1 /* Language independent return value optimizations
2 Copyright (C) 2004-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
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)
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.
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/>. */
22 #include "coretypes.h"
26 #include "basic-block.h"
27 #include "tree-pretty-print.h"
28 #include "tree-flow.h"
29 #include "tree-pass.h"
30 #include "langhooks.h"
31 #include "flags.h" /* For "optimize" in gate_pass_return_slot.
32 FIXME: That should be up to the pass manager,
33 but pass_nrv is not in pass_all_optimizations. */
35 /* This file implements return value optimizations for functions which
36 return aggregate types.
38 Basically this pass searches the function for return statements which
39 return a local aggregate. When converted to RTL such statements will
40 generate a copy from the local aggregate to final return value destination
41 mandated by the target's ABI.
43 That copy can often be avoided by directly constructing the return value
44 into the final destination mandated by the target's ABI.
46 This is basically a generic equivalent to the C++ front-end's
47 Named Return Value optimization. */
51 /* This is the temporary (a VAR_DECL) which appears in all of
52 this function's RETURN_EXPR statements. */
55 /* This is the function's RESULT_DECL. We will replace all occurrences
56 of VAR with RESULT_DECL when we apply this optimization. */
61 static tree
finalize_nrv_r (tree
*, int *, void *);
63 /* Callback for the tree walker.
65 If TP refers to a RETURN_EXPR, then set the expression being returned
68 If TP refers to nrv_data->var, then replace nrv_data->var with
71 If we reach a node where we know all the subtrees are uninteresting,
72 then set *WALK_SUBTREES to zero. */
75 finalize_nrv_r (tree
*tp
, int *walk_subtrees
, void *data
)
77 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
78 struct nrv_data
*dp
= (struct nrv_data
*) wi
->info
;
80 /* No need to walk into types. */
84 /* Otherwise replace all occurrences of VAR with RESULT. */
85 else if (*tp
== dp
->var
)
95 /* Main entry point for return value optimizations.
97 If this function always returns the same local variable, and that
98 local variable is an aggregate type, then replace the variable with
99 the function's DECL_RESULT.
101 This is the equivalent of the C++ named return value optimization
102 applied to optimized trees in a language independent form. If we
103 ever encounter languages which prevent this kind of optimization,
104 then we could either have the languages register the optimization or
105 we could change the gating function to check the current language. */
110 tree result
= DECL_RESULT (current_function_decl
);
111 tree result_type
= TREE_TYPE (result
);
114 gimple_stmt_iterator gsi
;
115 struct nrv_data data
;
117 /* If this function does not return an aggregate type in memory, then
118 there is nothing to do. */
119 if (!aggregate_value_p (result
, current_function_decl
))
122 /* If a GIMPLE type is returned in memory, finalize_nrv_r might create
124 if (is_gimple_reg_type (result_type
))
127 /* If the front end already did something like this, don't do it here. */
128 if (DECL_NAME (result
))
131 /* If the result has its address taken then it might be modified
132 by means not detected in the following loop. Bail out in this
134 if (TREE_ADDRESSABLE (result
))
137 /* Look through each block for assignments to the RESULT_DECL. */
140 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
142 gimple stmt
= gsi_stmt (gsi
);
145 if (gimple_code (stmt
) == GIMPLE_RETURN
)
147 /* In a function with an aggregate return value, the
148 gimplifier has changed all non-empty RETURN_EXPRs to
149 return the RESULT_DECL. */
150 ret_val
= gimple_return_retval (stmt
);
152 gcc_assert (ret_val
== result
);
154 else if (gimple_has_lhs (stmt
)
155 && gimple_get_lhs (stmt
) == result
)
159 if (!gimple_assign_copy_p (stmt
))
162 rhs
= gimple_assign_rhs1 (stmt
);
164 /* Now verify that this return statement uses the same value
165 as any previously encountered return statement. */
168 /* If we found a return statement using a different variable
169 than previous return statements, then we can not perform
170 NRV optimizations. */
177 /* The returned value must be a local automatic variable of the
178 same type and alignment as the function's result. */
179 if (TREE_CODE (found
) != VAR_DECL
180 || TREE_THIS_VOLATILE (found
)
181 || DECL_CONTEXT (found
) != current_function_decl
182 || TREE_STATIC (found
)
183 || TREE_ADDRESSABLE (found
)
184 || DECL_ALIGN (found
) > DECL_ALIGN (result
)
185 || !useless_type_conversion_p (result_type
,
189 else if (gimple_has_lhs (stmt
))
191 tree addr
= get_base_address (gimple_get_lhs (stmt
));
192 /* If there's any MODIFY of component of RESULT,
194 if (addr
&& addr
== result
)
203 /* If dumping details, then note once and only the NRV replacement. */
204 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
206 fprintf (dump_file
, "NRV Replaced: ");
207 print_generic_expr (dump_file
, found
, dump_flags
);
208 fprintf (dump_file
, " with: ");
209 print_generic_expr (dump_file
, result
, dump_flags
);
210 fprintf (dump_file
, "\n");
213 /* At this point we know that all the return statements return the
214 same local which has suitable attributes for NRV. Copy debugging
215 information from FOUND to RESULT if it will be useful. But don't set
216 DECL_ABSTRACT_ORIGIN to point at another function. */
217 if (!DECL_IGNORED_P (found
)
218 && !(DECL_ABSTRACT_ORIGIN (found
)
219 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found
)) != current_function_decl
))
221 DECL_NAME (result
) = DECL_NAME (found
);
222 DECL_SOURCE_LOCATION (result
) = DECL_SOURCE_LOCATION (found
);
223 DECL_ABSTRACT_ORIGIN (result
) = DECL_ABSTRACT_ORIGIN (found
);
226 TREE_ADDRESSABLE (result
) |= TREE_ADDRESSABLE (found
);
228 /* Now walk through the function changing all references to VAR to be
231 data
.result
= result
;
234 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
236 gimple stmt
= gsi_stmt (gsi
);
237 /* If this is a copy from VAR to RESULT, remove it. */
238 if (gimple_assign_copy_p (stmt
)
239 && gimple_assign_lhs (stmt
) == result
240 && gimple_assign_rhs1 (stmt
) == found
)
242 unlink_stmt_vdef (stmt
);
243 gsi_remove (&gsi
, true);
248 struct walk_stmt_info wi
;
249 memset (&wi
, 0, sizeof (wi
));
252 walk_gimple_op (stmt
, finalize_nrv_r
, &wi
);
260 SET_DECL_VALUE_EXPR (found
, result
);
261 DECL_HAS_VALUE_EXPR_P (found
) = 1;
267 gate_pass_return_slot (void)
274 const pass_data pass_data_nrv
=
276 GIMPLE_PASS
, /* type */
278 OPTGROUP_NONE
, /* optinfo_flags */
280 true, /* has_execute */
281 TV_TREE_NRV
, /* tv_id */
282 ( PROP_ssa
| PROP_cfg
), /* properties_required */
283 0, /* properties_provided */
284 0, /* properties_destroyed */
285 0, /* todo_flags_start */
286 0, /* todo_flags_finish */
289 class pass_nrv
: public gimple_opt_pass
292 pass_nrv(gcc::context
*ctxt
)
293 : gimple_opt_pass(pass_data_nrv
, ctxt
)
296 /* opt_pass methods: */
297 bool gate () { return gate_pass_return_slot (); }
298 unsigned int execute () { return tree_nrv (); }
305 make_pass_nrv (gcc::context
*ctxt
)
307 return new pass_nrv (ctxt
);
310 /* Determine (pessimistically) whether DEST is available for NRV
311 optimization, where DEST is expected to be the LHS of a modify
312 expression where the RHS is a function returning an aggregate.
314 DEST is available if it is not clobbered or used by the call. */
317 dest_safe_for_nrv_p (gimple call
)
319 tree dest
= gimple_call_lhs (call
);
321 dest
= get_base_address (dest
);
325 if (TREE_CODE (dest
) == SSA_NAME
)
328 if (call_may_clobber_ref_p (call
, dest
)
329 || ref_maybe_used_by_stmt_p (call
, dest
))
335 /* Walk through the function looking for GIMPLE_ASSIGNs with calls that
336 return in memory on the RHS. For each of these, determine whether it is
337 safe to pass the address of the LHS as the return slot, and mark the
338 call appropriately if so.
340 The NRV shares the return slot with a local variable in the callee; this
341 optimization shares the return slot with the target of the call within
342 the caller. If the NRV is performed (which we can't know in general),
343 this optimization is safe if the address of the target has not
344 escaped prior to the call. If it has, modifications to the local
345 variable will produce visible changes elsewhere, as in PR c++/19317. */
348 execute_return_slot_opt (void)
354 gimple_stmt_iterator gsi
;
355 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
357 gimple stmt
= gsi_stmt (gsi
);
360 if (is_gimple_call (stmt
)
361 && gimple_call_lhs (stmt
)
362 && !gimple_call_return_slot_opt_p (stmt
)
363 && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt
)),
364 gimple_call_fndecl (stmt
)))
366 /* Check if the location being assigned to is
367 clobbered by the call. */
368 slot_opt_p
= dest_safe_for_nrv_p (stmt
);
369 gimple_call_set_return_slot_opt (stmt
, slot_opt_p
);
378 const pass_data pass_data_return_slot
=
380 GIMPLE_PASS
, /* type */
381 "retslot", /* name */
382 OPTGROUP_NONE
, /* optinfo_flags */
383 false, /* has_gate */
384 true, /* has_execute */
386 PROP_ssa
, /* properties_required */
387 0, /* properties_provided */
388 0, /* properties_destroyed */
389 0, /* todo_flags_start */
390 0, /* todo_flags_finish */
393 class pass_return_slot
: public gimple_opt_pass
396 pass_return_slot(gcc::context
*ctxt
)
397 : gimple_opt_pass(pass_data_return_slot
, ctxt
)
400 /* opt_pass methods: */
401 unsigned int execute () { return execute_return_slot_opt (); }
403 }; // class pass_return_slot
408 make_pass_return_slot (gcc::context
*ctxt
)
410 return new pass_return_slot (ctxt
);