2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
3 2012 Free Software Foundation, Inc.
4 Contributed by Alexandre Oliva <aoliva@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
26 #include "diagnostic-core.h"
28 #include "tree-inline.h"
32 #include "insn-config.h"
34 #include "langhooks.h"
35 #include "basic-block.h"
36 #include "tree-iterator.h"
39 #include "tree-mudflap.h"
40 #include "tree-flow.h"
42 #include "tree-flow.h"
43 #include "tree-pretty-print.h"
46 #include "pointer-set.h"
48 #include "value-prof.h"
49 #include "tree-pass.h"
51 #include "integrate.h"
53 #include "rtl.h" /* FIXME: For asm_str_count. */
55 /* I'm not real happy about this, but we need to handle gimple and
59 /* Inlining, Cloning, Versioning, Parallelization
61 Inlining: a function body is duplicated, but the PARM_DECLs are
62 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
63 MODIFY_EXPRs that store to a dedicated returned-value variable.
64 The duplicated eh_region info of the copy will later be appended
65 to the info for the caller; the eh_region info in copied throwing
66 statements and RESX statements are adjusted accordingly.
68 Cloning: (only in C++) We have one body for a con/de/structor, and
69 multiple function decls, each with a unique parameter list.
70 Duplicate the body, using the given splay tree; some parameters
71 will become constants (like 0 or 1).
73 Versioning: a function body is duplicated and the result is a new
74 function rather than into blocks of an existing function as with
75 inlining. Some parameters will become constants.
77 Parallelization: a region of a function is duplicated resulting in
78 a new function. Variables may be replaced with complex expressions
79 to enable shared variable semantics.
81 All of these will simultaneously lookup any callgraph edges. If
82 we're going to inline the duplicated function body, and the given
83 function has some cloned callgraph nodes (one for each place this
84 function will be inlined) those callgraph edges will be duplicated.
85 If we're cloning the body, those callgraph edges will be
86 updated to point into the new body. (Note that the original
87 callgraph node and edge list will not be altered.)
89 See the CALL_EXPR handling case in copy_tree_body_r (). */
93 o In order to make inlining-on-trees work, we pessimized
94 function-local static constants. In particular, they are now
95 always output, even when not addressed. Fix this by treating
96 function-local static constants just like global static
97 constants; the back-end already knows not to output them if they
100 o Provide heuristics to clamp inlining of recursive template
104 /* Weights that estimate_num_insns uses to estimate the size of the
107 eni_weights eni_size_weights;
109 /* Weights that estimate_num_insns uses to estimate the time necessary
110 to execute the produced code. */
112 eni_weights eni_time_weights;
116 static tree declare_return_variable (copy_body_data *, tree, tree, basic_block);
117 static void remap_block (tree *, copy_body_data *);
118 static void copy_bind_expr (tree *, int *, copy_body_data *);
119 static tree mark_local_for_remap_r (tree *, int *, void *);
120 static void unsave_expr_1 (tree);
121 static tree unsave_r (tree *, int *, void *);
122 static void declare_inline_vars (tree, tree);
123 static void remap_save_expr (tree *, void *, int *);
124 static void prepend_lexical_block (tree current_block, tree new_block);
125 static tree copy_decl_to_var (tree, copy_body_data *);
126 static tree copy_result_decl_to_var (tree, copy_body_data *);
127 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
128 static gimple remap_gimple_stmt (gimple, copy_body_data *);
129 static bool delete_unreachable_blocks_update_callgraph (copy_body_data *id);
131 /* Insert a tree->tree mapping for ID. Despite the name suggests
132 that the trees should be variables, it is used for more than that. */
135 insert_decl_map (copy_body_data *id, tree key, tree value)
137 *pointer_map_insert (id->decl_map, key) = value;
139 /* Always insert an identity map as well. If we see this same new
140 node again, we won't want to duplicate it a second time. */
142 *pointer_map_insert (id->decl_map, value) = value;
145 /* Insert a tree->tree mapping for ID. This is only used for
149 insert_debug_decl_map (copy_body_data *id, tree key, tree value)
151 if (!gimple_in_ssa_p (id->src_cfun))
154 if (!MAY_HAVE_DEBUG_STMTS)
157 if (!target_for_debug_bind (key))
160 gcc_assert (TREE_CODE (key) == PARM_DECL);
161 gcc_assert (TREE_CODE (value) == VAR_DECL);
164 id->debug_map = pointer_map_create ();
166 *pointer_map_insert (id->debug_map, key) = value;
169 /* If nonzero, we're remapping the contents of inlined debug
170 statements. If negative, an error has occurred, such as a
171 reference to a variable that isn't available in the inlined
173 static int processing_debug_stmt = 0;
175 /* Construct new SSA name for old NAME. ID is the inline context. */
178 remap_ssa_name (tree name, copy_body_data *id)
183 gcc_assert (TREE_CODE (name) == SSA_NAME);
185 n = (tree *) pointer_map_contains (id->decl_map, name);
187 return unshare_expr (*n);
189 if (processing_debug_stmt)
191 if (TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL
192 && SSA_NAME_IS_DEFAULT_DEF (name)
193 && id->entry_bb == NULL
194 && single_succ_p (ENTRY_BLOCK_PTR))
196 tree vexpr = make_node (DEBUG_EXPR_DECL);
198 gimple_stmt_iterator gsi;
199 tree val = SSA_NAME_VAR (name);
201 n = (tree *) pointer_map_contains (id->decl_map, val);
204 if (TREE_CODE (val) != PARM_DECL)
206 processing_debug_stmt = -1;
209 def_temp = gimple_build_debug_source_bind (vexpr, val, NULL);
210 DECL_ARTIFICIAL (vexpr) = 1;
211 TREE_TYPE (vexpr) = TREE_TYPE (name);
212 DECL_MODE (vexpr) = DECL_MODE (SSA_NAME_VAR (name));
213 gsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR));
214 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
218 processing_debug_stmt = -1;
222 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
224 new_tree = remap_decl (SSA_NAME_VAR (name), id);
226 /* We might've substituted constant or another SSA_NAME for
229 Replace the SSA name representing RESULT_DECL by variable during
230 inlining: this saves us from need to introduce PHI node in a case
231 return value is just partly initialized. */
232 if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL)
233 && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
234 || !id->transform_return_to_modify))
236 struct ptr_info_def *pi;
237 new_tree = make_ssa_name (new_tree, NULL);
238 insert_decl_map (id, name, new_tree);
239 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
240 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
241 TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree));
242 /* At least IPA points-to info can be directly transferred. */
243 if (id->src_cfun->gimple_df
244 && id->src_cfun->gimple_df->ipa_pta
245 && (pi = SSA_NAME_PTR_INFO (name))
248 struct ptr_info_def *new_pi = get_ptr_info (new_tree);
251 if (gimple_nop_p (SSA_NAME_DEF_STMT (name)))
253 /* By inlining function having uninitialized variable, we might
254 extend the lifetime (variable might get reused). This cause
255 ICE in the case we end up extending lifetime of SSA name across
256 abnormal edge, but also increase register pressure.
258 We simply initialize all uninitialized vars by 0 except
259 for case we are inlining to very first BB. We can avoid
260 this for all BBs that are not inside strongly connected
261 regions of the CFG, but this is expensive to test. */
263 && is_gimple_reg (SSA_NAME_VAR (name))
264 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name)
265 && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL
266 && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest
267 || EDGE_COUNT (id->entry_bb->preds) != 1))
269 gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
271 tree zero = build_zero_cst (TREE_TYPE (new_tree));
273 init_stmt = gimple_build_assign (new_tree, zero);
274 gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT);
275 SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0;
279 SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop ();
280 if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name))
282 set_default_def (SSA_NAME_VAR (new_tree), new_tree);
287 insert_decl_map (id, name, new_tree);
291 /* Remap DECL during the copying of the BLOCK tree for the function. */
294 remap_decl (tree decl, copy_body_data *id)
298 /* We only remap local variables in the current function. */
300 /* See if we have remapped this declaration. */
302 n = (tree *) pointer_map_contains (id->decl_map, decl);
304 if (!n && processing_debug_stmt)
306 processing_debug_stmt = -1;
310 /* If we didn't already have an equivalent for this declaration,
314 /* Make a copy of the variable or label. */
315 tree t = id->copy_decl (decl, id);
317 /* Remember it, so that if we encounter this local entity again
318 we can reuse this copy. Do this early because remap_type may
319 need this decl for TYPE_STUB_DECL. */
320 insert_decl_map (id, decl, t);
325 /* Remap types, if necessary. */
326 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
327 if (TREE_CODE (t) == TYPE_DECL)
328 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
330 /* Remap sizes as necessary. */
331 walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL);
332 walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL);
334 /* If fields, do likewise for offset and qualifier. */
335 if (TREE_CODE (t) == FIELD_DECL)
337 walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL);
338 if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
339 walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL);
342 if ((TREE_CODE (t) == VAR_DECL
343 || TREE_CODE (t) == RESULT_DECL
344 || TREE_CODE (t) == PARM_DECL)
345 && id->src_fn && DECL_STRUCT_FUNCTION (id->src_fn)
346 && gimple_referenced_vars (DECL_STRUCT_FUNCTION (id->src_fn))
347 /* We don't want to mark as referenced VAR_DECLs that were
348 not marked as such in the src function. */
349 && (TREE_CODE (decl) != VAR_DECL
350 || referenced_var_lookup (DECL_STRUCT_FUNCTION (id->src_fn),
352 add_referenced_var (t);
356 if (id->do_not_unshare)
359 return unshare_expr (*n);
363 remap_type_1 (tree type, copy_body_data *id)
367 /* We do need a copy. build and register it now. If this is a pointer or
368 reference type, remap the designated type and make a new pointer or
370 if (TREE_CODE (type) == POINTER_TYPE)
372 new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
374 TYPE_REF_CAN_ALIAS_ALL (type));
375 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
376 new_tree = build_type_attribute_qual_variant (new_tree,
377 TYPE_ATTRIBUTES (type),
379 insert_decl_map (id, type, new_tree);
382 else if (TREE_CODE (type) == REFERENCE_TYPE)
384 new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
386 TYPE_REF_CAN_ALIAS_ALL (type));
387 if (TYPE_ATTRIBUTES (type) || TYPE_QUALS (type))
388 new_tree = build_type_attribute_qual_variant (new_tree,
389 TYPE_ATTRIBUTES (type),
391 insert_decl_map (id, type, new_tree);
395 new_tree = copy_node (type);
397 insert_decl_map (id, type, new_tree);
399 /* This is a new type, not a copy of an old type. Need to reassociate
400 variants. We can handle everything except the main variant lazily. */
401 t = TYPE_MAIN_VARIANT (type);
404 t = remap_type (t, id);
405 TYPE_MAIN_VARIANT (new_tree) = t;
406 TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t);
407 TYPE_NEXT_VARIANT (t) = new_tree;
411 TYPE_MAIN_VARIANT (new_tree) = new_tree;
412 TYPE_NEXT_VARIANT (new_tree) = NULL;
415 if (TYPE_STUB_DECL (type))
416 TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id);
418 /* Lazily create pointer and reference types. */
419 TYPE_POINTER_TO (new_tree) = NULL;
420 TYPE_REFERENCE_TO (new_tree) = NULL;
422 switch (TREE_CODE (new_tree))
426 case FIXED_POINT_TYPE:
429 t = TYPE_MIN_VALUE (new_tree);
430 if (t && TREE_CODE (t) != INTEGER_CST)
431 walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL);
433 t = TYPE_MAX_VALUE (new_tree);
434 if (t && TREE_CODE (t) != INTEGER_CST)
435 walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL);
439 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
440 walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL);
444 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
445 TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id);
450 case QUAL_UNION_TYPE:
454 for (f = TYPE_FIELDS (new_tree); f ; f = DECL_CHAIN (f))
456 t = remap_decl (f, id);
457 DECL_CONTEXT (t) = new_tree;
461 TYPE_FIELDS (new_tree) = nreverse (nf);
467 /* Shouldn't have been thought variable sized. */
471 walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL);
472 walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL);
478 remap_type (tree type, copy_body_data *id)
486 /* See if we have remapped this type. */
487 node = (tree *) pointer_map_contains (id->decl_map, type);
491 /* The type only needs remapping if it's variably modified. */
492 if (! variably_modified_type_p (type, id->src_fn))
494 insert_decl_map (id, type, type);
498 id->remapping_type_depth++;
499 tmp = remap_type_1 (type, id);
500 id->remapping_type_depth--;
505 /* Return previously remapped type of TYPE in ID. Return NULL if TYPE
506 is NULL or TYPE has not been remapped before. */
509 remapped_type (tree type, copy_body_data *id)
516 /* See if we have remapped this type. */
517 node = (tree *) pointer_map_contains (id->decl_map, type);
524 /* The type only needs remapping if it's variably modified. */
525 /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
528 can_be_nonlocal (tree decl, copy_body_data *id)
530 /* We can not duplicate function decls. */
531 if (TREE_CODE (decl) == FUNCTION_DECL)
534 /* Local static vars must be non-local or we get multiple declaration
536 if (TREE_CODE (decl) == VAR_DECL
537 && !auto_var_in_fn_p (decl, id->src_fn))
540 /* At the moment dwarf2out can handle only these types of nodes. We
541 can support more later. */
542 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
545 /* We must use global type. We call remapped_type instead of
546 remap_type since we don't want to remap this type here if it
547 hasn't been remapped before. */
548 if (TREE_TYPE (decl) != remapped_type (TREE_TYPE (decl), id))
551 /* Wihtout SSA we can't tell if variable is used. */
552 if (!gimple_in_ssa_p (cfun))
555 /* Live variables must be copied so we can attach DECL_RTL. */
563 remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id)
566 tree new_decls = NULL_TREE;
568 /* Remap its variables. */
569 for (old_var = decls; old_var; old_var = DECL_CHAIN (old_var))
573 if (can_be_nonlocal (old_var, id))
575 if (TREE_CODE (old_var) == VAR_DECL
576 && ! DECL_EXTERNAL (old_var)
577 && (var_ann (old_var) || !gimple_in_ssa_p (cfun)))
578 add_local_decl (cfun, old_var);
579 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
580 && !DECL_IGNORED_P (old_var)
581 && nonlocalized_list)
582 VEC_safe_push (tree, gc, *nonlocalized_list, old_var);
586 /* Remap the variable. */
587 new_var = remap_decl (old_var, id);
589 /* If we didn't remap this variable, we can't mess with its
590 TREE_CHAIN. If we remapped this variable to the return slot, it's
591 already declared somewhere else, so don't declare it here. */
593 if (new_var == id->retvar)
597 if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE)
598 && !DECL_IGNORED_P (old_var)
599 && nonlocalized_list)
600 VEC_safe_push (tree, gc, *nonlocalized_list, old_var);
604 gcc_assert (DECL_P (new_var));
605 DECL_CHAIN (new_var) = new_decls;
608 /* Also copy value-expressions. */
609 if (TREE_CODE (new_var) == VAR_DECL
610 && DECL_HAS_VALUE_EXPR_P (new_var))
612 tree tem = DECL_VALUE_EXPR (new_var);
613 bool old_regimplify = id->regimplify;
614 id->remapping_type_depth++;
615 walk_tree (&tem, copy_tree_body_r, id, NULL);
616 id->remapping_type_depth--;
617 id->regimplify = old_regimplify;
618 SET_DECL_VALUE_EXPR (new_var, tem);
623 return nreverse (new_decls);
626 /* Copy the BLOCK to contain remapped versions of the variables
627 therein. And hook the new block into the block-tree. */
630 remap_block (tree *block, copy_body_data *id)
635 /* Make the new block. */
637 new_block = make_node (BLOCK);
638 TREE_USED (new_block) = TREE_USED (old_block);
639 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
640 BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
641 BLOCK_NONLOCALIZED_VARS (new_block)
642 = VEC_copy (tree, gc, BLOCK_NONLOCALIZED_VARS (old_block));
645 /* Remap its variables. */
646 BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block),
647 &BLOCK_NONLOCALIZED_VARS (new_block),
650 if (id->transform_lang_insert_block)
651 id->transform_lang_insert_block (new_block);
653 /* Remember the remapped block. */
654 insert_decl_map (id, old_block, new_block);
657 /* Copy the whole block tree and root it in id->block. */
659 remap_blocks (tree block, copy_body_data *id)
662 tree new_tree = block;
667 remap_block (&new_tree, id);
668 gcc_assert (new_tree != block);
669 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
670 prepend_lexical_block (new_tree, remap_blocks (t, id));
671 /* Blocks are in arbitrary order, but make things slightly prettier and do
672 not swap order when producing a copy. */
673 BLOCK_SUBBLOCKS (new_tree) = blocks_nreverse (BLOCK_SUBBLOCKS (new_tree));
678 copy_statement_list (tree *tp)
680 tree_stmt_iterator oi, ni;
683 new_tree = alloc_stmt_list ();
684 ni = tsi_start (new_tree);
685 oi = tsi_start (*tp);
686 TREE_TYPE (new_tree) = TREE_TYPE (*tp);
689 for (; !tsi_end_p (oi); tsi_next (&oi))
691 tree stmt = tsi_stmt (oi);
692 if (TREE_CODE (stmt) == STATEMENT_LIST)
693 /* This copy is not redundant; tsi_link_after will smash this
694 STATEMENT_LIST into the end of the one we're building, and we
695 don't want to do that with the original. */
696 copy_statement_list (&stmt);
697 tsi_link_after (&ni, stmt, TSI_CONTINUE_LINKING);
702 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
704 tree block = BIND_EXPR_BLOCK (*tp);
705 /* Copy (and replace) the statement. */
706 copy_tree_r (tp, walk_subtrees, NULL);
709 remap_block (&block, id);
710 BIND_EXPR_BLOCK (*tp) = block;
713 if (BIND_EXPR_VARS (*tp))
714 /* This will remap a lot of the same decls again, but this should be
716 BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
720 /* Create a new gimple_seq by remapping all the statements in BODY
721 using the inlining information in ID. */
724 remap_gimple_seq (gimple_seq body, copy_body_data *id)
726 gimple_stmt_iterator si;
727 gimple_seq new_body = NULL;
729 for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si))
731 gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id);
732 gimple_seq_add_stmt (&new_body, new_stmt);
739 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
740 block using the mapping information in ID. */
743 copy_gimple_bind (gimple stmt, copy_body_data *id)
746 tree new_block, new_vars;
747 gimple_seq body, new_body;
749 /* Copy the statement. Note that we purposely don't use copy_stmt
750 here because we need to remap statements as we copy. */
751 body = gimple_bind_body (stmt);
752 new_body = remap_gimple_seq (body, id);
754 new_block = gimple_bind_block (stmt);
756 remap_block (&new_block, id);
758 /* This will remap a lot of the same decls again, but this should be
760 new_vars = gimple_bind_vars (stmt);
762 new_vars = remap_decls (new_vars, NULL, id);
764 new_bind = gimple_build_bind (new_vars, new_body, new_block);
770 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
771 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
772 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
773 recursing into the children nodes of *TP. */
776 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
778 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
779 copy_body_data *id = (copy_body_data *) wi_p->info;
780 tree fn = id->src_fn;
782 if (TREE_CODE (*tp) == SSA_NAME)
784 *tp = remap_ssa_name (*tp, id);
788 else if (auto_var_in_fn_p (*tp, fn))
790 /* Local variables and labels need to be replaced by equivalent
791 variables. We don't want to copy static variables; there's
792 only one of those, no matter how many times we inline the
793 containing function. Similarly for globals from an outer
797 /* Remap the declaration. */
798 new_decl = remap_decl (*tp, id);
799 gcc_assert (new_decl);
800 /* Replace this variable with the copy. */
801 STRIP_TYPE_NOPS (new_decl);
802 /* ??? The C++ frontend uses void * pointer zero to initialize
803 any other type. This confuses the middle-end type verification.
804 As cloned bodies do not go through gimplification again the fixup
805 there doesn't trigger. */
806 if (TREE_CODE (new_decl) == INTEGER_CST
807 && !useless_type_conversion_p (TREE_TYPE (*tp), TREE_TYPE (new_decl)))
808 new_decl = fold_convert (TREE_TYPE (*tp), new_decl);
812 else if (TREE_CODE (*tp) == STATEMENT_LIST)
814 else if (TREE_CODE (*tp) == SAVE_EXPR)
816 else if (TREE_CODE (*tp) == LABEL_DECL
817 && (!DECL_CONTEXT (*tp)
818 || decl_function_context (*tp) == id->src_fn))
819 /* These may need to be remapped for EH handling. */
820 *tp = remap_decl (*tp, id);
821 else if (TREE_CODE (*tp) == FIELD_DECL)
823 /* If the enclosing record type is variably_modified_type_p, the field
824 has already been remapped. Otherwise, it need not be. */
825 tree *n = (tree *) pointer_map_contains (id->decl_map, *tp);
830 else if (TYPE_P (*tp))
831 /* Types may need remapping as well. */
832 *tp = remap_type (*tp, id);
833 else if (CONSTANT_CLASS_P (*tp))
835 /* If this is a constant, we have to copy the node iff the type
836 will be remapped. copy_tree_r will not copy a constant. */
837 tree new_type = remap_type (TREE_TYPE (*tp), id);
839 if (new_type == TREE_TYPE (*tp))
842 else if (TREE_CODE (*tp) == INTEGER_CST)
843 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
844 TREE_INT_CST_HIGH (*tp));
847 *tp = copy_node (*tp);
848 TREE_TYPE (*tp) = new_type;
853 /* Otherwise, just copy the node. Note that copy_tree_r already
854 knows not to copy VAR_DECLs, etc., so this is safe. */
856 /* We should never have TREE_BLOCK set on non-statements. */
858 gcc_assert (!TREE_BLOCK (*tp));
860 if (TREE_CODE (*tp) == MEM_REF)
862 tree ptr = TREE_OPERAND (*tp, 0);
863 tree type = remap_type (TREE_TYPE (*tp), id);
866 /* We need to re-canonicalize MEM_REFs from inline substitutions
867 that can happen when a pointer argument is an ADDR_EXPR.
868 Recurse here manually to allow that. */
869 walk_tree (&ptr, remap_gimple_op_r, data, NULL);
870 *tp = fold_build2 (MEM_REF, type,
871 ptr, TREE_OPERAND (*tp, 1));
872 TREE_THIS_NOTRAP (*tp) = TREE_THIS_NOTRAP (old);
873 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
874 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
879 /* Here is the "usual case". Copy this tree node, and then
880 tweak some special cases. */
881 copy_tree_r (tp, walk_subtrees, NULL);
883 if (TREE_CODE (*tp) != OMP_CLAUSE)
884 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
886 /* Global variables we haven't seen yet need to go into referenced
887 vars. If not referenced from types only. */
888 if (gimple_in_ssa_p (cfun)
889 && TREE_CODE (*tp) == VAR_DECL
890 && id->remapping_type_depth == 0
891 && !processing_debug_stmt)
892 add_referenced_var (*tp);
894 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
896 /* The copied TARGET_EXPR has never been expanded, even if the
897 original node was expanded already. */
898 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
899 TREE_OPERAND (*tp, 3) = NULL_TREE;
901 else if (TREE_CODE (*tp) == ADDR_EXPR)
903 /* Variable substitution need not be simple. In particular,
904 the MEM_REF substitution above. Make sure that
905 TREE_CONSTANT and friends are up-to-date. But make sure
906 to not improperly set TREE_BLOCK on some sub-expressions. */
907 int invariant = is_gimple_min_invariant (*tp);
908 tree block = id->block;
909 id->block = NULL_TREE;
910 walk_tree (&TREE_OPERAND (*tp, 0), remap_gimple_op_r, data, NULL);
912 recompute_tree_invariant_for_addr_expr (*tp);
914 /* If this used to be invariant, but is not any longer,
915 then regimplification is probably needed. */
916 if (invariant && !is_gimple_min_invariant (*tp))
917 id->regimplify = true;
923 /* Keep iterating. */
928 /* Called from copy_body_id via walk_tree. DATA is really a
929 `copy_body_data *'. */
932 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
934 copy_body_data *id = (copy_body_data *) data;
935 tree fn = id->src_fn;
938 /* Begin by recognizing trees that we'll completely rewrite for the
939 inlining context. Our output for these trees is completely
940 different from out input (e.g. RETURN_EXPR is deleted, and morphs
941 into an edge). Further down, we'll handle trees that get
942 duplicated and/or tweaked. */
944 /* When requested, RETURN_EXPRs should be transformed to just the
945 contained MODIFY_EXPR. The branch semantics of the return will
946 be handled elsewhere by manipulating the CFG rather than a statement. */
947 if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
949 tree assignment = TREE_OPERAND (*tp, 0);
951 /* If we're returning something, just turn that into an
952 assignment into the equivalent of the original RESULT_DECL.
953 If the "assignment" is just the result decl, the result
954 decl has already been set (e.g. a recent "foo (&result_decl,
955 ...)"); just toss the entire RETURN_EXPR. */
956 if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
958 /* Replace the RETURN_EXPR with (a copy of) the
959 MODIFY_EXPR hanging underneath. */
960 *tp = copy_node (assignment);
962 else /* Else the RETURN_EXPR returns no value. */
965 return (tree) (void *)1;
968 else if (TREE_CODE (*tp) == SSA_NAME)
970 *tp = remap_ssa_name (*tp, id);
975 /* Local variables and labels need to be replaced by equivalent
976 variables. We don't want to copy static variables; there's only
977 one of those, no matter how many times we inline the containing
978 function. Similarly for globals from an outer function. */
979 else if (auto_var_in_fn_p (*tp, fn))
983 /* Remap the declaration. */
984 new_decl = remap_decl (*tp, id);
985 gcc_assert (new_decl);
986 /* Replace this variable with the copy. */
987 STRIP_TYPE_NOPS (new_decl);
991 else if (TREE_CODE (*tp) == STATEMENT_LIST)
992 copy_statement_list (tp);
993 else if (TREE_CODE (*tp) == SAVE_EXPR
994 || TREE_CODE (*tp) == TARGET_EXPR)
995 remap_save_expr (tp, id->decl_map, walk_subtrees);
996 else if (TREE_CODE (*tp) == LABEL_DECL
997 && (! DECL_CONTEXT (*tp)
998 || decl_function_context (*tp) == id->src_fn))
999 /* These may need to be remapped for EH handling. */
1000 *tp = remap_decl (*tp, id);
1001 else if (TREE_CODE (*tp) == BIND_EXPR)
1002 copy_bind_expr (tp, walk_subtrees, id);
1003 /* Types may need remapping as well. */
1004 else if (TYPE_P (*tp))
1005 *tp = remap_type (*tp, id);
1007 /* If this is a constant, we have to copy the node iff the type will be
1008 remapped. copy_tree_r will not copy a constant. */
1009 else if (CONSTANT_CLASS_P (*tp))
1011 tree new_type = remap_type (TREE_TYPE (*tp), id);
1013 if (new_type == TREE_TYPE (*tp))
1016 else if (TREE_CODE (*tp) == INTEGER_CST)
1017 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
1018 TREE_INT_CST_HIGH (*tp));
1021 *tp = copy_node (*tp);
1022 TREE_TYPE (*tp) = new_type;
1026 /* Otherwise, just copy the node. Note that copy_tree_r already
1027 knows not to copy VAR_DECLs, etc., so this is safe. */
1030 /* Here we handle trees that are not completely rewritten.
1031 First we detect some inlining-induced bogosities for
1033 if (TREE_CODE (*tp) == MODIFY_EXPR
1034 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
1035 && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn)))
1037 /* Some assignments VAR = VAR; don't generate any rtl code
1038 and thus don't count as variable modification. Avoid
1039 keeping bogosities like 0 = 0. */
1040 tree decl = TREE_OPERAND (*tp, 0), value;
1043 n = (tree *) pointer_map_contains (id->decl_map, decl);
1047 STRIP_TYPE_NOPS (value);
1048 if (TREE_CONSTANT (value) || TREE_READONLY (value))
1050 *tp = build_empty_stmt (EXPR_LOCATION (*tp));
1051 return copy_tree_body_r (tp, walk_subtrees, data);
1055 else if (TREE_CODE (*tp) == INDIRECT_REF)
1057 /* Get rid of *& from inline substitutions that can happen when a
1058 pointer argument is an ADDR_EXPR. */
1059 tree decl = TREE_OPERAND (*tp, 0);
1062 n = (tree *) pointer_map_contains (id->decl_map, decl);
1067 /* If we happen to get an ADDR_EXPR in n->value, strip
1068 it manually here as we'll eventually get ADDR_EXPRs
1069 which lie about their types pointed to. In this case
1070 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
1071 but we absolutely rely on that. As fold_indirect_ref
1072 does other useful transformations, try that first, though. */
1073 tree type = TREE_TYPE (TREE_TYPE (*n));
1074 if (id->do_not_unshare)
1077 new_tree = unshare_expr (*n);
1079 *tp = gimple_fold_indirect_ref (new_tree);
1082 if (TREE_CODE (new_tree) == ADDR_EXPR)
1084 *tp = fold_indirect_ref_1 (EXPR_LOCATION (new_tree),
1086 /* ??? We should either assert here or build
1087 a VIEW_CONVERT_EXPR instead of blindly leaking
1088 incompatible types to our IL. */
1090 *tp = TREE_OPERAND (new_tree, 0);
1094 *tp = build1 (INDIRECT_REF, type, new_tree);
1095 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1096 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
1097 TREE_READONLY (*tp) = TREE_READONLY (old);
1098 TREE_THIS_NOTRAP (*tp) = TREE_THIS_NOTRAP (old);
1105 else if (TREE_CODE (*tp) == MEM_REF)
1107 /* We need to re-canonicalize MEM_REFs from inline substitutions
1108 that can happen when a pointer argument is an ADDR_EXPR. */
1109 tree decl = TREE_OPERAND (*tp, 0);
1112 n = (tree *) pointer_map_contains (id->decl_map, decl);
1116 *tp = fold_build2 (MEM_REF, TREE_TYPE (*tp),
1117 unshare_expr (*n), TREE_OPERAND (*tp, 1));
1118 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
1119 TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
1125 /* Here is the "usual case". Copy this tree node, and then
1126 tweak some special cases. */
1127 copy_tree_r (tp, walk_subtrees, NULL);
1129 /* Global variables we haven't seen yet needs to go into referenced
1130 vars. If not referenced from types or debug stmts only. */
1131 if (gimple_in_ssa_p (cfun)
1132 && TREE_CODE (*tp) == VAR_DECL
1133 && id->remapping_type_depth == 0
1134 && !processing_debug_stmt)
1135 add_referenced_var (*tp);
1137 /* If EXPR has block defined, map it to newly constructed block.
1138 When inlining we want EXPRs without block appear in the block
1139 of function call if we are not remapping a type. */
1142 new_block = id->remapping_type_depth == 0 ? id->block : NULL;
1143 if (TREE_BLOCK (*tp))
1146 n = (tree *) pointer_map_contains (id->decl_map,
1148 gcc_assert (n || id->remapping_type_depth != 0);
1152 TREE_BLOCK (*tp) = new_block;
1155 if (TREE_CODE (*tp) != OMP_CLAUSE)
1156 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
1158 /* The copied TARGET_EXPR has never been expanded, even if the
1159 original node was expanded already. */
1160 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
1162 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
1163 TREE_OPERAND (*tp, 3) = NULL_TREE;
1166 /* Variable substitution need not be simple. In particular, the
1167 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
1168 and friends are up-to-date. */
1169 else if (TREE_CODE (*tp) == ADDR_EXPR)
1171 int invariant = is_gimple_min_invariant (*tp);
1172 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
1174 /* Handle the case where we substituted an INDIRECT_REF
1175 into the operand of the ADDR_EXPR. */
1176 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
1177 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
1179 recompute_tree_invariant_for_addr_expr (*tp);
1181 /* If this used to be invariant, but is not any longer,
1182 then regimplification is probably needed. */
1183 if (invariant && !is_gimple_min_invariant (*tp))
1184 id->regimplify = true;
1190 /* Keep iterating. */
1194 /* Helper for remap_gimple_stmt. Given an EH region number for the
1195 source function, map that to the duplicate EH region number in
1196 the destination function. */
1199 remap_eh_region_nr (int old_nr, copy_body_data *id)
1201 eh_region old_r, new_r;
1204 old_r = get_eh_region_from_number_fn (id->src_cfun, old_nr);
1205 slot = pointer_map_contains (id->eh_map, old_r);
1206 new_r = (eh_region) *slot;
1208 return new_r->index;
1211 /* Similar, but operate on INTEGER_CSTs. */
1214 remap_eh_region_tree_nr (tree old_t_nr, copy_body_data *id)
1218 old_nr = tree_low_cst (old_t_nr, 0);
1219 new_nr = remap_eh_region_nr (old_nr, id);
1221 return build_int_cst (integer_type_node, new_nr);
1224 /* Helper for copy_bb. Remap statement STMT using the inlining
1225 information in ID. Return the new statement copy. */
1228 remap_gimple_stmt (gimple stmt, copy_body_data *id)
1231 struct walk_stmt_info wi;
1233 bool skip_first = false;
1235 /* Begin by recognizing trees that we'll completely rewrite for the
1236 inlining context. Our output for these trees is completely
1237 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1238 into an edge). Further down, we'll handle trees that get
1239 duplicated and/or tweaked. */
1241 /* When requested, GIMPLE_RETURNs should be transformed to just the
1242 contained GIMPLE_ASSIGN. The branch semantics of the return will
1243 be handled elsewhere by manipulating the CFG rather than the
1245 if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
1247 tree retval = gimple_return_retval (stmt);
1249 /* If we're returning something, just turn that into an
1250 assignment into the equivalent of the original RESULT_DECL.
1251 If RETVAL is just the result decl, the result decl has
1252 already been set (e.g. a recent "foo (&result_decl, ...)");
1253 just toss the entire GIMPLE_RETURN. */
1255 && (TREE_CODE (retval) != RESULT_DECL
1256 && (TREE_CODE (retval) != SSA_NAME
1257 || TREE_CODE (SSA_NAME_VAR (retval)) != RESULT_DECL)))
1259 copy = gimple_build_assign (id->retvar, retval);
1260 /* id->retvar is already substituted. Skip it on later remapping. */
1264 return gimple_build_nop ();
1266 else if (gimple_has_substatements (stmt))
1270 /* When cloning bodies from the C++ front end, we will be handed bodies
1271 in High GIMPLE form. Handle here all the High GIMPLE statements that
1272 have embedded statements. */
1273 switch (gimple_code (stmt))
1276 copy = copy_gimple_bind (stmt, id);
1280 s1 = remap_gimple_seq (gimple_catch_handler (stmt), id);
1281 copy = gimple_build_catch (gimple_catch_types (stmt), s1);
1284 case GIMPLE_EH_FILTER:
1285 s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id);
1286 copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1);
1290 s1 = remap_gimple_seq (gimple_try_eval (stmt), id);
1291 s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id);
1292 copy = gimple_build_try (s1, s2, gimple_try_kind (stmt));
1295 case GIMPLE_WITH_CLEANUP_EXPR:
1296 s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id);
1297 copy = gimple_build_wce (s1);
1300 case GIMPLE_OMP_PARALLEL:
1301 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1302 copy = gimple_build_omp_parallel
1304 gimple_omp_parallel_clauses (stmt),
1305 gimple_omp_parallel_child_fn (stmt),
1306 gimple_omp_parallel_data_arg (stmt));
1309 case GIMPLE_OMP_TASK:
1310 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1311 copy = gimple_build_omp_task
1313 gimple_omp_task_clauses (stmt),
1314 gimple_omp_task_child_fn (stmt),
1315 gimple_omp_task_data_arg (stmt),
1316 gimple_omp_task_copy_fn (stmt),
1317 gimple_omp_task_arg_size (stmt),
1318 gimple_omp_task_arg_align (stmt));
1321 case GIMPLE_OMP_FOR:
1322 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1323 s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id);
1324 copy = gimple_build_omp_for (s1, gimple_omp_for_clauses (stmt),
1325 gimple_omp_for_collapse (stmt), s2);
1328 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1330 gimple_omp_for_set_index (copy, i,
1331 gimple_omp_for_index (stmt, i));
1332 gimple_omp_for_set_initial (copy, i,
1333 gimple_omp_for_initial (stmt, i));
1334 gimple_omp_for_set_final (copy, i,
1335 gimple_omp_for_final (stmt, i));
1336 gimple_omp_for_set_incr (copy, i,
1337 gimple_omp_for_incr (stmt, i));
1338 gimple_omp_for_set_cond (copy, i,
1339 gimple_omp_for_cond (stmt, i));
1344 case GIMPLE_OMP_MASTER:
1345 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1346 copy = gimple_build_omp_master (s1);
1349 case GIMPLE_OMP_ORDERED:
1350 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1351 copy = gimple_build_omp_ordered (s1);
1354 case GIMPLE_OMP_SECTION:
1355 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1356 copy = gimple_build_omp_section (s1);
1359 case GIMPLE_OMP_SECTIONS:
1360 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1361 copy = gimple_build_omp_sections
1362 (s1, gimple_omp_sections_clauses (stmt));
1365 case GIMPLE_OMP_SINGLE:
1366 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1367 copy = gimple_build_omp_single
1368 (s1, gimple_omp_single_clauses (stmt));
1371 case GIMPLE_OMP_CRITICAL:
1372 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1374 = gimple_build_omp_critical (s1, gimple_omp_critical_name (stmt));
1377 case GIMPLE_TRANSACTION:
1378 s1 = remap_gimple_seq (gimple_transaction_body (stmt), id);
1379 copy = gimple_build_transaction (s1, gimple_transaction_label (stmt));
1380 gimple_transaction_set_subcode (copy, gimple_transaction_subcode (stmt));
1389 if (gimple_assign_copy_p (stmt)
1390 && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt)
1391 && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn))
1393 /* Here we handle statements that are not completely rewritten.
1394 First we detect some inlining-induced bogosities for
1397 /* Some assignments VAR = VAR; don't generate any rtl code
1398 and thus don't count as variable modification. Avoid
1399 keeping bogosities like 0 = 0. */
1400 tree decl = gimple_assign_lhs (stmt), value;
1403 n = (tree *) pointer_map_contains (id->decl_map, decl);
1407 STRIP_TYPE_NOPS (value);
1408 if (TREE_CONSTANT (value) || TREE_READONLY (value))
1409 return gimple_build_nop ();
1413 if (gimple_debug_bind_p (stmt))
1415 copy = gimple_build_debug_bind (gimple_debug_bind_get_var (stmt),
1416 gimple_debug_bind_get_value (stmt),
1418 VEC_safe_push (gimple, heap, id->debug_stmts, copy);
1421 if (gimple_debug_source_bind_p (stmt))
1423 copy = gimple_build_debug_source_bind
1424 (gimple_debug_source_bind_get_var (stmt),
1425 gimple_debug_source_bind_get_value (stmt), stmt);
1426 VEC_safe_push (gimple, heap, id->debug_stmts, copy);
1430 /* Create a new deep copy of the statement. */
1431 copy = gimple_copy (stmt);
1433 /* Remap the region numbers for __builtin_eh_{pointer,filter},
1434 RESX and EH_DISPATCH. */
1436 switch (gimple_code (copy))
1440 tree r, fndecl = gimple_call_fndecl (copy);
1441 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
1442 switch (DECL_FUNCTION_CODE (fndecl))
1444 case BUILT_IN_EH_COPY_VALUES:
1445 r = gimple_call_arg (copy, 1);
1446 r = remap_eh_region_tree_nr (r, id);
1447 gimple_call_set_arg (copy, 1, r);
1450 case BUILT_IN_EH_POINTER:
1451 case BUILT_IN_EH_FILTER:
1452 r = gimple_call_arg (copy, 0);
1453 r = remap_eh_region_tree_nr (r, id);
1454 gimple_call_set_arg (copy, 0, r);
1461 /* Reset alias info if we didn't apply measures to
1462 keep it valid over inlining by setting DECL_PT_UID. */
1463 if (!id->src_cfun->gimple_df
1464 || !id->src_cfun->gimple_df->ipa_pta)
1465 gimple_call_reset_alias_info (copy);
1471 int r = gimple_resx_region (copy);
1472 r = remap_eh_region_nr (r, id);
1473 gimple_resx_set_region (copy, r);
1477 case GIMPLE_EH_DISPATCH:
1479 int r = gimple_eh_dispatch_region (copy);
1480 r = remap_eh_region_nr (r, id);
1481 gimple_eh_dispatch_set_region (copy, r);
1490 /* If STMT has a block defined, map it to the newly constructed
1491 block. When inlining we want statements without a block to
1492 appear in the block of the function call. */
1493 new_block = id->block;
1494 if (gimple_block (copy))
1497 n = (tree *) pointer_map_contains (id->decl_map, gimple_block (copy));
1502 gimple_set_block (copy, new_block);
1504 if (gimple_debug_bind_p (copy) || gimple_debug_source_bind_p (copy))
1507 /* Remap all the operands in COPY. */
1508 memset (&wi, 0, sizeof (wi));
1511 walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL);
1513 walk_gimple_op (copy, remap_gimple_op_r, &wi);
1515 /* Clear the copied virtual operands. We are not remapping them here
1516 but are going to recreate them from scratch. */
1517 if (gimple_has_mem_ops (copy))
1519 gimple_set_vdef (copy, NULL_TREE);
1520 gimple_set_vuse (copy, NULL_TREE);
1527 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1531 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
1532 gcov_type count_scale)
1534 gimple_stmt_iterator gsi, copy_gsi, seq_gsi;
1535 basic_block copy_basic_block;
1540 /* Search for previous copied basic block. */
1543 prev = prev->prev_bb;
1545 /* create_basic_block() will append every new block to
1546 basic_block_info automatically. */
1547 copy_basic_block = create_basic_block (NULL, (void *) 0,
1548 (basic_block) prev->aux);
1549 copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
1551 /* We are going to rebuild frequencies from scratch. These values
1552 have just small importance to drive canonicalize_loop_headers. */
1553 freq = ((gcov_type)bb->frequency * frequency_scale / REG_BR_PROB_BASE);
1555 /* We recompute frequencies after inlining, so this is quite safe. */
1556 if (freq > BB_FREQ_MAX)
1558 copy_basic_block->frequency = freq;
1560 copy_gsi = gsi_start_bb (copy_basic_block);
1562 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1564 gimple stmt = gsi_stmt (gsi);
1565 gimple orig_stmt = stmt;
1567 id->regimplify = false;
1568 stmt = remap_gimple_stmt (stmt, id);
1569 if (gimple_nop_p (stmt))
1572 gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt);
1575 /* With return slot optimization we can end up with
1576 non-gimple (foo *)&this->m, fix that here. */
1577 if (is_gimple_assign (stmt)
1578 && gimple_assign_rhs_code (stmt) == NOP_EXPR
1579 && !is_gimple_val (gimple_assign_rhs1 (stmt)))
1582 new_rhs = force_gimple_operand_gsi (&seq_gsi,
1583 gimple_assign_rhs1 (stmt),
1585 GSI_CONTINUE_LINKING);
1586 gimple_assign_set_rhs1 (stmt, new_rhs);
1587 id->regimplify = false;
1590 gsi_insert_after (&seq_gsi, stmt, GSI_NEW_STMT);
1593 gimple_regimplify_operands (stmt, &seq_gsi);
1595 /* If copy_basic_block has been empty at the start of this iteration,
1596 call gsi_start_bb again to get at the newly added statements. */
1597 if (gsi_end_p (copy_gsi))
1598 copy_gsi = gsi_start_bb (copy_basic_block);
1600 gsi_next (©_gsi);
1602 /* Process the new statement. The call to gimple_regimplify_operands
1603 possibly turned the statement into multiple statements, we
1604 need to process all of them. */
1609 stmt = gsi_stmt (copy_gsi);
1610 if (is_gimple_call (stmt)
1611 && gimple_call_va_arg_pack_p (stmt)
1614 /* __builtin_va_arg_pack () should be replaced by
1615 all arguments corresponding to ... in the caller. */
1618 VEC(tree, heap) *argarray;
1619 size_t nargs = gimple_call_num_args (id->gimple_call);
1622 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p))
1625 /* Create the new array of arguments. */
1626 n = nargs + gimple_call_num_args (stmt);
1627 argarray = VEC_alloc (tree, heap, n);
1628 VEC_safe_grow (tree, heap, argarray, n);
1630 /* Copy all the arguments before '...' */
1631 memcpy (VEC_address (tree, argarray),
1632 gimple_call_arg_ptr (stmt, 0),
1633 gimple_call_num_args (stmt) * sizeof (tree));
1635 /* Append the arguments passed in '...' */
1636 memcpy (VEC_address(tree, argarray) + gimple_call_num_args (stmt),
1637 gimple_call_arg_ptr (id->gimple_call, 0)
1638 + (gimple_call_num_args (id->gimple_call) - nargs),
1639 nargs * sizeof (tree));
1641 new_call = gimple_build_call_vec (gimple_call_fn (stmt),
1644 VEC_free (tree, heap, argarray);
1646 /* Copy all GIMPLE_CALL flags, location and block, except
1647 GF_CALL_VA_ARG_PACK. */
1648 gimple_call_copy_flags (new_call, stmt);
1649 gimple_call_set_va_arg_pack (new_call, false);
1650 gimple_set_location (new_call, gimple_location (stmt));
1651 gimple_set_block (new_call, gimple_block (stmt));
1652 gimple_call_set_lhs (new_call, gimple_call_lhs (stmt));
1654 gsi_replace (©_gsi, new_call, false);
1657 else if (is_gimple_call (stmt)
1659 && (decl = gimple_call_fndecl (stmt))
1660 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1661 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN)
1663 /* __builtin_va_arg_pack_len () should be replaced by
1664 the number of anonymous arguments. */
1665 size_t nargs = gimple_call_num_args (id->gimple_call);
1669 for (p = DECL_ARGUMENTS (id->src_fn); p; p = DECL_CHAIN (p))
1672 count = build_int_cst (integer_type_node, nargs);
1673 new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count);
1674 gsi_replace (©_gsi, new_stmt, false);
1678 /* Statements produced by inlining can be unfolded, especially
1679 when we constant propagated some operands. We can't fold
1680 them right now for two reasons:
1681 1) folding require SSA_NAME_DEF_STMTs to be correct
1682 2) we can't change function calls to builtins.
1683 So we just mark statement for later folding. We mark
1684 all new statements, instead just statements that has changed
1685 by some nontrivial substitution so even statements made
1686 foldable indirectly are updated. If this turns out to be
1687 expensive, copy_body can be told to watch for nontrivial
1689 if (id->statements_to_fold)
1690 pointer_set_insert (id->statements_to_fold, stmt);
1692 /* We're duplicating a CALL_EXPR. Find any corresponding
1693 callgraph edges and update or duplicate them. */
1694 if (is_gimple_call (stmt))
1696 struct cgraph_edge *edge;
1699 switch (id->transform_call_graph_edges)
1701 case CB_CGE_DUPLICATE:
1702 edge = cgraph_edge (id->src_node, orig_stmt);
1705 int edge_freq = edge->frequency;
1706 edge = cgraph_clone_edge (edge, id->dst_node, stmt,
1708 REG_BR_PROB_BASE, CGRAPH_FREQ_BASE,
1710 /* We could also just rescale the frequency, but
1711 doing so would introduce roundoff errors and make
1712 verifier unhappy. */
1714 = compute_call_stmt_bb_frequency (id->dst_node->decl,
1717 && profile_status_for_function (cfun) != PROFILE_ABSENT
1718 && (edge_freq > edge->frequency + 10
1719 || edge_freq < edge->frequency - 10))
1721 fprintf (dump_file, "Edge frequency estimated by "
1722 "cgraph %i diverge from inliner's estimate %i\n",
1726 "Orig bb: %i, orig bb freq %i, new bb freq %i\n",
1729 copy_basic_block->frequency);
1731 stmt = cgraph_redirect_edge_call_stmt_to_callee (edge);
1735 case CB_CGE_MOVE_CLONES:
1736 cgraph_set_call_stmt_including_clones (id->dst_node,
1738 edge = cgraph_edge (id->dst_node, stmt);
1742 edge = cgraph_edge (id->dst_node, orig_stmt);
1744 cgraph_set_call_stmt (edge, stmt);
1751 /* Constant propagation on argument done during inlining
1752 may create new direct call. Produce an edge for it. */
1754 || (edge->indirect_inlining_edge
1755 && id->transform_call_graph_edges == CB_CGE_MOVE_CLONES))
1756 && id->dst_node->analyzed
1757 && (fn = gimple_call_fndecl (stmt)) != NULL)
1759 struct cgraph_node *dest = cgraph_get_node (fn);
1761 /* We have missing edge in the callgraph. This can happen
1762 when previous inlining turned an indirect call into a
1763 direct call by constant propagating arguments or we are
1764 producing dead clone (for further cloning). In all
1765 other cases we hit a bug (incorrect node sharing is the
1766 most common reason for missing edges). */
1767 gcc_assert (dest->needed || !dest->analyzed
1768 || dest->address_taken
1769 || !id->src_node->analyzed
1770 || !id->dst_node->analyzed);
1771 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES)
1772 cgraph_create_edge_including_clones
1773 (id->dst_node, dest, orig_stmt, stmt, bb->count,
1774 compute_call_stmt_bb_frequency (id->dst_node->decl,
1776 CIF_ORIGINALLY_INDIRECT_CALL);
1778 cgraph_create_edge (id->dst_node, dest, stmt,
1780 compute_call_stmt_bb_frequency
1781 (id->dst_node->decl, copy_basic_block))->inline_failed
1782 = CIF_ORIGINALLY_INDIRECT_CALL;
1785 fprintf (dump_file, "Created new direct edge to %s\n",
1786 cgraph_node_name (dest));
1790 flags = gimple_call_flags (stmt);
1791 if (flags & ECF_MAY_BE_ALLOCA)
1792 cfun->calls_alloca = true;
1793 if (flags & ECF_RETURNS_TWICE)
1794 cfun->calls_setjmp = true;
1797 maybe_duplicate_eh_stmt_fn (cfun, stmt, id->src_cfun, orig_stmt,
1798 id->eh_map, id->eh_lp_nr);
1800 if (gimple_in_ssa_p (cfun) && !is_gimple_debug (stmt))
1805 find_new_referenced_vars (gsi_stmt (copy_gsi));
1806 FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
1807 if (TREE_CODE (def) == SSA_NAME)
1808 SSA_NAME_DEF_STMT (def) = stmt;
1811 gsi_next (©_gsi);
1813 while (!gsi_end_p (copy_gsi));
1815 copy_gsi = gsi_last_bb (copy_basic_block);
1818 return copy_basic_block;
1821 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1822 form is quite easy, since dominator relationship for old basic blocks does
1825 There is however exception where inlining might change dominator relation
1826 across EH edges from basic block within inlined functions destinating
1827 to landing pads in function we inline into.
1829 The function fills in PHI_RESULTs of such PHI nodes if they refer
1830 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1831 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1832 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1833 set, and this means that there will be no overlapping live ranges
1834 for the underlying symbol.
1836 This might change in future if we allow redirecting of EH edges and
1837 we might want to change way build CFG pre-inlining to include
1838 all the possible edges then. */
1840 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
1841 bool can_throw, bool nonlocal_goto)
1846 FOR_EACH_EDGE (e, ei, bb->succs)
1848 || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
1851 gimple_stmt_iterator si;
1854 gcc_assert (e->flags & EDGE_EH);
1857 gcc_assert (!(e->flags & EDGE_EH));
1859 for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si))
1863 phi = gsi_stmt (si);
1865 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */
1866 gcc_assert (!e->dest->aux);
1868 gcc_assert ((e->flags & EDGE_EH)
1869 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)));
1871 if (!is_gimple_reg (PHI_RESULT (phi)))
1873 mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi)));
1877 re = find_edge (ret_bb, e->dest);
1879 gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
1880 == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
1882 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
1883 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
1889 /* Copy edges from BB into its copy constructed earlier, scale profile
1890 accordingly. Edges will be taken care of later. Assume aux
1891 pointers to point to the copies of each BB. Return true if any
1892 debug stmts are left after a statement that must end the basic block. */
1895 copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb)
1897 basic_block new_bb = (basic_block) bb->aux;
1900 gimple_stmt_iterator si;
1902 bool need_debug_cleanup = false;
1904 /* Use the indices from the original blocks to create edges for the
1906 FOR_EACH_EDGE (old_edge, ei, bb->succs)
1907 if (!(old_edge->flags & EDGE_EH))
1911 flags = old_edge->flags;
1913 /* Return edges do get a FALLTHRU flag when the get inlined. */
1914 if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
1915 && old_edge->dest->aux != EXIT_BLOCK_PTR)
1916 flags |= EDGE_FALLTHRU;
1917 new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
1918 new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
1919 new_edge->probability = old_edge->probability;
1922 if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
1925 for (si = gsi_start_bb (new_bb); !gsi_end_p (si);)
1928 bool can_throw, nonlocal_goto;
1930 copy_stmt = gsi_stmt (si);
1931 if (!is_gimple_debug (copy_stmt))
1933 update_stmt (copy_stmt);
1934 if (gimple_in_ssa_p (cfun))
1935 mark_symbols_for_renaming (copy_stmt);
1938 /* Do this before the possible split_block. */
1941 /* If this tree could throw an exception, there are two
1942 cases where we need to add abnormal edge(s): the
1943 tree wasn't in a region and there is a "current
1944 region" in the caller; or the original tree had
1945 EH edges. In both cases split the block after the tree,
1946 and add abnormal edge(s) as needed; we need both
1947 those from the callee and the caller.
1948 We check whether the copy can throw, because the const
1949 propagation can change an INDIRECT_REF which throws
1950 into a COMPONENT_REF which doesn't. If the copy
1951 can throw, the original could also throw. */
1952 can_throw = stmt_can_throw_internal (copy_stmt);
1953 nonlocal_goto = stmt_can_make_abnormal_goto (copy_stmt);
1955 if (can_throw || nonlocal_goto)
1957 if (!gsi_end_p (si))
1959 while (!gsi_end_p (si) && is_gimple_debug (gsi_stmt (si)))
1962 need_debug_cleanup = true;
1964 if (!gsi_end_p (si))
1965 /* Note that bb's predecessor edges aren't necessarily
1966 right at this point; split_block doesn't care. */
1968 edge e = split_block (new_bb, copy_stmt);
1971 new_bb->aux = e->src->aux;
1972 si = gsi_start_bb (new_bb);
1976 if (gimple_code (copy_stmt) == GIMPLE_EH_DISPATCH)
1977 make_eh_dispatch_edges (copy_stmt);
1979 make_eh_edges (copy_stmt);
1982 make_abnormal_goto_edges (gimple_bb (copy_stmt), true);
1984 if ((can_throw || nonlocal_goto)
1985 && gimple_in_ssa_p (cfun))
1986 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb,
1987 can_throw, nonlocal_goto);
1989 return need_debug_cleanup;
1992 /* Copy the PHIs. All blocks and edges are copied, some blocks
1993 was possibly split and new outgoing EH edges inserted.
1994 BB points to the block of original function and AUX pointers links
1995 the original and newly copied blocks. */
1998 copy_phis_for_bb (basic_block bb, copy_body_data *id)
2000 basic_block const new_bb = (basic_block) bb->aux;
2003 gimple_stmt_iterator si;
2005 bool inserted = false;
2007 for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si))
2012 phi = gsi_stmt (si);
2013 res = PHI_RESULT (phi);
2015 if (is_gimple_reg (res))
2017 walk_tree (&new_res, copy_tree_body_r, id, NULL);
2018 SSA_NAME_DEF_STMT (new_res)
2019 = new_phi = create_phi_node (new_res, new_bb);
2020 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
2022 edge old_edge = find_edge ((basic_block) new_edge->src->aux, bb);
2025 tree block = id->block;
2028 /* When doing partial cloning, we allow PHIs on the entry block
2029 as long as all the arguments are the same. Find any input
2030 edge to see argument to copy. */
2032 FOR_EACH_EDGE (old_edge, ei2, bb->preds)
2033 if (!old_edge->src->aux)
2036 arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
2038 id->block = NULL_TREE;
2039 walk_tree (&new_arg, copy_tree_body_r, id, NULL);
2041 gcc_assert (new_arg);
2042 /* With return slot optimization we can end up with
2043 non-gimple (foo *)&this->m, fix that here. */
2044 if (TREE_CODE (new_arg) != SSA_NAME
2045 && TREE_CODE (new_arg) != FUNCTION_DECL
2046 && !is_gimple_val (new_arg))
2048 gimple_seq stmts = NULL;
2049 new_arg = force_gimple_operand (new_arg, &stmts, true, NULL);
2050 gsi_insert_seq_on_edge (new_edge, stmts);
2053 add_phi_arg (new_phi, new_arg, new_edge,
2054 gimple_phi_arg_location_from_edge (phi, old_edge));
2059 /* Commit the delayed edge insertions. */
2061 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
2062 gsi_commit_one_edge_insert (new_edge, NULL);
2066 /* Wrapper for remap_decl so it can be used as a callback. */
2069 remap_decl_1 (tree decl, void *data)
2071 return remap_decl (decl, (copy_body_data *) data);
2074 /* Build struct function and associated datastructures for the new clone
2075 NEW_FNDECL to be build. CALLEE_FNDECL is the original */
2078 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count)
2080 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2081 gcov_type count_scale;
2083 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
2084 count_scale = (REG_BR_PROB_BASE * count
2085 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
2087 count_scale = REG_BR_PROB_BASE;
2089 /* Register specific tree functions. */
2090 gimple_register_cfg_hooks ();
2092 /* Get clean struct function. */
2093 push_struct_function (new_fndecl);
2095 /* We will rebuild these, so just sanity check that they are empty. */
2096 gcc_assert (VALUE_HISTOGRAMS (cfun) == NULL);
2097 gcc_assert (cfun->local_decls == NULL);
2098 gcc_assert (cfun->cfg == NULL);
2099 gcc_assert (cfun->decl == new_fndecl);
2101 /* Copy items we preserve during cloning. */
2102 cfun->static_chain_decl = src_cfun->static_chain_decl;
2103 cfun->nonlocal_goto_save_area = src_cfun->nonlocal_goto_save_area;
2104 cfun->function_end_locus = src_cfun->function_end_locus;
2105 cfun->curr_properties = src_cfun->curr_properties;
2106 cfun->last_verified = src_cfun->last_verified;
2107 cfun->va_list_gpr_size = src_cfun->va_list_gpr_size;
2108 cfun->va_list_fpr_size = src_cfun->va_list_fpr_size;
2109 cfun->has_nonlocal_label = src_cfun->has_nonlocal_label;
2110 cfun->stdarg = src_cfun->stdarg;
2111 cfun->after_inlining = src_cfun->after_inlining;
2112 cfun->can_throw_non_call_exceptions
2113 = src_cfun->can_throw_non_call_exceptions;
2114 cfun->returns_struct = src_cfun->returns_struct;
2115 cfun->returns_pcc_struct = src_cfun->returns_pcc_struct;
2116 cfun->after_tree_profile = src_cfun->after_tree_profile;
2118 init_empty_tree_cfg ();
2120 profile_status_for_function (cfun) = profile_status_for_function (src_cfun);
2121 ENTRY_BLOCK_PTR->count =
2122 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
2124 ENTRY_BLOCK_PTR->frequency
2125 = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency;
2126 EXIT_BLOCK_PTR->count =
2127 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
2129 EXIT_BLOCK_PTR->frequency =
2130 EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency;
2132 init_eh_for_function ();
2134 if (src_cfun->gimple_df)
2136 init_tree_ssa (cfun);
2137 cfun->gimple_df->in_ssa_p = true;
2138 init_ssa_operands ();
2143 /* Helper function for copy_cfg_body. Move debug stmts from the end
2144 of NEW_BB to the beginning of successor basic blocks when needed. If the
2145 successor has multiple predecessors, reset them, otherwise keep
2149 maybe_move_debug_stmts_to_successors (copy_body_data *id, basic_block new_bb)
2153 gimple_stmt_iterator si = gsi_last_nondebug_bb (new_bb);
2156 || gsi_one_before_end_p (si)
2157 || !(stmt_can_throw_internal (gsi_stmt (si))
2158 || stmt_can_make_abnormal_goto (gsi_stmt (si))))
2161 FOR_EACH_EDGE (e, ei, new_bb->succs)
2163 gimple_stmt_iterator ssi = gsi_last_bb (new_bb);
2164 gimple_stmt_iterator dsi = gsi_after_labels (e->dest);
2165 while (is_gimple_debug (gsi_stmt (ssi)))
2167 gimple stmt = gsi_stmt (ssi), new_stmt;
2171 /* For the last edge move the debug stmts instead of copying
2173 if (ei_one_before_end_p (ei))
2177 if (!single_pred_p (e->dest) && gimple_debug_bind_p (stmt))
2178 gimple_debug_bind_reset_value (stmt);
2179 gsi_remove (&si, false);
2180 gsi_insert_before (&dsi, stmt, GSI_SAME_STMT);
2184 if (gimple_debug_bind_p (stmt))
2186 var = gimple_debug_bind_get_var (stmt);
2187 if (single_pred_p (e->dest))
2189 value = gimple_debug_bind_get_value (stmt);
2190 value = unshare_expr (value);
2194 new_stmt = gimple_build_debug_bind (var, value, stmt);
2196 else if (gimple_debug_source_bind_p (stmt))
2198 var = gimple_debug_source_bind_get_var (stmt);
2199 value = gimple_debug_source_bind_get_value (stmt);
2200 new_stmt = gimple_build_debug_source_bind (var, value, stmt);
2204 gsi_insert_before (&dsi, new_stmt, GSI_SAME_STMT);
2205 VEC_safe_push (gimple, heap, id->debug_stmts, new_stmt);
2211 /* Make a copy of the body of FN so that it can be inserted inline in
2212 another function. Walks FN via CFG, returns new fndecl. */
2215 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale,
2216 basic_block entry_block_map, basic_block exit_block_map,
2217 bitmap blocks_to_copy, basic_block new_entry)
2219 tree callee_fndecl = id->src_fn;
2220 /* Original cfun for the callee, doesn't change. */
2221 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2222 struct function *cfun_to_copy;
2224 tree new_fndecl = NULL;
2225 bool need_debug_cleanup = false;
2226 gcov_type count_scale;
2228 int incoming_frequency = 0;
2229 gcov_type incoming_count = 0;
2231 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
2232 count_scale = (REG_BR_PROB_BASE * count
2233 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
2235 count_scale = REG_BR_PROB_BASE;
2237 /* Register specific tree functions. */
2238 gimple_register_cfg_hooks ();
2240 /* If we are inlining just region of the function, make sure to connect new entry
2241 to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute
2242 frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
2243 probabilities of edges incoming from nonduplicated region. */
2249 FOR_EACH_EDGE (e, ei, new_entry->preds)
2252 incoming_frequency += EDGE_FREQUENCY (e);
2253 incoming_count += e->count;
2255 incoming_count = incoming_count * count_scale / REG_BR_PROB_BASE;
2257 = incoming_frequency * frequency_scale / REG_BR_PROB_BASE;
2258 ENTRY_BLOCK_PTR->count = incoming_count;
2259 ENTRY_BLOCK_PTR->frequency = incoming_frequency;
2262 /* Must have a CFG here at this point. */
2263 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
2264 (DECL_STRUCT_FUNCTION (callee_fndecl)));
2266 cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
2268 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
2269 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
2270 entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
2271 exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
2273 /* Duplicate any exception-handling regions. */
2275 id->eh_map = duplicate_eh_regions (cfun_to_copy, NULL, id->eh_lp_nr,
2278 /* Use aux pointers to map the original blocks to copy. */
2279 FOR_EACH_BB_FN (bb, cfun_to_copy)
2280 if (!blocks_to_copy || bitmap_bit_p (blocks_to_copy, bb->index))
2282 basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale);
2287 last = last_basic_block;
2289 /* Now that we've duplicated the blocks, duplicate their edges. */
2290 FOR_ALL_BB_FN (bb, cfun_to_copy)
2292 || (bb->index > 0 && bitmap_bit_p (blocks_to_copy, bb->index)))
2293 need_debug_cleanup |= copy_edges_for_bb (bb, count_scale, exit_block_map);
2297 edge e = make_edge (entry_block_map, (basic_block)new_entry->aux, EDGE_FALLTHRU);
2298 e->probability = REG_BR_PROB_BASE;
2299 e->count = incoming_count;
2302 if (gimple_in_ssa_p (cfun))
2303 FOR_ALL_BB_FN (bb, cfun_to_copy)
2305 || (bb->index > 0 && bitmap_bit_p (blocks_to_copy, bb->index)))
2306 copy_phis_for_bb (bb, id);
2308 FOR_ALL_BB_FN (bb, cfun_to_copy)
2311 if (need_debug_cleanup
2312 && bb->index != ENTRY_BLOCK
2313 && bb->index != EXIT_BLOCK)
2314 maybe_move_debug_stmts_to_successors (id, (basic_block) bb->aux);
2315 ((basic_block)bb->aux)->aux = NULL;
2319 /* Zero out AUX fields of newly created block during EH edge
2321 for (; last < last_basic_block; last++)
2323 if (need_debug_cleanup)
2324 maybe_move_debug_stmts_to_successors (id, BASIC_BLOCK (last));
2325 BASIC_BLOCK (last)->aux = NULL;
2327 entry_block_map->aux = NULL;
2328 exit_block_map->aux = NULL;
2332 pointer_map_destroy (id->eh_map);
2339 /* Copy the debug STMT using ID. We deal with these statements in a
2340 special way: if any variable in their VALUE expression wasn't
2341 remapped yet, we won't remap it, because that would get decl uids
2342 out of sync, causing codegen differences between -g and -g0. If
2343 this arises, we drop the VALUE expression altogether. */
2346 copy_debug_stmt (gimple stmt, copy_body_data *id)
2349 struct walk_stmt_info wi;
2352 if (gimple_block (stmt))
2354 n = (tree *) pointer_map_contains (id->decl_map, gimple_block (stmt));
2358 gimple_set_block (stmt, t);
2360 /* Remap all the operands in COPY. */
2361 memset (&wi, 0, sizeof (wi));
2364 processing_debug_stmt = 1;
2366 if (gimple_debug_source_bind_p (stmt))
2367 t = gimple_debug_source_bind_get_var (stmt);
2369 t = gimple_debug_bind_get_var (stmt);
2371 if (TREE_CODE (t) == PARM_DECL && id->debug_map
2372 && (n = (tree *) pointer_map_contains (id->debug_map, t)))
2374 gcc_assert (TREE_CODE (*n) == VAR_DECL);
2377 else if (TREE_CODE (t) == VAR_DECL
2379 && gimple_in_ssa_p (cfun)
2380 && !pointer_map_contains (id->decl_map, t)
2382 /* T is a non-localized variable. */;
2384 walk_tree (&t, remap_gimple_op_r, &wi, NULL);
2386 if (gimple_debug_bind_p (stmt))
2388 gimple_debug_bind_set_var (stmt, t);
2390 if (gimple_debug_bind_has_value_p (stmt))
2391 walk_tree (gimple_debug_bind_get_value_ptr (stmt),
2392 remap_gimple_op_r, &wi, NULL);
2394 /* Punt if any decl couldn't be remapped. */
2395 if (processing_debug_stmt < 0)
2396 gimple_debug_bind_reset_value (stmt);
2398 else if (gimple_debug_source_bind_p (stmt))
2400 gimple_debug_source_bind_set_var (stmt, t);
2401 walk_tree (gimple_debug_source_bind_get_value_ptr (stmt),
2402 remap_gimple_op_r, &wi, NULL);
2405 processing_debug_stmt = 0;
2408 if (gimple_in_ssa_p (cfun))
2409 mark_symbols_for_renaming (stmt);
2412 /* Process deferred debug stmts. In order to give values better odds
2413 of being successfully remapped, we delay the processing of debug
2414 stmts until all other stmts that might require remapping are
2418 copy_debug_stmts (copy_body_data *id)
2423 if (!id->debug_stmts)
2426 FOR_EACH_VEC_ELT (gimple, id->debug_stmts, i, stmt)
2427 copy_debug_stmt (stmt, id);
2429 VEC_free (gimple, heap, id->debug_stmts);
2432 /* Make a copy of the body of SRC_FN so that it can be inserted inline in
2433 another function. */
2436 copy_tree_body (copy_body_data *id)
2438 tree fndecl = id->src_fn;
2439 tree body = DECL_SAVED_TREE (fndecl);
2441 walk_tree (&body, copy_tree_body_r, id, NULL);
2446 /* Make a copy of the body of FN so that it can be inserted inline in
2447 another function. */
2450 copy_body (copy_body_data *id, gcov_type count, int frequency_scale,
2451 basic_block entry_block_map, basic_block exit_block_map,
2452 bitmap blocks_to_copy, basic_block new_entry)
2454 tree fndecl = id->src_fn;
2457 /* If this body has a CFG, walk CFG and copy. */
2458 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
2459 body = copy_cfg_body (id, count, frequency_scale, entry_block_map, exit_block_map,
2460 blocks_to_copy, new_entry);
2461 copy_debug_stmts (id);
2466 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
2467 defined in function FN, or of a data member thereof. */
2470 self_inlining_addr_expr (tree value, tree fn)
2474 if (TREE_CODE (value) != ADDR_EXPR)
2477 var = get_base_address (TREE_OPERAND (value, 0));
2479 return var && auto_var_in_fn_p (var, fn);
2482 /* Append to BB a debug annotation that binds VAR to VALUE, inheriting
2483 lexical block and line number information from base_stmt, if given,
2484 or from the last stmt of the block otherwise. */
2487 insert_init_debug_bind (copy_body_data *id,
2488 basic_block bb, tree var, tree value,
2492 gimple_stmt_iterator gsi;
2495 if (!gimple_in_ssa_p (id->src_cfun))
2498 if (!MAY_HAVE_DEBUG_STMTS)
2501 tracked_var = target_for_debug_bind (var);
2507 gsi = gsi_last_bb (bb);
2508 if (!base_stmt && !gsi_end_p (gsi))
2509 base_stmt = gsi_stmt (gsi);
2512 note = gimple_build_debug_bind (tracked_var, value, base_stmt);
2516 if (!gsi_end_p (gsi))
2517 gsi_insert_after (&gsi, note, GSI_SAME_STMT);
2519 gsi_insert_before (&gsi, note, GSI_SAME_STMT);
2526 insert_init_stmt (copy_body_data *id, basic_block bb, gimple init_stmt)
2528 /* If VAR represents a zero-sized variable, it's possible that the
2529 assignment statement may result in no gimple statements. */
2532 gimple_stmt_iterator si = gsi_last_bb (bb);
2534 /* We can end up with init statements that store to a non-register
2535 from a rhs with a conversion. Handle that here by forcing the
2536 rhs into a temporary. gimple_regimplify_operands is not
2537 prepared to do this for us. */
2538 if (!is_gimple_debug (init_stmt)
2539 && !is_gimple_reg (gimple_assign_lhs (init_stmt))
2540 && is_gimple_reg_type (TREE_TYPE (gimple_assign_lhs (init_stmt)))
2541 && gimple_assign_rhs_class (init_stmt) == GIMPLE_UNARY_RHS)
2543 tree rhs = build1 (gimple_assign_rhs_code (init_stmt),
2544 gimple_expr_type (init_stmt),
2545 gimple_assign_rhs1 (init_stmt));
2546 rhs = force_gimple_operand_gsi (&si, rhs, true, NULL_TREE, false,
2548 gimple_assign_set_rhs_code (init_stmt, TREE_CODE (rhs));
2549 gimple_assign_set_rhs1 (init_stmt, rhs);
2551 gsi_insert_after (&si, init_stmt, GSI_NEW_STMT);
2552 gimple_regimplify_operands (init_stmt, &si);
2553 mark_symbols_for_renaming (init_stmt);
2555 if (!is_gimple_debug (init_stmt) && MAY_HAVE_DEBUG_STMTS)
2557 tree var, def = gimple_assign_lhs (init_stmt);
2559 if (TREE_CODE (def) == SSA_NAME)
2560 var = SSA_NAME_VAR (def);
2564 insert_init_debug_bind (id, bb, var, def, init_stmt);
2569 /* Initialize parameter P with VALUE. If needed, produce init statement
2570 at the end of BB. When BB is NULL, we return init statement to be
2573 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
2574 basic_block bb, tree *vars)
2576 gimple init_stmt = NULL;
2579 tree def = (gimple_in_ssa_p (cfun)
2580 ? gimple_default_def (id->src_cfun, p) : NULL);
2583 && value != error_mark_node
2584 && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
2586 /* If we can match up types by promotion/demotion do so. */
2587 if (fold_convertible_p (TREE_TYPE (p), value))
2588 rhs = fold_convert (TREE_TYPE (p), value);
2591 /* ??? For valid programs we should not end up here.
2592 Still if we end up with truly mismatched types here, fall back
2593 to using a VIEW_CONVERT_EXPR or a literal zero to not leak invalid
2594 GIMPLE to the following passes. */
2595 if (!is_gimple_reg_type (TREE_TYPE (value))
2596 || TYPE_SIZE (TREE_TYPE (p)) == TYPE_SIZE (TREE_TYPE (value)))
2597 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value);
2599 rhs = build_zero_cst (TREE_TYPE (p));
2603 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
2604 here since the type of this decl must be visible to the calling
2606 var = copy_decl_to_var (p, id);
2608 /* We're actually using the newly-created var. */
2609 if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL)
2610 add_referenced_var (var);
2612 /* Declare this new variable. */
2613 DECL_CHAIN (var) = *vars;
2616 /* Make gimplifier happy about this variable. */
2617 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
2619 /* We are eventually using the value - make sure all variables
2620 referenced therein are properly recorded. */
2622 && gimple_in_ssa_p (cfun)
2623 && TREE_CODE (value) == ADDR_EXPR)
2625 tree base = get_base_address (TREE_OPERAND (value, 0));
2626 if (base && TREE_CODE (base) == VAR_DECL)
2627 add_referenced_var (base);
2630 /* If the parameter is never assigned to, has no SSA_NAMEs created,
2631 we would not need to create a new variable here at all, if it
2632 weren't for debug info. Still, we can just use the argument
2634 if (TREE_READONLY (p)
2635 && !TREE_ADDRESSABLE (p)
2636 && value && !TREE_SIDE_EFFECTS (value)
2639 /* We may produce non-gimple trees by adding NOPs or introduce
2640 invalid sharing when operand is not really constant.
2641 It is not big deal to prohibit constant propagation here as
2642 we will constant propagate in DOM1 pass anyway. */
2643 if (is_gimple_min_invariant (value)
2644 && useless_type_conversion_p (TREE_TYPE (p),
2646 /* We have to be very careful about ADDR_EXPR. Make sure
2647 the base variable isn't a local variable of the inlined
2648 function, e.g., when doing recursive inlining, direct or
2649 mutually-recursive or whatever, which is why we don't
2650 just test whether fn == current_function_decl. */
2651 && ! self_inlining_addr_expr (value, fn))
2653 insert_decl_map (id, p, value);
2654 insert_debug_decl_map (id, p, var);
2655 return insert_init_debug_bind (id, bb, var, value, NULL);
2659 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
2660 that way, when the PARM_DECL is encountered, it will be
2661 automatically replaced by the VAR_DECL. */
2662 insert_decl_map (id, p, var);
2664 /* Even if P was TREE_READONLY, the new VAR should not be.
2665 In the original code, we would have constructed a
2666 temporary, and then the function body would have never
2667 changed the value of P. However, now, we will be
2668 constructing VAR directly. The constructor body may
2669 change its value multiple times as it is being
2670 constructed. Therefore, it must not be TREE_READONLY;
2671 the back-end assumes that TREE_READONLY variable is
2672 assigned to only once. */
2673 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
2674 TREE_READONLY (var) = 0;
2676 /* If there is no setup required and we are in SSA, take the easy route
2677 replacing all SSA names representing the function parameter by the
2678 SSA name passed to function.
2680 We need to construct map for the variable anyway as it might be used
2681 in different SSA names when parameter is set in function.
2683 Do replacement at -O0 for const arguments replaced by constant.
2684 This is important for builtin_constant_p and other construct requiring
2685 constant argument to be visible in inlined function body. */
2686 if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
2688 || (TREE_READONLY (p)
2689 && is_gimple_min_invariant (rhs)))
2690 && (TREE_CODE (rhs) == SSA_NAME
2691 || is_gimple_min_invariant (rhs))
2692 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
2694 insert_decl_map (id, def, rhs);
2695 return insert_init_debug_bind (id, bb, var, rhs, NULL);
2698 /* If the value of argument is never used, don't care about initializing
2700 if (optimize && gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
2702 gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
2703 return insert_init_debug_bind (id, bb, var, rhs, NULL);
2706 /* Initialize this VAR_DECL from the equivalent argument. Convert
2707 the argument to the proper type in case it was promoted. */
2710 if (rhs == error_mark_node)
2712 insert_decl_map (id, p, var);
2713 return insert_init_debug_bind (id, bb, var, rhs, NULL);
2716 STRIP_USELESS_TYPE_CONVERSION (rhs);
2718 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
2719 keep our trees in gimple form. */
2720 if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p))
2722 def = remap_ssa_name (def, id);
2723 init_stmt = gimple_build_assign (def, rhs);
2724 SSA_NAME_IS_DEFAULT_DEF (def) = 0;
2725 set_default_def (var, NULL);
2728 init_stmt = gimple_build_assign (var, rhs);
2730 if (bb && init_stmt)
2731 insert_init_stmt (id, bb, init_stmt);
2736 /* Generate code to initialize the parameters of the function at the
2737 top of the stack in ID from the GIMPLE_CALL STMT. */
2740 initialize_inlined_parameters (copy_body_data *id, gimple stmt,
2741 tree fn, basic_block bb)
2746 tree vars = NULL_TREE;
2747 tree static_chain = gimple_call_chain (stmt);
2749 /* Figure out what the parameters are. */
2750 parms = DECL_ARGUMENTS (fn);
2752 /* Loop through the parameter declarations, replacing each with an
2753 equivalent VAR_DECL, appropriately initialized. */
2754 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++)
2757 val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL;
2758 setup_one_parameter (id, p, val, fn, bb, &vars);
2760 /* After remapping parameters remap their types. This has to be done
2761 in a second loop over all parameters to appropriately remap
2762 variable sized arrays when the size is specified in a
2763 parameter following the array. */
2764 for (p = parms, i = 0; p; p = DECL_CHAIN (p), i++)
2766 tree *varp = (tree *) pointer_map_contains (id->decl_map, p);
2768 && TREE_CODE (*varp) == VAR_DECL)
2770 tree def = (gimple_in_ssa_p (cfun) && is_gimple_reg (p)
2771 ? gimple_default_def (id->src_cfun, p) : NULL);
2773 TREE_TYPE (var) = remap_type (TREE_TYPE (var), id);
2774 /* Also remap the default definition if it was remapped
2775 to the default definition of the parameter replacement
2776 by the parameter setup. */
2779 tree *defp = (tree *) pointer_map_contains (id->decl_map, def);
2781 && TREE_CODE (*defp) == SSA_NAME
2782 && SSA_NAME_VAR (*defp) == var)
2783 TREE_TYPE (*defp) = TREE_TYPE (var);
2788 /* Initialize the static chain. */
2789 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
2790 gcc_assert (fn != current_function_decl);
2793 /* No static chain? Seems like a bug in tree-nested.c. */
2794 gcc_assert (static_chain);
2796 setup_one_parameter (id, p, static_chain, fn, bb, &vars);
2799 declare_inline_vars (id->block, vars);
2803 /* Declare a return variable to replace the RESULT_DECL for the
2804 function we are calling. An appropriate DECL_STMT is returned.
2805 The USE_STMT is filled to contain a use of the declaration to
2806 indicate the return value of the function.
2808 RETURN_SLOT, if non-null is place where to store the result. It
2809 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
2810 was the LHS of the MODIFY_EXPR to which this call is the RHS.
2812 The return value is a (possibly null) value that holds the result
2813 as seen by the caller. */
2816 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
2817 basic_block entry_bb)
2819 tree callee = id->src_fn;
2820 tree result = DECL_RESULT (callee);
2821 tree callee_type = TREE_TYPE (result);
2825 /* Handle type-mismatches in the function declaration return type
2826 vs. the call expression. */
2828 caller_type = TREE_TYPE (modify_dest);
2830 caller_type = TREE_TYPE (TREE_TYPE (callee));
2832 /* We don't need to do anything for functions that don't return anything. */
2833 if (VOID_TYPE_P (callee_type))
2836 /* If there was a return slot, then the return value is the
2837 dereferenced address of that object. */
2840 /* The front end shouldn't have used both return_slot and
2841 a modify expression. */
2842 gcc_assert (!modify_dest);
2843 if (DECL_BY_REFERENCE (result))
2845 tree return_slot_addr = build_fold_addr_expr (return_slot);
2846 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
2848 /* We are going to construct *&return_slot and we can't do that
2849 for variables believed to be not addressable.
2851 FIXME: This check possibly can match, because values returned
2852 via return slot optimization are not believed to have address
2853 taken by alias analysis. */
2854 gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
2855 var = return_slot_addr;
2860 gcc_assert (TREE_CODE (var) != SSA_NAME);
2861 TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result);
2863 if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2864 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2865 && !DECL_GIMPLE_REG_P (result)
2867 DECL_GIMPLE_REG_P (var) = 0;
2872 /* All types requiring non-trivial constructors should have been handled. */
2873 gcc_assert (!TREE_ADDRESSABLE (callee_type));
2875 /* Attempt to avoid creating a new temporary variable. */
2877 && TREE_CODE (modify_dest) != SSA_NAME)
2879 bool use_it = false;
2881 /* We can't use MODIFY_DEST if there's type promotion involved. */
2882 if (!useless_type_conversion_p (callee_type, caller_type))
2885 /* ??? If we're assigning to a variable sized type, then we must
2886 reuse the destination variable, because we've no good way to
2887 create variable sized temporaries at this point. */
2888 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
2891 /* If the callee cannot possibly modify MODIFY_DEST, then we can
2892 reuse it as the result of the call directly. Don't do this if
2893 it would promote MODIFY_DEST to addressable. */
2894 else if (TREE_ADDRESSABLE (result))
2898 tree base_m = get_base_address (modify_dest);
2900 /* If the base isn't a decl, then it's a pointer, and we don't
2901 know where that's going to go. */
2902 if (!DECL_P (base_m))
2904 else if (is_global_var (base_m))
2906 else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2907 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2908 && !DECL_GIMPLE_REG_P (result)
2909 && DECL_GIMPLE_REG_P (base_m))
2911 else if (!TREE_ADDRESSABLE (base_m))
2923 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
2925 var = copy_result_decl_to_var (result, id);
2926 if (gimple_in_ssa_p (cfun))
2927 add_referenced_var (var);
2929 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
2931 /* Do not have the rest of GCC warn about this variable as it should
2932 not be visible to the user. */
2933 TREE_NO_WARNING (var) = 1;
2935 declare_inline_vars (id->block, var);
2937 /* Build the use expr. If the return type of the function was
2938 promoted, convert it back to the expected type. */
2940 if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
2942 /* If we can match up types by promotion/demotion do so. */
2943 if (fold_convertible_p (caller_type, var))
2944 use = fold_convert (caller_type, var);
2947 /* ??? For valid programs we should not end up here.
2948 Still if we end up with truly mismatched types here, fall back
2949 to using a MEM_REF to not leak invalid GIMPLE to the following
2951 /* Prevent var from being written into SSA form. */
2952 if (TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
2953 || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE)
2954 DECL_GIMPLE_REG_P (var) = false;
2955 else if (is_gimple_reg_type (TREE_TYPE (var)))
2956 TREE_ADDRESSABLE (var) = true;
2957 use = fold_build2 (MEM_REF, caller_type,
2958 build_fold_addr_expr (var),
2959 build_int_cst (ptr_type_node, 0));
2963 STRIP_USELESS_TYPE_CONVERSION (use);
2965 if (DECL_BY_REFERENCE (result))
2967 TREE_ADDRESSABLE (var) = 1;
2968 var = build_fold_addr_expr (var);
2972 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
2973 way, when the RESULT_DECL is encountered, it will be
2974 automatically replaced by the VAR_DECL.
2976 When returning by reference, ensure that RESULT_DECL remaps to
2978 if (DECL_BY_REFERENCE (result)
2979 && !is_gimple_val (var))
2981 tree temp = create_tmp_var (TREE_TYPE (result), "retvalptr");
2982 if (gimple_in_ssa_p (id->src_cfun))
2983 add_referenced_var (temp);
2984 insert_decl_map (id, result, temp);
2985 /* When RESULT_DECL is in SSA form, we need to use it's default_def
2987 if (gimple_in_ssa_p (id->src_cfun) && gimple_default_def (id->src_cfun, result))
2988 temp = remap_ssa_name (gimple_default_def (id->src_cfun, result), id);
2989 insert_init_stmt (id, entry_bb, gimple_build_assign (temp, var));
2992 insert_decl_map (id, result, var);
2994 /* Remember this so we can ignore it in remap_decls. */
3000 /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference
3001 to a local label. */
3004 has_label_address_in_static_1 (tree *nodep, int *walk_subtrees, void *fnp)
3007 tree fn = (tree) fnp;
3009 if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
3018 /* Determine if the function can be copied. If so return NULL. If
3019 not return a string describng the reason for failure. */
3022 copy_forbidden (struct function *fun, tree fndecl)
3024 const char *reason = fun->cannot_be_copied_reason;
3028 /* Only examine the function once. */
3029 if (fun->cannot_be_copied_set)
3032 /* We cannot copy a function that receives a non-local goto
3033 because we cannot remap the destination label used in the
3034 function that is performing the non-local goto. */
3035 /* ??? Actually, this should be possible, if we work at it.
3036 No doubt there's just a handful of places that simply
3037 assume it doesn't happen and don't substitute properly. */
3038 if (fun->has_nonlocal_label)
3040 reason = G_("function %q+F can never be copied "
3041 "because it receives a non-local goto");
3045 FOR_EACH_LOCAL_DECL (fun, ix, decl)
3046 if (TREE_CODE (decl) == VAR_DECL
3047 && TREE_STATIC (decl)
3048 && !DECL_EXTERNAL (decl)
3049 && DECL_INITIAL (decl)
3050 && walk_tree_without_duplicates (&DECL_INITIAL (decl),
3051 has_label_address_in_static_1,
3054 reason = G_("function %q+F can never be copied because it saves "
3055 "address of local label in a static variable");
3060 fun->cannot_be_copied_reason = reason;
3061 fun->cannot_be_copied_set = true;
3066 static const char *inline_forbidden_reason;
3068 /* A callback for walk_gimple_seq to handle statements. Returns non-null
3069 iff a function can not be inlined. Also sets the reason why. */
3072 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
3073 struct walk_stmt_info *wip)
3075 tree fn = (tree) wip->info;
3077 gimple stmt = gsi_stmt (*gsi);
3079 switch (gimple_code (stmt))
3082 /* Refuse to inline alloca call unless user explicitly forced so as
3083 this may change program's memory overhead drastically when the
3084 function using alloca is called in loop. In GCC present in
3085 SPEC2000 inlining into schedule_block cause it to require 2GB of
3086 RAM instead of 256MB. Don't do so for alloca calls emitted for
3087 VLA objects as those can't cause unbounded growth (they're always
3088 wrapped inside stack_save/stack_restore regions. */
3089 if (gimple_alloca_call_p (stmt)
3090 && !gimple_call_alloca_for_var_p (stmt)
3091 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
3093 inline_forbidden_reason
3094 = G_("function %q+F can never be inlined because it uses "
3095 "alloca (override using the always_inline attribute)");
3096 *handled_ops_p = true;
3100 t = gimple_call_fndecl (stmt);
3104 /* We cannot inline functions that call setjmp. */
3105 if (setjmp_call_p (t))
3107 inline_forbidden_reason
3108 = G_("function %q+F can never be inlined because it uses setjmp");
3109 *handled_ops_p = true;
3113 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
3114 switch (DECL_FUNCTION_CODE (t))
3116 /* We cannot inline functions that take a variable number of
3118 case BUILT_IN_VA_START:
3119 case BUILT_IN_NEXT_ARG:
3120 case BUILT_IN_VA_END:
3121 inline_forbidden_reason
3122 = G_("function %q+F can never be inlined because it "
3123 "uses variable argument lists");
3124 *handled_ops_p = true;
3127 case BUILT_IN_LONGJMP:
3128 /* We can't inline functions that call __builtin_longjmp at
3129 all. The non-local goto machinery really requires the
3130 destination be in a different function. If we allow the
3131 function calling __builtin_longjmp to be inlined into the
3132 function calling __builtin_setjmp, Things will Go Awry. */
3133 inline_forbidden_reason
3134 = G_("function %q+F can never be inlined because "
3135 "it uses setjmp-longjmp exception handling");
3136 *handled_ops_p = true;
3139 case BUILT_IN_NONLOCAL_GOTO:
3141 inline_forbidden_reason
3142 = G_("function %q+F can never be inlined because "
3143 "it uses non-local goto");
3144 *handled_ops_p = true;
3147 case BUILT_IN_RETURN:
3148 case BUILT_IN_APPLY_ARGS:
3149 /* If a __builtin_apply_args caller would be inlined,
3150 it would be saving arguments of the function it has
3151 been inlined into. Similarly __builtin_return would
3152 return from the function the inline has been inlined into. */
3153 inline_forbidden_reason
3154 = G_("function %q+F can never be inlined because "
3155 "it uses __builtin_return or __builtin_apply_args");
3156 *handled_ops_p = true;
3165 t = gimple_goto_dest (stmt);
3167 /* We will not inline a function which uses computed goto. The
3168 addresses of its local labels, which may be tucked into
3169 global storage, are of course not constant across
3170 instantiations, which causes unexpected behavior. */
3171 if (TREE_CODE (t) != LABEL_DECL)
3173 inline_forbidden_reason
3174 = G_("function %q+F can never be inlined "
3175 "because it contains a computed goto");
3176 *handled_ops_p = true;
3185 *handled_ops_p = false;
3189 /* Return true if FNDECL is a function that cannot be inlined into
3193 inline_forbidden_p (tree fndecl)
3195 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
3196 struct walk_stmt_info wi;
3197 struct pointer_set_t *visited_nodes;
3199 bool forbidden_p = false;
3201 /* First check for shared reasons not to copy the code. */
3202 inline_forbidden_reason = copy_forbidden (fun, fndecl);
3203 if (inline_forbidden_reason != NULL)
3206 /* Next, walk the statements of the function looking for
3207 constraucts we can't handle, or are non-optimal for inlining. */
3208 visited_nodes = pointer_set_create ();
3209 memset (&wi, 0, sizeof (wi));
3210 wi.info = (void *) fndecl;
3211 wi.pset = visited_nodes;
3213 FOR_EACH_BB_FN (bb, fun)
3216 gimple_seq seq = bb_seq (bb);
3217 ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, NULL, &wi);
3218 forbidden_p = (ret != NULL);
3223 pointer_set_destroy (visited_nodes);
3227 /* Returns nonzero if FN is a function that does not have any
3228 fundamental inline blocking properties. */
3231 tree_inlinable_function_p (tree fn)
3233 bool inlinable = true;
3237 /* If we've already decided this function shouldn't be inlined,
3238 there's no need to check again. */
3239 if (DECL_UNINLINABLE (fn))
3242 /* We only warn for functions declared `inline' by the user. */
3243 do_warning = (warn_inline
3244 && DECL_DECLARED_INLINE_P (fn)
3245 && !DECL_NO_INLINE_WARNING_P (fn)
3246 && !DECL_IN_SYSTEM_HEADER (fn));
3248 always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
3251 && always_inline == NULL)
3254 warning (OPT_Winline, "function %q+F can never be inlined because it "
3255 "is suppressed using -fno-inline", fn);
3259 else if (!function_attribute_inlinable_p (fn))
3262 warning (OPT_Winline, "function %q+F can never be inlined because it "
3263 "uses attributes conflicting with inlining", fn);
3267 else if (inline_forbidden_p (fn))
3269 /* See if we should warn about uninlinable functions. Previously,
3270 some of these warnings would be issued while trying to expand
3271 the function inline, but that would cause multiple warnings
3272 about functions that would for example call alloca. But since
3273 this a property of the function, just one warning is enough.
3274 As a bonus we can now give more details about the reason why a
3275 function is not inlinable. */
3277 error (inline_forbidden_reason, fn);
3278 else if (do_warning)
3279 warning (OPT_Winline, inline_forbidden_reason, fn);
3284 /* Squirrel away the result so that we don't have to check again. */
3285 DECL_UNINLINABLE (fn) = !inlinable;
3290 /* Estimate the cost of a memory move. Use machine dependent
3291 word size and take possible memcpy call into account. */
3294 estimate_move_cost (tree type)
3298 gcc_assert (!VOID_TYPE_P (type));
3300 if (TREE_CODE (type) == VECTOR_TYPE)
3302 enum machine_mode inner = TYPE_MODE (TREE_TYPE (type));
3303 enum machine_mode simd
3304 = targetm.vectorize.preferred_simd_mode (inner);
3305 int simd_mode_size = GET_MODE_SIZE (simd);
3306 return ((GET_MODE_SIZE (TYPE_MODE (type)) + simd_mode_size - 1)
3310 size = int_size_in_bytes (type);
3312 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO (!optimize_size))
3313 /* Cost of a memcpy call, 3 arguments and the call. */
3316 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
3319 /* Returns cost of operation CODE, according to WEIGHTS */
3322 estimate_operator_cost (enum tree_code code, eni_weights *weights,
3323 tree op1 ATTRIBUTE_UNUSED, tree op2)
3327 /* These are "free" conversions, or their presumed cost
3328 is folded into other operations. */
3333 case VIEW_CONVERT_EXPR:
3336 /* Assign cost of 1 to usual operations.
3337 ??? We may consider mapping RTL costs to this. */
3343 case POINTER_PLUS_EXPR:
3348 case ADDR_SPACE_CONVERT_EXPR:
3349 case FIXED_CONVERT_EXPR:
3350 case FIX_TRUNC_EXPR:
3362 case VEC_LSHIFT_EXPR:
3363 case VEC_RSHIFT_EXPR:
3370 case TRUTH_ANDIF_EXPR:
3371 case TRUTH_ORIF_EXPR:
3372 case TRUTH_AND_EXPR:
3374 case TRUTH_XOR_EXPR:
3375 case TRUTH_NOT_EXPR:
3384 case UNORDERED_EXPR:
3395 case PREDECREMENT_EXPR:
3396 case PREINCREMENT_EXPR:
3397 case POSTDECREMENT_EXPR:
3398 case POSTINCREMENT_EXPR:
3400 case REALIGN_LOAD_EXPR:
3402 case REDUC_MAX_EXPR:
3403 case REDUC_MIN_EXPR:
3404 case REDUC_PLUS_EXPR:
3405 case WIDEN_SUM_EXPR:
3406 case WIDEN_MULT_EXPR:
3408 case WIDEN_MULT_PLUS_EXPR:
3409 case WIDEN_MULT_MINUS_EXPR:
3410 case WIDEN_LSHIFT_EXPR:
3412 case VEC_WIDEN_MULT_HI_EXPR:
3413 case VEC_WIDEN_MULT_LO_EXPR:
3414 case VEC_UNPACK_HI_EXPR:
3415 case VEC_UNPACK_LO_EXPR:
3416 case VEC_UNPACK_FLOAT_HI_EXPR:
3417 case VEC_UNPACK_FLOAT_LO_EXPR:
3418 case VEC_PACK_TRUNC_EXPR:
3419 case VEC_PACK_SAT_EXPR:
3420 case VEC_PACK_FIX_TRUNC_EXPR:
3421 case VEC_WIDEN_LSHIFT_HI_EXPR:
3422 case VEC_WIDEN_LSHIFT_LO_EXPR:
3426 /* Few special cases of expensive operations. This is useful
3427 to avoid inlining on functions having too many of these. */
3428 case TRUNC_DIV_EXPR:
3430 case FLOOR_DIV_EXPR:
3431 case ROUND_DIV_EXPR:
3432 case EXACT_DIV_EXPR:
3433 case TRUNC_MOD_EXPR:
3435 case FLOOR_MOD_EXPR:
3436 case ROUND_MOD_EXPR:
3438 if (TREE_CODE (op2) != INTEGER_CST)
3439 return weights->div_mod_cost;
3443 /* We expect a copy assignment with no operator. */
3444 gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS);
3450 /* Estimate number of instructions that will be created by expanding
3451 the statements in the statement sequence STMTS.
3452 WEIGHTS contains weights attributed to various constructs. */
3455 int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights)
3458 gimple_stmt_iterator gsi;
3461 for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
3462 cost += estimate_num_insns (gsi_stmt (gsi), weights);
3468 /* Estimate number of instructions that will be created by expanding STMT.
3469 WEIGHTS contains weights attributed to various constructs. */
3472 estimate_num_insns (gimple stmt, eni_weights *weights)
3475 enum gimple_code code = gimple_code (stmt);
3482 /* Try to estimate the cost of assignments. We have three cases to
3484 1) Simple assignments to registers;
3485 2) Stores to things that must live in memory. This includes
3486 "normal" stores to scalars, but also assignments of large
3487 structures, or constructors of big arrays;
3489 Let us look at the first two cases, assuming we have "a = b + C":
3490 <GIMPLE_ASSIGN <var_decl "a">
3491 <plus_expr <var_decl "b"> <constant C>>
3492 If "a" is a GIMPLE register, the assignment to it is free on almost
3493 any target, because "a" usually ends up in a real register. Hence
3494 the only cost of this expression comes from the PLUS_EXPR, and we
3495 can ignore the GIMPLE_ASSIGN.
3496 If "a" is not a GIMPLE register, the assignment to "a" will most
3497 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
3498 of moving something into "a", which we compute using the function
3499 estimate_move_cost. */
3500 if (gimple_clobber_p (stmt))
3501 return 0; /* ={v} {CLOBBER} stmt expands to nothing. */
3503 lhs = gimple_assign_lhs (stmt);
3504 rhs = gimple_assign_rhs1 (stmt);
3506 if (is_gimple_reg (lhs))
3509 cost = estimate_move_cost (TREE_TYPE (lhs));
3511 if (!is_gimple_reg (rhs) && !is_gimple_min_invariant (rhs))
3512 cost += estimate_move_cost (TREE_TYPE (rhs));
3514 cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights,
3515 gimple_assign_rhs1 (stmt),
3516 get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
3517 == GIMPLE_BINARY_RHS
3518 ? gimple_assign_rhs2 (stmt) : NULL);
3522 cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights,
3523 gimple_op (stmt, 0),
3524 gimple_op (stmt, 1));
3528 /* Take into account cost of the switch + guess 2 conditional jumps for
3531 TODO: once the switch expansion logic is sufficiently separated, we can
3532 do better job on estimating cost of the switch. */
3533 if (weights->time_based)
3534 cost = floor_log2 (gimple_switch_num_labels (stmt)) * 2;
3536 cost = gimple_switch_num_labels (stmt) * 2;
3541 tree decl = gimple_call_fndecl (stmt);
3542 struct cgraph_node *node = NULL;
3544 /* Do not special case builtins where we see the body.
3545 This just confuse inliner. */
3546 if (!decl || !(node = cgraph_get_node (decl)) || node->analyzed)
3548 /* For buitins that are likely expanded to nothing or
3549 inlined do not account operand costs. */
3550 else if (is_simple_builtin (decl))
3552 else if (is_inexpensive_builtin (decl))
3553 return weights->target_builtin_call_cost;
3554 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
3556 /* We canonicalize x * x to pow (x, 2.0) with -ffast-math, so
3557 specialize the cheap expansion we do here.
3558 ??? This asks for a more general solution. */
3559 switch (DECL_FUNCTION_CODE (decl))
3564 if (TREE_CODE (gimple_call_arg (stmt, 1)) == REAL_CST
3565 && REAL_VALUES_EQUAL
3566 (TREE_REAL_CST (gimple_call_arg (stmt, 1)), dconst2))
3567 return estimate_operator_cost (MULT_EXPR, weights,
3568 gimple_call_arg (stmt, 0),
3569 gimple_call_arg (stmt, 0));
3577 cost = node ? weights->call_cost : weights->indirect_call_cost;
3578 if (gimple_call_lhs (stmt))
3579 cost += estimate_move_cost (TREE_TYPE (gimple_call_lhs (stmt)));
3580 for (i = 0; i < gimple_call_num_args (stmt); i++)
3582 tree arg = gimple_call_arg (stmt, i);
3583 cost += estimate_move_cost (TREE_TYPE (arg));
3589 return weights->return_cost;
3595 case GIMPLE_PREDICT:
3600 return asm_str_count (gimple_asm_string (stmt));
3603 /* This is either going to be an external function call with one
3604 argument, or two register copy statements plus a goto. */
3607 case GIMPLE_EH_DISPATCH:
3608 /* ??? This is going to turn into a switch statement. Ideally
3609 we'd have a look at the eh region and estimate the number of
3614 return estimate_num_insns_seq (gimple_bind_body (stmt), weights);
3616 case GIMPLE_EH_FILTER:
3617 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights);
3620 return estimate_num_insns_seq (gimple_catch_handler (stmt), weights);
3623 return (estimate_num_insns_seq (gimple_try_eval (stmt), weights)
3624 + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights));
3626 /* OpenMP directives are generally very expensive. */
3628 case GIMPLE_OMP_RETURN:
3629 case GIMPLE_OMP_SECTIONS_SWITCH:
3630 case GIMPLE_OMP_ATOMIC_STORE:
3631 case GIMPLE_OMP_CONTINUE:
3632 /* ...except these, which are cheap. */
3635 case GIMPLE_OMP_ATOMIC_LOAD:
3636 return weights->omp_cost;
3638 case GIMPLE_OMP_FOR:
3639 return (weights->omp_cost
3640 + estimate_num_insns_seq (gimple_omp_body (stmt), weights)
3641 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights));
3643 case GIMPLE_OMP_PARALLEL:
3644 case GIMPLE_OMP_TASK:
3645 case GIMPLE_OMP_CRITICAL:
3646 case GIMPLE_OMP_MASTER:
3647 case GIMPLE_OMP_ORDERED:
3648 case GIMPLE_OMP_SECTION:
3649 case GIMPLE_OMP_SECTIONS:
3650 case GIMPLE_OMP_SINGLE:
3651 return (weights->omp_cost
3652 + estimate_num_insns_seq (gimple_omp_body (stmt), weights));
3654 case GIMPLE_TRANSACTION:
3655 return (weights->tm_cost
3656 + estimate_num_insns_seq (gimple_transaction_body (stmt),
3666 /* Estimate number of instructions that will be created by expanding
3667 function FNDECL. WEIGHTS contains weights attributed to various
3671 estimate_num_insns_fn (tree fndecl, eni_weights *weights)
3673 struct function *my_function = DECL_STRUCT_FUNCTION (fndecl);
3674 gimple_stmt_iterator bsi;
3678 gcc_assert (my_function && my_function->cfg);
3679 FOR_EACH_BB_FN (bb, my_function)
3681 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
3682 n += estimate_num_insns (gsi_stmt (bsi), weights);
3689 /* Initializes weights used by estimate_num_insns. */
3692 init_inline_once (void)
3694 eni_size_weights.call_cost = 1;
3695 eni_size_weights.indirect_call_cost = 3;
3696 eni_size_weights.target_builtin_call_cost = 1;
3697 eni_size_weights.div_mod_cost = 1;
3698 eni_size_weights.omp_cost = 40;
3699 eni_size_weights.tm_cost = 10;
3700 eni_size_weights.time_based = false;
3701 eni_size_weights.return_cost = 1;
3703 /* Estimating time for call is difficult, since we have no idea what the
3704 called function does. In the current uses of eni_time_weights,
3705 underestimating the cost does less harm than overestimating it, so
3706 we choose a rather small value here. */
3707 eni_time_weights.call_cost = 10;
3708 eni_time_weights.indirect_call_cost = 15;
3709 eni_time_weights.target_builtin_call_cost = 1;
3710 eni_time_weights.div_mod_cost = 10;
3711 eni_time_weights.omp_cost = 40;
3712 eni_time_weights.tm_cost = 40;
3713 eni_time_weights.time_based = true;
3714 eni_time_weights.return_cost = 2;
3717 /* Estimate the number of instructions in a gimple_seq. */
3720 count_insns_seq (gimple_seq seq, eni_weights *weights)
3722 gimple_stmt_iterator gsi;
3724 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
3725 n += estimate_num_insns (gsi_stmt (gsi), weights);
3731 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
3734 prepend_lexical_block (tree current_block, tree new_block)
3736 BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (current_block);
3737 BLOCK_SUBBLOCKS (current_block) = new_block;
3738 BLOCK_SUPERCONTEXT (new_block) = current_block;
3741 /* Add local variables from CALLEE to CALLER. */
3744 add_local_variables (struct function *callee, struct function *caller,
3745 copy_body_data *id, bool check_var_ann)
3750 FOR_EACH_LOCAL_DECL (callee, ix, var)
3751 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3754 || (var_ann (var) && add_referenced_var (var)))
3755 add_local_decl (caller, var);
3757 else if (!can_be_nonlocal (var, id))
3759 tree new_var = remap_decl (var, id);
3761 /* Remap debug-expressions. */
3762 if (TREE_CODE (new_var) == VAR_DECL
3763 && DECL_DEBUG_EXPR_IS_FROM (new_var)
3766 tree tem = DECL_DEBUG_EXPR (var);
3767 bool old_regimplify = id->regimplify;
3768 id->remapping_type_depth++;
3769 walk_tree (&tem, copy_tree_body_r, id, NULL);
3770 id->remapping_type_depth--;
3771 id->regimplify = old_regimplify;
3772 SET_DECL_DEBUG_EXPR (new_var, tem);
3774 add_local_decl (caller, new_var);
3778 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
3781 expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
3785 struct pointer_map_t *st, *dst;
3788 location_t saved_location;
3789 struct cgraph_edge *cg_edge;
3790 cgraph_inline_failed_t reason;
3791 basic_block return_block;
3793 gimple_stmt_iterator gsi, stmt_gsi;
3794 bool successfully_inlined = FALSE;
3795 bool purge_dead_abnormal_edges;
3797 /* Set input_location here so we get the right instantiation context
3798 if we call instantiate_decl from inlinable_function_p. */
3799 saved_location = input_location;
3800 if (gimple_has_location (stmt))
3801 input_location = gimple_location (stmt);
3803 /* From here on, we're only interested in CALL_EXPRs. */
3804 if (gimple_code (stmt) != GIMPLE_CALL)
3807 cg_edge = cgraph_edge (id->dst_node, stmt);
3808 gcc_checking_assert (cg_edge);
3809 /* First, see if we can figure out what function is being called.
3810 If we cannot, then there is no hope of inlining the function. */
3811 if (cg_edge->indirect_unknown_callee)
3813 fn = cg_edge->callee->decl;
3814 gcc_checking_assert (fn);
3816 /* If FN is a declaration of a function in a nested scope that was
3817 globally declared inline, we don't set its DECL_INITIAL.
3818 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3819 C++ front-end uses it for cdtors to refer to their internal
3820 declarations, that are not real functions. Fortunately those
3821 don't have trees to be saved, so we can tell by checking their
3823 if (!DECL_INITIAL (fn)
3824 && DECL_ABSTRACT_ORIGIN (fn)
3825 && gimple_has_body_p (DECL_ABSTRACT_ORIGIN (fn)))
3826 fn = DECL_ABSTRACT_ORIGIN (fn);
3828 /* Don't try to inline functions that are not well-suited to inlining. */
3829 if (!cgraph_inline_p (cg_edge, &reason))
3831 /* If this call was originally indirect, we do not want to emit any
3832 inlining related warnings or sorry messages because there are no
3833 guarantees regarding those. */
3834 if (cg_edge->indirect_inlining_edge)
3837 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
3838 /* Avoid warnings during early inline pass. */
3839 && cgraph_global_info_ready
3840 /* PR 20090218-1_0.c. Body can be provided by another module. */
3841 && (reason != CIF_BODY_NOT_AVAILABLE || !flag_generate_lto))
3843 error ("inlining failed in call to always_inline %q+F: %s", fn,
3844 cgraph_inline_failed_string (reason));
3845 error ("called from here");
3847 else if (warn_inline
3848 && DECL_DECLARED_INLINE_P (fn)
3849 && !DECL_NO_INLINE_WARNING_P (fn)
3850 && !DECL_IN_SYSTEM_HEADER (fn)
3851 && reason != CIF_UNSPECIFIED
3852 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
3853 /* Do not warn about not inlined recursive calls. */
3854 && !cgraph_edge_recursive_p (cg_edge)
3855 /* Avoid warnings during early inline pass. */
3856 && cgraph_global_info_ready)
3858 warning (OPT_Winline, "inlining failed in call to %q+F: %s",
3859 fn, _(cgraph_inline_failed_string (reason)));
3860 warning (OPT_Winline, "called from here");
3864 fn = cg_edge->callee->decl;
3866 #ifdef ENABLE_CHECKING
3867 if (cg_edge->callee->decl != id->dst_node->decl)
3868 verify_cgraph_node (cg_edge->callee);
3871 /* We will be inlining this callee. */
3872 id->eh_lp_nr = lookup_stmt_eh_lp (stmt);
3874 /* Update the callers EH personality. */
3875 if (DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl))
3876 DECL_FUNCTION_PERSONALITY (cg_edge->caller->decl)
3877 = DECL_FUNCTION_PERSONALITY (cg_edge->callee->decl);
3879 /* Split the block holding the GIMPLE_CALL. */
3880 e = split_block (bb, stmt);
3882 return_block = e->dest;
3885 /* split_block splits after the statement; work around this by
3886 moving the call into the second block manually. Not pretty,
3887 but seems easier than doing the CFG manipulation by hand
3888 when the GIMPLE_CALL is in the last statement of BB. */
3889 stmt_gsi = gsi_last_bb (bb);
3890 gsi_remove (&stmt_gsi, false);
3892 /* If the GIMPLE_CALL was in the last statement of BB, it may have
3893 been the source of abnormal edges. In this case, schedule
3894 the removal of dead abnormal edges. */
3895 gsi = gsi_start_bb (return_block);
3896 if (gsi_end_p (gsi))
3898 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
3899 purge_dead_abnormal_edges = true;
3903 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
3904 purge_dead_abnormal_edges = false;
3907 stmt_gsi = gsi_start_bb (return_block);
3909 /* Build a block containing code to initialize the arguments, the
3910 actual inline expansion of the body, and a label for the return
3911 statements within the function to jump to. The type of the
3912 statement expression is the return type of the function call. */
3913 id->block = make_node (BLOCK);
3914 BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
3915 BLOCK_SOURCE_LOCATION (id->block) = input_location;
3916 prepend_lexical_block (gimple_block (stmt), id->block);
3918 /* Local declarations will be replaced by their equivalents in this
3921 id->decl_map = pointer_map_create ();
3922 dst = id->debug_map;
3923 id->debug_map = NULL;
3925 /* Record the function we are about to inline. */
3927 id->src_node = cg_edge->callee;
3928 id->src_cfun = DECL_STRUCT_FUNCTION (fn);
3929 id->gimple_call = stmt;
3931 gcc_assert (!id->src_cfun->after_inlining);
3934 if (lookup_attribute ("cold", DECL_ATTRIBUTES (fn)))
3936 gimple_stmt_iterator si = gsi_last_bb (bb);
3937 gsi_insert_after (&si, gimple_build_predict (PRED_COLD_FUNCTION,
3941 initialize_inlined_parameters (id, stmt, fn, bb);
3943 if (DECL_INITIAL (fn))
3944 prepend_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
3946 /* Return statements in the function body will be replaced by jumps
3947 to the RET_LABEL. */
3948 gcc_assert (DECL_INITIAL (fn));
3949 gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
3951 /* Find the LHS to which the result of this call is assigned. */
3953 if (gimple_call_lhs (stmt))
3955 modify_dest = gimple_call_lhs (stmt);
3957 /* The function which we are inlining might not return a value,
3958 in which case we should issue a warning that the function
3959 does not return a value. In that case the optimizers will
3960 see that the variable to which the value is assigned was not
3961 initialized. We do not want to issue a warning about that
3962 uninitialized variable. */
3963 if (DECL_P (modify_dest))
3964 TREE_NO_WARNING (modify_dest) = 1;
3966 if (gimple_call_return_slot_opt_p (stmt))
3968 return_slot = modify_dest;
3975 /* If we are inlining a call to the C++ operator new, we don't want
3976 to use type based alias analysis on the return value. Otherwise
3977 we may get confused if the compiler sees that the inlined new
3978 function returns a pointer which was just deleted. See bug
3980 if (DECL_IS_OPERATOR_NEW (fn))
3986 /* Declare the return variable for the function. */
3987 use_retvar = declare_return_variable (id, return_slot, modify_dest, bb);
3989 /* Add local vars in this inlined callee to caller. */
3990 add_local_variables (id->src_cfun, cfun, id, true);
3992 if (dump_file && (dump_flags & TDF_DETAILS))
3994 fprintf (dump_file, "Inlining ");
3995 print_generic_expr (dump_file, id->src_fn, 0);
3996 fprintf (dump_file, " to ");
3997 print_generic_expr (dump_file, id->dst_fn, 0);
3998 fprintf (dump_file, " with frequency %i\n", cg_edge->frequency);
4001 /* This is it. Duplicate the callee body. Assume callee is
4002 pre-gimplified. Note that we must not alter the caller
4003 function in any way before this point, as this CALL_EXPR may be
4004 a self-referential call; if we're calling ourselves, we need to
4005 duplicate our body before altering anything. */
4006 copy_body (id, bb->count,
4007 cg_edge->frequency * REG_BR_PROB_BASE / CGRAPH_FREQ_BASE,
4008 bb, return_block, NULL, NULL);
4010 /* Reset the escaped solution. */
4011 if (cfun->gimple_df)
4012 pt_solution_reset (&cfun->gimple_df->escaped);
4017 pointer_map_destroy (id->debug_map);
4018 id->debug_map = dst;
4020 pointer_map_destroy (id->decl_map);
4023 /* Unlink the calls virtual operands before replacing it. */
4024 unlink_stmt_vdef (stmt);
4026 /* If the inlined function returns a result that we care about,
4027 substitute the GIMPLE_CALL with an assignment of the return
4028 variable to the LHS of the call. That is, if STMT was
4029 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
4030 if (use_retvar && gimple_call_lhs (stmt))
4032 gimple old_stmt = stmt;
4033 stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar);
4034 gsi_replace (&stmt_gsi, stmt, false);
4035 if (gimple_in_ssa_p (cfun))
4036 mark_symbols_for_renaming (stmt);
4037 maybe_clean_or_replace_eh_stmt (old_stmt, stmt);
4041 /* Handle the case of inlining a function with no return
4042 statement, which causes the return value to become undefined. */
4043 if (gimple_call_lhs (stmt)
4044 && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME)
4046 tree name = gimple_call_lhs (stmt);
4047 tree var = SSA_NAME_VAR (name);
4048 tree def = gimple_default_def (cfun, var);
4052 /* If the variable is used undefined, make this name
4053 undefined via a move. */
4054 stmt = gimple_build_assign (gimple_call_lhs (stmt), def);
4055 gsi_replace (&stmt_gsi, stmt, true);
4059 /* Otherwise make this variable undefined. */
4060 gsi_remove (&stmt_gsi, true);
4061 set_default_def (var, name);
4062 SSA_NAME_DEF_STMT (name) = gimple_build_nop ();
4066 gsi_remove (&stmt_gsi, true);
4069 if (purge_dead_abnormal_edges)
4071 gimple_purge_dead_eh_edges (return_block);
4072 gimple_purge_dead_abnormal_call_edges (return_block);
4075 /* If the value of the new expression is ignored, that's OK. We
4076 don't warn about this for CALL_EXPRs, so we shouldn't warn about
4077 the equivalent inlined version either. */
4078 if (is_gimple_assign (stmt))
4080 gcc_assert (gimple_assign_single_p (stmt)
4081 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)));
4082 TREE_USED (gimple_assign_rhs1 (stmt)) = 1;
4085 /* Output the inlining info for this abstract function, since it has been
4086 inlined. If we don't do this now, we can lose the information about the
4087 variables in the function when the blocks get blown away as soon as we
4088 remove the cgraph node. */
4089 (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
4091 /* Update callgraph if needed. */
4092 cgraph_remove_node (cg_edge->callee);
4094 id->block = NULL_TREE;
4095 successfully_inlined = TRUE;
4098 input_location = saved_location;
4099 return successfully_inlined;
4102 /* Expand call statements reachable from STMT_P.
4103 We can only have CALL_EXPRs as the "toplevel" tree code or nested
4104 in a MODIFY_EXPR. */
4107 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
4109 gimple_stmt_iterator gsi;
4111 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4113 gimple stmt = gsi_stmt (gsi);
4115 if (is_gimple_call (stmt)
4116 && expand_call_inline (bb, stmt, id))
4124 /* Walk all basic blocks created after FIRST and try to fold every statement
4125 in the STATEMENTS pointer set. */
4128 fold_marked_statements (int first, struct pointer_set_t *statements)
4130 for (; first < n_basic_blocks; first++)
4131 if (BASIC_BLOCK (first))
4133 gimple_stmt_iterator gsi;
4135 for (gsi = gsi_start_bb (BASIC_BLOCK (first));
4138 if (pointer_set_contains (statements, gsi_stmt (gsi)))
4140 gimple old_stmt = gsi_stmt (gsi);
4141 tree old_decl = is_gimple_call (old_stmt) ? gimple_call_fndecl (old_stmt) : 0;
4143 if (old_decl && DECL_BUILT_IN (old_decl))
4145 /* Folding builtins can create multiple instructions,
4146 we need to look at all of them. */
4147 gimple_stmt_iterator i2 = gsi;
4149 if (fold_stmt (&gsi))
4152 /* If a builtin at the end of a bb folded into nothing,
4153 the following loop won't work. */
4154 if (gsi_end_p (gsi))
4156 cgraph_update_edges_for_call_stmt (old_stmt,
4161 i2 = gsi_start_bb (BASIC_BLOCK (first));
4166 new_stmt = gsi_stmt (i2);
4167 update_stmt (new_stmt);
4168 cgraph_update_edges_for_call_stmt (old_stmt, old_decl,
4171 if (new_stmt == gsi_stmt (gsi))
4173 /* It is okay to check only for the very last
4174 of these statements. If it is a throwing
4175 statement nothing will change. If it isn't
4176 this can remove EH edges. If that weren't
4177 correct then because some intermediate stmts
4178 throw, but not the last one. That would mean
4179 we'd have to split the block, which we can't
4180 here and we'd loose anyway. And as builtins
4181 probably never throw, this all
4183 if (maybe_clean_or_replace_eh_stmt (old_stmt,
4185 gimple_purge_dead_eh_edges (BASIC_BLOCK (first));
4192 else if (fold_stmt (&gsi))
4194 /* Re-read the statement from GSI as fold_stmt() may
4196 gimple new_stmt = gsi_stmt (gsi);
4197 update_stmt (new_stmt);
4199 if (is_gimple_call (old_stmt)
4200 || is_gimple_call (new_stmt))
4201 cgraph_update_edges_for_call_stmt (old_stmt, old_decl,
4204 if (maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt))
4205 gimple_purge_dead_eh_edges (BASIC_BLOCK (first));
4211 /* Return true if BB has at least one abnormal outgoing edge. */
4214 has_abnormal_outgoing_edge_p (basic_block bb)
4219 FOR_EACH_EDGE (e, ei, bb->succs)
4220 if (e->flags & EDGE_ABNORMAL)
4226 /* Expand calls to inline functions in the body of FN. */
4229 optimize_inline_calls (tree fn)
4233 int last = n_basic_blocks;
4234 struct gimplify_ctx gctx;
4235 bool inlined_p = false;
4238 memset (&id, 0, sizeof (id));
4240 id.src_node = id.dst_node = cgraph_get_node (fn);
4241 gcc_assert (id.dst_node->analyzed);
4243 /* Or any functions that aren't finished yet. */
4244 if (current_function_decl)
4245 id.dst_fn = current_function_decl;
4247 id.copy_decl = copy_decl_maybe_to_var;
4248 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
4249 id.transform_new_cfg = false;
4250 id.transform_return_to_modify = true;
4251 id.transform_lang_insert_block = NULL;
4252 id.statements_to_fold = pointer_set_create ();
4254 push_gimplify_context (&gctx);
4256 /* We make no attempts to keep dominance info up-to-date. */
4257 free_dominance_info (CDI_DOMINATORS);
4258 free_dominance_info (CDI_POST_DOMINATORS);
4260 /* Register specific gimple functions. */
4261 gimple_register_cfg_hooks ();
4263 /* Reach the trees by walking over the CFG, and note the
4264 enclosing basic-blocks in the call edges. */
4265 /* We walk the blocks going forward, because inlined function bodies
4266 will split id->current_basic_block, and the new blocks will
4267 follow it; we'll trudge through them, processing their CALL_EXPRs
4270 inlined_p |= gimple_expand_calls_inline (bb, &id);
4272 pop_gimplify_context (NULL);
4274 #ifdef ENABLE_CHECKING
4276 struct cgraph_edge *e;
4278 verify_cgraph_node (id.dst_node);
4280 /* Double check that we inlined everything we are supposed to inline. */
4281 for (e = id.dst_node->callees; e; e = e->next_callee)
4282 gcc_assert (e->inline_failed);
4286 /* Fold queued statements. */
4287 fold_marked_statements (last, id.statements_to_fold);
4288 pointer_set_destroy (id.statements_to_fold);
4290 gcc_assert (!id.debug_stmts);
4292 /* If we didn't inline into the function there is nothing to do. */
4296 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4299 delete_unreachable_blocks_update_callgraph (&id);
4300 #ifdef ENABLE_CHECKING
4301 verify_cgraph_node (id.dst_node);
4304 /* It would be nice to check SSA/CFG/statement consistency here, but it is
4305 not possible yet - the IPA passes might make various functions to not
4306 throw and they don't care to proactively update local EH info. This is
4307 done later in fixup_cfg pass that also execute the verification. */
4308 return (TODO_update_ssa
4310 | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
4311 | (gimple_in_ssa_p (cfun) ? TODO_update_address_taken : 0)
4312 | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
4315 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
4318 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
4320 enum tree_code code = TREE_CODE (*tp);
4321 enum tree_code_class cl = TREE_CODE_CLASS (code);
4323 /* We make copies of most nodes. */
4324 if (IS_EXPR_CODE_CLASS (cl)
4325 || code == TREE_LIST
4327 || code == TYPE_DECL
4328 || code == OMP_CLAUSE)
4330 /* Because the chain gets clobbered when we make a copy, we save it
4332 tree chain = NULL_TREE, new_tree;
4334 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
4335 chain = TREE_CHAIN (*tp);
4337 /* Copy the node. */
4338 new_tree = copy_node (*tp);
4340 /* Propagate mudflap marked-ness. */
4341 if (flag_mudflap && mf_marked_p (*tp))
4346 /* Now, restore the chain, if appropriate. That will cause
4347 walk_tree to walk into the chain as well. */
4348 if (code == PARM_DECL
4349 || code == TREE_LIST
4350 || code == OMP_CLAUSE)
4351 TREE_CHAIN (*tp) = chain;
4353 /* For now, we don't update BLOCKs when we make copies. So, we
4354 have to nullify all BIND_EXPRs. */
4355 if (TREE_CODE (*tp) == BIND_EXPR)
4356 BIND_EXPR_BLOCK (*tp) = NULL_TREE;
4358 else if (code == CONSTRUCTOR)
4360 /* CONSTRUCTOR nodes need special handling because
4361 we need to duplicate the vector of elements. */
4364 new_tree = copy_node (*tp);
4366 /* Propagate mudflap marked-ness. */
4367 if (flag_mudflap && mf_marked_p (*tp))
4370 CONSTRUCTOR_ELTS (new_tree) = VEC_copy (constructor_elt, gc,
4371 CONSTRUCTOR_ELTS (*tp));
4374 else if (code == STATEMENT_LIST)
4375 /* We used to just abort on STATEMENT_LIST, but we can run into them
4376 with statement-expressions (c++/40975). */
4377 copy_statement_list (tp);
4378 else if (TREE_CODE_CLASS (code) == tcc_type)
4380 else if (TREE_CODE_CLASS (code) == tcc_declaration)
4382 else if (TREE_CODE_CLASS (code) == tcc_constant)
4387 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
4388 information indicating to what new SAVE_EXPR this one should be mapped,
4389 use that one. Otherwise, create a new node and enter it in ST. FN is
4390 the function into which the copy will be placed. */
4393 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
4395 struct pointer_map_t *st = (struct pointer_map_t *) st_;
4399 /* See if we already encountered this SAVE_EXPR. */
4400 n = (tree *) pointer_map_contains (st, *tp);
4402 /* If we didn't already remap this SAVE_EXPR, do so now. */
4405 t = copy_node (*tp);
4407 /* Remember this SAVE_EXPR. */
4408 *pointer_map_insert (st, *tp) = t;
4409 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
4410 *pointer_map_insert (st, t) = t;
4414 /* We've already walked into this SAVE_EXPR; don't do it again. */
4419 /* Replace this SAVE_EXPR with the copy. */
4423 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
4424 copies the declaration and enters it in the splay_tree in DATA (which is
4425 really an `copy_body_data *'). */
4428 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
4431 copy_body_data *id = (copy_body_data *) data;
4433 /* Don't walk into types. */
4437 else if (TREE_CODE (*tp) == LABEL_EXPR)
4439 tree decl = TREE_OPERAND (*tp, 0);
4441 /* Copy the decl and remember the copy. */
4442 insert_decl_map (id, decl, id->copy_decl (decl, id));
4448 /* Perform any modifications to EXPR required when it is unsaved. Does
4449 not recurse into EXPR's subtrees. */
4452 unsave_expr_1 (tree expr)
4454 switch (TREE_CODE (expr))
4457 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4458 It's OK for this to happen if it was part of a subtree that
4459 isn't immediately expanded, such as operand 2 of another
4461 if (TREE_OPERAND (expr, 1))
4464 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
4465 TREE_OPERAND (expr, 3) = NULL_TREE;
4473 /* Called via walk_tree when an expression is unsaved. Using the
4474 splay_tree pointed to by ST (which is really a `splay_tree'),
4475 remaps all local declarations to appropriate replacements. */
4478 unsave_r (tree *tp, int *walk_subtrees, void *data)
4480 copy_body_data *id = (copy_body_data *) data;
4481 struct pointer_map_t *st = id->decl_map;
4484 /* Only a local declaration (variable or label). */
4485 if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
4486 || TREE_CODE (*tp) == LABEL_DECL)
4488 /* Lookup the declaration. */
4489 n = (tree *) pointer_map_contains (st, *tp);
4491 /* If it's there, remap it. */
4496 else if (TREE_CODE (*tp) == STATEMENT_LIST)
4498 else if (TREE_CODE (*tp) == BIND_EXPR)
4499 copy_bind_expr (tp, walk_subtrees, id);
4500 else if (TREE_CODE (*tp) == SAVE_EXPR
4501 || TREE_CODE (*tp) == TARGET_EXPR)
4502 remap_save_expr (tp, st, walk_subtrees);
4505 copy_tree_r (tp, walk_subtrees, NULL);
4507 /* Do whatever unsaving is required. */
4508 unsave_expr_1 (*tp);
4511 /* Keep iterating. */
4515 /* Copies everything in EXPR and replaces variables, labels
4516 and SAVE_EXPRs local to EXPR. */
4519 unsave_expr_now (tree expr)
4523 /* There's nothing to do for NULL_TREE. */
4528 memset (&id, 0, sizeof (id));
4529 id.src_fn = current_function_decl;
4530 id.dst_fn = current_function_decl;
4531 id.decl_map = pointer_map_create ();
4532 id.debug_map = NULL;
4534 id.copy_decl = copy_decl_no_change;
4535 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
4536 id.transform_new_cfg = false;
4537 id.transform_return_to_modify = false;
4538 id.transform_lang_insert_block = NULL;
4540 /* Walk the tree once to find local labels. */
4541 walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
4543 /* Walk the tree again, copying, remapping, and unsaving. */
4544 walk_tree (&expr, unsave_r, &id, NULL);
4547 pointer_map_destroy (id.decl_map);
4549 pointer_map_destroy (id.debug_map);
4554 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
4555 label, copies the declaration and enters it in the splay_tree in DATA (which
4556 is really a 'copy_body_data *'. */
4559 mark_local_labels_stmt (gimple_stmt_iterator *gsip,
4560 bool *handled_ops_p ATTRIBUTE_UNUSED,
4561 struct walk_stmt_info *wi)
4563 copy_body_data *id = (copy_body_data *) wi->info;
4564 gimple stmt = gsi_stmt (*gsip);
4566 if (gimple_code (stmt) == GIMPLE_LABEL)
4568 tree decl = gimple_label_label (stmt);
4570 /* Copy the decl and remember the copy. */
4571 insert_decl_map (id, decl, id->copy_decl (decl, id));
4578 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4579 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4580 remaps all local declarations to appropriate replacements in gimple
4584 replace_locals_op (tree *tp, int *walk_subtrees, void *data)
4586 struct walk_stmt_info *wi = (struct walk_stmt_info*) data;
4587 copy_body_data *id = (copy_body_data *) wi->info;
4588 struct pointer_map_t *st = id->decl_map;
4592 /* Only a local declaration (variable or label). */
4593 if ((TREE_CODE (expr) == VAR_DECL
4594 && !TREE_STATIC (expr))
4595 || TREE_CODE (expr) == LABEL_DECL)
4597 /* Lookup the declaration. */
4598 n = (tree *) pointer_map_contains (st, expr);
4600 /* If it's there, remap it. */
4605 else if (TREE_CODE (expr) == STATEMENT_LIST
4606 || TREE_CODE (expr) == BIND_EXPR
4607 || TREE_CODE (expr) == SAVE_EXPR)
4609 else if (TREE_CODE (expr) == TARGET_EXPR)
4611 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
4612 It's OK for this to happen if it was part of a subtree that
4613 isn't immediately expanded, such as operand 2 of another
4615 if (!TREE_OPERAND (expr, 1))
4617 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
4618 TREE_OPERAND (expr, 3) = NULL_TREE;
4622 /* Keep iterating. */
4627 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
4628 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
4629 remaps all local declarations to appropriate replacements in gimple
4633 replace_locals_stmt (gimple_stmt_iterator *gsip,
4634 bool *handled_ops_p ATTRIBUTE_UNUSED,
4635 struct walk_stmt_info *wi)
4637 copy_body_data *id = (copy_body_data *) wi->info;
4638 gimple stmt = gsi_stmt (*gsip);
4640 if (gimple_code (stmt) == GIMPLE_BIND)
4642 tree block = gimple_bind_block (stmt);
4646 remap_block (&block, id);
4647 gimple_bind_set_block (stmt, block);
4650 /* This will remap a lot of the same decls again, but this should be
4652 if (gimple_bind_vars (stmt))
4653 gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), NULL, id));
4656 /* Keep iterating. */
4661 /* Copies everything in SEQ and replaces variables and labels local to
4662 current_function_decl. */
4665 copy_gimple_seq_and_replace_locals (gimple_seq seq)
4668 struct walk_stmt_info wi;
4669 struct pointer_set_t *visited;
4672 /* There's nothing to do for NULL_TREE. */
4677 memset (&id, 0, sizeof (id));
4678 id.src_fn = current_function_decl;
4679 id.dst_fn = current_function_decl;
4680 id.decl_map = pointer_map_create ();
4681 id.debug_map = NULL;
4683 id.copy_decl = copy_decl_no_change;
4684 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
4685 id.transform_new_cfg = false;
4686 id.transform_return_to_modify = false;
4687 id.transform_lang_insert_block = NULL;
4689 /* Walk the tree once to find local labels. */
4690 memset (&wi, 0, sizeof (wi));
4691 visited = pointer_set_create ();
4694 walk_gimple_seq (seq, mark_local_labels_stmt, NULL, &wi);
4695 pointer_set_destroy (visited);
4697 copy = gimple_seq_copy (seq);
4699 /* Walk the copy, remapping decls. */
4700 memset (&wi, 0, sizeof (wi));
4702 walk_gimple_seq (copy, replace_locals_stmt, replace_locals_op, &wi);
4705 pointer_map_destroy (id.decl_map);
4707 pointer_map_destroy (id.debug_map);
4713 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
4716 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
4725 debug_find_tree (tree top, tree search)
4727 return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
4731 /* Declare the variables created by the inliner. Add all the variables in
4732 VARS to BIND_EXPR. */
4735 declare_inline_vars (tree block, tree vars)
4738 for (t = vars; t; t = DECL_CHAIN (t))
4740 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
4741 gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
4742 add_local_decl (cfun, t);
4746 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
4749 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
4750 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
4751 VAR_DECL translation. */
4754 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
4756 /* Don't generate debug information for the copy if we wouldn't have
4757 generated it for the copy either. */
4758 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
4759 DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
4761 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
4762 declaration inspired this copy. */
4763 DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
4765 /* The new variable/label has no RTL, yet. */
4766 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
4767 && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
4768 SET_DECL_RTL (copy, 0);
4770 /* These args would always appear unused, if not for this. */
4771 TREE_USED (copy) = 1;
4773 /* Set the context for the new declaration. */
4774 if (!DECL_CONTEXT (decl))
4775 /* Globals stay global. */
4777 else if (DECL_CONTEXT (decl) != id->src_fn)
4778 /* Things that weren't in the scope of the function we're inlining
4779 from aren't in the scope we're inlining to, either. */
4781 else if (TREE_STATIC (decl))
4782 /* Function-scoped static variables should stay in the original
4786 /* Ordinary automatic local variables are now in the scope of the
4788 DECL_CONTEXT (copy) = id->dst_fn;
4790 if (TREE_CODE (decl) == VAR_DECL
4791 /* C++ clones functions during parsing, before
4793 && gimple_referenced_vars (DECL_STRUCT_FUNCTION (id->src_fn))
4794 && referenced_var_lookup (DECL_STRUCT_FUNCTION (id->src_fn),
4796 add_referenced_var (copy);
4802 copy_decl_to_var (tree decl, copy_body_data *id)
4806 gcc_assert (TREE_CODE (decl) == PARM_DECL
4807 || TREE_CODE (decl) == RESULT_DECL);
4809 type = TREE_TYPE (decl);
4811 copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn),
4812 VAR_DECL, DECL_NAME (decl), type);
4813 if (DECL_PT_UID_SET_P (decl))
4814 SET_DECL_PT_UID (copy, DECL_PT_UID (decl));
4815 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
4816 TREE_READONLY (copy) = TREE_READONLY (decl);
4817 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
4818 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
4820 return copy_decl_for_dup_finish (id, decl, copy);
4823 /* Like copy_decl_to_var, but create a return slot object instead of a
4824 pointer variable for return by invisible reference. */
4827 copy_result_decl_to_var (tree decl, copy_body_data *id)
4831 gcc_assert (TREE_CODE (decl) == PARM_DECL
4832 || TREE_CODE (decl) == RESULT_DECL);
4834 type = TREE_TYPE (decl);
4835 if (DECL_BY_REFERENCE (decl))
4836 type = TREE_TYPE (type);
4838 copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn),
4839 VAR_DECL, DECL_NAME (decl), type);
4840 if (DECL_PT_UID_SET_P (decl))
4841 SET_DECL_PT_UID (copy, DECL_PT_UID (decl));
4842 TREE_READONLY (copy) = TREE_READONLY (decl);
4843 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
4844 if (!DECL_BY_REFERENCE (decl))
4846 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
4847 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
4850 return copy_decl_for_dup_finish (id, decl, copy);
4854 copy_decl_no_change (tree decl, copy_body_data *id)
4858 copy = copy_node (decl);
4860 /* The COPY is not abstract; it will be generated in DST_FN. */
4861 DECL_ABSTRACT (copy) = 0;
4862 lang_hooks.dup_lang_specific_decl (copy);
4864 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4865 been taken; it's for internal bookkeeping in expand_goto_internal. */
4866 if (TREE_CODE (copy) == LABEL_DECL)
4868 TREE_ADDRESSABLE (copy) = 0;
4869 LABEL_DECL_UID (copy) = -1;
4872 return copy_decl_for_dup_finish (id, decl, copy);
4876 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
4878 if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
4879 return copy_decl_to_var (decl, id);
4881 return copy_decl_no_change (decl, id);
4884 /* Return a copy of the function's argument tree. */
4886 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id,
4887 bitmap args_to_skip, tree *vars)
4890 tree new_parm = NULL;
4895 for (arg = orig_parm; arg; arg = DECL_CHAIN (arg), i++)
4896 if (!args_to_skip || !bitmap_bit_p (args_to_skip, i))
4898 tree new_tree = remap_decl (arg, id);
4899 if (TREE_CODE (new_tree) != PARM_DECL)
4900 new_tree = id->copy_decl (arg, id);
4901 lang_hooks.dup_lang_specific_decl (new_tree);
4903 parg = &DECL_CHAIN (new_tree);
4905 else if (!pointer_map_contains (id->decl_map, arg))
4907 /* Make an equivalent VAR_DECL. If the argument was used
4908 as temporary variable later in function, the uses will be
4909 replaced by local variable. */
4910 tree var = copy_decl_to_var (arg, id);
4911 add_referenced_var (var);
4912 insert_decl_map (id, arg, var);
4913 /* Declare this new variable. */
4914 DECL_CHAIN (var) = *vars;
4920 /* Return a copy of the function's static chain. */
4922 copy_static_chain (tree static_chain, copy_body_data * id)
4924 tree *chain_copy, *pvar;
4926 chain_copy = &static_chain;
4927 for (pvar = chain_copy; *pvar; pvar = &DECL_CHAIN (*pvar))
4929 tree new_tree = remap_decl (*pvar, id);
4930 lang_hooks.dup_lang_specific_decl (new_tree);
4931 DECL_CHAIN (new_tree) = DECL_CHAIN (*pvar);
4934 return static_chain;
4937 /* Return true if the function is allowed to be versioned.
4938 This is a guard for the versioning functionality. */
4941 tree_versionable_function_p (tree fndecl)
4943 return (!lookup_attribute ("noclone", DECL_ATTRIBUTES (fndecl))
4944 && copy_forbidden (DECL_STRUCT_FUNCTION (fndecl), fndecl) == NULL);
4947 /* Delete all unreachable basic blocks and update callgraph.
4948 Doing so is somewhat nontrivial because we need to update all clones and
4949 remove inline function that become unreachable. */
4952 delete_unreachable_blocks_update_callgraph (copy_body_data *id)
4954 bool changed = false;
4955 basic_block b, next_bb;
4957 find_unreachable_blocks ();
4959 /* Delete all unreachable basic blocks. */
4961 for (b = ENTRY_BLOCK_PTR->next_bb; b != EXIT_BLOCK_PTR; b = next_bb)
4963 next_bb = b->next_bb;
4965 if (!(b->flags & BB_REACHABLE))
4967 gimple_stmt_iterator bsi;
4969 for (bsi = gsi_start_bb (b); !gsi_end_p (bsi); gsi_next (&bsi))
4970 if (gimple_code (gsi_stmt (bsi)) == GIMPLE_CALL)
4972 struct cgraph_edge *e;
4973 struct cgraph_node *node;
4975 if ((e = cgraph_edge (id->dst_node, gsi_stmt (bsi))) != NULL)
4977 if (!e->inline_failed)
4978 cgraph_remove_node_and_inline_clones (e->callee);
4980 cgraph_remove_edge (e);
4982 if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES
4983 && id->dst_node->clones)
4984 for (node = id->dst_node->clones; node != id->dst_node;)
4986 if ((e = cgraph_edge (node, gsi_stmt (bsi))) != NULL)
4988 if (!e->inline_failed)
4989 cgraph_remove_node_and_inline_clones (e->callee);
4991 cgraph_remove_edge (e);
4995 node = node->clones;
4996 else if (node->next_sibling_clone)
4997 node = node->next_sibling_clone;
5000 while (node != id->dst_node && !node->next_sibling_clone)
5001 node = node->clone_of;
5002 if (node != id->dst_node)
5003 node = node->next_sibling_clone;
5007 delete_basic_block (b);
5015 /* Update clone info after duplication. */
5018 update_clone_info (copy_body_data * id)
5020 struct cgraph_node *node;
5021 if (!id->dst_node->clones)
5023 for (node = id->dst_node->clones; node != id->dst_node;)
5025 /* First update replace maps to match the new body. */
5026 if (node->clone.tree_map)
5029 for (i = 0; i < VEC_length (ipa_replace_map_p, node->clone.tree_map); i++)
5031 struct ipa_replace_map *replace_info;
5032 replace_info = VEC_index (ipa_replace_map_p, node->clone.tree_map, i);
5033 walk_tree (&replace_info->old_tree, copy_tree_body_r, id, NULL);
5034 walk_tree (&replace_info->new_tree, copy_tree_body_r, id, NULL);
5038 node = node->clones;
5039 else if (node->next_sibling_clone)
5040 node = node->next_sibling_clone;
5043 while (node != id->dst_node && !node->next_sibling_clone)
5044 node = node->clone_of;
5045 if (node != id->dst_node)
5046 node = node->next_sibling_clone;
5051 /* Create a copy of a function's tree.
5052 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
5053 of the original function and the new copied function
5054 respectively. In case we want to replace a DECL
5055 tree with another tree while duplicating the function's
5056 body, TREE_MAP represents the mapping between these
5057 trees. If UPDATE_CLONES is set, the call_stmt fields
5058 of edges of clones of the function will be updated.
5060 If non-NULL ARGS_TO_SKIP determine function parameters to remove
5062 If SKIP_RETURN is true, the new version will return void.
5063 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
5064 If non_NULL NEW_ENTRY determine new entry BB of the clone.
5067 tree_function_versioning (tree old_decl, tree new_decl,
5068 VEC(ipa_replace_map_p,gc)* tree_map,
5069 bool update_clones, bitmap args_to_skip,
5070 bool skip_return, bitmap blocks_to_copy,
5071 basic_block new_entry)
5073 struct cgraph_node *old_version_node;
5074 struct cgraph_node *new_version_node;
5078 struct ipa_replace_map *replace_info;
5079 basic_block old_entry_block, bb;
5080 VEC (gimple, heap) *init_stmts = VEC_alloc (gimple, heap, 10);
5082 tree old_current_function_decl = current_function_decl;
5083 tree vars = NULL_TREE;
5085 gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
5086 && TREE_CODE (new_decl) == FUNCTION_DECL);
5087 DECL_POSSIBLY_INLINED (old_decl) = 1;
5089 old_version_node = cgraph_get_node (old_decl);
5090 gcc_checking_assert (old_version_node);
5091 new_version_node = cgraph_get_node (new_decl);
5092 gcc_checking_assert (new_version_node);
5094 /* Copy over debug args. */
5095 if (DECL_HAS_DEBUG_ARGS_P (old_decl))
5097 VEC(tree, gc) **new_debug_args, **old_debug_args;
5098 gcc_checking_assert (decl_debug_args_lookup (new_decl) == NULL);
5099 DECL_HAS_DEBUG_ARGS_P (new_decl) = 0;
5100 old_debug_args = decl_debug_args_lookup (old_decl);
5103 new_debug_args = decl_debug_args_insert (new_decl);
5104 *new_debug_args = VEC_copy (tree, gc, *old_debug_args);
5108 /* Output the inlining info for this abstract function, since it has been
5109 inlined. If we don't do this now, we can lose the information about the
5110 variables in the function when the blocks get blown away as soon as we
5111 remove the cgraph node. */
5112 (*debug_hooks->outlining_inline_function) (old_decl);
5114 DECL_ARTIFICIAL (new_decl) = 1;
5115 DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
5116 DECL_FUNCTION_PERSONALITY (new_decl) = DECL_FUNCTION_PERSONALITY (old_decl);
5118 /* Prepare the data structures for the tree copy. */
5119 memset (&id, 0, sizeof (id));
5121 /* Generate a new name for the new version. */
5122 id.statements_to_fold = pointer_set_create ();
5124 id.decl_map = pointer_map_create ();
5125 id.debug_map = NULL;
5126 id.src_fn = old_decl;
5127 id.dst_fn = new_decl;
5128 id.src_node = old_version_node;
5129 id.dst_node = new_version_node;
5130 id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
5131 if (id.src_node->ipa_transforms_to_apply)
5133 VEC(ipa_opt_pass,heap) * old_transforms_to_apply = id.dst_node->ipa_transforms_to_apply;
5136 id.dst_node->ipa_transforms_to_apply = VEC_copy (ipa_opt_pass, heap,
5137 id.src_node->ipa_transforms_to_apply);
5138 for (i = 0; i < VEC_length (ipa_opt_pass, old_transforms_to_apply); i++)
5139 VEC_safe_push (ipa_opt_pass, heap, id.dst_node->ipa_transforms_to_apply,
5140 VEC_index (ipa_opt_pass,
5141 old_transforms_to_apply,
5145 id.copy_decl = copy_decl_no_change;
5146 id.transform_call_graph_edges
5147 = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
5148 id.transform_new_cfg = true;
5149 id.transform_return_to_modify = false;
5150 id.transform_lang_insert_block = NULL;
5152 current_function_decl = new_decl;
5153 old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
5154 (DECL_STRUCT_FUNCTION (old_decl));
5155 initialize_cfun (new_decl, old_decl,
5156 old_entry_block->count);
5157 DECL_STRUCT_FUNCTION (new_decl)->gimple_df->ipa_pta
5158 = id.src_cfun->gimple_df->ipa_pta;
5159 push_cfun (DECL_STRUCT_FUNCTION (new_decl));
5161 /* Copy the function's static chain. */
5162 p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
5164 DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
5165 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
5168 /* If there's a tree_map, prepare for substitution. */
5170 for (i = 0; i < VEC_length (ipa_replace_map_p, tree_map); i++)
5173 replace_info = VEC_index (ipa_replace_map_p, tree_map, i);
5174 if (replace_info->replace_p)
5176 tree op = replace_info->new_tree;
5177 if (!replace_info->old_tree)
5179 int i = replace_info->parm_num;
5181 for (parm = DECL_ARGUMENTS (old_decl); i; parm = DECL_CHAIN (parm))
5183 replace_info->old_tree = parm;
5189 if (TREE_CODE (op) == VIEW_CONVERT_EXPR)
5190 op = TREE_OPERAND (op, 0);
5192 if (TREE_CODE (op) == ADDR_EXPR)
5194 op = TREE_OPERAND (op, 0);
5195 while (handled_component_p (op))
5196 op = TREE_OPERAND (op, 0);
5197 if (TREE_CODE (op) == VAR_DECL)
5198 add_referenced_var (op);
5200 gcc_assert (TREE_CODE (replace_info->old_tree) == PARM_DECL);
5201 init = setup_one_parameter (&id, replace_info->old_tree,
5202 replace_info->new_tree, id.src_fn,
5206 VEC_safe_push (gimple, heap, init_stmts, init);
5209 /* Copy the function's arguments. */
5210 if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
5211 DECL_ARGUMENTS (new_decl) =
5212 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id,
5213 args_to_skip, &vars);
5215 DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
5216 BLOCK_SUPERCONTEXT (DECL_INITIAL (new_decl)) = new_decl;
5218 declare_inline_vars (DECL_INITIAL (new_decl), vars);
5220 if (!VEC_empty (tree, DECL_STRUCT_FUNCTION (old_decl)->local_decls))
5221 /* Add local vars. */
5222 add_local_variables (DECL_STRUCT_FUNCTION (old_decl), cfun, &id, false);
5224 if (DECL_RESULT (old_decl) == NULL_TREE)
5226 else if (skip_return && !VOID_TYPE_P (TREE_TYPE (DECL_RESULT (old_decl))))
5228 DECL_RESULT (new_decl)
5229 = build_decl (DECL_SOURCE_LOCATION (DECL_RESULT (old_decl)),
5230 RESULT_DECL, NULL_TREE, void_type_node);
5231 DECL_CONTEXT (DECL_RESULT (new_decl)) = new_decl;
5232 cfun->returns_struct = 0;
5233 cfun->returns_pcc_struct = 0;
5238 DECL_RESULT (new_decl) = remap_decl (DECL_RESULT (old_decl), &id);
5239 lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
5240 if (gimple_in_ssa_p (id.src_cfun)
5241 && DECL_BY_REFERENCE (DECL_RESULT (old_decl))
5243 = gimple_default_def (id.src_cfun, DECL_RESULT (old_decl))))
5245 tree new_name = make_ssa_name (DECL_RESULT (new_decl), NULL);
5246 insert_decl_map (&id, old_name, new_name);
5247 SSA_NAME_DEF_STMT (new_name) = gimple_build_nop ();
5248 set_default_def (DECL_RESULT (new_decl), new_name);
5252 /* Copy the Function's body. */
5253 copy_body (&id, old_entry_block->count, REG_BR_PROB_BASE,
5254 ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, blocks_to_copy, new_entry);
5256 /* Renumber the lexical scoping (non-code) blocks consecutively. */
5257 number_blocks (new_decl);
5259 /* We want to create the BB unconditionally, so that the addition of
5260 debug stmts doesn't affect BB count, which may in the end cause
5261 codegen differences. */
5262 bb = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
5263 while (VEC_length (gimple, init_stmts))
5264 insert_init_stmt (&id, bb, VEC_pop (gimple, init_stmts));
5265 update_clone_info (&id);
5267 /* Remap the nonlocal_goto_save_area, if any. */
5268 if (cfun->nonlocal_goto_save_area)
5270 struct walk_stmt_info wi;
5272 memset (&wi, 0, sizeof (wi));
5274 walk_tree (&cfun->nonlocal_goto_save_area, remap_gimple_op_r, &wi, NULL);
5278 pointer_map_destroy (id.decl_map);
5280 pointer_map_destroy (id.debug_map);
5281 free_dominance_info (CDI_DOMINATORS);
5282 free_dominance_info (CDI_POST_DOMINATORS);
5284 fold_marked_statements (0, id.statements_to_fold);
5285 pointer_set_destroy (id.statements_to_fold);
5286 fold_cond_expr_cond ();
5287 delete_unreachable_blocks_update_callgraph (&id);
5288 if (id.dst_node->analyzed)
5289 cgraph_rebuild_references ();
5290 update_ssa (TODO_update_ssa);
5292 /* After partial cloning we need to rescale frequencies, so they are
5293 within proper range in the cloned function. */
5296 struct cgraph_edge *e;
5297 rebuild_frequencies ();
5299 new_version_node->count = ENTRY_BLOCK_PTR->count;
5300 for (e = new_version_node->callees; e; e = e->next_callee)
5302 basic_block bb = gimple_bb (e->call_stmt);
5303 e->frequency = compute_call_stmt_bb_frequency (current_function_decl,
5305 e->count = bb->count;
5307 for (e = new_version_node->indirect_calls; e; e = e->next_callee)
5309 basic_block bb = gimple_bb (e->call_stmt);
5310 e->frequency = compute_call_stmt_bb_frequency (current_function_decl,
5312 e->count = bb->count;
5316 free_dominance_info (CDI_DOMINATORS);
5317 free_dominance_info (CDI_POST_DOMINATORS);
5319 gcc_assert (!id.debug_stmts);
5320 VEC_free (gimple, heap, init_stmts);
5322 current_function_decl = old_current_function_decl;
5323 gcc_assert (!current_function_decl
5324 || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
5328 /* EXP is CALL_EXPR present in a GENERIC expression tree. Try to integrate
5329 the callee and return the inlined body on success. */
5332 maybe_inline_call_in_expr (tree exp)
5334 tree fn = get_callee_fndecl (exp);
5336 /* We can only try to inline "const" functions. */
5337 if (fn && TREE_READONLY (fn) && DECL_SAVED_TREE (fn))
5339 struct pointer_map_t *decl_map = pointer_map_create ();
5340 call_expr_arg_iterator iter;
5344 /* Remap the parameters. */
5345 for (param = DECL_ARGUMENTS (fn), arg = first_call_expr_arg (exp, &iter);
5347 param = DECL_CHAIN (param), arg = next_call_expr_arg (&iter))
5348 *pointer_map_insert (decl_map, param) = arg;
5350 memset (&id, 0, sizeof (id));
5352 id.dst_fn = current_function_decl;
5353 id.src_cfun = DECL_STRUCT_FUNCTION (fn);
5354 id.decl_map = decl_map;
5356 id.copy_decl = copy_decl_no_change;
5357 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
5358 id.transform_new_cfg = false;
5359 id.transform_return_to_modify = true;
5360 id.transform_lang_insert_block = NULL;
5362 /* Make sure not to unshare trees behind the front-end's back
5363 since front-end specific mechanisms may rely on sharing. */
5364 id.regimplify = false;
5365 id.do_not_unshare = true;
5367 /* We're not inside any EH region. */
5370 t = copy_tree_body (&id);
5371 pointer_map_destroy (decl_map);
5373 /* We can only return something suitable for use in a GENERIC
5375 if (TREE_CODE (t) == MODIFY_EXPR)
5376 return TREE_OPERAND (t, 1);
5382 /* Duplicate a type, fields and all. */
5385 build_duplicate_type (tree type)
5387 struct copy_body_data id;
5389 memset (&id, 0, sizeof (id));
5390 id.src_fn = current_function_decl;
5391 id.dst_fn = current_function_decl;
5393 id.decl_map = pointer_map_create ();
5394 id.debug_map = NULL;
5395 id.copy_decl = copy_decl_no_change;
5397 type = remap_type_1 (type, &id);
5399 pointer_map_destroy (id.decl_map);
5401 pointer_map_destroy (id.debug_map);
5403 TYPE_CANONICAL (type) = type;