Merge branch 'master' r217593-r217725 into gimple-classes-v2-option-3
[official-gcc.git] / gcc / tree-inline.c
blob45e0e62aa3c11393ece0ced567166e81d9c993b5
1 /* Tree inlining.
2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "diagnostic-core.h"
26 #include "tree.h"
27 #include "stor-layout.h"
28 #include "calls.h"
29 #include "tree-inline.h"
30 #include "flags.h"
31 #include "params.h"
32 #include "input.h"
33 #include "insn-config.h"
34 #include "hashtab.h"
35 #include "langhooks.h"
36 #include "predict.h"
37 #include "vec.h"
38 #include "hash-set.h"
39 #include "machmode.h"
40 #include "hard-reg-set.h"
41 #include "function.h"
42 #include "dominance.h"
43 #include "cfg.h"
44 #include "cfganal.h"
45 #include "basic-block.h"
46 #include "tree-iterator.h"
47 #include "intl.h"
48 #include "tree-ssa-alias.h"
49 #include "internal-fn.h"
50 #include "gimple-fold.h"
51 #include "tree-eh.h"
52 #include "gimple-expr.h"
53 #include "is-a.h"
54 #include "gimple.h"
55 #include "gimplify.h"
56 #include "gimple-iterator.h"
57 #include "gimplify-me.h"
58 #include "gimple-walk.h"
59 #include "gimple-ssa.h"
60 #include "tree-cfg.h"
61 #include "tree-phinodes.h"
62 #include "ssa-iterators.h"
63 #include "stringpool.h"
64 #include "tree-ssanames.h"
65 #include "tree-into-ssa.h"
66 #include "expr.h"
67 #include "tree-dfa.h"
68 #include "tree-ssa.h"
69 #include "tree-pretty-print.h"
70 #include "except.h"
71 #include "debug.h"
72 #include "hash-map.h"
73 #include "plugin-api.h"
74 #include "ipa-ref.h"
75 #include "cgraph.h"
76 #include "alloc-pool.h"
77 #include "ipa-prop.h"
78 #include "value-prof.h"
79 #include "tree-pass.h"
80 #include "target.h"
81 #include "cfgloop.h"
82 #include "builtins.h"
83 #include "tree-chkp.h"
85 #include "rtl.h" /* FIXME: For asm_str_count. */
87 /* I'm not real happy about this, but we need to handle gimple and
88 non-gimple trees. */
90 /* Inlining, Cloning, Versioning, Parallelization
92 Inlining: a function body is duplicated, but the PARM_DECLs are
93 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
94 MODIFY_EXPRs that store to a dedicated returned-value variable.
95 The duplicated eh_region info of the copy will later be appended
96 to the info for the caller; the eh_region info in copied throwing
97 statements and RESX statements are adjusted accordingly.
99 Cloning: (only in C++) We have one body for a con/de/structor, and
100 multiple function decls, each with a unique parameter list.
101 Duplicate the body, using the given splay tree; some parameters
102 will become constants (like 0 or 1).
104 Versioning: a function body is duplicated and the result is a new
105 function rather than into blocks of an existing function as with
106 inlining. Some parameters will become constants.
108 Parallelization: a region of a function is duplicated resulting in
109 a new function. Variables may be replaced with complex expressions
110 to enable shared variable semantics.
112 All of these will simultaneously lookup any callgraph edges. If
113 we're going to inline the duplicated function body, and the given
114 function has some cloned callgraph nodes (one for each place this
115 function will be inlined) those callgraph edges will be duplicated.
116 If we're cloning the body, those callgraph edges will be
117 updated to point into the new body. (Note that the original
118 callgraph node and edge list will not be altered.)
120 See the CALL_EXPR handling case in copy_tree_body_r (). */
122 /* To Do:
124 o In order to make inlining-on-trees work, we pessimized
125 function-local static constants. In particular, they are now
126 always output, even when not addressed. Fix this by treating
127 function-local static constants just like global static
128 constants; the back-end already knows not to output them if they
129 are not needed.
131 o Provide heuristics to clamp inlining of recursive template
132 calls? */
135 /* Weights that estimate_num_insns uses to estimate the size of the
136 produced code. */
138 eni_weights eni_size_weights;
140 /* Weights that estimate_num_insns uses to estimate the time necessary
141 to execute the produced code. */
143 eni_weights eni_time_weights;
145 /* Prototypes. */
147 static tree declare_return_variable (copy_body_data *, tree, tree, tree,
148 basic_block);
149 static void remap_block (tree *, copy_body_data *);
150 static void copy_bind_expr (tree *, int *, copy_body_data *);
151 static void declare_inline_vars (tree, tree);
152 static void remap_save_expr (tree *, hash_map<tree, tree> *, int *);
153 static void prepend_lexical_block (tree current_block, tree new_block);
154 static tree copy_decl_to_var (tree, copy_body_data *);
155 static tree copy_result_decl_to_var (tree, copy_body_data *);
156 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
157 static gimple_seq remap_gimple_stmt (gimple, copy_body_data *);
158 static bool delete_unreachable_blocks_update_callgraph (copy_body_data *id);
159 static void insert_init_stmt (copy_body_data *, basic_block, gimple);
161 /* Insert a tree->tree mapping for ID. Despite the name suggests
162 that the trees should be variables, it is used for more than that. */
164 void
165 insert_decl_map (copy_body_data *id, tree key, tree value)
167 id->decl_map->put (key, value);
169 /* Always insert an identity map as well. If we see this same new
170 node again, we won't want to duplicate it a second time. */
171 if (key != value)
172 id->decl_map->put (value, value);
175 /* Insert a tree->tree mapping for ID. This is only used for
176 variables. */
178 static void
179 insert_debug_decl_map (copy_body_data *id, tree key, tree value)
181 if (!gimple_in_ssa_p (id->src_cfun))
182 return;
184 if (!MAY_HAVE_DEBUG_STMTS)
185 return;
187 if (!target_for_debug_bind (key))
188 return;
190 gcc_assert (TREE_CODE (key) == PARM_DECL);
191 gcc_assert (TREE_CODE (value) == VAR_DECL);
193 if (!id->debug_map)
194 id->debug_map = new hash_map<tree, tree>;
196 id->debug_map->put (key, value);
199 /* If nonzero, we're remapping the contents of inlined debug
200 statements. If negative, an error has occurred, such as a
201 reference to a variable that isn't available in the inlined
202 context. */
203 static int processing_debug_stmt = 0;
205 /* Construct new SSA name for old NAME. ID is the inline context. */
207 static tree
208 remap_ssa_name (tree name, copy_body_data *id)
210 tree new_tree, var;
211 tree *n;
213 gcc_assert (TREE_CODE (name) == SSA_NAME);
215 n = id->decl_map->get (name);
216 if (n)
217 return unshare_expr (*n);
219 if (processing_debug_stmt)
221 if (SSA_NAME_IS_DEFAULT_DEF (name)
222 && TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL
223 && id->entry_bb == NULL
224 && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun)))
226 tree vexpr = make_node (DEBUG_EXPR_DECL);
227 gimple def_temp;
228 gimple_stmt_iterator gsi;
229 tree val = SSA_NAME_VAR (name);
231 n = id->decl_map->get (val);
232 if (n != NULL)
233 val = *n;
234 if (TREE_CODE (val) != PARM_DECL)
236 processing_debug_stmt = -1;
237 return name;
239 def_temp = gimple_build_debug_source_bind (vexpr, val, NULL);
240 DECL_ARTIFICIAL (vexpr) = 1;
241 TREE_TYPE (vexpr) = TREE_TYPE (name);
242 DECL_MODE (vexpr) = DECL_MODE (SSA_NAME_VAR (name));
243 gsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
244 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
245 return vexpr;
248 processing_debug_stmt = -1;
249 return name;
252 /* Remap anonymous SSA names or SSA names of anonymous decls. */
253 var = SSA_NAME_VAR (name);
254 if (!var
255 || (!SSA_NAME_IS_DEFAULT_DEF (name)
256 && TREE_CODE (var) == VAR_DECL
257 && !VAR_DECL_IS_VIRTUAL_OPERAND (var)
258 && DECL_ARTIFICIAL (var)
259 && DECL_IGNORED_P (var)
260 && !DECL_NAME (var)))
262 struct ptr_info_def *pi;
263 new_tree = make_ssa_name (remap_type (TREE_TYPE (name), id), NULL);
264 if (!var && SSA_NAME_IDENTIFIER (name))
265 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree, SSA_NAME_IDENTIFIER (name));
266 insert_decl_map (id, name, new_tree);
267 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
268 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
269 /* At least IPA points-to info can be directly transferred. */
270 if (id->src_cfun->gimple_df
271 && id->src_cfun->gimple_df->ipa_pta
272 && (pi = SSA_NAME_PTR_INFO (name))
273 && !pi->pt.anything)
275 struct ptr_info_def *new_pi = get_ptr_info (new_tree);
276 new_pi->pt = pi->pt;
278 return new_tree;
281 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
282 in copy_bb. */
283 new_tree = remap_decl (var, id);
285 /* We might've substituted constant or another SSA_NAME for
286 the variable.
288 Replace the SSA name representing RESULT_DECL by variable during
289 inlining: this saves us from need to introduce PHI node in a case
290 return value is just partly initialized. */
291 if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL)
292 && (!SSA_NAME_VAR (name)
293 || TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
294 || !id->transform_return_to_modify))
296 struct ptr_info_def *pi;
297 new_tree = make_ssa_name (new_tree, NULL);
298 insert_decl_map (id, name, new_tree);
299 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
300 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
301 /* At least IPA points-to info can be directly transferred. */
302 if (id->src_cfun->gimple_df
303 && id->src_cfun->gimple_df->ipa_pta
304 && (pi = SSA_NAME_PTR_INFO (name))
305 && !pi->pt.anything)
307 struct ptr_info_def *new_pi = get_ptr_info (new_tree);
308 new_pi->pt = pi->pt;
310 if (SSA_NAME_IS_DEFAULT_DEF (name))
312 /* By inlining function having uninitialized variable, we might
313 extend the lifetime (variable might get reused). This cause
314 ICE in the case we end up extending lifetime of SSA name across
315 abnormal edge, but also increase register pressure.
317 We simply initialize all uninitialized vars by 0 except
318 for case we are inlining to very first BB. We can avoid
319 this for all BBs that are not inside strongly connected
320 regions of the CFG, but this is expensive to test. */
321 if (id->entry_bb
322 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name)
323 && (!SSA_NAME_VAR (name)
324 || TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL)
325 && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR_FOR_FN (cfun),
326 0)->dest
327 || EDGE_COUNT (id->entry_bb->preds) != 1))
329 gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
330 gimple init_stmt;
331 tree zero = build_zero_cst (TREE_TYPE (new_tree));
333 init_stmt = gimple_build_assign (new_tree, zero);
334 gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT);
335 SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0;
337 else
339 SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop ();
340 set_ssa_default_def (cfun, SSA_NAME_VAR (new_tree), new_tree);
344 else
345 insert_decl_map (id, name, new_tree);
346 return new_tree;
349 /* Remap DECL during the copying of the BLOCK tree for the function. */
351 tree
352 remap_decl (tree decl, copy_body_data *id)
354 tree *n;
356 /* We only remap local variables in the current function. */
358 /* See if we have remapped this declaration. */
360 n = id->decl_map->get (decl);
362 if (!n && processing_debug_stmt)
364 processing_debug_stmt = -1;
365 return decl;
368 /* If we didn't already have an equivalent for this declaration,
369 create one now. */
370 if (!n)
372 /* Make a copy of the variable or label. */
373 tree t = id->copy_decl (decl, id);
375 /* Remember it, so that if we encounter this local entity again
376 we can reuse this copy. Do this early because remap_type may
377 need this decl for TYPE_STUB_DECL. */
378 insert_decl_map (id, decl, t);
380 if (!DECL_P (t))
381 return t;
383 /* Remap types, if necessary. */
384 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
385 if (TREE_CODE (t) == TYPE_DECL)
386 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
388 /* Remap sizes as necessary. */
389 walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL);
390 walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL);
392 /* If fields, do likewise for offset and qualifier. */
393 if (TREE_CODE (t) == FIELD_DECL)
395 walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL);
396 if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
397 walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL);
400 return t;
403 if (id->do_not_unshare)
404 return *n;
405 else
406 return unshare_expr (*n);
409 static tree
410 remap_type_1 (tree type, copy_body_data *id)
412 tree new_tree, t;
414 /* We do need a copy. build and register it now. If this is a pointer or
415 reference type, remap the designated type and make a new pointer or
416 reference type. */
417 if (TREE_CODE (type) == POINTER_TYPE)
419 new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
420 TYPE_MODE (type),
421 TYPE_REF_CAN_ALIAS_ALL (type));
422 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
423 new_tree = build_type_attribute_qual_variant (new_tree,
424 TYPE_ATTRIBUTES (type),
425 TYPE_QUALS (type));
426 insert_decl_map (id, type, new_tree);
427 return new_tree;
429 else if (TREE_CODE (type) == REFERENCE_TYPE)
431 new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
432 TYPE_MODE (type),
433 TYPE_REF_CAN_ALIAS_ALL (type));
434 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
435 new_tree = build_type_attribute_qual_variant (new_tree,
436 TYPE_ATTRIBUTES (type),
437 TYPE_QUALS (type));
438 insert_decl_map (id, type, new_tree);
439 return new_tree;
441 else
442 new_tree = copy_node (type);
444 insert_decl_map (id, type, new_tree);
446 /* This is a new type, not a copy of an old type. Need to reassociate
447 variants. We can handle everything except the main variant lazily. */
448 t = TYPE_MAIN_VARIANT (type);
449 if (type != t)
451 t = remap_type (t, id);
452 TYPE_MAIN_VARIANT (new_tree) = t;
453 TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t);
454 TYPE_NEXT_VARIANT (t) = new_tree;
456 else
458 TYPE_MAIN_VARIANT (new_tree) = new_tree;
459 TYPE_NEXT_VARIANT (new_tree) = NULL;
462 if (TYPE_STUB_DECL (type))
463 TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id);
465 /* Lazily create pointer and reference types. */
466 TYPE_POINTER_TO (new_tree) = NULL;
467 TYPE_REFERENCE_TO (new_tree) = NULL;
469 /* Copy all types that may contain references to local variables; be sure to
470 preserve sharing in between type and its main variant when possible. */
471 switch (TREE_CODE (new_tree))
473 case INTEGER_TYPE:
474 case REAL_TYPE:
475 case FIXED_POINT_TYPE:
476 case ENUMERAL_TYPE:
477 case BOOLEAN_TYPE:
478 if (TYPE_MAIN_VARIANT (new_tree) != new_tree)
480 gcc_checking_assert (TYPE_MIN_VALUE (type) == TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (type)));
481 gcc_checking_assert (TYPE_MAX_VALUE (type) == TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (type)));
483 TYPE_MIN_VALUE (new_tree) = TYPE_MIN_VALUE (TYPE_MAIN_VARIANT (new_tree));
484 TYPE_MAX_VALUE (new_tree) = TYPE_MAX_VALUE (TYPE_MAIN_VARIANT (new_tree));
486 else
488 t = TYPE_MIN_VALUE (new_tree);
489 if (t && TREE_CODE (t) != INTEGER_CST)
490 walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL);
492 t = TYPE_MAX_VALUE (new_tree);
493 if (t && TREE_CODE (t) != INTEGER_CST)
494 walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL);
496 return new_tree;
498 case FUNCTION_TYPE:
499 if (TYPE_MAIN_VARIANT (new_tree) != new_tree
500 && TREE_TYPE (type) == TREE_TYPE (TYPE_MAIN_VARIANT (type)))
501 TREE_TYPE (new_tree) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree));
502 else
503 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
504 if (TYPE_MAIN_VARIANT (new_tree) != new_tree
505 && TYPE_ARG_TYPES (type) == TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (type)))
506 TYPE_ARG_TYPES (new_tree) = TYPE_ARG_TYPES (TYPE_MAIN_VARIANT (new_tree));
507 else
508 walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL);
509 return new_tree;
511 case ARRAY_TYPE:
512 if (TYPE_MAIN_VARIANT (new_tree) != new_tree
513 && TREE_TYPE (type) == TREE_TYPE (TYPE_MAIN_VARIANT (type)))
514 TREE_TYPE (new_tree) = TREE_TYPE (TYPE_MAIN_VARIANT (new_tree));
515 else
516 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
518 if (TYPE_MAIN_VARIANT (new_tree) != new_tree)
520 gcc_checking_assert (TYPE_DOMAIN (type) == TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)));
521 TYPE_DOMAIN (new_tree) = TYPE_DOMAIN (TYPE_MAIN_VARIANT (new_tree));
523 else
524 TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id);
525 break;
527 case RECORD_TYPE:
528 case UNION_TYPE:
529 case QUAL_UNION_TYPE:
530 if (TYPE_MAIN_VARIANT (type) != type
531 && TYPE_FIELDS (type) == TYPE_FIELDS (TYPE_MAIN_VARIANT (type)))
532 TYPE_FIELDS (new_tree) = TYPE_FIELDS (TYPE_MAIN_VARIANT (new_tree));
533 else
535 tree f, nf = NULL;
537 for (f = TYPE_FIELDS (new_tree); f ; f = DECL_CHAIN (f))
539 t = remap_decl (f, id);
540 DECL_CONTEXT (t) = new_tree;
541 DECL_CHAIN (t) = nf;
542 nf = t;
544 TYPE_FIELDS (new_tree) = nreverse (nf);
546 break;
548 case OFFSET_TYPE:
549 default:
550 /* Shouldn't have been thought variable sized. */
551 gcc_unreachable ();
554 /* All variants of type share the same size, so use the already remaped data. */
555 if (TYPE_MAIN_VARIANT (new_tree) != new_tree)
557 gcc_checking_assert (TYPE_SIZE (type) == TYPE_SIZE (TYPE_MAIN_VARIANT (type)));
558 gcc_checking_assert (TYPE_SIZE_UNIT (type) == TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type)));
560 TYPE_SIZE (new_tree) = TYPE_SIZE (TYPE_MAIN_VARIANT (new_tree));
561 TYPE_SIZE_UNIT (new_tree) = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (new_tree));
563 else
565 walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL);
566 walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL);
569 return new_tree;
572 tree
573 remap_type (tree type, copy_body_data *id)
575 tree *node;
576 tree tmp;
578 if (type == NULL)
579 return type;
581 /* See if we have remapped this type. */
582 node = id->decl_map->get (type);
583 if (node)
584 return *node;
586 /* The type only needs remapping if it's variably modified. */
587 if (! variably_modified_type_p (type, id->src_fn))
589 insert_decl_map (id, type, type);
590 return type;
593 id->remapping_type_depth++;
594 tmp = remap_type_1 (type, id);
595 id->remapping_type_depth--;
597 return tmp;
600 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
602 static bool
603 can_be_nonlocal (tree decl, copy_body_data *id)
605 /* We can not duplicate function decls. */
606 if (TREE_CODE (decl) == FUNCTION_DECL)
607 return true;
609 /* Local static vars must be non-local or we get multiple declaration
610 problems. */
611 if (TREE_CODE (decl) == VAR_DECL
612 && !auto_var_in_fn_p (decl, id->src_fn))
613 return true;
615 return false;
618 static tree
619 remap_decls (tree decls, vec<tree, va_gc> **nonlocalized_list,
620 copy_body_data *id)
622 tree old_var;
623 tree new_decls = NULL_TREE;
625 /* Remap its variables. */
626 for (old_var = decls; old_var; old_var = DECL_CHAIN (old_var))
628 tree new_var;
630 if (can_be_nonlocal (old_var, id))
632 /* We need to add this variable to the local decls as otherwise
633 nothing else will do so. */
634 if (TREE_CODE (old_var) == VAR_DECL
635 && ! DECL_EXTERNAL (old_var))
636 add_local_decl (cfun, old_var);
637 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
638 && !DECL_IGNORED_P (old_var)
639 && nonlocalized_list)
640 vec_safe_push (*nonlocalized_list, old_var);
641 continue;
644 /* Remap the variable. */
645 new_var = remap_decl (old_var, id);
647 /* If we didn't remap this variable, we can't mess with its
648 TREE_CHAIN. If we remapped this variable to the return slot, it's
649 already declared somewhere else, so don't declare it here. */
651 if (new_var == id->retvar)
653 else if (!new_var)
655 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
656 && !DECL_IGNORED_P (old_var)
657 && nonlocalized_list)
658 vec_safe_push (*nonlocalized_list, old_var);
660 else
662 gcc_assert (DECL_P (new_var));
663 DECL_CHAIN (new_var) = new_decls;
664 new_decls = new_var;
666 /* Also copy value-expressions. */
667 if (TREE_CODE (new_var) == VAR_DECL
668 && DECL_HAS_VALUE_EXPR_P (new_var))
670 tree tem = DECL_VALUE_EXPR (new_var);
671 bool old_regimplify = id->regimplify;
672 id->remapping_type_depth++;
673 walk_tree (&tem, copy_tree_body_r, id, NULL);
674 id->remapping_type_depth--;
675 id->regimplify = old_regimplify;
676 SET_DECL_VALUE_EXPR (new_var, tem);
681 return nreverse (new_decls);
684 /* Copy the BLOCK to contain remapped versions of the variables
685 therein. And hook the new block into the block-tree. */
687 static void
688 remap_block (tree *block, copy_body_data *id)
690 tree old_block;
691 tree new_block;
693 /* Make the new block. */
694 old_block = *block;
695 new_block = make_node (BLOCK);
696 TREE_USED (new_block) = TREE_USED (old_block);
697 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
698 BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
699 BLOCK_NONLOCALIZED_VARS (new_block)
700 = vec_safe_copy (BLOCK_NONLOCALIZED_VARS (old_block));
701 *block = new_block;
703 /* Remap its variables. */
704 BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block),
705 &BLOCK_NONLOCALIZED_VARS (new_block),
706 id);
708 if (id->transform_lang_insert_block)
709 id->transform_lang_insert_block (new_block);
711 /* Remember the remapped block. */
712 insert_decl_map (id, old_block, new_block);
715 /* Copy the whole block tree and root it in id->block. */
716 static tree
717 remap_blocks (tree block, copy_body_data *id)
719 tree t;
720 tree new_tree = block;
722 if (!block)
723 return NULL;
725 remap_block (&new_tree, id);
726 gcc_assert (new_tree != block);
727 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
728 prepend_lexical_block (new_tree, remap_blocks (t, id));
729 /* Blocks are in arbitrary order, but make things slightly prettier and do
730 not swap order when producing a copy. */
731 BLOCK_SUBBLOCKS (new_tree) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree));
732 return new_tree;
735 /* Remap the block tree rooted at BLOCK to nothing. */
736 static void
737 remap_blocks_to_null (tree block, copy_body_data *id)
739 tree t;
740 insert_decl_map (id, block, NULL_TREE);
741 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
742 remap_blocks_to_null (t, id);
745 static void
746 copy_statement_list (tree *tp)
748 tree_stmt_iterator oi, ni;
749 tree new_tree;
751 new_tree = alloc_stmt_list ();
752 ni = tsi_start (new_tree);
753 oi = tsi_start (*tp);
754 TREE_TYPE (new_tree) = TREE_TYPE (*tp);
755 *tp = new_tree;
757 for (; !tsi_end_p (oi); tsi_next (&oi))
759 tree stmt = tsi_stmt (oi);
760 if (TREE_CODE (stmt) == STATEMENT_LIST)
761 /* This copy is not redundant; tsi_link_after will smash this
762 STATEMENT_LIST into the end of the one we're building, and we
763 don't want to do that with the original. */
764 copy_statement_list (&stmt);
765 tsi_link_after (&ni, stmt, TSI_CONTINUE_LINKING);
769 static void
770 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
772 tree block = BIND_EXPR_BLOCK (*tp);
773 /* Copy (and replace) the statement. */
774 copy_tree_r (tp, walk_subtrees, NULL);
775 if (block)
777 remap_block (&block, id);
778 BIND_EXPR_BLOCK (*tp) = block;
781 if (BIND_EXPR_VARS (*tp))
782 /* This will remap a lot of the same decls again, but this should be
783 harmless. */
784 BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
788 /* Create a new gimple_seq by remapping all the statements in BODY
789 using the inlining information in ID. */
791 static gimple_seq
792 remap_gimple_seq (gimple_seq body, copy_body_data *id)
794 gimple_stmt_iterator si;
795 gimple_seq new_body = NULL;
797 for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si))
799 gimple_seq new_stmts = remap_gimple_stmt (gsi_stmt (si), id);
800 gimple_seq_add_seq (&new_body, new_stmts);
803 return new_body;
807 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
808 block using the mapping information in ID. */
810 static gimple
811 copy_gimple_bind (gbind *stmt, copy_body_data *id)
813 gimple new_bind;
814 tree new_block, new_vars;
815 gimple_seq body, new_body;
817 /* Copy the statement. Note that we purposely don't use copy_stmt
818 here because we need to remap statements as we copy. */
819 body = gimple_bind_body (stmt);
820 new_body = remap_gimple_seq (body, id);
822 new_block = gimple_bind_block (stmt);
823 if (new_block)
824 remap_block (&new_block, id);
826 /* This will remap a lot of the same decls again, but this should be
827 harmless. */
828 new_vars = gimple_bind_vars (stmt);
829 if (new_vars)
830 new_vars = remap_decls (new_vars, NULL, id);
832 new_bind = gimple_build_bind (new_vars, new_body, new_block);
834 return new_bind;
837 /* Return true if DECL is a parameter or a SSA_NAME for a parameter. */
839 static bool
840 is_parm (tree decl)
842 if (TREE_CODE (decl) == SSA_NAME)
844 decl = SSA_NAME_VAR (decl);
845 if (!decl)
846 return false;
849 return (TREE_CODE (decl) == PARM_DECL);
852 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
853 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
854 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
855 recursing into the children nodes of *TP. */
857 static tree
858 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
860 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
861 copy_body_data *id = (copy_body_data *) wi_p->info;
862 tree fn = id->src_fn;
864 if (TREE_CODE (*tp) == SSA_NAME)
866 *tp = remap_ssa_name (*tp, id);
867 *walk_subtrees = 0;
868 return NULL;
870 else if (auto_var_in_fn_p (*tp, fn))
872 /* Local variables and labels need to be replaced by equivalent
873 variables. We don't want to copy static variables; there's
874 only one of those, no matter how many times we inline the
875 containing function. Similarly for globals from an outer
876 function. */
877 tree new_decl;
879 /* Remap the declaration. */
880 new_decl = remap_decl (*tp, id);
881 gcc_assert (new_decl);
882 /* Replace this variable with the copy. */
883 STRIP_TYPE_NOPS (new_decl);
884 /* ??? The C++ frontend uses void * pointer zero to initialize
885 any other type. This confuses the middle-end type verification.
886 As cloned bodies do not go through gimplification again the fixup
887 there doesn't trigger. */
888 if (TREE_CODE (new_decl) == INTEGER_CST
889 && !useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (new_decl)))
890 new_decl = fold_convert (TREE_TYPE (*tp), new_decl);
891 *tp = new_decl;
892 *walk_subtrees = 0;
894 else if (TREE_CODE (*tp) == STATEMENT_LIST)
895 gcc_unreachable ();
896 else if (TREE_CODE (*tp) == SAVE_EXPR)
897 gcc_unreachable ();
898 else if (TREE_CODE (*tp) == LABEL_DECL
899 && (!DECL_CONTEXT (*tp)
900 || decl_function_context (*tp) == id->src_fn))
901 /* These may need to be remapped for EH handling. */
902 *tp = remap_decl (*tp, id);
903 else if (TREE_CODE (*tp) == FIELD_DECL)
905 /* If the enclosing record type is variably_modified_type_p, the field
906 has already been remapped. Otherwise, it need not be. */
907 tree *n = id->decl_map->get (*tp);
908 if (n)
909 *tp = *n;
910 *walk_subtrees = 0;
912 else if (TYPE_P (*tp))
913 /* Types may need remapping as well. */
914 *tp = remap_type (*tp, id);
915 else if (CONSTANT_CLASS_P (*tp))
917 /* If this is a constant, we have to copy the node iff the type
918 will be remapped. copy_tree_r will not copy a constant. */
919 tree new_type = remap_type (TREE_TYPE (*tp), id);
921 if (new_type == TREE_TYPE (*tp))
922 *walk_subtrees = 0;
924 else if (TREE_CODE (*tp) == INTEGER_CST)
925 *tp = wide_int_to_tree (new_type, *tp);
926 else
928 *tp = copy_node (*tp);
929 TREE_TYPE (*tp) = new_type;
932 else
934 /* Otherwise, just copy the node. Note that copy_tree_r already
935 knows not to copy VAR_DECLs, etc., so this is safe. */
937 if (TREE_CODE (*tp) == MEM_REF)
939 /* We need to re-canonicalize MEM_REFs from inline substitutions
940 that can happen when a pointer argument is an ADDR_EXPR.
941 Recurse here manually to allow that. */
942 tree ptr = TREE_OPERAND (*tp, 0);
943 tree type = remap_type (TREE_TYPE (*tp), id);
944 tree old = *tp;
945 walk_tree (&ptr, remap_gimple_op_r, data, NULL);
946 *tp = fold_build2 (MEM_REF, type, ptr, TREE_OPERAND (*tp, 1));
947 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
948 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
949 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
950 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
951 remapped a parameter as the property might be valid only
952 for the parameter itself. */
953 if (TREE_THIS_NOTRAP (old)
954 && (!is_parm (TREE_OPERAND (old, 0))
955 || (!id->transform_parameter && is_parm (ptr))))
956 TREE_THIS_NOTRAP (*tp) = 1;
957 *walk_subtrees = 0;
958 return NULL;
961 /* Here is the "usual case". Copy this tree node, and then
962 tweak some special cases. */
963 copy_tree_r (tp, walk_subtrees, NULL);
965 if (TREE_CODE (*tp) != OMP_CLAUSE)
966 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
968 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
970 /* The copied TARGET_EXPR has never been expanded, even if the
971 original node was expanded already. */
972 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
973 TREE_OPERAND (*tp, 3) = NULL_TREE;
975 else if (TREE_CODE (*tp) == ADDR_EXPR)
977 /* Variable substitution need not be simple. In particular,
978 the MEM_REF substitution above. Make sure that
979 TREE_CONSTANT and friends are up-to-date. */
980 int invariant = is_gimple_min_invariant (*tp);
981 walk_tree (&TREE_OPERAND (*tp, 0), remap_gimple_op_r, data, NULL);
982 recompute_tree_invariant_for_addr_expr (*tp);
984 /* If this used to be invariant, but is not any longer,
985 then regimplification is probably needed. */
986 if (invariant && !is_gimple_min_invariant (*tp))
987 id->regimplify = true;
989 *walk_subtrees = 0;
993 /* Update the TREE_BLOCK for the cloned expr. */
994 if (EXPR_P (*tp))
996 tree new_block = id->remapping_type_depth == 0 ? id->block : NULL;
997 tree old_block = TREE_BLOCK (*tp);
998 if (old_block)
1000 tree *n;
1001 n = id->decl_map->get (TREE_BLOCK (*tp));
1002 if (n)
1003 new_block = *n;
1005 TREE_SET_BLOCK (*tp, new_block);
1008 /* Keep iterating. */
1009 return NULL_TREE;
1013 /* Called from copy_body_id via walk_tree. DATA is really a
1014 `copy_body_data *'. */
1016 tree
1017 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
1019 copy_body_data *id = (copy_body_data *) data;
1020 tree fn = id->src_fn;
1021 tree new_block;
1023 /* Begin by recognizing trees that we'll completely rewrite for the
1024 inlining context. Our output for these trees is completely
1025 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1026 into an edge). Further down, we'll handle trees that get
1027 duplicated and/or tweaked. */
1029 /* When requested, RETURN_EXPRs should be transformed to just the
1030 contained MODIFY_EXPR. The branch semantics of the return will
1031 be handled elsewhere by manipulating the CFG rather than a statement. */
1032 if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
1034 tree assignment = TREE_OPERAND (*tp, 0);
1036 /* If we're returning something, just turn that into an
1037 assignment into the equivalent of the original RESULT_DECL.
1038 If the "assignment" is just the result decl, the result
1039 decl has already been set (e.g. a recent "foo (&result_decl,
1040 ...)"); just toss the entire RETURN_EXPR. */
1041 if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
1043 /* Replace the RETURN_EXPR with (a copy of) the
1044 MODIFY_EXPR hanging underneath. */
1045 *tp = copy_node (assignment);
1047 else /* Else the RETURN_EXPR returns no value. */
1049 *tp = NULL;
1050 return (tree) (void *)1;
1053 else if (TREE_CODE (*tp) == SSA_NAME)
1055 *tp = remap_ssa_name (*tp, id);
1056 *walk_subtrees = 0;
1057 return NULL;
1060 /* Local variables and labels need to be replaced by equivalent
1061 variables. We don't want to copy static variables; there's only
1062 one of those, no matter how many times we inline the containing
1063 function. Similarly for globals from an outer function. */
1064 else if (auto_var_in_fn_p (*tp, fn))
1066 tree new_decl;
1068 /* Remap the declaration. */
1069 new_decl = remap_decl (*tp, id);
1070 gcc_assert (new_decl);
1071 /* Replace this variable with the copy. */
1072 STRIP_TYPE_NOPS (new_decl);
1073 *tp = new_decl;
1074 *walk_subtrees = 0;
1076 else if (TREE_CODE (*tp) == STATEMENT_LIST)
1077 copy_statement_list (tp);
1078 else if (TREE_CODE (*tp) == SAVE_EXPR
1079 || TREE_CODE (*tp) == TARGET_EXPR)
1080 remap_save_expr (tp, id->decl_map, walk_subtrees);
1081 else if (TREE_CODE (*tp) == LABEL_DECL
1082 && (! DECL_CONTEXT (*tp)
1083 || decl_function_context (*tp) == id->src_fn))
1084 /* These may need to be remapped for EH handling. */
1085 *tp = remap_decl (*tp, id);
1086 else if (TREE_CODE (*tp) == BIND_EXPR)
1087 copy_bind_expr (tp, walk_subtrees, id);
1088 /* Types may need remapping as well. */
1089 else if (TYPE_P (*tp))
1090 *tp = remap_type (*tp, id);
1092 /* If this is a constant, we have to copy the node iff the type will be
1093 remapped. copy_tree_r will not copy a constant. */
1094 else if (CONSTANT_CLASS_P (*tp))
1096 tree new_type = remap_type (TREE_TYPE (*tp), id);
1098 if (new_type == TREE_TYPE (*tp))
1099 *walk_subtrees = 0;
1101 else if (TREE_CODE (*tp) == INTEGER_CST)
1102 *tp = wide_int_to_tree (new_type, *tp);
1103 else
1105 *tp = copy_node (*tp);
1106 TREE_TYPE (*tp) = new_type;
1110 /* Otherwise, just copy the node. Note that copy_tree_r already
1111 knows not to copy VAR_DECLs, etc., so this is safe. */
1112 else
1114 /* Here we handle trees that are not completely rewritten.
1115 First we detect some inlining-induced bogosities for
1116 discarding. */
1117 if (TREE_CODE (*tp) == MODIFY_EXPR
1118 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
1119 && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn)))
1121 /* Some assignments VAR = VAR; don't generate any rtl code
1122 and thus don't count as variable modification. Avoid
1123 keeping bogosities like 0 = 0. */
1124 tree decl = TREE_OPERAND (*tp, 0), value;
1125 tree *n;
1127 n = id->decl_map->get (decl);
1128 if (n)
1130 value = *n;
1131 STRIP_TYPE_NOPS (value);
1132 if (TREE_CONSTANT (value) || TREE_READONLY (value))
1134 *tp = build_empty_stmt (EXPR_LOCATION (*tp));
1135 return copy_tree_body_r (tp, walk_subtrees, data);
1139 else if (TREE_CODE (*tp) == INDIRECT_REF)
1141 /* Get rid of *& from inline substitutions that can happen when a
1142 pointer argument is an ADDR_EXPR. */
1143 tree decl = TREE_OPERAND (*tp, 0);
1144 tree *n = id->decl_map->get (decl);
1145 if (n)
1147 /* If we happen to get an ADDR_EXPR in n->value, strip
1148 it manually here as we'll eventually get ADDR_EXPRs
1149 which lie about their types pointed to. In this case
1150 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1151 but we absolutely rely on that. As fold_indirect_ref
1152 does other useful transformations, try that first, though. */
1153 tree type = TREE_TYPE (*tp);
1154 tree ptr = id->do_not_unshare ? *n : unshare_expr (*n);
1155 tree old = *tp;
1156 *tp = gimple_fold_indirect_ref (ptr);
1157 if (! *tp)
1159 if (TREE_CODE (ptr) == ADDR_EXPR)
1162 = fold_indirect_ref_1 (EXPR_LOCATION (ptr), type, ptr);
1163 /* ??? We should either assert here or build
1164 a VIEW_CONVERT_EXPR instead of blindly leaking
1165 incompatible types to our IL. */
1166 if (! *tp)
1167 *tp = TREE_OPERAND (ptr, 0);
1169 else
1171 *tp = build1 (INDIRECT_REF, type, ptr);
1172 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1173 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
1174 TREE_READONLY (*tp) = TREE_READONLY (old);
1175 /* We cannot propagate the TREE_THIS_NOTRAP flag if we
1176 have remapped a parameter as the property might be
1177 valid only for the parameter itself. */
1178 if (TREE_THIS_NOTRAP (old)
1179 && (!is_parm (TREE_OPERAND (old, 0))
1180 || (!id->transform_parameter && is_parm (ptr))))
1181 TREE_THIS_NOTRAP (*tp) = 1;
1184 *walk_subtrees = 0;
1185 return NULL;
1188 else if (TREE_CODE (*tp) == MEM_REF)
1190 /* We need to re-canonicalize MEM_REFs from inline substitutions
1191 that can happen when a pointer argument is an ADDR_EXPR.
1192 Recurse here manually to allow that. */
1193 tree ptr = TREE_OPERAND (*tp, 0);
1194 tree type = remap_type (TREE_TYPE (*tp), id);
1195 tree old = *tp;
1196 walk_tree (&ptr, copy_tree_body_r, data, NULL);
1197 *tp = fold_build2 (MEM_REF, type, ptr, TREE_OPERAND (*tp, 1));
1198 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1199 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
1200 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
1201 /* We cannot propagate the TREE_THIS_NOTRAP flag if we have
1202 remapped a parameter as the property might be valid only
1203 for the parameter itself. */
1204 if (TREE_THIS_NOTRAP (old)
1205 && (!is_parm (TREE_OPERAND (old, 0))
1206 || (!id->transform_parameter && is_parm (ptr))))
1207 TREE_THIS_NOTRAP (*tp) = 1;
1208 *walk_subtrees = 0;
1209 return NULL;
1212 /* Here is the "usual case". Copy this tree node, and then
1213 tweak some special cases. */
1214 copy_tree_r (tp, walk_subtrees, NULL);
1216 /* If EXPR has block defined, map it to newly constructed block.
1217 When inlining we want EXPRs without block appear in the block
1218 of function call if we are not remapping a type. */
1219 if (EXPR_P (*tp))
1221 new_block = id->remapping_type_depth == 0 ? id->block : NULL;
1222 if (TREE_BLOCK (*tp))
1224 tree *n;
1225 n = id->decl_map->get (TREE_BLOCK (*tp));
1226 if (n)
1227 new_block = *n;
1229 TREE_SET_BLOCK (*tp, new_block);
1232 if (TREE_CODE (*tp) != OMP_CLAUSE)
1233 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
1235 /* The copied TARGET_EXPR has never been expanded, even if the
1236 original node was expanded already. */
1237 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
1239 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
1240 TREE_OPERAND (*tp, 3) = NULL_TREE;
1243 /* Variable substitution need not be simple. In particular, the
1244 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1245 and friends are up-to-date. */
1246 else if (TREE_CODE (*tp) == ADDR_EXPR)
1248 int invariant = is_gimple_min_invariant (*tp);
1249 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
1251 /* Handle the case where we substituted an INDIRECT_REF
1252 into the operand of the ADDR_EXPR. */
1253 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
1254 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
1255 else
1256 recompute_tree_invariant_for_addr_expr (*tp);
1258 /* If this used to be invariant, but is not any longer,
1259 then regimplification is probably needed. */
1260 if (invariant && !is_gimple_min_invariant (*tp))
1261 id->regimplify = true;
1263 *walk_subtrees = 0;
1267 /* Keep iterating. */
1268 return NULL_TREE;
1271 /* Helper for remap_gimple_stmt. Given an EH region number for the
1272 source function, map that to the duplicate EH region number in
1273 the destination function. */
1275 static int
1276 remap_eh_region_nr (int old_nr, copy_body_data *id)
1278 eh_region old_r, new_r;
1280 old_r = get_eh_region_from_number_fn (id->src_cfun, old_nr);
1281 new_r = static_cast<eh_region> (*id->eh_map->get (old_r));
1283 return new_r->index;
1286 /* Similar, but operate on INTEGER_CSTs. */
1288 static tree
1289 remap_eh_region_tree_nr (tree old_t_nr, copy_body_data *id)
1291 int old_nr, new_nr;
1293 old_nr = tree_to_shwi (old_t_nr);
1294 new_nr = remap_eh_region_nr (old_nr, id);
1296 return build_int_cst (integer_type_node, new_nr);
1299 /* Helper for copy_bb. Remap statement STMT using the inlining
1300 information in ID. Return the new statement copy. */
1302 static gimple_seq
1303 remap_gimple_stmt (gimple stmt, copy_body_data *id)
1305 gimple copy = NULL;
1306 struct walk_stmt_info wi;
1307 bool skip_first = false;
1308 gimple_seq stmts = NULL;
1310 /* Begin by recognizing trees that we'll completely rewrite for the
1311 inlining context. Our output for these trees is completely
1312 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1313 into an edge). Further down, we'll handle trees that get
1314 duplicated and/or tweaked. */
1316 /* When requested, GIMPLE_RETURNs should be transformed to just the
1317 contained GIMPLE_ASSIGN. The branch semantics of the return will
1318 be handled elsewhere by manipulating the CFG rather than the
1319 statement. */
1320 if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
1322 tree retval = gimple_return_retval (as_a <greturn *> (stmt));
1323 tree retbnd = gimple_return_retbnd (stmt);
1324 tree bndslot = id->retbnd;
1326 if (retbnd && bndslot)
1328 gimple bndcopy = gimple_build_assign (bndslot, retbnd);
1329 memset (&wi, 0, sizeof (wi));
1330 wi.info = id;
1331 walk_gimple_op (bndcopy, remap_gimple_op_r, &wi);
1332 gimple_seq_add_stmt (&stmts, bndcopy);
1335 /* If we're returning something, just turn that into an
1336 assignment into the equivalent of the original RESULT_DECL.
1337 If RETVAL is just the result decl, the result decl has
1338 already been set (e.g. a recent "foo (&result_decl, ...)");
1339 just toss the entire GIMPLE_RETURN. */
1340 if (retval
1341 && (TREE_CODE (retval) != RESULT_DECL
1342 && (TREE_CODE (retval) != SSA_NAME
1343 || ! SSA_NAME_VAR (retval)
1344 || TREE_CODE (SSA_NAME_VAR (retval)) != RESULT_DECL)))
1346 copy = gimple_build_assign (id->do_not_unshare
1347 ? id->retvar : unshare_expr (id->retvar),
1348 retval);
1349 /* id->retvar is already substituted. Skip it on later remapping. */
1350 skip_first = true;
1352 /* We need to copy bounds if return structure with pointers into
1353 instrumented function. */
1354 if (chkp_function_instrumented_p (id->dst_fn)
1355 && !bndslot
1356 && !BOUNDED_P (id->retvar)
1357 && chkp_type_has_pointer (TREE_TYPE (id->retvar)))
1358 id->assign_stmts.safe_push (copy);
1361 else
1362 return stmts;
1364 else if (gimple_has_substatements (stmt))
1366 gimple_seq s1, s2;
1368 /* When cloning bodies from the C++ front end, we will be handed bodies
1369 in High GIMPLE form. Handle here all the High GIMPLE statements that
1370 have embedded statements. */
1371 switch (gimple_code (stmt))
1373 case GIMPLE_BIND:
1374 copy = copy_gimple_bind (as_a <gbind *> (stmt), id);
1375 break;
1377 case GIMPLE_CATCH:
1379 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1380 s1 = remap_gimple_seq (gimple_catch_handler (catch_stmt), id);
1381 copy = gimple_build_catch (gimple_catch_types (catch_stmt), s1);
1383 break;
1385 case GIMPLE_EH_FILTER:
1386 s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id);
1387 copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1);
1388 break;
1390 case GIMPLE_TRY:
1391 s1 = remap_gimple_seq (gimple_try_eval (stmt), id);
1392 s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id);
1393 copy = gimple_build_try (s1, s2, gimple_try_kind (stmt));
1394 break;
1396 case GIMPLE_WITH_CLEANUP_EXPR:
1397 s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id);
1398 copy = gimple_build_wce (s1);
1399 break;
1401 case GIMPLE_OMP_PARALLEL:
1403 gomp_parallel *omp_par_stmt =
1404 as_a <gomp_parallel *> (stmt);
1405 s1 = remap_gimple_seq (gimple_omp_body (omp_par_stmt), id);
1406 copy = gimple_build_omp_parallel
1407 (s1,
1408 gimple_omp_parallel_clauses (omp_par_stmt),
1409 gimple_omp_parallel_child_fn (omp_par_stmt),
1410 gimple_omp_parallel_data_arg (omp_par_stmt));
1412 break;
1414 case GIMPLE_OMP_TASK:
1415 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1416 copy = gimple_build_omp_task
1417 (s1,
1418 gimple_omp_task_clauses (stmt),
1419 gimple_omp_task_child_fn (stmt),
1420 gimple_omp_task_data_arg (stmt),
1421 gimple_omp_task_copy_fn (stmt),
1422 gimple_omp_task_arg_size (stmt),
1423 gimple_omp_task_arg_align (stmt));
1424 break;
1426 case GIMPLE_OMP_FOR:
1427 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1428 s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id);
1429 copy = gimple_build_omp_for (s1, gimple_omp_for_kind (stmt),
1430 gimple_omp_for_clauses (stmt),
1431 gimple_omp_for_collapse (stmt), s2);
1433 size_t i;
1434 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1436 gimple_omp_for_set_index (copy, i,
1437 gimple_omp_for_index (stmt, i));
1438 gimple_omp_for_set_initial (copy, i,
1439 gimple_omp_for_initial (stmt, i));
1440 gimple_omp_for_set_final (copy, i,
1441 gimple_omp_for_final (stmt, i));
1442 gimple_omp_for_set_incr (copy, i,
1443 gimple_omp_for_incr (stmt, i));
1444 gimple_omp_for_set_cond (copy, i,
1445 gimple_omp_for_cond (stmt, i));
1448 break;
1450 case GIMPLE_OMP_MASTER:
1451 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1452 copy = gimple_build_omp_master (s1);
1453 break;
1455 case GIMPLE_OMP_TASKGROUP:
1456 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1457 copy = gimple_build_omp_taskgroup (s1);
1458 break;
1460 case GIMPLE_OMP_ORDERED:
1461 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1462 copy = gimple_build_omp_ordered (s1);
1463 break;
1465 case GIMPLE_OMP_SECTION:
1466 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1467 copy = gimple_build_omp_section (s1);
1468 break;
1470 case GIMPLE_OMP_SECTIONS:
1471 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1472 copy = gimple_build_omp_sections
1473 (s1, gimple_omp_sections_clauses (stmt));
1474 break;
1476 case GIMPLE_OMP_SINGLE:
1477 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1478 copy = gimple_build_omp_single
1479 (s1, gimple_omp_single_clauses (stmt));
1480 break;
1482 case GIMPLE_OMP_TARGET:
1483 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1484 copy = gimple_build_omp_target
1485 (s1, gimple_omp_target_kind (stmt),
1486 gimple_omp_target_clauses (stmt));
1487 break;
1489 case GIMPLE_OMP_TEAMS:
1490 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1491 copy = gimple_build_omp_teams
1492 (s1, gimple_omp_teams_clauses (stmt));
1493 break;
1495 case GIMPLE_OMP_CRITICAL:
1496 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1497 copy =
1498 gimple_build_omp_critical (s1,
1499 gimple_omp_critical_name (
1500 as_a <gomp_critical *> (stmt)));
1501 break;
1503 case GIMPLE_TRANSACTION:
1505 gtransaction *old_trans_stmt =
1506 as_a <gtransaction *> (stmt);
1507 gtransaction *new_trans_stmt;
1508 s1 = remap_gimple_seq (gimple_transaction_body (old_trans_stmt),
1509 id);
1510 copy = new_trans_stmt =
1511 gimple_build_transaction (s1,
1512 gimple_transaction_label (old_trans_stmt));
1513 gimple_transaction_set_subcode (
1514 new_trans_stmt,
1515 gimple_transaction_subcode (old_trans_stmt));
1517 break;
1519 default:
1520 gcc_unreachable ();
1523 else
1525 if (gimple_assign_copy_p (stmt)
1526 && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt)
1527 && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn))
1529 /* Here we handle statements that are not completely rewritten.
1530 First we detect some inlining-induced bogosities for
1531 discarding. */
1533 /* Some assignments VAR = VAR; don't generate any rtl code
1534 and thus don't count as variable modification. Avoid
1535 keeping bogosities like 0 = 0. */
1536 tree decl = gimple_assign_lhs (stmt), value;
1537 tree *n;
1539 n = id->decl_map->get (decl);
1540 if (n)
1542 value = *n;
1543 STRIP_TYPE_NOPS (value);
1544 if (TREE_CONSTANT (value) || TREE_READONLY (value))
1545 return NULL;
1549 /* For *ptr_N ={v} {CLOBBER}, if ptr_N is SSA_NAME defined
1550 in a block that we aren't copying during tree_function_versioning,
1551 just drop the clobber stmt. */
1552 if (id->blocks_to_copy && gimple_clobber_p (stmt))
1554 tree lhs = gimple_assign_lhs (stmt);
1555 if (TREE_CODE (lhs) == MEM_REF
1556 && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME)
1558 gimple def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (lhs, 0));
1559 if (gimple_bb (def_stmt)
1560 && !bitmap_bit_p (id->blocks_to_copy,
1561 gimple_bb (def_stmt)->index))
1562 return NULL;
1566 if (gimple_debug_bind_p (stmt))
1568 gdebug *copy =
1569 gimple_build_debug_bind (gimple_debug_bind_get_var (stmt),
1570 gimple_debug_bind_get_value (stmt),
1571 stmt);
1572 id->debug_stmts.safe_push (copy);
1573 gimple_seq_add_stmt (&stmts, copy);
1574 return stmts;
1576 if (gimple_debug_source_bind_p (stmt))
1578 gdebug *copy = gimple_build_debug_source_bind
1579 (gimple_debug_source_bind_get_var (stmt),
1580 gimple_debug_source_bind_get_value (stmt), stmt);
1581 id->debug_stmts.safe_push (copy);
1582 gimple_seq_add_stmt (&stmts, copy);
1583 return stmts;
1586 /* Create a new deep copy of the statement. */
1587 copy = gimple_copy (stmt);
1589 /* Clear flags that need revisiting. */
1590 if (gcall *call_stmt = dyn_cast <gcall *> (copy))
1591 if (gimple_call_tail_p (call_stmt))
1592 gimple_call_set_tail (call_stmt, false);
1594 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1595 RESX and EH_DISPATCH. */
1596 if (id->eh_map)
1597 switch (gimple_code (copy))
1599 case GIMPLE_CALL:
1601 tree r, fndecl = gimple_call_fndecl (copy);
1602 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
1603 switch (DECL_FUNCTION_CODE (fndecl))
1605 case BUILT_IN_EH_COPY_VALUES:
1606 r = gimple_call_arg (copy, 1);
1607 r = remap_eh_region_tree_nr (r, id);
1608 gimple_call_set_arg (copy, 1, r);
1609 /* FALLTHRU */
1611 case BUILT_IN_EH_POINTER:
1612 case BUILT_IN_EH_FILTER:
1613 r = gimple_call_arg (copy, 0);
1614 r = remap_eh_region_tree_nr (r, id);
1615 gimple_call_set_arg (copy, 0, r);
1616 break;
1618 default:
1619 break;
1622 /* Reset alias info if we didn't apply measures to
1623 keep it valid over inlining by setting DECL_PT_UID. */
1624 if (!id->src_cfun->gimple_df
1625 || !id->src_cfun->gimple_df->ipa_pta)
1626 gimple_call_reset_alias_info (as_a <gcall *> (copy));
1628 break;
1630 case GIMPLE_RESX:
1632 gresx *resx_stmt = as_a <gresx *> (copy);
1633 int r = gimple_resx_region (resx_stmt);
1634 r = remap_eh_region_nr (r, id);
1635 gimple_resx_set_region (resx_stmt, r);
1637 break;
1639 case GIMPLE_EH_DISPATCH:
1641 geh_dispatch *eh_dispatch = as_a <geh_dispatch *> (copy);
1642 int r = gimple_eh_dispatch_region (eh_dispatch);
1643 r = remap_eh_region_nr (r, id);
1644 gimple_eh_dispatch_set_region (eh_dispatch, r);
1646 break;
1648 default:
1649 break;
1653 /* If STMT has a block defined, map it to the newly constructed
1654 block. */
1655 if (gimple_block (copy))
1657 tree *n;
1658 n = id->decl_map->get (gimple_block (copy));
1659 gcc_assert (n);
1660 gimple_set_block (copy, *n);
1663 if (gimple_debug_bind_p (copy) || gimple_debug_source_bind_p (copy))
1665 gimple_seq_add_stmt (&stmts, copy);
1666 return stmts;
1669 /* Remap all the operands in COPY. */
1670 memset (&wi, 0, sizeof (wi));
1671 wi.info = id;
1672 if (skip_first)
1673 walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL);
1674 else
1675 walk_gimple_op (copy, remap_gimple_op_r, &wi);
1677 /* Clear the copied virtual operands. We are not remapping them here
1678 but are going to recreate them from scratch. */
1679 if (gimple_has_mem_ops (copy))
1681 gimple_set_vdef (copy, NULL_TREE);
1682 gimple_set_vuse (copy, NULL_TREE);
1685 gimple_seq_add_stmt (&stmts, copy);
1686 return stmts;
1690 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1691 later */
1693 static basic_block
1694 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
1695 gcov_type count_scale)
1697 gimple_stmt_iterator gsi, copy_gsi, seq_gsi;
1698 basic_block copy_basic_block;
1699 tree decl;
1700 gcov_type freq;
1701 basic_block prev;
1703 /* Search for previous copied basic block. */
1704 prev = bb->prev_bb;
1705 while (!prev->aux)
1706 prev = prev->prev_bb;
1708 /* create_basic_block() will append every new block to
1709 basic_block_info automatically. */
1710 copy_basic_block = create_basic_block (NULL, (void *) 0,
1711 (basic_block) prev->aux);
1712 copy_basic_block->count = apply_scale (bb->count, count_scale);
1714 /* We are going to rebuild frequencies from scratch. These values
1715 have just small importance to drive canonicalize_loop_headers. */
1716 freq = apply_scale ((gcov_type)bb->frequency, frequency_scale);
1718 /* We recompute frequencies after inlining, so this is quite safe. */
1719 if (freq > BB_FREQ_MAX)
1720 freq = BB_FREQ_MAX;
1721 copy_basic_block->frequency = freq;
1723 copy_gsi = gsi_start_bb (copy_basic_block);
1725 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1727 gimple_seq stmts;
1728 gimple stmt = gsi_stmt (gsi);
1729 gimple orig_stmt = stmt;
1730 gimple_stmt_iterator stmts_gsi;
1731 bool stmt_added = false;
1733 id->regimplify = false;
1734 stmts = remap_gimple_stmt (stmt, id);
1736 if (gimple_seq_empty_p (stmts))
1737 continue;
1739 seq_gsi = copy_gsi;
1741 for (stmts_gsi = gsi_start (stmts);
1742 !gsi_end_p (stmts_gsi); )
1744 stmt = gsi_stmt (stmts_gsi);
1746 /* Advance iterator now before stmt is moved to seq_gsi. */
1747 gsi_next (&stmts_gsi);
1749 if (gimple_nop_p (stmt))
1750 continue;
1752 gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun,
1753 orig_stmt);
1755 /* With return slot optimization we can end up with
1756 non-gimple (foo *)&this->m, fix that here. */
1757 if (is_gimple_assign (stmt)
1758 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
1759 && !is_gimple_val (gimple_assign_rhs1 (stmt)))
1761 tree new_rhs;
1762 new_rhs = force_gimple_operand_gsi (&seq_gsi,
1763 gimple_assign_rhs1 (stmt),
1764 true, NULL, false,
1765 GSI_CONTINUE_LINKING);
1766 gimple_assign_set_rhs1 (stmt, new_rhs);
1767 id->regimplify = false;
1770 gsi_insert_after (&seq_gsi, stmt, GSI_NEW_STMT);
1772 if (id->regimplify)
1773 gimple_regimplify_operands (stmt, &seq_gsi);
1775 stmt_added = true;
1778 if (!stmt_added)
1779 continue;
1781 /* If copy_basic_block has been empty at the start of this iteration,
1782 call gsi_start_bb again to get at the newly added statements. */
1783 if (gsi_end_p (copy_gsi))
1784 copy_gsi = gsi_start_bb (copy_basic_block);
1785 else
1786 gsi_next (&copy_gsi);
1788 /* Process the new statement. The call to gimple_regimplify_operands
1789 possibly turned the statement into multiple statements, we
1790 need to process all of them. */
1793 tree fn;
1794 gcall *call_stmt;
1796 stmt = gsi_stmt (copy_gsi);
1797 call_stmt = dyn_cast <gcall *> (stmt);
1798 if (call_stmt
1799 && gimple_call_va_arg_pack_p (call_stmt)
1800 && id->call_stmt)
1802 /* __builtin_va_arg_pack () should be replaced by
1803 all arguments corresponding to ... in the caller. */
1804 tree p;
1805 gcall *new_call;
1806 vec<tree> argarray;
1807 size_t nargs = gimple_call_num_args (id->call_stmt);
1808 size_t n, i, nargs_to_copy;
1809 bool remove_bounds = false;
1811 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p))
1812 nargs--;
1814 /* Bounds should be removed from arg pack in case
1815 we handle not instrumented call in instrumented
1816 function. */
1817 nargs_to_copy = nargs;
1818 if (gimple_call_with_bounds_p (id->call_stmt)
1819 && !gimple_call_with_bounds_p (stmt))
1821 for (i = gimple_call_num_args (id->call_stmt) - nargs;
1822 i < gimple_call_num_args (id->call_stmt);
1823 i++)
1824 if (POINTER_BOUNDS_P (gimple_call_arg (id->call_stmt, i)))
1825 nargs_to_copy--;
1826 remove_bounds = true;
1829 /* Create the new array of arguments. */
1830 n = nargs_to_copy + gimple_call_num_args (call_stmt);
1831 argarray.create (n);
1832 argarray.safe_grow_cleared (n);
1834 /* Copy all the arguments before '...' */
1835 memcpy (argarray.address (),
1836 gimple_call_arg_ptr (call_stmt, 0),
1837 gimple_call_num_args (call_stmt) * sizeof (tree));
1839 if (remove_bounds)
1841 /* Append the rest of arguments removing bounds. */
1842 unsigned cur = gimple_call_num_args (call_stmt);
1843 i = gimple_call_num_args (id->call_stmt) - nargs;
1844 for (i = gimple_call_num_args (id->call_stmt) - nargs;
1845 i < gimple_call_num_args (id->call_stmt);
1846 i++)
1847 if (!POINTER_BOUNDS_P (gimple_call_arg (id->call_stmt, i)))
1848 argarray[cur++] = gimple_call_arg (id->call_stmt, i);
1849 gcc_assert (cur == n);
1851 else
1853 /* Append the arguments passed in '...' */
1854 memcpy (argarray.address () + gimple_call_num_args (call_stmt),
1855 gimple_call_arg_ptr (id->call_stmt, 0)
1856 + (gimple_call_num_args (id->call_stmt) - nargs),
1857 nargs * sizeof (tree));
1860 new_call = gimple_build_call_vec (gimple_call_fn (call_stmt),
1861 argarray);
1863 argarray.release ();
1865 /* Copy all GIMPLE_CALL flags, location and block, except
1866 GF_CALL_VA_ARG_PACK. */
1867 gimple_call_copy_flags (new_call, call_stmt);
1868 gimple_call_set_va_arg_pack (new_call, false);
1869 gimple_set_location (new_call, gimple_location (stmt));
1870 gimple_set_block (new_call, gimple_block (stmt));
1871 gimple_call_set_lhs (new_call, gimple_call_lhs (call_stmt));
1873 gsi_replace (&copy_gsi, new_call, false);
1874 stmt = new_call;
1876 else if (is_gimple_call (stmt)
1877 && id->call_stmt
1878 && (decl = gimple_call_fndecl (stmt))
1879 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1880 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN)
1882 /* __builtin_va_arg_pack_len () should be replaced by
1883 the number of anonymous arguments. */
1884 size_t nargs = gimple_call_num_args (id->call_stmt), i;
1885 tree count, p;
1886 gimple new_stmt;
1888 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p))
1889 nargs--;
1891 /* For instrumented calls we should ignore bounds. */
1892 for (i = gimple_call_num_args (id->call_stmt) - nargs;
1893 i < gimple_call_num_args (id->call_stmt);
1894 i++)
1895 if (POINTER_BOUNDS_P (gimple_call_arg (id->call_stmt, i)))
1896 nargs--;
1898 count = build_int_cst (integer_type_node, nargs);
1899 new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count);
1900 gsi_replace (&copy_gsi, new_stmt, false);
1901 stmt = new_stmt;
1904 /* Statements produced by inlining can be unfolded, especially
1905 when we constant propagated some operands. We can't fold
1906 them right now for two reasons:
1907 1) folding require SSA_NAME_DEF_STMTs to be correct
1908 2) we can't change function calls to builtins.
1909 So we just mark statement for later folding. We mark
1910 all new statements, instead just statements that has changed
1911 by some nontrivial substitution so even statements made
1912 foldable indirectly are updated. If this turns out to be
1913 expensive, copy_body can be told to watch for nontrivial
1914 changes. */
1915 if (id->statements_to_fold)
1916 id->statements_to_fold->add (stmt);
1918 /* We're duplicating a CALL_EXPR. Find any corresponding
1919 callgraph edges and update or duplicate them. */
1920 if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
1922 struct cgraph_edge *edge;
1924 switch (id->transform_call_graph_edges)
1926 case CB_CGE_DUPLICATE:
1927 edge = id->src_node->get_edge (orig_stmt);
1928 if (edge)
1930 int edge_freq = edge->frequency;
1931 int new_freq;
1932 struct cgraph_edge *old_edge = edge;
1933 edge = edge->clone (id->dst_node, call_stmt,
1934 gimple_uid (stmt),
1935 REG_BR_PROB_BASE, CGRAPH_FREQ_BASE,
1936 true);
1937 /* We could also just rescale the frequency, but
1938 doing so would introduce roundoff errors and make
1939 verifier unhappy. */
1940 new_freq = compute_call_stmt_bb_frequency (id->dst_node->decl,
1941 copy_basic_block);
1943 /* Speculative calls consist of two edges - direct and indirect.
1944 Duplicate the whole thing and distribute frequencies accordingly. */
1945 if (edge->speculative)
1947 struct cgraph_edge *direct, *indirect;
1948 struct ipa_ref *ref;
1950 gcc_assert (!edge->indirect_unknown_callee);
1951 old_edge->speculative_call_info (direct, indirect, ref);
1952 indirect = indirect->clone (id->dst_node, call_stmt,
1953 gimple_uid (stmt),
1954 REG_BR_PROB_BASE, CGRAPH_FREQ_BASE,
1955 true);
1956 if (old_edge->frequency + indirect->frequency)
1958 edge->frequency = MIN (RDIV ((gcov_type)new_freq * old_edge->frequency,
1959 (old_edge->frequency + indirect->frequency)),
1960 CGRAPH_FREQ_MAX);
1961 indirect->frequency = MIN (RDIV ((gcov_type)new_freq * indirect->frequency,
1962 (old_edge->frequency + indirect->frequency)),
1963 CGRAPH_FREQ_MAX);
1965 id->dst_node->clone_reference (ref, stmt);
1967 else
1969 edge->frequency = new_freq;
1970 if (dump_file
1971 && profile_status_for_fn (cfun) != PROFILE_ABSENT
1972 && (edge_freq > edge->frequency + 10
1973 || edge_freq < edge->frequency - 10))
1975 fprintf (dump_file, "Edge frequency estimated by "
1976 "cgraph %i diverge from inliner's estimate %i\n",
1977 edge_freq,
1978 edge->frequency);
1979 fprintf (dump_file,
1980 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1981 bb->index,
1982 bb->frequency,
1983 copy_basic_block->frequency);
1987 break;
1989 case CB_CGE_MOVE_CLONES:
1990 id->dst_node->set_call_stmt_including_clones (orig_stmt,
1991 call_stmt);
1992 edge = id->dst_node->get_edge (stmt);
1993 break;
1995 case CB_CGE_MOVE:
1996 edge = id->dst_node->get_edge (orig_stmt);
1997 if (edge)
1998 edge->set_call_stmt (call_stmt);
1999 break;
2001 default:
2002 gcc_unreachable ();
2005 /* Constant propagation on argument done during inlining
2006 may create new direct call. Produce an edge for it. */
2007 if ((!edge
2008 || (edge->indirect_inlining_edge
2009 && id->transform_call_graph_edges == CB_CGE_MOVE_CLONES))
2010 && id->dst_node->definition
2011 && (fn = gimple_call_fndecl (stmt)) != NULL)
2013 struct cgraph_node *dest = cgraph_node::get (fn);
2015 /* We have missing edge in the callgraph. This can happen
2016 when previous inlining turned an indirect call into a
2017 direct call by constant propagating arguments or we are
2018 producing dead clone (for further cloning). In all
2019 other cases we hit a bug (incorrect node sharing is the
2020 most common reason for missing edges). */
2021 gcc_assert (!dest->definition
2022 || dest->address_taken
2023 || !id->src_node->definition
2024 || !id->dst_node->definition);
2025 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES)
2026 id->dst_node->create_edge_including_clones
2027 (dest, orig_stmt, call_stmt, bb->count,
2028 compute_call_stmt_bb_frequency (id->dst_node->decl,
2029 copy_basic_block),
2030 CIF_ORIGINALLY_INDIRECT_CALL);
2031 else
2032 id->dst_node->create_edge (dest, call_stmt,
2033 bb->count,
2034 compute_call_stmt_bb_frequency
2035 (id->dst_node->decl,
2036 copy_basic_block))->inline_failed
2037 = CIF_ORIGINALLY_INDIRECT_CALL;
2038 if (dump_file)
2040 fprintf (dump_file, "Created new direct edge to %s\n",
2041 dest->name ());
2045 notice_special_calls (as_a <gcall *> (stmt));
2048 maybe_duplicate_eh_stmt_fn (cfun, stmt, id->src_cfun, orig_stmt,
2049 id->eh_map, id->eh_lp_nr);
2051 if (gimple_in_ssa_p (cfun) && !is_gimple_debug (stmt))
2053 ssa_op_iter i;
2054 tree def;
2056 FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
2057 if (TREE_CODE (def) == SSA_NAME)
2058 SSA_NAME_DEF_STMT (def) = stmt;
2061 gsi_next (&copy_gsi);
2063 while (!gsi_end_p (copy_gsi));
2065 copy_gsi = gsi_last_bb (copy_basic_block);
2068 return copy_basic_block;
2071 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
2072 form is quite easy, since dominator relationship for old basic blocks does
2073 not change.
2075 There is however exception where inlining might change dominator relation
2076 across EH edges from basic block within inlined functions destinating
2077 to landing pads in function we inline into.
2079 The function fills in PHI_RESULTs of such PHI nodes if they refer
2080 to gimple regs. Otherwise, the function mark PHI_RESULT of such
2081 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
2082 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
2083 set, and this means that there will be no overlapping live ranges
2084 for the underlying symbol.
2086 This might change in future if we allow redirecting of EH edges and
2087 we might want to change way build CFG pre-inlining to include
2088 all the possible edges then. */
2089 static void
2090 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
2091 bool can_throw, bool nonlocal_goto)
2093 edge e;
2094 edge_iterator ei;
2096 FOR_EACH_EDGE (e, ei, bb->succs)
2097 if (!e->dest->aux
2098 || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
2100 gphi *phi;
2101 gphi_iterator si;
2103 if (!nonlocal_goto)
2104 gcc_assert (e->flags & EDGE_EH);
2106 if (!can_throw)
2107 gcc_assert (!(e->flags & EDGE_EH));
2109 for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si))
2111 edge re;
2113 phi = si.phi ();
2115 /* For abnormal goto/call edges the receiver can be the
2116 ENTRY_BLOCK. Do not assert this cannot happen. */
2118 gcc_assert ((e->flags & EDGE_EH)
2119 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)));
2121 re = find_edge (ret_bb, e->dest);
2122 gcc_checking_assert (re);
2123 gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
2124 == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
2126 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
2127 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
2133 /* Copy edges from BB into its copy constructed earlier, scale profile
2134 accordingly. Edges will be taken care of later. Assume aux
2135 pointers to point to the copies of each BB. Return true if any
2136 debug stmts are left after a statement that must end the basic block. */
2138 static bool
2139 copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb,
2140 basic_block abnormal_goto_dest)
2142 basic_block new_bb = (basic_block) bb->aux;
2143 edge_iterator ei;
2144 edge old_edge;
2145 gimple_stmt_iterator si;
2146 int flags;
2147 bool need_debug_cleanup = false;
2149 /* Use the indices from the original blocks to create edges for the
2150 new ones. */
2151 FOR_EACH_EDGE (old_edge, ei, bb->succs)
2152 if (!(old_edge->flags & EDGE_EH))
2154 edge new_edge;
2156 flags = old_edge->flags;
2158 /* Return edges do get a FALLTHRU flag when the get inlined. */
2159 if (old_edge->dest->index == EXIT_BLOCK
2160 && !(old_edge->flags & (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE|EDGE_FAKE))
2161 && old_edge->dest->aux != EXIT_BLOCK_PTR_FOR_FN (cfun))
2162 flags |= EDGE_FALLTHRU;
2163 new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
2164 new_edge->count = apply_scale (old_edge->count, count_scale);
2165 new_edge->probability = old_edge->probability;
2168 if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
2169 return false;
2171 for (si = gsi_start_bb (new_bb); !gsi_end_p (si);)
2173 gimple copy_stmt;
2174 bool can_throw, nonlocal_goto;
2176 copy_stmt = gsi_stmt (si);
2177 if (!is_gimple_debug (copy_stmt))
2178 update_stmt (copy_stmt);
2180 /* Do this before the possible split_block. */
2181 gsi_next (&si);
2183 /* If this tree could throw an exception, there are two
2184 cases where we need to add abnormal edge(s): the
2185 tree wasn't in a region and there is a "current
2186 region" in the caller; or the original tree had
2187 EH edges. In both cases split the block after the tree,
2188 and add abnormal edge(s) as needed; we need both
2189 those from the callee and the caller.
2190 We check whether the copy can throw, because the const
2191 propagation can change an INDIRECT_REF which throws
2192 into a COMPONENT_REF which doesn't. If the copy
2193 can throw, the original could also throw. */
2194 can_throw = stmt_can_throw_internal (copy_stmt);
2195 nonlocal_goto
2196 = (stmt_can_make_abnormal_goto (copy_stmt)
2197 && !computed_goto_p (copy_stmt));
2199 if (can_throw || nonlocal_goto)
2201 if (!gsi_end_p (si))
2203 while (!gsi_end_p (si) && is_gimple_debug (gsi_stmt (si)))
2204 gsi_next (&si);
2205 if (gsi_end_p (si))
2206 need_debug_cleanup = true;
2208 if (!gsi_end_p (si))
2209 /* Note that bb's predecessor edges aren't necessarily
2210 right at this point; split_block doesn't care. */
2212 edge e = split_block (new_bb, copy_stmt);
2214 new_bb = e->dest;
2215 new_bb->aux = e->src->aux;
2216 si = gsi_start_bb (new_bb);
2220 if (gimple_code (copy_stmt) == GIMPLE_EH_DISPATCH)
2221 make_eh_dispatch_edges (as_a <geh_dispatch *> (copy_stmt));
2222 else if (can_throw)
2223 make_eh_edges (copy_stmt);
2225 /* If the call we inline cannot make abnormal goto do not add
2226 additional abnormal edges but only retain those already present
2227 in the original function body. */
2228 if (abnormal_goto_dest == NULL)
2229 nonlocal_goto = false;
2230 if (nonlocal_goto)
2232 basic_block copy_stmt_bb = gimple_bb (copy_stmt);
2234 if (get_abnormal_succ_dispatcher (copy_stmt_bb))
2235 nonlocal_goto = false;
2236 /* ABNORMAL_DISPATCHER (1) is for longjmp/setjmp or nonlocal gotos
2237 in OpenMP regions which aren't allowed to be left abnormally.
2238 So, no need to add abnormal edge in that case. */
2239 else if (is_gimple_call (copy_stmt)
2240 && gimple_call_internal_p (copy_stmt)
2241 && (gimple_call_internal_fn (copy_stmt)
2242 == IFN_ABNORMAL_DISPATCHER)
2243 && gimple_call_arg (copy_stmt, 0) == boolean_true_node)
2244 nonlocal_goto = false;
2245 else
2246 make_edge (copy_stmt_bb, abnormal_goto_dest, EDGE_ABNORMAL);
2249 if ((can_throw || nonlocal_goto)
2250 && gimple_in_ssa_p (cfun))
2251 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb,
2252 can_throw, nonlocal_goto);
2254 return need_debug_cleanup;
2257 /* Copy the PHIs. All blocks and edges are copied, some blocks
2258 was possibly split and new outgoing EH edges inserted.
2259 BB points to the block of original function and AUX pointers links
2260 the original and newly copied blocks. */
2262 static void
2263 copy_phis_for_bb (basic_block bb, copy_body_data *id)
2265 basic_block const new_bb = (basic_block) bb->aux;
2266 edge_iterator ei;
2267 gphi *phi;
2268 gphi_iterator si;
2269 edge new_edge;
2270 bool inserted = false;
2272 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
2274 tree res, new_res;
2275 gphi *new_phi;
2277 phi = si.phi ();
2278 res = PHI_RESULT (phi);
2279 new_res = res;
2280 if (!virtual_operand_p (res))
2282 walk_tree (&new_res, copy_tree_body_r, id, NULL);
2283 new_phi = create_phi_node (new_res, new_bb);
2284 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
2286 edge old_edge = find_edge ((basic_block) new_edge->src->aux, bb);
2287 tree arg;
2288 tree new_arg;
2289 edge_iterator ei2;
2290 location_t locus;
2292 /* When doing partial cloning, we allow PHIs on the entry block
2293 as long as all the arguments are the same. Find any input
2294 edge to see argument to copy. */
2295 if (!old_edge)
2296 FOR_EACH_EDGE (old_edge, ei2, bb->preds)
2297 if (!old_edge->src->aux)
2298 break;
2300 arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
2301 new_arg = arg;
2302 walk_tree (&new_arg, copy_tree_body_r, id, NULL);
2303 gcc_assert (new_arg);
2304 /* With return slot optimization we can end up with
2305 non-gimple (foo *)&this->m, fix that here. */
2306 if (TREE_CODE (new_arg) != SSA_NAME
2307 && TREE_CODE (new_arg) != FUNCTION_DECL
2308 && !is_gimple_val (new_arg))
2310 gimple_seq stmts = NULL;
2311 new_arg = force_gimple_operand (new_arg, &stmts, true, NULL);
2312 gsi_insert_seq_on_edge (new_edge, stmts);
2313 inserted = true;
2315 locus = gimple_phi_arg_location_from_edge (phi, old_edge);
2316 if (LOCATION_BLOCK (locus))
2318 tree *n;
2319 n = id->decl_map->get (LOCATION_BLOCK (locus));
2320 gcc_assert (n);
2321 if (*n)
2322 locus = COMBINE_LOCATION_DATA (line_table, locus, *n);
2323 else
2324 locus = LOCATION_LOCUS (locus);
2326 else
2327 locus = LOCATION_LOCUS (locus);
2329 add_phi_arg (new_phi, new_arg, new_edge, locus);
2334 /* Commit the delayed edge insertions. */
2335 if (inserted)
2336 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
2337 gsi_commit_one_edge_insert (new_edge, NULL);
2341 /* Wrapper for remap_decl so it can be used as a callback. */
2343 static tree
2344 remap_decl_1 (tree decl, void *data)
2346 return remap_decl (decl, (copy_body_data *) data);
2349 /* Build struct function and associated datastructures for the new clone
2350 NEW_FNDECL to be build. CALLEE_FNDECL is the original. Function changes
2351 the cfun to the function of new_fndecl (and current_function_decl too). */
2353 static void
2354 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count)
2356 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2357 gcov_type count_scale;
2359 if (!DECL_ARGUMENTS (new_fndecl))
2360 DECL_ARGUMENTS (new_fndecl) = DECL_ARGUMENTS (callee_fndecl);
2361 if (!DECL_RESULT (new_fndecl))
2362 DECL_RESULT (new_fndecl) = DECL_RESULT (callee_fndecl);
2364 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count)
2365 count_scale
2366 = GCOV_COMPUTE_SCALE (count,
2367 ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count);
2368 else
2369 count_scale = REG_BR_PROB_BASE;
2371 /* Register specific tree functions. */
2372 gimple_register_cfg_hooks ();
2374 /* Get clean struct function. */
2375 push_struct_function (new_fndecl);
2377 /* We will rebuild these, so just sanity check that they are empty. */
2378 gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL);
2379 gcc_assert (cfun->local_decls == NULL);
2380 gcc_assert (cfun->cfg == NULL);
2381 gcc_assert (cfun->decl == new_fndecl);
2383 /* Copy items we preserve during cloning. */
2384 cfun->static_chain_decl = src_cfun->static_chain_decl;
2385 cfun->nonlocal_goto_save_area = src_cfun->nonlocal_goto_save_area;
2386 cfun->function_end_locus = src_cfun->function_end_locus;
2387 cfun->curr_properties = src_cfun->curr_properties;
2388 cfun->last_verified = src_cfun->last_verified;
2389 cfun->va_list_gpr_size = src_cfun->va_list_gpr_size;
2390 cfun->va_list_fpr_size = src_cfun->va_list_fpr_size;
2391 cfun->has_nonlocal_label = src_cfun->has_nonlocal_label;
2392 cfun->stdarg = src_cfun->stdarg;
2393 cfun->after_inlining = src_cfun->after_inlining;
2394 cfun->can_throw_non_call_exceptions
2395 = src_cfun->can_throw_non_call_exceptions;
2396 cfun->can_delete_dead_exceptions = src_cfun->can_delete_dead_exceptions;
2397 cfun->returns_struct = src_cfun->returns_struct;
2398 cfun->returns_pcc_struct = src_cfun->returns_pcc_struct;
2400 init_empty_tree_cfg ();
2402 profile_status_for_fn (cfun) = profile_status_for_fn (src_cfun);
2403 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count =
2404 (ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count * count_scale /
2405 REG_BR_PROB_BASE);
2406 ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency
2407 = ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->frequency;
2408 EXIT_BLOCK_PTR_FOR_FN (cfun)->count =
2409 (EXIT_BLOCK_PTR_FOR_FN (src_cfun)->count * count_scale /
2410 REG_BR_PROB_BASE);
2411 EXIT_BLOCK_PTR_FOR_FN (cfun)->frequency =
2412 EXIT_BLOCK_PTR_FOR_FN (src_cfun)->frequency;
2413 if (src_cfun->eh)
2414 init_eh_for_function ();
2416 if (src_cfun->gimple_df)
2418 init_tree_ssa (cfun);
2419 cfun->gimple_df->in_ssa_p = true;
2420 init_ssa_operands (cfun);
2424 /* Helper function for copy_cfg_body. Move debug stmts from the end
2425 of NEW_BB to the beginning of successor basic blocks when needed. If the
2426 successor has multiple predecessors, reset them, otherwise keep
2427 their value. */
2429 static void
2430 maybe_move_debug_stmts_to_successors (copy_body_data *id, basic_block new_bb)
2432 edge e;
2433 edge_iterator ei;
2434 gimple_stmt_iterator si = gsi_last_nondebug_bb (new_bb);
2436 if (gsi_end_p (si)
2437 || gsi_one_before_end_p (si)
2438 || !(stmt_can_throw_internal (gsi_stmt (si))
2439 || stmt_can_make_abnormal_goto (gsi_stmt (si))))
2440 return;
2442 FOR_EACH_EDGE (e, ei, new_bb->succs)
2444 gimple_stmt_iterator ssi = gsi_last_bb (new_bb);
2445 gimple_stmt_iterator dsi = gsi_after_labels (e->dest);
2446 while (is_gimple_debug (gsi_stmt (ssi)))
2448 gimple stmt = gsi_stmt (ssi);
2449 gdebug *new_stmt;
2450 tree var;
2451 tree value;
2453 /* For the last edge move the debug stmts instead of copying
2454 them. */
2455 if (ei_one_before_end_p (ei))
2457 si = ssi;
2458 gsi_prev (&ssi);
2459 if (!single_pred_p (e->dest) && gimple_debug_bind_p (stmt))
2460 gimple_debug_bind_reset_value (stmt);
2461 gsi_remove (&si, false);
2462 gsi_insert_before (&dsi, stmt, GSI_SAME_STMT);
2463 continue;
2466 if (gimple_debug_bind_p (stmt))
2468 var = gimple_debug_bind_get_var (stmt);
2469 if (single_pred_p (e->dest))
2471 value = gimple_debug_bind_get_value (stmt);
2472 value = unshare_expr (value);
2474 else
2475 value = NULL_TREE;
2476 new_stmt = gimple_build_debug_bind (var, value, stmt);
2478 else if (gimple_debug_source_bind_p (stmt))
2480 var = gimple_debug_source_bind_get_var (stmt);
2481 value = gimple_debug_source_bind_get_value (stmt);
2482 new_stmt = gimple_build_debug_source_bind (var, value, stmt);
2484 else
2485 gcc_unreachable ();
2486 gsi_insert_before (&dsi, new_stmt, GSI_SAME_STMT);
2487 id->debug_stmts.safe_push (new_stmt);
2488 gsi_prev (&ssi);
2493 /* Make a copy of the sub-loops of SRC_PARENT and place them
2494 as siblings of DEST_PARENT. */
2496 static void
2497 copy_loops (copy_body_data *id,
2498 struct loop *dest_parent, struct loop *src_parent)
2500 struct loop *src_loop = src_parent->inner;
2501 while (src_loop)
2503 if (!id->blocks_to_copy
2504 || bitmap_bit_p (id->blocks_to_copy, src_loop->header->index))
2506 struct loop *dest_loop = alloc_loop ();
2508 /* Assign the new loop its header and latch and associate
2509 those with the new loop. */
2510 dest_loop->header = (basic_block)src_loop->header->aux;
2511 dest_loop->header->loop_father = dest_loop;
2512 if (src_loop->latch != NULL)
2514 dest_loop->latch = (basic_block)src_loop->latch->aux;
2515 dest_loop->latch->loop_father = dest_loop;
2518 /* Copy loop meta-data. */
2519 copy_loop_info (src_loop, dest_loop);
2521 /* Finally place it into the loop array and the loop tree. */
2522 place_new_loop (cfun, dest_loop);
2523 flow_loop_tree_node_add (dest_parent, dest_loop);
2525 dest_loop->safelen = src_loop->safelen;
2526 dest_loop->dont_vectorize = src_loop->dont_vectorize;
2527 if (src_loop->force_vectorize)
2529 dest_loop->force_vectorize = true;
2530 cfun->has_force_vectorize_loops = true;
2532 if (src_loop->simduid)
2534 dest_loop->simduid = remap_decl (src_loop->simduid, id);
2535 cfun->has_simduid_loops = true;
2538 /* Recurse. */
2539 copy_loops (id, dest_loop, src_loop);
2541 src_loop = src_loop->next;
2545 /* Call cgraph_redirect_edge_call_stmt_to_callee on all calls in BB */
2547 void
2548 redirect_all_calls (copy_body_data * id, basic_block bb)
2550 gimple_stmt_iterator si;
2551 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2553 if (is_gimple_call (gsi_stmt (si)))
2555 struct cgraph_edge *edge = id->dst_node->get_edge (gsi_stmt (si));
2556 if (edge)
2557 edge->redirect_call_stmt_to_callee ();
2562 /* Convert estimated frequencies into counts for NODE, scaling COUNT
2563 with each bb's frequency. Used when NODE has a 0-weight entry
2564 but we are about to inline it into a non-zero count call bb.
2565 See the comments for handle_missing_profiles() in predict.c for
2566 when this can happen for COMDATs. */
2568 void
2569 freqs_to_counts (struct cgraph_node *node, gcov_type count)
2571 basic_block bb;
2572 edge_iterator ei;
2573 edge e;
2574 struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
2576 FOR_ALL_BB_FN(bb, fn)
2578 bb->count = apply_scale (count,
2579 GCOV_COMPUTE_SCALE (bb->frequency, BB_FREQ_MAX));
2580 FOR_EACH_EDGE (e, ei, bb->succs)
2581 e->count = apply_probability (e->src->count, e->probability);
2585 /* Make a copy of the body of FN so that it can be inserted inline in
2586 another function. Walks FN via CFG, returns new fndecl. */
2588 static tree
2589 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale,
2590 basic_block entry_block_map, basic_block exit_block_map,
2591 basic_block new_entry)
2593 tree callee_fndecl = id->src_fn;
2594 /* Original cfun for the callee, doesn't change. */
2595 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2596 struct function *cfun_to_copy;
2597 basic_block bb;
2598 tree new_fndecl = NULL;
2599 bool need_debug_cleanup = false;
2600 gcov_type count_scale;
2601 int last;
2602 int incoming_frequency = 0;
2603 gcov_type incoming_count = 0;
2605 /* This can happen for COMDAT routines that end up with 0 counts
2606 despite being called (see the comments for handle_missing_profiles()
2607 in predict.c as to why). Apply counts to the blocks in the callee
2608 before inlining, using the guessed edge frequencies, so that we don't
2609 end up with a 0-count inline body which can confuse downstream
2610 optimizations such as function splitting. */
2611 if (!ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count && count)
2613 /* Apply the larger of the call bb count and the total incoming
2614 call edge count to the callee. */
2615 gcov_type in_count = 0;
2616 struct cgraph_edge *in_edge;
2617 for (in_edge = id->src_node->callers; in_edge;
2618 in_edge = in_edge->next_caller)
2619 in_count += in_edge->count;
2620 freqs_to_counts (id->src_node, count > in_count ? count : in_count);
2623 if (ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count)
2624 count_scale
2625 = GCOV_COMPUTE_SCALE (count,
2626 ENTRY_BLOCK_PTR_FOR_FN (src_cfun)->count);
2627 else
2628 count_scale = REG_BR_PROB_BASE;
2630 /* Register specific tree functions. */
2631 gimple_register_cfg_hooks ();
2633 /* If we are inlining just region of the function, make sure to connect
2634 new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
2635 part of loop, we must compute frequency and probability of
2636 ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
2637 probabilities of edges incoming from nonduplicated region. */
2638 if (new_entry)
2640 edge e;
2641 edge_iterator ei;
2643 FOR_EACH_EDGE (e, ei, new_entry->preds)
2644 if (!e->src->aux)
2646 incoming_frequency += EDGE_FREQUENCY (e);
2647 incoming_count += e->count;
2649 incoming_count = apply_scale (incoming_count, count_scale);
2650 incoming_frequency
2651 = apply_scale ((gcov_type)incoming_frequency, frequency_scale);
2652 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = incoming_count;
2653 ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency = incoming_frequency;
2656 /* Must have a CFG here at this point. */
2657 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN
2658 (DECL_STRUCT_FUNCTION (callee_fndecl)));
2660 cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2662 ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy)->aux = entry_block_map;
2663 EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy)->aux = exit_block_map;
2664 entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FN (cfun_to_copy);
2665 exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FN (cfun_to_copy);
2667 /* Duplicate any exception-handling regions. */
2668 if (cfun->eh)
2669 id->eh_map = duplicate_eh_regions (cfun_to_copy, NULL, id->eh_lp_nr,
2670 remap_decl_1, id);
2672 /* Use aux pointers to map the original blocks to copy. */
2673 FOR_EACH_BB_FN (bb, cfun_to_copy)
2674 if (!id->blocks_to_copy || bitmap_bit_p (id->blocks_to_copy, bb->index))
2676 basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale);
2677 bb->aux = new_bb;
2678 new_bb->aux = bb;
2679 new_bb->loop_father = entry_block_map->loop_father;
2682 last = last_basic_block_for_fn (cfun);
2684 /* Now that we've duplicated the blocks, duplicate their edges. */
2685 basic_block abnormal_goto_dest = NULL;
2686 if (id->call_stmt
2687 && stmt_can_make_abnormal_goto (id->call_stmt))
2689 gimple_stmt_iterator gsi = gsi_for_stmt (id->call_stmt);
2691 bb = gimple_bb (id->call_stmt);
2692 gsi_next (&gsi);
2693 if (gsi_end_p (gsi))
2694 abnormal_goto_dest = get_abnormal_succ_dispatcher (bb);
2696 FOR_ALL_BB_FN (bb, cfun_to_copy)
2697 if (!id->blocks_to_copy
2698 || (bb->index > 0 && bitmap_bit_p (id->blocks_to_copy, bb->index)))
2699 need_debug_cleanup |= copy_edges_for_bb (bb, count_scale, exit_block_map,
2700 abnormal_goto_dest);
2702 if (new_entry)
2704 edge e = make_edge (entry_block_map, (basic_block)new_entry->aux, EDGE_FALLTHRU);
2705 e->probability = REG_BR_PROB_BASE;
2706 e->count = incoming_count;
2709 /* Duplicate the loop tree, if available and wanted. */
2710 if (loops_for_fn (src_cfun) != NULL
2711 && current_loops != NULL)
2713 copy_loops (id, entry_block_map->loop_father,
2714 get_loop (src_cfun, 0));
2715 /* Defer to cfgcleanup to update loop-father fields of basic-blocks. */
2716 loops_state_set (LOOPS_NEED_FIXUP);
2719 /* If the loop tree in the source function needed fixup, mark the
2720 destination loop tree for fixup, too. */
2721 if (loops_for_fn (src_cfun)->state & LOOPS_NEED_FIXUP)
2722 loops_state_set (LOOPS_NEED_FIXUP);
2724 if (gimple_in_ssa_p (cfun))
2725 FOR_ALL_BB_FN (bb, cfun_to_copy)
2726 if (!id->blocks_to_copy
2727 || (bb->index > 0 && bitmap_bit_p (id->blocks_to_copy, bb->index)))
2728 copy_phis_for_bb (bb, id);
2730 FOR_ALL_BB_FN (bb, cfun_to_copy)
2731 if (bb->aux)
2733 if (need_debug_cleanup
2734 && bb->index != ENTRY_BLOCK
2735 && bb->index != EXIT_BLOCK)
2736 maybe_move_debug_stmts_to_successors (id, (basic_block) bb->aux);
2737 /* Update call edge destinations. This can not be done before loop
2738 info is updated, because we may split basic blocks. */
2739 if (id->transform_call_graph_edges == CB_CGE_DUPLICATE)
2740 redirect_all_calls (id, (basic_block)bb->aux);
2741 ((basic_block)bb->aux)->aux = NULL;
2742 bb->aux = NULL;
2745 /* Zero out AUX fields of newly created block during EH edge
2746 insertion. */
2747 for (; last < last_basic_block_for_fn (cfun); last++)
2749 if (need_debug_cleanup)
2750 maybe_move_debug_stmts_to_successors (id,
2751 BASIC_BLOCK_FOR_FN (cfun, last));
2752 BASIC_BLOCK_FOR_FN (cfun, last)->aux = NULL;
2753 /* Update call edge destinations. This can not be done before loop
2754 info is updated, because we may split basic blocks. */
2755 if (id->transform_call_graph_edges == CB_CGE_DUPLICATE)
2756 redirect_all_calls (id, BASIC_BLOCK_FOR_FN (cfun, last));
2758 entry_block_map->aux = NULL;
2759 exit_block_map->aux = NULL;
2761 if (id->eh_map)
2763 delete id->eh_map;
2764 id->eh_map = NULL;
2767 return new_fndecl;
2770 /* Copy the debug STMT using ID. We deal with these statements in a
2771 special way: if any variable in their VALUE expression wasn't
2772 remapped yet, we won't remap it, because that would get decl uids
2773 out of sync, causing codegen differences between -g and -g0. If
2774 this arises, we drop the VALUE expression altogether. */
2776 static void
2777 copy_debug_stmt (gdebug *stmt, copy_body_data *id)
2779 tree t, *n;
2780 struct walk_stmt_info wi;
2782 if (gimple_block (stmt))
2784 n = id->decl_map->get (gimple_block (stmt));
2785 gimple_set_block (stmt, n ? *n : id->block);
2788 /* Remap all the operands in COPY. */
2789 memset (&wi, 0, sizeof (wi));
2790 wi.info = id;
2792 processing_debug_stmt = 1;
2794 if (gimple_debug_source_bind_p (stmt))
2795 t = gimple_debug_source_bind_get_var (stmt);
2796 else
2797 t = gimple_debug_bind_get_var (stmt);
2799 if (TREE_CODE (t) == PARM_DECL && id->debug_map
2800 && (n = id->debug_map->get (t)))
2802 gcc_assert (TREE_CODE (*n) == VAR_DECL);
2803 t = *n;
2805 else if (TREE_CODE (t) == VAR_DECL
2806 && !is_global_var (t)
2807 && !id->decl_map->get (t))
2808 /* T is a non-localized variable. */;
2809 else
2810 walk_tree (&t, remap_gimple_op_r, &wi, NULL);
2812 if (gimple_debug_bind_p (stmt))
2814 gimple_debug_bind_set_var (stmt, t);
2816 if (gimple_debug_bind_has_value_p (stmt))
2817 walk_tree (gimple_debug_bind_get_value_ptr (stmt),
2818 remap_gimple_op_r, &wi, NULL);
2820 /* Punt if any decl couldn't be remapped. */
2821 if (processing_debug_stmt < 0)
2822 gimple_debug_bind_reset_value (stmt);
2824 else if (gimple_debug_source_bind_p (stmt))
2826 gimple_debug_source_bind_set_var (stmt, t);
2827 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt),
2828 remap_gimple_op_r, &wi, NULL);
2829 /* When inlining and source bind refers to one of the optimized
2830 away parameters, change the source bind into normal debug bind
2831 referring to the corresponding DEBUG_EXPR_DECL that should have
2832 been bound before the call stmt. */
2833 t = gimple_debug_source_bind_get_value (stmt);
2834 if (t != NULL_TREE
2835 && TREE_CODE (t) == PARM_DECL
2836 && id->call_stmt)
2838 vec<tree, va_gc> **debug_args = decl_debug_args_lookup (id->src_fn);
2839 unsigned int i;
2840 if (debug_args != NULL)
2842 for (i = 0; i < vec_safe_length (*debug_args); i += 2)
2843 if ((**debug_args)[i] == DECL_ORIGIN (t)
2844 && TREE_CODE ((**debug_args)[i + 1]) == DEBUG_EXPR_DECL)
2846 t = (**debug_args)[i + 1];
2847 stmt->subcode = GIMPLE_DEBUG_BIND;
2848 gimple_debug_bind_set_value (stmt, t);
2849 break;
2855 processing_debug_stmt = 0;
2857 update_stmt (stmt);
2860 /* Process deferred debug stmts. In order to give values better odds
2861 of being successfully remapped, we delay the processing of debug
2862 stmts until all other stmts that might require remapping are
2863 processed. */
2865 static void
2866 copy_debug_stmts (copy_body_data *id)
2868 size_t i;
2869 gdebug *stmt;
2871 if (!id->debug_stmts.exists ())
2872 return;
2874 FOR_EACH_VEC_ELT (id->debug_stmts, i, stmt)
2875 copy_debug_stmt (stmt, id);
2877 id->debug_stmts.release ();
2880 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2881 another function. */
2883 static tree
2884 copy_tree_body (copy_body_data *id)
2886 tree fndecl = id->src_fn;
2887 tree body = DECL_SAVED_TREE (fndecl);
2889 walk_tree (&body, copy_tree_body_r, id, NULL);
2891 return body;
2894 /* Make a copy of the body of FN so that it can be inserted inline in
2895 another function. */
2897 static tree
2898 copy_body (copy_body_data *id, gcov_type count, int frequency_scale,
2899 basic_block entry_block_map, basic_block exit_block_map,
2900 basic_block new_entry)
2902 tree fndecl = id->src_fn;
2903 tree body;
2905 /* If this body has a CFG, walk CFG and copy. */
2906 gcc_assert (ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (fndecl)));
2907 body = copy_cfg_body (id, count, frequency_scale, entry_block_map, exit_block_map,
2908 new_entry);
2909 copy_debug_stmts (id);
2911 return body;
2914 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2915 defined in function FN, or of a data member thereof. */
2917 static bool
2918 self_inlining_addr_expr (tree value, tree fn)
2920 tree var;
2922 if (TREE_CODE (value) != ADDR_EXPR)
2923 return false;
2925 var = get_base_address (TREE_OPERAND (value, 0));
2927 return var && auto_var_in_fn_p (var, fn);
2930 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2931 lexical block and line number information from base_stmt, if given,
2932 or from the last stmt of the block otherwise. */
2934 static gimple
2935 insert_init_debug_bind (copy_body_data *id,
2936 basic_block bb, tree var, tree value,
2937 gimple base_stmt)
2939 gimple note;
2940 gimple_stmt_iterator gsi;
2941 tree tracked_var;
2943 if (!gimple_in_ssa_p (id->src_cfun))
2944 return NULL;
2946 if (!MAY_HAVE_DEBUG_STMTS)
2947 return NULL;
2949 tracked_var = target_for_debug_bind (var);
2950 if (!tracked_var)
2951 return NULL;
2953 if (bb)
2955 gsi = gsi_last_bb (bb);
2956 if (!base_stmt && !gsi_end_p (gsi))
2957 base_stmt = gsi_stmt (gsi);
2960 note = gimple_build_debug_bind (tracked_var, value, base_stmt);
2962 if (bb)
2964 if (!gsi_end_p (gsi))
2965 gsi_insert_after (&gsi, note, GSI_SAME_STMT);
2966 else
2967 gsi_insert_before (&gsi, note, GSI_SAME_STMT);
2970 return note;
2973 static void
2974 insert_init_stmt (copy_body_data *id, basic_block bb, gimple init_stmt)
2976 /* If VAR represents a zero-sized variable, it's possible that the
2977 assignment statement may result in no gimple statements. */
2978 if (init_stmt)
2980 gimple_stmt_iterator si = gsi_last_bb (bb);
2982 /* We can end up with init statements that store to a non-register
2983 from a rhs with a conversion. Handle that here by forcing the
2984 rhs into a temporary. gimple_regimplify_operands is not
2985 prepared to do this for us. */
2986 if (!is_gimple_debug (init_stmt)
2987 && !is_gimple_reg (gimple_assign_lhs (init_stmt))
2988 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt)))
2989 && gimple_assign_rhs_class (init_stmt) == GIMPLE_UNARY_RHS)
2991 tree rhs = build1 (gimple_assign_rhs_code (init_stmt),
2992 gimple_expr_type (init_stmt),
2993 gimple_assign_rhs1 (init_stmt));
2994 rhs = force_gimple_operand_gsi (&si, rhs, true, NULL_TREE, false,
2995 GSI_NEW_STMT);
2996 gimple_assign_set_rhs_code (init_stmt, TREE_CODE (rhs));
2997 gimple_assign_set_rhs1 (init_stmt, rhs);
2999 gsi_insert_after (&si, init_stmt, GSI_NEW_STMT);
3000 gimple_regimplify_operands (init_stmt, &si);
3002 if (!is_gimple_debug (init_stmt) && MAY_HAVE_DEBUG_STMTS)
3004 tree def = gimple_assign_lhs (init_stmt);
3005 insert_init_debug_bind (id, bb, def, def, init_stmt);
3010 /* Initialize parameter P with VALUE. If needed, produce init statement
3011 at the end of BB. When BB is NULL, we return init statement to be
3012 output later. */
3013 static gimple
3014 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
3015 basic_block bb, tree *vars)
3017 gimple init_stmt = NULL;
3018 tree var;
3019 tree rhs = value;
3020 tree def = (gimple_in_ssa_p (cfun)
3021 ? ssa_default_def (id->src_cfun, p) : NULL);
3023 if (value
3024 && value != error_mark_node
3025 && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
3027 /* If we can match up types by promotion/demotion do so. */
3028 if (fold_convertible_p (TREE_TYPE (p), value))
3029 rhs = fold_convert (TREE_TYPE (p), value);
3030 else
3032 /* ??? For valid programs we should not end up here.
3033 Still if we end up with truly mismatched types here, fall back
3034 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
3035 GIMPLE to the following passes. */
3036 if (!is_gimple_reg_type (TREE_TYPE (value))
3037 || TYPE_SIZE (TREE_TYPE (p)) == TYPE_SIZE (TREE_TYPE (value)))
3038 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value);
3039 else
3040 rhs = build_zero_cst (TREE_TYPE (p));
3044 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
3045 here since the type of this decl must be visible to the calling
3046 function. */
3047 var = copy_decl_to_var (p, id);
3049 /* Declare this new variable. */
3050 DECL_CHAIN (var) = *vars;
3051 *vars = var;
3053 /* Make gimplifier happy about this variable. */
3054 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
3056 /* If the parameter is never assigned to, has no SSA_NAMEs created,
3057 we would not need to create a new variable here at all, if it
3058 weren't for debug info. Still, we can just use the argument
3059 value. */
3060 if (TREE_READONLY (p)
3061 && !TREE_ADDRESSABLE (p)
3062 && value && !TREE_SIDE_EFFECTS (value)
3063 && !def)
3065 /* We may produce non-gimple trees by adding NOPs or introduce
3066 invalid sharing when operand is not really constant.
3067 It is not big deal to prohibit constant propagation here as
3068 we will constant propagate in DOM1 pass anyway. */
3069 if (is_gimple_min_invariant (value)
3070 && useless_type_conversion_p (TREE_TYPE (p),
3071 TREE_TYPE (value))
3072 /* We have to be very careful about ADDR_EXPR. Make sure
3073 the base variable isn't a local variable of the inlined
3074 function, e.g., when doing recursive inlining, direct or
3075 mutually-recursive or whatever, which is why we don't
3076 just test whether fn == current_function_decl. */
3077 && ! self_inlining_addr_expr (value, fn))
3079 insert_decl_map (id, p, value);
3080 insert_debug_decl_map (id, p, var);
3081 return insert_init_debug_bind (id, bb, var, value, NULL);
3085 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
3086 that way, when the PARM_DECL is encountered, it will be
3087 automatically replaced by the VAR_DECL. */
3088 insert_decl_map (id, p, var);
3090 /* Even if P was TREE_READONLY, the new VAR should not be.
3091 In the original code, we would have constructed a
3092 temporary, and then the function body would have never
3093 changed the value of P. However, now, we will be
3094 constructing VAR directly. The constructor body may
3095 change its value multiple times as it is being
3096 constructed. Therefore, it must not be TREE_READONLY;
3097 the back-end assumes that TREE_READONLY variable is
3098 assigned to only once. */
3099 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
3100 TREE_READONLY (var) = 0;
3102 /* If there is no setup required and we are in SSA, take the easy route
3103 replacing all SSA names representing the function parameter by the
3104 SSA name passed to function.
3106 We need to construct map for the variable anyway as it might be used
3107 in different SSA names when parameter is set in function.
3109 Do replacement at -O0 for const arguments replaced by constant.
3110 This is important for builtin_constant_p and other construct requiring
3111 constant argument to be visible in inlined function body. */
3112 if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
3113 && (optimize
3114 || (TREE_READONLY (p)
3115 && is_gimple_min_invariant (rhs)))
3116 && (TREE_CODE (rhs) == SSA_NAME
3117 || is_gimple_min_invariant (rhs))
3118 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
3120 insert_decl_map (id, def, rhs);
3121 return insert_init_debug_bind (id, bb, var, rhs, NULL);
3124 /* If the value of argument is never used, don't care about initializing
3125 it. */
3126 if (optimize && gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
3128 gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
3129 return insert_init_debug_bind (id, bb, var, rhs, NULL);
3132 /* Initialize this VAR_DECL from the equivalent argument. Convert
3133 the argument to the proper type in case it was promoted. */
3134 if (value)
3136 if (rhs == error_mark_node)
3138 insert_decl_map (id, p, var);
3139 return insert_init_debug_bind (id, bb, var, rhs, NULL);
3142 STRIP_USELESS_TYPE_CONVERSION (rhs);
3144 /* If we are in SSA form properly remap the default definition
3145 or assign to a dummy SSA name if the parameter is unused and
3146 we are not optimizing. */
3147 if (gimple_in_ssa_p (cfun) && is_gimple_reg (p))
3149 if (def)
3151 def = remap_ssa_name (def, id);
3152 init_stmt = gimple_build_assign (def, rhs);
3153 SSA_NAME_IS_DEFAULT_DEF (def) = 0;
3154 set_ssa_default_def (cfun, var, NULL);
3156 else if (!optimize)
3158 def = make_ssa_name (var, NULL);
3159 init_stmt = gimple_build_assign (def, rhs);
3162 else
3163 init_stmt = gimple_build_assign (var, rhs);
3165 if (bb && init_stmt)
3166 insert_init_stmt (id, bb, init_stmt);
3168 return init_stmt;
3171 /* Generate code to initialize the parameters of the function at the
3172 top of the stack in ID from the GIMPLE_CALL STMT. */
3174 static void
3175 initialize_inlined_parameters (copy_body_data *id, gimple stmt,
3176 tree fn, basic_block bb)
3178 tree parms;
3179 size_t i;
3180 tree p;
3181 tree vars = NULL_TREE;
3182 tree static_chain = gimple_call_chain (stmt);
3184 /* Figure out what the parameters are. */
3185 parms = DECL_ARGUMENTS (fn);
3187 /* Loop through the parameter declarations, replacing each with an
3188 equivalent VAR_DECL, appropriately initialized. */
3189 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++)
3191 tree val;
3192 val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL;
3193 setup_one_parameter (id, p, val, fn, bb, &vars);
3195 /* After remapping parameters remap their types. This has to be done
3196 in a second loop over all parameters to appropriately remap
3197 variable sized arrays when the size is specified in a
3198 parameter following the array. */
3199 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++)
3201 tree *varp = id->decl_map->get (p);
3202 if (varp
3203 && TREE_CODE (*varp) == VAR_DECL)
3205 tree def = (gimple_in_ssa_p (cfun) && is_gimple_reg (p)
3206 ? ssa_default_def (id->src_cfun, p) : NULL);
3207 tree var = *varp;
3208 TREE_TYPE (var) = remap_type (TREE_TYPE (var), id);
3209 /* Also remap the default definition if it was remapped
3210 to the default definition of the parameter replacement
3211 by the parameter setup. */
3212 if (def)
3214 tree *defp = id->decl_map->get (def);
3215 if (defp
3216 && TREE_CODE (*defp) == SSA_NAME
3217 && SSA_NAME_VAR (*defp) == var)
3218 TREE_TYPE (*defp) = TREE_TYPE (var);
3223 /* Initialize the static chain. */
3224 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
3225 gcc_assert (fn != current_function_decl);
3226 if (p)
3228 /* No static chain? Seems like a bug in tree-nested.c. */
3229 gcc_assert (static_chain);
3231 setup_one_parameter (id, p, static_chain, fn, bb, &vars);
3234 declare_inline_vars (id->block, vars);
3238 /* Declare a return variable to replace the RESULT_DECL for the
3239 function we are calling. An appropriate DECL_STMT is returned.
3240 The USE_STMT is filled to contain a use of the declaration to
3241 indicate the return value of the function.
3243 RETURN_SLOT, if non-null is place where to store the result. It
3244 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
3245 was the LHS of the MODIFY_EXPR to which this call is the RHS.
3247 RETURN_BOUNDS holds a destination for returned bounds.
3249 The return value is a (possibly null) value that holds the result
3250 as seen by the caller. */
3252 static tree
3253 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
3254 tree return_bounds, basic_block entry_bb)
3256 tree callee = id->src_fn;
3257 tree result = DECL_RESULT (callee);
3258 tree callee_type = TREE_TYPE (result);
3259 tree caller_type;
3260 tree var, use;
3262 /* Handle type-mismatches in the function declaration return type
3263 vs. the call expression. */
3264 if (modify_dest)
3265 caller_type = TREE_TYPE (modify_dest);
3266 else
3267 caller_type = TREE_TYPE (TREE_TYPE (callee));
3269 /* We don't need to do anything for functions that don't return anything. */
3270 if (VOID_TYPE_P (callee_type))
3271 return NULL_TREE;
3273 /* If there was a return slot, then the return value is the
3274 dereferenced address of that object. */
3275 if (return_slot)
3277 /* The front end shouldn't have used both return_slot and
3278 a modify expression. */
3279 gcc_assert (!modify_dest);
3280 if (DECL_BY_REFERENCE (result))
3282 tree return_slot_addr = build_fold_addr_expr (return_slot);
3283 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
3285 /* We are going to construct *&return_slot and we can't do that
3286 for variables believed to be not addressable.
3288 FIXME: This check possibly can match, because values returned
3289 via return slot optimization are not believed to have address
3290 taken by alias analysis. */
3291 gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
3292 var = return_slot_addr;
3294 else
3296 var = return_slot;
3297 gcc_assert (TREE_CODE (var) != SSA_NAME);
3298 if (TREE_ADDRESSABLE (result))
3299 mark_addressable (var);
3301 if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
3302 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
3303 && !DECL_GIMPLE_REG_P (result)
3304 && DECL_P (var))
3305 DECL_GIMPLE_REG_P (var) = 0;
3306 use = NULL;
3307 goto done;
3310 /* All types requiring non-trivial constructors should have been handled. */
3311 gcc_assert (!TREE_ADDRESSABLE (callee_type));
3313 /* Attempt to avoid creating a new temporary variable. */
3314 if (modify_dest
3315 && TREE_CODE (modify_dest) != SSA_NAME)
3317 bool use_it = false;
3319 /* We can't use MODIFY_DEST if there's type promotion involved. */
3320 if (!useless_type_conversion_p (callee_type, caller_type))
3321 use_it = false;
3323 /* ??? If we're assigning to a variable sized type, then we must
3324 reuse the destination variable, because we've no good way to
3325 create variable sized temporaries at this point. */
3326 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
3327 use_it = true;
3329 /* If the callee cannot possibly modify MODIFY_DEST, then we can
3330 reuse it as the result of the call directly. Don't do this if
3331 it would promote MODIFY_DEST to addressable. */
3332 else if (TREE_ADDRESSABLE (result))
3333 use_it = false;
3334 else
3336 tree base_m = get_base_address (modify_dest);
3338 /* If the base isn't a decl, then it's a pointer, and we don't
3339 know where that's going to go. */
3340 if (!DECL_P (base_m))
3341 use_it = false;
3342 else if (is_global_var (base_m))
3343 use_it = false;
3344 else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
3345 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
3346 && !DECL_GIMPLE_REG_P (result)
3347 && DECL_GIMPLE_REG_P (base_m))
3348 use_it = false;
3349 else if (!TREE_ADDRESSABLE (base_m))
3350 use_it = true;
3353 if (use_it)
3355 var = modify_dest;
3356 use = NULL;
3357 goto done;
3361 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
3363 var = copy_result_decl_to_var (result, id);
3364 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
3366 /* Do not have the rest of GCC warn about this variable as it should
3367 not be visible to the user. */
3368 TREE_NO_WARNING (var) = 1;
3370 declare_inline_vars (id->block, var);
3372 /* Build the use expr. If the return type of the function was
3373 promoted, convert it back to the expected type. */
3374 use = var;
3375 if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
3377 /* If we can match up types by promotion/demotion do so. */
3378 if (fold_convertible_p (caller_type, var))
3379 use = fold_convert (caller_type, var);
3380 else
3382 /* ??? For valid programs we should not end up here.
3383 Still if we end up with truly mismatched types here, fall back
3384 to using a MEM_REF to not leak invalid GIMPLE to the following
3385 passes. */
3386 /* Prevent var from being written into SSA form. */
3387 if (TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
3388 || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE)
3389 DECL_GIMPLE_REG_P (var) = false;
3390 else if (is_gimple_reg_type (TREE_TYPE (var)))
3391 TREE_ADDRESSABLE (var) = true;
3392 use = fold_build2 (MEM_REF, caller_type,
3393 build_fold_addr_expr (var),
3394 build_int_cst (ptr_type_node, 0));
3398 STRIP_USELESS_TYPE_CONVERSION (use);
3400 if (DECL_BY_REFERENCE (result))
3402 TREE_ADDRESSABLE (var) = 1;
3403 var = build_fold_addr_expr (var);
3406 done:
3407 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
3408 way, when the RESULT_DECL is encountered, it will be
3409 automatically replaced by the VAR_DECL.
3411 When returning by reference, ensure that RESULT_DECL remaps to
3412 gimple_val. */
3413 if (DECL_BY_REFERENCE (result)
3414 && !is_gimple_val (var))
3416 tree temp = create_tmp_var (TREE_TYPE (result), "retvalptr");
3417 insert_decl_map (id, result, temp);
3418 /* When RESULT_DECL is in SSA form, we need to remap and initialize
3419 it's default_def SSA_NAME. */
3420 if (gimple_in_ssa_p (id->src_cfun)
3421 && is_gimple_reg (result))
3423 temp = make_ssa_name (temp, NULL);
3424 insert_decl_map (id, ssa_default_def (id->src_cfun, result), temp);
3426 insert_init_stmt (id, entry_bb, gimple_build_assign (temp, var));
3428 else
3429 insert_decl_map (id, result, var);
3431 /* Remember this so we can ignore it in remap_decls. */
3432 id->retvar = var;
3434 /* If returned bounds are used, then make var for them. */
3435 if (return_bounds)
3437 tree bndtemp = create_tmp_var (pointer_bounds_type_node, "retbnd");
3438 DECL_SEEN_IN_BIND_EXPR_P (bndtemp) = 1;
3439 TREE_NO_WARNING (bndtemp) = 1;
3440 declare_inline_vars (id->block, bndtemp);
3442 id->retbnd = bndtemp;
3443 insert_init_stmt (id, entry_bb,
3444 gimple_build_assign (bndtemp, chkp_get_zero_bounds_var ()));
3447 return use;
3450 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3451 to a local label. */
3453 static tree
3454 has_label_address_in_static_1 (tree *nodep, int *walk_subtrees, void *fnp)
3456 tree node = *nodep;
3457 tree fn = (tree) fnp;
3459 if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
3460 return node;
3462 if (TYPE_P (node))
3463 *walk_subtrees = 0;
3465 return NULL_TREE;
3468 /* Determine if the function can be copied. If so return NULL. If
3469 not return a string describng the reason for failure. */
3471 static const char *
3472 copy_forbidden (struct function *fun, tree fndecl)
3474 const char *reason = fun->cannot_be_copied_reason;
3475 tree decl;
3476 unsigned ix;
3478 /* Only examine the function once. */
3479 if (fun->cannot_be_copied_set)
3480 return reason;
3482 /* We cannot copy a function that receives a non-local goto
3483 because we cannot remap the destination label used in the
3484 function that is performing the non-local goto. */
3485 /* ??? Actually, this should be possible, if we work at it.
3486 No doubt there's just a handful of places that simply
3487 assume it doesn't happen and don't substitute properly. */
3488 if (fun->has_nonlocal_label)
3490 reason = G_("function %q+F can never be copied "
3491 "because it receives a non-local goto");
3492 goto fail;
3495 FOR_EACH_LOCAL_DECL (fun, ix, decl)
3496 if (TREE_CODE (decl) == VAR_DECL
3497 && TREE_STATIC (decl)
3498 && !DECL_EXTERNAL (decl)
3499 && DECL_INITIAL (decl)
3500 && walk_tree_without_duplicates (&DECL_INITIAL (decl),
3501 has_label_address_in_static_1,
3502 fndecl))
3504 reason = G_("function %q+F can never be copied because it saves "
3505 "address of local label in a static variable");
3506 goto fail;
3509 fail:
3510 fun->cannot_be_copied_reason = reason;
3511 fun->cannot_be_copied_set = true;
3512 return reason;
3516 static const char *inline_forbidden_reason;
3518 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3519 iff a function can not be inlined. Also sets the reason why. */
3521 static tree
3522 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
3523 struct walk_stmt_info *wip)
3525 tree fn = (tree) wip->info;
3526 tree t;
3527 gimple stmt = gsi_stmt (*gsi);
3529 switch (gimple_code (stmt))
3531 case GIMPLE_CALL:
3532 /* Refuse to inline alloca call unless user explicitly forced so as
3533 this may change program's memory overhead drastically when the
3534 function using alloca is called in loop. In GCC present in
3535 SPEC2000 inlining into schedule_block cause it to require 2GB of
3536 RAM instead of 256MB. Don't do so for alloca calls emitted for
3537 VLA objects as those can't cause unbounded growth (they're always
3538 wrapped inside stack_save/stack_restore regions. */
3539 if (gimple_alloca_call_p (stmt)
3540 && !gimple_call_alloca_for_var_p (as_a <gcall *> (stmt))
3541 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
3543 inline_forbidden_reason
3544 = G_("function %q+F can never be inlined because it uses "
3545 "alloca (override using the always_inline attribute)");
3546 *handled_ops_p = true;
3547 return fn;
3550 t = gimple_call_fndecl (stmt);
3551 if (t == NULL_TREE)
3552 break;
3554 /* We cannot inline functions that call setjmp. */
3555 if (setjmp_call_p (t))
3557 inline_forbidden_reason
3558 = G_("function %q+F can never be inlined because it uses setjmp");
3559 *handled_ops_p = true;
3560 return t;
3563 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
3564 switch (DECL_FUNCTION_CODE (t))
3566 /* We cannot inline functions that take a variable number of
3567 arguments. */
3568 case BUILT_IN_VA_START:
3569 case BUILT_IN_NEXT_ARG:
3570 case BUILT_IN_VA_END:
3571 inline_forbidden_reason
3572 = G_("function %q+F can never be inlined because it "
3573 "uses variable argument lists");
3574 *handled_ops_p = true;
3575 return t;
3577 case BUILT_IN_LONGJMP:
3578 /* We can't inline functions that call __builtin_longjmp at
3579 all. The non-local goto machinery really requires the
3580 destination be in a different function. If we allow the
3581 function calling __builtin_longjmp to be inlined into the
3582 function calling __builtin_setjmp, Things will Go Awry. */
3583 inline_forbidden_reason
3584 = G_("function %q+F can never be inlined because "
3585 "it uses setjmp-longjmp exception handling");
3586 *handled_ops_p = true;
3587 return t;
3589 case BUILT_IN_NONLOCAL_GOTO:
3590 /* Similarly. */
3591 inline_forbidden_reason
3592 = G_("function %q+F can never be inlined because "
3593 "it uses non-local goto");
3594 *handled_ops_p = true;
3595 return t;
3597 case BUILT_IN_RETURN:
3598 case BUILT_IN_APPLY_ARGS:
3599 /* If a __builtin_apply_args caller would be inlined,
3600 it would be saving arguments of the function it has
3601 been inlined into. Similarly __builtin_return would
3602 return from the function the inline has been inlined into. */
3603 inline_forbidden_reason
3604 = G_("function %q+F can never be inlined because "
3605 "it uses __builtin_return or __builtin_apply_args");
3606 *handled_ops_p = true;
3607 return t;
3609 default:
3610 break;
3612 break;
3614 case GIMPLE_GOTO:
3615 t = gimple_goto_dest (stmt);
3617 /* We will not inline a function which uses computed goto. The
3618 addresses of its local labels, which may be tucked into
3619 global storage, are of course not constant across
3620 instantiations, which causes unexpected behavior. */
3621 if (TREE_CODE (t) != LABEL_DECL)
3623 inline_forbidden_reason
3624 = G_("function %q+F can never be inlined "
3625 "because it contains a computed goto");
3626 *handled_ops_p = true;
3627 return t;
3629 break;
3631 default:
3632 break;
3635 *handled_ops_p = false;
3636 return NULL_TREE;
3639 /* Return true if FNDECL is a function that cannot be inlined into
3640 another one. */
3642 static bool
3643 inline_forbidden_p (tree fndecl)
3645 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
3646 struct walk_stmt_info wi;
3647 basic_block bb;
3648 bool forbidden_p = false;
3650 /* First check for shared reasons not to copy the code. */
3651 inline_forbidden_reason = copy_forbidden (fun, fndecl);
3652 if (inline_forbidden_reason != NULL)
3653 return true;
3655 /* Next, walk the statements of the function looking for
3656 constraucts we can't handle, or are non-optimal for inlining. */
3657 hash_set<tree> visited_nodes;
3658 memset (&wi, 0, sizeof (wi));
3659 wi.info = (void *) fndecl;
3660 wi.pset = &visited_nodes;
3662 FOR_EACH_BB_FN (bb, fun)
3664 gimple ret;
3665 gimple_seq seq = bb_seq (bb);
3666 ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, NULL, &wi);
3667 forbidden_p = (ret != NULL);
3668 if (forbidden_p)
3669 break;
3672 return forbidden_p;
3675 /* Return false if the function FNDECL cannot be inlined on account of its
3676 attributes, true otherwise. */
3677 static bool
3678 function_attribute_inlinable_p (const_tree fndecl)
3680 if (targetm.attribute_table)
3682 const_tree a;
3684 for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
3686 const_tree name = TREE_PURPOSE (a);
3687 int i;
3689 for (i = 0; targetm.attribute_table[i].name != NULL; i++)
3690 if (is_attribute_p (targetm.attribute_table[i].name, name))
3691 return targetm.function_attribute_inlinable_p (fndecl);
3695 return true;
3698 /* Returns nonzero if FN is a function that does not have any
3699 fundamental inline blocking properties. */
3701 bool
3702 tree_inlinable_function_p (tree fn)
3704 bool inlinable = true;
3705 bool do_warning;
3706 tree always_inline;
3708 /* If we've already decided this function shouldn't be inlined,
3709 there's no need to check again. */
3710 if (DECL_UNINLINABLE (fn))
3711 return false;
3713 /* We only warn for functions declared `inline' by the user. */
3714 do_warning = (warn_inline
3715 && DECL_DECLARED_INLINE_P (fn)
3716 && !DECL_NO_INLINE_WARNING_P (fn)
3717 && !DECL_IN_SYSTEM_HEADER (fn));
3719 always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
3721 if (flag_no_inline
3722 && always_inline == NULL)
3724 if (do_warning)
3725 warning (OPT_Winline, "function %q+F can never be inlined because it "
3726 "is suppressed using -fno-inline", fn);
3727 inlinable = false;
3730 else if (!function_attribute_inlinable_p (fn))
3732 if (do_warning)
3733 warning (OPT_Winline, "function %q+F can never be inlined because it "
3734 "uses attributes conflicting with inlining", fn);
3735 inlinable = false;
3738 else if (inline_forbidden_p (fn))
3740 /* See if we should warn about uninlinable functions. Previously,
3741 some of these warnings would be issued while trying to expand
3742 the function inline, but that would cause multiple warnings
3743 about functions that would for example call alloca. But since
3744 this a property of the function, just one warning is enough.
3745 As a bonus we can now give more details about the reason why a
3746 function is not inlinable. */
3747 if (always_inline)
3748 error (inline_forbidden_reason, fn);
3749 else if (do_warning)
3750 warning (OPT_Winline, inline_forbidden_reason, fn);
3752 inlinable = false;
3755 /* Squirrel away the result so that we don't have to check again. */
3756 DECL_UNINLINABLE (fn) = !inlinable;
3758 return inlinable;
3761 /* Estimate the cost of a memory move of type TYPE. Use machine dependent
3762 word size and take possible memcpy call into account and return
3763 cost based on whether optimizing for size or speed according to SPEED_P. */
3766 estimate_move_cost (tree type, bool ARG_UNUSED (speed_p))
3768 HOST_WIDE_INT size;
3770 gcc_assert (!VOID_TYPE_P (type));
3772 if (TREE_CODE (type) == VECTOR_TYPE)
3774 machine_mode inner = TYPE_MODE (TREE_TYPE (type));
3775 machine_mode simd
3776 = targetm.vectorize.preferred_simd_mode (inner);
3777 int simd_mode_size = GET_MODE_SIZE (simd);
3778 return ((GET_MODE_SIZE (TYPE_MODE (type)) + simd_mode_size - 1)
3779 / simd_mode_size);
3782 size = int_size_in_bytes (type);
3784 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (speed_p))
3785 /* Cost of a memcpy call, 3 arguments and the call. */
3786 return 4;
3787 else
3788 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
3791 /* Returns cost of operation CODE, according to WEIGHTS */
3793 static int
3794 estimate_operator_cost (enum tree_code code, eni_weights *weights,
3795 tree op1 ATTRIBUTE_UNUSED, tree op2)
3797 switch (code)
3799 /* These are "free" conversions, or their presumed cost
3800 is folded into other operations. */
3801 case RANGE_EXPR:
3802 CASE_CONVERT:
3803 case COMPLEX_EXPR:
3804 case PAREN_EXPR:
3805 case VIEW_CONVERT_EXPR:
3806 return 0;
3808 /* Assign cost of 1 to usual operations.
3809 ??? We may consider mapping RTL costs to this. */
3810 case COND_EXPR:
3811 case VEC_COND_EXPR:
3812 case VEC_PERM_EXPR:
3814 case PLUS_EXPR:
3815 case POINTER_PLUS_EXPR:
3816 case MINUS_EXPR:
3817 case MULT_EXPR:
3818 case MULT_HIGHPART_EXPR:
3819 case FMA_EXPR:
3821 case ADDR_SPACE_CONVERT_EXPR:
3822 case FIXED_CONVERT_EXPR:
3823 case FIX_TRUNC_EXPR:
3825 case NEGATE_EXPR:
3826 case FLOAT_EXPR:
3827 case MIN_EXPR:
3828 case MAX_EXPR:
3829 case ABS_EXPR:
3831 case LSHIFT_EXPR:
3832 case RSHIFT_EXPR:
3833 case LROTATE_EXPR:
3834 case RROTATE_EXPR:
3836 case BIT_IOR_EXPR:
3837 case BIT_XOR_EXPR:
3838 case BIT_AND_EXPR:
3839 case BIT_NOT_EXPR:
3841 case TRUTH_ANDIF_EXPR:
3842 case TRUTH_ORIF_EXPR:
3843 case TRUTH_AND_EXPR:
3844 case TRUTH_OR_EXPR:
3845 case TRUTH_XOR_EXPR:
3846 case TRUTH_NOT_EXPR:
3848 case LT_EXPR:
3849 case LE_EXPR:
3850 case GT_EXPR:
3851 case GE_EXPR:
3852 case EQ_EXPR:
3853 case NE_EXPR:
3854 case ORDERED_EXPR:
3855 case UNORDERED_EXPR:
3857 case UNLT_EXPR:
3858 case UNLE_EXPR:
3859 case UNGT_EXPR:
3860 case UNGE_EXPR:
3861 case UNEQ_EXPR:
3862 case LTGT_EXPR:
3864 case CONJ_EXPR:
3866 case PREDECREMENT_EXPR:
3867 case PREINCREMENT_EXPR:
3868 case POSTDECREMENT_EXPR:
3869 case POSTINCREMENT_EXPR:
3871 case REALIGN_LOAD_EXPR:
3873 case REDUC_MAX_EXPR:
3874 case REDUC_MIN_EXPR:
3875 case REDUC_PLUS_EXPR:
3876 case WIDEN_SUM_EXPR:
3877 case WIDEN_MULT_EXPR:
3878 case DOT_PROD_EXPR:
3879 case SAD_EXPR:
3880 case WIDEN_MULT_PLUS_EXPR:
3881 case WIDEN_MULT_MINUS_EXPR:
3882 case WIDEN_LSHIFT_EXPR:
3884 case VEC_WIDEN_MULT_HI_EXPR:
3885 case VEC_WIDEN_MULT_LO_EXPR:
3886 case VEC_WIDEN_MULT_EVEN_EXPR:
3887 case VEC_WIDEN_MULT_ODD_EXPR:
3888 case VEC_UNPACK_HI_EXPR:
3889 case VEC_UNPACK_LO_EXPR:
3890 case VEC_UNPACK_FLOAT_HI_EXPR:
3891 case VEC_UNPACK_FLOAT_LO_EXPR:
3892 case VEC_PACK_TRUNC_EXPR:
3893 case VEC_PACK_SAT_EXPR:
3894 case VEC_PACK_FIX_TRUNC_EXPR:
3895 case VEC_WIDEN_LSHIFT_HI_EXPR:
3896 case VEC_WIDEN_LSHIFT_LO_EXPR:
3898 return 1;
3900 /* Few special cases of expensive operations. This is useful
3901 to avoid inlining on functions having too many of these. */
3902 case TRUNC_DIV_EXPR:
3903 case CEIL_DIV_EXPR:
3904 case FLOOR_DIV_EXPR:
3905 case ROUND_DIV_EXPR:
3906 case EXACT_DIV_EXPR:
3907 case TRUNC_MOD_EXPR:
3908 case CEIL_MOD_EXPR:
3909 case FLOOR_MOD_EXPR:
3910 case ROUND_MOD_EXPR:
3911 case RDIV_EXPR:
3912 if (TREE_CODE (op2) != INTEGER_CST)
3913 return weights->div_mod_cost;
3914 return 1;
3916 default:
3917 /* We expect a copy assignment with no operator. */
3918 gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS);
3919 return 0;
3924 /* Estimate number of instructions that will be created by expanding
3925 the statements in the statement sequence STMTS.
3926 WEIGHTS contains weights attributed to various constructs. */
3928 static
3929 int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights)
3931 int cost;
3932 gimple_stmt_iterator gsi;
3934 cost = 0;
3935 for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
3936 cost += estimate_num_insns (gsi_stmt (gsi), weights);
3938 return cost;
3942 /* Estimate number of instructions that will be created by expanding STMT.
3943 WEIGHTS contains weights attributed to various constructs. */
3946 estimate_num_insns (gimple stmt, eni_weights *weights)
3948 unsigned cost, i;
3949 enum gimple_code code = gimple_code (stmt);
3950 tree lhs;
3951 tree rhs;
3953 switch (code)
3955 case GIMPLE_ASSIGN:
3956 /* Try to estimate the cost of assignments. We have three cases to
3957 deal with:
3958 1) Simple assignments to registers;
3959 2) Stores to things that must live in memory. This includes
3960 "normal" stores to scalars, but also assignments of large
3961 structures, or constructors of big arrays;
3963 Let us look at the first two cases, assuming we have "a = b + C":
3964 <GIMPLE_ASSIGN <var_decl "a">
3965 <plus_expr <var_decl "b"> <constant C>>
3966 If "a" is a GIMPLE register, the assignment to it is free on almost
3967 any target, because "a" usually ends up in a real register. Hence
3968 the only cost of this expression comes from the PLUS_EXPR, and we
3969 can ignore the GIMPLE_ASSIGN.
3970 If "a" is not a GIMPLE register, the assignment to "a" will most
3971 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3972 of moving something into "a", which we compute using the function
3973 estimate_move_cost. */
3974 if (gimple_clobber_p (stmt))
3975 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3977 lhs = gimple_assign_lhs (stmt);
3978 rhs = gimple_assign_rhs1 (stmt);
3980 cost = 0;
3982 /* Account for the cost of moving to / from memory. */
3983 if (gimple_store_p (stmt))
3984 cost += estimate_move_cost (TREE_TYPE (lhs), weights->time_based);
3985 if (gimple_assign_load_p (stmt))
3986 cost += estimate_move_cost (TREE_TYPE (rhs), weights->time_based);
3988 cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights,
3989 gimple_assign_rhs1 (stmt),
3990 get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
3991 == GIMPLE_BINARY_RHS
3992 ? gimple_assign_rhs2 (stmt) : NULL);
3993 break;
3995 case GIMPLE_COND:
3996 cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights,
3997 gimple_op (stmt, 0),
3998 gimple_op (stmt, 1));
3999 break;
4001 case GIMPLE_SWITCH:
4003 gswitch *switch_stmt = as_a <gswitch *> (stmt);
4004 /* Take into account cost of the switch + guess 2 conditional jumps for
4005 each case label.
4007 TODO: once the switch expansion logic is sufficiently separated, we can
4008 do better job on estimating cost of the switch. */
4009 if (weights->time_based)
4010 cost = floor_log2 (gimple_switch_num_labels (switch_stmt)) * 2;
4011 else
4012 cost = gimple_switch_num_labels (switch_stmt) * 2;
4014 break;
4016 case GIMPLE_CALL:
4018 tree decl;
4020 if (gimple_call_internal_p (stmt))
4021 return 0;
4022 else if ((decl = gimple_call_fndecl (stmt))
4023 && DECL_BUILT_IN (decl))
4025 /* Do not special case builtins where we see the body.
4026 This just confuse inliner. */
4027 struct cgraph_node *node;
4028 if (!(node = cgraph_node::get (decl))
4029 || node->definition)
4031 /* For buitins that are likely expanded to nothing or
4032 inlined do not account operand costs. */
4033 else if (is_simple_builtin (decl))
4034 return 0;
4035 else if (is_inexpensive_builtin (decl))
4036 return weights->target_builtin_call_cost;
4037 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4039 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
4040 specialize the cheap expansion we do here.
4041 ??? This asks for a more general solution. */
4042 switch (DECL_FUNCTION_CODE (decl))
4044 case BUILT_IN_POW:
4045 case BUILT_IN_POWF:
4046 case BUILT_IN_POWL:
4047 if (TREE_CODE (gimple_call_arg (stmt, 1)) == REAL_CST
4048 && REAL_VALUES_EQUAL
4049 (TREE_REAL_CST (gimple_call_arg (stmt, 1)), dconst2))
4050 return estimate_operator_cost
4051 (MULT_EXPR, weights, gimple_call_arg (stmt, 0),
4052 gimple_call_arg (stmt, 0));
4053 break;
4055 default:
4056 break;
4061 cost = decl ? weights->call_cost : weights->indirect_call_cost;
4062 if (gimple_call_lhs (stmt))
4063 cost += estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt)),
4064 weights->time_based);
4065 for (i = 0; i < gimple_call_num_args (stmt); i++)
4067 tree arg = gimple_call_arg (stmt, i);
4068 cost += estimate_move_cost (TREE_TYPE (arg),
4069 weights->time_based);
4071 break;
4074 case GIMPLE_RETURN:
4075 return weights->return_cost;
4077 case GIMPLE_GOTO:
4078 case GIMPLE_LABEL:
4079 case GIMPLE_NOP:
4080 case GIMPLE_PHI:
4081 case GIMPLE_PREDICT:
4082 case GIMPLE_DEBUG:
4083 return 0;
4085 case GIMPLE_ASM:
4087 int count =
4088 asm_str_count (gimple_asm_string (as_a <gasm *> (stmt)));
4089 /* 1000 means infinity. This avoids overflows later
4090 with very long asm statements. */
4091 if (count > 1000)
4092 count = 1000;
4093 return count;
4096 case GIMPLE_RESX:
4097 /* This is either going to be an external function call with one
4098 argument, or two register copy statements plus a goto. */
4099 return 2;
4101 case GIMPLE_EH_DISPATCH:
4102 /* ??? This is going to turn into a switch statement. Ideally
4103 we'd have a look at the eh region and estimate the number of
4104 edges involved. */
4105 return 10;
4107 case GIMPLE_BIND:
4108 return estimate_num_insns_seq (
4109 gimple_bind_body (as_a <gbind *> (stmt)),
4110 weights);
4112 case GIMPLE_EH_FILTER:
4113 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights);
4115 case GIMPLE_CATCH:
4116 return estimate_num_insns_seq (gimple_catch_handler (
4117 as_a <gcatch *> (stmt)),
4118 weights);
4120 case GIMPLE_TRY:
4121 return (estimate_num_insns_seq (gimple_try_eval (stmt), weights)
4122 + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights));
4124 /* OpenMP directives are generally very expensive. */
4126 case GIMPLE_OMP_RETURN:
4127 case GIMPLE_OMP_SECTIONS_SWITCH:
4128 case GIMPLE_OMP_ATOMIC_STORE:
4129 case GIMPLE_OMP_CONTINUE:
4130 /* ...except these, which are cheap. */
4131 return 0;
4133 case GIMPLE_OMP_ATOMIC_LOAD:
4134 return weights->omp_cost;
4136 case GIMPLE_OMP_FOR:
4137 return (weights->omp_cost
4138 + estimate_num_insns_seq (gimple_omp_body (stmt), weights)
4139 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights));
4141 case GIMPLE_OMP_PARALLEL:
4142 case GIMPLE_OMP_TASK:
4143 case GIMPLE_OMP_CRITICAL:
4144 case GIMPLE_OMP_MASTER:
4145 case GIMPLE_OMP_TASKGROUP:
4146 case GIMPLE_OMP_ORDERED:
4147 case GIMPLE_OMP_SECTION:
4148 case GIMPLE_OMP_SECTIONS:
4149 case GIMPLE_OMP_SINGLE:
4150 case GIMPLE_OMP_TARGET:
4151 case GIMPLE_OMP_TEAMS:
4152 return (weights->omp_cost
4153 + estimate_num_insns_seq (gimple_omp_body (stmt), weights));
4155 case GIMPLE_TRANSACTION:
4156 return (weights->tm_cost
4157 + estimate_num_insns_seq (gimple_transaction_body (
4158 as_a <gtransaction *> (stmt)),
4159 weights));
4161 default:
4162 gcc_unreachable ();
4165 return cost;
4168 /* Estimate number of instructions that will be created by expanding
4169 function FNDECL. WEIGHTS contains weights attributed to various
4170 constructs. */
4173 estimate_num_insns_fn (tree fndecl, eni_weights *weights)
4175 struct function *my_function = DECL_STRUCT_FUNCTION (fndecl);
4176 gimple_stmt_iterator bsi;
4177 basic_block bb;
4178 int n = 0;
4180 gcc_assert (my_function && my_function->cfg);
4181 FOR_EACH_BB_FN (bb, my_function)
4183 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
4184 n += estimate_num_insns (gsi_stmt (bsi), weights);
4187 return n;
4191 /* Initializes weights used by estimate_num_insns. */
4193 void
4194 init_inline_once (void)
4196 eni_size_weights.call_cost = 1;
4197 eni_size_weights.indirect_call_cost = 3;
4198 eni_size_weights.target_builtin_call_cost = 1;
4199 eni_size_weights.div_mod_cost = 1;
4200 eni_size_weights.omp_cost = 40;
4201 eni_size_weights.tm_cost = 10;
4202 eni_size_weights.time_based = false;
4203 eni_size_weights.return_cost = 1;
4205 /* Estimating time for call is difficult, since we have no idea what the
4206 called function does. In the current uses of eni_time_weights,
4207 underestimating the cost does less harm than overestimating it, so
4208 we choose a rather small value here. */
4209 eni_time_weights.call_cost = 10;
4210 eni_time_weights.indirect_call_cost = 15;
4211 eni_time_weights.target_builtin_call_cost = 1;
4212 eni_time_weights.div_mod_cost = 10;
4213 eni_time_weights.omp_cost = 40;
4214 eni_time_weights.tm_cost = 40;
4215 eni_time_weights.time_based = true;
4216 eni_time_weights.return_cost = 2;
4219 /* Estimate the number of instructions in a gimple_seq. */
4222 count_insns_seq (gimple_seq seq, eni_weights *weights)
4224 gimple_stmt_iterator gsi;
4225 int n = 0;
4226 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
4227 n += estimate_num_insns (gsi_stmt (gsi), weights);
4229 return n;
4233 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
4235 static void
4236 prepend_lexical_block (tree current_block, tree new_block)
4238 BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (current_block);
4239 BLOCK_SUBBLOCKS (current_block) = new_block;
4240 BLOCK_SUPERCONTEXT (new_block) = current_block;
4243 /* Add local variables from CALLEE to CALLER. */
4245 static inline void
4246 add_local_variables (struct function *callee, struct function *caller,
4247 copy_body_data *id)
4249 tree var;
4250 unsigned ix;
4252 FOR_EACH_LOCAL_DECL (callee, ix, var)
4253 if (!can_be_nonlocal (var, id))
4255 tree new_var = remap_decl (var, id);
4257 /* Remap debug-expressions. */
4258 if (TREE_CODE (new_var) == VAR_DECL
4259 && DECL_HAS_DEBUG_EXPR_P (var)
4260 && new_var != var)
4262 tree tem = DECL_DEBUG_EXPR (var);
4263 bool old_regimplify = id->regimplify;
4264 id->remapping_type_depth++;
4265 walk_tree (&tem, copy_tree_body_r, id, NULL);
4266 id->remapping_type_depth--;
4267 id->regimplify = old_regimplify;
4268 SET_DECL_DEBUG_EXPR (new_var, tem);
4269 DECL_HAS_DEBUG_EXPR_P (new_var) = 1;
4271 add_local_decl (caller, new_var);
4275 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
4277 static bool
4278 expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
4280 tree use_retvar;
4281 tree fn;
4282 hash_map<tree, tree> *dst;
4283 hash_map<tree, tree> *st = NULL;
4284 tree return_slot;
4285 tree modify_dest;
4286 tree return_bounds = NULL;
4287 location_t saved_location;
4288 struct cgraph_edge *cg_edge;
4289 cgraph_inline_failed_t reason;
4290 basic_block return_block;
4291 edge e;
4292 gimple_stmt_iterator gsi, stmt_gsi;
4293 bool successfully_inlined = FALSE;
4294 bool purge_dead_abnormal_edges;
4295 gcall *call_stmt;
4296 unsigned int i;
4298 /* Set input_location here so we get the right instantiation context
4299 if we call instantiate_decl from inlinable_function_p. */
4300 /* FIXME: instantiate_decl isn't called by inlinable_function_p. */
4301 saved_location = input_location;
4302 input_location = gimple_location (stmt);
4304 /* From here on, we're only interested in CALL_EXPRs. */
4305 call_stmt = dyn_cast <gcall *> (stmt);
4306 if (!call_stmt)
4307 goto egress;
4309 cg_edge = id->dst_node->get_edge (stmt);
4310 gcc_checking_assert (cg_edge);
4311 /* First, see if we can figure out what function is being called.
4312 If we cannot, then there is no hope of inlining the function. */
4313 if (cg_edge->indirect_unknown_callee)
4314 goto egress;
4315 fn = cg_edge->callee->decl;
4316 gcc_checking_assert (fn);
4318 /* If FN is a declaration of a function in a nested scope that was
4319 globally declared inline, we don't set its DECL_INITIAL.
4320 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
4321 C++ front-end uses it for cdtors to refer to their internal
4322 declarations, that are not real functions. Fortunately those
4323 don't have trees to be saved, so we can tell by checking their
4324 gimple_body. */
4325 if (!DECL_INITIAL (fn)
4326 && DECL_ABSTRACT_ORIGIN (fn)
4327 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn)))
4328 fn = DECL_ABSTRACT_ORIGIN (fn);
4330 /* Don't try to inline functions that are not well-suited to inlining. */
4331 if (cg_edge->inline_failed)
4333 reason = cg_edge->inline_failed;
4334 /* If this call was originally indirect, we do not want to emit any
4335 inlining related warnings or sorry messages because there are no
4336 guarantees regarding those. */
4337 if (cg_edge->indirect_inlining_edge)
4338 goto egress;
4340 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
4341 /* For extern inline functions that get redefined we always
4342 silently ignored always_inline flag. Better behaviour would
4343 be to be able to keep both bodies and use extern inline body
4344 for inlining, but we can't do that because frontends overwrite
4345 the body. */
4346 && !cg_edge->callee->local.redefined_extern_inline
4347 /* During early inline pass, report only when optimization is
4348 not turned on. */
4349 && (symtab->global_info_ready
4350 || !optimize
4351 || cgraph_inline_failed_type (reason) == CIF_FINAL_ERROR)
4352 /* PR 20090218-1_0.c. Body can be provided by another module. */
4353 && (reason != CIF_BODY_NOT_AVAILABLE || !flag_generate_lto))
4355 error ("inlining failed in call to always_inline %q+F: %s", fn,
4356 cgraph_inline_failed_string (reason));
4357 error ("called from here");
4359 else if (warn_inline
4360 && DECL_DECLARED_INLINE_P (fn)
4361 && !DECL_NO_INLINE_WARNING_P (fn)
4362 && !DECL_IN_SYSTEM_HEADER (fn)
4363 && reason != CIF_UNSPECIFIED
4364 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
4365 /* Do not warn about not inlined recursive calls. */
4366 && !cg_edge->recursive_p ()
4367 /* Avoid warnings during early inline pass. */
4368 && symtab->global_info_ready)
4370 warning (OPT_Winline, "inlining failed in call to %q+F: %s",
4371 fn, _(cgraph_inline_failed_string (reason)));
4372 warning (OPT_Winline, "called from here");
4374 goto egress;
4376 fn = cg_edge->callee->decl;
4377 cg_edge->callee->get_untransformed_body ();
4379 #ifdef ENABLE_CHECKING
4380 if (cg_edge->callee->decl != id->dst_node->decl)
4381 cg_edge->callee->verify ();
4382 #endif
4384 /* We will be inlining this callee. */
4385 id->eh_lp_nr = lookup_stmt_eh_lp (stmt);
4386 id->assign_stmts.create (0);
4388 /* Update the callers EH personality. */
4389 if (DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl))
4390 DECL_FUNCTION_PERSONALITY (cg_edge->caller->decl)
4391 = DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl);
4393 /* Split the block holding the GIMPLE_CALL. */
4394 e = split_block (bb, stmt);
4395 bb = e->src;
4396 return_block = e->dest;
4397 remove_edge (e);
4399 /* split_block splits after the statement; work around this by
4400 moving the call into the second block manually. Not pretty,
4401 but seems easier than doing the CFG manipulation by hand
4402 when the GIMPLE_CALL is in the last statement of BB. */
4403 stmt_gsi = gsi_last_bb (bb);
4404 gsi_remove (&stmt_gsi, false);
4406 /* If the GIMPLE_CALL was in the last statement of BB, it may have
4407 been the source of abnormal edges. In this case, schedule
4408 the removal of dead abnormal edges. */
4409 gsi = gsi_start_bb (return_block);
4410 if (gsi_end_p (gsi))
4412 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
4413 purge_dead_abnormal_edges = true;
4415 else
4417 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
4418 purge_dead_abnormal_edges = false;
4421 stmt_gsi = gsi_start_bb (return_block);
4423 /* Build a block containing code to initialize the arguments, the
4424 actual inline expansion of the body, and a label for the return
4425 statements within the function to jump to. The type of the
4426 statement expression is the return type of the function call.
4427 ??? If the call does not have an associated block then we will
4428 remap all callee blocks to NULL, effectively dropping most of
4429 its debug information. This should only happen for calls to
4430 artificial decls inserted by the compiler itself. We need to
4431 either link the inlined blocks into the caller block tree or
4432 not refer to them in any way to not break GC for locations. */
4433 if (gimple_block (stmt))
4435 id->block = make_node (BLOCK);
4436 BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
4437 BLOCK_SOURCE_LOCATION (id->block) = LOCATION_LOCUS (input_location);
4438 prepend_lexical_block (gimple_block (stmt), id->block);
4441 /* Local declarations will be replaced by their equivalents in this
4442 map. */
4443 st = id->decl_map;
4444 id->decl_map = new hash_map<tree, tree>;
4445 dst = id->debug_map;
4446 id->debug_map = NULL;
4448 /* Record the function we are about to inline. */
4449 id->src_fn = fn;
4450 id->src_node = cg_edge->callee;
4451 id->src_cfun = DECL_STRUCT_FUNCTION (fn);
4452 id->call_stmt = stmt;
4454 gcc_assert (!id->src_cfun->after_inlining);
4456 id->entry_bb = bb;
4457 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn)))
4459 gimple_stmt_iterator si = gsi_last_bb (bb);
4460 gsi_insert_after (&si, gimple_build_predict (PRED_COLD_FUNCTION,
4461 NOT_TAKEN),
4462 GSI_NEW_STMT);
4464 initialize_inlined_parameters (id, stmt, fn, bb);
4466 if (DECL_INITIAL (fn))
4468 if (gimple_block (stmt))
4470 tree *var;
4472 prepend_lexical_block (id->block,
4473 remap_blocks (DECL_INITIAL (fn), id));
4474 gcc_checking_assert (BLOCK_SUBBLOCKS (id->block)
4475 && (BLOCK_CHAIN (BLOCK_SUBBLOCKS (id->block))
4476 == NULL_TREE));
4477 /* Move vars for PARM_DECLs from DECL_INITIAL block to id->block,
4478 otherwise for DWARF DW_TAG_formal_parameter will not be children of
4479 DW_TAG_inlined_subroutine, but of a DW_TAG_lexical_block
4480 under it. The parameters can be then evaluated in the debugger,
4481 but don't show in backtraces. */
4482 for (var = &BLOCK_VARS (BLOCK_SUBBLOCKS (id->block)); *var; )
4483 if (TREE_CODE (DECL_ORIGIN (*var)) == PARM_DECL)
4485 tree v = *var;
4486 *var = TREE_CHAIN (v);
4487 TREE_CHAIN (v) = BLOCK_VARS (id->block);
4488 BLOCK_VARS (id->block) = v;
4490 else
4491 var = &TREE_CHAIN (*var);
4493 else
4494 remap_blocks_to_null (DECL_INITIAL (fn), id);
4497 /* Return statements in the function body will be replaced by jumps
4498 to the RET_LABEL. */
4499 gcc_assert (DECL_INITIAL (fn));
4500 gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
4502 /* Find the LHS to which the result of this call is assigned. */
4503 return_slot = NULL;
4504 if (gimple_call_lhs (stmt))
4506 modify_dest = gimple_call_lhs (stmt);
4508 /* Remember where to copy returned bounds. */
4509 if (gimple_call_with_bounds_p (stmt)
4510 && TREE_CODE (modify_dest) == SSA_NAME)
4512 gcall *retbnd = chkp_retbnd_call_by_val (modify_dest);
4513 if (retbnd)
4515 return_bounds = gimple_call_lhs (retbnd);
4516 /* If returned bounds are not used then just
4517 remove unused call. */
4518 if (!return_bounds)
4520 gimple_stmt_iterator iter = gsi_for_stmt (retbnd);
4521 gsi_remove (&iter, true);
4526 /* The function which we are inlining might not return a value,
4527 in which case we should issue a warning that the function
4528 does not return a value. In that case the optimizers will
4529 see that the variable to which the value is assigned was not
4530 initialized. We do not want to issue a warning about that
4531 uninitialized variable. */
4532 if (DECL_P (modify_dest))
4533 TREE_NO_WARNING (modify_dest) = 1;
4535 if (gimple_call_return_slot_opt_p (call_stmt))
4537 return_slot = modify_dest;
4538 modify_dest = NULL;
4541 else
4542 modify_dest = NULL;
4544 /* If we are inlining a call to the C++ operator new, we don't want
4545 to use type based alias analysis on the return value. Otherwise
4546 we may get confused if the compiler sees that the inlined new
4547 function returns a pointer which was just deleted. See bug
4548 33407. */
4549 if (DECL_IS_OPERATOR_NEW (fn))
4551 return_slot = NULL;
4552 modify_dest = NULL;
4555 /* Declare the return variable for the function. */
4556 use_retvar = declare_return_variable (id, return_slot, modify_dest,
4557 return_bounds, bb);
4559 /* Add local vars in this inlined callee to caller. */
4560 add_local_variables (id->src_cfun, cfun, id);
4562 if (dump_file && (dump_flags & TDF_DETAILS))
4564 fprintf (dump_file, "Inlining ");
4565 print_generic_expr (dump_file, id->src_fn, 0);
4566 fprintf (dump_file, " to ");
4567 print_generic_expr (dump_file, id->dst_fn, 0);
4568 fprintf (dump_file, " with frequency %i\n", cg_edge->frequency);
4571 /* This is it. Duplicate the callee body. Assume callee is
4572 pre-gimplified. Note that we must not alter the caller
4573 function in any way before this point, as this CALL_EXPR may be
4574 a self-referential call; if we're calling ourselves, we need to
4575 duplicate our body before altering anything. */
4576 copy_body (id, cg_edge->callee->count,
4577 GCOV_COMPUTE_SCALE (cg_edge->frequency, CGRAPH_FREQ_BASE),
4578 bb, return_block, NULL);
4580 /* Reset the escaped solution. */
4581 if (cfun->gimple_df)
4582 pt_solution_reset (&cfun->gimple_df->escaped);
4584 /* Clean up. */
4585 if (id->debug_map)
4587 delete id->debug_map;
4588 id->debug_map = dst;
4590 delete id->decl_map;
4591 id->decl_map = st;
4593 /* Unlink the calls virtual operands before replacing it. */
4594 unlink_stmt_vdef (stmt);
4595 if (gimple_vdef (stmt)
4596 && TREE_CODE (gimple_vdef (stmt)) == SSA_NAME)
4597 release_ssa_name (gimple_vdef (stmt));
4599 /* If the inlined function returns a result that we care about,
4600 substitute the GIMPLE_CALL with an assignment of the return
4601 variable to the LHS of the call. That is, if STMT was
4602 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4603 if (use_retvar && gimple_call_lhs (stmt))
4605 gimple old_stmt = stmt;
4606 stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar);
4607 gsi_replace (&stmt_gsi, stmt, false);
4608 maybe_clean_or_replace_eh_stmt (old_stmt, stmt);
4610 /* Copy bounds if we copy structure with bounds. */
4611 if (chkp_function_instrumented_p (id->dst_fn)
4612 && !BOUNDED_P (use_retvar)
4613 && chkp_type_has_pointer (TREE_TYPE (use_retvar)))
4614 id->assign_stmts.safe_push (stmt);
4616 else
4618 /* Handle the case of inlining a function with no return
4619 statement, which causes the return value to become undefined. */
4620 if (gimple_call_lhs (stmt)
4621 && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME)
4623 tree name = gimple_call_lhs (stmt);
4624 tree var = SSA_NAME_VAR (name);
4625 tree def = ssa_default_def (cfun, var);
4627 if (def)
4629 /* If the variable is used undefined, make this name
4630 undefined via a move. */
4631 stmt = gimple_build_assign (gimple_call_lhs (stmt), def);
4632 gsi_replace (&stmt_gsi, stmt, true);
4634 else
4636 /* Otherwise make this variable undefined. */
4637 gsi_remove (&stmt_gsi, true);
4638 set_ssa_default_def (cfun, var, name);
4639 SSA_NAME_DEF_STMT (name) = gimple_build_nop ();
4642 else
4643 gsi_remove (&stmt_gsi, true);
4646 /* Put returned bounds into the correct place if required. */
4647 if (return_bounds)
4649 gimple old_stmt = SSA_NAME_DEF_STMT (return_bounds);
4650 gimple new_stmt = gimple_build_assign (return_bounds, id->retbnd);
4651 gimple_stmt_iterator bnd_gsi = gsi_for_stmt (old_stmt);
4652 unlink_stmt_vdef (old_stmt);
4653 gsi_replace (&bnd_gsi, new_stmt, false);
4654 maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt);
4655 cgraph_update_edges_for_call_stmt (old_stmt,
4656 gimple_call_fndecl (old_stmt),
4657 new_stmt);
4660 if (purge_dead_abnormal_edges)
4662 gimple_purge_dead_eh_edges (return_block);
4663 gimple_purge_dead_abnormal_call_edges (return_block);
4666 /* If the value of the new expression is ignored, that's OK. We
4667 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4668 the equivalent inlined version either. */
4669 if (is_gimple_assign (stmt))
4671 gcc_assert (gimple_assign_single_p (stmt)
4672 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)));
4673 TREE_USED (gimple_assign_rhs1 (stmt)) = 1;
4676 /* Copy bounds for all generated assigns that need it. */
4677 for (i = 0; i < id->assign_stmts.length (); i++)
4678 chkp_copy_bounds_for_assign (id->assign_stmts[i], cg_edge);
4679 id->assign_stmts.release ();
4681 /* Output the inlining info for this abstract function, since it has been
4682 inlined. If we don't do this now, we can lose the information about the
4683 variables in the function when the blocks get blown away as soon as we
4684 remove the cgraph node. */
4685 if (gimple_block (stmt))
4686 (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
4688 /* Update callgraph if needed. */
4689 cg_edge->callee->remove ();
4691 id->block = NULL_TREE;
4692 successfully_inlined = TRUE;
4694 egress:
4695 input_location = saved_location;
4696 return successfully_inlined;
4699 /* Expand call statements reachable from STMT_P.
4700 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4701 in a MODIFY_EXPR. */
4703 static bool
4704 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
4706 gimple_stmt_iterator gsi;
4708 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4710 gimple stmt = gsi_stmt (gsi);
4712 if (is_gimple_call (stmt)
4713 && !gimple_call_internal_p (stmt)
4714 && expand_call_inline (bb, stmt, id))
4715 return true;
4718 return false;
4722 /* Walk all basic blocks created after FIRST and try to fold every statement
4723 in the STATEMENTS pointer set. */
4725 static void
4726 fold_marked_statements (int first, hash_set<gimple> *statements)
4728 for (; first < n_basic_blocks_for_fn (cfun); first++)
4729 if (BASIC_BLOCK_FOR_FN (cfun, first))
4731 gimple_stmt_iterator gsi;
4733 for (gsi = gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, first));
4734 !gsi_end_p (gsi);
4735 gsi_next (&gsi))
4736 if (statements->contains (gsi_stmt (gsi)))
4738 gimple old_stmt = gsi_stmt (gsi);
4739 tree old_decl = is_gimple_call (old_stmt) ? gimple_call_fndecl (old_stmt) : 0;
4741 if (old_decl && DECL_BUILT_IN (old_decl))
4743 /* Folding builtins can create multiple instructions,
4744 we need to look at all of them. */
4745 gimple_stmt_iterator i2 = gsi;
4746 gsi_prev (&i2);
4747 if (fold_stmt (&gsi))
4749 gimple new_stmt;
4750 /* If a builtin at the end of a bb folded into nothing,
4751 the following loop won't work. */
4752 if (gsi_end_p (gsi))
4754 cgraph_update_edges_for_call_stmt (old_stmt,
4755 old_decl, NULL);
4756 break;
4758 if (gsi_end_p (i2))
4759 i2 = gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, first));
4760 else
4761 gsi_next (&i2);
4762 while (1)
4764 new_stmt = gsi_stmt (i2);
4765 update_stmt (new_stmt);
4766 cgraph_update_edges_for_call_stmt (old_stmt, old_decl,
4767 new_stmt);
4769 if (new_stmt == gsi_stmt (gsi))
4771 /* It is okay to check only for the very last
4772 of these statements. If it is a throwing
4773 statement nothing will change. If it isn't
4774 this can remove EH edges. If that weren't
4775 correct then because some intermediate stmts
4776 throw, but not the last one. That would mean
4777 we'd have to split the block, which we can't
4778 here and we'd loose anyway. And as builtins
4779 probably never throw, this all
4780 is mood anyway. */
4781 if (maybe_clean_or_replace_eh_stmt (old_stmt,
4782 new_stmt))
4783 gimple_purge_dead_eh_edges (
4784 BASIC_BLOCK_FOR_FN (cfun, first));
4785 break;
4787 gsi_next (&i2);
4791 else if (fold_stmt (&gsi))
4793 /* Re-read the statement from GSI as fold_stmt() may
4794 have changed it. */
4795 gimple new_stmt = gsi_stmt (gsi);
4796 update_stmt (new_stmt);
4798 if (is_gimple_call (old_stmt)
4799 || is_gimple_call (new_stmt))
4800 cgraph_update_edges_for_call_stmt (old_stmt, old_decl,
4801 new_stmt);
4803 if (maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt))
4804 gimple_purge_dead_eh_edges (BASIC_BLOCK_FOR_FN (cfun,
4805 first));
4811 /* Expand calls to inline functions in the body of FN. */
4813 unsigned int
4814 optimize_inline_calls (tree fn)
4816 copy_body_data id;
4817 basic_block bb;
4818 int last = n_basic_blocks_for_fn (cfun);
4819 bool inlined_p = false;
4821 /* Clear out ID. */
4822 memset (&id, 0, sizeof (id));
4824 id.src_node = id.dst_node = cgraph_node::get (fn);
4825 gcc_assert (id.dst_node->definition);
4826 id.dst_fn = fn;
4827 /* Or any functions that aren't finished yet. */
4828 if (current_function_decl)
4829 id.dst_fn = current_function_decl;
4831 id.copy_decl = copy_decl_maybe_to_var;
4832 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
4833 id.transform_new_cfg = false;
4834 id.transform_return_to_modify = true;
4835 id.transform_parameter = true;
4836 id.transform_lang_insert_block = NULL;
4837 id.statements_to_fold = new hash_set<gimple>;
4839 push_gimplify_context ();
4841 /* We make no attempts to keep dominance info up-to-date. */
4842 free_dominance_info (CDI_DOMINATORS);
4843 free_dominance_info (CDI_POST_DOMINATORS);
4845 /* Register specific gimple functions. */
4846 gimple_register_cfg_hooks ();
4848 /* Reach the trees by walking over the CFG, and note the
4849 enclosing basic-blocks in the call edges. */
4850 /* We walk the blocks going forward, because inlined function bodies
4851 will split id->current_basic_block, and the new blocks will
4852 follow it; we'll trudge through them, processing their CALL_EXPRs
4853 along the way. */
4854 FOR_EACH_BB_FN (bb, cfun)
4855 inlined_p |= gimple_expand_calls_inline (bb, &id);
4857 pop_gimplify_context (NULL);
4859 #ifdef ENABLE_CHECKING
4861 struct cgraph_edge *e;
4863 id.dst_node->verify ();
4865 /* Double check that we inlined everything we are supposed to inline. */
4866 for (e = id.dst_node->callees; e; e = e->next_callee)
4867 gcc_assert (e->inline_failed);
4869 #endif
4871 /* Fold queued statements. */
4872 fold_marked_statements (last, id.statements_to_fold);
4873 delete id.statements_to_fold;
4875 gcc_assert (!id.debug_stmts.exists ());
4877 /* If we didn't inline into the function there is nothing to do. */
4878 if (!inlined_p)
4879 return 0;
4881 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4882 number_blocks (fn);
4884 delete_unreachable_blocks_update_callgraph (&id);
4885 #ifdef ENABLE_CHECKING
4886 id.dst_node->verify ();
4887 #endif
4889 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4890 not possible yet - the IPA passes might make various functions to not
4891 throw and they don't care to proactively update local EH info. This is
4892 done later in fixup_cfg pass that also execute the verification. */
4893 return (TODO_update_ssa
4894 | TODO_cleanup_cfg
4895 | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
4896 | (gimple_in_ssa_p (cfun) ? TODO_update_address_taken : 0)
4897 | (profile_status_for_fn (cfun) != PROFILE_ABSENT
4898 ? TODO_rebuild_frequencies : 0));
4901 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4903 tree
4904 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
4906 enum tree_code code = TREE_CODE (*tp);
4907 enum tree_code_class cl = TREE_CODE_CLASS (code);
4909 /* We make copies of most nodes. */
4910 if (IS_EXPR_CODE_CLASS (cl)
4911 || code == TREE_LIST
4912 || code == TREE_VEC
4913 || code == TYPE_DECL
4914 || code == OMP_CLAUSE)
4916 /* Because the chain gets clobbered when we make a copy, we save it
4917 here. */
4918 tree chain = NULL_TREE, new_tree;
4920 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
4921 chain = TREE_CHAIN (*tp);
4923 /* Copy the node. */
4924 new_tree = copy_node (*tp);
4926 *tp = new_tree;
4928 /* Now, restore the chain, if appropriate. That will cause
4929 walk_tree to walk into the chain as well. */
4930 if (code == PARM_DECL
4931 || code == TREE_LIST
4932 || code == OMP_CLAUSE)
4933 TREE_CHAIN (*tp) = chain;
4935 /* For now, we don't update BLOCKs when we make copies. So, we
4936 have to nullify all BIND_EXPRs. */
4937 if (TREE_CODE (*tp) == BIND_EXPR)
4938 BIND_EXPR_BLOCK (*tp) = NULL_TREE;
4940 else if (code == CONSTRUCTOR)
4942 /* CONSTRUCTOR nodes need special handling because
4943 we need to duplicate the vector of elements. */
4944 tree new_tree;
4946 new_tree = copy_node (*tp);
4947 CONSTRUCTOR_ELTS (new_tree) = vec_safe_copy (CONSTRUCTOR_ELTS (*tp));
4948 *tp = new_tree;
4950 else if (code == STATEMENT_LIST)
4951 /* We used to just abort on STATEMENT_LIST, but we can run into them
4952 with statement-expressions (c++/40975). */
4953 copy_statement_list (tp);
4954 else if (TREE_CODE_CLASS (code) == tcc_type)
4955 *walk_subtrees = 0;
4956 else if (TREE_CODE_CLASS (code) == tcc_declaration)
4957 *walk_subtrees = 0;
4958 else if (TREE_CODE_CLASS (code) == tcc_constant)
4959 *walk_subtrees = 0;
4960 return NULL_TREE;
4963 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4964 information indicating to what new SAVE_EXPR this one should be mapped,
4965 use that one. Otherwise, create a new node and enter it in ST. FN is
4966 the function into which the copy will be placed. */
4968 static void
4969 remap_save_expr (tree *tp, hash_map<tree, tree> *st, int *walk_subtrees)
4971 tree *n;
4972 tree t;
4974 /* See if we already encountered this SAVE_EXPR. */
4975 n = st->get (*tp);
4977 /* If we didn't already remap this SAVE_EXPR, do so now. */
4978 if (!n)
4980 t = copy_node (*tp);
4982 /* Remember this SAVE_EXPR. */
4983 st->put (*tp, t);
4984 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4985 st->put (t, t);
4987 else
4989 /* We've already walked into this SAVE_EXPR; don't do it again. */
4990 *walk_subtrees = 0;
4991 t = *n;
4994 /* Replace this SAVE_EXPR with the copy. */
4995 *tp = t;
4998 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4999 label, copies the declaration and enters it in the splay_tree in DATA (which
5000 is really a 'copy_body_data *'. */
5002 static tree
5003 mark_local_labels_stmt (gimple_stmt_iterator *gsip,
5004 bool *handled_ops_p ATTRIBUTE_UNUSED,
5005 struct walk_stmt_info *wi)
5007 copy_body_data *id = (copy_body_data *) wi->info;
5008 glabel *stmt = dyn_cast <glabel *> (gsi_stmt (*gsip));
5010 if (stmt)
5012 tree decl = gimple_label_label (stmt);
5014 /* Copy the decl and remember the copy. */
5015 insert_decl_map (id, decl, id->copy_decl (decl, id));
5018 return NULL_TREE;
5022 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5023 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5024 remaps all local declarations to appropriate replacements in gimple
5025 operands. */
5027 static tree
5028 replace_locals_op (tree *tp, int *walk_subtrees, void *data)
5030 struct walk_stmt_info *wi = (struct walk_stmt_info*) data;
5031 copy_body_data *id = (copy_body_data *) wi->info;
5032 hash_map<tree, tree> *st = id->decl_map;
5033 tree *n;
5034 tree expr = *tp;
5036 /* Only a local declaration (variable or label). */
5037 if ((TREE_CODE (expr) == VAR_DECL
5038 && !TREE_STATIC (expr))
5039 || TREE_CODE (expr) == LABEL_DECL)
5041 /* Lookup the declaration. */
5042 n = st->get (expr);
5044 /* If it's there, remap it. */
5045 if (n)
5046 *tp = *n;
5047 *walk_subtrees = 0;
5049 else if (TREE_CODE (expr) == STATEMENT_LIST
5050 || TREE_CODE (expr) == BIND_EXPR
5051 || TREE_CODE (expr) == SAVE_EXPR)
5052 gcc_unreachable ();
5053 else if (TREE_CODE (expr) == TARGET_EXPR)
5055 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
5056 It's OK for this to happen if it was part of a subtree that
5057 isn't immediately expanded, such as operand 2 of another
5058 TARGET_EXPR. */
5059 if (!TREE_OPERAND (expr, 1))
5061 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
5062 TREE_OPERAND (expr, 3) = NULL_TREE;
5066 /* Keep iterating. */
5067 return NULL_TREE;
5071 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
5072 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
5073 remaps all local declarations to appropriate replacements in gimple
5074 statements. */
5076 static tree
5077 replace_locals_stmt (gimple_stmt_iterator *gsip,
5078 bool *handled_ops_p ATTRIBUTE_UNUSED,
5079 struct walk_stmt_info *wi)
5081 copy_body_data *id = (copy_body_data *) wi->info;
5082 gimple gs = gsi_stmt (*gsip);
5084 if (gbind *stmt = dyn_cast <gbind *> (gs))
5086 tree block = gimple_bind_block (stmt);
5088 if (block)
5090 remap_block (&block, id);
5091 gimple_bind_set_block (stmt, block);
5094 /* This will remap a lot of the same decls again, but this should be
5095 harmless. */
5096 if (gimple_bind_vars (stmt))
5097 gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt),
5098 NULL, id));
5101 /* Keep iterating. */
5102 return NULL_TREE;
5106 /* Copies everything in SEQ and replaces variables and labels local to
5107 current_function_decl. */
5109 gimple_seq
5110 copy_gimple_seq_and_replace_locals (gimple_seq seq)
5112 copy_body_data id;
5113 struct walk_stmt_info wi;
5114 gimple_seq copy;
5116 /* There's nothing to do for NULL_TREE. */
5117 if (seq == NULL)
5118 return seq;
5120 /* Set up ID. */
5121 memset (&id, 0, sizeof (id));
5122 id.src_fn = current_function_decl;
5123 id.dst_fn = current_function_decl;
5124 id.decl_map = new hash_map<tree, tree>;
5125 id.debug_map = NULL;
5127 id.copy_decl = copy_decl_no_change;
5128 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
5129 id.transform_new_cfg = false;
5130 id.transform_return_to_modify = false;
5131 id.transform_parameter = false;
5132 id.transform_lang_insert_block = NULL;
5134 /* Walk the tree once to find local labels. */
5135 memset (&wi, 0, sizeof (wi));
5136 hash_set<tree> visited;
5137 wi.info = &id;
5138 wi.pset = &visited;
5139 walk_gimple_seq (seq, mark_local_labels_stmt, NULL, &wi);
5141 copy = gimple_seq_copy (seq);
5143 /* Walk the copy, remapping decls. */
5144 memset (&wi, 0, sizeof (wi));
5145 wi.info = &id;
5146 walk_gimple_seq (copy, replace_locals_stmt, replace_locals_op, &wi);
5148 /* Clean up. */
5149 delete id.decl_map;
5150 if (id.debug_map)
5151 delete id.debug_map;
5153 return copy;
5157 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
5159 static tree
5160 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
5162 if (*tp == data)
5163 return (tree) data;
5164 else
5165 return NULL;
5168 DEBUG_FUNCTION bool
5169 debug_find_tree (tree top, tree search)
5171 return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
5175 /* Declare the variables created by the inliner. Add all the variables in
5176 VARS to BIND_EXPR. */
5178 static void
5179 declare_inline_vars (tree block, tree vars)
5181 tree t;
5182 for (t = vars; t; t = DECL_CHAIN (t))
5184 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
5185 gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
5186 add_local_decl (cfun, t);
5189 if (block)
5190 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
5193 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
5194 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
5195 VAR_DECL translation. */
5197 static tree
5198 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
5200 /* Don't generate debug information for the copy if we wouldn't have
5201 generated it for the copy either. */
5202 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
5203 DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
5205 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
5206 declaration inspired this copy. */
5207 DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
5209 /* The new variable/label has no RTL, yet. */
5210 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
5211 && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
5212 SET_DECL_RTL (copy, 0);
5214 /* These args would always appear unused, if not for this. */
5215 TREE_USED (copy) = 1;
5217 /* Set the context for the new declaration. */
5218 if (!DECL_CONTEXT (decl))
5219 /* Globals stay global. */
5221 else if (DECL_CONTEXT (decl) != id->src_fn)
5222 /* Things that weren't in the scope of the function we're inlining
5223 from aren't in the scope we're inlining to, either. */
5225 else if (TREE_STATIC (decl))
5226 /* Function-scoped static variables should stay in the original
5227 function. */
5229 else
5230 /* Ordinary automatic local variables are now in the scope of the
5231 new function. */
5232 DECL_CONTEXT (copy) = id->dst_fn;
5234 return copy;
5237 static tree
5238 copy_decl_to_var (tree decl, copy_body_data *id)
5240 tree copy, type;
5242 gcc_assert (TREE_CODE (decl) == PARM_DECL
5243 || TREE_CODE (decl) == RESULT_DECL);
5245 type = TREE_TYPE (decl);
5247 copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn),
5248 VAR_DECL, DECL_NAME (decl), type);
5249 if (DECL_PT_UID_SET_P (decl))
5250 SET_DECL_PT_UID (copy, DECL_PT_UID (decl));
5251 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
5252 TREE_READONLY (copy) = TREE_READONLY (decl);
5253 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
5254 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
5256 return copy_decl_for_dup_finish (id, decl, copy);
5259 /* Like copy_decl_to_var, but create a return slot object instead of a
5260 pointer variable for return by invisible reference. */
5262 static tree
5263 copy_result_decl_to_var (tree decl, copy_body_data *id)
5265 tree copy, type;
5267 gcc_assert (TREE_CODE (decl) == PARM_DECL
5268 || TREE_CODE (decl) == RESULT_DECL);
5270 type = TREE_TYPE (decl);
5271 if (DECL_BY_REFERENCE (decl))
5272 type = TREE_TYPE (type);
5274 copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn),
5275 VAR_DECL, DECL_NAME (decl), type);
5276 if (DECL_PT_UID_SET_P (decl))
5277 SET_DECL_PT_UID (copy, DECL_PT_UID (decl));
5278 TREE_READONLY (copy) = TREE_READONLY (decl);
5279 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
5280 if (!DECL_BY_REFERENCE (decl))
5282 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
5283 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
5286 return copy_decl_for_dup_finish (id, decl, copy);
5289 tree
5290 copy_decl_no_change (tree decl, copy_body_data *id)
5292 tree copy;
5294 copy = copy_node (decl);
5296 /* The COPY is not abstract; it will be generated in DST_FN. */
5297 DECL_ABSTRACT_P (copy) = false;
5298 lang_hooks.dup_lang_specific_decl (copy);
5300 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
5301 been taken; it's for internal bookkeeping in expand_goto_internal. */
5302 if (TREE_CODE (copy) == LABEL_DECL)
5304 TREE_ADDRESSABLE (copy) = 0;
5305 LABEL_DECL_UID (copy) = -1;
5308 return copy_decl_for_dup_finish (id, decl, copy);
5311 static tree
5312 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
5314 if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
5315 return copy_decl_to_var (decl, id);
5316 else
5317 return copy_decl_no_change (decl, id);
5320 /* Return a copy of the function's argument tree. */
5321 static tree
5322 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id,
5323 bitmap args_to_skip, tree *vars)
5325 tree arg, *parg;
5326 tree new_parm = NULL;
5327 int i = 0;
5329 parg = &new_parm;
5331 for (arg = orig_parm; arg; arg = DECL_CHAIN (arg), i++)
5332 if (!args_to_skip || !bitmap_bit_p (args_to_skip, i))
5334 tree new_tree = remap_decl (arg, id);
5335 if (TREE_CODE (new_tree) != PARM_DECL)
5336 new_tree = id->copy_decl (arg, id);
5337 lang_hooks.dup_lang_specific_decl (new_tree);
5338 *parg = new_tree;
5339 parg = &DECL_CHAIN (new_tree);
5341 else if (!id->decl_map->get (arg))
5343 /* Make an equivalent VAR_DECL. If the argument was used
5344 as temporary variable later in function, the uses will be
5345 replaced by local variable. */
5346 tree var = copy_decl_to_var (arg, id);
5347 insert_decl_map (id, arg, var);
5348 /* Declare this new variable. */
5349 DECL_CHAIN (var) = *vars;
5350 *vars = var;
5352 return new_parm;
5355 /* Return a copy of the function's static chain. */
5356 static tree
5357 copy_static_chain (tree static_chain, copy_body_data * id)
5359 tree *chain_copy, *pvar;
5361 chain_copy = &static_chain;
5362 for (pvar = chain_copy; *pvar; pvar = &DECL_CHAIN (*pvar))
5364 tree new_tree = remap_decl (*pvar, id);
5365 lang_hooks.dup_lang_specific_decl (new_tree);
5366 DECL_CHAIN (new_tree) = DECL_CHAIN (*pvar);
5367 *pvar = new_tree;
5369 return static_chain;
5372 /* Return true if the function is allowed to be versioned.
5373 This is a guard for the versioning functionality. */
5375 bool
5376 tree_versionable_function_p (tree fndecl)
5378 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl))
5379 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl), fndecl) == NULL);
5382 /* Delete all unreachable basic blocks and update callgraph.
5383 Doing so is somewhat nontrivial because we need to update all clones and
5384 remove inline function that become unreachable. */
5386 static bool
5387 delete_unreachable_blocks_update_callgraph (copy_body_data *id)
5389 bool changed = false;
5390 basic_block b, next_bb;
5392 find_unreachable_blocks ();
5394 /* Delete all unreachable basic blocks. */
5396 for (b = ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb; b
5397 != EXIT_BLOCK_PTR_FOR_FN (cfun); b = next_bb)
5399 next_bb = b->next_bb;
5401 if (!(b->flags & BB_REACHABLE))
5403 gimple_stmt_iterator bsi;
5405 for (bsi = gsi_start_bb (b); !gsi_end_p (bsi); gsi_next (&bsi))
5407 struct cgraph_edge *e;
5408 struct cgraph_node *node;
5410 id->dst_node->remove_stmt_references (gsi_stmt (bsi));
5412 if (gimple_code (gsi_stmt (bsi)) == GIMPLE_CALL
5413 &&(e = id->dst_node->get_edge (gsi_stmt (bsi))) != NULL)
5415 if (!e->inline_failed)
5416 e->callee->remove_symbol_and_inline_clones (id->dst_node);
5417 else
5418 e->remove ();
5420 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES
5421 && id->dst_node->clones)
5422 for (node = id->dst_node->clones; node != id->dst_node;)
5424 node->remove_stmt_references (gsi_stmt (bsi));
5425 if (gimple_code (gsi_stmt (bsi)) == GIMPLE_CALL
5426 && (e = node->get_edge (gsi_stmt (bsi))) != NULL)
5428 if (!e->inline_failed)
5429 e->callee->remove_symbol_and_inline_clones (id->dst_node);
5430 else
5431 e->remove ();
5434 if (node->clones)
5435 node = node->clones;
5436 else if (node->next_sibling_clone)
5437 node = node->next_sibling_clone;
5438 else
5440 while (node != id->dst_node && !node->next_sibling_clone)
5441 node = node->clone_of;
5442 if (node != id->dst_node)
5443 node = node->next_sibling_clone;
5447 delete_basic_block (b);
5448 changed = true;
5452 return changed;
5455 /* Update clone info after duplication. */
5457 static void
5458 update_clone_info (copy_body_data * id)
5460 struct cgraph_node *node;
5461 if (!id->dst_node->clones)
5462 return;
5463 for (node = id->dst_node->clones; node != id->dst_node;)
5465 /* First update replace maps to match the new body. */
5466 if (node->clone.tree_map)
5468 unsigned int i;
5469 for (i = 0; i < vec_safe_length (node->clone.tree_map); i++)
5471 struct ipa_replace_map *replace_info;
5472 replace_info = (*node->clone.tree_map)[i];
5473 walk_tree (&replace_info->old_tree, copy_tree_body_r, id, NULL);
5474 walk_tree (&replace_info->new_tree, copy_tree_body_r, id, NULL);
5477 if (node->clones)
5478 node = node->clones;
5479 else if (node->next_sibling_clone)
5480 node = node->next_sibling_clone;
5481 else
5483 while (node != id->dst_node && !node->next_sibling_clone)
5484 node = node->clone_of;
5485 if (node != id->dst_node)
5486 node = node->next_sibling_clone;
5491 /* Create a copy of a function's tree.
5492 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5493 of the original function and the new copied function
5494 respectively. In case we want to replace a DECL
5495 tree with another tree while duplicating the function's
5496 body, TREE_MAP represents the mapping between these
5497 trees. If UPDATE_CLONES is set, the call_stmt fields
5498 of edges of clones of the function will be updated.
5500 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5501 from new version.
5502 If SKIP_RETURN is true, the new version will return void.
5503 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5504 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5506 void
5507 tree_function_versioning (tree old_decl, tree new_decl,
5508 vec<ipa_replace_map *, va_gc> *tree_map,
5509 bool update_clones, bitmap args_to_skip,
5510 bool skip_return, bitmap blocks_to_copy,
5511 basic_block new_entry)
5513 struct cgraph_node *old_version_node;
5514 struct cgraph_node *new_version_node;
5515 copy_body_data id;
5516 tree p;
5517 unsigned i;
5518 struct ipa_replace_map *replace_info;
5519 basic_block old_entry_block, bb;
5520 auto_vec<gimple, 10> init_stmts;
5521 tree vars = NULL_TREE;
5523 gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
5524 && TREE_CODE (new_decl) == FUNCTION_DECL);
5525 DECL_POSSIBLY_INLINED (old_decl) = 1;
5527 old_version_node = cgraph_node::get (old_decl);
5528 gcc_checking_assert (old_version_node);
5529 new_version_node = cgraph_node::get (new_decl);
5530 gcc_checking_assert (new_version_node);
5532 /* Copy over debug args. */
5533 if (DECL_HAS_DEBUG_ARGS_P (old_decl))
5535 vec<tree, va_gc> **new_debug_args, **old_debug_args;
5536 gcc_checking_assert (decl_debug_args_lookup (new_decl) == NULL);
5537 DECL_HAS_DEBUG_ARGS_P (new_decl) = 0;
5538 old_debug_args = decl_debug_args_lookup (old_decl);
5539 if (old_debug_args)
5541 new_debug_args = decl_debug_args_insert (new_decl);
5542 *new_debug_args = vec_safe_copy (*old_debug_args);
5546 /* Output the inlining info for this abstract function, since it has been
5547 inlined. If we don't do this now, we can lose the information about the
5548 variables in the function when the blocks get blown away as soon as we
5549 remove the cgraph node. */
5550 (*debug_hooks->outlining_inline_function) (old_decl);
5552 DECL_ARTIFICIAL (new_decl) = 1;
5553 DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
5554 if (DECL_ORIGIN (old_decl) == old_decl)
5555 old_version_node->used_as_abstract_origin = true;
5556 DECL_FUNCTION_PERSONALITY (new_decl) = DECL_FUNCTION_PERSONALITY (old_decl);
5558 /* Prepare the data structures for the tree copy. */
5559 memset (&id, 0, sizeof (id));
5561 /* Generate a new name for the new version. */
5562 id.statements_to_fold = new hash_set<gimple>;
5564 id.decl_map = new hash_map<tree, tree>;
5565 id.debug_map = NULL;
5566 id.src_fn = old_decl;
5567 id.dst_fn = new_decl;
5568 id.src_node = old_version_node;
5569 id.dst_node = new_version_node;
5570 id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
5571 id.blocks_to_copy = blocks_to_copy;
5573 id.copy_decl = copy_decl_no_change;
5574 id.transform_call_graph_edges
5575 = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
5576 id.transform_new_cfg = true;
5577 id.transform_return_to_modify = false;
5578 id.transform_parameter = false;
5579 id.transform_lang_insert_block = NULL;
5581 old_entry_block = ENTRY_BLOCK_PTR_FOR_FN
5582 (DECL_STRUCT_FUNCTION (old_decl));
5583 DECL_RESULT (new_decl) = DECL_RESULT (old_decl);
5584 DECL_ARGUMENTS (new_decl) = DECL_ARGUMENTS (old_decl);
5585 initialize_cfun (new_decl, old_decl,
5586 old_entry_block->count);
5587 if (DECL_STRUCT_FUNCTION (new_decl)->gimple_df)
5588 DECL_STRUCT_FUNCTION (new_decl)->gimple_df->ipa_pta
5589 = id.src_cfun->gimple_df->ipa_pta;
5591 /* Copy the function's static chain. */
5592 p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
5593 if (p)
5594 DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
5595 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
5596 &id);
5598 /* If there's a tree_map, prepare for substitution. */
5599 if (tree_map)
5600 for (i = 0; i < tree_map->length (); i++)
5602 gimple init;
5603 replace_info = (*tree_map)[i];
5604 if (replace_info->replace_p)
5606 if (!replace_info->old_tree)
5608 int i = replace_info->parm_num;
5609 tree parm;
5610 tree req_type;
5612 for (parm = DECL_ARGUMENTS (old_decl); i; parm = DECL_CHAIN (parm))
5613 i --;
5614 replace_info->old_tree = parm;
5615 req_type = TREE_TYPE (parm);
5616 if (!useless_type_conversion_p (req_type, TREE_TYPE (replace_info->new_tree)))
5618 if (fold_convertible_p (req_type, replace_info->new_tree))
5619 replace_info->new_tree = fold_build1 (NOP_EXPR, req_type, replace_info->new_tree);
5620 else if (TYPE_SIZE (req_type) == TYPE_SIZE (TREE_TYPE (replace_info->new_tree)))
5621 replace_info->new_tree = fold_build1 (VIEW_CONVERT_EXPR, req_type, replace_info->new_tree);
5622 else
5624 if (dump_file)
5626 fprintf (dump_file, " const ");
5627 print_generic_expr (dump_file, replace_info->new_tree, 0);
5628 fprintf (dump_file, " can't be converted to param ");
5629 print_generic_expr (dump_file, parm, 0);
5630 fprintf (dump_file, "\n");
5632 replace_info->old_tree = NULL;
5636 else
5637 gcc_assert (TREE_CODE (replace_info->old_tree) == PARM_DECL);
5638 if (replace_info->old_tree)
5640 init = setup_one_parameter (&id, replace_info->old_tree,
5641 replace_info->new_tree, id.src_fn,
5642 NULL,
5643 &vars);
5644 if (init)
5645 init_stmts.safe_push (init);
5649 /* Copy the function's arguments. */
5650 if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
5651 DECL_ARGUMENTS (new_decl) =
5652 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id,
5653 args_to_skip, &vars);
5655 DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
5656 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl)) = new_decl;
5658 declare_inline_vars (DECL_INITIAL (new_decl), vars);
5660 if (!vec_safe_is_empty (DECL_STRUCT_FUNCTION (old_decl)->local_decls))
5661 /* Add local vars. */
5662 add_local_variables (DECL_STRUCT_FUNCTION (old_decl), cfun, &id);
5664 if (DECL_RESULT (old_decl) == NULL_TREE)
5666 else if (skip_return && !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl))))
5668 DECL_RESULT (new_decl)
5669 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl)),
5670 RESULT_DECL, NULL_TREE, void_type_node);
5671 DECL_CONTEXT (DECL_RESULT (new_decl)) = new_decl;
5672 cfun->returns_struct = 0;
5673 cfun->returns_pcc_struct = 0;
5675 else
5677 tree old_name;
5678 DECL_RESULT (new_decl) = remap_decl (DECL_RESULT (old_decl), &id);
5679 lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
5680 if (gimple_in_ssa_p (id.src_cfun)
5681 && DECL_BY_REFERENCE (DECL_RESULT (old_decl))
5682 && (old_name = ssa_default_def (id.src_cfun, DECL_RESULT (old_decl))))
5684 tree new_name = make_ssa_name (DECL_RESULT (new_decl), NULL);
5685 insert_decl_map (&id, old_name, new_name);
5686 SSA_NAME_DEF_STMT (new_name) = gimple_build_nop ();
5687 set_ssa_default_def (cfun, DECL_RESULT (new_decl), new_name);
5691 /* Set up the destination functions loop tree. */
5692 if (loops_for_fn (DECL_STRUCT_FUNCTION (old_decl)) != NULL)
5694 cfun->curr_properties &= ~PROP_loops;
5695 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
5696 cfun->curr_properties |= PROP_loops;
5699 /* Copy the Function's body. */
5700 copy_body (&id, old_entry_block->count, REG_BR_PROB_BASE,
5701 ENTRY_BLOCK_PTR_FOR_FN (cfun), EXIT_BLOCK_PTR_FOR_FN (cfun),
5702 new_entry);
5704 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5705 number_blocks (new_decl);
5707 /* We want to create the BB unconditionally, so that the addition of
5708 debug stmts doesn't affect BB count, which may in the end cause
5709 codegen differences. */
5710 bb = split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
5711 while (init_stmts.length ())
5712 insert_init_stmt (&id, bb, init_stmts.pop ());
5713 update_clone_info (&id);
5715 /* Remap the nonlocal_goto_save_area, if any. */
5716 if (cfun->nonlocal_goto_save_area)
5718 struct walk_stmt_info wi;
5720 memset (&wi, 0, sizeof (wi));
5721 wi.info = &id;
5722 walk_tree (&cfun->nonlocal_goto_save_area, remap_gimple_op_r, &wi, NULL);
5725 /* Clean up. */
5726 delete id.decl_map;
5727 if (id.debug_map)
5728 delete id.debug_map;
5729 free_dominance_info (CDI_DOMINATORS);
5730 free_dominance_info (CDI_POST_DOMINATORS);
5732 fold_marked_statements (0, id.statements_to_fold);
5733 delete id.statements_to_fold;
5734 fold_cond_expr_cond ();
5735 delete_unreachable_blocks_update_callgraph (&id);
5736 if (id.dst_node->definition)
5737 cgraph_edge::rebuild_references ();
5738 if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
5740 calculate_dominance_info (CDI_DOMINATORS);
5741 fix_loop_structure (NULL);
5743 update_ssa (TODO_update_ssa);
5745 /* After partial cloning we need to rescale frequencies, so they are
5746 within proper range in the cloned function. */
5747 if (new_entry)
5749 struct cgraph_edge *e;
5750 rebuild_frequencies ();
5752 new_version_node->count = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
5753 for (e = new_version_node->callees; e; e = e->next_callee)
5755 basic_block bb = gimple_bb (e->call_stmt);
5756 e->frequency = compute_call_stmt_bb_frequency (current_function_decl,
5757 bb);
5758 e->count = bb->count;
5760 for (e = new_version_node->indirect_calls; e; e = e->next_callee)
5762 basic_block bb = gimple_bb (e->call_stmt);
5763 e->frequency = compute_call_stmt_bb_frequency (current_function_decl,
5764 bb);
5765 e->count = bb->count;
5769 free_dominance_info (CDI_DOMINATORS);
5770 free_dominance_info (CDI_POST_DOMINATORS);
5772 gcc_assert (!id.debug_stmts.exists ());
5773 pop_cfun ();
5774 return;
5777 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5778 the callee and return the inlined body on success. */
5780 tree
5781 maybe_inline_call_in_expr (tree exp)
5783 tree fn = get_callee_fndecl (exp);
5785 /* We can only try to inline "const" functions. */
5786 if (fn && TREE_READONLY (fn) && DECL_SAVED_TREE (fn))
5788 call_expr_arg_iterator iter;
5789 copy_body_data id;
5790 tree param, arg, t;
5791 hash_map<tree, tree> decl_map;
5793 /* Remap the parameters. */
5794 for (param = DECL_ARGUMENTS (fn), arg = first_call_expr_arg (exp, &iter);
5795 param;
5796 param = DECL_CHAIN (param), arg = next_call_expr_arg (&iter))
5797 decl_map.put (param, arg);
5799 memset (&id, 0, sizeof (id));
5800 id.src_fn = fn;
5801 id.dst_fn = current_function_decl;
5802 id.src_cfun = DECL_STRUCT_FUNCTION (fn);
5803 id.decl_map = &decl_map;
5805 id.copy_decl = copy_decl_no_change;
5806 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
5807 id.transform_new_cfg = false;
5808 id.transform_return_to_modify = true;
5809 id.transform_parameter = true;
5810 id.transform_lang_insert_block = NULL;
5812 /* Make sure not to unshare trees behind the front-end's back
5813 since front-end specific mechanisms may rely on sharing. */
5814 id.regimplify = false;
5815 id.do_not_unshare = true;
5817 /* We're not inside any EH region. */
5818 id.eh_lp_nr = 0;
5820 t = copy_tree_body (&id);
5822 /* We can only return something suitable for use in a GENERIC
5823 expression tree. */
5824 if (TREE_CODE (t) == MODIFY_EXPR)
5825 return TREE_OPERAND (t, 1);
5828 return NULL_TREE;
5831 /* Duplicate a type, fields and all. */
5833 tree
5834 build_duplicate_type (tree type)
5836 struct copy_body_data id;
5838 memset (&id, 0, sizeof (id));
5839 id.src_fn = current_function_decl;
5840 id.dst_fn = current_function_decl;
5841 id.src_cfun = cfun;
5842 id.decl_map = new hash_map<tree, tree>;
5843 id.debug_map = NULL;
5844 id.copy_decl = copy_decl_no_change;
5846 type = remap_type_1 (type, &id);
5848 delete id.decl_map;
5849 if (id.debug_map)
5850 delete id.debug_map;
5852 TYPE_CANONICAL (type) = type;
5854 return type;
5857 /* Unshare the entire DECL_SAVED_TREE of FN and return the remapped
5858 parameters and RESULT_DECL in PARMS and RESULT. Used by C++ constexpr
5859 evaluation. */
5861 tree
5862 copy_fn (tree fn, tree& parms, tree& result)
5864 copy_body_data id;
5865 tree param;
5866 hash_map<tree, tree> decl_map;
5868 tree *p = &parms;
5869 *p = NULL_TREE;
5871 memset (&id, 0, sizeof (id));
5872 id.src_fn = fn;
5873 id.dst_fn = current_function_decl;
5874 id.src_cfun = DECL_STRUCT_FUNCTION (fn);
5875 id.decl_map = &decl_map;
5877 id.copy_decl = copy_decl_no_change;
5878 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
5879 id.transform_new_cfg = false;
5880 id.transform_return_to_modify = false;
5881 id.transform_parameter = true;
5882 id.transform_lang_insert_block = NULL;
5884 /* Make sure not to unshare trees behind the front-end's back
5885 since front-end specific mechanisms may rely on sharing. */
5886 id.regimplify = false;
5887 id.do_not_unshare = true;
5889 /* We're not inside any EH region. */
5890 id.eh_lp_nr = 0;
5892 /* Remap the parameters and result and return them to the caller. */
5893 for (param = DECL_ARGUMENTS (fn);
5894 param;
5895 param = DECL_CHAIN (param))
5897 *p = remap_decl (param, &id);
5898 p = &DECL_CHAIN (*p);
5901 if (DECL_RESULT (fn))
5902 result = remap_decl (DECL_RESULT (fn), &id);
5903 else
5904 result = NULL_TREE;
5906 return copy_tree_body (&id);