1/* Tree lowering to gimple for middle end use only.
2 This converts the GENERIC functions-as-trees tree representation into
3 the GIMPLE form.
4 Copyright (C) 2013-2023 Free Software Foundation, Inc.
5 Major work done by Sebastian Pop <s.pop@laposte.net>,
6 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7
8This file is part of GCC.
9
10GCC is free software; you can redistribute it and/or modify it under
11the terms of the GNU General Public License as published by the Free
12Software Foundation; either version 3, or (at your option) any later
13version.
14
15GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16WARRANTY; without even the implied warranty of MERCHANTABILITY or
17FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18for more details.
19
20You should have received a copy of the GNU General Public License
21along with GCC; see the file COPYING3. If not see
22<http://www.gnu.org/licenses/>. */
23
24#include "config.h"
25#include "system.h"
26#include "coretypes.h"
27#include "backend.h"
28#include "tree.h"
29#include "gimple.h"
30#include "ssa.h"
31#include "stmt.h"
32#include "stor-layout.h"
33#include "tree-eh.h"
34#include "gimple-iterator.h"
35#include "gimplify.h"
36#include "gimplify-me.h"
37
38
39/* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
40 the predicate that will hold for the result. If VAR is not NULL, make the
41 base variable of the final destination be VAR if suitable. */
42
43tree
44force_gimple_operand_1 (tree expr, gimple_seq *stmts,
45 gimple_predicate gimple_test_f, tree var)
46{
47 enum gimplify_status ret;
48 location_t saved_location;
49
50 *stmts = NULL;
51
52 /* gimple_test_f might be more strict than is_gimple_val, make
53 sure we pass both. Just checking gimple_test_f doesn't work
54 because most gimple predicates do not work recursively. */
55 if (is_gimple_val (expr)
56 && (*gimple_test_f) (expr))
57 return expr;
58
59 push_gimplify_context (in_ssa: gimple_in_ssa_p (cfun), rhs_cond_ok: true);
60 saved_location = input_location;
61 input_location = UNKNOWN_LOCATION;
62
63 if (var)
64 {
65 if (gimple_in_ssa_p (cfun) && is_gimple_reg (var))
66 var = make_ssa_name (var);
67 expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
68 }
69
70 if (TREE_CODE (expr) != MODIFY_EXPR
71 && TREE_TYPE (expr) == void_type_node)
72 {
73 gimplify_and_add (expr, stmts);
74 expr = NULL_TREE;
75 }
76 else
77 {
78 ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
79 gcc_assert (ret != GS_ERROR);
80 }
81
82 input_location = saved_location;
83 pop_gimplify_context (NULL);
84
85 return expr;
86}
87
88/* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
89 force the result to be either ssa_name or an invariant, otherwise
90 just force it to be a rhs expression. If VAR is not NULL, make the
91 base variable of the final destination be VAR if suitable. */
92
93tree
94force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
95{
96 return force_gimple_operand_1 (expr, stmts,
97 gimple_test_f: simple ? is_gimple_val : is_gimple_reg_rhs,
98 var);
99}
100
101/* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
102 and VAR. If some statements are produced, emits them at GSI.
103 If BEFORE is true. the statements are appended before GSI, otherwise
104 they are appended after it. M specifies the way GSI moves after
105 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
106
107tree
108force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
109 gimple_predicate gimple_test_f,
110 tree var, bool before,
111 enum gsi_iterator_update m)
112{
113 gimple_seq stmts;
114
115 expr = force_gimple_operand_1 (expr, stmts: &stmts, gimple_test_f, var);
116
117 if (!gimple_seq_empty_p (s: stmts))
118 {
119 if (before)
120 gsi_insert_seq_before (gsi, stmts, m);
121 else
122 gsi_insert_seq_after (gsi, stmts, m);
123 }
124
125 return expr;
126}
127
128/* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
129 If SIMPLE is true, force the result to be either ssa_name or an invariant,
130 otherwise just force it to be a rhs expression. If some statements are
131 produced, emits them at GSI. If BEFORE is true, the statements are
132 appended before GSI, otherwise they are appended after it. M specifies
133 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
134 are the usual values). */
135
136tree
137force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
138 bool simple_p, tree var, bool before,
139 enum gsi_iterator_update m)
140{
141 return force_gimple_operand_gsi_1 (gsi, expr,
142 gimple_test_f: simple_p
143 ? is_gimple_val : is_gimple_reg_rhs,
144 var, before, m);
145}
146
147/* Some transformations like inlining may invalidate the GIMPLE form
148 for operands. This function traverses all the operands in STMT and
149 gimplifies anything that is not a valid gimple operand. Any new
150 GIMPLE statements are inserted before *GSI_P. */
151
152void
153gimple_regimplify_operands (gimple *stmt, gimple_stmt_iterator *gsi_p)
154{
155 size_t i, num_ops;
156 tree lhs;
157 gimple_seq pre = NULL;
158 gimple *post_stmt = NULL;
159
160 push_gimplify_context (in_ssa: gimple_in_ssa_p (cfun));
161
162 switch (gimple_code (g: stmt))
163 {
164 case GIMPLE_COND:
165 {
166 gcond *cond_stmt = as_a <gcond *> (p: stmt);
167 gimplify_expr (gimple_cond_lhs_ptr (gs: cond_stmt), &pre, NULL,
168 is_gimple_val, fb_rvalue);
169 gimplify_expr (gimple_cond_rhs_ptr (gs: cond_stmt), &pre, NULL,
170 is_gimple_val, fb_rvalue);
171 }
172 break;
173 case GIMPLE_SWITCH:
174 gimplify_expr (gimple_switch_index_ptr (gs: as_a <gswitch *> (p: stmt)),
175 &pre, NULL, is_gimple_val, fb_rvalue);
176 break;
177 case GIMPLE_OMP_ATOMIC_LOAD:
178 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (
179 load_stmt: as_a <gomp_atomic_load *> (p: stmt)),
180 &pre, NULL, is_gimple_val, fb_rvalue);
181 break;
182 case GIMPLE_ASM:
183 {
184 gasm *asm_stmt = as_a <gasm *> (p: stmt);
185 size_t i, noutputs = gimple_asm_noutputs (asm_stmt);
186 const char *constraint, **oconstraints;
187 bool allows_mem, allows_reg, is_inout;
188
189 oconstraints
190 = (const char **) alloca ((noutputs) * sizeof (const char *));
191 for (i = 0; i < noutputs; i++)
192 {
193 tree op = gimple_asm_output_op (asm_stmt, index: i);
194 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
195 oconstraints[i] = constraint;
196 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
197 &allows_reg, &is_inout);
198 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
199 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
200 fb_lvalue | fb_mayfail);
201 }
202 for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++)
203 {
204 tree op = gimple_asm_input_op (asm_stmt, index: i);
205 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
206 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
207 oconstraints, &allows_mem, &allows_reg);
208 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
209 allows_reg = 0;
210 if (!allows_reg && allows_mem)
211 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
212 is_gimple_lvalue, fb_lvalue | fb_mayfail);
213 else
214 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
215 is_gimple_asm_val, fb_rvalue);
216 }
217 }
218 break;
219 default:
220 /* NOTE: We start gimplifying operands from last to first to
221 make sure that side-effects on the RHS of calls, assignments
222 and ASMs are executed before the LHS. The ordering is not
223 important for other statements. */
224 num_ops = gimple_num_ops (gs: stmt);
225 for (i = num_ops; i > 0; i--)
226 {
227 tree op = gimple_op (gs: stmt, i: i - 1);
228 if (op == NULL_TREE)
229 continue;
230 if (i == 1 && (is_gimple_call (gs: stmt) || is_gimple_assign (gs: stmt)))
231 gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
232 else if (i == 2
233 && gimple_assign_single_p (gs: stmt)
234 && num_ops == 2)
235 gimplify_expr (&op, &pre, NULL,
236 rhs_predicate_for (gimple_assign_lhs (gs: stmt)),
237 fb_rvalue);
238 else if (i == 2 && is_gimple_call (gs: stmt))
239 {
240 if (TREE_CODE (op) == FUNCTION_DECL)
241 continue;
242 gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
243 }
244 else
245 gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
246 gimple_set_op (gs: stmt, i: i - 1, op);
247 }
248
249 lhs = gimple_get_lhs (stmt);
250 /* If the LHS changed it in a way that requires a simple RHS,
251 create temporary. */
252 if (lhs && !is_gimple_reg (lhs))
253 {
254 bool need_temp = false;
255
256 if (gimple_assign_single_p (gs: stmt)
257 && num_ops == 2)
258 gimplify_expr (gimple_assign_rhs1_ptr (gs: stmt), &pre, NULL,
259 rhs_predicate_for (gimple_assign_lhs (gs: stmt)),
260 fb_rvalue);
261 else if (is_gimple_reg (lhs))
262 {
263 if (is_gimple_reg_type (TREE_TYPE (lhs)))
264 {
265 if (is_gimple_call (gs: stmt))
266 {
267 i = gimple_call_flags (stmt);
268 if ((i & ECF_LOOPING_CONST_OR_PURE)
269 || !(i & (ECF_CONST | ECF_PURE)))
270 need_temp = true;
271 }
272 if (stmt_can_throw_internal (cfun, stmt))
273 need_temp = true;
274 }
275 }
276 else
277 {
278 if (is_gimple_reg_type (TREE_TYPE (lhs)))
279 need_temp = true;
280 else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
281 {
282 if (is_gimple_call (gs: stmt))
283 {
284 tree fndecl = gimple_call_fndecl (gs: stmt);
285
286 if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
287 && !(fndecl && DECL_RESULT (fndecl)
288 && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
289 need_temp = true;
290 }
291 else
292 need_temp = true;
293 }
294 }
295 if (need_temp)
296 {
297 tree temp = create_tmp_reg (TREE_TYPE (lhs));
298 if (gimple_in_ssa_p (cfun)
299 && is_gimple_reg_type (TREE_TYPE (lhs)))
300 temp = make_ssa_name (var: temp);
301 gimple_set_lhs (stmt, temp);
302 post_stmt = gimple_build_assign (lhs, temp);
303 }
304 }
305 break;
306 }
307
308 if (!gimple_seq_empty_p (s: pre))
309 gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
310 if (post_stmt)
311 gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
312
313 pop_gimplify_context (NULL);
314
315 update_stmt (s: stmt);
316}
317
318
319

source code of gcc/gimplify-me.cc