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 831492081 : types_compatible_p (tree type1, tree type2)
65 : {
66 831492081 : return (type1 == type2
67 831492081 : || (useless_type_conversion_p (type1, type2)
68 68364303 : && 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 37713760701 : is_gimple_reg_type (tree type)
75 : {
76 37709149620 : return !AGGREGATE_TYPE_P (type);
77 : }
78 :
79 : /* Return true if T is a variable. */
80 :
81 : inline bool
82 37303001834 : is_gimple_variable (tree t)
83 : {
84 37303001834 : return (VAR_P (t)
85 : || TREE_CODE (t) == PARM_DECL
86 : || TREE_CODE (t) == RESULT_DECL
87 37303001834 : || 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 3062028317 : is_gimple_id (tree t)
94 : {
95 3062028317 : return (is_gimple_variable (t)
96 1593058455 : || 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 3062028317 : || 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 78768987851 : virtual_operand_p (tree op)
107 : {
108 57582283130 : if (TREE_CODE (op) == SSA_NAME)
109 62463183747 : return SSA_NAME_IS_VIRTUAL_OPERAND (op);
110 :
111 16305804104 : if (VAR_P (op))
112 5064236215 : 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 545802150 : is_gimple_addressable (tree t)
121 : {
122 1124394394 : return (is_gimple_id (t) || handled_component_p (t)
123 32790094 : || TREE_CODE (t) == TARGET_MEM_REF
124 578547601 : || TREE_CODE (t) == MEM_REF);
125 : }
126 :
127 : /* Return true if T is a valid gimple constant. */
128 :
129 : inline bool
130 16674214035 : is_gimple_constant (const_tree t)
131 : {
132 16674214035 : 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 7737598368 : default:
144 7737598368 : 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 72639673 : extract_ops_from_tree (tree expr, enum tree_code *code, tree *op0,
153 : tree *op1)
154 : {
155 72639673 : tree op2;
156 72639673 : extract_ops_from_tree (expr, code, op0, op1, &op2);
157 72639673 : gcc_assert (op2 == NULL_TREE);
158 72639673 : }
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 8752116201 : gimple_call_addr_fndecl (const_tree fn)
165 : {
166 8752116201 : if (fn && TREE_CODE (fn) == ADDR_EXPR)
167 : {
168 8380554852 : tree fndecl = TREE_OPERAND (fn, 0);
169 8380554852 : if (TREE_CODE (fndecl) == MEM_REF
170 6358 : && TREE_CODE (TREE_OPERAND (fndecl, 0)) == ADDR_EXPR
171 8380561210 : && integer_zerop (TREE_OPERAND (fndecl, 1)))
172 0 : fndecl = TREE_OPERAND (TREE_OPERAND (fndecl, 0), 0);
173 8380554852 : if (TREE_CODE (fndecl) == FUNCTION_DECL)
174 : return fndecl;
175 : }
176 : return NULL_TREE;
177 : }
178 :
179 : #endif /* GCC_GIMPLE_EXPR_H */
|
