Line data Source code
1 : /* Header file for gimple decl, type and expressions.
2 : Copyright (C) 2013-2026 Free Software Foundation, Inc.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify it under
7 : the terms of the GNU General Public License as published by the Free
8 : Software Foundation; either version 3, or (at your option) any later
9 : version.
10 :
11 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with GCC; see the file COPYING3. If not see
18 : <http://www.gnu.org/licenses/>. */
19 :
20 : #ifndef GCC_GIMPLE_EXPR_H
21 : #define GCC_GIMPLE_EXPR_H
22 :
23 : extern bool useless_type_conversion_p (tree, tree);
24 :
25 :
26 : extern void gimple_set_body (tree, gimple_seq);
27 : extern gimple_seq gimple_body (tree);
28 : extern bool gimple_has_body_p (tree);
29 : extern const char *gimple_decl_printable_name (tree, int);
30 : extern tree copy_var_decl (tree, tree, tree);
31 : extern tree create_tmp_var_name (const char *);
32 : extern tree create_tmp_var_raw (tree, const char * = NULL);
33 : extern tree create_tmp_var (tree, const char * = NULL);
34 : extern tree create_tmp_reg (tree, const char * = NULL);
35 : extern tree create_tmp_reg_fn (struct function *, tree, const char *);
36 :
37 :
38 : extern void extract_ops_from_tree (tree, enum tree_code *, tree *, tree *,
39 : tree *);
40 : extern void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *,
41 : tree *);
42 : extern bool is_gimple_lvalue (tree);
43 : extern bool is_gimple_condexpr_for_cond (tree);
44 : extern bool is_gimple_address (const_tree);
45 : extern bool is_gimple_invariant_address (const_tree);
46 : extern bool is_gimple_ip_invariant_address (const_tree);
47 : extern bool is_gimple_min_invariant (const_tree);
48 : extern bool is_gimple_ip_invariant (const_tree);
49 : extern bool is_gimple_reg (tree);
50 : extern bool is_gimple_val (tree);
51 : extern bool is_gimple_asm_val (tree);
52 : extern bool is_gimple_min_lval (tree);
53 : extern bool is_gimple_call_addr (tree);
54 : extern bool is_gimple_mem_ref_addr (tree);
55 : extern void flush_mark_addressable_queue (void);
56 : extern void mark_addressable (tree);
57 : extern bool is_gimple_reg_rhs (tree);
58 : extern tree canonicalize_cond_expr_cond (tree);
59 :
60 : /* Return true if a conversion from either type of TYPE1 and TYPE2
61 : to the other is not required. Otherwise return false. */
62 :
63 : inline bool
64 837977846 : types_compatible_p (tree type1, tree type2)
65 : {
66 837977846 : return (type1 == type2
67 837977846 : || (useless_type_conversion_p (type1, type2)
68 68177045 : && useless_type_conversion_p (type2, type1)));
69 : }
70 :
71 : /* Return true if TYPE is a suitable type for a scalar register variable. */
72 :
73 : inline bool
74 37811731113 : is_gimple_reg_type (tree type)
75 : {
76 37807361459 : return !AGGREGATE_TYPE_P (type);
77 : }
78 :
79 : /* Return true if T is a variable. */
80 :
81 : inline bool
82 37376995359 : is_gimple_variable (tree t)
83 : {
84 37376995359 : return (VAR_P (t)
85 : || TREE_CODE (t) == PARM_DECL
86 : || TREE_CODE (t) == RESULT_DECL
87 37376995359 : || TREE_CODE (t) == SSA_NAME);
88 : }
89 :
90 : /* Return true if T is a GIMPLE identifier (something with an address). */
91 :
92 : inline bool
93 3070742399 : is_gimple_id (tree t)
94 : {
95 3070742399 : return (is_gimple_variable (t)
96 1594600413 : || TREE_CODE (t) == FUNCTION_DECL
97 : || TREE_CODE (t) == LABEL_DECL
98 : || TREE_CODE (t) == CONST_DECL
99 : /* Allow string constants, since they are addressable. */
100 3070742399 : || TREE_CODE (t) == STRING_CST);
101 : }
102 :
103 : /* Return true if OP, an SSA name or a DECL is a virtual operand. */
104 :
105 : inline bool
106 78862810890 : virtual_operand_p (tree op)
107 : {
108 57660676442 : if (TREE_CODE (op) == SSA_NAME)
109 62504183306 : return SSA_NAME_IS_VIRTUAL_OPERAND (op);
110 :
111 16358627584 : if (VAR_P (op))
112 5089228387 : return VAR_DECL_IS_VIRTUAL_OPERAND (op);
113 :
114 : return false;
115 : }
116 :
117 : /* Return true if T is something whose address can be taken. */
118 :
119 : inline bool
120 549238760 : is_gimple_addressable (tree t)
121 : {
122 1131085984 : return (is_gimple_id (t) || handled_component_p (t)
123 32608464 : || TREE_CODE (t) == TARGET_MEM_REF
124 581802581 : || TREE_CODE (t) == MEM_REF);
125 : }
126 :
127 : /* Return true if T is a valid gimple constant. */
128 :
129 : inline bool
130 16703645630 : is_gimple_constant (const_tree t)
131 : {
132 16703645630 : switch (TREE_CODE (t))
133 : {
134 : case INTEGER_CST:
135 : case POLY_INT_CST:
136 : case REAL_CST:
137 : case FIXED_CST:
138 : case COMPLEX_CST:
139 : case VECTOR_CST:
140 : case STRING_CST:
141 : return true;
142 :
143 7741023360 : default:
144 7741023360 : return false;
145 : }
146 : }
147 :
148 : /* A wrapper around extract_ops_from_tree with 3 ops, for callers which
149 : expect to see only a maximum of two operands. */
150 :
151 : inline void
152 72805478 : extract_ops_from_tree (tree expr, enum tree_code *code, tree *op0,
153 : tree *op1)
154 : {
155 72805478 : tree op2;
156 72805478 : extract_ops_from_tree (expr, code, op0, op1, &op2);
157 72805478 : gcc_assert (op2 == NULL_TREE);
158 72805478 : }
159 :
160 : /* Given a valid GIMPLE_CALL function address return the FUNCTION_DECL
161 : associated with the callee if known. Otherwise return NULL_TREE. */
162 :
163 : inline tree
164 8751697322 : gimple_call_addr_fndecl (const_tree fn)
165 : {
166 8751697322 : if (fn && TREE_CODE (fn) == ADDR_EXPR)
167 : {
168 8383898313 : tree fndecl = TREE_OPERAND (fn, 0);
169 8383898313 : if (TREE_CODE (fndecl) == MEM_REF
170 6358 : && TREE_CODE (TREE_OPERAND (fndecl, 0)) == ADDR_EXPR
171 8383904671 : && integer_zerop (TREE_OPERAND (fndecl, 1)))
172 0 : fndecl = TREE_OPERAND (TREE_OPERAND (fndecl, 0), 0);
173 8383898313 : if (TREE_CODE (fndecl) == FUNCTION_DECL)
174 : return fndecl;
175 : }
176 : return NULL_TREE;
177 : }
178 :
179 : #endif /* GCC_GIMPLE_EXPR_H */
|
