1 /* Language independent return value optimizations
2 Copyright (C) 2004, 2005, 2007, 2008, 2009 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"
27 #include "basic-block.h"
29 #include "diagnostic.h"
30 #include "tree-flow.h"
32 #include "tree-dump.h"
33 #include "tree-pass.h"
34 #include "langhooks.h"
36 /* This file implements return value optimizations for functions which
37 return aggregate types.
39 Basically this pass searches the function for return statements which
40 return a local aggregate. When converted to RTL such statements will
41 generate a copy from the local aggregate to final return value destination
42 mandated by the target's ABI.
44 That copy can often be avoided by directly constructing the return value
45 into the final destination mandated by the target's ABI.
47 This is basically a generic equivalent to the C++ front-end's
48 Named Return Value optimization. */
52 /* This is the temporary (a VAR_DECL) which appears in all of
53 this function's RETURN_EXPR statements. */
56 /* This is the function's RESULT_DECL. We will replace all occurrences
57 of VAR with RESULT_DECL when we apply this optimization. */
62 static tree
finalize_nrv_r (tree
*, int *, void *);
64 /* Callback for the tree walker.
66 If TP refers to a RETURN_EXPR, then set the expression being returned
69 If TP refers to nrv_data->var, then replace nrv_data->var with
72 If we reach a node where we know all the subtrees are uninteresting,
73 then set *WALK_SUBTREES to zero. */
76 finalize_nrv_r (tree
*tp
, int *walk_subtrees
, void *data
)
78 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
79 struct nrv_data
*dp
= (struct nrv_data
*) wi
->info
;
81 /* No need to walk into types. */
85 /* Otherwise replace all occurrences of VAR with RESULT. */
86 else if (*tp
== dp
->var
)
96 /* Main entry point for return value optimizations.
98 If this function always returns the same local variable, and that
99 local variable is an aggregate type, then replace the variable with
100 the function's DECL_RESULT.
102 This is the equivalent of the C++ named return value optimization
103 applied to optimized trees in a language independent form. If we
104 ever encounter languages which prevent this kind of optimization,
105 then we could either have the languages register the optimization or
106 we could change the gating function to check the current language. */
111 tree result
= DECL_RESULT (current_function_decl
);
112 tree result_type
= TREE_TYPE (result
);
115 gimple_stmt_iterator gsi
;
116 struct nrv_data data
;
118 /* If this function does not return an aggregate type in memory, then
119 there is nothing to do. */
120 if (!aggregate_value_p (result
, current_function_decl
))
123 /* If a GIMPLE type is returned in memory, finalize_nrv_r might create
125 if (is_gimple_reg_type (result_type
))
128 /* If the front end already did something like this, don't do it here. */
129 if (DECL_NAME (result
))
132 /* Look through each block for assignments to the RESULT_DECL. */
135 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
137 gimple stmt
= gsi_stmt (gsi
);
140 if (gimple_code (stmt
) == GIMPLE_RETURN
)
142 /* In a function with an aggregate return value, the
143 gimplifier has changed all non-empty RETURN_EXPRs to
144 return the RESULT_DECL. */
145 ret_val
= gimple_return_retval (stmt
);
147 gcc_assert (ret_val
== result
);
149 else if (gimple_has_lhs (stmt
)
150 && gimple_get_lhs (stmt
) == result
)
154 if (!gimple_assign_copy_p (stmt
))
157 rhs
= gimple_assign_rhs1 (stmt
);
159 /* Now verify that this return statement uses the same value
160 as any previously encountered return statement. */
163 /* If we found a return statement using a different variable
164 than previous return statements, then we can not perform
165 NRV optimizations. */
172 /* The returned value must be a local automatic variable of the
173 same type and alignment as the function's result. */
174 if (TREE_CODE (found
) != VAR_DECL
175 || TREE_THIS_VOLATILE (found
)
176 || DECL_CONTEXT (found
) != current_function_decl
177 || TREE_STATIC (found
)
178 || TREE_ADDRESSABLE (found
)
179 || DECL_ALIGN (found
) > DECL_ALIGN (result
)
180 || !useless_type_conversion_p (result_type
,
184 else if (gimple_has_lhs (stmt
))
186 tree addr
= get_base_address (gimple_get_lhs (stmt
));
187 /* If there's any MODIFY of component of RESULT,
189 if (addr
&& addr
== result
)
198 /* If dumping details, then note once and only the NRV replacement. */
199 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
201 fprintf (dump_file
, "NRV Replaced: ");
202 print_generic_expr (dump_file
, found
, dump_flags
);
203 fprintf (dump_file
, " with: ");
204 print_generic_expr (dump_file
, result
, dump_flags
);
205 fprintf (dump_file
, "\n");
208 /* At this point we know that all the return statements return the
209 same local which has suitable attributes for NRV. Copy debugging
210 information from FOUND to RESULT if it will be useful. But don't set
211 DECL_ABSTRACT_ORIGIN to point at another function. */
212 if (!DECL_IGNORED_P (found
)
213 && !(DECL_ABSTRACT_ORIGIN (found
)
214 && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found
)) != current_function_decl
))
216 DECL_NAME (result
) = DECL_NAME (found
);
217 DECL_SOURCE_LOCATION (result
) = DECL_SOURCE_LOCATION (found
);
218 DECL_ABSTRACT_ORIGIN (result
) = DECL_ABSTRACT_ORIGIN (found
);
221 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (found
);
223 /* Now walk through the function changing all references to VAR to be
226 data
.result
= result
;
229 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
231 gimple stmt
= gsi_stmt (gsi
);
232 /* If this is a copy from VAR to RESULT, remove it. */
233 if (gimple_assign_copy_p (stmt
)
234 && gimple_assign_lhs (stmt
) == result
235 && gimple_assign_rhs1 (stmt
) == found
)
237 unlink_stmt_vdef (stmt
);
238 gsi_remove (&gsi
, true);
242 struct walk_stmt_info wi
;
243 memset (&wi
, 0, sizeof (wi
));
246 walk_gimple_op (stmt
, finalize_nrv_r
, &wi
);
254 /* FOUND is no longer used. Ensure it gets removed. */
255 var_ann (found
)->used
= 0;
260 gate_pass_return_slot (void)
265 struct gimple_opt_pass pass_nrv
=
270 gate_pass_return_slot
, /* gate */
271 tree_nrv
, /* execute */
274 0, /* static_pass_number */
275 TV_TREE_NRV
, /* tv_id */
276 PROP_ssa
| PROP_cfg
, /* properties_required */
277 0, /* properties_provided */
278 0, /* properties_destroyed */
279 0, /* todo_flags_start */
280 TODO_dump_func
| TODO_ggc_collect
/* todo_flags_finish */
284 /* Determine (pessimistically) whether DEST is available for NRV
285 optimization, where DEST is expected to be the LHS of a modify
286 expression where the RHS is a function returning an aggregate.
288 We search for a base VAR_DECL and look to see if it is call clobbered.
289 Note that we could do better, for example, by
290 attempting to doing points-to analysis on INDIRECT_REFs. */
293 dest_safe_for_nrv_p (tree dest
)
295 while (handled_component_p (dest
))
296 dest
= TREE_OPERAND (dest
, 0);
298 if (! SSA_VAR_P (dest
))
301 if (TREE_CODE (dest
) == SSA_NAME
)
302 dest
= SSA_NAME_VAR (dest
);
304 if (is_call_used (dest
))
310 /* Walk through the function looking for GIMPLE_ASSIGNs with calls that
311 return in memory on the RHS. For each of these, determine whether it is
312 safe to pass the address of the LHS as the return slot, and mark the
313 call appropriately if so.
315 The NRV shares the return slot with a local variable in the callee; this
316 optimization shares the return slot with the target of the call within
317 the caller. If the NRV is performed (which we can't know in general),
318 this optimization is safe if the address of the target has not
319 escaped prior to the call. If it has, modifications to the local
320 variable will produce visible changes elsewhere, as in PR c++/19317. */
323 execute_return_slot_opt (void)
329 gimple_stmt_iterator gsi
;
330 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
332 gimple stmt
= gsi_stmt (gsi
);
335 if (is_gimple_call (stmt
)
336 && gimple_call_lhs (stmt
)
337 && !gimple_call_return_slot_opt_p (stmt
)
338 && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt
)),
339 gimple_call_fndecl (stmt
))
342 /* Check if the location being assigned to is
344 slot_opt_p
= dest_safe_for_nrv_p (gimple_call_lhs (stmt
));
345 gimple_call_set_return_slot_opt (stmt
, slot_opt_p
);
352 struct gimple_opt_pass pass_return_slot
=
356 "retslot", /* name */
358 execute_return_slot_opt
, /* execute */
361 0, /* static_pass_number */
363 PROP_ssa
| PROP_alias
, /* properties_required */
364 0, /* properties_provided */
365 0, /* properties_destroyed */
366 0, /* todo_flags_start */
367 0 /* todo_flags_finish */