Mercurial > hg > CbC > CbC_gcc
comparison gcc/tree-inline.c @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 58ad6c70ea60 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 /* Tree inlining. | |
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 | |
3 Free Software Foundation, Inc. | |
4 Contributed by Alexandre Oliva <aoliva@redhat.com> | |
5 | |
6 This file is part of GCC. | |
7 | |
8 GCC is free software; you can redistribute it and/or modify | |
9 it under the terms of the GNU General Public License as published by | |
10 the Free Software Foundation; either version 3, or (at your option) | |
11 any later version. | |
12 | |
13 GCC is distributed in the hope that it will be useful, | |
14 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 GNU General Public License for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
19 along with GCC; see the file COPYING3. If not see | |
20 <http://www.gnu.org/licenses/>. */ | |
21 | |
22 #include "config.h" | |
23 #include "system.h" | |
24 #include "coretypes.h" | |
25 #include "tm.h" | |
26 #include "toplev.h" | |
27 #include "tree.h" | |
28 #include "tree-inline.h" | |
29 #include "rtl.h" | |
30 #include "expr.h" | |
31 #include "flags.h" | |
32 #include "params.h" | |
33 #include "input.h" | |
34 #include "insn-config.h" | |
35 #include "varray.h" | |
36 #include "hashtab.h" | |
37 #include "langhooks.h" | |
38 #include "basic-block.h" | |
39 #include "tree-iterator.h" | |
40 #include "cgraph.h" | |
41 #include "intl.h" | |
42 #include "tree-mudflap.h" | |
43 #include "tree-flow.h" | |
44 #include "function.h" | |
45 #include "ggc.h" | |
46 #include "tree-flow.h" | |
47 #include "diagnostic.h" | |
48 #include "except.h" | |
49 #include "debug.h" | |
50 #include "pointer-set.h" | |
51 #include "ipa-prop.h" | |
52 #include "value-prof.h" | |
53 #include "tree-pass.h" | |
54 #include "target.h" | |
55 #include "integrate.h" | |
56 | |
57 /* I'm not real happy about this, but we need to handle gimple and | |
58 non-gimple trees. */ | |
59 #include "gimple.h" | |
60 | |
61 /* Inlining, Cloning, Versioning, Parallelization | |
62 | |
63 Inlining: a function body is duplicated, but the PARM_DECLs are | |
64 remapped into VAR_DECLs, and non-void RETURN_EXPRs become | |
65 MODIFY_EXPRs that store to a dedicated returned-value variable. | |
66 The duplicated eh_region info of the copy will later be appended | |
67 to the info for the caller; the eh_region info in copied throwing | |
68 statements and RESX_EXPRs is adjusted accordingly. | |
69 | |
70 Cloning: (only in C++) We have one body for a con/de/structor, and | |
71 multiple function decls, each with a unique parameter list. | |
72 Duplicate the body, using the given splay tree; some parameters | |
73 will become constants (like 0 or 1). | |
74 | |
75 Versioning: a function body is duplicated and the result is a new | |
76 function rather than into blocks of an existing function as with | |
77 inlining. Some parameters will become constants. | |
78 | |
79 Parallelization: a region of a function is duplicated resulting in | |
80 a new function. Variables may be replaced with complex expressions | |
81 to enable shared variable semantics. | |
82 | |
83 All of these will simultaneously lookup any callgraph edges. If | |
84 we're going to inline the duplicated function body, and the given | |
85 function has some cloned callgraph nodes (one for each place this | |
86 function will be inlined) those callgraph edges will be duplicated. | |
87 If we're cloning the body, those callgraph edges will be | |
88 updated to point into the new body. (Note that the original | |
89 callgraph node and edge list will not be altered.) | |
90 | |
91 See the CALL_EXPR handling case in copy_tree_body_r (). */ | |
92 | |
93 /* To Do: | |
94 | |
95 o In order to make inlining-on-trees work, we pessimized | |
96 function-local static constants. In particular, they are now | |
97 always output, even when not addressed. Fix this by treating | |
98 function-local static constants just like global static | |
99 constants; the back-end already knows not to output them if they | |
100 are not needed. | |
101 | |
102 o Provide heuristics to clamp inlining of recursive template | |
103 calls? */ | |
104 | |
105 | |
106 /* Weights that estimate_num_insns uses for heuristics in inlining. */ | |
107 | |
108 eni_weights eni_inlining_weights; | |
109 | |
110 /* Weights that estimate_num_insns uses to estimate the size of the | |
111 produced code. */ | |
112 | |
113 eni_weights eni_size_weights; | |
114 | |
115 /* Weights that estimate_num_insns uses to estimate the time necessary | |
116 to execute the produced code. */ | |
117 | |
118 eni_weights eni_time_weights; | |
119 | |
120 /* Prototypes. */ | |
121 | |
122 static tree declare_return_variable (copy_body_data *, tree, tree, tree *); | |
123 static bool inlinable_function_p (tree); | |
124 static void remap_block (tree *, copy_body_data *); | |
125 static void copy_bind_expr (tree *, int *, copy_body_data *); | |
126 static tree mark_local_for_remap_r (tree *, int *, void *); | |
127 static void unsave_expr_1 (tree); | |
128 static tree unsave_r (tree *, int *, void *); | |
129 static void declare_inline_vars (tree, tree); | |
130 static void remap_save_expr (tree *, void *, int *); | |
131 static void prepend_lexical_block (tree current_block, tree new_block); | |
132 static tree copy_decl_to_var (tree, copy_body_data *); | |
133 static tree copy_result_decl_to_var (tree, copy_body_data *); | |
134 static tree copy_decl_maybe_to_var (tree, copy_body_data *); | |
135 static gimple remap_gimple_stmt (gimple, copy_body_data *); | |
136 | |
137 /* Insert a tree->tree mapping for ID. Despite the name suggests | |
138 that the trees should be variables, it is used for more than that. */ | |
139 | |
140 void | |
141 insert_decl_map (copy_body_data *id, tree key, tree value) | |
142 { | |
143 *pointer_map_insert (id->decl_map, key) = value; | |
144 | |
145 /* Always insert an identity map as well. If we see this same new | |
146 node again, we won't want to duplicate it a second time. */ | |
147 if (key != value) | |
148 *pointer_map_insert (id->decl_map, value) = value; | |
149 } | |
150 | |
151 /* Construct new SSA name for old NAME. ID is the inline context. */ | |
152 | |
153 static tree | |
154 remap_ssa_name (tree name, copy_body_data *id) | |
155 { | |
156 tree new_tree; | |
157 tree *n; | |
158 | |
159 gcc_assert (TREE_CODE (name) == SSA_NAME); | |
160 | |
161 n = (tree *) pointer_map_contains (id->decl_map, name); | |
162 if (n) | |
163 return unshare_expr (*n); | |
164 | |
165 /* Do not set DEF_STMT yet as statement is not copied yet. We do that | |
166 in copy_bb. */ | |
167 new_tree = remap_decl (SSA_NAME_VAR (name), id); | |
168 | |
169 /* We might've substituted constant or another SSA_NAME for | |
170 the variable. | |
171 | |
172 Replace the SSA name representing RESULT_DECL by variable during | |
173 inlining: this saves us from need to introduce PHI node in a case | |
174 return value is just partly initialized. */ | |
175 if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL) | |
176 && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL | |
177 || !id->transform_return_to_modify)) | |
178 { | |
179 new_tree = make_ssa_name (new_tree, NULL); | |
180 insert_decl_map (id, name, new_tree); | |
181 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree) | |
182 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name); | |
183 TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree)); | |
184 if (gimple_nop_p (SSA_NAME_DEF_STMT (name))) | |
185 { | |
186 /* By inlining function having uninitialized variable, we might | |
187 extend the lifetime (variable might get reused). This cause | |
188 ICE in the case we end up extending lifetime of SSA name across | |
189 abnormal edge, but also increase register pressure. | |
190 | |
191 We simply initialize all uninitialized vars by 0 except | |
192 for case we are inlining to very first BB. We can avoid | |
193 this for all BBs that are not inside strongly connected | |
194 regions of the CFG, but this is expensive to test. */ | |
195 if (id->entry_bb | |
196 && is_gimple_reg (SSA_NAME_VAR (name)) | |
197 && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL | |
198 && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest | |
199 || EDGE_COUNT (id->entry_bb->preds) != 1)) | |
200 { | |
201 gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb); | |
202 gimple init_stmt; | |
203 | |
204 init_stmt = gimple_build_assign (new_tree, | |
205 fold_convert (TREE_TYPE (new_tree), | |
206 integer_zero_node)); | |
207 gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT); | |
208 SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0; | |
209 } | |
210 else | |
211 { | |
212 SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop (); | |
213 if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) | |
214 == name) | |
215 set_default_def (SSA_NAME_VAR (new_tree), new_tree); | |
216 } | |
217 } | |
218 } | |
219 else | |
220 insert_decl_map (id, name, new_tree); | |
221 return new_tree; | |
222 } | |
223 | |
224 /* Remap DECL during the copying of the BLOCK tree for the function. */ | |
225 | |
226 tree | |
227 remap_decl (tree decl, copy_body_data *id) | |
228 { | |
229 tree *n; | |
230 tree fn; | |
231 | |
232 /* We only remap local variables in the current function. */ | |
233 fn = id->src_fn; | |
234 | |
235 /* See if we have remapped this declaration. */ | |
236 | |
237 n = (tree *) pointer_map_contains (id->decl_map, decl); | |
238 | |
239 /* If we didn't already have an equivalent for this declaration, | |
240 create one now. */ | |
241 if (!n) | |
242 { | |
243 /* Make a copy of the variable or label. */ | |
244 tree t = id->copy_decl (decl, id); | |
245 | |
246 /* Remember it, so that if we encounter this local entity again | |
247 we can reuse this copy. Do this early because remap_type may | |
248 need this decl for TYPE_STUB_DECL. */ | |
249 insert_decl_map (id, decl, t); | |
250 | |
251 if (!DECL_P (t)) | |
252 return t; | |
253 | |
254 /* Remap types, if necessary. */ | |
255 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id); | |
256 if (TREE_CODE (t) == TYPE_DECL) | |
257 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id); | |
258 | |
259 /* Remap sizes as necessary. */ | |
260 walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL); | |
261 walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL); | |
262 | |
263 /* If fields, do likewise for offset and qualifier. */ | |
264 if (TREE_CODE (t) == FIELD_DECL) | |
265 { | |
266 walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL); | |
267 if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE) | |
268 walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL); | |
269 } | |
270 | |
271 if (cfun && gimple_in_ssa_p (cfun) | |
272 && (TREE_CODE (t) == VAR_DECL | |
273 || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL)) | |
274 { | |
275 tree def = gimple_default_def (id->src_cfun, decl); | |
276 get_var_ann (t); | |
277 if (TREE_CODE (decl) != PARM_DECL && def) | |
278 { | |
279 tree map = remap_ssa_name (def, id); | |
280 /* Watch out RESULT_DECLs whose SSA names map directly | |
281 to them. */ | |
282 if (TREE_CODE (map) == SSA_NAME | |
283 && gimple_nop_p (SSA_NAME_DEF_STMT (map))) | |
284 set_default_def (t, map); | |
285 } | |
286 add_referenced_var (t); | |
287 } | |
288 return t; | |
289 } | |
290 | |
291 return unshare_expr (*n); | |
292 } | |
293 | |
294 static tree | |
295 remap_type_1 (tree type, copy_body_data *id) | |
296 { | |
297 tree new_tree, t; | |
298 | |
299 /* We do need a copy. build and register it now. If this is a pointer or | |
300 reference type, remap the designated type and make a new pointer or | |
301 reference type. */ | |
302 if (TREE_CODE (type) == POINTER_TYPE) | |
303 { | |
304 new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id), | |
305 TYPE_MODE (type), | |
306 TYPE_REF_CAN_ALIAS_ALL (type)); | |
307 insert_decl_map (id, type, new_tree); | |
308 return new_tree; | |
309 } | |
310 else if (TREE_CODE (type) == REFERENCE_TYPE) | |
311 { | |
312 new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id), | |
313 TYPE_MODE (type), | |
314 TYPE_REF_CAN_ALIAS_ALL (type)); | |
315 insert_decl_map (id, type, new_tree); | |
316 return new_tree; | |
317 } | |
318 else | |
319 new_tree = copy_node (type); | |
320 | |
321 insert_decl_map (id, type, new_tree); | |
322 | |
323 /* This is a new type, not a copy of an old type. Need to reassociate | |
324 variants. We can handle everything except the main variant lazily. */ | |
325 t = TYPE_MAIN_VARIANT (type); | |
326 if (type != t) | |
327 { | |
328 t = remap_type (t, id); | |
329 TYPE_MAIN_VARIANT (new_tree) = t; | |
330 TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t); | |
331 TYPE_NEXT_VARIANT (t) = new_tree; | |
332 } | |
333 else | |
334 { | |
335 TYPE_MAIN_VARIANT (new_tree) = new_tree; | |
336 TYPE_NEXT_VARIANT (new_tree) = NULL; | |
337 } | |
338 | |
339 if (TYPE_STUB_DECL (type)) | |
340 TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id); | |
341 | |
342 /* Lazily create pointer and reference types. */ | |
343 TYPE_POINTER_TO (new_tree) = NULL; | |
344 TYPE_REFERENCE_TO (new_tree) = NULL; | |
345 | |
346 switch (TREE_CODE (new_tree)) | |
347 { | |
348 case INTEGER_TYPE: | |
349 case REAL_TYPE: | |
350 case FIXED_POINT_TYPE: | |
351 case ENUMERAL_TYPE: | |
352 case BOOLEAN_TYPE: | |
353 t = TYPE_MIN_VALUE (new_tree); | |
354 if (t && TREE_CODE (t) != INTEGER_CST) | |
355 walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL); | |
356 | |
357 t = TYPE_MAX_VALUE (new_tree); | |
358 if (t && TREE_CODE (t) != INTEGER_CST) | |
359 walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL); | |
360 return new_tree; | |
361 | |
362 case FUNCTION_TYPE: | |
363 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id); | |
364 walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL); | |
365 return new_tree; | |
366 | |
367 case ARRAY_TYPE: | |
368 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id); | |
369 TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id); | |
370 break; | |
371 | |
372 case RECORD_TYPE: | |
373 case UNION_TYPE: | |
374 case QUAL_UNION_TYPE: | |
375 { | |
376 tree f, nf = NULL; | |
377 | |
378 for (f = TYPE_FIELDS (new_tree); f ; f = TREE_CHAIN (f)) | |
379 { | |
380 t = remap_decl (f, id); | |
381 DECL_CONTEXT (t) = new_tree; | |
382 TREE_CHAIN (t) = nf; | |
383 nf = t; | |
384 } | |
385 TYPE_FIELDS (new_tree) = nreverse (nf); | |
386 } | |
387 break; | |
388 | |
389 case OFFSET_TYPE: | |
390 default: | |
391 /* Shouldn't have been thought variable sized. */ | |
392 gcc_unreachable (); | |
393 } | |
394 | |
395 walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL); | |
396 walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL); | |
397 | |
398 return new_tree; | |
399 } | |
400 | |
401 tree | |
402 remap_type (tree type, copy_body_data *id) | |
403 { | |
404 tree *node; | |
405 tree tmp; | |
406 | |
407 if (type == NULL) | |
408 return type; | |
409 | |
410 /* See if we have remapped this type. */ | |
411 node = (tree *) pointer_map_contains (id->decl_map, type); | |
412 if (node) | |
413 return *node; | |
414 | |
415 /* The type only needs remapping if it's variably modified. */ | |
416 if (! variably_modified_type_p (type, id->src_fn)) | |
417 { | |
418 insert_decl_map (id, type, type); | |
419 return type; | |
420 } | |
421 | |
422 id->remapping_type_depth++; | |
423 tmp = remap_type_1 (type, id); | |
424 id->remapping_type_depth--; | |
425 | |
426 return tmp; | |
427 } | |
428 | |
429 /* Return previously remapped type of TYPE in ID. Return NULL if TYPE | |
430 is NULL or TYPE has not been remapped before. */ | |
431 | |
432 static tree | |
433 remapped_type (tree type, copy_body_data *id) | |
434 { | |
435 tree *node; | |
436 | |
437 if (type == NULL) | |
438 return type; | |
439 | |
440 /* See if we have remapped this type. */ | |
441 node = (tree *) pointer_map_contains (id->decl_map, type); | |
442 if (node) | |
443 return *node; | |
444 else | |
445 return NULL; | |
446 } | |
447 | |
448 /* The type only needs remapping if it's variably modified. */ | |
449 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */ | |
450 | |
451 static bool | |
452 can_be_nonlocal (tree decl, copy_body_data *id) | |
453 { | |
454 /* We can not duplicate function decls. */ | |
455 if (TREE_CODE (decl) == FUNCTION_DECL) | |
456 return true; | |
457 | |
458 /* Local static vars must be non-local or we get multiple declaration | |
459 problems. */ | |
460 if (TREE_CODE (decl) == VAR_DECL | |
461 && !auto_var_in_fn_p (decl, id->src_fn)) | |
462 return true; | |
463 | |
464 /* At the moment dwarf2out can handle only these types of nodes. We | |
465 can support more later. */ | |
466 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL) | |
467 return false; | |
468 | |
469 /* We must use global type. We call remapped_type instead of | |
470 remap_type since we don't want to remap this type here if it | |
471 hasn't been remapped before. */ | |
472 if (TREE_TYPE (decl) != remapped_type (TREE_TYPE (decl), id)) | |
473 return false; | |
474 | |
475 /* Wihtout SSA we can't tell if variable is used. */ | |
476 if (!gimple_in_ssa_p (cfun)) | |
477 return false; | |
478 | |
479 /* Live variables must be copied so we can attach DECL_RTL. */ | |
480 if (var_ann (decl)) | |
481 return false; | |
482 | |
483 return true; | |
484 } | |
485 | |
486 static tree | |
487 remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id) | |
488 { | |
489 tree old_var; | |
490 tree new_decls = NULL_TREE; | |
491 | |
492 /* Remap its variables. */ | |
493 for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var)) | |
494 { | |
495 tree new_var; | |
496 tree origin_var = DECL_ORIGIN (old_var); | |
497 | |
498 if (can_be_nonlocal (old_var, id)) | |
499 { | |
500 if (TREE_CODE (old_var) == VAR_DECL | |
501 && (var_ann (old_var) || !gimple_in_ssa_p (cfun))) | |
502 cfun->local_decls = tree_cons (NULL_TREE, old_var, | |
503 cfun->local_decls); | |
504 if (debug_info_level > DINFO_LEVEL_TERSE | |
505 && !DECL_IGNORED_P (old_var) | |
506 && nonlocalized_list) | |
507 VEC_safe_push (tree, gc, *nonlocalized_list, origin_var); | |
508 continue; | |
509 } | |
510 | |
511 /* Remap the variable. */ | |
512 new_var = remap_decl (old_var, id); | |
513 | |
514 /* If we didn't remap this variable, we can't mess with its | |
515 TREE_CHAIN. If we remapped this variable to the return slot, it's | |
516 already declared somewhere else, so don't declare it here. */ | |
517 | |
518 if (new_var == id->retvar) | |
519 ; | |
520 else if (!new_var) | |
521 { | |
522 if (debug_info_level > DINFO_LEVEL_TERSE | |
523 && !DECL_IGNORED_P (old_var) | |
524 && nonlocalized_list) | |
525 VEC_safe_push (tree, gc, *nonlocalized_list, origin_var); | |
526 } | |
527 else | |
528 { | |
529 gcc_assert (DECL_P (new_var)); | |
530 TREE_CHAIN (new_var) = new_decls; | |
531 new_decls = new_var; | |
532 } | |
533 } | |
534 | |
535 return nreverse (new_decls); | |
536 } | |
537 | |
538 /* Copy the BLOCK to contain remapped versions of the variables | |
539 therein. And hook the new block into the block-tree. */ | |
540 | |
541 static void | |
542 remap_block (tree *block, copy_body_data *id) | |
543 { | |
544 tree old_block; | |
545 tree new_block; | |
546 tree fn; | |
547 | |
548 /* Make the new block. */ | |
549 old_block = *block; | |
550 new_block = make_node (BLOCK); | |
551 TREE_USED (new_block) = TREE_USED (old_block); | |
552 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block; | |
553 BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block); | |
554 BLOCK_NONLOCALIZED_VARS (new_block) | |
555 = VEC_copy (tree, gc, BLOCK_NONLOCALIZED_VARS (old_block)); | |
556 *block = new_block; | |
557 | |
558 /* Remap its variables. */ | |
559 BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), | |
560 &BLOCK_NONLOCALIZED_VARS (new_block), | |
561 id); | |
562 | |
563 fn = id->dst_fn; | |
564 | |
565 if (id->transform_lang_insert_block) | |
566 id->transform_lang_insert_block (new_block); | |
567 | |
568 /* Remember the remapped block. */ | |
569 insert_decl_map (id, old_block, new_block); | |
570 } | |
571 | |
572 /* Copy the whole block tree and root it in id->block. */ | |
573 static tree | |
574 remap_blocks (tree block, copy_body_data *id) | |
575 { | |
576 tree t; | |
577 tree new_tree = block; | |
578 | |
579 if (!block) | |
580 return NULL; | |
581 | |
582 remap_block (&new_tree, id); | |
583 gcc_assert (new_tree != block); | |
584 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t)) | |
585 prepend_lexical_block (new_tree, remap_blocks (t, id)); | |
586 /* Blocks are in arbitrary order, but make things slightly prettier and do | |
587 not swap order when producing a copy. */ | |
588 BLOCK_SUBBLOCKS (new_tree) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree)); | |
589 return new_tree; | |
590 } | |
591 | |
592 static void | |
593 copy_statement_list (tree *tp) | |
594 { | |
595 tree_stmt_iterator oi, ni; | |
596 tree new_tree; | |
597 | |
598 new_tree = alloc_stmt_list (); | |
599 ni = tsi_start (new_tree); | |
600 oi = tsi_start (*tp); | |
601 *tp = new_tree; | |
602 | |
603 for (; !tsi_end_p (oi); tsi_next (&oi)) | |
604 tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT); | |
605 } | |
606 | |
607 static void | |
608 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id) | |
609 { | |
610 tree block = BIND_EXPR_BLOCK (*tp); | |
611 /* Copy (and replace) the statement. */ | |
612 copy_tree_r (tp, walk_subtrees, NULL); | |
613 if (block) | |
614 { | |
615 remap_block (&block, id); | |
616 BIND_EXPR_BLOCK (*tp) = block; | |
617 } | |
618 | |
619 if (BIND_EXPR_VARS (*tp)) | |
620 /* This will remap a lot of the same decls again, but this should be | |
621 harmless. */ | |
622 BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id); | |
623 } | |
624 | |
625 | |
626 /* Create a new gimple_seq by remapping all the statements in BODY | |
627 using the inlining information in ID. */ | |
628 | |
629 gimple_seq | |
630 remap_gimple_seq (gimple_seq body, copy_body_data *id) | |
631 { | |
632 gimple_stmt_iterator si; | |
633 gimple_seq new_body = NULL; | |
634 | |
635 for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si)) | |
636 { | |
637 gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id); | |
638 gimple_seq_add_stmt (&new_body, new_stmt); | |
639 } | |
640 | |
641 return new_body; | |
642 } | |
643 | |
644 | |
645 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its | |
646 block using the mapping information in ID. */ | |
647 | |
648 static gimple | |
649 copy_gimple_bind (gimple stmt, copy_body_data *id) | |
650 { | |
651 gimple new_bind; | |
652 tree new_block, new_vars; | |
653 gimple_seq body, new_body; | |
654 | |
655 /* Copy the statement. Note that we purposely don't use copy_stmt | |
656 here because we need to remap statements as we copy. */ | |
657 body = gimple_bind_body (stmt); | |
658 new_body = remap_gimple_seq (body, id); | |
659 | |
660 new_block = gimple_bind_block (stmt); | |
661 if (new_block) | |
662 remap_block (&new_block, id); | |
663 | |
664 /* This will remap a lot of the same decls again, but this should be | |
665 harmless. */ | |
666 new_vars = gimple_bind_vars (stmt); | |
667 if (new_vars) | |
668 new_vars = remap_decls (new_vars, NULL, id); | |
669 | |
670 new_bind = gimple_build_bind (new_vars, new_body, new_block); | |
671 | |
672 return new_bind; | |
673 } | |
674 | |
675 | |
676 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a | |
677 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'. | |
678 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep | |
679 recursing into the children nodes of *TP. */ | |
680 | |
681 static tree | |
682 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data) | |
683 { | |
684 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data; | |
685 copy_body_data *id = (copy_body_data *) wi_p->info; | |
686 tree fn = id->src_fn; | |
687 | |
688 if (TREE_CODE (*tp) == SSA_NAME) | |
689 { | |
690 *tp = remap_ssa_name (*tp, id); | |
691 *walk_subtrees = 0; | |
692 return NULL; | |
693 } | |
694 else if (auto_var_in_fn_p (*tp, fn)) | |
695 { | |
696 /* Local variables and labels need to be replaced by equivalent | |
697 variables. We don't want to copy static variables; there's | |
698 only one of those, no matter how many times we inline the | |
699 containing function. Similarly for globals from an outer | |
700 function. */ | |
701 tree new_decl; | |
702 | |
703 /* Remap the declaration. */ | |
704 new_decl = remap_decl (*tp, id); | |
705 gcc_assert (new_decl); | |
706 /* Replace this variable with the copy. */ | |
707 STRIP_TYPE_NOPS (new_decl); | |
708 *tp = new_decl; | |
709 *walk_subtrees = 0; | |
710 } | |
711 else if (TREE_CODE (*tp) == STATEMENT_LIST) | |
712 gcc_unreachable (); | |
713 else if (TREE_CODE (*tp) == SAVE_EXPR) | |
714 gcc_unreachable (); | |
715 else if (TREE_CODE (*tp) == LABEL_DECL | |
716 && (!DECL_CONTEXT (*tp) | |
717 || decl_function_context (*tp) == id->src_fn)) | |
718 /* These may need to be remapped for EH handling. */ | |
719 *tp = remap_decl (*tp, id); | |
720 else if (TYPE_P (*tp)) | |
721 /* Types may need remapping as well. */ | |
722 *tp = remap_type (*tp, id); | |
723 else if (CONSTANT_CLASS_P (*tp)) | |
724 { | |
725 /* If this is a constant, we have to copy the node iff the type | |
726 will be remapped. copy_tree_r will not copy a constant. */ | |
727 tree new_type = remap_type (TREE_TYPE (*tp), id); | |
728 | |
729 if (new_type == TREE_TYPE (*tp)) | |
730 *walk_subtrees = 0; | |
731 | |
732 else if (TREE_CODE (*tp) == INTEGER_CST) | |
733 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp), | |
734 TREE_INT_CST_HIGH (*tp)); | |
735 else | |
736 { | |
737 *tp = copy_node (*tp); | |
738 TREE_TYPE (*tp) = new_type; | |
739 } | |
740 } | |
741 else | |
742 { | |
743 /* Otherwise, just copy the node. Note that copy_tree_r already | |
744 knows not to copy VAR_DECLs, etc., so this is safe. */ | |
745 if (TREE_CODE (*tp) == INDIRECT_REF) | |
746 { | |
747 /* Get rid of *& from inline substitutions that can happen when a | |
748 pointer argument is an ADDR_EXPR. */ | |
749 tree decl = TREE_OPERAND (*tp, 0); | |
750 tree *n; | |
751 | |
752 n = (tree *) pointer_map_contains (id->decl_map, decl); | |
753 if (n) | |
754 { | |
755 tree type, new_tree, old; | |
756 | |
757 /* If we happen to get an ADDR_EXPR in n->value, strip | |
758 it manually here as we'll eventually get ADDR_EXPRs | |
759 which lie about their types pointed to. In this case | |
760 build_fold_indirect_ref wouldn't strip the | |
761 INDIRECT_REF, but we absolutely rely on that. As | |
762 fold_indirect_ref does other useful transformations, | |
763 try that first, though. */ | |
764 type = TREE_TYPE (TREE_TYPE (*n)); | |
765 new_tree = unshare_expr (*n); | |
766 old = *tp; | |
767 *tp = gimple_fold_indirect_ref (new_tree); | |
768 if (!*tp) | |
769 { | |
770 if (TREE_CODE (new_tree) == ADDR_EXPR) | |
771 { | |
772 *tp = fold_indirect_ref_1 (type, new_tree); | |
773 /* ??? We should either assert here or build | |
774 a VIEW_CONVERT_EXPR instead of blindly leaking | |
775 incompatible types to our IL. */ | |
776 if (! *tp) | |
777 *tp = TREE_OPERAND (new_tree, 0); | |
778 } | |
779 else | |
780 { | |
781 *tp = build1 (INDIRECT_REF, type, new_tree); | |
782 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); | |
783 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old); | |
784 } | |
785 } | |
786 *walk_subtrees = 0; | |
787 return NULL; | |
788 } | |
789 } | |
790 | |
791 /* Here is the "usual case". Copy this tree node, and then | |
792 tweak some special cases. */ | |
793 copy_tree_r (tp, walk_subtrees, NULL); | |
794 | |
795 /* Global variables we haven't seen yet need to go into referenced | |
796 vars. If not referenced from types only. */ | |
797 if (gimple_in_ssa_p (cfun) | |
798 && TREE_CODE (*tp) == VAR_DECL | |
799 && id->remapping_type_depth == 0) | |
800 add_referenced_var (*tp); | |
801 | |
802 /* We should never have TREE_BLOCK set on non-statements. */ | |
803 if (EXPR_P (*tp)) | |
804 gcc_assert (!TREE_BLOCK (*tp)); | |
805 | |
806 if (TREE_CODE (*tp) != OMP_CLAUSE) | |
807 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id); | |
808 | |
809 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3)) | |
810 { | |
811 /* The copied TARGET_EXPR has never been expanded, even if the | |
812 original node was expanded already. */ | |
813 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3); | |
814 TREE_OPERAND (*tp, 3) = NULL_TREE; | |
815 } | |
816 else if (TREE_CODE (*tp) == ADDR_EXPR) | |
817 { | |
818 /* Variable substitution need not be simple. In particular, | |
819 the INDIRECT_REF substitution above. Make sure that | |
820 TREE_CONSTANT and friends are up-to-date. But make sure | |
821 to not improperly set TREE_BLOCK on some sub-expressions. */ | |
822 int invariant = is_gimple_min_invariant (*tp); | |
823 tree block = id->block; | |
824 id->block = NULL_TREE; | |
825 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL); | |
826 id->block = block; | |
827 | |
828 /* Handle the case where we substituted an INDIRECT_REF | |
829 into the operand of the ADDR_EXPR. */ | |
830 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF) | |
831 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0); | |
832 else | |
833 recompute_tree_invariant_for_addr_expr (*tp); | |
834 | |
835 /* If this used to be invariant, but is not any longer, | |
836 then regimplification is probably needed. */ | |
837 if (invariant && !is_gimple_min_invariant (*tp)) | |
838 id->regimplify = true; | |
839 | |
840 *walk_subtrees = 0; | |
841 } | |
842 } | |
843 | |
844 /* Keep iterating. */ | |
845 return NULL_TREE; | |
846 } | |
847 | |
848 | |
849 /* Called from copy_body_id via walk_tree. DATA is really a | |
850 `copy_body_data *'. */ | |
851 | |
852 tree | |
853 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data) | |
854 { | |
855 copy_body_data *id = (copy_body_data *) data; | |
856 tree fn = id->src_fn; | |
857 tree new_block; | |
858 | |
859 /* Begin by recognizing trees that we'll completely rewrite for the | |
860 inlining context. Our output for these trees is completely | |
861 different from out input (e.g. RETURN_EXPR is deleted, and morphs | |
862 into an edge). Further down, we'll handle trees that get | |
863 duplicated and/or tweaked. */ | |
864 | |
865 /* When requested, RETURN_EXPRs should be transformed to just the | |
866 contained MODIFY_EXPR. The branch semantics of the return will | |
867 be handled elsewhere by manipulating the CFG rather than a statement. */ | |
868 if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify) | |
869 { | |
870 tree assignment = TREE_OPERAND (*tp, 0); | |
871 | |
872 /* If we're returning something, just turn that into an | |
873 assignment into the equivalent of the original RESULT_DECL. | |
874 If the "assignment" is just the result decl, the result | |
875 decl has already been set (e.g. a recent "foo (&result_decl, | |
876 ...)"); just toss the entire RETURN_EXPR. */ | |
877 if (assignment && TREE_CODE (assignment) == MODIFY_EXPR) | |
878 { | |
879 /* Replace the RETURN_EXPR with (a copy of) the | |
880 MODIFY_EXPR hanging underneath. */ | |
881 *tp = copy_node (assignment); | |
882 } | |
883 else /* Else the RETURN_EXPR returns no value. */ | |
884 { | |
885 *tp = NULL; | |
886 return (tree) (void *)1; | |
887 } | |
888 } | |
889 else if (TREE_CODE (*tp) == SSA_NAME) | |
890 { | |
891 *tp = remap_ssa_name (*tp, id); | |
892 *walk_subtrees = 0; | |
893 return NULL; | |
894 } | |
895 | |
896 /* Local variables and labels need to be replaced by equivalent | |
897 variables. We don't want to copy static variables; there's only | |
898 one of those, no matter how many times we inline the containing | |
899 function. Similarly for globals from an outer function. */ | |
900 else if (auto_var_in_fn_p (*tp, fn)) | |
901 { | |
902 tree new_decl; | |
903 | |
904 /* Remap the declaration. */ | |
905 new_decl = remap_decl (*tp, id); | |
906 gcc_assert (new_decl); | |
907 /* Replace this variable with the copy. */ | |
908 STRIP_TYPE_NOPS (new_decl); | |
909 *tp = new_decl; | |
910 *walk_subtrees = 0; | |
911 } | |
912 else if (TREE_CODE (*tp) == STATEMENT_LIST) | |
913 copy_statement_list (tp); | |
914 else if (TREE_CODE (*tp) == SAVE_EXPR) | |
915 remap_save_expr (tp, id->decl_map, walk_subtrees); | |
916 else if (TREE_CODE (*tp) == LABEL_DECL | |
917 && (! DECL_CONTEXT (*tp) | |
918 || decl_function_context (*tp) == id->src_fn)) | |
919 /* These may need to be remapped for EH handling. */ | |
920 *tp = remap_decl (*tp, id); | |
921 else if (TREE_CODE (*tp) == BIND_EXPR) | |
922 copy_bind_expr (tp, walk_subtrees, id); | |
923 /* Types may need remapping as well. */ | |
924 else if (TYPE_P (*tp)) | |
925 *tp = remap_type (*tp, id); | |
926 | |
927 /* If this is a constant, we have to copy the node iff the type will be | |
928 remapped. copy_tree_r will not copy a constant. */ | |
929 else if (CONSTANT_CLASS_P (*tp)) | |
930 { | |
931 tree new_type = remap_type (TREE_TYPE (*tp), id); | |
932 | |
933 if (new_type == TREE_TYPE (*tp)) | |
934 *walk_subtrees = 0; | |
935 | |
936 else if (TREE_CODE (*tp) == INTEGER_CST) | |
937 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp), | |
938 TREE_INT_CST_HIGH (*tp)); | |
939 else | |
940 { | |
941 *tp = copy_node (*tp); | |
942 TREE_TYPE (*tp) = new_type; | |
943 } | |
944 } | |
945 | |
946 /* Otherwise, just copy the node. Note that copy_tree_r already | |
947 knows not to copy VAR_DECLs, etc., so this is safe. */ | |
948 else | |
949 { | |
950 /* Here we handle trees that are not completely rewritten. | |
951 First we detect some inlining-induced bogosities for | |
952 discarding. */ | |
953 if (TREE_CODE (*tp) == MODIFY_EXPR | |
954 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1) | |
955 && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn))) | |
956 { | |
957 /* Some assignments VAR = VAR; don't generate any rtl code | |
958 and thus don't count as variable modification. Avoid | |
959 keeping bogosities like 0 = 0. */ | |
960 tree decl = TREE_OPERAND (*tp, 0), value; | |
961 tree *n; | |
962 | |
963 n = (tree *) pointer_map_contains (id->decl_map, decl); | |
964 if (n) | |
965 { | |
966 value = *n; | |
967 STRIP_TYPE_NOPS (value); | |
968 if (TREE_CONSTANT (value) || TREE_READONLY (value)) | |
969 { | |
970 *tp = build_empty_stmt (); | |
971 return copy_tree_body_r (tp, walk_subtrees, data); | |
972 } | |
973 } | |
974 } | |
975 else if (TREE_CODE (*tp) == INDIRECT_REF) | |
976 { | |
977 /* Get rid of *& from inline substitutions that can happen when a | |
978 pointer argument is an ADDR_EXPR. */ | |
979 tree decl = TREE_OPERAND (*tp, 0); | |
980 tree *n; | |
981 | |
982 n = (tree *) pointer_map_contains (id->decl_map, decl); | |
983 if (n) | |
984 { | |
985 tree new_tree; | |
986 tree old; | |
987 /* If we happen to get an ADDR_EXPR in n->value, strip | |
988 it manually here as we'll eventually get ADDR_EXPRs | |
989 which lie about their types pointed to. In this case | |
990 build_fold_indirect_ref wouldn't strip the INDIRECT_REF, | |
991 but we absolutely rely on that. As fold_indirect_ref | |
992 does other useful transformations, try that first, though. */ | |
993 tree type = TREE_TYPE (TREE_TYPE (*n)); | |
994 new_tree = unshare_expr (*n); | |
995 old = *tp; | |
996 *tp = gimple_fold_indirect_ref (new_tree); | |
997 if (! *tp) | |
998 { | |
999 if (TREE_CODE (new_tree) == ADDR_EXPR) | |
1000 { | |
1001 *tp = fold_indirect_ref_1 (type, new_tree); | |
1002 /* ??? We should either assert here or build | |
1003 a VIEW_CONVERT_EXPR instead of blindly leaking | |
1004 incompatible types to our IL. */ | |
1005 if (! *tp) | |
1006 *tp = TREE_OPERAND (new_tree, 0); | |
1007 } | |
1008 else | |
1009 { | |
1010 *tp = build1 (INDIRECT_REF, type, new_tree); | |
1011 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); | |
1012 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old); | |
1013 } | |
1014 } | |
1015 *walk_subtrees = 0; | |
1016 return NULL; | |
1017 } | |
1018 } | |
1019 | |
1020 /* Here is the "usual case". Copy this tree node, and then | |
1021 tweak some special cases. */ | |
1022 copy_tree_r (tp, walk_subtrees, NULL); | |
1023 | |
1024 /* Global variables we haven't seen yet needs to go into referenced | |
1025 vars. If not referenced from types only. */ | |
1026 if (gimple_in_ssa_p (cfun) | |
1027 && TREE_CODE (*tp) == VAR_DECL | |
1028 && id->remapping_type_depth == 0) | |
1029 add_referenced_var (*tp); | |
1030 | |
1031 /* If EXPR has block defined, map it to newly constructed block. | |
1032 When inlining we want EXPRs without block appear in the block | |
1033 of function call. */ | |
1034 if (EXPR_P (*tp)) | |
1035 { | |
1036 new_block = id->block; | |
1037 if (TREE_BLOCK (*tp)) | |
1038 { | |
1039 tree *n; | |
1040 n = (tree *) pointer_map_contains (id->decl_map, | |
1041 TREE_BLOCK (*tp)); | |
1042 gcc_assert (n); | |
1043 new_block = *n; | |
1044 } | |
1045 TREE_BLOCK (*tp) = new_block; | |
1046 } | |
1047 | |
1048 if (TREE_CODE (*tp) == RESX_EXPR && id->eh_region_offset) | |
1049 TREE_OPERAND (*tp, 0) = | |
1050 build_int_cst (NULL_TREE, | |
1051 id->eh_region_offset | |
1052 + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0))); | |
1053 | |
1054 if (TREE_CODE (*tp) != OMP_CLAUSE) | |
1055 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id); | |
1056 | |
1057 /* The copied TARGET_EXPR has never been expanded, even if the | |
1058 original node was expanded already. */ | |
1059 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3)) | |
1060 { | |
1061 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3); | |
1062 TREE_OPERAND (*tp, 3) = NULL_TREE; | |
1063 } | |
1064 | |
1065 /* Variable substitution need not be simple. In particular, the | |
1066 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT | |
1067 and friends are up-to-date. */ | |
1068 else if (TREE_CODE (*tp) == ADDR_EXPR) | |
1069 { | |
1070 int invariant = is_gimple_min_invariant (*tp); | |
1071 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL); | |
1072 | |
1073 /* Handle the case where we substituted an INDIRECT_REF | |
1074 into the operand of the ADDR_EXPR. */ | |
1075 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF) | |
1076 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0); | |
1077 else | |
1078 recompute_tree_invariant_for_addr_expr (*tp); | |
1079 | |
1080 /* If this used to be invariant, but is not any longer, | |
1081 then regimplification is probably needed. */ | |
1082 if (invariant && !is_gimple_min_invariant (*tp)) | |
1083 id->regimplify = true; | |
1084 | |
1085 *walk_subtrees = 0; | |
1086 } | |
1087 } | |
1088 | |
1089 /* Keep iterating. */ | |
1090 return NULL_TREE; | |
1091 } | |
1092 | |
1093 | |
1094 /* Helper for copy_bb. Remap statement STMT using the inlining | |
1095 information in ID. Return the new statement copy. */ | |
1096 | |
1097 static gimple | |
1098 remap_gimple_stmt (gimple stmt, copy_body_data *id) | |
1099 { | |
1100 gimple copy = NULL; | |
1101 struct walk_stmt_info wi; | |
1102 tree new_block; | |
1103 bool skip_first = false; | |
1104 | |
1105 /* Begin by recognizing trees that we'll completely rewrite for the | |
1106 inlining context. Our output for these trees is completely | |
1107 different from out input (e.g. RETURN_EXPR is deleted, and morphs | |
1108 into an edge). Further down, we'll handle trees that get | |
1109 duplicated and/or tweaked. */ | |
1110 | |
1111 /* When requested, GIMPLE_RETURNs should be transformed to just the | |
1112 contained GIMPLE_ASSIGN. The branch semantics of the return will | |
1113 be handled elsewhere by manipulating the CFG rather than the | |
1114 statement. */ | |
1115 if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify) | |
1116 { | |
1117 tree retval = gimple_return_retval (stmt); | |
1118 | |
1119 /* If we're returning something, just turn that into an | |
1120 assignment into the equivalent of the original RESULT_DECL. | |
1121 If RETVAL is just the result decl, the result decl has | |
1122 already been set (e.g. a recent "foo (&result_decl, ...)"); | |
1123 just toss the entire GIMPLE_RETURN. */ | |
1124 if (retval && TREE_CODE (retval) != RESULT_DECL) | |
1125 { | |
1126 copy = gimple_build_assign (id->retvar, retval); | |
1127 /* id->retvar is already substituted. Skip it on later remapping. */ | |
1128 skip_first = true; | |
1129 } | |
1130 else | |
1131 return gimple_build_nop (); | |
1132 } | |
1133 else if (gimple_has_substatements (stmt)) | |
1134 { | |
1135 gimple_seq s1, s2; | |
1136 | |
1137 /* When cloning bodies from the C++ front end, we will be handed bodies | |
1138 in High GIMPLE form. Handle here all the High GIMPLE statements that | |
1139 have embedded statements. */ | |
1140 switch (gimple_code (stmt)) | |
1141 { | |
1142 case GIMPLE_BIND: | |
1143 copy = copy_gimple_bind (stmt, id); | |
1144 break; | |
1145 | |
1146 case GIMPLE_CATCH: | |
1147 s1 = remap_gimple_seq (gimple_catch_handler (stmt), id); | |
1148 copy = gimple_build_catch (gimple_catch_types (stmt), s1); | |
1149 break; | |
1150 | |
1151 case GIMPLE_EH_FILTER: | |
1152 s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id); | |
1153 copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1); | |
1154 break; | |
1155 | |
1156 case GIMPLE_TRY: | |
1157 s1 = remap_gimple_seq (gimple_try_eval (stmt), id); | |
1158 s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id); | |
1159 copy = gimple_build_try (s1, s2, gimple_try_kind (stmt)); | |
1160 break; | |
1161 | |
1162 case GIMPLE_WITH_CLEANUP_EXPR: | |
1163 s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id); | |
1164 copy = gimple_build_wce (s1); | |
1165 break; | |
1166 | |
1167 case GIMPLE_OMP_PARALLEL: | |
1168 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1169 copy = gimple_build_omp_parallel | |
1170 (s1, | |
1171 gimple_omp_parallel_clauses (stmt), | |
1172 gimple_omp_parallel_child_fn (stmt), | |
1173 gimple_omp_parallel_data_arg (stmt)); | |
1174 break; | |
1175 | |
1176 case GIMPLE_OMP_TASK: | |
1177 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1178 copy = gimple_build_omp_task | |
1179 (s1, | |
1180 gimple_omp_task_clauses (stmt), | |
1181 gimple_omp_task_child_fn (stmt), | |
1182 gimple_omp_task_data_arg (stmt), | |
1183 gimple_omp_task_copy_fn (stmt), | |
1184 gimple_omp_task_arg_size (stmt), | |
1185 gimple_omp_task_arg_align (stmt)); | |
1186 break; | |
1187 | |
1188 case GIMPLE_OMP_FOR: | |
1189 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1190 s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id); | |
1191 copy = gimple_build_omp_for (s1, gimple_omp_for_clauses (stmt), | |
1192 gimple_omp_for_collapse (stmt), s2); | |
1193 { | |
1194 size_t i; | |
1195 for (i = 0; i < gimple_omp_for_collapse (stmt); i++) | |
1196 { | |
1197 gimple_omp_for_set_index (copy, i, | |
1198 gimple_omp_for_index (stmt, i)); | |
1199 gimple_omp_for_set_initial (copy, i, | |
1200 gimple_omp_for_initial (stmt, i)); | |
1201 gimple_omp_for_set_final (copy, i, | |
1202 gimple_omp_for_final (stmt, i)); | |
1203 gimple_omp_for_set_incr (copy, i, | |
1204 gimple_omp_for_incr (stmt, i)); | |
1205 gimple_omp_for_set_cond (copy, i, | |
1206 gimple_omp_for_cond (stmt, i)); | |
1207 } | |
1208 } | |
1209 break; | |
1210 | |
1211 case GIMPLE_OMP_MASTER: | |
1212 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1213 copy = gimple_build_omp_master (s1); | |
1214 break; | |
1215 | |
1216 case GIMPLE_OMP_ORDERED: | |
1217 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1218 copy = gimple_build_omp_ordered (s1); | |
1219 break; | |
1220 | |
1221 case GIMPLE_OMP_SECTION: | |
1222 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1223 copy = gimple_build_omp_section (s1); | |
1224 break; | |
1225 | |
1226 case GIMPLE_OMP_SECTIONS: | |
1227 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1228 copy = gimple_build_omp_sections | |
1229 (s1, gimple_omp_sections_clauses (stmt)); | |
1230 break; | |
1231 | |
1232 case GIMPLE_OMP_SINGLE: | |
1233 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1234 copy = gimple_build_omp_single | |
1235 (s1, gimple_omp_single_clauses (stmt)); | |
1236 break; | |
1237 | |
1238 case GIMPLE_OMP_CRITICAL: | |
1239 s1 = remap_gimple_seq (gimple_omp_body (stmt), id); | |
1240 copy | |
1241 = gimple_build_omp_critical (s1, gimple_omp_critical_name (stmt)); | |
1242 break; | |
1243 | |
1244 default: | |
1245 gcc_unreachable (); | |
1246 } | |
1247 } | |
1248 else | |
1249 { | |
1250 if (gimple_assign_copy_p (stmt) | |
1251 && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt) | |
1252 && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn)) | |
1253 { | |
1254 /* Here we handle statements that are not completely rewritten. | |
1255 First we detect some inlining-induced bogosities for | |
1256 discarding. */ | |
1257 | |
1258 /* Some assignments VAR = VAR; don't generate any rtl code | |
1259 and thus don't count as variable modification. Avoid | |
1260 keeping bogosities like 0 = 0. */ | |
1261 tree decl = gimple_assign_lhs (stmt), value; | |
1262 tree *n; | |
1263 | |
1264 n = (tree *) pointer_map_contains (id->decl_map, decl); | |
1265 if (n) | |
1266 { | |
1267 value = *n; | |
1268 STRIP_TYPE_NOPS (value); | |
1269 if (TREE_CONSTANT (value) || TREE_READONLY (value)) | |
1270 return gimple_build_nop (); | |
1271 } | |
1272 } | |
1273 | |
1274 /* Create a new deep copy of the statement. */ | |
1275 copy = gimple_copy (stmt); | |
1276 } | |
1277 | |
1278 /* If STMT has a block defined, map it to the newly constructed | |
1279 block. When inlining we want statements without a block to | |
1280 appear in the block of the function call. */ | |
1281 new_block = id->block; | |
1282 if (gimple_block (copy)) | |
1283 { | |
1284 tree *n; | |
1285 n = (tree *) pointer_map_contains (id->decl_map, gimple_block (copy)); | |
1286 gcc_assert (n); | |
1287 new_block = *n; | |
1288 } | |
1289 | |
1290 gimple_set_block (copy, new_block); | |
1291 | |
1292 /* Remap all the operands in COPY. */ | |
1293 memset (&wi, 0, sizeof (wi)); | |
1294 wi.info = id; | |
1295 if (skip_first) | |
1296 walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL); | |
1297 else | |
1298 walk_gimple_op (copy, remap_gimple_op_r, &wi); | |
1299 | |
1300 /* We have to handle EH region remapping of GIMPLE_RESX specially because | |
1301 the region number is not an operand. */ | |
1302 if (gimple_code (stmt) == GIMPLE_RESX && id->eh_region_offset) | |
1303 { | |
1304 gimple_resx_set_region (copy, gimple_resx_region (stmt) + id->eh_region_offset); | |
1305 } | |
1306 return copy; | |
1307 } | |
1308 | |
1309 | |
1310 /* Copy basic block, scale profile accordingly. Edges will be taken care of | |
1311 later */ | |
1312 | |
1313 static basic_block | |
1314 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, | |
1315 gcov_type count_scale) | |
1316 { | |
1317 gimple_stmt_iterator gsi, copy_gsi, seq_gsi; | |
1318 basic_block copy_basic_block; | |
1319 tree decl; | |
1320 | |
1321 /* create_basic_block() will append every new block to | |
1322 basic_block_info automatically. */ | |
1323 copy_basic_block = create_basic_block (NULL, (void *) 0, | |
1324 (basic_block) bb->prev_bb->aux); | |
1325 copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE; | |
1326 | |
1327 /* We are going to rebuild frequencies from scratch. These values | |
1328 have just small importance to drive canonicalize_loop_headers. */ | |
1329 copy_basic_block->frequency = ((gcov_type)bb->frequency | |
1330 * frequency_scale / REG_BR_PROB_BASE); | |
1331 | |
1332 if (copy_basic_block->frequency > BB_FREQ_MAX) | |
1333 copy_basic_block->frequency = BB_FREQ_MAX; | |
1334 | |
1335 copy_gsi = gsi_start_bb (copy_basic_block); | |
1336 | |
1337 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
1338 { | |
1339 gimple stmt = gsi_stmt (gsi); | |
1340 gimple orig_stmt = stmt; | |
1341 | |
1342 id->regimplify = false; | |
1343 stmt = remap_gimple_stmt (stmt, id); | |
1344 if (gimple_nop_p (stmt)) | |
1345 continue; | |
1346 | |
1347 gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt); | |
1348 seq_gsi = copy_gsi; | |
1349 | |
1350 /* With return slot optimization we can end up with | |
1351 non-gimple (foo *)&this->m, fix that here. */ | |
1352 if (is_gimple_assign (stmt) | |
1353 && gimple_assign_rhs_code (stmt) == NOP_EXPR | |
1354 && !is_gimple_val (gimple_assign_rhs1 (stmt))) | |
1355 { | |
1356 tree new_rhs; | |
1357 new_rhs = force_gimple_operand_gsi (&seq_gsi, | |
1358 gimple_assign_rhs1 (stmt), | |
1359 true, NULL, true, GSI_SAME_STMT); | |
1360 gimple_assign_set_rhs1 (stmt, new_rhs); | |
1361 id->regimplify = false; | |
1362 } | |
1363 | |
1364 gsi_insert_after (&seq_gsi, stmt, GSI_NEW_STMT); | |
1365 | |
1366 if (id->regimplify) | |
1367 gimple_regimplify_operands (stmt, &seq_gsi); | |
1368 | |
1369 /* If copy_basic_block has been empty at the start of this iteration, | |
1370 call gsi_start_bb again to get at the newly added statements. */ | |
1371 if (gsi_end_p (copy_gsi)) | |
1372 copy_gsi = gsi_start_bb (copy_basic_block); | |
1373 else | |
1374 gsi_next (©_gsi); | |
1375 | |
1376 /* Process the new statement. The call to gimple_regimplify_operands | |
1377 possibly turned the statement into multiple statements, we | |
1378 need to process all of them. */ | |
1379 do | |
1380 { | |
1381 stmt = gsi_stmt (copy_gsi); | |
1382 if (is_gimple_call (stmt) | |
1383 && gimple_call_va_arg_pack_p (stmt) | |
1384 && id->gimple_call) | |
1385 { | |
1386 /* __builtin_va_arg_pack () should be replaced by | |
1387 all arguments corresponding to ... in the caller. */ | |
1388 tree p; | |
1389 gimple new_call; | |
1390 VEC(tree, heap) *argarray; | |
1391 size_t nargs = gimple_call_num_args (id->gimple_call); | |
1392 size_t n; | |
1393 | |
1394 for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p)) | |
1395 nargs--; | |
1396 | |
1397 /* Create the new array of arguments. */ | |
1398 n = nargs + gimple_call_num_args (stmt); | |
1399 argarray = VEC_alloc (tree, heap, n); | |
1400 VEC_safe_grow (tree, heap, argarray, n); | |
1401 | |
1402 /* Copy all the arguments before '...' */ | |
1403 memcpy (VEC_address (tree, argarray), | |
1404 gimple_call_arg_ptr (stmt, 0), | |
1405 gimple_call_num_args (stmt) * sizeof (tree)); | |
1406 | |
1407 /* Append the arguments passed in '...' */ | |
1408 memcpy (VEC_address(tree, argarray) + gimple_call_num_args (stmt), | |
1409 gimple_call_arg_ptr (id->gimple_call, 0) | |
1410 + (gimple_call_num_args (id->gimple_call) - nargs), | |
1411 nargs * sizeof (tree)); | |
1412 | |
1413 new_call = gimple_build_call_vec (gimple_call_fn (stmt), | |
1414 argarray); | |
1415 | |
1416 VEC_free (tree, heap, argarray); | |
1417 | |
1418 /* Copy all GIMPLE_CALL flags, location and block, except | |
1419 GF_CALL_VA_ARG_PACK. */ | |
1420 gimple_call_copy_flags (new_call, stmt); | |
1421 gimple_call_set_va_arg_pack (new_call, false); | |
1422 gimple_set_location (new_call, gimple_location (stmt)); | |
1423 gimple_set_block (new_call, gimple_block (stmt)); | |
1424 gimple_call_set_lhs (new_call, gimple_call_lhs (stmt)); | |
1425 | |
1426 gsi_replace (©_gsi, new_call, false); | |
1427 gimple_set_bb (stmt, NULL); | |
1428 stmt = new_call; | |
1429 } | |
1430 else if (is_gimple_call (stmt) | |
1431 && id->gimple_call | |
1432 && (decl = gimple_call_fndecl (stmt)) | |
1433 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL | |
1434 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN) | |
1435 { | |
1436 /* __builtin_va_arg_pack_len () should be replaced by | |
1437 the number of anonymous arguments. */ | |
1438 size_t nargs = gimple_call_num_args (id->gimple_call); | |
1439 tree count, p; | |
1440 gimple new_stmt; | |
1441 | |
1442 for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p)) | |
1443 nargs--; | |
1444 | |
1445 count = build_int_cst (integer_type_node, nargs); | |
1446 new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count); | |
1447 gsi_replace (©_gsi, new_stmt, false); | |
1448 stmt = new_stmt; | |
1449 } | |
1450 | |
1451 /* Statements produced by inlining can be unfolded, especially | |
1452 when we constant propagated some operands. We can't fold | |
1453 them right now for two reasons: | |
1454 1) folding require SSA_NAME_DEF_STMTs to be correct | |
1455 2) we can't change function calls to builtins. | |
1456 So we just mark statement for later folding. We mark | |
1457 all new statements, instead just statements that has changed | |
1458 by some nontrivial substitution so even statements made | |
1459 foldable indirectly are updated. If this turns out to be | |
1460 expensive, copy_body can be told to watch for nontrivial | |
1461 changes. */ | |
1462 if (id->statements_to_fold) | |
1463 pointer_set_insert (id->statements_to_fold, stmt); | |
1464 | |
1465 /* We're duplicating a CALL_EXPR. Find any corresponding | |
1466 callgraph edges and update or duplicate them. */ | |
1467 if (is_gimple_call (stmt)) | |
1468 { | |
1469 struct cgraph_node *node; | |
1470 struct cgraph_edge *edge; | |
1471 int flags; | |
1472 | |
1473 switch (id->transform_call_graph_edges) | |
1474 { | |
1475 case CB_CGE_DUPLICATE: | |
1476 edge = cgraph_edge (id->src_node, orig_stmt); | |
1477 if (edge) | |
1478 cgraph_clone_edge (edge, id->dst_node, stmt, | |
1479 REG_BR_PROB_BASE, 1, | |
1480 edge->frequency, true); | |
1481 break; | |
1482 | |
1483 case CB_CGE_MOVE_CLONES: | |
1484 for (node = id->dst_node->next_clone; | |
1485 node; | |
1486 node = node->next_clone) | |
1487 { | |
1488 edge = cgraph_edge (node, orig_stmt); | |
1489 if (edge) | |
1490 cgraph_set_call_stmt (edge, stmt); | |
1491 } | |
1492 /* FALLTHRU */ | |
1493 | |
1494 case CB_CGE_MOVE: | |
1495 edge = cgraph_edge (id->dst_node, orig_stmt); | |
1496 if (edge) | |
1497 cgraph_set_call_stmt (edge, stmt); | |
1498 break; | |
1499 | |
1500 default: | |
1501 gcc_unreachable (); | |
1502 } | |
1503 | |
1504 flags = gimple_call_flags (stmt); | |
1505 | |
1506 if (flags & ECF_MAY_BE_ALLOCA) | |
1507 cfun->calls_alloca = true; | |
1508 if (flags & ECF_RETURNS_TWICE) | |
1509 cfun->calls_setjmp = true; | |
1510 } | |
1511 | |
1512 /* If you think we can abort here, you are wrong. | |
1513 There is no region 0 in gimple. */ | |
1514 gcc_assert (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) != 0); | |
1515 | |
1516 if (stmt_could_throw_p (stmt) | |
1517 /* When we are cloning for inlining, we are supposed to | |
1518 construct a clone that calls precisely the same functions | |
1519 as original. However IPA optimizers might've proved | |
1520 earlier some function calls as non-trapping that might | |
1521 render some basic blocks dead that might become | |
1522 unreachable. | |
1523 | |
1524 We can't update SSA with unreachable blocks in CFG and thus | |
1525 we prevent the scenario by preserving even the "dead" eh | |
1526 edges until the point they are later removed by | |
1527 fixup_cfg pass. */ | |
1528 || (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES | |
1529 && lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) > 0)) | |
1530 { | |
1531 int region = lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt); | |
1532 | |
1533 /* Add an entry for the copied tree in the EH hashtable. | |
1534 When cloning or versioning, use the hashtable in | |
1535 cfun, and just copy the EH number. When inlining, use the | |
1536 hashtable in the caller, and adjust the region number. */ | |
1537 if (region > 0) | |
1538 add_stmt_to_eh_region (stmt, region + id->eh_region_offset); | |
1539 | |
1540 /* If this tree doesn't have a region associated with it, | |
1541 and there is a "current region," | |
1542 then associate this tree with the current region | |
1543 and add edges associated with this region. */ | |
1544 if (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) <= 0 | |
1545 && id->eh_region > 0 | |
1546 && stmt_could_throw_p (stmt)) | |
1547 add_stmt_to_eh_region (stmt, id->eh_region); | |
1548 } | |
1549 | |
1550 if (gimple_in_ssa_p (cfun)) | |
1551 { | |
1552 ssa_op_iter i; | |
1553 tree def; | |
1554 | |
1555 find_new_referenced_vars (gsi_stmt (copy_gsi)); | |
1556 FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF) | |
1557 if (TREE_CODE (def) == SSA_NAME) | |
1558 SSA_NAME_DEF_STMT (def) = stmt; | |
1559 } | |
1560 | |
1561 gsi_next (©_gsi); | |
1562 } | |
1563 while (!gsi_end_p (copy_gsi)); | |
1564 | |
1565 copy_gsi = gsi_last_bb (copy_basic_block); | |
1566 } | |
1567 | |
1568 return copy_basic_block; | |
1569 } | |
1570 | |
1571 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA | |
1572 form is quite easy, since dominator relationship for old basic blocks does | |
1573 not change. | |
1574 | |
1575 There is however exception where inlining might change dominator relation | |
1576 across EH edges from basic block within inlined functions destinating | |
1577 to landing pads in function we inline into. | |
1578 | |
1579 The function fills in PHI_RESULTs of such PHI nodes if they refer | |
1580 to gimple regs. Otherwise, the function mark PHI_RESULT of such | |
1581 PHI nodes for renaming. For non-gimple regs, renaming is safe: the | |
1582 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be | |
1583 set, and this means that there will be no overlapping live ranges | |
1584 for the underlying symbol. | |
1585 | |
1586 This might change in future if we allow redirecting of EH edges and | |
1587 we might want to change way build CFG pre-inlining to include | |
1588 all the possible edges then. */ | |
1589 static void | |
1590 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb, | |
1591 bool can_throw, bool nonlocal_goto) | |
1592 { | |
1593 edge e; | |
1594 edge_iterator ei; | |
1595 | |
1596 FOR_EACH_EDGE (e, ei, bb->succs) | |
1597 if (!e->dest->aux | |
1598 || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK) | |
1599 { | |
1600 gimple phi; | |
1601 gimple_stmt_iterator si; | |
1602 | |
1603 gcc_assert (e->flags & EDGE_ABNORMAL); | |
1604 | |
1605 if (!nonlocal_goto) | |
1606 gcc_assert (e->flags & EDGE_EH); | |
1607 | |
1608 if (!can_throw) | |
1609 gcc_assert (!(e->flags & EDGE_EH)); | |
1610 | |
1611 for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si)) | |
1612 { | |
1613 edge re; | |
1614 | |
1615 phi = gsi_stmt (si); | |
1616 | |
1617 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */ | |
1618 gcc_assert (!e->dest->aux); | |
1619 | |
1620 gcc_assert (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi))); | |
1621 | |
1622 if (!is_gimple_reg (PHI_RESULT (phi))) | |
1623 { | |
1624 mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi))); | |
1625 continue; | |
1626 } | |
1627 | |
1628 re = find_edge (ret_bb, e->dest); | |
1629 gcc_assert (re); | |
1630 gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL)) | |
1631 == (e->flags & (EDGE_EH | EDGE_ABNORMAL))); | |
1632 | |
1633 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e), | |
1634 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re))); | |
1635 } | |
1636 } | |
1637 } | |
1638 | |
1639 | |
1640 /* Copy edges from BB into its copy constructed earlier, scale profile | |
1641 accordingly. Edges will be taken care of later. Assume aux | |
1642 pointers to point to the copies of each BB. */ | |
1643 | |
1644 static void | |
1645 copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) | |
1646 { | |
1647 basic_block new_bb = (basic_block) bb->aux; | |
1648 edge_iterator ei; | |
1649 edge old_edge; | |
1650 gimple_stmt_iterator si; | |
1651 int flags; | |
1652 | |
1653 /* Use the indices from the original blocks to create edges for the | |
1654 new ones. */ | |
1655 FOR_EACH_EDGE (old_edge, ei, bb->succs) | |
1656 if (!(old_edge->flags & EDGE_EH)) | |
1657 { | |
1658 edge new_edge; | |
1659 | |
1660 flags = old_edge->flags; | |
1661 | |
1662 /* Return edges do get a FALLTHRU flag when the get inlined. */ | |
1663 if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags | |
1664 && old_edge->dest->aux != EXIT_BLOCK_PTR) | |
1665 flags |= EDGE_FALLTHRU; | |
1666 new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags); | |
1667 new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE; | |
1668 new_edge->probability = old_edge->probability; | |
1669 } | |
1670 | |
1671 if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK) | |
1672 return; | |
1673 | |
1674 for (si = gsi_start_bb (new_bb); !gsi_end_p (si);) | |
1675 { | |
1676 gimple copy_stmt; | |
1677 bool can_throw, nonlocal_goto; | |
1678 | |
1679 copy_stmt = gsi_stmt (si); | |
1680 update_stmt (copy_stmt); | |
1681 if (gimple_in_ssa_p (cfun)) | |
1682 mark_symbols_for_renaming (copy_stmt); | |
1683 | |
1684 /* Do this before the possible split_block. */ | |
1685 gsi_next (&si); | |
1686 | |
1687 /* If this tree could throw an exception, there are two | |
1688 cases where we need to add abnormal edge(s): the | |
1689 tree wasn't in a region and there is a "current | |
1690 region" in the caller; or the original tree had | |
1691 EH edges. In both cases split the block after the tree, | |
1692 and add abnormal edge(s) as needed; we need both | |
1693 those from the callee and the caller. | |
1694 We check whether the copy can throw, because the const | |
1695 propagation can change an INDIRECT_REF which throws | |
1696 into a COMPONENT_REF which doesn't. If the copy | |
1697 can throw, the original could also throw. */ | |
1698 can_throw = stmt_can_throw_internal (copy_stmt); | |
1699 nonlocal_goto = stmt_can_make_abnormal_goto (copy_stmt); | |
1700 | |
1701 if (can_throw || nonlocal_goto) | |
1702 { | |
1703 if (!gsi_end_p (si)) | |
1704 /* Note that bb's predecessor edges aren't necessarily | |
1705 right at this point; split_block doesn't care. */ | |
1706 { | |
1707 edge e = split_block (new_bb, copy_stmt); | |
1708 | |
1709 new_bb = e->dest; | |
1710 new_bb->aux = e->src->aux; | |
1711 si = gsi_start_bb (new_bb); | |
1712 } | |
1713 } | |
1714 | |
1715 if (can_throw) | |
1716 make_eh_edges (copy_stmt); | |
1717 | |
1718 if (nonlocal_goto) | |
1719 make_abnormal_goto_edges (gimple_bb (copy_stmt), true); | |
1720 | |
1721 if ((can_throw || nonlocal_goto) | |
1722 && gimple_in_ssa_p (cfun)) | |
1723 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb, | |
1724 can_throw, nonlocal_goto); | |
1725 } | |
1726 } | |
1727 | |
1728 /* Copy the PHIs. All blocks and edges are copied, some blocks | |
1729 was possibly split and new outgoing EH edges inserted. | |
1730 BB points to the block of original function and AUX pointers links | |
1731 the original and newly copied blocks. */ | |
1732 | |
1733 static void | |
1734 copy_phis_for_bb (basic_block bb, copy_body_data *id) | |
1735 { | |
1736 basic_block const new_bb = (basic_block) bb->aux; | |
1737 edge_iterator ei; | |
1738 gimple phi; | |
1739 gimple_stmt_iterator si; | |
1740 | |
1741 for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si)) | |
1742 { | |
1743 tree res, new_res; | |
1744 gimple new_phi; | |
1745 edge new_edge; | |
1746 | |
1747 phi = gsi_stmt (si); | |
1748 res = PHI_RESULT (phi); | |
1749 new_res = res; | |
1750 if (is_gimple_reg (res)) | |
1751 { | |
1752 walk_tree (&new_res, copy_tree_body_r, id, NULL); | |
1753 SSA_NAME_DEF_STMT (new_res) | |
1754 = new_phi = create_phi_node (new_res, new_bb); | |
1755 FOR_EACH_EDGE (new_edge, ei, new_bb->preds) | |
1756 { | |
1757 edge const old_edge | |
1758 = find_edge ((basic_block) new_edge->src->aux, bb); | |
1759 tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge); | |
1760 tree new_arg = arg; | |
1761 tree block = id->block; | |
1762 id->block = NULL_TREE; | |
1763 walk_tree (&new_arg, copy_tree_body_r, id, NULL); | |
1764 id->block = block; | |
1765 gcc_assert (new_arg); | |
1766 /* With return slot optimization we can end up with | |
1767 non-gimple (foo *)&this->m, fix that here. */ | |
1768 if (TREE_CODE (new_arg) != SSA_NAME | |
1769 && TREE_CODE (new_arg) != FUNCTION_DECL | |
1770 && !is_gimple_val (new_arg)) | |
1771 { | |
1772 gimple_seq stmts = NULL; | |
1773 new_arg = force_gimple_operand (new_arg, &stmts, true, NULL); | |
1774 gsi_insert_seq_on_edge_immediate (new_edge, stmts); | |
1775 } | |
1776 add_phi_arg (new_phi, new_arg, new_edge); | |
1777 } | |
1778 } | |
1779 } | |
1780 } | |
1781 | |
1782 | |
1783 /* Wrapper for remap_decl so it can be used as a callback. */ | |
1784 | |
1785 static tree | |
1786 remap_decl_1 (tree decl, void *data) | |
1787 { | |
1788 return remap_decl (decl, (copy_body_data *) data); | |
1789 } | |
1790 | |
1791 /* Build struct function and associated datastructures for the new clone | |
1792 NEW_FNDECL to be build. CALLEE_FNDECL is the original */ | |
1793 | |
1794 static void | |
1795 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count, | |
1796 int frequency) | |
1797 { | |
1798 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); | |
1799 gcov_type count_scale, frequency_scale; | |
1800 | |
1801 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count) | |
1802 count_scale = (REG_BR_PROB_BASE * count | |
1803 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count); | |
1804 else | |
1805 count_scale = 1; | |
1806 | |
1807 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency) | |
1808 frequency_scale = (REG_BR_PROB_BASE * frequency | |
1809 / | |
1810 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency); | |
1811 else | |
1812 frequency_scale = count_scale; | |
1813 | |
1814 /* Register specific tree functions. */ | |
1815 gimple_register_cfg_hooks (); | |
1816 | |
1817 /* Get clean struct function. */ | |
1818 push_struct_function (new_fndecl); | |
1819 | |
1820 /* We will rebuild these, so just sanity check that they are empty. */ | |
1821 gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL); | |
1822 gcc_assert (cfun->local_decls == NULL); | |
1823 gcc_assert (cfun->cfg == NULL); | |
1824 gcc_assert (cfun->decl == new_fndecl); | |
1825 | |
1826 /* Copy items we preserve during clonning. */ | |
1827 cfun->static_chain_decl = src_cfun->static_chain_decl; | |
1828 cfun->nonlocal_goto_save_area = src_cfun->nonlocal_goto_save_area; | |
1829 cfun->function_end_locus = src_cfun->function_end_locus; | |
1830 cfun->curr_properties = src_cfun->curr_properties; | |
1831 cfun->last_verified = src_cfun->last_verified; | |
1832 if (src_cfun->ipa_transforms_to_apply) | |
1833 cfun->ipa_transforms_to_apply = VEC_copy (ipa_opt_pass, heap, | |
1834 src_cfun->ipa_transforms_to_apply); | |
1835 cfun->va_list_gpr_size = src_cfun->va_list_gpr_size; | |
1836 cfun->va_list_fpr_size = src_cfun->va_list_fpr_size; | |
1837 cfun->function_frequency = src_cfun->function_frequency; | |
1838 cfun->has_nonlocal_label = src_cfun->has_nonlocal_label; | |
1839 cfun->stdarg = src_cfun->stdarg; | |
1840 cfun->dont_save_pending_sizes_p = src_cfun->dont_save_pending_sizes_p; | |
1841 cfun->after_inlining = src_cfun->after_inlining; | |
1842 cfun->returns_struct = src_cfun->returns_struct; | |
1843 cfun->returns_pcc_struct = src_cfun->returns_pcc_struct; | |
1844 cfun->after_tree_profile = src_cfun->after_tree_profile; | |
1845 | |
1846 init_empty_tree_cfg (); | |
1847 | |
1848 ENTRY_BLOCK_PTR->count = | |
1849 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale / | |
1850 REG_BR_PROB_BASE); | |
1851 ENTRY_BLOCK_PTR->frequency = | |
1852 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency * | |
1853 frequency_scale / REG_BR_PROB_BASE); | |
1854 EXIT_BLOCK_PTR->count = | |
1855 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale / | |
1856 REG_BR_PROB_BASE); | |
1857 EXIT_BLOCK_PTR->frequency = | |
1858 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency * | |
1859 frequency_scale / REG_BR_PROB_BASE); | |
1860 if (src_cfun->eh) | |
1861 init_eh_for_function (); | |
1862 | |
1863 if (src_cfun->gimple_df) | |
1864 { | |
1865 init_tree_ssa (cfun); | |
1866 cfun->gimple_df->in_ssa_p = true; | |
1867 init_ssa_operands (); | |
1868 } | |
1869 pop_cfun (); | |
1870 } | |
1871 | |
1872 /* Make a copy of the body of FN so that it can be inserted inline in | |
1873 another function. Walks FN via CFG, returns new fndecl. */ | |
1874 | |
1875 static tree | |
1876 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, | |
1877 basic_block entry_block_map, basic_block exit_block_map) | |
1878 { | |
1879 tree callee_fndecl = id->src_fn; | |
1880 /* Original cfun for the callee, doesn't change. */ | |
1881 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); | |
1882 struct function *cfun_to_copy; | |
1883 basic_block bb; | |
1884 tree new_fndecl = NULL; | |
1885 gcov_type count_scale, frequency_scale; | |
1886 int last; | |
1887 | |
1888 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count) | |
1889 count_scale = (REG_BR_PROB_BASE * count | |
1890 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count); | |
1891 else | |
1892 count_scale = 1; | |
1893 | |
1894 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency) | |
1895 frequency_scale = (REG_BR_PROB_BASE * frequency | |
1896 / | |
1897 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency); | |
1898 else | |
1899 frequency_scale = count_scale; | |
1900 | |
1901 /* Register specific tree functions. */ | |
1902 gimple_register_cfg_hooks (); | |
1903 | |
1904 /* Must have a CFG here at this point. */ | |
1905 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION | |
1906 (DECL_STRUCT_FUNCTION (callee_fndecl))); | |
1907 | |
1908 cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); | |
1909 | |
1910 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map; | |
1911 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map; | |
1912 entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy); | |
1913 exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy); | |
1914 | |
1915 /* Duplicate any exception-handling regions. */ | |
1916 if (cfun->eh) | |
1917 { | |
1918 id->eh_region_offset | |
1919 = duplicate_eh_regions (cfun_to_copy, remap_decl_1, id, | |
1920 0, id->eh_region); | |
1921 } | |
1922 | |
1923 /* Use aux pointers to map the original blocks to copy. */ | |
1924 FOR_EACH_BB_FN (bb, cfun_to_copy) | |
1925 { | |
1926 basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale); | |
1927 bb->aux = new_bb; | |
1928 new_bb->aux = bb; | |
1929 } | |
1930 | |
1931 last = last_basic_block; | |
1932 | |
1933 /* Now that we've duplicated the blocks, duplicate their edges. */ | |
1934 FOR_ALL_BB_FN (bb, cfun_to_copy) | |
1935 copy_edges_for_bb (bb, count_scale, exit_block_map); | |
1936 | |
1937 if (gimple_in_ssa_p (cfun)) | |
1938 FOR_ALL_BB_FN (bb, cfun_to_copy) | |
1939 copy_phis_for_bb (bb, id); | |
1940 | |
1941 FOR_ALL_BB_FN (bb, cfun_to_copy) | |
1942 { | |
1943 ((basic_block)bb->aux)->aux = NULL; | |
1944 bb->aux = NULL; | |
1945 } | |
1946 | |
1947 /* Zero out AUX fields of newly created block during EH edge | |
1948 insertion. */ | |
1949 for (; last < last_basic_block; last++) | |
1950 BASIC_BLOCK (last)->aux = NULL; | |
1951 entry_block_map->aux = NULL; | |
1952 exit_block_map->aux = NULL; | |
1953 | |
1954 return new_fndecl; | |
1955 } | |
1956 | |
1957 static tree | |
1958 copy_body (copy_body_data *id, gcov_type count, int frequency, | |
1959 basic_block entry_block_map, basic_block exit_block_map) | |
1960 { | |
1961 tree fndecl = id->src_fn; | |
1962 tree body; | |
1963 | |
1964 /* If this body has a CFG, walk CFG and copy. */ | |
1965 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl))); | |
1966 body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map); | |
1967 | |
1968 return body; | |
1969 } | |
1970 | |
1971 /* Return true if VALUE is an ADDR_EXPR of an automatic variable | |
1972 defined in function FN, or of a data member thereof. */ | |
1973 | |
1974 static bool | |
1975 self_inlining_addr_expr (tree value, tree fn) | |
1976 { | |
1977 tree var; | |
1978 | |
1979 if (TREE_CODE (value) != ADDR_EXPR) | |
1980 return false; | |
1981 | |
1982 var = get_base_address (TREE_OPERAND (value, 0)); | |
1983 | |
1984 return var && auto_var_in_fn_p (var, fn); | |
1985 } | |
1986 | |
1987 static void | |
1988 insert_init_stmt (basic_block bb, gimple init_stmt) | |
1989 { | |
1990 /* If VAR represents a zero-sized variable, it's possible that the | |
1991 assignment statement may result in no gimple statements. */ | |
1992 if (init_stmt) | |
1993 { | |
1994 gimple_stmt_iterator si = gsi_last_bb (bb); | |
1995 | |
1996 /* We can end up with init statements that store to a non-register | |
1997 from a rhs with a conversion. Handle that here by forcing the | |
1998 rhs into a temporary. gimple_regimplify_operands is not | |
1999 prepared to do this for us. */ | |
2000 if (!is_gimple_reg (gimple_assign_lhs (init_stmt)) | |
2001 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt))) | |
2002 && gimple_assign_rhs_class (init_stmt) == GIMPLE_UNARY_RHS) | |
2003 { | |
2004 tree rhs = build1 (gimple_assign_rhs_code (init_stmt), | |
2005 gimple_expr_type (init_stmt), | |
2006 gimple_assign_rhs1 (init_stmt)); | |
2007 rhs = force_gimple_operand_gsi (&si, rhs, true, NULL_TREE, false, | |
2008 GSI_NEW_STMT); | |
2009 gimple_assign_set_rhs_code (init_stmt, TREE_CODE (rhs)); | |
2010 gimple_assign_set_rhs1 (init_stmt, rhs); | |
2011 } | |
2012 gsi_insert_after (&si, init_stmt, GSI_NEW_STMT); | |
2013 gimple_regimplify_operands (init_stmt, &si); | |
2014 mark_symbols_for_renaming (init_stmt); | |
2015 } | |
2016 } | |
2017 | |
2018 /* Initialize parameter P with VALUE. If needed, produce init statement | |
2019 at the end of BB. When BB is NULL, we return init statement to be | |
2020 output later. */ | |
2021 static gimple | |
2022 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn, | |
2023 basic_block bb, tree *vars) | |
2024 { | |
2025 gimple init_stmt = NULL; | |
2026 tree var; | |
2027 tree rhs = value; | |
2028 tree def = (gimple_in_ssa_p (cfun) | |
2029 ? gimple_default_def (id->src_cfun, p) : NULL); | |
2030 | |
2031 if (value | |
2032 && value != error_mark_node | |
2033 && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value))) | |
2034 { | |
2035 if (fold_convertible_p (TREE_TYPE (p), value)) | |
2036 rhs = fold_build1 (NOP_EXPR, TREE_TYPE (p), value); | |
2037 else | |
2038 /* ??? For valid (GIMPLE) programs we should not end up here. | |
2039 Still if something has gone wrong and we end up with truly | |
2040 mismatched types here, fall back to using a VIEW_CONVERT_EXPR | |
2041 to not leak invalid GIMPLE to the following passes. */ | |
2042 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value); | |
2043 } | |
2044 | |
2045 /* If the parameter is never assigned to, has no SSA_NAMEs created, | |
2046 we may not need to create a new variable here at all. Instead, we may | |
2047 be able to just use the argument value. */ | |
2048 if (TREE_READONLY (p) | |
2049 && !TREE_ADDRESSABLE (p) | |
2050 && value && !TREE_SIDE_EFFECTS (value) | |
2051 && !def) | |
2052 { | |
2053 /* We may produce non-gimple trees by adding NOPs or introduce | |
2054 invalid sharing when operand is not really constant. | |
2055 It is not big deal to prohibit constant propagation here as | |
2056 we will constant propagate in DOM1 pass anyway. */ | |
2057 if (is_gimple_min_invariant (value) | |
2058 && useless_type_conversion_p (TREE_TYPE (p), | |
2059 TREE_TYPE (value)) | |
2060 /* We have to be very careful about ADDR_EXPR. Make sure | |
2061 the base variable isn't a local variable of the inlined | |
2062 function, e.g., when doing recursive inlining, direct or | |
2063 mutually-recursive or whatever, which is why we don't | |
2064 just test whether fn == current_function_decl. */ | |
2065 && ! self_inlining_addr_expr (value, fn)) | |
2066 { | |
2067 insert_decl_map (id, p, value); | |
2068 return NULL; | |
2069 } | |
2070 } | |
2071 | |
2072 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type | |
2073 here since the type of this decl must be visible to the calling | |
2074 function. */ | |
2075 var = copy_decl_to_var (p, id); | |
2076 if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL) | |
2077 { | |
2078 get_var_ann (var); | |
2079 add_referenced_var (var); | |
2080 } | |
2081 | |
2082 /* Register the VAR_DECL as the equivalent for the PARM_DECL; | |
2083 that way, when the PARM_DECL is encountered, it will be | |
2084 automatically replaced by the VAR_DECL. */ | |
2085 insert_decl_map (id, p, var); | |
2086 | |
2087 /* Declare this new variable. */ | |
2088 TREE_CHAIN (var) = *vars; | |
2089 *vars = var; | |
2090 | |
2091 /* Make gimplifier happy about this variable. */ | |
2092 DECL_SEEN_IN_BIND_EXPR_P (var) = 1; | |
2093 | |
2094 /* Even if P was TREE_READONLY, the new VAR should not be. | |
2095 In the original code, we would have constructed a | |
2096 temporary, and then the function body would have never | |
2097 changed the value of P. However, now, we will be | |
2098 constructing VAR directly. The constructor body may | |
2099 change its value multiple times as it is being | |
2100 constructed. Therefore, it must not be TREE_READONLY; | |
2101 the back-end assumes that TREE_READONLY variable is | |
2102 assigned to only once. */ | |
2103 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p))) | |
2104 TREE_READONLY (var) = 0; | |
2105 | |
2106 /* If there is no setup required and we are in SSA, take the easy route | |
2107 replacing all SSA names representing the function parameter by the | |
2108 SSA name passed to function. | |
2109 | |
2110 We need to construct map for the variable anyway as it might be used | |
2111 in different SSA names when parameter is set in function. | |
2112 | |
2113 Do replacement at -O0 for const arguments replaced by constant. | |
2114 This is important for builtin_constant_p and other construct requiring | |
2115 constant argument to be visible in inlined function body. | |
2116 | |
2117 FIXME: This usually kills the last connection in between inlined | |
2118 function parameter and the actual value in debug info. Can we do | |
2119 better here? If we just inserted the statement, copy propagation | |
2120 would kill it anyway as it always did in older versions of GCC. | |
2121 | |
2122 We might want to introduce a notion that single SSA_NAME might | |
2123 represent multiple variables for purposes of debugging. */ | |
2124 if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p) | |
2125 && (optimize | |
2126 || (TREE_READONLY (p) | |
2127 && is_gimple_min_invariant (rhs))) | |
2128 && (TREE_CODE (rhs) == SSA_NAME | |
2129 || is_gimple_min_invariant (rhs)) | |
2130 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)) | |
2131 { | |
2132 insert_decl_map (id, def, rhs); | |
2133 return NULL; | |
2134 } | |
2135 | |
2136 /* If the value of argument is never used, don't care about initializing | |
2137 it. */ | |
2138 if (optimize && gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p)) | |
2139 { | |
2140 gcc_assert (!value || !TREE_SIDE_EFFECTS (value)); | |
2141 return NULL; | |
2142 } | |
2143 | |
2144 /* Initialize this VAR_DECL from the equivalent argument. Convert | |
2145 the argument to the proper type in case it was promoted. */ | |
2146 if (value) | |
2147 { | |
2148 if (rhs == error_mark_node) | |
2149 { | |
2150 insert_decl_map (id, p, var); | |
2151 return NULL; | |
2152 } | |
2153 | |
2154 STRIP_USELESS_TYPE_CONVERSION (rhs); | |
2155 | |
2156 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we | |
2157 keep our trees in gimple form. */ | |
2158 if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p)) | |
2159 { | |
2160 def = remap_ssa_name (def, id); | |
2161 init_stmt = gimple_build_assign (def, rhs); | |
2162 SSA_NAME_IS_DEFAULT_DEF (def) = 0; | |
2163 set_default_def (var, NULL); | |
2164 } | |
2165 else | |
2166 init_stmt = gimple_build_assign (var, rhs); | |
2167 | |
2168 if (bb && init_stmt) | |
2169 insert_init_stmt (bb, init_stmt); | |
2170 } | |
2171 return init_stmt; | |
2172 } | |
2173 | |
2174 /* Generate code to initialize the parameters of the function at the | |
2175 top of the stack in ID from the GIMPLE_CALL STMT. */ | |
2176 | |
2177 static void | |
2178 initialize_inlined_parameters (copy_body_data *id, gimple stmt, | |
2179 tree fn, basic_block bb) | |
2180 { | |
2181 tree parms; | |
2182 size_t i; | |
2183 tree p; | |
2184 tree vars = NULL_TREE; | |
2185 tree static_chain = gimple_call_chain (stmt); | |
2186 | |
2187 /* Figure out what the parameters are. */ | |
2188 parms = DECL_ARGUMENTS (fn); | |
2189 | |
2190 /* Loop through the parameter declarations, replacing each with an | |
2191 equivalent VAR_DECL, appropriately initialized. */ | |
2192 for (p = parms, i = 0; p; p = TREE_CHAIN (p), i++) | |
2193 { | |
2194 tree val; | |
2195 val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL; | |
2196 setup_one_parameter (id, p, val, fn, bb, &vars); | |
2197 } | |
2198 | |
2199 /* Initialize the static chain. */ | |
2200 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl; | |
2201 gcc_assert (fn != current_function_decl); | |
2202 if (p) | |
2203 { | |
2204 /* No static chain? Seems like a bug in tree-nested.c. */ | |
2205 gcc_assert (static_chain); | |
2206 | |
2207 setup_one_parameter (id, p, static_chain, fn, bb, &vars); | |
2208 } | |
2209 | |
2210 declare_inline_vars (id->block, vars); | |
2211 } | |
2212 | |
2213 | |
2214 /* Declare a return variable to replace the RESULT_DECL for the | |
2215 function we are calling. An appropriate DECL_STMT is returned. | |
2216 The USE_STMT is filled to contain a use of the declaration to | |
2217 indicate the return value of the function. | |
2218 | |
2219 RETURN_SLOT, if non-null is place where to store the result. It | |
2220 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null, | |
2221 was the LHS of the MODIFY_EXPR to which this call is the RHS. | |
2222 | |
2223 The return value is a (possibly null) value that is the result of the | |
2224 function as seen by the callee. *USE_P is a (possibly null) value that | |
2225 holds the result as seen by the caller. */ | |
2226 | |
2227 static tree | |
2228 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest, | |
2229 tree *use_p) | |
2230 { | |
2231 tree callee = id->src_fn; | |
2232 tree caller = id->dst_fn; | |
2233 tree result = DECL_RESULT (callee); | |
2234 tree callee_type = TREE_TYPE (result); | |
2235 tree caller_type = TREE_TYPE (TREE_TYPE (callee)); | |
2236 tree var, use; | |
2237 | |
2238 /* We don't need to do anything for functions that don't return | |
2239 anything. */ | |
2240 if (!result || VOID_TYPE_P (callee_type)) | |
2241 { | |
2242 *use_p = NULL_TREE; | |
2243 return NULL_TREE; | |
2244 } | |
2245 | |
2246 /* If there was a return slot, then the return value is the | |
2247 dereferenced address of that object. */ | |
2248 if (return_slot) | |
2249 { | |
2250 /* The front end shouldn't have used both return_slot and | |
2251 a modify expression. */ | |
2252 gcc_assert (!modify_dest); | |
2253 if (DECL_BY_REFERENCE (result)) | |
2254 { | |
2255 tree return_slot_addr = build_fold_addr_expr (return_slot); | |
2256 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr); | |
2257 | |
2258 /* We are going to construct *&return_slot and we can't do that | |
2259 for variables believed to be not addressable. | |
2260 | |
2261 FIXME: This check possibly can match, because values returned | |
2262 via return slot optimization are not believed to have address | |
2263 taken by alias analysis. */ | |
2264 gcc_assert (TREE_CODE (return_slot) != SSA_NAME); | |
2265 if (gimple_in_ssa_p (cfun)) | |
2266 { | |
2267 HOST_WIDE_INT bitsize; | |
2268 HOST_WIDE_INT bitpos; | |
2269 tree offset; | |
2270 enum machine_mode mode; | |
2271 int unsignedp; | |
2272 int volatilep; | |
2273 tree base; | |
2274 base = get_inner_reference (return_slot, &bitsize, &bitpos, | |
2275 &offset, | |
2276 &mode, &unsignedp, &volatilep, | |
2277 false); | |
2278 if (TREE_CODE (base) == INDIRECT_REF) | |
2279 base = TREE_OPERAND (base, 0); | |
2280 if (TREE_CODE (base) == SSA_NAME) | |
2281 base = SSA_NAME_VAR (base); | |
2282 mark_sym_for_renaming (base); | |
2283 } | |
2284 var = return_slot_addr; | |
2285 } | |
2286 else | |
2287 { | |
2288 var = return_slot; | |
2289 gcc_assert (TREE_CODE (var) != SSA_NAME); | |
2290 TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result); | |
2291 } | |
2292 if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE | |
2293 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE) | |
2294 && !DECL_GIMPLE_REG_P (result) | |
2295 && DECL_P (var)) | |
2296 DECL_GIMPLE_REG_P (var) = 0; | |
2297 use = NULL; | |
2298 goto done; | |
2299 } | |
2300 | |
2301 /* All types requiring non-trivial constructors should have been handled. */ | |
2302 gcc_assert (!TREE_ADDRESSABLE (callee_type)); | |
2303 | |
2304 /* Attempt to avoid creating a new temporary variable. */ | |
2305 if (modify_dest | |
2306 && TREE_CODE (modify_dest) != SSA_NAME) | |
2307 { | |
2308 bool use_it = false; | |
2309 | |
2310 /* We can't use MODIFY_DEST if there's type promotion involved. */ | |
2311 if (!useless_type_conversion_p (callee_type, caller_type)) | |
2312 use_it = false; | |
2313 | |
2314 /* ??? If we're assigning to a variable sized type, then we must | |
2315 reuse the destination variable, because we've no good way to | |
2316 create variable sized temporaries at this point. */ | |
2317 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST) | |
2318 use_it = true; | |
2319 | |
2320 /* If the callee cannot possibly modify MODIFY_DEST, then we can | |
2321 reuse it as the result of the call directly. Don't do this if | |
2322 it would promote MODIFY_DEST to addressable. */ | |
2323 else if (TREE_ADDRESSABLE (result)) | |
2324 use_it = false; | |
2325 else | |
2326 { | |
2327 tree base_m = get_base_address (modify_dest); | |
2328 | |
2329 /* If the base isn't a decl, then it's a pointer, and we don't | |
2330 know where that's going to go. */ | |
2331 if (!DECL_P (base_m)) | |
2332 use_it = false; | |
2333 else if (is_global_var (base_m)) | |
2334 use_it = false; | |
2335 else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE | |
2336 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE) | |
2337 && !DECL_GIMPLE_REG_P (result) | |
2338 && DECL_GIMPLE_REG_P (base_m)) | |
2339 use_it = false; | |
2340 else if (!TREE_ADDRESSABLE (base_m)) | |
2341 use_it = true; | |
2342 } | |
2343 | |
2344 if (use_it) | |
2345 { | |
2346 var = modify_dest; | |
2347 use = NULL; | |
2348 goto done; | |
2349 } | |
2350 } | |
2351 | |
2352 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST); | |
2353 | |
2354 var = copy_result_decl_to_var (result, id); | |
2355 if (gimple_in_ssa_p (cfun)) | |
2356 { | |
2357 get_var_ann (var); | |
2358 add_referenced_var (var); | |
2359 } | |
2360 | |
2361 DECL_SEEN_IN_BIND_EXPR_P (var) = 1; | |
2362 DECL_STRUCT_FUNCTION (caller)->local_decls | |
2363 = tree_cons (NULL_TREE, var, | |
2364 DECL_STRUCT_FUNCTION (caller)->local_decls); | |
2365 | |
2366 /* Do not have the rest of GCC warn about this variable as it should | |
2367 not be visible to the user. */ | |
2368 TREE_NO_WARNING (var) = 1; | |
2369 | |
2370 declare_inline_vars (id->block, var); | |
2371 | |
2372 /* Build the use expr. If the return type of the function was | |
2373 promoted, convert it back to the expected type. */ | |
2374 use = var; | |
2375 if (!useless_type_conversion_p (caller_type, TREE_TYPE (var))) | |
2376 use = fold_convert (caller_type, var); | |
2377 | |
2378 STRIP_USELESS_TYPE_CONVERSION (use); | |
2379 | |
2380 if (DECL_BY_REFERENCE (result)) | |
2381 var = build_fold_addr_expr (var); | |
2382 | |
2383 done: | |
2384 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that | |
2385 way, when the RESULT_DECL is encountered, it will be | |
2386 automatically replaced by the VAR_DECL. */ | |
2387 insert_decl_map (id, result, var); | |
2388 | |
2389 /* Remember this so we can ignore it in remap_decls. */ | |
2390 id->retvar = var; | |
2391 | |
2392 *use_p = use; | |
2393 return var; | |
2394 } | |
2395 | |
2396 /* Returns nonzero if a function can be inlined as a tree. */ | |
2397 | |
2398 bool | |
2399 tree_inlinable_function_p (tree fn) | |
2400 { | |
2401 return inlinable_function_p (fn); | |
2402 } | |
2403 | |
2404 static const char *inline_forbidden_reason; | |
2405 | |
2406 /* A callback for walk_gimple_seq to handle tree operands. Returns | |
2407 NULL_TREE if a function can be inlined, otherwise sets the reason | |
2408 why not and returns a tree representing the offending operand. */ | |
2409 | |
2410 static tree | |
2411 inline_forbidden_p_op (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, | |
2412 void *fnp ATTRIBUTE_UNUSED) | |
2413 { | |
2414 tree node = *nodep; | |
2415 tree t; | |
2416 | |
2417 if (TREE_CODE (node) == RECORD_TYPE || TREE_CODE (node) == UNION_TYPE) | |
2418 { | |
2419 /* We cannot inline a function of the form | |
2420 | |
2421 void F (int i) { struct S { int ar[i]; } s; } | |
2422 | |
2423 Attempting to do so produces a catch-22. | |
2424 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/ | |
2425 UNION_TYPE nodes, then it goes into infinite recursion on a | |
2426 structure containing a pointer to its own type. If it doesn't, | |
2427 then the type node for S doesn't get adjusted properly when | |
2428 F is inlined. | |
2429 | |
2430 ??? This is likely no longer true, but it's too late in the 4.0 | |
2431 cycle to try to find out. This should be checked for 4.1. */ | |
2432 for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t)) | |
2433 if (variably_modified_type_p (TREE_TYPE (t), NULL)) | |
2434 { | |
2435 inline_forbidden_reason | |
2436 = G_("function %q+F can never be inlined " | |
2437 "because it uses variable sized variables"); | |
2438 return node; | |
2439 } | |
2440 } | |
2441 | |
2442 return NULL_TREE; | |
2443 } | |
2444 | |
2445 | |
2446 /* A callback for walk_gimple_seq to handle statements. Returns | |
2447 non-NULL iff a function can not be inlined. Also sets the reason | |
2448 why. */ | |
2449 | |
2450 static tree | |
2451 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p, | |
2452 struct walk_stmt_info *wip) | |
2453 { | |
2454 tree fn = (tree) wip->info; | |
2455 tree t; | |
2456 gimple stmt = gsi_stmt (*gsi); | |
2457 | |
2458 switch (gimple_code (stmt)) | |
2459 { | |
2460 case GIMPLE_CALL: | |
2461 /* Refuse to inline alloca call unless user explicitly forced so as | |
2462 this may change program's memory overhead drastically when the | |
2463 function using alloca is called in loop. In GCC present in | |
2464 SPEC2000 inlining into schedule_block cause it to require 2GB of | |
2465 RAM instead of 256MB. */ | |
2466 if (gimple_alloca_call_p (stmt) | |
2467 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))) | |
2468 { | |
2469 inline_forbidden_reason | |
2470 = G_("function %q+F can never be inlined because it uses " | |
2471 "alloca (override using the always_inline attribute)"); | |
2472 *handled_ops_p = true; | |
2473 return fn; | |
2474 } | |
2475 | |
2476 t = gimple_call_fndecl (stmt); | |
2477 if (t == NULL_TREE) | |
2478 break; | |
2479 | |
2480 /* We cannot inline functions that call setjmp. */ | |
2481 if (setjmp_call_p (t)) | |
2482 { | |
2483 inline_forbidden_reason | |
2484 = G_("function %q+F can never be inlined because it uses setjmp"); | |
2485 *handled_ops_p = true; | |
2486 return t; | |
2487 } | |
2488 | |
2489 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL) | |
2490 switch (DECL_FUNCTION_CODE (t)) | |
2491 { | |
2492 /* We cannot inline functions that take a variable number of | |
2493 arguments. */ | |
2494 case BUILT_IN_VA_START: | |
2495 case BUILT_IN_NEXT_ARG: | |
2496 case BUILT_IN_VA_END: | |
2497 inline_forbidden_reason | |
2498 = G_("function %q+F can never be inlined because it " | |
2499 "uses variable argument lists"); | |
2500 *handled_ops_p = true; | |
2501 return t; | |
2502 | |
2503 case BUILT_IN_LONGJMP: | |
2504 /* We can't inline functions that call __builtin_longjmp at | |
2505 all. The non-local goto machinery really requires the | |
2506 destination be in a different function. If we allow the | |
2507 function calling __builtin_longjmp to be inlined into the | |
2508 function calling __builtin_setjmp, Things will Go Awry. */ | |
2509 inline_forbidden_reason | |
2510 = G_("function %q+F can never be inlined because " | |
2511 "it uses setjmp-longjmp exception handling"); | |
2512 *handled_ops_p = true; | |
2513 return t; | |
2514 | |
2515 case BUILT_IN_NONLOCAL_GOTO: | |
2516 /* Similarly. */ | |
2517 inline_forbidden_reason | |
2518 = G_("function %q+F can never be inlined because " | |
2519 "it uses non-local goto"); | |
2520 *handled_ops_p = true; | |
2521 return t; | |
2522 | |
2523 case BUILT_IN_RETURN: | |
2524 case BUILT_IN_APPLY_ARGS: | |
2525 /* If a __builtin_apply_args caller would be inlined, | |
2526 it would be saving arguments of the function it has | |
2527 been inlined into. Similarly __builtin_return would | |
2528 return from the function the inline has been inlined into. */ | |
2529 inline_forbidden_reason | |
2530 = G_("function %q+F can never be inlined because " | |
2531 "it uses __builtin_return or __builtin_apply_args"); | |
2532 *handled_ops_p = true; | |
2533 return t; | |
2534 | |
2535 default: | |
2536 break; | |
2537 } | |
2538 break; | |
2539 | |
2540 case GIMPLE_GOTO: | |
2541 t = gimple_goto_dest (stmt); | |
2542 | |
2543 /* We will not inline a function which uses computed goto. The | |
2544 addresses of its local labels, which may be tucked into | |
2545 global storage, are of course not constant across | |
2546 instantiations, which causes unexpected behavior. */ | |
2547 if (TREE_CODE (t) != LABEL_DECL) | |
2548 { | |
2549 inline_forbidden_reason | |
2550 = G_("function %q+F can never be inlined " | |
2551 "because it contains a computed goto"); | |
2552 *handled_ops_p = true; | |
2553 return t; | |
2554 } | |
2555 break; | |
2556 | |
2557 case GIMPLE_LABEL: | |
2558 t = gimple_label_label (stmt); | |
2559 if (DECL_NONLOCAL (t)) | |
2560 { | |
2561 /* We cannot inline a function that receives a non-local goto | |
2562 because we cannot remap the destination label used in the | |
2563 function that is performing the non-local goto. */ | |
2564 inline_forbidden_reason | |
2565 = G_("function %q+F can never be inlined " | |
2566 "because it receives a non-local goto"); | |
2567 *handled_ops_p = true; | |
2568 return t; | |
2569 } | |
2570 break; | |
2571 | |
2572 default: | |
2573 break; | |
2574 } | |
2575 | |
2576 *handled_ops_p = false; | |
2577 return NULL_TREE; | |
2578 } | |
2579 | |
2580 | |
2581 static tree | |
2582 inline_forbidden_p_2 (tree *nodep, int *walk_subtrees, | |
2583 void *fnp) | |
2584 { | |
2585 tree node = *nodep; | |
2586 tree fn = (tree) fnp; | |
2587 | |
2588 if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn) | |
2589 { | |
2590 inline_forbidden_reason | |
2591 = G_("function %q+F can never be inlined " | |
2592 "because it saves address of local label in a static variable"); | |
2593 return node; | |
2594 } | |
2595 | |
2596 if (TYPE_P (node)) | |
2597 *walk_subtrees = 0; | |
2598 | |
2599 return NULL_TREE; | |
2600 } | |
2601 | |
2602 /* Return true if FNDECL is a function that cannot be inlined into | |
2603 another one. */ | |
2604 | |
2605 static bool | |
2606 inline_forbidden_p (tree fndecl) | |
2607 { | |
2608 location_t saved_loc = input_location; | |
2609 struct function *fun = DECL_STRUCT_FUNCTION (fndecl); | |
2610 tree step; | |
2611 struct walk_stmt_info wi; | |
2612 struct pointer_set_t *visited_nodes; | |
2613 basic_block bb; | |
2614 bool forbidden_p = false; | |
2615 | |
2616 visited_nodes = pointer_set_create (); | |
2617 memset (&wi, 0, sizeof (wi)); | |
2618 wi.info = (void *) fndecl; | |
2619 wi.pset = visited_nodes; | |
2620 | |
2621 FOR_EACH_BB_FN (bb, fun) | |
2622 { | |
2623 gimple ret; | |
2624 gimple_seq seq = bb_seq (bb); | |
2625 ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, | |
2626 inline_forbidden_p_op, &wi); | |
2627 forbidden_p = (ret != NULL); | |
2628 if (forbidden_p) | |
2629 goto egress; | |
2630 } | |
2631 | |
2632 for (step = fun->local_decls; step; step = TREE_CHAIN (step)) | |
2633 { | |
2634 tree decl = TREE_VALUE (step); | |
2635 if (TREE_CODE (decl) == VAR_DECL | |
2636 && TREE_STATIC (decl) | |
2637 && !DECL_EXTERNAL (decl) | |
2638 && DECL_INITIAL (decl)) | |
2639 { | |
2640 tree ret; | |
2641 ret = walk_tree_without_duplicates (&DECL_INITIAL (decl), | |
2642 inline_forbidden_p_2, fndecl); | |
2643 forbidden_p = (ret != NULL); | |
2644 if (forbidden_p) | |
2645 goto egress; | |
2646 } | |
2647 } | |
2648 | |
2649 egress: | |
2650 pointer_set_destroy (visited_nodes); | |
2651 input_location = saved_loc; | |
2652 return forbidden_p; | |
2653 } | |
2654 | |
2655 /* Returns nonzero if FN is a function that does not have any | |
2656 fundamental inline blocking properties. */ | |
2657 | |
2658 static bool | |
2659 inlinable_function_p (tree fn) | |
2660 { | |
2661 bool inlinable = true; | |
2662 bool do_warning; | |
2663 tree always_inline; | |
2664 | |
2665 /* If we've already decided this function shouldn't be inlined, | |
2666 there's no need to check again. */ | |
2667 if (DECL_UNINLINABLE (fn)) | |
2668 return false; | |
2669 | |
2670 /* We only warn for functions declared `inline' by the user. */ | |
2671 do_warning = (warn_inline | |
2672 && DECL_DECLARED_INLINE_P (fn) | |
2673 && !DECL_NO_INLINE_WARNING_P (fn) | |
2674 && !DECL_IN_SYSTEM_HEADER (fn)); | |
2675 | |
2676 always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)); | |
2677 | |
2678 if (flag_no_inline | |
2679 && always_inline == NULL) | |
2680 { | |
2681 if (do_warning) | |
2682 warning (OPT_Winline, "function %q+F can never be inlined because it " | |
2683 "is suppressed using -fno-inline", fn); | |
2684 inlinable = false; | |
2685 } | |
2686 | |
2687 /* Don't auto-inline anything that might not be bound within | |
2688 this unit of translation. */ | |
2689 else if (!DECL_DECLARED_INLINE_P (fn) | |
2690 && DECL_REPLACEABLE_P (fn)) | |
2691 inlinable = false; | |
2692 | |
2693 else if (!function_attribute_inlinable_p (fn)) | |
2694 { | |
2695 if (do_warning) | |
2696 warning (OPT_Winline, "function %q+F can never be inlined because it " | |
2697 "uses attributes conflicting with inlining", fn); | |
2698 inlinable = false; | |
2699 } | |
2700 | |
2701 else if (inline_forbidden_p (fn)) | |
2702 { | |
2703 /* See if we should warn about uninlinable functions. Previously, | |
2704 some of these warnings would be issued while trying to expand | |
2705 the function inline, but that would cause multiple warnings | |
2706 about functions that would for example call alloca. But since | |
2707 this a property of the function, just one warning is enough. | |
2708 As a bonus we can now give more details about the reason why a | |
2709 function is not inlinable. */ | |
2710 if (always_inline) | |
2711 sorry (inline_forbidden_reason, fn); | |
2712 else if (do_warning) | |
2713 warning (OPT_Winline, inline_forbidden_reason, fn); | |
2714 | |
2715 inlinable = false; | |
2716 } | |
2717 | |
2718 /* Squirrel away the result so that we don't have to check again. */ | |
2719 DECL_UNINLINABLE (fn) = !inlinable; | |
2720 | |
2721 return inlinable; | |
2722 } | |
2723 | |
2724 /* Estimate the cost of a memory move. Use machine dependent | |
2725 word size and take possible memcpy call into account. */ | |
2726 | |
2727 int | |
2728 estimate_move_cost (tree type) | |
2729 { | |
2730 HOST_WIDE_INT size; | |
2731 | |
2732 size = int_size_in_bytes (type); | |
2733 | |
2734 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (!optimize_size)) | |
2735 /* Cost of a memcpy call, 3 arguments and the call. */ | |
2736 return 4; | |
2737 else | |
2738 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES); | |
2739 } | |
2740 | |
2741 /* Returns cost of operation CODE, according to WEIGHTS */ | |
2742 | |
2743 static int | |
2744 estimate_operator_cost (enum tree_code code, eni_weights *weights) | |
2745 { | |
2746 switch (code) | |
2747 { | |
2748 /* These are "free" conversions, or their presumed cost | |
2749 is folded into other operations. */ | |
2750 case RANGE_EXPR: | |
2751 CASE_CONVERT: | |
2752 case COMPLEX_EXPR: | |
2753 case PAREN_EXPR: | |
2754 return 0; | |
2755 | |
2756 /* Assign cost of 1 to usual operations. | |
2757 ??? We may consider mapping RTL costs to this. */ | |
2758 case COND_EXPR: | |
2759 case VEC_COND_EXPR: | |
2760 | |
2761 case PLUS_EXPR: | |
2762 case POINTER_PLUS_EXPR: | |
2763 case MINUS_EXPR: | |
2764 case MULT_EXPR: | |
2765 | |
2766 case FIXED_CONVERT_EXPR: | |
2767 case FIX_TRUNC_EXPR: | |
2768 | |
2769 case NEGATE_EXPR: | |
2770 case FLOAT_EXPR: | |
2771 case MIN_EXPR: | |
2772 case MAX_EXPR: | |
2773 case ABS_EXPR: | |
2774 | |
2775 case LSHIFT_EXPR: | |
2776 case RSHIFT_EXPR: | |
2777 case LROTATE_EXPR: | |
2778 case RROTATE_EXPR: | |
2779 case VEC_LSHIFT_EXPR: | |
2780 case VEC_RSHIFT_EXPR: | |
2781 | |
2782 case BIT_IOR_EXPR: | |
2783 case BIT_XOR_EXPR: | |
2784 case BIT_AND_EXPR: | |
2785 case BIT_NOT_EXPR: | |
2786 | |
2787 case TRUTH_ANDIF_EXPR: | |
2788 case TRUTH_ORIF_EXPR: | |
2789 case TRUTH_AND_EXPR: | |
2790 case TRUTH_OR_EXPR: | |
2791 case TRUTH_XOR_EXPR: | |
2792 case TRUTH_NOT_EXPR: | |
2793 | |
2794 case LT_EXPR: | |
2795 case LE_EXPR: | |
2796 case GT_EXPR: | |
2797 case GE_EXPR: | |
2798 case EQ_EXPR: | |
2799 case NE_EXPR: | |
2800 case ORDERED_EXPR: | |
2801 case UNORDERED_EXPR: | |
2802 | |
2803 case UNLT_EXPR: | |
2804 case UNLE_EXPR: | |
2805 case UNGT_EXPR: | |
2806 case UNGE_EXPR: | |
2807 case UNEQ_EXPR: | |
2808 case LTGT_EXPR: | |
2809 | |
2810 case CONJ_EXPR: | |
2811 | |
2812 case PREDECREMENT_EXPR: | |
2813 case PREINCREMENT_EXPR: | |
2814 case POSTDECREMENT_EXPR: | |
2815 case POSTINCREMENT_EXPR: | |
2816 | |
2817 case REALIGN_LOAD_EXPR: | |
2818 | |
2819 case REDUC_MAX_EXPR: | |
2820 case REDUC_MIN_EXPR: | |
2821 case REDUC_PLUS_EXPR: | |
2822 case WIDEN_SUM_EXPR: | |
2823 case WIDEN_MULT_EXPR: | |
2824 case DOT_PROD_EXPR: | |
2825 | |
2826 case VEC_WIDEN_MULT_HI_EXPR: | |
2827 case VEC_WIDEN_MULT_LO_EXPR: | |
2828 case VEC_UNPACK_HI_EXPR: | |
2829 case VEC_UNPACK_LO_EXPR: | |
2830 case VEC_UNPACK_FLOAT_HI_EXPR: | |
2831 case VEC_UNPACK_FLOAT_LO_EXPR: | |
2832 case VEC_PACK_TRUNC_EXPR: | |
2833 case VEC_PACK_SAT_EXPR: | |
2834 case VEC_PACK_FIX_TRUNC_EXPR: | |
2835 case VEC_EXTRACT_EVEN_EXPR: | |
2836 case VEC_EXTRACT_ODD_EXPR: | |
2837 case VEC_INTERLEAVE_HIGH_EXPR: | |
2838 case VEC_INTERLEAVE_LOW_EXPR: | |
2839 | |
2840 return 1; | |
2841 | |
2842 /* Few special cases of expensive operations. This is useful | |
2843 to avoid inlining on functions having too many of these. */ | |
2844 case TRUNC_DIV_EXPR: | |
2845 case CEIL_DIV_EXPR: | |
2846 case FLOOR_DIV_EXPR: | |
2847 case ROUND_DIV_EXPR: | |
2848 case EXACT_DIV_EXPR: | |
2849 case TRUNC_MOD_EXPR: | |
2850 case CEIL_MOD_EXPR: | |
2851 case FLOOR_MOD_EXPR: | |
2852 case ROUND_MOD_EXPR: | |
2853 case RDIV_EXPR: | |
2854 return weights->div_mod_cost; | |
2855 | |
2856 default: | |
2857 /* We expect a copy assignment with no operator. */ | |
2858 gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS); | |
2859 return 0; | |
2860 } | |
2861 } | |
2862 | |
2863 | |
2864 /* Estimate number of instructions that will be created by expanding | |
2865 the statements in the statement sequence STMTS. | |
2866 WEIGHTS contains weights attributed to various constructs. */ | |
2867 | |
2868 static | |
2869 int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights) | |
2870 { | |
2871 int cost; | |
2872 gimple_stmt_iterator gsi; | |
2873 | |
2874 cost = 0; | |
2875 for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi)) | |
2876 cost += estimate_num_insns (gsi_stmt (gsi), weights); | |
2877 | |
2878 return cost; | |
2879 } | |
2880 | |
2881 | |
2882 /* Estimate number of instructions that will be created by expanding STMT. | |
2883 WEIGHTS contains weights attributed to various constructs. */ | |
2884 | |
2885 int | |
2886 estimate_num_insns (gimple stmt, eni_weights *weights) | |
2887 { | |
2888 unsigned cost, i; | |
2889 enum gimple_code code = gimple_code (stmt); | |
2890 tree lhs; | |
2891 | |
2892 switch (code) | |
2893 { | |
2894 case GIMPLE_ASSIGN: | |
2895 /* Try to estimate the cost of assignments. We have three cases to | |
2896 deal with: | |
2897 1) Simple assignments to registers; | |
2898 2) Stores to things that must live in memory. This includes | |
2899 "normal" stores to scalars, but also assignments of large | |
2900 structures, or constructors of big arrays; | |
2901 | |
2902 Let us look at the first two cases, assuming we have "a = b + C": | |
2903 <GIMPLE_ASSIGN <var_decl "a"> | |
2904 <plus_expr <var_decl "b"> <constant C>> | |
2905 If "a" is a GIMPLE register, the assignment to it is free on almost | |
2906 any target, because "a" usually ends up in a real register. Hence | |
2907 the only cost of this expression comes from the PLUS_EXPR, and we | |
2908 can ignore the GIMPLE_ASSIGN. | |
2909 If "a" is not a GIMPLE register, the assignment to "a" will most | |
2910 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost | |
2911 of moving something into "a", which we compute using the function | |
2912 estimate_move_cost. */ | |
2913 lhs = gimple_assign_lhs (stmt); | |
2914 if (is_gimple_reg (lhs)) | |
2915 cost = 0; | |
2916 else | |
2917 cost = estimate_move_cost (TREE_TYPE (lhs)); | |
2918 | |
2919 cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights); | |
2920 break; | |
2921 | |
2922 case GIMPLE_COND: | |
2923 cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights); | |
2924 break; | |
2925 | |
2926 case GIMPLE_SWITCH: | |
2927 /* Take into account cost of the switch + guess 2 conditional jumps for | |
2928 each case label. | |
2929 | |
2930 TODO: once the switch expansion logic is sufficiently separated, we can | |
2931 do better job on estimating cost of the switch. */ | |
2932 cost = gimple_switch_num_labels (stmt) * 2; | |
2933 break; | |
2934 | |
2935 case GIMPLE_CALL: | |
2936 { | |
2937 tree decl = gimple_call_fndecl (stmt); | |
2938 tree addr = gimple_call_fn (stmt); | |
2939 tree funtype = TREE_TYPE (addr); | |
2940 | |
2941 if (POINTER_TYPE_P (funtype)) | |
2942 funtype = TREE_TYPE (funtype); | |
2943 | |
2944 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD) | |
2945 cost = weights->target_builtin_call_cost; | |
2946 else | |
2947 cost = weights->call_cost; | |
2948 | |
2949 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) | |
2950 switch (DECL_FUNCTION_CODE (decl)) | |
2951 { | |
2952 case BUILT_IN_CONSTANT_P: | |
2953 return 0; | |
2954 case BUILT_IN_EXPECT: | |
2955 cost = 0; | |
2956 break; | |
2957 | |
2958 /* Prefetch instruction is not expensive. */ | |
2959 case BUILT_IN_PREFETCH: | |
2960 cost = weights->target_builtin_call_cost; | |
2961 break; | |
2962 | |
2963 default: | |
2964 break; | |
2965 } | |
2966 | |
2967 if (decl) | |
2968 funtype = TREE_TYPE (decl); | |
2969 | |
2970 /* Our cost must be kept in sync with | |
2971 cgraph_estimate_size_after_inlining that does use function | |
2972 declaration to figure out the arguments. */ | |
2973 if (decl && DECL_ARGUMENTS (decl)) | |
2974 { | |
2975 tree arg; | |
2976 for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg)) | |
2977 cost += estimate_move_cost (TREE_TYPE (arg)); | |
2978 } | |
2979 else if (funtype && prototype_p (funtype)) | |
2980 { | |
2981 tree t; | |
2982 for (t = TYPE_ARG_TYPES (funtype); t; t = TREE_CHAIN (t)) | |
2983 cost += estimate_move_cost (TREE_VALUE (t)); | |
2984 } | |
2985 else | |
2986 { | |
2987 for (i = 0; i < gimple_call_num_args (stmt); i++) | |
2988 { | |
2989 tree arg = gimple_call_arg (stmt, i); | |
2990 cost += estimate_move_cost (TREE_TYPE (arg)); | |
2991 } | |
2992 } | |
2993 | |
2994 break; | |
2995 } | |
2996 | |
2997 case GIMPLE_GOTO: | |
2998 case GIMPLE_LABEL: | |
2999 case GIMPLE_NOP: | |
3000 case GIMPLE_PHI: | |
3001 case GIMPLE_RETURN: | |
3002 case GIMPLE_CHANGE_DYNAMIC_TYPE: | |
3003 case GIMPLE_PREDICT: | |
3004 return 0; | |
3005 | |
3006 case GIMPLE_ASM: | |
3007 case GIMPLE_RESX: | |
3008 return 1; | |
3009 | |
3010 case GIMPLE_BIND: | |
3011 return estimate_num_insns_seq (gimple_bind_body (stmt), weights); | |
3012 | |
3013 case GIMPLE_EH_FILTER: | |
3014 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights); | |
3015 | |
3016 case GIMPLE_CATCH: | |
3017 return estimate_num_insns_seq (gimple_catch_handler (stmt), weights); | |
3018 | |
3019 case GIMPLE_TRY: | |
3020 return (estimate_num_insns_seq (gimple_try_eval (stmt), weights) | |
3021 + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights)); | |
3022 | |
3023 /* OpenMP directives are generally very expensive. */ | |
3024 | |
3025 case GIMPLE_OMP_RETURN: | |
3026 case GIMPLE_OMP_SECTIONS_SWITCH: | |
3027 case GIMPLE_OMP_ATOMIC_STORE: | |
3028 case GIMPLE_OMP_CONTINUE: | |
3029 /* ...except these, which are cheap. */ | |
3030 return 0; | |
3031 | |
3032 case GIMPLE_OMP_ATOMIC_LOAD: | |
3033 return weights->omp_cost; | |
3034 | |
3035 case GIMPLE_OMP_FOR: | |
3036 return (weights->omp_cost | |
3037 + estimate_num_insns_seq (gimple_omp_body (stmt), weights) | |
3038 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights)); | |
3039 | |
3040 case GIMPLE_OMP_PARALLEL: | |
3041 case GIMPLE_OMP_TASK: | |
3042 case GIMPLE_OMP_CRITICAL: | |
3043 case GIMPLE_OMP_MASTER: | |
3044 case GIMPLE_OMP_ORDERED: | |
3045 case GIMPLE_OMP_SECTION: | |
3046 case GIMPLE_OMP_SECTIONS: | |
3047 case GIMPLE_OMP_SINGLE: | |
3048 return (weights->omp_cost | |
3049 + estimate_num_insns_seq (gimple_omp_body (stmt), weights)); | |
3050 | |
3051 default: | |
3052 gcc_unreachable (); | |
3053 } | |
3054 | |
3055 return cost; | |
3056 } | |
3057 | |
3058 /* Estimate number of instructions that will be created by expanding | |
3059 function FNDECL. WEIGHTS contains weights attributed to various | |
3060 constructs. */ | |
3061 | |
3062 int | |
3063 estimate_num_insns_fn (tree fndecl, eni_weights *weights) | |
3064 { | |
3065 struct function *my_function = DECL_STRUCT_FUNCTION (fndecl); | |
3066 gimple_stmt_iterator bsi; | |
3067 basic_block bb; | |
3068 int n = 0; | |
3069 | |
3070 gcc_assert (my_function && my_function->cfg); | |
3071 FOR_EACH_BB_FN (bb, my_function) | |
3072 { | |
3073 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) | |
3074 n += estimate_num_insns (gsi_stmt (bsi), weights); | |
3075 } | |
3076 | |
3077 return n; | |
3078 } | |
3079 | |
3080 | |
3081 /* Initializes weights used by estimate_num_insns. */ | |
3082 | |
3083 void | |
3084 init_inline_once (void) | |
3085 { | |
3086 eni_inlining_weights.call_cost = PARAM_VALUE (PARAM_INLINE_CALL_COST); | |
3087 eni_inlining_weights.target_builtin_call_cost = 1; | |
3088 eni_inlining_weights.div_mod_cost = 10; | |
3089 eni_inlining_weights.omp_cost = 40; | |
3090 | |
3091 eni_size_weights.call_cost = 1; | |
3092 eni_size_weights.target_builtin_call_cost = 1; | |
3093 eni_size_weights.div_mod_cost = 1; | |
3094 eni_size_weights.omp_cost = 40; | |
3095 | |
3096 /* Estimating time for call is difficult, since we have no idea what the | |
3097 called function does. In the current uses of eni_time_weights, | |
3098 underestimating the cost does less harm than overestimating it, so | |
3099 we choose a rather small value here. */ | |
3100 eni_time_weights.call_cost = 10; | |
3101 eni_time_weights.target_builtin_call_cost = 10; | |
3102 eni_time_weights.div_mod_cost = 10; | |
3103 eni_time_weights.omp_cost = 40; | |
3104 } | |
3105 | |
3106 /* Estimate the number of instructions in a gimple_seq. */ | |
3107 | |
3108 int | |
3109 count_insns_seq (gimple_seq seq, eni_weights *weights) | |
3110 { | |
3111 gimple_stmt_iterator gsi; | |
3112 int n = 0; | |
3113 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) | |
3114 n += estimate_num_insns (gsi_stmt (gsi), weights); | |
3115 | |
3116 return n; | |
3117 } | |
3118 | |
3119 | |
3120 /* Install new lexical TREE_BLOCK underneath 'current_block'. */ | |
3121 | |
3122 static void | |
3123 prepend_lexical_block (tree current_block, tree new_block) | |
3124 { | |
3125 BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (current_block); | |
3126 BLOCK_SUBBLOCKS (current_block) = new_block; | |
3127 BLOCK_SUPERCONTEXT (new_block) = current_block; | |
3128 } | |
3129 | |
3130 /* Fetch callee declaration from the call graph edge going from NODE and | |
3131 associated with STMR call statement. Return NULL_TREE if not found. */ | |
3132 static tree | |
3133 get_indirect_callee_fndecl (struct cgraph_node *node, gimple stmt) | |
3134 { | |
3135 struct cgraph_edge *cs; | |
3136 | |
3137 cs = cgraph_edge (node, stmt); | |
3138 if (cs) | |
3139 return cs->callee->decl; | |
3140 | |
3141 return NULL_TREE; | |
3142 } | |
3143 | |
3144 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */ | |
3145 | |
3146 static bool | |
3147 expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) | |
3148 { | |
3149 tree retvar, use_retvar; | |
3150 tree fn; | |
3151 struct pointer_map_t *st; | |
3152 tree return_slot; | |
3153 tree modify_dest; | |
3154 location_t saved_location; | |
3155 struct cgraph_edge *cg_edge; | |
3156 const char *reason; | |
3157 basic_block return_block; | |
3158 edge e; | |
3159 gimple_stmt_iterator gsi, stmt_gsi; | |
3160 bool successfully_inlined = FALSE; | |
3161 bool purge_dead_abnormal_edges; | |
3162 tree t_step; | |
3163 tree var; | |
3164 | |
3165 /* Set input_location here so we get the right instantiation context | |
3166 if we call instantiate_decl from inlinable_function_p. */ | |
3167 saved_location = input_location; | |
3168 if (gimple_has_location (stmt)) | |
3169 input_location = gimple_location (stmt); | |
3170 | |
3171 /* From here on, we're only interested in CALL_EXPRs. */ | |
3172 if (gimple_code (stmt) != GIMPLE_CALL) | |
3173 goto egress; | |
3174 | |
3175 /* First, see if we can figure out what function is being called. | |
3176 If we cannot, then there is no hope of inlining the function. */ | |
3177 fn = gimple_call_fndecl (stmt); | |
3178 if (!fn) | |
3179 { | |
3180 fn = get_indirect_callee_fndecl (id->dst_node, stmt); | |
3181 if (!fn) | |
3182 goto egress; | |
3183 } | |
3184 | |
3185 /* Turn forward declarations into real ones. */ | |
3186 fn = cgraph_node (fn)->decl; | |
3187 | |
3188 /* If FN is a declaration of a function in a nested scope that was | |
3189 globally declared inline, we don't set its DECL_INITIAL. | |
3190 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the | |
3191 C++ front-end uses it for cdtors to refer to their internal | |
3192 declarations, that are not real functions. Fortunately those | |
3193 don't have trees to be saved, so we can tell by checking their | |
3194 gimple_body. */ | |
3195 if (!DECL_INITIAL (fn) | |
3196 && DECL_ABSTRACT_ORIGIN (fn) | |
3197 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn))) | |
3198 fn = DECL_ABSTRACT_ORIGIN (fn); | |
3199 | |
3200 /* Objective C and fortran still calls tree_rest_of_compilation directly. | |
3201 Kill this check once this is fixed. */ | |
3202 if (!id->dst_node->analyzed) | |
3203 goto egress; | |
3204 | |
3205 cg_edge = cgraph_edge (id->dst_node, stmt); | |
3206 | |
3207 /* Constant propagation on argument done during previous inlining | |
3208 may create new direct call. Produce an edge for it. */ | |
3209 if (!cg_edge) | |
3210 { | |
3211 struct cgraph_node *dest = cgraph_node (fn); | |
3212 | |
3213 /* We have missing edge in the callgraph. This can happen in one case | |
3214 where previous inlining turned indirect call into direct call by | |
3215 constant propagating arguments. In all other cases we hit a bug | |
3216 (incorrect node sharing is most common reason for missing edges. */ | |
3217 gcc_assert (dest->needed); | |
3218 cgraph_create_edge (id->dst_node, dest, stmt, | |
3219 bb->count, CGRAPH_FREQ_BASE, | |
3220 bb->loop_depth)->inline_failed | |
3221 = N_("originally indirect function call not considered for inlining"); | |
3222 if (dump_file) | |
3223 { | |
3224 fprintf (dump_file, "Created new direct edge to %s", | |
3225 cgraph_node_name (dest)); | |
3226 } | |
3227 goto egress; | |
3228 } | |
3229 | |
3230 /* Don't try to inline functions that are not well-suited to | |
3231 inlining. */ | |
3232 if (!cgraph_inline_p (cg_edge, &reason)) | |
3233 { | |
3234 /* If this call was originally indirect, we do not want to emit any | |
3235 inlining related warnings or sorry messages because there are no | |
3236 guarantees regarding those. */ | |
3237 if (cg_edge->indirect_call) | |
3238 goto egress; | |
3239 | |
3240 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) | |
3241 /* Avoid warnings during early inline pass. */ | |
3242 && cgraph_global_info_ready) | |
3243 { | |
3244 sorry ("inlining failed in call to %q+F: %s", fn, reason); | |
3245 sorry ("called from here"); | |
3246 } | |
3247 else if (warn_inline && DECL_DECLARED_INLINE_P (fn) | |
3248 && !DECL_IN_SYSTEM_HEADER (fn) | |
3249 && strlen (reason) | |
3250 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn)) | |
3251 /* Avoid warnings during early inline pass. */ | |
3252 && cgraph_global_info_ready) | |
3253 { | |
3254 warning (OPT_Winline, "inlining failed in call to %q+F: %s", | |
3255 fn, reason); | |
3256 warning (OPT_Winline, "called from here"); | |
3257 } | |
3258 goto egress; | |
3259 } | |
3260 fn = cg_edge->callee->decl; | |
3261 | |
3262 #ifdef ENABLE_CHECKING | |
3263 if (cg_edge->callee->decl != id->dst_node->decl) | |
3264 verify_cgraph_node (cg_edge->callee); | |
3265 #endif | |
3266 | |
3267 /* We will be inlining this callee. */ | |
3268 id->eh_region = lookup_stmt_eh_region (stmt); | |
3269 | |
3270 /* Split the block holding the GIMPLE_CALL. */ | |
3271 e = split_block (bb, stmt); | |
3272 bb = e->src; | |
3273 return_block = e->dest; | |
3274 remove_edge (e); | |
3275 | |
3276 /* split_block splits after the statement; work around this by | |
3277 moving the call into the second block manually. Not pretty, | |
3278 but seems easier than doing the CFG manipulation by hand | |
3279 when the GIMPLE_CALL is in the last statement of BB. */ | |
3280 stmt_gsi = gsi_last_bb (bb); | |
3281 gsi_remove (&stmt_gsi, false); | |
3282 | |
3283 /* If the GIMPLE_CALL was in the last statement of BB, it may have | |
3284 been the source of abnormal edges. In this case, schedule | |
3285 the removal of dead abnormal edges. */ | |
3286 gsi = gsi_start_bb (return_block); | |
3287 if (gsi_end_p (gsi)) | |
3288 { | |
3289 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT); | |
3290 purge_dead_abnormal_edges = true; | |
3291 } | |
3292 else | |
3293 { | |
3294 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); | |
3295 purge_dead_abnormal_edges = false; | |
3296 } | |
3297 | |
3298 stmt_gsi = gsi_start_bb (return_block); | |
3299 | |
3300 /* Build a block containing code to initialize the arguments, the | |
3301 actual inline expansion of the body, and a label for the return | |
3302 statements within the function to jump to. The type of the | |
3303 statement expression is the return type of the function call. */ | |
3304 id->block = make_node (BLOCK); | |
3305 BLOCK_ABSTRACT_ORIGIN (id->block) = fn; | |
3306 BLOCK_SOURCE_LOCATION (id->block) = input_location; | |
3307 prepend_lexical_block (gimple_block (stmt), id->block); | |
3308 | |
3309 /* Local declarations will be replaced by their equivalents in this | |
3310 map. */ | |
3311 st = id->decl_map; | |
3312 id->decl_map = pointer_map_create (); | |
3313 | |
3314 /* Record the function we are about to inline. */ | |
3315 id->src_fn = fn; | |
3316 id->src_node = cg_edge->callee; | |
3317 id->src_cfun = DECL_STRUCT_FUNCTION (fn); | |
3318 id->gimple_call = stmt; | |
3319 | |
3320 gcc_assert (!id->src_cfun->after_inlining); | |
3321 | |
3322 id->entry_bb = bb; | |
3323 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn))) | |
3324 { | |
3325 gimple_stmt_iterator si = gsi_last_bb (bb); | |
3326 gsi_insert_after (&si, gimple_build_predict (PRED_COLD_FUNCTION, | |
3327 NOT_TAKEN), | |
3328 GSI_NEW_STMT); | |
3329 } | |
3330 initialize_inlined_parameters (id, stmt, fn, bb); | |
3331 | |
3332 if (DECL_INITIAL (fn)) | |
3333 prepend_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id)); | |
3334 | |
3335 /* Return statements in the function body will be replaced by jumps | |
3336 to the RET_LABEL. */ | |
3337 gcc_assert (DECL_INITIAL (fn)); | |
3338 gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK); | |
3339 | |
3340 /* Find the LHS to which the result of this call is assigned. */ | |
3341 return_slot = NULL; | |
3342 if (gimple_call_lhs (stmt)) | |
3343 { | |
3344 modify_dest = gimple_call_lhs (stmt); | |
3345 | |
3346 /* The function which we are inlining might not return a value, | |
3347 in which case we should issue a warning that the function | |
3348 does not return a value. In that case the optimizers will | |
3349 see that the variable to which the value is assigned was not | |
3350 initialized. We do not want to issue a warning about that | |
3351 uninitialized variable. */ | |
3352 if (DECL_P (modify_dest)) | |
3353 TREE_NO_WARNING (modify_dest) = 1; | |
3354 | |
3355 if (gimple_call_return_slot_opt_p (stmt)) | |
3356 { | |
3357 return_slot = modify_dest; | |
3358 modify_dest = NULL; | |
3359 } | |
3360 } | |
3361 else | |
3362 modify_dest = NULL; | |
3363 | |
3364 /* If we are inlining a call to the C++ operator new, we don't want | |
3365 to use type based alias analysis on the return value. Otherwise | |
3366 we may get confused if the compiler sees that the inlined new | |
3367 function returns a pointer which was just deleted. See bug | |
3368 33407. */ | |
3369 if (DECL_IS_OPERATOR_NEW (fn)) | |
3370 { | |
3371 return_slot = NULL; | |
3372 modify_dest = NULL; | |
3373 } | |
3374 | |
3375 /* Declare the return variable for the function. */ | |
3376 retvar = declare_return_variable (id, return_slot, modify_dest, &use_retvar); | |
3377 | |
3378 if (DECL_IS_OPERATOR_NEW (fn)) | |
3379 { | |
3380 gcc_assert (TREE_CODE (retvar) == VAR_DECL | |
3381 && POINTER_TYPE_P (TREE_TYPE (retvar))); | |
3382 DECL_NO_TBAA_P (retvar) = 1; | |
3383 } | |
3384 | |
3385 /* Add local vars in this inlined callee to caller. */ | |
3386 t_step = id->src_cfun->local_decls; | |
3387 for (; t_step; t_step = TREE_CHAIN (t_step)) | |
3388 { | |
3389 var = TREE_VALUE (t_step); | |
3390 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var)) | |
3391 { | |
3392 if (var_ann (var) && add_referenced_var (var)) | |
3393 cfun->local_decls = tree_cons (NULL_TREE, var, | |
3394 cfun->local_decls); | |
3395 } | |
3396 else if (!can_be_nonlocal (var, id)) | |
3397 cfun->local_decls = tree_cons (NULL_TREE, remap_decl (var, id), | |
3398 cfun->local_decls); | |
3399 } | |
3400 | |
3401 /* This is it. Duplicate the callee body. Assume callee is | |
3402 pre-gimplified. Note that we must not alter the caller | |
3403 function in any way before this point, as this CALL_EXPR may be | |
3404 a self-referential call; if we're calling ourselves, we need to | |
3405 duplicate our body before altering anything. */ | |
3406 copy_body (id, bb->count, bb->frequency, bb, return_block); | |
3407 | |
3408 /* Clean up. */ | |
3409 pointer_map_destroy (id->decl_map); | |
3410 id->decl_map = st; | |
3411 | |
3412 /* If the inlined function returns a result that we care about, | |
3413 substitute the GIMPLE_CALL with an assignment of the return | |
3414 variable to the LHS of the call. That is, if STMT was | |
3415 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */ | |
3416 if (use_retvar && gimple_call_lhs (stmt)) | |
3417 { | |
3418 gimple old_stmt = stmt; | |
3419 stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar); | |
3420 gsi_replace (&stmt_gsi, stmt, false); | |
3421 if (gimple_in_ssa_p (cfun)) | |
3422 { | |
3423 update_stmt (stmt); | |
3424 mark_symbols_for_renaming (stmt); | |
3425 } | |
3426 maybe_clean_or_replace_eh_stmt (old_stmt, stmt); | |
3427 } | |
3428 else | |
3429 { | |
3430 /* Handle the case of inlining a function with no return | |
3431 statement, which causes the return value to become undefined. */ | |
3432 if (gimple_call_lhs (stmt) | |
3433 && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME) | |
3434 { | |
3435 tree name = gimple_call_lhs (stmt); | |
3436 tree var = SSA_NAME_VAR (name); | |
3437 tree def = gimple_default_def (cfun, var); | |
3438 | |
3439 if (def) | |
3440 { | |
3441 /* If the variable is used undefined, make this name | |
3442 undefined via a move. */ | |
3443 stmt = gimple_build_assign (gimple_call_lhs (stmt), def); | |
3444 gsi_replace (&stmt_gsi, stmt, true); | |
3445 update_stmt (stmt); | |
3446 } | |
3447 else | |
3448 { | |
3449 /* Otherwise make this variable undefined. */ | |
3450 gsi_remove (&stmt_gsi, true); | |
3451 set_default_def (var, name); | |
3452 SSA_NAME_DEF_STMT (name) = gimple_build_nop (); | |
3453 } | |
3454 } | |
3455 else | |
3456 gsi_remove (&stmt_gsi, true); | |
3457 } | |
3458 | |
3459 if (purge_dead_abnormal_edges) | |
3460 gimple_purge_dead_abnormal_call_edges (return_block); | |
3461 | |
3462 /* If the value of the new expression is ignored, that's OK. We | |
3463 don't warn about this for CALL_EXPRs, so we shouldn't warn about | |
3464 the equivalent inlined version either. */ | |
3465 if (is_gimple_assign (stmt)) | |
3466 { | |
3467 gcc_assert (gimple_assign_single_p (stmt) | |
3468 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))); | |
3469 TREE_USED (gimple_assign_rhs1 (stmt)) = 1; | |
3470 } | |
3471 | |
3472 /* Output the inlining info for this abstract function, since it has been | |
3473 inlined. If we don't do this now, we can lose the information about the | |
3474 variables in the function when the blocks get blown away as soon as we | |
3475 remove the cgraph node. */ | |
3476 (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl); | |
3477 | |
3478 /* Update callgraph if needed. */ | |
3479 cgraph_remove_node (cg_edge->callee); | |
3480 | |
3481 id->block = NULL_TREE; | |
3482 successfully_inlined = TRUE; | |
3483 | |
3484 egress: | |
3485 input_location = saved_location; | |
3486 return successfully_inlined; | |
3487 } | |
3488 | |
3489 /* Expand call statements reachable from STMT_P. | |
3490 We can only have CALL_EXPRs as the "toplevel" tree code or nested | |
3491 in a MODIFY_EXPR. See tree-gimple.c:get_call_expr_in(). We can | |
3492 unfortunately not use that function here because we need a pointer | |
3493 to the CALL_EXPR, not the tree itself. */ | |
3494 | |
3495 static bool | |
3496 gimple_expand_calls_inline (basic_block bb, copy_body_data *id) | |
3497 { | |
3498 gimple_stmt_iterator gsi; | |
3499 | |
3500 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
3501 { | |
3502 gimple stmt = gsi_stmt (gsi); | |
3503 | |
3504 if (is_gimple_call (stmt) | |
3505 && expand_call_inline (bb, stmt, id)) | |
3506 return true; | |
3507 } | |
3508 | |
3509 return false; | |
3510 } | |
3511 | |
3512 | |
3513 /* Walk all basic blocks created after FIRST and try to fold every statement | |
3514 in the STATEMENTS pointer set. */ | |
3515 | |
3516 static void | |
3517 fold_marked_statements (int first, struct pointer_set_t *statements) | |
3518 { | |
3519 for (; first < n_basic_blocks; first++) | |
3520 if (BASIC_BLOCK (first)) | |
3521 { | |
3522 gimple_stmt_iterator gsi; | |
3523 | |
3524 for (gsi = gsi_start_bb (BASIC_BLOCK (first)); | |
3525 !gsi_end_p (gsi); | |
3526 gsi_next (&gsi)) | |
3527 if (pointer_set_contains (statements, gsi_stmt (gsi))) | |
3528 { | |
3529 gimple old_stmt = gsi_stmt (gsi); | |
3530 | |
3531 if (fold_stmt (&gsi)) | |
3532 { | |
3533 /* Re-read the statement from GSI as fold_stmt() may | |
3534 have changed it. */ | |
3535 gimple new_stmt = gsi_stmt (gsi); | |
3536 update_stmt (new_stmt); | |
3537 | |
3538 if (is_gimple_call (old_stmt)) | |
3539 cgraph_update_edges_for_call_stmt (old_stmt, new_stmt); | |
3540 | |
3541 if (maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt)) | |
3542 gimple_purge_dead_eh_edges (BASIC_BLOCK (first)); | |
3543 } | |
3544 } | |
3545 } | |
3546 } | |
3547 | |
3548 /* Return true if BB has at least one abnormal outgoing edge. */ | |
3549 | |
3550 static inline bool | |
3551 has_abnormal_outgoing_edge_p (basic_block bb) | |
3552 { | |
3553 edge e; | |
3554 edge_iterator ei; | |
3555 | |
3556 FOR_EACH_EDGE (e, ei, bb->succs) | |
3557 if (e->flags & EDGE_ABNORMAL) | |
3558 return true; | |
3559 | |
3560 return false; | |
3561 } | |
3562 | |
3563 /* Expand calls to inline functions in the body of FN. */ | |
3564 | |
3565 unsigned int | |
3566 optimize_inline_calls (tree fn) | |
3567 { | |
3568 copy_body_data id; | |
3569 tree prev_fn; | |
3570 basic_block bb; | |
3571 int last = n_basic_blocks; | |
3572 struct gimplify_ctx gctx; | |
3573 | |
3574 /* There is no point in performing inlining if errors have already | |
3575 occurred -- and we might crash if we try to inline invalid | |
3576 code. */ | |
3577 if (errorcount || sorrycount) | |
3578 return 0; | |
3579 | |
3580 /* Clear out ID. */ | |
3581 memset (&id, 0, sizeof (id)); | |
3582 | |
3583 id.src_node = id.dst_node = cgraph_node (fn); | |
3584 id.dst_fn = fn; | |
3585 /* Or any functions that aren't finished yet. */ | |
3586 prev_fn = NULL_TREE; | |
3587 if (current_function_decl) | |
3588 { | |
3589 id.dst_fn = current_function_decl; | |
3590 prev_fn = current_function_decl; | |
3591 } | |
3592 | |
3593 id.copy_decl = copy_decl_maybe_to_var; | |
3594 id.transform_call_graph_edges = CB_CGE_DUPLICATE; | |
3595 id.transform_new_cfg = false; | |
3596 id.transform_return_to_modify = true; | |
3597 id.transform_lang_insert_block = NULL; | |
3598 id.statements_to_fold = pointer_set_create (); | |
3599 | |
3600 push_gimplify_context (&gctx); | |
3601 | |
3602 /* We make no attempts to keep dominance info up-to-date. */ | |
3603 free_dominance_info (CDI_DOMINATORS); | |
3604 free_dominance_info (CDI_POST_DOMINATORS); | |
3605 | |
3606 /* Register specific gimple functions. */ | |
3607 gimple_register_cfg_hooks (); | |
3608 | |
3609 /* Reach the trees by walking over the CFG, and note the | |
3610 enclosing basic-blocks in the call edges. */ | |
3611 /* We walk the blocks going forward, because inlined function bodies | |
3612 will split id->current_basic_block, and the new blocks will | |
3613 follow it; we'll trudge through them, processing their CALL_EXPRs | |
3614 along the way. */ | |
3615 FOR_EACH_BB (bb) | |
3616 gimple_expand_calls_inline (bb, &id); | |
3617 | |
3618 pop_gimplify_context (NULL); | |
3619 | |
3620 #ifdef ENABLE_CHECKING | |
3621 { | |
3622 struct cgraph_edge *e; | |
3623 | |
3624 verify_cgraph_node (id.dst_node); | |
3625 | |
3626 /* Double check that we inlined everything we are supposed to inline. */ | |
3627 for (e = id.dst_node->callees; e; e = e->next_callee) | |
3628 gcc_assert (e->inline_failed); | |
3629 } | |
3630 #endif | |
3631 | |
3632 /* Fold the statements before compacting/renumbering the basic blocks. */ | |
3633 fold_marked_statements (last, id.statements_to_fold); | |
3634 pointer_set_destroy (id.statements_to_fold); | |
3635 | |
3636 /* Renumber the (code) basic_blocks consecutively. */ | |
3637 compact_blocks (); | |
3638 /* Renumber the lexical scoping (non-code) blocks consecutively. */ | |
3639 number_blocks (fn); | |
3640 | |
3641 /* We are not going to maintain the cgraph edges up to date. | |
3642 Kill it so it won't confuse us. */ | |
3643 cgraph_node_remove_callees (id.dst_node); | |
3644 | |
3645 fold_cond_expr_cond (); | |
3646 | |
3647 /* It would be nice to check SSA/CFG/statement consistency here, but it is | |
3648 not possible yet - the IPA passes might make various functions to not | |
3649 throw and they don't care to proactively update local EH info. This is | |
3650 done later in fixup_cfg pass that also execute the verification. */ | |
3651 return (TODO_update_ssa | |
3652 | TODO_cleanup_cfg | |
3653 | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0) | |
3654 | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0)); | |
3655 } | |
3656 | |
3657 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */ | |
3658 | |
3659 tree | |
3660 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) | |
3661 { | |
3662 enum tree_code code = TREE_CODE (*tp); | |
3663 enum tree_code_class cl = TREE_CODE_CLASS (code); | |
3664 | |
3665 /* We make copies of most nodes. */ | |
3666 if (IS_EXPR_CODE_CLASS (cl) | |
3667 || code == TREE_LIST | |
3668 || code == TREE_VEC | |
3669 || code == TYPE_DECL | |
3670 || code == OMP_CLAUSE) | |
3671 { | |
3672 /* Because the chain gets clobbered when we make a copy, we save it | |
3673 here. */ | |
3674 tree chain = NULL_TREE, new_tree; | |
3675 | |
3676 chain = TREE_CHAIN (*tp); | |
3677 | |
3678 /* Copy the node. */ | |
3679 new_tree = copy_node (*tp); | |
3680 | |
3681 /* Propagate mudflap marked-ness. */ | |
3682 if (flag_mudflap && mf_marked_p (*tp)) | |
3683 mf_mark (new_tree); | |
3684 | |
3685 *tp = new_tree; | |
3686 | |
3687 /* Now, restore the chain, if appropriate. That will cause | |
3688 walk_tree to walk into the chain as well. */ | |
3689 if (code == PARM_DECL | |
3690 || code == TREE_LIST | |
3691 || code == OMP_CLAUSE) | |
3692 TREE_CHAIN (*tp) = chain; | |
3693 | |
3694 /* For now, we don't update BLOCKs when we make copies. So, we | |
3695 have to nullify all BIND_EXPRs. */ | |
3696 if (TREE_CODE (*tp) == BIND_EXPR) | |
3697 BIND_EXPR_BLOCK (*tp) = NULL_TREE; | |
3698 } | |
3699 else if (code == CONSTRUCTOR) | |
3700 { | |
3701 /* CONSTRUCTOR nodes need special handling because | |
3702 we need to duplicate the vector of elements. */ | |
3703 tree new_tree; | |
3704 | |
3705 new_tree = copy_node (*tp); | |
3706 | |
3707 /* Propagate mudflap marked-ness. */ | |
3708 if (flag_mudflap && mf_marked_p (*tp)) | |
3709 mf_mark (new_tree); | |
3710 | |
3711 CONSTRUCTOR_ELTS (new_tree) = VEC_copy (constructor_elt, gc, | |
3712 CONSTRUCTOR_ELTS (*tp)); | |
3713 *tp = new_tree; | |
3714 } | |
3715 else if (TREE_CODE_CLASS (code) == tcc_type) | |
3716 *walk_subtrees = 0; | |
3717 else if (TREE_CODE_CLASS (code) == tcc_declaration) | |
3718 *walk_subtrees = 0; | |
3719 else if (TREE_CODE_CLASS (code) == tcc_constant) | |
3720 *walk_subtrees = 0; | |
3721 else | |
3722 gcc_assert (code != STATEMENT_LIST); | |
3723 return NULL_TREE; | |
3724 } | |
3725 | |
3726 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains | |
3727 information indicating to what new SAVE_EXPR this one should be mapped, | |
3728 use that one. Otherwise, create a new node and enter it in ST. FN is | |
3729 the function into which the copy will be placed. */ | |
3730 | |
3731 static void | |
3732 remap_save_expr (tree *tp, void *st_, int *walk_subtrees) | |
3733 { | |
3734 struct pointer_map_t *st = (struct pointer_map_t *) st_; | |
3735 tree *n; | |
3736 tree t; | |
3737 | |
3738 /* See if we already encountered this SAVE_EXPR. */ | |
3739 n = (tree *) pointer_map_contains (st, *tp); | |
3740 | |
3741 /* If we didn't already remap this SAVE_EXPR, do so now. */ | |
3742 if (!n) | |
3743 { | |
3744 t = copy_node (*tp); | |
3745 | |
3746 /* Remember this SAVE_EXPR. */ | |
3747 *pointer_map_insert (st, *tp) = t; | |
3748 /* Make sure we don't remap an already-remapped SAVE_EXPR. */ | |
3749 *pointer_map_insert (st, t) = t; | |
3750 } | |
3751 else | |
3752 { | |
3753 /* We've already walked into this SAVE_EXPR; don't do it again. */ | |
3754 *walk_subtrees = 0; | |
3755 t = *n; | |
3756 } | |
3757 | |
3758 /* Replace this SAVE_EXPR with the copy. */ | |
3759 *tp = t; | |
3760 } | |
3761 | |
3762 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label, | |
3763 copies the declaration and enters it in the splay_tree in DATA (which is | |
3764 really an `copy_body_data *'). */ | |
3765 | |
3766 static tree | |
3767 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, | |
3768 void *data) | |
3769 { | |
3770 copy_body_data *id = (copy_body_data *) data; | |
3771 | |
3772 /* Don't walk into types. */ | |
3773 if (TYPE_P (*tp)) | |
3774 *walk_subtrees = 0; | |
3775 | |
3776 else if (TREE_CODE (*tp) == LABEL_EXPR) | |
3777 { | |
3778 tree decl = TREE_OPERAND (*tp, 0); | |
3779 | |
3780 /* Copy the decl and remember the copy. */ | |
3781 insert_decl_map (id, decl, id->copy_decl (decl, id)); | |
3782 } | |
3783 | |
3784 return NULL_TREE; | |
3785 } | |
3786 | |
3787 /* Perform any modifications to EXPR required when it is unsaved. Does | |
3788 not recurse into EXPR's subtrees. */ | |
3789 | |
3790 static void | |
3791 unsave_expr_1 (tree expr) | |
3792 { | |
3793 switch (TREE_CODE (expr)) | |
3794 { | |
3795 case TARGET_EXPR: | |
3796 /* Don't mess with a TARGET_EXPR that hasn't been expanded. | |
3797 It's OK for this to happen if it was part of a subtree that | |
3798 isn't immediately expanded, such as operand 2 of another | |
3799 TARGET_EXPR. */ | |
3800 if (TREE_OPERAND (expr, 1)) | |
3801 break; | |
3802 | |
3803 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3); | |
3804 TREE_OPERAND (expr, 3) = NULL_TREE; | |
3805 break; | |
3806 | |
3807 default: | |
3808 break; | |
3809 } | |
3810 } | |
3811 | |
3812 /* Called via walk_tree when an expression is unsaved. Using the | |
3813 splay_tree pointed to by ST (which is really a `splay_tree'), | |
3814 remaps all local declarations to appropriate replacements. */ | |
3815 | |
3816 static tree | |
3817 unsave_r (tree *tp, int *walk_subtrees, void *data) | |
3818 { | |
3819 copy_body_data *id = (copy_body_data *) data; | |
3820 struct pointer_map_t *st = id->decl_map; | |
3821 tree *n; | |
3822 | |
3823 /* Only a local declaration (variable or label). */ | |
3824 if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp)) | |
3825 || TREE_CODE (*tp) == LABEL_DECL) | |
3826 { | |
3827 /* Lookup the declaration. */ | |
3828 n = (tree *) pointer_map_contains (st, *tp); | |
3829 | |
3830 /* If it's there, remap it. */ | |
3831 if (n) | |
3832 *tp = *n; | |
3833 } | |
3834 | |
3835 else if (TREE_CODE (*tp) == STATEMENT_LIST) | |
3836 gcc_unreachable (); | |
3837 else if (TREE_CODE (*tp) == BIND_EXPR) | |
3838 copy_bind_expr (tp, walk_subtrees, id); | |
3839 else if (TREE_CODE (*tp) == SAVE_EXPR) | |
3840 remap_save_expr (tp, st, walk_subtrees); | |
3841 else | |
3842 { | |
3843 copy_tree_r (tp, walk_subtrees, NULL); | |
3844 | |
3845 /* Do whatever unsaving is required. */ | |
3846 unsave_expr_1 (*tp); | |
3847 } | |
3848 | |
3849 /* Keep iterating. */ | |
3850 return NULL_TREE; | |
3851 } | |
3852 | |
3853 /* Copies everything in EXPR and replaces variables, labels | |
3854 and SAVE_EXPRs local to EXPR. */ | |
3855 | |
3856 tree | |
3857 unsave_expr_now (tree expr) | |
3858 { | |
3859 copy_body_data id; | |
3860 | |
3861 /* There's nothing to do for NULL_TREE. */ | |
3862 if (expr == 0) | |
3863 return expr; | |
3864 | |
3865 /* Set up ID. */ | |
3866 memset (&id, 0, sizeof (id)); | |
3867 id.src_fn = current_function_decl; | |
3868 id.dst_fn = current_function_decl; | |
3869 id.decl_map = pointer_map_create (); | |
3870 | |
3871 id.copy_decl = copy_decl_no_change; | |
3872 id.transform_call_graph_edges = CB_CGE_DUPLICATE; | |
3873 id.transform_new_cfg = false; | |
3874 id.transform_return_to_modify = false; | |
3875 id.transform_lang_insert_block = NULL; | |
3876 | |
3877 /* Walk the tree once to find local labels. */ | |
3878 walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id); | |
3879 | |
3880 /* Walk the tree again, copying, remapping, and unsaving. */ | |
3881 walk_tree (&expr, unsave_r, &id, NULL); | |
3882 | |
3883 /* Clean up. */ | |
3884 pointer_map_destroy (id.decl_map); | |
3885 | |
3886 return expr; | |
3887 } | |
3888 | |
3889 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local | |
3890 label, copies the declaration and enters it in the splay_tree in DATA (which | |
3891 is really a 'copy_body_data *'. */ | |
3892 | |
3893 static tree | |
3894 mark_local_labels_stmt (gimple_stmt_iterator *gsip, | |
3895 bool *handled_ops_p ATTRIBUTE_UNUSED, | |
3896 struct walk_stmt_info *wi) | |
3897 { | |
3898 copy_body_data *id = (copy_body_data *) wi->info; | |
3899 gimple stmt = gsi_stmt (*gsip); | |
3900 | |
3901 if (gimple_code (stmt) == GIMPLE_LABEL) | |
3902 { | |
3903 tree decl = gimple_label_label (stmt); | |
3904 | |
3905 /* Copy the decl and remember the copy. */ | |
3906 insert_decl_map (id, decl, id->copy_decl (decl, id)); | |
3907 } | |
3908 | |
3909 return NULL_TREE; | |
3910 } | |
3911 | |
3912 | |
3913 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local. | |
3914 Using the splay_tree pointed to by ST (which is really a `splay_tree'), | |
3915 remaps all local declarations to appropriate replacements in gimple | |
3916 operands. */ | |
3917 | |
3918 static tree | |
3919 replace_locals_op (tree *tp, int *walk_subtrees, void *data) | |
3920 { | |
3921 struct walk_stmt_info *wi = (struct walk_stmt_info*) data; | |
3922 copy_body_data *id = (copy_body_data *) wi->info; | |
3923 struct pointer_map_t *st = id->decl_map; | |
3924 tree *n; | |
3925 tree expr = *tp; | |
3926 | |
3927 /* Only a local declaration (variable or label). */ | |
3928 if ((TREE_CODE (expr) == VAR_DECL | |
3929 && !TREE_STATIC (expr)) | |
3930 || TREE_CODE (expr) == LABEL_DECL) | |
3931 { | |
3932 /* Lookup the declaration. */ | |
3933 n = (tree *) pointer_map_contains (st, expr); | |
3934 | |
3935 /* If it's there, remap it. */ | |
3936 if (n) | |
3937 *tp = *n; | |
3938 *walk_subtrees = 0; | |
3939 } | |
3940 else if (TREE_CODE (expr) == STATEMENT_LIST | |
3941 || TREE_CODE (expr) == BIND_EXPR | |
3942 || TREE_CODE (expr) == SAVE_EXPR) | |
3943 gcc_unreachable (); | |
3944 else if (TREE_CODE (expr) == TARGET_EXPR) | |
3945 { | |
3946 /* Don't mess with a TARGET_EXPR that hasn't been expanded. | |
3947 It's OK for this to happen if it was part of a subtree that | |
3948 isn't immediately expanded, such as operand 2 of another | |
3949 TARGET_EXPR. */ | |
3950 if (!TREE_OPERAND (expr, 1)) | |
3951 { | |
3952 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3); | |
3953 TREE_OPERAND (expr, 3) = NULL_TREE; | |
3954 } | |
3955 } | |
3956 | |
3957 /* Keep iterating. */ | |
3958 return NULL_TREE; | |
3959 } | |
3960 | |
3961 | |
3962 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local. | |
3963 Using the splay_tree pointed to by ST (which is really a `splay_tree'), | |
3964 remaps all local declarations to appropriate replacements in gimple | |
3965 statements. */ | |
3966 | |
3967 static tree | |
3968 replace_locals_stmt (gimple_stmt_iterator *gsip, | |
3969 bool *handled_ops_p ATTRIBUTE_UNUSED, | |
3970 struct walk_stmt_info *wi) | |
3971 { | |
3972 copy_body_data *id = (copy_body_data *) wi->info; | |
3973 gimple stmt = gsi_stmt (*gsip); | |
3974 | |
3975 if (gimple_code (stmt) == GIMPLE_BIND) | |
3976 { | |
3977 tree block = gimple_bind_block (stmt); | |
3978 | |
3979 if (block) | |
3980 { | |
3981 remap_block (&block, id); | |
3982 gimple_bind_set_block (stmt, block); | |
3983 } | |
3984 | |
3985 /* This will remap a lot of the same decls again, but this should be | |
3986 harmless. */ | |
3987 if (gimple_bind_vars (stmt)) | |
3988 gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), NULL, id)); | |
3989 } | |
3990 | |
3991 /* Keep iterating. */ | |
3992 return NULL_TREE; | |
3993 } | |
3994 | |
3995 | |
3996 /* Copies everything in SEQ and replaces variables and labels local to | |
3997 current_function_decl. */ | |
3998 | |
3999 gimple_seq | |
4000 copy_gimple_seq_and_replace_locals (gimple_seq seq) | |
4001 { | |
4002 copy_body_data id; | |
4003 struct walk_stmt_info wi; | |
4004 struct pointer_set_t *visited; | |
4005 gimple_seq copy; | |
4006 | |
4007 /* There's nothing to do for NULL_TREE. */ | |
4008 if (seq == NULL) | |
4009 return seq; | |
4010 | |
4011 /* Set up ID. */ | |
4012 memset (&id, 0, sizeof (id)); | |
4013 id.src_fn = current_function_decl; | |
4014 id.dst_fn = current_function_decl; | |
4015 id.decl_map = pointer_map_create (); | |
4016 | |
4017 id.copy_decl = copy_decl_no_change; | |
4018 id.transform_call_graph_edges = CB_CGE_DUPLICATE; | |
4019 id.transform_new_cfg = false; | |
4020 id.transform_return_to_modify = false; | |
4021 id.transform_lang_insert_block = NULL; | |
4022 | |
4023 /* Walk the tree once to find local labels. */ | |
4024 memset (&wi, 0, sizeof (wi)); | |
4025 visited = pointer_set_create (); | |
4026 wi.info = &id; | |
4027 wi.pset = visited; | |
4028 walk_gimple_seq (seq, mark_local_labels_stmt, NULL, &wi); | |
4029 pointer_set_destroy (visited); | |
4030 | |
4031 copy = gimple_seq_copy (seq); | |
4032 | |
4033 /* Walk the copy, remapping decls. */ | |
4034 memset (&wi, 0, sizeof (wi)); | |
4035 wi.info = &id; | |
4036 walk_gimple_seq (copy, replace_locals_stmt, replace_locals_op, &wi); | |
4037 | |
4038 /* Clean up. */ | |
4039 pointer_map_destroy (id.decl_map); | |
4040 | |
4041 return copy; | |
4042 } | |
4043 | |
4044 | |
4045 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */ | |
4046 | |
4047 static tree | |
4048 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data) | |
4049 { | |
4050 if (*tp == data) | |
4051 return (tree) data; | |
4052 else | |
4053 return NULL; | |
4054 } | |
4055 | |
4056 bool | |
4057 debug_find_tree (tree top, tree search) | |
4058 { | |
4059 return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0; | |
4060 } | |
4061 | |
4062 | |
4063 /* Declare the variables created by the inliner. Add all the variables in | |
4064 VARS to BIND_EXPR. */ | |
4065 | |
4066 static void | |
4067 declare_inline_vars (tree block, tree vars) | |
4068 { | |
4069 tree t; | |
4070 for (t = vars; t; t = TREE_CHAIN (t)) | |
4071 { | |
4072 DECL_SEEN_IN_BIND_EXPR_P (t) = 1; | |
4073 gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t)); | |
4074 cfun->local_decls = tree_cons (NULL_TREE, t, cfun->local_decls); | |
4075 } | |
4076 | |
4077 if (block) | |
4078 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars); | |
4079 } | |
4080 | |
4081 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN, | |
4082 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to | |
4083 VAR_DECL translation. */ | |
4084 | |
4085 static tree | |
4086 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy) | |
4087 { | |
4088 /* Don't generate debug information for the copy if we wouldn't have | |
4089 generated it for the copy either. */ | |
4090 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl); | |
4091 DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl); | |
4092 | |
4093 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what | |
4094 declaration inspired this copy. */ | |
4095 DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl); | |
4096 | |
4097 /* The new variable/label has no RTL, yet. */ | |
4098 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL) | |
4099 && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy)) | |
4100 SET_DECL_RTL (copy, NULL_RTX); | |
4101 | |
4102 /* These args would always appear unused, if not for this. */ | |
4103 TREE_USED (copy) = 1; | |
4104 | |
4105 /* Set the context for the new declaration. */ | |
4106 if (!DECL_CONTEXT (decl)) | |
4107 /* Globals stay global. */ | |
4108 ; | |
4109 else if (DECL_CONTEXT (decl) != id->src_fn) | |
4110 /* Things that weren't in the scope of the function we're inlining | |
4111 from aren't in the scope we're inlining to, either. */ | |
4112 ; | |
4113 else if (TREE_STATIC (decl)) | |
4114 /* Function-scoped static variables should stay in the original | |
4115 function. */ | |
4116 ; | |
4117 else | |
4118 /* Ordinary automatic local variables are now in the scope of the | |
4119 new function. */ | |
4120 DECL_CONTEXT (copy) = id->dst_fn; | |
4121 | |
4122 return copy; | |
4123 } | |
4124 | |
4125 static tree | |
4126 copy_decl_to_var (tree decl, copy_body_data *id) | |
4127 { | |
4128 tree copy, type; | |
4129 | |
4130 gcc_assert (TREE_CODE (decl) == PARM_DECL | |
4131 || TREE_CODE (decl) == RESULT_DECL); | |
4132 | |
4133 type = TREE_TYPE (decl); | |
4134 | |
4135 copy = build_decl (VAR_DECL, DECL_NAME (decl), type); | |
4136 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl); | |
4137 TREE_READONLY (copy) = TREE_READONLY (decl); | |
4138 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); | |
4139 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl); | |
4140 DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl); | |
4141 | |
4142 return copy_decl_for_dup_finish (id, decl, copy); | |
4143 } | |
4144 | |
4145 /* Like copy_decl_to_var, but create a return slot object instead of a | |
4146 pointer variable for return by invisible reference. */ | |
4147 | |
4148 static tree | |
4149 copy_result_decl_to_var (tree decl, copy_body_data *id) | |
4150 { | |
4151 tree copy, type; | |
4152 | |
4153 gcc_assert (TREE_CODE (decl) == PARM_DECL | |
4154 || TREE_CODE (decl) == RESULT_DECL); | |
4155 | |
4156 type = TREE_TYPE (decl); | |
4157 if (DECL_BY_REFERENCE (decl)) | |
4158 type = TREE_TYPE (type); | |
4159 | |
4160 copy = build_decl (VAR_DECL, DECL_NAME (decl), type); | |
4161 TREE_READONLY (copy) = TREE_READONLY (decl); | |
4162 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); | |
4163 if (!DECL_BY_REFERENCE (decl)) | |
4164 { | |
4165 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl); | |
4166 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl); | |
4167 DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl); | |
4168 } | |
4169 | |
4170 return copy_decl_for_dup_finish (id, decl, copy); | |
4171 } | |
4172 | |
4173 tree | |
4174 copy_decl_no_change (tree decl, copy_body_data *id) | |
4175 { | |
4176 tree copy; | |
4177 | |
4178 copy = copy_node (decl); | |
4179 | |
4180 /* The COPY is not abstract; it will be generated in DST_FN. */ | |
4181 DECL_ABSTRACT (copy) = 0; | |
4182 lang_hooks.dup_lang_specific_decl (copy); | |
4183 | |
4184 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has | |
4185 been taken; it's for internal bookkeeping in expand_goto_internal. */ | |
4186 if (TREE_CODE (copy) == LABEL_DECL) | |
4187 { | |
4188 TREE_ADDRESSABLE (copy) = 0; | |
4189 LABEL_DECL_UID (copy) = -1; | |
4190 } | |
4191 | |
4192 return copy_decl_for_dup_finish (id, decl, copy); | |
4193 } | |
4194 | |
4195 static tree | |
4196 copy_decl_maybe_to_var (tree decl, copy_body_data *id) | |
4197 { | |
4198 if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL) | |
4199 return copy_decl_to_var (decl, id); | |
4200 else | |
4201 return copy_decl_no_change (decl, id); | |
4202 } | |
4203 | |
4204 /* Return a copy of the function's argument tree. */ | |
4205 static tree | |
4206 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id, | |
4207 bitmap args_to_skip, tree *vars) | |
4208 { | |
4209 tree arg, *parg; | |
4210 tree new_parm = NULL; | |
4211 int i = 0; | |
4212 | |
4213 parg = &new_parm; | |
4214 | |
4215 for (arg = orig_parm; arg; arg = TREE_CHAIN (arg), i++) | |
4216 if (!args_to_skip || !bitmap_bit_p (args_to_skip, i)) | |
4217 { | |
4218 tree new_tree = remap_decl (arg, id); | |
4219 lang_hooks.dup_lang_specific_decl (new_tree); | |
4220 *parg = new_tree; | |
4221 parg = &TREE_CHAIN (new_tree); | |
4222 } | |
4223 else if (!pointer_map_contains (id->decl_map, arg)) | |
4224 { | |
4225 /* Make an equivalent VAR_DECL. If the argument was used | |
4226 as temporary variable later in function, the uses will be | |
4227 replaced by local variable. */ | |
4228 tree var = copy_decl_to_var (arg, id); | |
4229 get_var_ann (var); | |
4230 add_referenced_var (var); | |
4231 insert_decl_map (id, arg, var); | |
4232 /* Declare this new variable. */ | |
4233 TREE_CHAIN (var) = *vars; | |
4234 *vars = var; | |
4235 } | |
4236 return new_parm; | |
4237 } | |
4238 | |
4239 /* Return a copy of the function's static chain. */ | |
4240 static tree | |
4241 copy_static_chain (tree static_chain, copy_body_data * id) | |
4242 { | |
4243 tree *chain_copy, *pvar; | |
4244 | |
4245 chain_copy = &static_chain; | |
4246 for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar)) | |
4247 { | |
4248 tree new_tree = remap_decl (*pvar, id); | |
4249 lang_hooks.dup_lang_specific_decl (new_tree); | |
4250 TREE_CHAIN (new_tree) = TREE_CHAIN (*pvar); | |
4251 *pvar = new_tree; | |
4252 } | |
4253 return static_chain; | |
4254 } | |
4255 | |
4256 /* Return true if the function is allowed to be versioned. | |
4257 This is a guard for the versioning functionality. */ | |
4258 bool | |
4259 tree_versionable_function_p (tree fndecl) | |
4260 { | |
4261 if (fndecl == NULL_TREE) | |
4262 return false; | |
4263 /* ??? There are cases where a function is | |
4264 uninlinable but can be versioned. */ | |
4265 if (!tree_inlinable_function_p (fndecl)) | |
4266 return false; | |
4267 | |
4268 return true; | |
4269 } | |
4270 | |
4271 /* Create a copy of a function's tree. | |
4272 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes | |
4273 of the original function and the new copied function | |
4274 respectively. In case we want to replace a DECL | |
4275 tree with another tree while duplicating the function's | |
4276 body, TREE_MAP represents the mapping between these | |
4277 trees. If UPDATE_CLONES is set, the call_stmt fields | |
4278 of edges of clones of the function will be updated. */ | |
4279 void | |
4280 tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map, | |
4281 bool update_clones, bitmap args_to_skip) | |
4282 { | |
4283 struct cgraph_node *old_version_node; | |
4284 struct cgraph_node *new_version_node; | |
4285 copy_body_data id; | |
4286 tree p; | |
4287 unsigned i; | |
4288 struct ipa_replace_map *replace_info; | |
4289 basic_block old_entry_block; | |
4290 VEC (gimple, heap) *init_stmts = VEC_alloc (gimple, heap, 10); | |
4291 | |
4292 tree t_step; | |
4293 tree old_current_function_decl = current_function_decl; | |
4294 tree vars = NULL_TREE; | |
4295 | |
4296 gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL | |
4297 && TREE_CODE (new_decl) == FUNCTION_DECL); | |
4298 DECL_POSSIBLY_INLINED (old_decl) = 1; | |
4299 | |
4300 old_version_node = cgraph_node (old_decl); | |
4301 new_version_node = cgraph_node (new_decl); | |
4302 | |
4303 /* Output the inlining info for this abstract function, since it has been | |
4304 inlined. If we don't do this now, we can lose the information about the | |
4305 variables in the function when the blocks get blown away as soon as we | |
4306 remove the cgraph node. */ | |
4307 (*debug_hooks->outlining_inline_function) (old_decl); | |
4308 | |
4309 DECL_ARTIFICIAL (new_decl) = 1; | |
4310 DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl); | |
4311 | |
4312 /* Prepare the data structures for the tree copy. */ | |
4313 memset (&id, 0, sizeof (id)); | |
4314 | |
4315 /* Generate a new name for the new version. */ | |
4316 if (!update_clones) | |
4317 { | |
4318 DECL_NAME (new_decl) = create_tmp_var_name (NULL); | |
4319 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl)); | |
4320 SET_DECL_RTL (new_decl, NULL_RTX); | |
4321 id.statements_to_fold = pointer_set_create (); | |
4322 } | |
4323 | |
4324 id.decl_map = pointer_map_create (); | |
4325 id.src_fn = old_decl; | |
4326 id.dst_fn = new_decl; | |
4327 id.src_node = old_version_node; | |
4328 id.dst_node = new_version_node; | |
4329 id.src_cfun = DECL_STRUCT_FUNCTION (old_decl); | |
4330 | |
4331 id.copy_decl = copy_decl_no_change; | |
4332 id.transform_call_graph_edges | |
4333 = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE; | |
4334 id.transform_new_cfg = true; | |
4335 id.transform_return_to_modify = false; | |
4336 id.transform_lang_insert_block = NULL; | |
4337 | |
4338 current_function_decl = new_decl; | |
4339 old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION | |
4340 (DECL_STRUCT_FUNCTION (old_decl)); | |
4341 initialize_cfun (new_decl, old_decl, | |
4342 old_entry_block->count, | |
4343 old_entry_block->frequency); | |
4344 push_cfun (DECL_STRUCT_FUNCTION (new_decl)); | |
4345 | |
4346 /* Copy the function's static chain. */ | |
4347 p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl; | |
4348 if (p) | |
4349 DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl = | |
4350 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl, | |
4351 &id); | |
4352 | |
4353 /* If there's a tree_map, prepare for substitution. */ | |
4354 if (tree_map) | |
4355 for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++) | |
4356 { | |
4357 gimple init; | |
4358 replace_info | |
4359 = (struct ipa_replace_map *) VARRAY_GENERIC_PTR (tree_map, i); | |
4360 if (replace_info->replace_p) | |
4361 { | |
4362 tree op = replace_info->new_tree; | |
4363 | |
4364 STRIP_NOPS (op); | |
4365 | |
4366 if (TREE_CODE (op) == VIEW_CONVERT_EXPR) | |
4367 op = TREE_OPERAND (op, 0); | |
4368 | |
4369 if (TREE_CODE (op) == ADDR_EXPR) | |
4370 { | |
4371 op = TREE_OPERAND (op, 0); | |
4372 while (handled_component_p (op)) | |
4373 op = TREE_OPERAND (op, 0); | |
4374 if (TREE_CODE (op) == VAR_DECL) | |
4375 add_referenced_var (op); | |
4376 } | |
4377 gcc_assert (TREE_CODE (replace_info->old_tree) == PARM_DECL); | |
4378 init = setup_one_parameter (&id, replace_info->old_tree, | |
4379 replace_info->new_tree, id.src_fn, | |
4380 NULL, | |
4381 &vars); | |
4382 if (init) | |
4383 VEC_safe_push (gimple, heap, init_stmts, init); | |
4384 } | |
4385 } | |
4386 /* Copy the function's arguments. */ | |
4387 if (DECL_ARGUMENTS (old_decl) != NULL_TREE) | |
4388 DECL_ARGUMENTS (new_decl) = | |
4389 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id, | |
4390 args_to_skip, &vars); | |
4391 | |
4392 DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id); | |
4393 | |
4394 /* Renumber the lexical scoping (non-code) blocks consecutively. */ | |
4395 number_blocks (id.dst_fn); | |
4396 | |
4397 declare_inline_vars (DECL_INITIAL (new_decl), vars); | |
4398 if (DECL_STRUCT_FUNCTION (old_decl)->local_decls != NULL_TREE) | |
4399 /* Add local vars. */ | |
4400 for (t_step = DECL_STRUCT_FUNCTION (old_decl)->local_decls; | |
4401 t_step; t_step = TREE_CHAIN (t_step)) | |
4402 { | |
4403 tree var = TREE_VALUE (t_step); | |
4404 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var)) | |
4405 cfun->local_decls = tree_cons (NULL_TREE, var, cfun->local_decls); | |
4406 else if (!can_be_nonlocal (var, &id)) | |
4407 cfun->local_decls = | |
4408 tree_cons (NULL_TREE, remap_decl (var, &id), | |
4409 cfun->local_decls); | |
4410 } | |
4411 | |
4412 /* Copy the Function's body. */ | |
4413 copy_body (&id, old_entry_block->count, old_entry_block->frequency, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR); | |
4414 | |
4415 if (DECL_RESULT (old_decl) != NULL_TREE) | |
4416 { | |
4417 tree *res_decl = &DECL_RESULT (old_decl); | |
4418 DECL_RESULT (new_decl) = remap_decl (*res_decl, &id); | |
4419 lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl)); | |
4420 } | |
4421 | |
4422 /* Renumber the lexical scoping (non-code) blocks consecutively. */ | |
4423 number_blocks (new_decl); | |
4424 | |
4425 if (VEC_length (gimple, init_stmts)) | |
4426 { | |
4427 basic_block bb = split_edge (single_succ_edge (ENTRY_BLOCK_PTR)); | |
4428 while (VEC_length (gimple, init_stmts)) | |
4429 insert_init_stmt (bb, VEC_pop (gimple, init_stmts)); | |
4430 } | |
4431 | |
4432 /* Clean up. */ | |
4433 pointer_map_destroy (id.decl_map); | |
4434 if (!update_clones) | |
4435 { | |
4436 fold_marked_statements (0, id.statements_to_fold); | |
4437 pointer_set_destroy (id.statements_to_fold); | |
4438 fold_cond_expr_cond (); | |
4439 } | |
4440 if (gimple_in_ssa_p (cfun)) | |
4441 { | |
4442 free_dominance_info (CDI_DOMINATORS); | |
4443 free_dominance_info (CDI_POST_DOMINATORS); | |
4444 if (!update_clones) | |
4445 delete_unreachable_blocks (); | |
4446 update_ssa (TODO_update_ssa); | |
4447 if (!update_clones) | |
4448 { | |
4449 fold_cond_expr_cond (); | |
4450 if (need_ssa_update_p ()) | |
4451 update_ssa (TODO_update_ssa); | |
4452 } | |
4453 } | |
4454 free_dominance_info (CDI_DOMINATORS); | |
4455 free_dominance_info (CDI_POST_DOMINATORS); | |
4456 VEC_free (gimple, heap, init_stmts); | |
4457 pop_cfun (); | |
4458 current_function_decl = old_current_function_decl; | |
4459 gcc_assert (!current_function_decl | |
4460 || DECL_STRUCT_FUNCTION (current_function_decl) == cfun); | |
4461 return; | |
4462 } | |
4463 | |
4464 /* Duplicate a type, fields and all. */ | |
4465 | |
4466 tree | |
4467 build_duplicate_type (tree type) | |
4468 { | |
4469 struct copy_body_data id; | |
4470 | |
4471 memset (&id, 0, sizeof (id)); | |
4472 id.src_fn = current_function_decl; | |
4473 id.dst_fn = current_function_decl; | |
4474 id.src_cfun = cfun; | |
4475 id.decl_map = pointer_map_create (); | |
4476 id.copy_decl = copy_decl_no_change; | |
4477 | |
4478 type = remap_type_1 (type, &id); | |
4479 | |
4480 pointer_map_destroy (id.decl_map); | |
4481 | |
4482 TYPE_CANONICAL (type) = type; | |
4483 | |
4484 return type; | |
4485 } | |
4486 | |
4487 /* Return whether it is safe to inline a function because it used different | |
4488 target specific options or different optimization options. */ | |
4489 bool | |
4490 tree_can_inline_p (tree caller, tree callee) | |
4491 { | |
4492 #if 0 | |
4493 /* This causes a regression in SPEC in that it prevents a cold function from | |
4494 inlining a hot function. Perhaps this should only apply to functions | |
4495 that the user declares hot/cold/optimize explicitly. */ | |
4496 | |
4497 /* Don't inline a function with a higher optimization level than the | |
4498 caller, or with different space constraints (hot/cold functions). */ | |
4499 tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (caller); | |
4500 tree callee_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee); | |
4501 | |
4502 if (caller_tree != callee_tree) | |
4503 { | |
4504 struct cl_optimization *caller_opt | |
4505 = TREE_OPTIMIZATION ((caller_tree) | |
4506 ? caller_tree | |
4507 : optimization_default_node); | |
4508 | |
4509 struct cl_optimization *callee_opt | |
4510 = TREE_OPTIMIZATION ((callee_tree) | |
4511 ? callee_tree | |
4512 : optimization_default_node); | |
4513 | |
4514 if ((caller_opt->optimize > callee_opt->optimize) | |
4515 || (caller_opt->optimize_size != callee_opt->optimize_size)) | |
4516 return false; | |
4517 } | |
4518 #endif | |
4519 | |
4520 /* Allow the backend to decide if inlining is ok. */ | |
4521 return targetm.target_option.can_inline_p (caller, callee); | |
4522 } |