Branch data Line data Source code
1 : : /* Language independent return value optimizations
2 : : Copyright (C) 2004-2025 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
7 : : it under the terms of the GNU General Public License as published by
8 : : the Free Software Foundation; either version 3, or (at your option)
9 : : any later version.
10 : :
11 : : GCC is distributed in the hope that it will be useful,
12 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : GNU General Public License 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 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "tree.h"
25 : : #include "gimple.h"
26 : : #include "tree-pass.h"
27 : : #include "ssa.h"
28 : : #include "tree-pretty-print.h"
29 : : #include "gimple-iterator.h"
30 : : #include "gimple-walk.h"
31 : : #include "internal-fn.h"
32 : :
33 : : /* This file implements return value optimizations for functions which
34 : : return aggregate types.
35 : :
36 : : Basically this pass searches the function for return statements which
37 : : return a local aggregate. When converted to RTL such statements will
38 : : generate a copy from the local aggregate to final return value destination
39 : : mandated by the target's ABI.
40 : :
41 : : That copy can often be avoided by directly constructing the return value
42 : : into the final destination mandated by the target's ABI.
43 : :
44 : : This is basically a generic equivalent to the C++ front-end's
45 : : Named Return Value optimization. */
46 : :
47 : : struct nrv_data_t
48 : : {
49 : : /* This is the temporary (a VAR_DECL) which appears in all of
50 : : this function's RETURN_EXPR statements. */
51 : : tree var;
52 : :
53 : : /* This is the function's RESULT_DECL. We will replace all occurrences
54 : : of VAR with RESULT_DECL when we apply this optimization. */
55 : : tree result;
56 : : int modified;
57 : : };
58 : :
59 : : static tree finalize_nrv_r (tree *, int *, void *);
60 : :
61 : : /* Callback for the tree walker.
62 : :
63 : : If TP refers to a RETURN_EXPR, then set the expression being returned
64 : : to nrv_data->result.
65 : :
66 : : If TP refers to nrv_data->var, then replace nrv_data->var with
67 : : nrv_data->result.
68 : :
69 : : If we reach a node where we know all the subtrees are uninteresting,
70 : : then set *WALK_SUBTREES to zero. */
71 : :
72 : : static tree
73 : 334014 : finalize_nrv_r (tree *tp, int *walk_subtrees, void *data)
74 : : {
75 : 334014 : struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
76 : 334014 : struct nrv_data_t *dp = (struct nrv_data_t *) wi->info;
77 : :
78 : : /* No need to walk into types. */
79 : 334014 : if (TYPE_P (*tp))
80 : 0 : *walk_subtrees = 0;
81 : :
82 : : /* Otherwise replace all occurrences of VAR with RESULT. */
83 : 334014 : else if (*tp == dp->var)
84 : : {
85 : 5481 : *tp = dp->result;
86 : 5481 : dp->modified = 1;
87 : : }
88 : :
89 : : /* Keep iterating. */
90 : 334014 : return NULL_TREE;
91 : : }
92 : :
93 : : /* Main entry point for return value optimizations.
94 : :
95 : : If this function always returns the same local variable, and that
96 : : local variable is an aggregate type, then replace the variable with
97 : : the function's DECL_RESULT.
98 : :
99 : : This is the equivalent of the C++ named return value optimization
100 : : applied to optimized trees in a language independent form. If we
101 : : ever encounter languages which prevent this kind of optimization,
102 : : then we could either have the languages register the optimization or
103 : : we could change the gating function to check the current language. */
104 : :
105 : : namespace {
106 : :
107 : : const pass_data pass_data_nrv =
108 : : {
109 : : GIMPLE_PASS, /* type */
110 : : "nrv", /* name */
111 : : OPTGROUP_NONE, /* optinfo_flags */
112 : : TV_TREE_NRV, /* tv_id */
113 : : ( PROP_ssa | PROP_cfg ), /* properties_required */
114 : : 0, /* properties_provided */
115 : : 0, /* properties_destroyed */
116 : : 0, /* todo_flags_start */
117 : : 0, /* todo_flags_finish */
118 : : };
119 : :
120 : : class pass_nrv : public gimple_opt_pass
121 : : {
122 : : public:
123 : 285081 : pass_nrv (gcc::context *ctxt)
124 : 570162 : : gimple_opt_pass (pass_data_nrv, ctxt)
125 : : {}
126 : :
127 : : /* opt_pass methods: */
128 : 1450636 : bool gate (function *) final override { return optimize > 0; }
129 : :
130 : : unsigned int execute (function *) final override;
131 : :
132 : : }; // class pass_nrv
133 : :
134 : : unsigned int
135 : 1024131 : pass_nrv::execute (function *fun)
136 : : {
137 : 1024131 : tree result = DECL_RESULT (current_function_decl);
138 : 1024131 : tree result_type = TREE_TYPE (result);
139 : 1024131 : tree found = NULL;
140 : 1024131 : basic_block bb;
141 : 1024131 : gimple_stmt_iterator gsi;
142 : 1024131 : struct nrv_data_t data;
143 : :
144 : : /* If this function does not return an aggregate type in memory, then
145 : : there is nothing to do. */
146 : 1024131 : if (!aggregate_value_p (result, current_function_decl))
147 : : return 0;
148 : :
149 : : /* If a GIMPLE type is returned in memory, finalize_nrv_r might create
150 : : non-GIMPLE. */
151 : 53446 : if (is_gimple_reg_type (result_type))
152 : : return 0;
153 : :
154 : : /* If the front end already did something like this, don't do it here. */
155 : 43341 : if (DECL_NAME (result))
156 : : return 0;
157 : :
158 : : /* If the result has its address taken then it might be modified
159 : : by means not detected in the following loop. Bail out in this
160 : : case. */
161 : 42592 : if (TREE_ADDRESSABLE (result))
162 : : return 0;
163 : :
164 : : /* Look through each block for assignments to the RESULT_DECL. */
165 : 526584 : FOR_EACH_BB_FN (bb, fun)
166 : : {
167 : 3438325 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
168 : : {
169 : 2431225 : gimple *stmt = gsi_stmt (gsi);
170 : :
171 : 2431225 : if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
172 : : {
173 : : /* We cannot perform NRV optimizations in a function with an
174 : : aggregate return value if there is a return that does not
175 : : return RESULT_DECL. We used to assert this scenario doesn't
176 : : happen: the gimplifier has changed all non-empty RETURN_EXPRs
177 : : to return the RESULT_DECL. However, per PR119835 we may run
178 : : into this scenario for offloading compilation, and therefore
179 : : gracefully bail out. */
180 : 4592 : if (tree ret_val = gimple_return_retval (return_stmt))
181 : : {
182 : 4592 : if (ret_val != result)
183 : : return 0;
184 : : }
185 : : }
186 : 2426633 : else if (gimple_has_lhs (stmt)
187 : 1152017 : && gimple_get_lhs (stmt) == result)
188 : : {
189 : 12420 : tree rhs;
190 : :
191 : 12420 : if (!gimple_assign_copy_p (stmt))
192 : : return 0;
193 : :
194 : 10432 : rhs = gimple_assign_rhs1 (stmt);
195 : :
196 : : /* Now verify that this return statement uses the same value
197 : : as any previously encountered return statement. */
198 : 10432 : if (found != NULL)
199 : : {
200 : : /* If we found a return statement using a different variable
201 : : than previous return statements, then we cannot perform
202 : : NRV optimizations. */
203 : 728 : if (found != rhs)
204 : : return 0;
205 : : }
206 : : else
207 : : found = rhs;
208 : :
209 : : /* The returned value must be a local automatic variable of the
210 : : same type and alignment as the function's result. */
211 : 9705 : if (!VAR_P (found)
212 : 9082 : || TREE_THIS_VOLATILE (found)
213 : 9080 : || !auto_var_in_fn_p (found, current_function_decl)
214 : 7826 : || TREE_ADDRESSABLE (found)
215 : 7461 : || DECL_ALIGN (found) > DECL_ALIGN (result)
216 : 15560 : || !useless_type_conversion_p (result_type,
217 : 5855 : TREE_TYPE (found)))
218 : 3850 : return 0;
219 : : }
220 : 5017469 : else if (gimple_has_lhs (stmt))
221 : : {
222 : 1051706 : tree addr = get_base_address (gimple_get_lhs (stmt));
223 : : /* If there's any MODIFY of component of RESULT,
224 : : then bail out. */
225 : 1051706 : if (addr && addr == result)
226 : : return 0;
227 : : }
228 : : }
229 : : }
230 : :
231 : 4510 : if (!found)
232 : : return 0;
233 : :
234 : : /* If dumping details, then note once and only the NRV replacement. */
235 : 4399 : if (dump_file && (dump_flags & TDF_DETAILS))
236 : : {
237 : 0 : fprintf (dump_file, "NRV Replaced: ");
238 : 0 : print_generic_expr (dump_file, found, dump_flags);
239 : 0 : fprintf (dump_file, " with: ");
240 : 0 : print_generic_expr (dump_file, result, dump_flags);
241 : 0 : fprintf (dump_file, "\n");
242 : : }
243 : :
244 : 4399 : TREE_ADDRESSABLE (result) |= TREE_ADDRESSABLE (found);
245 : :
246 : : /* Now walk through the function changing all references to VAR to be
247 : : RESULT. */
248 : 4399 : data.var = found;
249 : 4399 : data.result = result;
250 : 27981 : FOR_EACH_BB_FN (bb, fun)
251 : : {
252 : 144055 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
253 : : {
254 : 96891 : gimple *stmt = gsi_stmt (gsi);
255 : : /* If this is a copy from VAR to RESULT, remove it. */
256 : 96891 : if (gimple_assign_copy_p (stmt)
257 : 21322 : && gimple_assign_lhs (stmt) == result
258 : 101290 : && gimple_assign_rhs1 (stmt) == found)
259 : : {
260 : 4399 : unlink_stmt_vdef (stmt);
261 : 4399 : gsi_remove (&gsi, true);
262 : 4399 : release_defs (stmt);
263 : : }
264 : : else
265 : : {
266 : 92492 : struct walk_stmt_info wi;
267 : 92492 : memset (&wi, 0, sizeof (wi));
268 : 92492 : wi.info = &data;
269 : 92492 : data.modified = 0;
270 : 92492 : walk_gimple_op (stmt, finalize_nrv_r, &wi);
271 : 92492 : if (data.modified)
272 : : {
273 : : /* If this is a CLOBBER of VAR, remove it. */
274 : 5481 : if (gimple_clobber_p (stmt))
275 : : {
276 : 629 : unlink_stmt_vdef (stmt);
277 : 629 : gsi_remove (&gsi, true);
278 : 629 : release_defs (stmt);
279 : 629 : continue;
280 : : }
281 : 4852 : update_stmt (stmt);
282 : : }
283 : 91863 : gsi_next (&gsi);
284 : : }
285 : : }
286 : : }
287 : :
288 : 4399 : SET_DECL_VALUE_EXPR (found, result);
289 : 4399 : DECL_HAS_VALUE_EXPR_P (found) = 1;
290 : :
291 : 4399 : return 0;
292 : : }
293 : :
294 : : } // anon namespace
295 : :
296 : : gimple_opt_pass *
297 : 285081 : make_pass_nrv (gcc::context *ctxt)
298 : : {
299 : 285081 : return new pass_nrv (ctxt);
300 : : }
301 : :
302 : : /* Determine (pessimistically) whether DEST is available for NRV
303 : : optimization, where DEST is expected to be the LHS of a modify
304 : : expression where the RHS is a function returning an aggregate.
305 : :
306 : : DEST is available if it is not clobbered or used by the call. */
307 : :
308 : : static bool
309 : 7281 : dest_safe_for_nrv_p (gcall *call)
310 : : {
311 : 7281 : tree dest = gimple_call_lhs (call);
312 : :
313 : 7281 : dest = get_base_address (dest);
314 : 7281 : if (! dest)
315 : : return false;
316 : :
317 : 7281 : if (TREE_CODE (dest) == SSA_NAME)
318 : : return true;
319 : :
320 : 3454 : if (call_may_clobber_ref_p (call, dest, false)
321 : 3454 : || ref_maybe_used_by_stmt_p (call, dest, false))
322 : 704 : return false;
323 : :
324 : : return true;
325 : : }
326 : :
327 : : /* Walk through the function looking for GIMPLE_ASSIGNs with calls that
328 : : return in memory on the RHS. For each of these, determine whether it is
329 : : safe to pass the address of the LHS as the return slot, and mark the
330 : : call appropriately if so.
331 : :
332 : : The NRV shares the return slot with a local variable in the callee; this
333 : : optimization shares the return slot with the target of the call within
334 : : the caller. If the NRV is performed (which we can't know in general),
335 : : this optimization is safe if the address of the target has not
336 : : escaped prior to the call. If it has, modifications to the local
337 : : variable will produce visible changes elsewhere, as in PR c++/19317. */
338 : :
339 : : namespace {
340 : :
341 : : const pass_data pass_data_return_slot =
342 : : {
343 : : GIMPLE_PASS, /* type */
344 : : "retslot", /* name */
345 : : OPTGROUP_NONE, /* optinfo_flags */
346 : : TV_NONE, /* tv_id */
347 : : PROP_ssa, /* properties_required */
348 : : 0, /* properties_provided */
349 : : 0, /* properties_destroyed */
350 : : 0, /* todo_flags_start */
351 : : 0, /* todo_flags_finish */
352 : : };
353 : :
354 : : class pass_return_slot : public gimple_opt_pass
355 : : {
356 : : public:
357 : 285081 : pass_return_slot (gcc::context *ctxt)
358 : 570162 : : gimple_opt_pass (pass_data_return_slot, ctxt)
359 : : {}
360 : :
361 : : /* opt_pass methods: */
362 : : unsigned int execute (function *) final override;
363 : :
364 : : }; // class pass_return_slot
365 : :
366 : : unsigned int
367 : 1021522 : pass_return_slot::execute (function *fun)
368 : : {
369 : 1021522 : basic_block bb;
370 : :
371 : 12466732 : FOR_EACH_BB_FN (bb, fun)
372 : : {
373 : 11445210 : gimple_stmt_iterator gsi;
374 : 107497522 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
375 : : {
376 : 84607102 : gcall *stmt;
377 : 84607102 : bool slot_opt_p;
378 : :
379 : 84607102 : stmt = dyn_cast <gcall *> (gsi_stmt (gsi));
380 : 5704633 : if (stmt
381 : 5704633 : && gimple_call_lhs (stmt)
382 : 2047211 : && !gimple_call_return_slot_opt_p (stmt)
383 : : /* Ignore internal functions, those are expanded specially
384 : : and aggregate_value_p on their result might result in
385 : : undesirable warnings with some backends. */
386 : 1857935 : && !gimple_call_internal_p (stmt)
387 : 1786576 : && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
388 : 1786576 : gimple_call_fndecl (stmt)))
389 : : {
390 : : /* Check if the location being assigned to is
391 : : clobbered by the call. */
392 : 7281 : slot_opt_p = dest_safe_for_nrv_p (stmt);
393 : 84614383 : gimple_call_set_return_slot_opt (stmt, slot_opt_p);
394 : : }
395 : : }
396 : : }
397 : 1021522 : return 0;
398 : : }
399 : :
400 : : } // anon namespace
401 : :
402 : : gimple_opt_pass *
403 : 285081 : make_pass_return_slot (gcc::context *ctxt)
404 : : {
405 : 285081 : return new pass_return_slot (ctxt);
406 : : }
|
