1 /* Language independent return value optimizations
2 Copyright (C) 2004-2015 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 "hard-reg-set.h"
29 #include "fold-const.h"
30 #include "tree-pretty-print.h"
31 #include "internal-fn.h"
32 #include "gimple-iterator.h"
33 #include "gimple-walk.h"
34 #include "tree-pass.h"
35 #include "langhooks.h"
36 #include "flags.h" /* For "optimize" in gate_pass_return_slot.
37 FIXME: That should be up to the pass manager,
38 but pass_nrv is not in pass_all_optimizations. */
40 /* This file implements return value optimizations for functions which
41 return aggregate types.
43 Basically this pass searches the function for return statements which
44 return a local aggregate. When converted to RTL such statements will
45 generate a copy from the local aggregate to final return value destination
46 mandated by the target's ABI.
48 That copy can often be avoided by directly constructing the return value
49 into the final destination mandated by the target's ABI.
51 This is basically a generic equivalent to the C++ front-end's
52 Named Return Value optimization. */
56 /* This is the temporary (a VAR_DECL) which appears in all of
57 this function's RETURN_EXPR statements. */
60 /* This is the function's RESULT_DECL. We will replace all occurrences
61 of VAR with RESULT_DECL when we apply this optimization. */
66 static tree
finalize_nrv_r (tree
*, int *, void *);
68 /* Callback for the tree walker.
70 If TP refers to a RETURN_EXPR, then set the expression being returned
73 If TP refers to nrv_data->var, then replace nrv_data->var with
76 If we reach a node where we know all the subtrees are uninteresting,
77 then set *WALK_SUBTREES to zero. */
80 finalize_nrv_r (tree
*tp
, int *walk_subtrees
, void *data
)
82 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
83 struct nrv_data_t
*dp
= (struct nrv_data_t
*) wi
->info
;
85 /* No need to walk into types. */
89 /* Otherwise replace all occurrences of VAR with RESULT. */
90 else if (*tp
== dp
->var
)
100 /* Main entry point for return value optimizations.
102 If this function always returns the same local variable, and that
103 local variable is an aggregate type, then replace the variable with
104 the function's DECL_RESULT.
106 This is the equivalent of the C++ named return value optimization
107 applied to optimized trees in a language independent form. If we
108 ever encounter languages which prevent this kind of optimization,
109 then we could either have the languages register the optimization or
110 we could change the gating function to check the current language. */
114 const pass_data pass_data_nrv
=
116 GIMPLE_PASS
, /* type */
118 OPTGROUP_NONE
, /* optinfo_flags */
119 TV_TREE_NRV
, /* tv_id */
120 ( PROP_ssa
| PROP_cfg
), /* properties_required */
121 0, /* properties_provided */
122 0, /* properties_destroyed */
123 0, /* todo_flags_start */
124 0, /* todo_flags_finish */
127 class pass_nrv
: public gimple_opt_pass
130 pass_nrv (gcc::context
*ctxt
)
131 : gimple_opt_pass (pass_data_nrv
, ctxt
)
134 /* opt_pass methods: */
135 virtual bool gate (function
*) { return optimize
> 0; }
137 virtual unsigned int execute (function
*);
142 pass_nrv::execute (function
*fun
)
144 tree result
= DECL_RESULT (current_function_decl
);
145 tree result_type
= TREE_TYPE (result
);
148 gimple_stmt_iterator gsi
;
149 struct nrv_data_t data
;
151 /* If this function does not return an aggregate type in memory, then
152 there is nothing to do. */
153 if (!aggregate_value_p (result
, current_function_decl
))
156 /* If a GIMPLE type is returned in memory, finalize_nrv_r might create
158 if (is_gimple_reg_type (result_type
))
161 /* If the front end already did something like this, don't do it here. */
162 if (DECL_NAME (result
))
165 /* If the result has its address taken then it might be modified
166 by means not detected in the following loop. Bail out in this
168 if (TREE_ADDRESSABLE (result
))
171 /* Look through each block for assignments to the RESULT_DECL. */
172 FOR_EACH_BB_FN (bb
, fun
)
174 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
176 gimple
*stmt
= gsi_stmt (gsi
);
179 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
181 /* In a function with an aggregate return value, the
182 gimplifier has changed all non-empty RETURN_EXPRs to
183 return the RESULT_DECL. */
184 ret_val
= gimple_return_retval (return_stmt
);
186 gcc_assert (ret_val
== result
);
188 else if (gimple_has_lhs (stmt
)
189 && gimple_get_lhs (stmt
) == result
)
193 if (!gimple_assign_copy_p (stmt
))
196 rhs
= gimple_assign_rhs1 (stmt
);
198 /* Now verify that this return statement uses the same value
199 as any previously encountered return statement. */
202 /* If we found a return statement using a different variable
203 than previous return statements, then we can not perform
204 NRV optimizations. */
211 /* The returned value must be a local automatic variable of the
212 same type and alignment as the function's result. */
213 if (TREE_CODE (found
) != VAR_DECL
214 || TREE_THIS_VOLATILE (found
)
215 || !auto_var_in_fn_p (found
, current_function_decl
)
216 || TREE_ADDRESSABLE (found
)
217 || DECL_ALIGN (found
) > DECL_ALIGN (result
)
218 || !useless_type_conversion_p (result_type
,
222 else if (gimple_has_lhs (stmt
))
224 tree addr
= get_base_address (gimple_get_lhs (stmt
));
225 /* If there's any MODIFY of component of RESULT,
227 if (addr
&& addr
== result
)
236 /* If dumping details, then note once and only the NRV replacement. */
237 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
239 fprintf (dump_file
, "NRV Replaced: ");
240 print_generic_expr (dump_file
, found
, dump_flags
);
241 fprintf (dump_file
, " with: ");
242 print_generic_expr (dump_file
, result
, dump_flags
);
243 fprintf (dump_file
, "\n");
246 /* At this point we know that all the return statements return the
247 same local which has suitable attributes for NRV. Copy debugging
248 information from FOUND to RESULT if it will be useful. But don't set
249 DECL_ABSTRACT_ORIGIN to point at another function. */
250 if (!DECL_IGNORED_P (found
)
251 && !(DECL_ABSTRACT_ORIGIN (found
)
252 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found
)) != current_function_decl
))
254 DECL_NAME (result
) = DECL_NAME (found
);
255 DECL_SOURCE_LOCATION (result
) = DECL_SOURCE_LOCATION (found
);
256 DECL_ABSTRACT_ORIGIN (result
) = DECL_ABSTRACT_ORIGIN (found
);
259 TREE_ADDRESSABLE (result
) |= TREE_ADDRESSABLE (found
);
261 /* Now walk through the function changing all references to VAR to be
264 data
.result
= result
;
265 FOR_EACH_BB_FN (bb
, fun
)
267 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
269 gimple
*stmt
= gsi_stmt (gsi
);
270 /* If this is a copy from VAR to RESULT, remove it. */
271 if (gimple_assign_copy_p (stmt
)
272 && gimple_assign_lhs (stmt
) == result
273 && gimple_assign_rhs1 (stmt
) == found
)
275 unlink_stmt_vdef (stmt
);
276 gsi_remove (&gsi
, true);
281 struct walk_stmt_info wi
;
282 memset (&wi
, 0, sizeof (wi
));
285 walk_gimple_op (stmt
, finalize_nrv_r
, &wi
);
293 SET_DECL_VALUE_EXPR (found
, result
);
294 DECL_HAS_VALUE_EXPR_P (found
) = 1;
302 make_pass_nrv (gcc::context
*ctxt
)
304 return new pass_nrv (ctxt
);
307 /* Determine (pessimistically) whether DEST is available for NRV
308 optimization, where DEST is expected to be the LHS of a modify
309 expression where the RHS is a function returning an aggregate.
311 DEST is available if it is not clobbered or used by the call. */
314 dest_safe_for_nrv_p (gcall
*call
)
316 tree dest
= gimple_call_lhs (call
);
318 dest
= get_base_address (dest
);
322 if (TREE_CODE (dest
) == SSA_NAME
)
325 if (call_may_clobber_ref_p (call
, dest
)
326 || ref_maybe_used_by_stmt_p (call
, dest
))
332 /* Walk through the function looking for GIMPLE_ASSIGNs with calls that
333 return in memory on the RHS. For each of these, determine whether it is
334 safe to pass the address of the LHS as the return slot, and mark the
335 call appropriately if so.
337 The NRV shares the return slot with a local variable in the callee; this
338 optimization shares the return slot with the target of the call within
339 the caller. If the NRV is performed (which we can't know in general),
340 this optimization is safe if the address of the target has not
341 escaped prior to the call. If it has, modifications to the local
342 variable will produce visible changes elsewhere, as in PR c++/19317. */
346 const pass_data pass_data_return_slot
=
348 GIMPLE_PASS
, /* type */
349 "retslot", /* name */
350 OPTGROUP_NONE
, /* optinfo_flags */
352 PROP_ssa
, /* properties_required */
353 0, /* properties_provided */
354 0, /* properties_destroyed */
355 0, /* todo_flags_start */
356 0, /* todo_flags_finish */
359 class pass_return_slot
: public gimple_opt_pass
362 pass_return_slot (gcc::context
*ctxt
)
363 : gimple_opt_pass (pass_data_return_slot
, ctxt
)
366 /* opt_pass methods: */
367 virtual unsigned int execute (function
*);
369 }; // class pass_return_slot
372 pass_return_slot::execute (function
*fun
)
376 FOR_EACH_BB_FN (bb
, fun
)
378 gimple_stmt_iterator gsi
;
379 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
384 stmt
= dyn_cast
<gcall
*> (gsi_stmt (gsi
));
386 && gimple_call_lhs (stmt
)
387 && !gimple_call_return_slot_opt_p (stmt
)
388 && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt
)),
389 gimple_call_fndecl (stmt
)))
391 /* Check if the location being assigned to is
392 clobbered by the call. */
393 slot_opt_p
= dest_safe_for_nrv_p (stmt
);
394 gimple_call_set_return_slot_opt (stmt
, slot_opt_p
);
404 make_pass_return_slot (gcc::context
*ctxt
)
406 return new pass_return_slot (ctxt
);