Daily bump.
[official-gcc.git] / gcc / tree-nrv.c
blobef5ee67a2f3119c419c20833dabc631bcd793e34
1 /* Language independent return value optimizations
2 Copyright (C) 2004, 2005, 2007 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)
9 any later version.
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/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "tree.h"
25 #include "rtl.h"
26 #include "function.h"
27 #include "basic-block.h"
28 #include "expr.h"
29 #include "diagnostic.h"
30 #include "tree-flow.h"
31 #include "timevar.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. */
50 struct nrv_data
52 /* This is the temporary (a VAR_DECL) which appears in all of
53 this function's RETURN_EXPR statements. */
54 tree var;
56 /* This is the function's RESULT_DECL. We will replace all occurrences
57 of VAR with RESULT_DECL when we apply this optimization. */
58 tree result;
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
66 to nrv_data->result.
68 If TP refers to nrv_data->var, then replace nrv_data->var with
69 nrv_data->result.
71 If we reach a node where we know all the subtrees are uninteresting,
72 then set *WALK_SUBTREES to zero. */
74 static tree
75 finalize_nrv_r (tree *tp, int *walk_subtrees, void *data)
77 struct nrv_data *dp = (struct nrv_data *)data;
79 /* No need to walk into types. */
80 if (TYPE_P (*tp))
81 *walk_subtrees = 0;
83 /* Otherwise replace all occurrences of VAR with RESULT. */
84 else if (*tp == dp->var)
85 *tp = dp->result;
87 /* Keep iterating. */
88 return NULL_TREE;
91 /* Main entry point for return value optimizations.
93 If this function always returns the same local variable, and that
94 local variable is an aggregate type, then replace the variable with
95 the function's DECL_RESULT.
97 This is the equivalent of the C++ named return value optimization
98 applied to optimized trees in a language independent form. If we
99 ever encounter languages which prevent this kind of optimization,
100 then we could either have the languages register the optimization or
101 we could change the gating function to check the current language. */
103 static unsigned int
104 tree_nrv (void)
106 tree result = DECL_RESULT (current_function_decl);
107 tree result_type = TREE_TYPE (result);
108 tree found = NULL;
109 basic_block bb;
110 block_stmt_iterator bsi;
111 struct nrv_data data;
113 /* If this function does not return an aggregate type in memory, then
114 there is nothing to do. */
115 if (!aggregate_value_p (result, current_function_decl))
116 return 0;
118 /* Look through each block for assignments to the RESULT_DECL. */
119 FOR_EACH_BB (bb)
121 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
123 tree stmt = bsi_stmt (bsi);
124 tree ret_expr;
126 if (TREE_CODE (stmt) == RETURN_EXPR)
128 /* In a function with an aggregate return value, the
129 gimplifier has changed all non-empty RETURN_EXPRs to
130 return the RESULT_DECL. */
131 ret_expr = TREE_OPERAND (stmt, 0);
132 if (ret_expr)
133 gcc_assert (ret_expr == result);
135 else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
136 && GIMPLE_STMT_OPERAND (stmt, 0) == result)
138 ret_expr = GIMPLE_STMT_OPERAND (stmt, 1);
140 /* Now verify that this return statement uses the same value
141 as any previously encountered return statement. */
142 if (found != NULL)
144 /* If we found a return statement using a different variable
145 than previous return statements, then we can not perform
146 NRV optimizations. */
147 if (found != ret_expr)
148 return 0;
150 else
151 found = ret_expr;
153 /* The returned value must be a local automatic variable of the
154 same type and alignment as the function's result. */
155 if (TREE_CODE (found) != VAR_DECL
156 || TREE_THIS_VOLATILE (found)
157 || DECL_CONTEXT (found) != current_function_decl
158 || TREE_STATIC (found)
159 || TREE_ADDRESSABLE (found)
160 || DECL_ALIGN (found) > DECL_ALIGN (result)
161 || !useless_type_conversion_p (result_type,
162 TREE_TYPE (found)))
163 return 0;
165 else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
167 tree addr = get_base_address (GIMPLE_STMT_OPERAND (stmt, 0));
168 /* If there's any MODIFY of component of RESULT,
169 then bail out. */
170 if (addr && addr == result)
171 return 0;
176 if (!found)
177 return 0;
179 /* If dumping details, then note once and only the NRV replacement. */
180 if (dump_file && (dump_flags & TDF_DETAILS))
182 fprintf (dump_file, "NRV Replaced: ");
183 print_generic_expr (dump_file, found, dump_flags);
184 fprintf (dump_file, " with: ");
185 print_generic_expr (dump_file, result, dump_flags);
186 fprintf (dump_file, "\n");
189 /* At this point we know that all the return statements return the
190 same local which has suitable attributes for NRV. Copy debugging
191 information from FOUND to RESULT. */
192 DECL_NAME (result) = DECL_NAME (found);
193 DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (found);
194 DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (found);
195 TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (found);
197 /* Now walk through the function changing all references to VAR to be
198 RESULT. */
199 data.var = found;
200 data.result = result;
201 FOR_EACH_BB (bb)
203 for (bsi = bsi_start (bb); !bsi_end_p (bsi); )
205 tree *tp = bsi_stmt_ptr (bsi);
206 /* If this is a copy from VAR to RESULT, remove it. */
207 if (TREE_CODE (*tp) == GIMPLE_MODIFY_STMT
208 && GIMPLE_STMT_OPERAND (*tp, 0) == result
209 && GIMPLE_STMT_OPERAND (*tp, 1) == found)
210 bsi_remove (&bsi, true);
211 else
213 walk_tree (tp, finalize_nrv_r, &data, 0);
214 bsi_next (&bsi);
219 /* FOUND is no longer used. Ensure it gets removed. */
220 var_ann (found)->used = 0;
221 return 0;
224 struct tree_opt_pass pass_nrv =
226 "nrv", /* name */
227 NULL, /* gate */
228 tree_nrv, /* execute */
229 NULL, /* sub */
230 NULL, /* next */
231 0, /* static_pass_number */
232 TV_TREE_NRV, /* tv_id */
233 PROP_cfg, /* properties_required */
234 0, /* properties_provided */
235 0, /* properties_destroyed */
236 0, /* todo_flags_start */
237 TODO_dump_func | TODO_ggc_collect, /* todo_flags_finish */
238 0 /* letter */
241 /* Determine (pessimistically) whether DEST is available for NRV
242 optimization, where DEST is expected to be the LHS of a modify
243 expression where the RHS is a function returning an aggregate.
245 We search for a base VAR_DECL and look to see if it, or any of its
246 subvars are clobbered. Note that we could do better, for example, by
247 attempting to doing points-to analysis on INDIRECT_REFs. */
249 static bool
250 dest_safe_for_nrv_p (tree dest)
252 subvar_t sv;
253 unsigned int i;
254 tree subvar;
256 while (handled_component_p (dest))
257 dest = TREE_OPERAND (dest, 0);
259 if (! SSA_VAR_P (dest))
260 return false;
262 if (TREE_CODE (dest) == SSA_NAME)
263 dest = SSA_NAME_VAR (dest);
265 if (is_call_clobbered (dest))
266 return false;
268 sv = get_subvars_for_var (dest);
269 for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i)
270 if (is_call_clobbered (subvar))
271 return false;
273 return true;
276 /* Walk through the function looking for GIMPLE_MODIFY_STMTs with calls that
277 return in memory on the RHS. For each of these, determine whether it is
278 safe to pass the address of the LHS as the return slot, and mark the
279 call appropriately if so.
281 The NRV shares the return slot with a local variable in the callee; this
282 optimization shares the return slot with the target of the call within
283 the caller. If the NRV is performed (which we can't know in general),
284 this optimization is safe if the address of the target has not
285 escaped prior to the call. If it has, modifications to the local
286 variable will produce visible changes elsewhere, as in PR c++/19317. */
288 static unsigned int
289 execute_return_slot_opt (void)
291 basic_block bb;
293 FOR_EACH_BB (bb)
295 block_stmt_iterator i;
296 for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
298 tree stmt = bsi_stmt (i);
299 tree call;
301 if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
302 && (call = GIMPLE_STMT_OPERAND (stmt, 1),
303 TREE_CODE (call) == CALL_EXPR)
304 && !CALL_EXPR_RETURN_SLOT_OPT (call)
305 && aggregate_value_p (call, call))
306 /* Check if the location being assigned to is
307 call-clobbered. */
308 CALL_EXPR_RETURN_SLOT_OPT (call) =
309 dest_safe_for_nrv_p (GIMPLE_STMT_OPERAND (stmt, 0)) ? 1 : 0;
312 return 0;
315 struct tree_opt_pass pass_return_slot =
317 "retslot", /* name */
318 NULL, /* gate */
319 execute_return_slot_opt, /* execute */
320 NULL, /* sub */
321 NULL, /* next */
322 0, /* static_pass_number */
323 0, /* tv_id */
324 PROP_ssa | PROP_alias, /* properties_required */
325 0, /* properties_provided */
326 0, /* properties_destroyed */
327 0, /* todo_flags_start */
328 0, /* todo_flags_finish */
329 0 /* letter */