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"
29 #include "gimple-ssa.h"
30 #include "tree-ssanames.h"
31 #include "tree-pass.h"
32 #include "langhooks.h"
33 #include "flags.h" /* For "optimize" in gate_pass_return_slot.
34 FIXME: That should be up to the pass manager,
35 but pass_nrv is not in pass_all_optimizations. */
37 /* This file implements return value optimizations for functions which
38 return aggregate types.
40 Basically this pass searches the function for return statements which
41 return a local aggregate. When converted to RTL such statements will
42 generate a copy from the local aggregate to final return value destination
43 mandated by the target's ABI.
45 That copy can often be avoided by directly constructing the return value
46 into the final destination mandated by the target's ABI.
48 This is basically a generic equivalent to the C++ front-end's
49 Named Return Value optimization. */
53 /* This is the temporary (a VAR_DECL) which appears in all of
54 this function's RETURN_EXPR statements. */
57 /* This is the function's RESULT_DECL. We will replace all occurrences
58 of VAR with RESULT_DECL when we apply this optimization. */
63 static tree
finalize_nrv_r (tree
*, int *, void *);
65 /* Callback for the tree walker.
67 If TP refers to a RETURN_EXPR, then set the expression being returned
70 If TP refers to nrv_data->var, then replace nrv_data->var with
73 If we reach a node where we know all the subtrees are uninteresting,
74 then set *WALK_SUBTREES to zero. */
77 finalize_nrv_r (tree
*tp
, int *walk_subtrees
, void *data
)
79 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
80 struct nrv_data
*dp
= (struct nrv_data
*) wi
->info
;
82 /* No need to walk into types. */
86 /* Otherwise replace all occurrences of VAR with RESULT. */
87 else if (*tp
== dp
->var
)
97 /* Main entry point for return value optimizations.
99 If this function always returns the same local variable, and that
100 local variable is an aggregate type, then replace the variable with
101 the function's DECL_RESULT.
103 This is the equivalent of the C++ named return value optimization
104 applied to optimized trees in a language independent form. If we
105 ever encounter languages which prevent this kind of optimization,
106 then we could either have the languages register the optimization or
107 we could change the gating function to check the current language. */
112 tree result
= DECL_RESULT (current_function_decl
);
113 tree result_type
= TREE_TYPE (result
);
116 gimple_stmt_iterator gsi
;
117 struct nrv_data data
;
119 /* If this function does not return an aggregate type in memory, then
120 there is nothing to do. */
121 if (!aggregate_value_p (result
, current_function_decl
))
124 /* If a GIMPLE type is returned in memory, finalize_nrv_r might create
126 if (is_gimple_reg_type (result_type
))
129 /* If the front end already did something like this, don't do it here. */
130 if (DECL_NAME (result
))
133 /* If the result has its address taken then it might be modified
134 by means not detected in the following loop. Bail out in this
136 if (TREE_ADDRESSABLE (result
))
139 /* Look through each block for assignments to the RESULT_DECL. */
142 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
144 gimple stmt
= gsi_stmt (gsi
);
147 if (gimple_code (stmt
) == GIMPLE_RETURN
)
149 /* In a function with an aggregate return value, the
150 gimplifier has changed all non-empty RETURN_EXPRs to
151 return the RESULT_DECL. */
152 ret_val
= gimple_return_retval (stmt
);
154 gcc_assert (ret_val
== result
);
156 else if (gimple_has_lhs (stmt
)
157 && gimple_get_lhs (stmt
) == result
)
161 if (!gimple_assign_copy_p (stmt
))
164 rhs
= gimple_assign_rhs1 (stmt
);
166 /* Now verify that this return statement uses the same value
167 as any previously encountered return statement. */
170 /* If we found a return statement using a different variable
171 than previous return statements, then we can not perform
172 NRV optimizations. */
179 /* The returned value must be a local automatic variable of the
180 same type and alignment as the function's result. */
181 if (TREE_CODE (found
) != VAR_DECL
182 || TREE_THIS_VOLATILE (found
)
183 || DECL_CONTEXT (found
) != current_function_decl
184 || TREE_STATIC (found
)
185 || TREE_ADDRESSABLE (found
)
186 || DECL_ALIGN (found
) > DECL_ALIGN (result
)
187 || !useless_type_conversion_p (result_type
,
191 else if (gimple_has_lhs (stmt
))
193 tree addr
= get_base_address (gimple_get_lhs (stmt
));
194 /* If there's any MODIFY of component of RESULT,
196 if (addr
&& addr
== result
)
205 /* If dumping details, then note once and only the NRV replacement. */
206 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
208 fprintf (dump_file
, "NRV Replaced: ");
209 print_generic_expr (dump_file
, found
, dump_flags
);
210 fprintf (dump_file
, " with: ");
211 print_generic_expr (dump_file
, result
, dump_flags
);
212 fprintf (dump_file
, "\n");
215 /* At this point we know that all the return statements return the
216 same local which has suitable attributes for NRV. Copy debugging
217 information from FOUND to RESULT if it will be useful. But don't set
218 DECL_ABSTRACT_ORIGIN to point at another function. */
219 if (!DECL_IGNORED_P (found
)
220 && !(DECL_ABSTRACT_ORIGIN (found
)
221 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found
)) != current_function_decl
))
223 DECL_NAME (result
) = DECL_NAME (found
);
224 DECL_SOURCE_LOCATION (result
) = DECL_SOURCE_LOCATION (found
);
225 DECL_ABSTRACT_ORIGIN (result
) = DECL_ABSTRACT_ORIGIN (found
);
228 TREE_ADDRESSABLE (result
) |= TREE_ADDRESSABLE (found
);
230 /* Now walk through the function changing all references to VAR to be
233 data
.result
= result
;
236 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
238 gimple stmt
= gsi_stmt (gsi
);
239 /* If this is a copy from VAR to RESULT, remove it. */
240 if (gimple_assign_copy_p (stmt
)
241 && gimple_assign_lhs (stmt
) == result
242 && gimple_assign_rhs1 (stmt
) == found
)
244 unlink_stmt_vdef (stmt
);
245 gsi_remove (&gsi
, true);
250 struct walk_stmt_info wi
;
251 memset (&wi
, 0, sizeof (wi
));
254 walk_gimple_op (stmt
, finalize_nrv_r
, &wi
);
262 SET_DECL_VALUE_EXPR (found
, result
);
263 DECL_HAS_VALUE_EXPR_P (found
) = 1;
269 gate_pass_return_slot (void)
276 const pass_data pass_data_nrv
=
278 GIMPLE_PASS
, /* type */
280 OPTGROUP_NONE
, /* optinfo_flags */
282 true, /* has_execute */
283 TV_TREE_NRV
, /* tv_id */
284 ( PROP_ssa
| PROP_cfg
), /* properties_required */
285 0, /* properties_provided */
286 0, /* properties_destroyed */
287 0, /* todo_flags_start */
288 0, /* todo_flags_finish */
291 class pass_nrv
: public gimple_opt_pass
294 pass_nrv (gcc::context
*ctxt
)
295 : gimple_opt_pass (pass_data_nrv
, ctxt
)
298 /* opt_pass methods: */
299 bool gate () { return gate_pass_return_slot (); }
300 unsigned int execute () { return tree_nrv (); }
307 make_pass_nrv (gcc::context
*ctxt
)
309 return new pass_nrv (ctxt
);
312 /* Determine (pessimistically) whether DEST is available for NRV
313 optimization, where DEST is expected to be the LHS of a modify
314 expression where the RHS is a function returning an aggregate.
316 DEST is available if it is not clobbered or used by the call. */
319 dest_safe_for_nrv_p (gimple call
)
321 tree dest
= gimple_call_lhs (call
);
323 dest
= get_base_address (dest
);
327 if (TREE_CODE (dest
) == SSA_NAME
)
330 if (call_may_clobber_ref_p (call
, dest
)
331 || ref_maybe_used_by_stmt_p (call
, dest
))
337 /* Walk through the function looking for GIMPLE_ASSIGNs with calls that
338 return in memory on the RHS. For each of these, determine whether it is
339 safe to pass the address of the LHS as the return slot, and mark the
340 call appropriately if so.
342 The NRV shares the return slot with a local variable in the callee; this
343 optimization shares the return slot with the target of the call within
344 the caller. If the NRV is performed (which we can't know in general),
345 this optimization is safe if the address of the target has not
346 escaped prior to the call. If it has, modifications to the local
347 variable will produce visible changes elsewhere, as in PR c++/19317. */
350 execute_return_slot_opt (void)
356 gimple_stmt_iterator gsi
;
357 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
359 gimple stmt
= gsi_stmt (gsi
);
362 if (is_gimple_call (stmt
)
363 && gimple_call_lhs (stmt
)
364 && !gimple_call_return_slot_opt_p (stmt
)
365 && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt
)),
366 gimple_call_fndecl (stmt
)))
368 /* Check if the location being assigned to is
369 clobbered by the call. */
370 slot_opt_p
= dest_safe_for_nrv_p (stmt
);
371 gimple_call_set_return_slot_opt (stmt
, slot_opt_p
);
380 const pass_data pass_data_return_slot
=
382 GIMPLE_PASS
, /* type */
383 "retslot", /* name */
384 OPTGROUP_NONE
, /* optinfo_flags */
385 false, /* has_gate */
386 true, /* has_execute */
388 PROP_ssa
, /* properties_required */
389 0, /* properties_provided */
390 0, /* properties_destroyed */
391 0, /* todo_flags_start */
392 0, /* todo_flags_finish */
395 class pass_return_slot
: public gimple_opt_pass
398 pass_return_slot (gcc::context
*ctxt
)
399 : gimple_opt_pass (pass_data_return_slot
, ctxt
)
402 /* opt_pass methods: */
403 unsigned int execute () { return execute_return_slot_opt (); }
405 }; // class pass_return_slot
410 make_pass_return_slot (gcc::context
*ctxt
)
412 return new pass_return_slot (ctxt
);