1/* Gimple folding definitions.
2
3 Copyright (C) 2011-2023 Free Software Foundation, Inc.
4 Contributed by Richard Guenther <rguenther@suse.de>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#ifndef GCC_GIMPLE_FOLD_H
23#define GCC_GIMPLE_FOLD_H
24
25extern tree create_tmp_reg_or_ssa_name (tree, gimple *stmt = NULL);
26extern tree canonicalize_constructor_val (tree, tree);
27extern tree get_symbol_constant_value (tree);
28struct c_strlen_data;
29extern bool get_range_strlen (tree, c_strlen_data *, unsigned eltsize);
30extern void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree);
31extern bool update_gimple_call (gimple_stmt_iterator *, tree, int, ...);
32extern bool fold_stmt (gimple_stmt_iterator *);
33extern bool fold_stmt (gimple_stmt_iterator *, tree (*) (tree));
34extern bool fold_stmt_inplace (gimple_stmt_iterator *);
35extern tree maybe_fold_and_comparisons (tree, enum tree_code, tree, tree,
36 enum tree_code, tree, tree,
37 basic_block = nullptr);
38extern tree maybe_fold_or_comparisons (tree, enum tree_code, tree, tree,
39 enum tree_code, tree, tree,
40 basic_block = nullptr);
41extern bool optimize_atomic_compare_exchange_p (gimple *);
42extern void fold_builtin_atomic_compare_exchange (gimple_stmt_iterator *);
43extern tree no_follow_ssa_edges (tree);
44extern tree follow_single_use_edges (tree);
45extern tree follow_all_ssa_edges (tree);
46extern tree gimple_fold_stmt_to_constant_1 (gimple *, tree (*) (tree),
47 tree (*) (tree) = no_follow_ssa_edges);
48extern tree gimple_fold_stmt_to_constant (gimple *, tree (*) (tree));
49extern tree fold_ctor_reference (tree, tree, const poly_uint64&,
50 const poly_uint64&, tree,
51 unsigned HOST_WIDE_INT * = NULL);
52extern tree fold_const_aggregate_ref_1 (tree, tree (*) (tree));
53extern tree fold_const_aggregate_ref (tree);
54extern tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree,
55 bool *can_refer = NULL);
56extern tree gimple_get_virt_method_for_vtable (HOST_WIDE_INT, tree,
57 unsigned HOST_WIDE_INT,
58 bool *can_refer = NULL);
59extern tree gimple_fold_indirect_ref (tree);
60extern bool gimple_fold_builtin_sprintf (gimple_stmt_iterator *);
61extern bool gimple_fold_builtin_snprintf (gimple_stmt_iterator *);
62extern bool arith_code_with_undefined_signed_overflow (tree_code);
63extern void rewrite_to_defined_overflow (gimple_stmt_iterator *);
64extern gimple_seq rewrite_to_defined_overflow (gimple *);
65extern void replace_call_with_value (gimple_stmt_iterator *, tree);
66extern tree tree_vec_extract (gimple_stmt_iterator *, tree, tree, tree, tree);
67extern void gsi_replace_with_seq_vops (gimple_stmt_iterator *, gimple_seq);
68
69/* gimple_build, functionally matching fold_buildN, outputs stmts
70 int the provided sequence, matching and simplifying them on-the-fly.
71 Supposed to replace force_gimple_operand (fold_buildN (...), ...). */
72extern tree gimple_build (gimple_stmt_iterator *, bool,
73 enum gsi_iterator_update,
74 location_t, enum tree_code, tree, tree);
75extern tree gimple_build (gimple_stmt_iterator *, bool,
76 enum gsi_iterator_update,
77 location_t, enum tree_code, tree, tree, tree);
78extern tree gimple_build (gimple_stmt_iterator *, bool,
79 enum gsi_iterator_update,
80 location_t, enum tree_code, tree, tree, tree, tree);
81template<class ...Args>
82inline tree
83gimple_build (gimple_seq *seq, location_t loc,
84 enum tree_code code, tree type, Args ...ops)
85{
86 static_assert (sizeof...(ops) > 0 && sizeof...(ops) <= 3,
87 "Number of operands must be from one to three");
88 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
89 return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
90 loc, code, type, ops...);
91}
92template<class ...Args>
93inline tree
94gimple_build (gimple_seq *seq, enum tree_code code, tree type, Args ...ops)
95{
96 static_assert (sizeof...(ops) > 0 && sizeof...(ops) <= 3,
97 "Number of operands must be from one to three");
98 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
99 return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
100 UNKNOWN_LOCATION, code, type, ops...);
101}
102
103extern tree gimple_build (gimple_stmt_iterator *, bool,
104 enum gsi_iterator_update,
105 location_t, combined_fn, tree);
106extern tree gimple_build (gimple_stmt_iterator *, bool,
107 enum gsi_iterator_update,
108 location_t, combined_fn, tree, tree);
109extern tree gimple_build (gimple_stmt_iterator *, bool,
110 enum gsi_iterator_update,
111 location_t, combined_fn, tree, tree, tree);
112extern tree gimple_build (gimple_stmt_iterator *, bool,
113 enum gsi_iterator_update,
114 location_t, combined_fn, tree, tree, tree, tree);
115template<class ...Args>
116inline tree
117gimple_build (gimple_seq *seq, location_t loc,
118 combined_fn fn, tree type, Args ...args)
119{
120 static_assert (sizeof...(args) < 4,
121 "Number of arguments must be less than four");
122 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
123 return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
124 loc, fn, type, args...);
125}
126template<class ...Args>
127inline tree
128gimple_build (gimple_seq *seq, combined_fn fn, tree type, Args ...args)
129{
130 static_assert (sizeof...(args) < 4,
131 "Number of arguments must be less than four");
132 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
133 return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
134 UNKNOWN_LOCATION, fn, type, args...);
135}
136
137extern tree gimple_build (gimple_stmt_iterator *, bool,
138 enum gsi_iterator_update,
139 location_t, code_helper, tree, tree);
140extern tree gimple_build (gimple_stmt_iterator *, bool,
141 enum gsi_iterator_update,
142 location_t, code_helper, tree, tree, tree);
143extern tree gimple_build (gimple_stmt_iterator *, bool,
144 enum gsi_iterator_update,
145 location_t, code_helper, tree, tree, tree, tree);
146
147template<class ...Args>
148inline tree
149gimple_build (gimple_seq *seq, location_t loc,
150 code_helper code, tree type, Args ...ops)
151{
152 static_assert (sizeof...(ops) < 4,
153 "Number of operands must be less than four");
154 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
155 return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
156 loc, code, type, ops...);
157}
158template<class ...Args>
159inline tree
160gimple_build (gimple_seq *seq,
161 code_helper code, tree type, Args ...ops)
162{
163 static_assert (sizeof...(ops) < 4,
164 "Number of operands must be less than four");
165 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
166 return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
167 UNKNOWN_LOCATION, code, type, ops...);
168}
169
170extern tree gimple_convert (gimple_stmt_iterator *, bool,
171 enum gsi_iterator_update,
172 location_t, tree, tree);
173inline tree
174gimple_convert (gimple_seq *seq, location_t loc, tree type, tree op)
175{
176 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
177 return gimple_convert (&gsi, false, GSI_CONTINUE_LINKING, loc, type, op);
178}
179inline tree
180gimple_convert (gimple_seq *seq, tree type, tree op)
181{
182 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
183 return gimple_convert (&gsi, false, GSI_CONTINUE_LINKING,
184 UNKNOWN_LOCATION, type, op);
185}
186
187extern tree gimple_convert_to_ptrofftype (gimple_stmt_iterator *, bool,
188 enum gsi_iterator_update,
189 location_t, tree);
190inline tree
191gimple_convert_to_ptrofftype (gimple_seq *seq, location_t loc, tree op)
192{
193 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
194 return gimple_convert_to_ptrofftype (&gsi, false, GSI_CONTINUE_LINKING,
195 loc, op);
196}
197inline tree
198gimple_convert_to_ptrofftype (gimple_seq *seq, tree op)
199{
200 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
201 return gimple_convert_to_ptrofftype (&gsi, false, GSI_CONTINUE_LINKING,
202 UNKNOWN_LOCATION, op);
203}
204
205extern tree gimple_build_vector_from_val (gimple_stmt_iterator *, bool,
206 enum gsi_iterator_update,
207 location_t, tree, tree);
208inline tree
209gimple_build_vector_from_val (gimple_seq *seq, location_t loc,
210 tree type, tree op)
211{
212 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
213 return gimple_build_vector_from_val (&gsi, false, GSI_CONTINUE_LINKING,
214 loc, type, op);
215}
216inline tree
217gimple_build_vector_from_val (gimple_seq *seq, tree type, tree op)
218{
219 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
220 return gimple_build_vector_from_val (&gsi, false, GSI_CONTINUE_LINKING,
221 UNKNOWN_LOCATION, type, op);
222}
223
224class tree_vector_builder;
225extern tree gimple_build_vector (gimple_stmt_iterator *, bool,
226 enum gsi_iterator_update,
227 location_t, tree_vector_builder *);
228inline tree
229gimple_build_vector (gimple_seq *seq, location_t loc,
230 tree_vector_builder *builder)
231{
232 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
233 return gimple_build_vector (&gsi, false, GSI_CONTINUE_LINKING,
234 loc, builder);
235}
236inline tree
237gimple_build_vector (gimple_seq *seq, tree_vector_builder *builder)
238{
239 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
240 return gimple_build_vector (&gsi, false, GSI_CONTINUE_LINKING,
241 UNKNOWN_LOCATION, builder);
242}
243
244extern tree gimple_build_round_up (gimple_stmt_iterator *, bool,
245 enum gsi_iterator_update,
246 location_t, tree, tree,
247 unsigned HOST_WIDE_INT);
248inline tree
249gimple_build_round_up (gimple_seq *seq, location_t loc,
250 tree type, tree old_size, unsigned HOST_WIDE_INT align)
251{
252 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
253 return gimple_build_round_up (&gsi, false, GSI_CONTINUE_LINKING,
254 loc, type, old_size, align);
255}
256inline tree
257gimple_build_round_up (gimple_seq *seq, tree type, tree old_size,
258 unsigned HOST_WIDE_INT align)
259{
260 gimple_stmt_iterator gsi = gsi_last (seq&: *seq);
261 return gimple_build_round_up (&gsi, false, GSI_CONTINUE_LINKING,
262 UNKNOWN_LOCATION, type, old_size, align);
263}
264
265extern bool gimple_stmt_nonnegative_warnv_p (gimple *, bool *, int = 0);
266extern bool gimple_stmt_integer_valued_real_p (gimple *, int = 0);
267
268/* In gimple-match.cc. */
269extern tree gimple_simplify (enum tree_code, tree, tree,
270 gimple_seq *, tree (*)(tree));
271extern tree gimple_simplify (enum tree_code, tree, tree, tree,
272 gimple_seq *, tree (*)(tree));
273extern tree gimple_simplify (enum tree_code, tree, tree, tree, tree,
274 gimple_seq *, tree (*)(tree));
275extern tree gimple_simplify (combined_fn, tree, tree,
276 gimple_seq *, tree (*)(tree));
277extern tree gimple_simplify (combined_fn, tree, tree, tree,
278 gimple_seq *, tree (*)(tree));
279extern tree gimple_simplify (combined_fn, tree, tree, tree, tree,
280 gimple_seq *, tree (*)(tree));
281
282#endif /* GCC_GIMPLE_FOLD_H */
283

source code of gcc/gimple-fold.h