2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
3 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"
28 #include "tree-inline.h"
34 #include "insn-config.h"
37 #include "langhooks.h"
38 #include "basic-block.h"
39 #include "tree-iterator.h"
42 #include "tree-mudflap.h"
43 #include "tree-flow.h"
46 #include "tree-flow.h"
47 #include "diagnostic.h"
50 #include "pointer-set.h"
52 #include "value-prof.h"
53 #include "tree-pass.h"
55 #include "integrate.h"
57 /* I'm not real happy about this, but we need to handle gimple and
61 /* Inlining, Cloning, Versioning, Parallelization
63 Inlining: a function body is duplicated, but the PARM_DECLs are
64 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
65 MODIFY_EXPRs that store to a dedicated returned-value variable.
66 The duplicated eh_region info of the copy will later be appended
67 to the info for the caller; the eh_region info in copied throwing
68 statements and RESX_EXPRs is adjusted accordingly.
70 Cloning: (only in C++) We have one body for a con/de/structor, and
71 multiple function decls, each with a unique parameter list.
72 Duplicate the body, using the given splay tree; some parameters
73 will become constants (like 0 or 1).
75 Versioning: a function body is duplicated and the result is a new
76 function rather than into blocks of an existing function as with
77 inlining. Some parameters will become constants.
79 Parallelization: a region of a function is duplicated resulting in
80 a new function. Variables may be replaced with complex expressions
81 to enable shared variable semantics.
83 All of these will simultaneously lookup any callgraph edges. If
84 we're going to inline the duplicated function body, and the given
85 function has some cloned callgraph nodes (one for each place this
86 function will be inlined) those callgraph edges will be duplicated.
87 If we're cloning the body, those callgraph edges will be
88 updated to point into the new body. (Note that the original
89 callgraph node and edge list will not be altered.)
91 See the CALL_EXPR handling case in copy_tree_body_r (). */
95 o In order to make inlining-on-trees work, we pessimized
96 function-local static constants. In particular, they are now
97 always output, even when not addressed. Fix this by treating
98 function-local static constants just like global static
99 constants; the back-end already knows not to output them if they
102 o Provide heuristics to clamp inlining of recursive template
106 /* Weights that estimate_num_insns uses for heuristics in inlining. */
108 eni_weights eni_inlining_weights;
110 /* Weights that estimate_num_insns uses to estimate the size of the
113 eni_weights eni_size_weights;
115 /* Weights that estimate_num_insns uses to estimate the time necessary
116 to execute the produced code. */
118 eni_weights eni_time_weights;
122 static tree declare_return_variable (copy_body_data *, tree, tree, tree *);
123 static bool inlinable_function_p (tree);
124 static void remap_block (tree *, copy_body_data *);
125 static tree remap_decls (tree, copy_body_data *);
126 static void copy_bind_expr (tree *, int *, copy_body_data *);
127 static tree mark_local_for_remap_r (tree *, int *, void *);
128 static void unsave_expr_1 (tree);
129 static tree unsave_r (tree *, int *, void *);
130 static void declare_inline_vars (tree, tree);
131 static void remap_save_expr (tree *, void *, int *);
132 static void add_lexical_block (tree current_block, tree new_block);
133 static tree copy_decl_to_var (tree, copy_body_data *);
134 static tree copy_result_decl_to_var (tree, copy_body_data *);
135 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
136 static gimple remap_gimple_stmt (gimple, copy_body_data *);
138 /* Insert a tree->tree mapping for ID. Despite the name suggests
139 that the trees should be variables, it is used for more than that. */
142 insert_decl_map (copy_body_data *id, tree key, tree value)
144 *pointer_map_insert (id->decl_map, key) = value;
146 /* Always insert an identity map as well. If we see this same new
147 node again, we won't want to duplicate it a second time. */
149 *pointer_map_insert (id->decl_map, value) = value;
152 /* Construct new SSA name for old NAME. ID is the inline context. */
155 remap_ssa_name (tree name, copy_body_data *id)
160 gcc_assert (TREE_CODE (name) == SSA_NAME);
162 n = (tree *) pointer_map_contains (id->decl_map, name);
164 return unshare_expr (*n);
166 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
168 new_tree = remap_decl (SSA_NAME_VAR (name), id);
170 /* We might've substituted constant or another SSA_NAME for
173 Replace the SSA name representing RESULT_DECL by variable during
174 inlining: this saves us from need to introduce PHI node in a case
175 return value is just partly initialized. */
176 if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL)
177 && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
178 || !id->transform_return_to_modify))
180 new_tree = make_ssa_name (new_tree, NULL);
181 insert_decl_map (id, name, new_tree);
182 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
183 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
184 TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree));
185 if (gimple_nop_p (SSA_NAME_DEF_STMT (name)))
187 /* By inlining function having uninitialized variable, we might
188 extend the lifetime (variable might get reused). This cause
189 ICE in the case we end up extending lifetime of SSA name across
190 abnormal edge, but also increase register pressure.
192 We simply initialize all uninitialized vars by 0 except
193 for case we are inlining to very first BB. We can avoid
194 this for all BBs that are not inside strongly connected
195 regions of the CFG, but this is expensive to test. */
197 && is_gimple_reg (SSA_NAME_VAR (name))
198 && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL
199 && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest
200 || EDGE_COUNT (id->entry_bb->preds) != 1))
202 gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
205 init_stmt = gimple_build_assign (new_tree,
206 fold_convert (TREE_TYPE (new_tree),
208 gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT);
209 SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0;
213 SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop ();
214 if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name))
216 set_default_def (SSA_NAME_VAR (new_tree), new_tree);
221 insert_decl_map (id, name, new_tree);
225 /* Remap DECL during the copying of the BLOCK tree for the function. */
228 remap_decl (tree decl, copy_body_data *id)
233 /* We only remap local variables in the current function. */
236 /* See if we have remapped this declaration. */
238 n = (tree *) pointer_map_contains (id->decl_map, decl);
240 /* If we didn't already have an equivalent for this declaration,
244 /* Make a copy of the variable or label. */
245 tree t = id->copy_decl (decl, id);
247 /* Remember it, so that if we encounter this local entity again
248 we can reuse this copy. Do this early because remap_type may
249 need this decl for TYPE_STUB_DECL. */
250 insert_decl_map (id, decl, t);
255 /* Remap types, if necessary. */
256 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
257 if (TREE_CODE (t) == TYPE_DECL)
258 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
260 /* Remap sizes as necessary. */
261 walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL);
262 walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL);
264 /* If fields, do likewise for offset and qualifier. */
265 if (TREE_CODE (t) == FIELD_DECL)
267 walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL);
268 if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
269 walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL);
272 if (cfun && gimple_in_ssa_p (cfun)
273 && (TREE_CODE (t) == VAR_DECL
274 || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL))
276 tree def = gimple_default_def (id->src_cfun, decl);
278 if (TREE_CODE (decl) != PARM_DECL && def)
280 tree map = remap_ssa_name (def, id);
281 /* Watch out RESULT_DECLs whose SSA names map directly
283 if (TREE_CODE (map) == SSA_NAME
284 && gimple_nop_p (SSA_NAME_DEF_STMT (map)))
285 set_default_def (t, map);
287 add_referenced_var (t);
292 return unshare_expr (*n);
296 remap_type_1 (tree type, copy_body_data *id)
300 /* We do need a copy. build and register it now. If this is a pointer or
301 reference type, remap the designated type and make a new pointer or
303 if (TREE_CODE (type) == POINTER_TYPE)
305 new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
307 TYPE_REF_CAN_ALIAS_ALL (type));
308 insert_decl_map (id, type, new_tree);
311 else if (TREE_CODE (type) == REFERENCE_TYPE)
313 new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
315 TYPE_REF_CAN_ALIAS_ALL (type));
316 insert_decl_map (id, type, new_tree);
320 new_tree = copy_node (type);
322 insert_decl_map (id, type, new_tree);
324 /* This is a new type, not a copy of an old type. Need to reassociate
325 variants. We can handle everything except the main variant lazily. */
326 t = TYPE_MAIN_VARIANT (type);
329 t = remap_type (t, id);
330 TYPE_MAIN_VARIANT (new_tree) = t;
331 TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t);
332 TYPE_NEXT_VARIANT (t) = new_tree;
336 TYPE_MAIN_VARIANT (new_tree) = new_tree;
337 TYPE_NEXT_VARIANT (new_tree) = NULL;
340 if (TYPE_STUB_DECL (type))
341 TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id);
343 /* Lazily create pointer and reference types. */
344 TYPE_POINTER_TO (new_tree) = NULL;
345 TYPE_REFERENCE_TO (new_tree) = NULL;
347 switch (TREE_CODE (new_tree))
351 case FIXED_POINT_TYPE:
354 t = TYPE_MIN_VALUE (new_tree);
355 if (t && TREE_CODE (t) != INTEGER_CST)
356 walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL);
358 t = TYPE_MAX_VALUE (new_tree);
359 if (t && TREE_CODE (t) != INTEGER_CST)
360 walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL);
364 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
365 walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL);
369 TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
370 TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id);
375 case QUAL_UNION_TYPE:
379 for (f = TYPE_FIELDS (new_tree); f ; f = TREE_CHAIN (f))
381 t = remap_decl (f, id);
382 DECL_CONTEXT (t) = new_tree;
386 TYPE_FIELDS (new_tree) = nreverse (nf);
392 /* Shouldn't have been thought variable sized. */
396 walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL);
397 walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL);
403 remap_type (tree type, copy_body_data *id)
411 /* See if we have remapped this type. */
412 node = (tree *) pointer_map_contains (id->decl_map, type);
416 /* The type only needs remapping if it's variably modified. */
417 if (! variably_modified_type_p (type, id->src_fn))
419 insert_decl_map (id, type, type);
423 id->remapping_type_depth++;
424 tmp = remap_type_1 (type, id);
425 id->remapping_type_depth--;
431 remap_decls (tree decls, copy_body_data *id)
434 tree new_decls = NULL_TREE;
436 /* Remap its variables. */
437 for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
441 /* We cannot chain the local static declarations into the local_decls
442 as we can't duplicate them or break one decl rule. Go ahead
443 and link them into local_decls. */
445 if (!auto_var_in_fn_p (old_var, id->src_fn)
446 && !DECL_EXTERNAL (old_var))
448 cfun->local_decls = tree_cons (NULL_TREE, old_var,
453 /* Remap the variable. */
454 new_var = remap_decl (old_var, id);
456 /* If we didn't remap this variable, we can't mess with its
457 TREE_CHAIN. If we remapped this variable to the return slot, it's
458 already declared somewhere else, so don't declare it here. */
459 if (!new_var || new_var == id->retvar)
463 gcc_assert (DECL_P (new_var));
464 TREE_CHAIN (new_var) = new_decls;
469 return nreverse (new_decls);
472 /* Copy the BLOCK to contain remapped versions of the variables
473 therein. And hook the new block into the block-tree. */
476 remap_block (tree *block, copy_body_data *id)
482 /* Make the new block. */
484 new_block = make_node (BLOCK);
485 TREE_USED (new_block) = TREE_USED (old_block);
486 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
487 BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
490 /* Remap its variables. */
491 BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), id);
495 if (id->transform_lang_insert_block)
496 id->transform_lang_insert_block (new_block);
498 /* Remember the remapped block. */
499 insert_decl_map (id, old_block, new_block);
502 /* Copy the whole block tree and root it in id->block. */
504 remap_blocks (tree block, copy_body_data *id)
507 tree new_tree = block;
512 remap_block (&new_tree, id);
513 gcc_assert (new_tree != block);
514 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
515 add_lexical_block (new_tree, remap_blocks (t, id));
520 copy_statement_list (tree *tp)
522 tree_stmt_iterator oi, ni;
525 new_tree = alloc_stmt_list ();
526 ni = tsi_start (new_tree);
527 oi = tsi_start (*tp);
530 for (; !tsi_end_p (oi); tsi_next (&oi))
531 tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT);
535 copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id)
537 tree block = BIND_EXPR_BLOCK (*tp);
538 /* Copy (and replace) the statement. */
539 copy_tree_r (tp, walk_subtrees, NULL);
542 remap_block (&block, id);
543 BIND_EXPR_BLOCK (*tp) = block;
546 if (BIND_EXPR_VARS (*tp))
547 /* This will remap a lot of the same decls again, but this should be
549 BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id);
553 /* Create a new gimple_seq by remapping all the statements in BODY
554 using the inlining information in ID. */
557 remap_gimple_seq (gimple_seq body, copy_body_data *id)
559 gimple_stmt_iterator si;
560 gimple_seq new_body = NULL;
562 for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si))
564 gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id);
565 gimple_seq_add_stmt (&new_body, new_stmt);
572 /* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its
573 block using the mapping information in ID. */
576 copy_gimple_bind (gimple stmt, copy_body_data *id)
579 tree new_block, new_vars;
580 gimple_seq body, new_body;
582 /* Copy the statement. Note that we purposely don't use copy_stmt
583 here because we need to remap statements as we copy. */
584 body = gimple_bind_body (stmt);
585 new_body = remap_gimple_seq (body, id);
587 new_block = gimple_bind_block (stmt);
589 remap_block (&new_block, id);
591 /* This will remap a lot of the same decls again, but this should be
593 new_vars = gimple_bind_vars (stmt);
595 new_vars = remap_decls (new_vars, id);
597 new_bind = gimple_build_bind (new_vars, new_body, new_block);
603 /* Remap the GIMPLE operand pointed to by *TP. DATA is really a
604 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'.
605 WALK_SUBTREES is used to indicate walk_gimple_op whether to keep
606 recursing into the children nodes of *TP. */
609 remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
611 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
612 copy_body_data *id = (copy_body_data *) wi_p->info;
613 tree fn = id->src_fn;
615 if (TREE_CODE (*tp) == SSA_NAME)
617 *tp = remap_ssa_name (*tp, id);
621 else if (auto_var_in_fn_p (*tp, fn))
623 /* Local variables and labels need to be replaced by equivalent
624 variables. We don't want to copy static variables; there's
625 only one of those, no matter how many times we inline the
626 containing function. Similarly for globals from an outer
630 /* Remap the declaration. */
631 new_decl = remap_decl (*tp, id);
632 gcc_assert (new_decl);
633 /* Replace this variable with the copy. */
634 STRIP_TYPE_NOPS (new_decl);
638 else if (TREE_CODE (*tp) == STATEMENT_LIST)
640 else if (TREE_CODE (*tp) == SAVE_EXPR)
642 else if (TREE_CODE (*tp) == LABEL_DECL
643 && (!DECL_CONTEXT (*tp)
644 || decl_function_context (*tp) == id->src_fn))
645 /* These may need to be remapped for EH handling. */
646 *tp = remap_decl (*tp, id);
647 else if (TYPE_P (*tp))
648 /* Types may need remapping as well. */
649 *tp = remap_type (*tp, id);
650 else if (CONSTANT_CLASS_P (*tp))
652 /* If this is a constant, we have to copy the node iff the type
653 will be remapped. copy_tree_r will not copy a constant. */
654 tree new_type = remap_type (TREE_TYPE (*tp), id);
656 if (new_type == TREE_TYPE (*tp))
659 else if (TREE_CODE (*tp) == INTEGER_CST)
660 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
661 TREE_INT_CST_HIGH (*tp));
664 *tp = copy_node (*tp);
665 TREE_TYPE (*tp) = new_type;
670 /* Otherwise, just copy the node. Note that copy_tree_r already
671 knows not to copy VAR_DECLs, etc., so this is safe. */
672 if (TREE_CODE (*tp) == INDIRECT_REF)
674 /* Get rid of *& from inline substitutions that can happen when a
675 pointer argument is an ADDR_EXPR. */
676 tree decl = TREE_OPERAND (*tp, 0);
679 n = (tree *) pointer_map_contains (id->decl_map, decl);
682 tree type, new_tree, old;
684 /* If we happen to get an ADDR_EXPR in n->value, strip
685 it manually here as we'll eventually get ADDR_EXPRs
686 which lie about their types pointed to. In this case
687 build_fold_indirect_ref wouldn't strip the
688 INDIRECT_REF, but we absolutely rely on that. As
689 fold_indirect_ref does other useful transformations,
690 try that first, though. */
691 type = TREE_TYPE (TREE_TYPE (*n));
692 new_tree = unshare_expr (*n);
694 *tp = gimple_fold_indirect_ref (new_tree);
697 if (TREE_CODE (new_tree) == ADDR_EXPR)
699 *tp = fold_indirect_ref_1 (type, new_tree);
700 /* ??? We should either assert here or build
701 a VIEW_CONVERT_EXPR instead of blindly leaking
702 incompatible types to our IL. */
704 *tp = TREE_OPERAND (new_tree, 0);
708 *tp = build1 (INDIRECT_REF, type, new_tree);
709 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
717 /* Here is the "usual case". Copy this tree node, and then
718 tweak some special cases. */
719 copy_tree_r (tp, walk_subtrees, NULL);
721 /* Global variables we haven't seen yet need to go into referenced
722 vars. If not referenced from types only. */
723 if (gimple_in_ssa_p (cfun)
724 && TREE_CODE (*tp) == VAR_DECL
725 && id->remapping_type_depth == 0)
726 add_referenced_var (*tp);
728 /* We should never have TREE_BLOCK set on non-statements. */
730 gcc_assert (!TREE_BLOCK (*tp));
732 if (TREE_CODE (*tp) != OMP_CLAUSE)
733 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
735 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
737 /* The copied TARGET_EXPR has never been expanded, even if the
738 original node was expanded already. */
739 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
740 TREE_OPERAND (*tp, 3) = NULL_TREE;
742 else if (TREE_CODE (*tp) == ADDR_EXPR)
744 /* Variable substitution need not be simple. In particular,
745 the INDIRECT_REF substitution above. Make sure that
746 TREE_CONSTANT and friends are up-to-date. But make sure
747 to not improperly set TREE_BLOCK on some sub-expressions. */
748 int invariant = is_gimple_min_invariant (*tp);
749 tree block = id->block;
750 id->block = NULL_TREE;
751 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
754 /* Handle the case where we substituted an INDIRECT_REF
755 into the operand of the ADDR_EXPR. */
756 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
757 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
759 recompute_tree_invariant_for_addr_expr (*tp);
761 /* If this used to be invariant, but is not any longer,
762 then regimplification is probably needed. */
763 if (invariant && !is_gimple_min_invariant (*tp))
764 id->regimplify = true;
770 /* Keep iterating. */
775 /* Called from copy_body_id via walk_tree. DATA is really a
776 `copy_body_data *'. */
779 copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
781 copy_body_data *id = (copy_body_data *) data;
782 tree fn = id->src_fn;
785 /* Begin by recognizing trees that we'll completely rewrite for the
786 inlining context. Our output for these trees is completely
787 different from out input (e.g. RETURN_EXPR is deleted, and morphs
788 into an edge). Further down, we'll handle trees that get
789 duplicated and/or tweaked. */
791 /* When requested, RETURN_EXPRs should be transformed to just the
792 contained MODIFY_EXPR. The branch semantics of the return will
793 be handled elsewhere by manipulating the CFG rather than a statement. */
794 if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
796 tree assignment = TREE_OPERAND (*tp, 0);
798 /* If we're returning something, just turn that into an
799 assignment into the equivalent of the original RESULT_DECL.
800 If the "assignment" is just the result decl, the result
801 decl has already been set (e.g. a recent "foo (&result_decl,
802 ...)"); just toss the entire RETURN_EXPR. */
803 if (assignment && TREE_CODE (assignment) == MODIFY_EXPR)
805 /* Replace the RETURN_EXPR with (a copy of) the
806 MODIFY_EXPR hanging underneath. */
807 *tp = copy_node (assignment);
809 else /* Else the RETURN_EXPR returns no value. */
812 return (tree) (void *)1;
815 else if (TREE_CODE (*tp) == SSA_NAME)
817 *tp = remap_ssa_name (*tp, id);
822 /* Local variables and labels need to be replaced by equivalent
823 variables. We don't want to copy static variables; there's only
824 one of those, no matter how many times we inline the containing
825 function. Similarly for globals from an outer function. */
826 else if (auto_var_in_fn_p (*tp, fn))
830 /* Remap the declaration. */
831 new_decl = remap_decl (*tp, id);
832 gcc_assert (new_decl);
833 /* Replace this variable with the copy. */
834 STRIP_TYPE_NOPS (new_decl);
838 else if (TREE_CODE (*tp) == STATEMENT_LIST)
839 copy_statement_list (tp);
840 else if (TREE_CODE (*tp) == SAVE_EXPR)
841 remap_save_expr (tp, id->decl_map, walk_subtrees);
842 else if (TREE_CODE (*tp) == LABEL_DECL
843 && (! DECL_CONTEXT (*tp)
844 || decl_function_context (*tp) == id->src_fn))
845 /* These may need to be remapped for EH handling. */
846 *tp = remap_decl (*tp, id);
847 else if (TREE_CODE (*tp) == BIND_EXPR)
848 copy_bind_expr (tp, walk_subtrees, id);
849 /* Types may need remapping as well. */
850 else if (TYPE_P (*tp))
851 *tp = remap_type (*tp, id);
853 /* If this is a constant, we have to copy the node iff the type will be
854 remapped. copy_tree_r will not copy a constant. */
855 else if (CONSTANT_CLASS_P (*tp))
857 tree new_type = remap_type (TREE_TYPE (*tp), id);
859 if (new_type == TREE_TYPE (*tp))
862 else if (TREE_CODE (*tp) == INTEGER_CST)
863 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
864 TREE_INT_CST_HIGH (*tp));
867 *tp = copy_node (*tp);
868 TREE_TYPE (*tp) = new_type;
872 /* Otherwise, just copy the node. Note that copy_tree_r already
873 knows not to copy VAR_DECLs, etc., so this is safe. */
876 /* Here we handle trees that are not completely rewritten.
877 First we detect some inlining-induced bogosities for
879 if (TREE_CODE (*tp) == MODIFY_EXPR
880 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
881 && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn)))
883 /* Some assignments VAR = VAR; don't generate any rtl code
884 and thus don't count as variable modification. Avoid
885 keeping bogosities like 0 = 0. */
886 tree decl = TREE_OPERAND (*tp, 0), value;
889 n = (tree *) pointer_map_contains (id->decl_map, decl);
893 STRIP_TYPE_NOPS (value);
894 if (TREE_CONSTANT (value) || TREE_READONLY (value))
896 *tp = build_empty_stmt ();
897 return copy_tree_body_r (tp, walk_subtrees, data);
901 else if (TREE_CODE (*tp) == INDIRECT_REF)
903 /* Get rid of *& from inline substitutions that can happen when a
904 pointer argument is an ADDR_EXPR. */
905 tree decl = TREE_OPERAND (*tp, 0);
908 n = (tree *) pointer_map_contains (id->decl_map, decl);
913 /* If we happen to get an ADDR_EXPR in n->value, strip
914 it manually here as we'll eventually get ADDR_EXPRs
915 which lie about their types pointed to. In this case
916 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
917 but we absolutely rely on that. As fold_indirect_ref
918 does other useful transformations, try that first, though. */
919 tree type = TREE_TYPE (TREE_TYPE (*n));
920 new_tree = unshare_expr (*n);
922 *tp = gimple_fold_indirect_ref (new_tree);
925 if (TREE_CODE (new_tree) == ADDR_EXPR)
927 *tp = fold_indirect_ref_1 (type, new_tree);
928 /* ??? We should either assert here or build
929 a VIEW_CONVERT_EXPR instead of blindly leaking
930 incompatible types to our IL. */
932 *tp = TREE_OPERAND (new_tree, 0);
936 *tp = build1 (INDIRECT_REF, type, new_tree);
937 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
938 TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
946 /* Here is the "usual case". Copy this tree node, and then
947 tweak some special cases. */
948 copy_tree_r (tp, walk_subtrees, NULL);
950 /* Global variables we haven't seen yet needs to go into referenced
951 vars. If not referenced from types only. */
952 if (gimple_in_ssa_p (cfun)
953 && TREE_CODE (*tp) == VAR_DECL
954 && id->remapping_type_depth == 0)
955 add_referenced_var (*tp);
957 /* If EXPR has block defined, map it to newly constructed block.
958 When inlining we want EXPRs without block appear in the block
962 new_block = id->block;
963 if (TREE_BLOCK (*tp))
966 n = (tree *) pointer_map_contains (id->decl_map,
971 TREE_BLOCK (*tp) = new_block;
974 if (TREE_CODE (*tp) == RESX_EXPR && id->eh_region_offset)
975 TREE_OPERAND (*tp, 0) =
976 build_int_cst (NULL_TREE,
978 + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0)));
980 if (TREE_CODE (*tp) != OMP_CLAUSE)
981 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
983 /* The copied TARGET_EXPR has never been expanded, even if the
984 original node was expanded already. */
985 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
987 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
988 TREE_OPERAND (*tp, 3) = NULL_TREE;
991 /* Variable substitution need not be simple. In particular, the
992 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
993 and friends are up-to-date. */
994 else if (TREE_CODE (*tp) == ADDR_EXPR)
996 int invariant = is_gimple_min_invariant (*tp);
997 walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL);
999 /* Handle the case where we substituted an INDIRECT_REF
1000 into the operand of the ADDR_EXPR. */
1001 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
1002 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
1004 recompute_tree_invariant_for_addr_expr (*tp);
1006 /* If this used to be invariant, but is not any longer,
1007 then regimplification is probably needed. */
1008 if (invariant && !is_gimple_min_invariant (*tp))
1009 id->regimplify = true;
1015 /* Keep iterating. */
1020 /* Helper for copy_bb. Remap statement STMT using the inlining
1021 information in ID. Return the new statement copy. */
1024 remap_gimple_stmt (gimple stmt, copy_body_data *id)
1027 struct walk_stmt_info wi;
1030 /* Begin by recognizing trees that we'll completely rewrite for the
1031 inlining context. Our output for these trees is completely
1032 different from out input (e.g. RETURN_EXPR is deleted, and morphs
1033 into an edge). Further down, we'll handle trees that get
1034 duplicated and/or tweaked. */
1036 /* When requested, GIMPLE_RETURNs should be transformed to just the
1037 contained GIMPLE_ASSIGN. The branch semantics of the return will
1038 be handled elsewhere by manipulating the CFG rather than the
1040 if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify)
1042 tree retval = gimple_return_retval (stmt);
1044 /* If we're returning something, just turn that into an
1045 assignment into the equivalent of the original RESULT_DECL.
1046 If RETVAL is just the result decl, the result decl has
1047 already been set (e.g. a recent "foo (&result_decl, ...)");
1048 just toss the entire GIMPLE_RETURN. */
1049 if (retval && TREE_CODE (retval) != RESULT_DECL)
1050 copy = gimple_build_assign (id->retvar, retval);
1052 return gimple_build_nop ();
1054 else if (gimple_has_substatements (stmt))
1058 /* When cloning bodies from the C++ front end, we will be handed bodies
1059 in High GIMPLE form. Handle here all the High GIMPLE statements that
1060 have embedded statements. */
1061 switch (gimple_code (stmt))
1064 copy = copy_gimple_bind (stmt, id);
1068 s1 = remap_gimple_seq (gimple_catch_handler (stmt), id);
1069 copy = gimple_build_catch (gimple_catch_types (stmt), s1);
1072 case GIMPLE_EH_FILTER:
1073 s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id);
1074 copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1);
1078 s1 = remap_gimple_seq (gimple_try_eval (stmt), id);
1079 s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id);
1080 copy = gimple_build_try (s1, s2, gimple_try_kind (stmt));
1083 case GIMPLE_WITH_CLEANUP_EXPR:
1084 s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id);
1085 copy = gimple_build_wce (s1);
1088 case GIMPLE_OMP_PARALLEL:
1089 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1090 copy = gimple_build_omp_parallel
1092 gimple_omp_parallel_clauses (stmt),
1093 gimple_omp_parallel_child_fn (stmt),
1094 gimple_omp_parallel_data_arg (stmt));
1097 case GIMPLE_OMP_TASK:
1098 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1099 copy = gimple_build_omp_task
1101 gimple_omp_task_clauses (stmt),
1102 gimple_omp_task_child_fn (stmt),
1103 gimple_omp_task_data_arg (stmt),
1104 gimple_omp_task_copy_fn (stmt),
1105 gimple_omp_task_arg_size (stmt),
1106 gimple_omp_task_arg_align (stmt));
1109 case GIMPLE_OMP_FOR:
1110 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1111 s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id);
1112 copy = gimple_build_omp_for (s1, gimple_omp_for_clauses (stmt),
1113 gimple_omp_for_collapse (stmt), s2);
1116 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1118 gimple_omp_for_set_index (copy, i,
1119 gimple_omp_for_index (stmt, i));
1120 gimple_omp_for_set_initial (copy, i,
1121 gimple_omp_for_initial (stmt, i));
1122 gimple_omp_for_set_final (copy, i,
1123 gimple_omp_for_final (stmt, i));
1124 gimple_omp_for_set_incr (copy, i,
1125 gimple_omp_for_incr (stmt, i));
1126 gimple_omp_for_set_cond (copy, i,
1127 gimple_omp_for_cond (stmt, i));
1132 case GIMPLE_OMP_MASTER:
1133 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1134 copy = gimple_build_omp_master (s1);
1137 case GIMPLE_OMP_ORDERED:
1138 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1139 copy = gimple_build_omp_ordered (s1);
1142 case GIMPLE_OMP_SECTION:
1143 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1144 copy = gimple_build_omp_section (s1);
1147 case GIMPLE_OMP_SECTIONS:
1148 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1149 copy = gimple_build_omp_sections
1150 (s1, gimple_omp_sections_clauses (stmt));
1153 case GIMPLE_OMP_SINGLE:
1154 s1 = remap_gimple_seq (gimple_omp_body (stmt), id);
1155 copy = gimple_build_omp_single
1156 (s1, gimple_omp_single_clauses (stmt));
1165 if (gimple_assign_copy_p (stmt)
1166 && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt)
1167 && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn))
1169 /* Here we handle statements that are not completely rewritten.
1170 First we detect some inlining-induced bogosities for
1173 /* Some assignments VAR = VAR; don't generate any rtl code
1174 and thus don't count as variable modification. Avoid
1175 keeping bogosities like 0 = 0. */
1176 tree decl = gimple_assign_lhs (stmt), value;
1179 n = (tree *) pointer_map_contains (id->decl_map, decl);
1183 STRIP_TYPE_NOPS (value);
1184 if (TREE_CONSTANT (value) || TREE_READONLY (value))
1185 return gimple_build_nop ();
1189 /* Create a new deep copy of the statement. */
1190 copy = gimple_copy (stmt);
1193 /* If STMT has a block defined, map it to the newly constructed
1194 block. When inlining we want statements without a block to
1195 appear in the block of the function call. */
1196 new_block = id->block;
1197 if (gimple_block (copy))
1200 n = (tree *) pointer_map_contains (id->decl_map, gimple_block (copy));
1205 gimple_set_block (copy, new_block);
1207 /* Remap all the operands in COPY. */
1208 memset (&wi, 0, sizeof (wi));
1210 walk_gimple_op (copy, remap_gimple_op_r, &wi);
1212 /* We have to handle EH region remapping of GIMPLE_RESX specially because
1213 the region number is not an operand. */
1214 if (gimple_code (stmt) == GIMPLE_RESX && id->eh_region_offset)
1216 gimple_resx_set_region (copy, gimple_resx_region (stmt) + id->eh_region_offset);
1222 /* Copy basic block, scale profile accordingly. Edges will be taken care of
1226 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale,
1227 gcov_type count_scale)
1229 gimple_stmt_iterator gsi, copy_gsi;
1230 basic_block copy_basic_block;
1233 /* create_basic_block() will append every new block to
1234 basic_block_info automatically. */
1235 copy_basic_block = create_basic_block (NULL, (void *) 0,
1236 (basic_block) bb->prev_bb->aux);
1237 copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
1239 /* We are going to rebuild frequencies from scratch. These values
1240 have just small importance to drive canonicalize_loop_headers. */
1241 copy_basic_block->frequency = ((gcov_type)bb->frequency
1242 * frequency_scale / REG_BR_PROB_BASE);
1244 if (copy_basic_block->frequency > BB_FREQ_MAX)
1245 copy_basic_block->frequency = BB_FREQ_MAX;
1247 copy_gsi = gsi_start_bb (copy_basic_block);
1249 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1251 gimple stmt = gsi_stmt (gsi);
1252 gimple orig_stmt = stmt;
1254 id->regimplify = false;
1255 stmt = remap_gimple_stmt (stmt, id);
1256 if (gimple_nop_p (stmt))
1259 gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt);
1261 /* With return slot optimization we can end up with
1262 non-gimple (foo *)&this->m, fix that here. */
1263 if (is_gimple_assign (stmt)
1264 && gimple_assign_rhs_code (stmt) == NOP_EXPR
1265 && !is_gimple_val (gimple_assign_rhs1 (stmt)))
1268 new_rhs = force_gimple_operand_gsi (©_gsi,
1269 gimple_assign_rhs1 (stmt),
1270 true, NULL, true, GSI_SAME_STMT);
1271 gimple_assign_set_rhs1 (stmt, new_rhs);
1273 else if (id->regimplify)
1274 gimple_regimplify_operands (stmt, ©_gsi);
1276 gsi_insert_after (©_gsi, stmt, GSI_NEW_STMT);
1278 /* Process the new statement. The call to gimple_regimplify_operands
1279 possibly turned the statement into multiple statements, we
1280 need to process all of them. */
1281 while (!gsi_end_p (copy_gsi))
1283 if (is_gimple_call (stmt)
1284 && gimple_call_va_arg_pack_p (stmt)
1287 /* __builtin_va_arg_pack () should be replaced by
1288 all arguments corresponding to ... in the caller. */
1291 VEC(tree, heap) *argarray;
1292 size_t nargs = gimple_call_num_args (id->gimple_call);
1295 for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
1298 /* Create the new array of arguments. */
1299 n = nargs + gimple_call_num_args (stmt);
1300 argarray = VEC_alloc (tree, heap, n);
1301 VEC_safe_grow (tree, heap, argarray, n);
1303 /* Copy all the arguments before '...' */
1304 memcpy (VEC_address (tree, argarray),
1305 gimple_call_arg_ptr (stmt, 0),
1306 gimple_call_num_args (stmt) * sizeof (tree));
1308 /* Append the arguments passed in '...' */
1309 memcpy (VEC_address(tree, argarray) + gimple_call_num_args (stmt),
1310 gimple_call_arg_ptr (id->gimple_call, 0)
1311 + (gimple_call_num_args (id->gimple_call) - nargs),
1312 nargs * sizeof (tree));
1314 new_call = gimple_build_call_vec (gimple_call_fn (stmt),
1317 VEC_free (tree, heap, argarray);
1319 /* Copy all GIMPLE_CALL flags, location and block, except
1320 GF_CALL_VA_ARG_PACK. */
1321 gimple_call_copy_flags (new_call, stmt);
1322 gimple_call_set_va_arg_pack (new_call, false);
1323 gimple_set_location (new_call, gimple_location (stmt));
1324 gimple_set_block (new_call, gimple_block (stmt));
1325 gimple_call_set_lhs (new_call, gimple_call_lhs (stmt));
1327 gsi_replace (©_gsi, new_call, false);
1330 else if (is_gimple_call (stmt)
1332 && (decl = gimple_call_fndecl (stmt))
1333 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1334 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN)
1336 /* __builtin_va_arg_pack_len () should be replaced by
1337 the number of anonymous arguments. */
1338 size_t nargs = gimple_call_num_args (id->gimple_call);
1342 for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
1345 count = build_int_cst (integer_type_node, nargs);
1346 new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count);
1347 gsi_replace (©_gsi, new_stmt, false);
1351 /* Statements produced by inlining can be unfolded, especially
1352 when we constant propagated some operands. We can't fold
1353 them right now for two reasons:
1354 1) folding require SSA_NAME_DEF_STMTs to be correct
1355 2) we can't change function calls to builtins.
1356 So we just mark statement for later folding. We mark
1357 all new statements, instead just statements that has changed
1358 by some nontrivial substitution so even statements made
1359 foldable indirectly are updated. If this turns out to be
1360 expensive, copy_body can be told to watch for nontrivial
1362 if (id->statements_to_fold)
1363 pointer_set_insert (id->statements_to_fold, stmt);
1365 /* We're duplicating a CALL_EXPR. Find any corresponding
1366 callgraph edges and update or duplicate them. */
1367 if (is_gimple_call (stmt))
1369 struct cgraph_node *node;
1370 struct cgraph_edge *edge;
1372 switch (id->transform_call_graph_edges)
1374 case CB_CGE_DUPLICATE:
1375 edge = cgraph_edge (id->src_node, orig_stmt);
1377 cgraph_clone_edge (edge, id->dst_node, stmt,
1378 REG_BR_PROB_BASE, 1,
1379 edge->frequency, true);
1382 case CB_CGE_MOVE_CLONES:
1383 for (node = id->dst_node->next_clone;
1385 node = node->next_clone)
1387 edge = cgraph_edge (node, orig_stmt);
1389 cgraph_set_call_stmt (edge, stmt);
1394 edge = cgraph_edge (id->dst_node, orig_stmt);
1396 cgraph_set_call_stmt (edge, stmt);
1404 /* If you think we can abort here, you are wrong.
1405 There is no region 0 in gimple. */
1406 gcc_assert (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) != 0);
1408 if (stmt_could_throw_p (stmt)
1409 /* When we are cloning for inlining, we are supposed to
1410 construct a clone that calls precisely the same functions
1411 as original. However IPA optimizers might've proved
1412 earlier some function calls as non-trapping that might
1413 render some basic blocks dead that might become
1416 We can't update SSA with unreachable blocks in CFG and thus
1417 we prevent the scenario by preserving even the "dead" eh
1418 edges until the point they are later removed by
1420 || (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES
1421 && lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) > 0))
1423 int region = lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt);
1425 /* Add an entry for the copied tree in the EH hashtable.
1426 When cloning or versioning, use the hashtable in
1427 cfun, and just copy the EH number. When inlining, use the
1428 hashtable in the caller, and adjust the region number. */
1430 add_stmt_to_eh_region (stmt, region + id->eh_region_offset);
1432 /* If this tree doesn't have a region associated with it,
1433 and there is a "current region,"
1434 then associate this tree with the current region
1435 and add edges associated with this region. */
1436 if (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) <= 0
1437 && id->eh_region > 0
1438 && stmt_could_throw_p (stmt))
1439 add_stmt_to_eh_region (stmt, id->eh_region);
1442 if (gimple_in_ssa_p (cfun))
1447 find_new_referenced_vars (gsi_stmt (copy_gsi));
1448 FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
1449 if (TREE_CODE (def) == SSA_NAME)
1450 SSA_NAME_DEF_STMT (def) = stmt;
1453 gsi_next (©_gsi);
1456 copy_gsi = gsi_last_bb (copy_basic_block);
1459 return copy_basic_block;
1462 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1463 form is quite easy, since dominator relationship for old basic blocks does
1466 There is however exception where inlining might change dominator relation
1467 across EH edges from basic block within inlined functions destinating
1468 to landing pads in function we inline into.
1470 The function fills in PHI_RESULTs of such PHI nodes if they refer
1471 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1472 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1473 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1474 set, and this means that there will be no overlapping live ranges
1475 for the underlying symbol.
1477 This might change in future if we allow redirecting of EH edges and
1478 we might want to change way build CFG pre-inlining to include
1479 all the possible edges then. */
1481 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
1482 bool can_throw, bool nonlocal_goto)
1487 FOR_EACH_EDGE (e, ei, bb->succs)
1489 || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
1492 gimple_stmt_iterator si;
1494 gcc_assert (e->flags & EDGE_ABNORMAL);
1497 gcc_assert (e->flags & EDGE_EH);
1500 gcc_assert (!(e->flags & EDGE_EH));
1502 for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si))
1506 phi = gsi_stmt (si);
1508 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */
1509 gcc_assert (!e->dest->aux);
1511 gcc_assert (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)));
1513 if (!is_gimple_reg (PHI_RESULT (phi)))
1515 mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi)));
1519 re = find_edge (ret_bb, e->dest);
1521 gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
1522 == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
1524 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
1525 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
1531 /* Copy edges from BB into its copy constructed earlier, scale profile
1532 accordingly. Edges will be taken care of later. Assume aux
1533 pointers to point to the copies of each BB. */
1536 copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb)
1538 basic_block new_bb = (basic_block) bb->aux;
1541 gimple_stmt_iterator si;
1544 /* Use the indices from the original blocks to create edges for the
1546 FOR_EACH_EDGE (old_edge, ei, bb->succs)
1547 if (!(old_edge->flags & EDGE_EH))
1551 flags = old_edge->flags;
1553 /* Return edges do get a FALLTHRU flag when the get inlined. */
1554 if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
1555 && old_edge->dest->aux != EXIT_BLOCK_PTR)
1556 flags |= EDGE_FALLTHRU;
1557 new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
1558 new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
1559 new_edge->probability = old_edge->probability;
1562 if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
1565 for (si = gsi_start_bb (new_bb); !gsi_end_p (si);)
1568 bool can_throw, nonlocal_goto;
1570 copy_stmt = gsi_stmt (si);
1571 update_stmt (copy_stmt);
1572 if (gimple_in_ssa_p (cfun))
1573 mark_symbols_for_renaming (copy_stmt);
1575 /* Do this before the possible split_block. */
1578 /* If this tree could throw an exception, there are two
1579 cases where we need to add abnormal edge(s): the
1580 tree wasn't in a region and there is a "current
1581 region" in the caller; or the original tree had
1582 EH edges. In both cases split the block after the tree,
1583 and add abnormal edge(s) as needed; we need both
1584 those from the callee and the caller.
1585 We check whether the copy can throw, because the const
1586 propagation can change an INDIRECT_REF which throws
1587 into a COMPONENT_REF which doesn't. If the copy
1588 can throw, the original could also throw. */
1589 can_throw = stmt_can_throw_internal (copy_stmt);
1590 nonlocal_goto = stmt_can_make_abnormal_goto (copy_stmt);
1592 if (can_throw || nonlocal_goto)
1594 if (!gsi_end_p (si))
1595 /* Note that bb's predecessor edges aren't necessarily
1596 right at this point; split_block doesn't care. */
1598 edge e = split_block (new_bb, copy_stmt);
1601 new_bb->aux = e->src->aux;
1602 si = gsi_start_bb (new_bb);
1607 make_eh_edges (copy_stmt);
1610 make_abnormal_goto_edges (gimple_bb (copy_stmt), true);
1612 if ((can_throw || nonlocal_goto)
1613 && gimple_in_ssa_p (cfun))
1614 update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb,
1615 can_throw, nonlocal_goto);
1619 /* Copy the PHIs. All blocks and edges are copied, some blocks
1620 was possibly split and new outgoing EH edges inserted.
1621 BB points to the block of original function and AUX pointers links
1622 the original and newly copied blocks. */
1625 copy_phis_for_bb (basic_block bb, copy_body_data *id)
1627 basic_block const new_bb = (basic_block) bb->aux;
1630 gimple_stmt_iterator si;
1632 for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si))
1638 phi = gsi_stmt (si);
1639 res = PHI_RESULT (phi);
1641 if (is_gimple_reg (res))
1643 walk_tree (&new_res, copy_tree_body_r, id, NULL);
1644 SSA_NAME_DEF_STMT (new_res)
1645 = new_phi = create_phi_node (new_res, new_bb);
1646 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
1649 = find_edge ((basic_block) new_edge->src->aux, bb);
1650 tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
1652 tree block = id->block;
1653 id->block = NULL_TREE;
1654 walk_tree (&new_arg, copy_tree_body_r, id, NULL);
1656 gcc_assert (new_arg);
1657 /* With return slot optimization we can end up with
1658 non-gimple (foo *)&this->m, fix that here. */
1659 if (TREE_CODE (new_arg) != SSA_NAME
1660 && TREE_CODE (new_arg) != FUNCTION_DECL
1661 && !is_gimple_val (new_arg))
1663 gimple_seq stmts = NULL;
1664 new_arg = force_gimple_operand (new_arg, &stmts, true, NULL);
1665 gsi_insert_seq_on_edge_immediate (new_edge, stmts);
1667 add_phi_arg (new_phi, new_arg, new_edge);
1674 /* Wrapper for remap_decl so it can be used as a callback. */
1677 remap_decl_1 (tree decl, void *data)
1679 return remap_decl (decl, (copy_body_data *) data);
1682 /* Build struct function and associated datastructures for the new clone
1683 NEW_FNDECL to be build. CALLEE_FNDECL is the original */
1686 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count,
1689 struct function *new_cfun
1690 = (struct function *) ggc_alloc_cleared (sizeof (struct function));
1691 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1692 gcov_type count_scale, frequency_scale;
1694 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1695 count_scale = (REG_BR_PROB_BASE * count
1696 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1700 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1701 frequency_scale = (REG_BR_PROB_BASE * frequency
1703 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1705 frequency_scale = count_scale;
1707 /* Register specific tree functions. */
1708 gimple_register_cfg_hooks ();
1709 *new_cfun = *DECL_STRUCT_FUNCTION (callee_fndecl);
1710 new_cfun->funcdef_no = get_next_funcdef_no ();
1711 VALUE_HISTOGRAMS (new_cfun) = NULL;
1712 new_cfun->local_decls = NULL;
1713 new_cfun->cfg = NULL;
1714 new_cfun->decl = new_fndecl /*= copy_node (callee_fndecl)*/;
1715 DECL_STRUCT_FUNCTION (new_fndecl) = new_cfun;
1716 push_cfun (new_cfun);
1717 init_empty_tree_cfg ();
1719 ENTRY_BLOCK_PTR->count =
1720 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1722 ENTRY_BLOCK_PTR->frequency =
1723 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1724 frequency_scale / REG_BR_PROB_BASE);
1725 EXIT_BLOCK_PTR->count =
1726 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1728 EXIT_BLOCK_PTR->frequency =
1729 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1730 frequency_scale / REG_BR_PROB_BASE);
1732 init_eh_for_function ();
1734 if (src_cfun->gimple_df)
1736 init_tree_ssa (cfun);
1737 cfun->gimple_df->in_ssa_p = true;
1738 init_ssa_operands ();
1743 /* Make a copy of the body of FN so that it can be inserted inline in
1744 another function. Walks FN via CFG, returns new fndecl. */
1747 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency,
1748 basic_block entry_block_map, basic_block exit_block_map)
1750 tree callee_fndecl = id->src_fn;
1751 /* Original cfun for the callee, doesn't change. */
1752 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1753 struct function *cfun_to_copy;
1755 tree new_fndecl = NULL;
1756 gcov_type count_scale, frequency_scale;
1759 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1760 count_scale = (REG_BR_PROB_BASE * count
1761 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1765 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1766 frequency_scale = (REG_BR_PROB_BASE * frequency
1768 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1770 frequency_scale = count_scale;
1772 /* Register specific tree functions. */
1773 gimple_register_cfg_hooks ();
1775 /* Must have a CFG here at this point. */
1776 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
1777 (DECL_STRUCT_FUNCTION (callee_fndecl)));
1779 cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1781 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
1782 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
1783 entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1784 exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1786 /* Duplicate any exception-handling regions. */
1789 id->eh_region_offset
1790 = duplicate_eh_regions (cfun_to_copy, remap_decl_1, id,
1794 /* Use aux pointers to map the original blocks to copy. */
1795 FOR_EACH_BB_FN (bb, cfun_to_copy)
1797 basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale);
1802 last = last_basic_block;
1804 /* Now that we've duplicated the blocks, duplicate their edges. */
1805 FOR_ALL_BB_FN (bb, cfun_to_copy)
1806 copy_edges_for_bb (bb, count_scale, exit_block_map);
1808 if (gimple_in_ssa_p (cfun))
1809 FOR_ALL_BB_FN (bb, cfun_to_copy)
1810 copy_phis_for_bb (bb, id);
1812 FOR_ALL_BB_FN (bb, cfun_to_copy)
1814 ((basic_block)bb->aux)->aux = NULL;
1818 /* Zero out AUX fields of newly created block during EH edge
1820 for (; last < last_basic_block; last++)
1821 BASIC_BLOCK (last)->aux = NULL;
1822 entry_block_map->aux = NULL;
1823 exit_block_map->aux = NULL;
1829 copy_body (copy_body_data *id, gcov_type count, int frequency,
1830 basic_block entry_block_map, basic_block exit_block_map)
1832 tree fndecl = id->src_fn;
1835 /* If this body has a CFG, walk CFG and copy. */
1836 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
1837 body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map);
1842 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
1843 defined in function FN, or of a data member thereof. */
1846 self_inlining_addr_expr (tree value, tree fn)
1850 if (TREE_CODE (value) != ADDR_EXPR)
1853 var = get_base_address (TREE_OPERAND (value, 0));
1855 return var && auto_var_in_fn_p (var, fn);
1859 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
1860 basic_block bb, tree *vars)
1865 tree def = (gimple_in_ssa_p (cfun)
1866 ? gimple_default_def (id->src_cfun, p) : NULL);
1869 && value != error_mark_node
1870 && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
1872 if (fold_convertible_p (TREE_TYPE (p), value))
1873 rhs = fold_build1 (NOP_EXPR, TREE_TYPE (p), value);
1875 /* ??? For valid (GIMPLE) programs we should not end up here.
1876 Still if something has gone wrong and we end up with truly
1877 mismatched types here, fall back to using a VIEW_CONVERT_EXPR
1878 to not leak invalid GIMPLE to the following passes. */
1879 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (p), value);
1882 /* If the parameter is never assigned to, has no SSA_NAMEs created,
1883 we may not need to create a new variable here at all. Instead, we may
1884 be able to just use the argument value. */
1885 if (TREE_READONLY (p)
1886 && !TREE_ADDRESSABLE (p)
1887 && value && !TREE_SIDE_EFFECTS (value)
1890 /* We may produce non-gimple trees by adding NOPs or introduce
1891 invalid sharing when operand is not really constant.
1892 It is not big deal to prohibit constant propagation here as
1893 we will constant propagate in DOM1 pass anyway. */
1894 if (is_gimple_min_invariant (value)
1895 && useless_type_conversion_p (TREE_TYPE (p),
1897 /* We have to be very careful about ADDR_EXPR. Make sure
1898 the base variable isn't a local variable of the inlined
1899 function, e.g., when doing recursive inlining, direct or
1900 mutually-recursive or whatever, which is why we don't
1901 just test whether fn == current_function_decl. */
1902 && ! self_inlining_addr_expr (value, fn))
1904 insert_decl_map (id, p, value);
1909 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
1910 here since the type of this decl must be visible to the calling
1912 var = copy_decl_to_var (p, id);
1913 if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL)
1916 add_referenced_var (var);
1919 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
1920 that way, when the PARM_DECL is encountered, it will be
1921 automatically replaced by the VAR_DECL. */
1922 insert_decl_map (id, p, var);
1924 /* Declare this new variable. */
1925 TREE_CHAIN (var) = *vars;
1928 /* Make gimplifier happy about this variable. */
1929 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1931 /* Even if P was TREE_READONLY, the new VAR should not be.
1932 In the original code, we would have constructed a
1933 temporary, and then the function body would have never
1934 changed the value of P. However, now, we will be
1935 constructing VAR directly. The constructor body may
1936 change its value multiple times as it is being
1937 constructed. Therefore, it must not be TREE_READONLY;
1938 the back-end assumes that TREE_READONLY variable is
1939 assigned to only once. */
1940 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
1941 TREE_READONLY (var) = 0;
1943 /* If there is no setup required and we are in SSA, take the easy route
1944 replacing all SSA names representing the function parameter by the
1945 SSA name passed to function.
1947 We need to construct map for the variable anyway as it might be used
1948 in different SSA names when parameter is set in function.
1950 FIXME: This usually kills the last connection in between inlined
1951 function parameter and the actual value in debug info. Can we do
1952 better here? If we just inserted the statement, copy propagation
1953 would kill it anyway as it always did in older versions of GCC.
1955 We might want to introduce a notion that single SSA_NAME might
1956 represent multiple variables for purposes of debugging. */
1957 if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
1958 && (TREE_CODE (rhs) == SSA_NAME
1959 || is_gimple_min_invariant (rhs))
1960 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
1962 insert_decl_map (id, def, rhs);
1966 /* If the value of argument is never used, don't care about initializing
1968 if (gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
1970 gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
1974 /* Initialize this VAR_DECL from the equivalent argument. Convert
1975 the argument to the proper type in case it was promoted. */
1978 gimple_stmt_iterator si = gsi_last_bb (bb);
1980 if (rhs == error_mark_node)
1982 insert_decl_map (id, p, var);
1986 STRIP_USELESS_TYPE_CONVERSION (rhs);
1988 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
1989 keep our trees in gimple form. */
1990 if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p))
1992 def = remap_ssa_name (def, id);
1993 init_stmt = gimple_build_assign (def, rhs);
1994 SSA_NAME_IS_DEFAULT_DEF (def) = 0;
1995 set_default_def (var, NULL);
1998 init_stmt = gimple_build_assign (var, rhs);
2000 /* If we did not create a gimple value and we did not create a gimple
2001 cast of a gimple value, then we will need to gimplify INIT_STMT
2002 at the end. Note that is_gimple_cast only checks the outer
2003 tree code, not its operand. Thus the explicit check that its
2004 operand is a gimple value. */
2005 if ((!is_gimple_val (rhs)
2006 && (!is_gimple_cast (rhs)
2007 || !is_gimple_val (TREE_OPERAND (rhs, 0))))
2008 || !is_gimple_reg (var))
2010 gimple_stmt_iterator i;
2011 gimple_seq seq = gimple_seq_alloc ();
2012 struct gimplify_ctx gctx;
2014 push_gimplify_context (&gctx);
2016 i = gsi_start (seq);
2017 gimple_regimplify_operands (init_stmt, &i);
2019 if (gimple_in_ssa_p (cfun)
2021 && !gimple_seq_empty_p (seq))
2023 /* The replacement can expose previously unreferenced
2025 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
2026 find_new_referenced_vars (gsi_stmt (i));
2028 /* Insert the gimplified sequence needed for INIT_STMT
2029 after SI. INIT_STMT will be inserted after SEQ. */
2030 gsi_insert_seq_after (&si, seq, GSI_NEW_STMT);
2033 pop_gimplify_context (NULL);
2036 /* If VAR represents a zero-sized variable, it's possible that the
2037 assignment statement may result in no gimple statements. */
2039 gsi_insert_after (&si, init_stmt, GSI_NEW_STMT);
2041 if (gimple_in_ssa_p (cfun))
2042 for (;!gsi_end_p (si); gsi_next (&si))
2043 mark_symbols_for_renaming (gsi_stmt (si));
2047 /* Generate code to initialize the parameters of the function at the
2048 top of the stack in ID from the GIMPLE_CALL STMT. */
2051 initialize_inlined_parameters (copy_body_data *id, gimple stmt,
2052 tree fn, basic_block bb)
2057 tree vars = NULL_TREE;
2058 tree static_chain = gimple_call_chain (stmt);
2060 /* Figure out what the parameters are. */
2061 parms = DECL_ARGUMENTS (fn);
2063 /* Loop through the parameter declarations, replacing each with an
2064 equivalent VAR_DECL, appropriately initialized. */
2065 for (p = parms, i = 0; p; p = TREE_CHAIN (p), i++)
2068 val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL;
2069 setup_one_parameter (id, p, val, fn, bb, &vars);
2072 /* Initialize the static chain. */
2073 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
2074 gcc_assert (fn != current_function_decl);
2077 /* No static chain? Seems like a bug in tree-nested.c. */
2078 gcc_assert (static_chain);
2080 setup_one_parameter (id, p, static_chain, fn, bb, &vars);
2083 declare_inline_vars (id->block, vars);
2087 /* Declare a return variable to replace the RESULT_DECL for the
2088 function we are calling. An appropriate DECL_STMT is returned.
2089 The USE_STMT is filled to contain a use of the declaration to
2090 indicate the return value of the function.
2092 RETURN_SLOT, if non-null is place where to store the result. It
2093 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
2094 was the LHS of the MODIFY_EXPR to which this call is the RHS.
2096 The return value is a (possibly null) value that is the result of the
2097 function as seen by the callee. *USE_P is a (possibly null) value that
2098 holds the result as seen by the caller. */
2101 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
2104 tree callee = id->src_fn;
2105 tree caller = id->dst_fn;
2106 tree result = DECL_RESULT (callee);
2107 tree callee_type = TREE_TYPE (result);
2108 tree caller_type = TREE_TYPE (TREE_TYPE (callee));
2111 /* We don't need to do anything for functions that don't return
2113 if (!result || VOID_TYPE_P (callee_type))
2119 /* If there was a return slot, then the return value is the
2120 dereferenced address of that object. */
2123 /* The front end shouldn't have used both return_slot and
2124 a modify expression. */
2125 gcc_assert (!modify_dest);
2126 if (DECL_BY_REFERENCE (result))
2128 tree return_slot_addr = build_fold_addr_expr (return_slot);
2129 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
2131 /* We are going to construct *&return_slot and we can't do that
2132 for variables believed to be not addressable.
2134 FIXME: This check possibly can match, because values returned
2135 via return slot optimization are not believed to have address
2136 taken by alias analysis. */
2137 gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
2138 if (gimple_in_ssa_p (cfun))
2140 HOST_WIDE_INT bitsize;
2141 HOST_WIDE_INT bitpos;
2143 enum machine_mode mode;
2147 base = get_inner_reference (return_slot, &bitsize, &bitpos,
2149 &mode, &unsignedp, &volatilep,
2151 if (TREE_CODE (base) == INDIRECT_REF)
2152 base = TREE_OPERAND (base, 0);
2153 if (TREE_CODE (base) == SSA_NAME)
2154 base = SSA_NAME_VAR (base);
2155 mark_sym_for_renaming (base);
2157 var = return_slot_addr;
2162 gcc_assert (TREE_CODE (var) != SSA_NAME);
2163 TREE_ADDRESSABLE (var) |= TREE_ADDRESSABLE (result);
2165 if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2166 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2167 && !DECL_GIMPLE_REG_P (result)
2169 DECL_GIMPLE_REG_P (var) = 0;
2174 /* All types requiring non-trivial constructors should have been handled. */
2175 gcc_assert (!TREE_ADDRESSABLE (callee_type));
2177 /* Attempt to avoid creating a new temporary variable. */
2179 && TREE_CODE (modify_dest) != SSA_NAME)
2181 bool use_it = false;
2183 /* We can't use MODIFY_DEST if there's type promotion involved. */
2184 if (!useless_type_conversion_p (callee_type, caller_type))
2187 /* ??? If we're assigning to a variable sized type, then we must
2188 reuse the destination variable, because we've no good way to
2189 create variable sized temporaries at this point. */
2190 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
2193 /* If the callee cannot possibly modify MODIFY_DEST, then we can
2194 reuse it as the result of the call directly. Don't do this if
2195 it would promote MODIFY_DEST to addressable. */
2196 else if (TREE_ADDRESSABLE (result))
2200 tree base_m = get_base_address (modify_dest);
2202 /* If the base isn't a decl, then it's a pointer, and we don't
2203 know where that's going to go. */
2204 if (!DECL_P (base_m))
2206 else if (is_global_var (base_m))
2208 else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
2209 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
2210 && !DECL_GIMPLE_REG_P (result)
2211 && DECL_GIMPLE_REG_P (base_m))
2213 else if (!TREE_ADDRESSABLE (base_m))
2225 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
2227 var = copy_result_decl_to_var (result, id);
2228 if (gimple_in_ssa_p (cfun))
2231 add_referenced_var (var);
2234 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
2235 DECL_STRUCT_FUNCTION (caller)->local_decls
2236 = tree_cons (NULL_TREE, var,
2237 DECL_STRUCT_FUNCTION (caller)->local_decls);
2239 /* Do not have the rest of GCC warn about this variable as it should
2240 not be visible to the user. */
2241 TREE_NO_WARNING (var) = 1;
2243 declare_inline_vars (id->block, var);
2245 /* Build the use expr. If the return type of the function was
2246 promoted, convert it back to the expected type. */
2248 if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
2249 use = fold_convert (caller_type, var);
2251 STRIP_USELESS_TYPE_CONVERSION (use);
2253 if (DECL_BY_REFERENCE (result))
2254 var = build_fold_addr_expr (var);
2257 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
2258 way, when the RESULT_DECL is encountered, it will be
2259 automatically replaced by the VAR_DECL. */
2260 insert_decl_map (id, result, var);
2262 /* Remember this so we can ignore it in remap_decls. */
2269 /* Returns nonzero if a function can be inlined as a tree. */
2272 tree_inlinable_function_p (tree fn)
2274 bool ret = inlinable_function_p (fn);
2276 if (getenv ("TUPLES_INLINE"))
2277 fprintf (stderr, "Function %s is %sinlinable\n", get_name (fn),
2283 static const char *inline_forbidden_reason;
2285 /* A callback for walk_gimple_seq to handle tree operands. Returns
2286 NULL_TREE if a function can be inlined, otherwise sets the reason
2287 why not and returns a tree representing the offending operand. */
2290 inline_forbidden_p_op (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
2291 void *fnp ATTRIBUTE_UNUSED)
2296 if (TREE_CODE (node) == RECORD_TYPE || TREE_CODE (node) == UNION_TYPE)
2298 /* We cannot inline a function of the form
2300 void F (int i) { struct S { int ar[i]; } s; }
2302 Attempting to do so produces a catch-22.
2303 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
2304 UNION_TYPE nodes, then it goes into infinite recursion on a
2305 structure containing a pointer to its own type. If it doesn't,
2306 then the type node for S doesn't get adjusted properly when
2309 ??? This is likely no longer true, but it's too late in the 4.0
2310 cycle to try to find out. This should be checked for 4.1. */
2311 for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
2312 if (variably_modified_type_p (TREE_TYPE (t), NULL))
2314 inline_forbidden_reason
2315 = G_("function %q+F can never be inlined "
2316 "because it uses variable sized variables");
2325 /* A callback for walk_gimple_seq to handle statements. Returns
2326 non-NULL iff a function can not be inlined. Also sets the reason
2330 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2331 struct walk_stmt_info *wip)
2333 tree fn = (tree) wip->info;
2335 gimple stmt = gsi_stmt (*gsi);
2337 switch (gimple_code (stmt))
2340 /* Refuse to inline alloca call unless user explicitly forced so as
2341 this may change program's memory overhead drastically when the
2342 function using alloca is called in loop. In GCC present in
2343 SPEC2000 inlining into schedule_block cause it to require 2GB of
2344 RAM instead of 256MB. */
2345 if (gimple_alloca_call_p (stmt)
2346 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
2348 inline_forbidden_reason
2349 = G_("function %q+F can never be inlined because it uses "
2350 "alloca (override using the always_inline attribute)");
2351 *handled_ops_p = true;
2355 t = gimple_call_fndecl (stmt);
2359 /* We cannot inline functions that call setjmp. */
2360 if (setjmp_call_p (t))
2362 inline_forbidden_reason
2363 = G_("function %q+F can never be inlined because it uses setjmp");
2364 *handled_ops_p = true;
2368 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
2369 switch (DECL_FUNCTION_CODE (t))
2371 /* We cannot inline functions that take a variable number of
2373 case BUILT_IN_VA_START:
2374 case BUILT_IN_NEXT_ARG:
2375 case BUILT_IN_VA_END:
2376 inline_forbidden_reason
2377 = G_("function %q+F can never be inlined because it "
2378 "uses variable argument lists");
2379 *handled_ops_p = true;
2382 case BUILT_IN_LONGJMP:
2383 /* We can't inline functions that call __builtin_longjmp at
2384 all. The non-local goto machinery really requires the
2385 destination be in a different function. If we allow the
2386 function calling __builtin_longjmp to be inlined into the
2387 function calling __builtin_setjmp, Things will Go Awry. */
2388 inline_forbidden_reason
2389 = G_("function %q+F can never be inlined because "
2390 "it uses setjmp-longjmp exception handling");
2391 *handled_ops_p = true;
2394 case BUILT_IN_NONLOCAL_GOTO:
2396 inline_forbidden_reason
2397 = G_("function %q+F can never be inlined because "
2398 "it uses non-local goto");
2399 *handled_ops_p = true;
2402 case BUILT_IN_RETURN:
2403 case BUILT_IN_APPLY_ARGS:
2404 /* If a __builtin_apply_args caller would be inlined,
2405 it would be saving arguments of the function it has
2406 been inlined into. Similarly __builtin_return would
2407 return from the function the inline has been inlined into. */
2408 inline_forbidden_reason
2409 = G_("function %q+F can never be inlined because "
2410 "it uses __builtin_return or __builtin_apply_args");
2411 *handled_ops_p = true;
2420 t = gimple_goto_dest (stmt);
2422 /* We will not inline a function which uses computed goto. The
2423 addresses of its local labels, which may be tucked into
2424 global storage, are of course not constant across
2425 instantiations, which causes unexpected behavior. */
2426 if (TREE_CODE (t) != LABEL_DECL)
2428 inline_forbidden_reason
2429 = G_("function %q+F can never be inlined "
2430 "because it contains a computed goto");
2431 *handled_ops_p = true;
2437 t = gimple_label_label (stmt);
2438 if (DECL_NONLOCAL (t))
2440 /* We cannot inline a function that receives a non-local goto
2441 because we cannot remap the destination label used in the
2442 function that is performing the non-local goto. */
2443 inline_forbidden_reason
2444 = G_("function %q+F can never be inlined "
2445 "because it receives a non-local goto");
2446 *handled_ops_p = true;
2455 *handled_ops_p = false;
2461 inline_forbidden_p_2 (tree *nodep, int *walk_subtrees,
2465 tree fn = (tree) fnp;
2467 if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
2469 inline_forbidden_reason
2470 = G_("function %q+F can never be inlined "
2471 "because it saves address of local label in a static variable");
2481 /* Return true if FNDECL is a function that cannot be inlined into
2485 inline_forbidden_p (tree fndecl)
2487 location_t saved_loc = input_location;
2488 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
2490 struct walk_stmt_info wi;
2491 struct pointer_set_t *visited_nodes;
2493 bool forbidden_p = false;
2495 visited_nodes = pointer_set_create ();
2496 memset (&wi, 0, sizeof (wi));
2497 wi.info = (void *) fndecl;
2498 wi.pset = visited_nodes;
2500 FOR_EACH_BB_FN (bb, fun)
2503 gimple_seq seq = bb_seq (bb);
2504 ret = walk_gimple_seq (seq, inline_forbidden_p_stmt,
2505 inline_forbidden_p_op, &wi);
2506 forbidden_p = (ret != NULL);
2511 for (step = fun->local_decls; step; step = TREE_CHAIN (step))
2513 tree decl = TREE_VALUE (step);
2514 if (TREE_CODE (decl) == VAR_DECL
2515 && TREE_STATIC (decl)
2516 && !DECL_EXTERNAL (decl)
2517 && DECL_INITIAL (decl))
2520 ret = walk_tree_without_duplicates (&DECL_INITIAL (decl),
2521 inline_forbidden_p_2, fndecl);
2522 forbidden_p = (ret != NULL);
2529 pointer_set_destroy (visited_nodes);
2530 input_location = saved_loc;
2534 /* Returns nonzero if FN is a function that does not have any
2535 fundamental inline blocking properties. */
2538 inlinable_function_p (tree fn)
2540 bool inlinable = true;
2544 /* If we've already decided this function shouldn't be inlined,
2545 there's no need to check again. */
2546 if (DECL_UNINLINABLE (fn))
2549 /* We only warn for functions declared `inline' by the user. */
2550 do_warning = (warn_inline
2551 && DECL_DECLARED_INLINE_P (fn)
2552 && !DECL_IN_SYSTEM_HEADER (fn));
2554 always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
2557 && always_inline == NULL)
2560 warning (OPT_Winline, "function %q+F can never be inlined because it "
2561 "is suppressed using -fno-inline", fn);
2565 /* Don't auto-inline anything that might not be bound within
2566 this unit of translation. */
2567 else if (!DECL_DECLARED_INLINE_P (fn)
2568 && DECL_REPLACEABLE_P (fn))
2571 else if (!function_attribute_inlinable_p (fn))
2574 warning (OPT_Winline, "function %q+F can never be inlined because it "
2575 "uses attributes conflicting with inlining", fn);
2579 /* If we don't have the function body available, we can't inline it.
2580 However, this should not be recorded since we also get here for
2581 forward declared inline functions. Therefore, return at once. */
2582 if (!gimple_body (fn))
2585 else if (inline_forbidden_p (fn))
2587 /* See if we should warn about uninlinable functions. Previously,
2588 some of these warnings would be issued while trying to expand
2589 the function inline, but that would cause multiple warnings
2590 about functions that would for example call alloca. But since
2591 this a property of the function, just one warning is enough.
2592 As a bonus we can now give more details about the reason why a
2593 function is not inlinable. */
2595 sorry (inline_forbidden_reason, fn);
2596 else if (do_warning)
2597 warning (OPT_Winline, inline_forbidden_reason, fn);
2602 /* Squirrel away the result so that we don't have to check again. */
2603 DECL_UNINLINABLE (fn) = !inlinable;
2608 /* Estimate the cost of a memory move. Use machine dependent
2609 word size and take possible memcpy call into account. */
2612 estimate_move_cost (tree type)
2616 size = int_size_in_bytes (type);
2618 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
2619 /* Cost of a memcpy call, 3 arguments and the call. */
2622 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
2625 /* Returns cost of operation CODE, according to WEIGHTS */
2628 estimate_operator_cost (enum tree_code code, eni_weights *weights)
2632 /* These are "free" conversions, or their presumed cost
2633 is folded into other operations. */
2640 /* Assign cost of 1 to usual operations.
2641 ??? We may consider mapping RTL costs to this. */
2646 case POINTER_PLUS_EXPR:
2650 case FIXED_CONVERT_EXPR:
2651 case FIX_TRUNC_EXPR:
2663 case VEC_LSHIFT_EXPR:
2664 case VEC_RSHIFT_EXPR:
2671 case TRUTH_ANDIF_EXPR:
2672 case TRUTH_ORIF_EXPR:
2673 case TRUTH_AND_EXPR:
2675 case TRUTH_XOR_EXPR:
2676 case TRUTH_NOT_EXPR:
2685 case UNORDERED_EXPR:
2696 case PREDECREMENT_EXPR:
2697 case PREINCREMENT_EXPR:
2698 case POSTDECREMENT_EXPR:
2699 case POSTINCREMENT_EXPR:
2701 case REALIGN_LOAD_EXPR:
2703 case REDUC_MAX_EXPR:
2704 case REDUC_MIN_EXPR:
2705 case REDUC_PLUS_EXPR:
2706 case WIDEN_SUM_EXPR:
2707 case WIDEN_MULT_EXPR:
2710 case VEC_WIDEN_MULT_HI_EXPR:
2711 case VEC_WIDEN_MULT_LO_EXPR:
2712 case VEC_UNPACK_HI_EXPR:
2713 case VEC_UNPACK_LO_EXPR:
2714 case VEC_UNPACK_FLOAT_HI_EXPR:
2715 case VEC_UNPACK_FLOAT_LO_EXPR:
2716 case VEC_PACK_TRUNC_EXPR:
2717 case VEC_PACK_SAT_EXPR:
2718 case VEC_PACK_FIX_TRUNC_EXPR:
2719 case VEC_EXTRACT_EVEN_EXPR:
2720 case VEC_EXTRACT_ODD_EXPR:
2721 case VEC_INTERLEAVE_HIGH_EXPR:
2722 case VEC_INTERLEAVE_LOW_EXPR:
2726 /* Few special cases of expensive operations. This is useful
2727 to avoid inlining on functions having too many of these. */
2728 case TRUNC_DIV_EXPR:
2730 case FLOOR_DIV_EXPR:
2731 case ROUND_DIV_EXPR:
2732 case EXACT_DIV_EXPR:
2733 case TRUNC_MOD_EXPR:
2735 case FLOOR_MOD_EXPR:
2736 case ROUND_MOD_EXPR:
2738 return weights->div_mod_cost;
2741 /* We expect a copy assignment with no operator. */
2742 gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS);
2748 /* Estimate number of instructions that will be created by expanding
2749 the statements in the statement sequence STMTS.
2750 WEIGHTS contains weights attributed to various constructs. */
2753 int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights)
2756 gimple_stmt_iterator gsi;
2759 for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
2760 cost += estimate_num_insns (gsi_stmt (gsi), weights);
2766 /* Estimate number of instructions that will be created by expanding STMT.
2767 WEIGHTS contains weights attributed to various constructs. */
2770 estimate_num_insns (gimple stmt, eni_weights *weights)
2773 enum gimple_code code = gimple_code (stmt);
2779 /* Try to estimate the cost of assignments. We have three cases to
2781 1) Simple assignments to registers;
2782 2) Stores to things that must live in memory. This includes
2783 "normal" stores to scalars, but also assignments of large
2784 structures, or constructors of big arrays;
2786 Let us look at the first two cases, assuming we have "a = b + C":
2787 <GIMPLE_ASSIGN <var_decl "a">
2788 <plus_expr <var_decl "b"> <constant C>>
2789 If "a" is a GIMPLE register, the assignment to it is free on almost
2790 any target, because "a" usually ends up in a real register. Hence
2791 the only cost of this expression comes from the PLUS_EXPR, and we
2792 can ignore the GIMPLE_ASSIGN.
2793 If "a" is not a GIMPLE register, the assignment to "a" will most
2794 likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost
2795 of moving something into "a", which we compute using the function
2796 estimate_move_cost. */
2797 lhs = gimple_assign_lhs (stmt);
2798 if (is_gimple_reg (lhs))
2801 cost = estimate_move_cost (TREE_TYPE (lhs));
2803 cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights);
2807 cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights);
2811 /* Take into account cost of the switch + guess 2 conditional jumps for
2814 TODO: once the switch expansion logic is sufficiently separated, we can
2815 do better job on estimating cost of the switch. */
2816 cost = gimple_switch_num_labels (stmt) * 2;
2821 tree decl = gimple_call_fndecl (stmt);
2822 tree addr = gimple_call_fn (stmt);
2823 tree funtype = TREE_TYPE (addr);
2825 if (POINTER_TYPE_P (funtype))
2826 funtype = TREE_TYPE (funtype);
2828 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
2829 cost = weights->target_builtin_call_cost;
2831 cost = weights->call_cost;
2833 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2834 switch (DECL_FUNCTION_CODE (decl))
2836 case BUILT_IN_CONSTANT_P:
2838 case BUILT_IN_EXPECT:
2842 /* Prefetch instruction is not expensive. */
2843 case BUILT_IN_PREFETCH:
2844 cost = weights->target_builtin_call_cost;
2852 funtype = TREE_TYPE (decl);
2854 /* Our cost must be kept in sync with
2855 cgraph_estimate_size_after_inlining that does use function
2856 declaration to figure out the arguments. */
2857 if (decl && DECL_ARGUMENTS (decl))
2860 for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2861 cost += estimate_move_cost (TREE_TYPE (arg));
2863 else if (funtype && prototype_p (funtype))
2866 for (t = TYPE_ARG_TYPES (funtype); t; t = TREE_CHAIN (t))
2867 cost += estimate_move_cost (TREE_VALUE (t));
2871 for (i = 0; i < gimple_call_num_args (stmt); i++)
2873 tree arg = gimple_call_arg (stmt, i);
2874 cost += estimate_move_cost (TREE_TYPE (arg));
2886 case GIMPLE_CHANGE_DYNAMIC_TYPE:
2887 case GIMPLE_PREDICT:
2895 return estimate_num_insns_seq (gimple_bind_body (stmt), weights);
2897 case GIMPLE_EH_FILTER:
2898 return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights);
2901 return estimate_num_insns_seq (gimple_catch_handler (stmt), weights);
2904 return (estimate_num_insns_seq (gimple_try_eval (stmt), weights)
2905 + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights));
2907 /* OpenMP directives are generally very expensive. */
2909 case GIMPLE_OMP_RETURN:
2910 case GIMPLE_OMP_SECTIONS_SWITCH:
2911 case GIMPLE_OMP_ATOMIC_STORE:
2912 case GIMPLE_OMP_CONTINUE:
2913 /* ...except these, which are cheap. */
2916 case GIMPLE_OMP_ATOMIC_LOAD:
2917 return weights->omp_cost;
2919 case GIMPLE_OMP_FOR:
2920 return (weights->omp_cost
2921 + estimate_num_insns_seq (gimple_omp_body (stmt), weights)
2922 + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights));
2924 case GIMPLE_OMP_PARALLEL:
2925 case GIMPLE_OMP_TASK:
2926 case GIMPLE_OMP_CRITICAL:
2927 case GIMPLE_OMP_MASTER:
2928 case GIMPLE_OMP_ORDERED:
2929 case GIMPLE_OMP_SECTION:
2930 case GIMPLE_OMP_SECTIONS:
2931 case GIMPLE_OMP_SINGLE:
2932 return (weights->omp_cost
2933 + estimate_num_insns_seq (gimple_omp_body (stmt), weights));
2942 /* Estimate number of instructions that will be created by expanding
2943 function FNDECL. WEIGHTS contains weights attributed to various
2947 estimate_num_insns_fn (tree fndecl, eni_weights *weights)
2949 struct function *my_function = DECL_STRUCT_FUNCTION (fndecl);
2950 gimple_stmt_iterator bsi;
2954 gcc_assert (my_function && my_function->cfg);
2955 FOR_EACH_BB_FN (bb, my_function)
2957 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
2958 n += estimate_num_insns (gsi_stmt (bsi), weights);
2965 /* Initializes weights used by estimate_num_insns. */
2968 init_inline_once (void)
2970 eni_inlining_weights.call_cost = PARAM_VALUE (PARAM_INLINE_CALL_COST);
2971 eni_inlining_weights.target_builtin_call_cost = 1;
2972 eni_inlining_weights.div_mod_cost = 10;
2973 eni_inlining_weights.omp_cost = 40;
2975 eni_size_weights.call_cost = 1;
2976 eni_size_weights.target_builtin_call_cost = 1;
2977 eni_size_weights.div_mod_cost = 1;
2978 eni_size_weights.omp_cost = 40;
2980 /* Estimating time for call is difficult, since we have no idea what the
2981 called function does. In the current uses of eni_time_weights,
2982 underestimating the cost does less harm than overestimating it, so
2983 we choose a rather small value here. */
2984 eni_time_weights.call_cost = 10;
2985 eni_time_weights.target_builtin_call_cost = 10;
2986 eni_time_weights.div_mod_cost = 10;
2987 eni_time_weights.omp_cost = 40;
2990 /* Estimate the number of instructions in a gimple_seq. */
2993 count_insns_seq (gimple_seq seq, eni_weights *weights)
2995 gimple_stmt_iterator gsi;
2997 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
2998 n += estimate_num_insns (gsi_stmt (gsi), weights);
3004 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
3007 add_lexical_block (tree current_block, tree new_block)
3011 /* Walk to the last sub-block. */
3012 for (blk_p = &BLOCK_SUBBLOCKS (current_block);
3014 blk_p = &BLOCK_CHAIN (*blk_p))
3017 BLOCK_SUPERCONTEXT (new_block) = current_block;
3020 /* Fetch callee declaration from the call graph edge going from NODE and
3021 associated with STMR call statement. Return NULL_TREE if not found. */
3023 get_indirect_callee_fndecl (struct cgraph_node *node, gimple stmt)
3025 struct cgraph_edge *cs;
3027 cs = cgraph_edge (node, stmt);
3029 return cs->callee->decl;
3034 /* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */
3037 expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
3039 tree retvar, use_retvar;
3041 struct pointer_map_t *st;
3044 location_t saved_location;
3045 struct cgraph_edge *cg_edge;
3047 basic_block return_block;
3049 gimple_stmt_iterator gsi, stmt_gsi;
3050 bool successfully_inlined = FALSE;
3051 bool purge_dead_abnormal_edges;
3055 /* Set input_location here so we get the right instantiation context
3056 if we call instantiate_decl from inlinable_function_p. */
3057 saved_location = input_location;
3058 if (gimple_has_location (stmt))
3059 input_location = gimple_location (stmt);
3061 /* From here on, we're only interested in CALL_EXPRs. */
3062 if (gimple_code (stmt) != GIMPLE_CALL)
3065 /* First, see if we can figure out what function is being called.
3066 If we cannot, then there is no hope of inlining the function. */
3067 fn = gimple_call_fndecl (stmt);
3070 fn = get_indirect_callee_fndecl (id->dst_node, stmt);
3075 /* Turn forward declarations into real ones. */
3076 fn = cgraph_node (fn)->decl;
3078 /* If FN is a declaration of a function in a nested scope that was
3079 globally declared inline, we don't set its DECL_INITIAL.
3080 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
3081 C++ front-end uses it for cdtors to refer to their internal
3082 declarations, that are not real functions. Fortunately those
3083 don't have trees to be saved, so we can tell by checking their
3085 if (!DECL_INITIAL (fn)
3086 && DECL_ABSTRACT_ORIGIN (fn)
3087 && gimple_body (DECL_ABSTRACT_ORIGIN (fn)))
3088 fn = DECL_ABSTRACT_ORIGIN (fn);
3090 /* Objective C and fortran still calls tree_rest_of_compilation directly.
3091 Kill this check once this is fixed. */
3092 if (!id->dst_node->analyzed)
3095 cg_edge = cgraph_edge (id->dst_node, stmt);
3097 /* Constant propagation on argument done during previous inlining
3098 may create new direct call. Produce an edge for it. */
3101 struct cgraph_node *dest = cgraph_node (fn);
3103 /* We have missing edge in the callgraph. This can happen in one case
3104 where previous inlining turned indirect call into direct call by
3105 constant propagating arguments. In all other cases we hit a bug
3106 (incorrect node sharing is most common reason for missing edges. */
3107 gcc_assert (dest->needed);
3108 cgraph_create_edge (id->dst_node, dest, stmt,
3109 bb->count, CGRAPH_FREQ_BASE,
3110 bb->loop_depth)->inline_failed
3111 = N_("originally indirect function call not considered for inlining");
3114 fprintf (dump_file, "Created new direct edge to %s",
3115 cgraph_node_name (dest));
3120 /* Don't try to inline functions that are not well-suited to
3122 if (!cgraph_inline_p (cg_edge, &reason))
3124 /* If this call was originally indirect, we do not want to emit any
3125 inlining related warnings or sorry messages because there are no
3126 guarantees regarding those. */
3127 if (cg_edge->indirect_call)
3130 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
3131 /* Avoid warnings during early inline pass. */
3132 && cgraph_global_info_ready)
3134 sorry ("inlining failed in call to %q+F: %s", fn, reason);
3135 sorry ("called from here");
3137 else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
3138 && !DECL_IN_SYSTEM_HEADER (fn)
3140 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
3141 /* Avoid warnings during early inline pass. */
3142 && cgraph_global_info_ready)
3144 warning (OPT_Winline, "inlining failed in call to %q+F: %s",
3146 warning (OPT_Winline, "called from here");
3150 fn = cg_edge->callee->decl;
3152 #ifdef ENABLE_CHECKING
3153 if (cg_edge->callee->decl != id->dst_node->decl)
3154 verify_cgraph_node (cg_edge->callee);
3157 /* We will be inlining this callee. */
3158 id->eh_region = lookup_stmt_eh_region (stmt);
3160 /* Split the block holding the GIMPLE_CALL. */
3161 e = split_block (bb, stmt);
3163 return_block = e->dest;
3166 /* split_block splits after the statement; work around this by
3167 moving the call into the second block manually. Not pretty,
3168 but seems easier than doing the CFG manipulation by hand
3169 when the GIMPLE_CALL is in the last statement of BB. */
3170 stmt_gsi = gsi_last_bb (bb);
3171 gsi_remove (&stmt_gsi, false);
3173 /* If the GIMPLE_CALL was in the last statement of BB, it may have
3174 been the source of abnormal edges. In this case, schedule
3175 the removal of dead abnormal edges. */
3176 gsi = gsi_start_bb (return_block);
3177 if (gsi_end_p (gsi))
3179 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
3180 purge_dead_abnormal_edges = true;
3184 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
3185 purge_dead_abnormal_edges = false;
3188 stmt_gsi = gsi_start_bb (return_block);
3190 /* Build a block containing code to initialize the arguments, the
3191 actual inline expansion of the body, and a label for the return
3192 statements within the function to jump to. The type of the
3193 statement expression is the return type of the function call. */
3194 id->block = make_node (BLOCK);
3195 BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
3196 BLOCK_SOURCE_LOCATION (id->block) = input_location;
3197 add_lexical_block (gimple_block (stmt), id->block);
3199 /* Local declarations will be replaced by their equivalents in this
3202 id->decl_map = pointer_map_create ();
3204 /* Record the function we are about to inline. */
3206 id->src_node = cg_edge->callee;
3207 id->src_cfun = DECL_STRUCT_FUNCTION (fn);
3208 id->gimple_call = stmt;
3210 gcc_assert (!id->src_cfun->after_inlining);
3213 initialize_inlined_parameters (id, stmt, fn, bb);
3215 if (DECL_INITIAL (fn))
3216 add_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
3218 /* Return statements in the function body will be replaced by jumps
3219 to the RET_LABEL. */
3220 gcc_assert (DECL_INITIAL (fn));
3221 gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
3223 /* Find the LHS to which the result of this call is assigned. */
3225 if (gimple_call_lhs (stmt))
3227 modify_dest = gimple_call_lhs (stmt);
3229 /* The function which we are inlining might not return a value,
3230 in which case we should issue a warning that the function
3231 does not return a value. In that case the optimizers will
3232 see that the variable to which the value is assigned was not
3233 initialized. We do not want to issue a warning about that
3234 uninitialized variable. */
3235 if (DECL_P (modify_dest))
3236 TREE_NO_WARNING (modify_dest) = 1;
3238 if (gimple_call_return_slot_opt_p (stmt))
3240 return_slot = modify_dest;
3247 /* If we are inlining a call to the C++ operator new, we don't want
3248 to use type based alias analysis on the return value. Otherwise
3249 we may get confused if the compiler sees that the inlined new
3250 function returns a pointer which was just deleted. See bug
3252 if (DECL_IS_OPERATOR_NEW (fn))
3258 /* Declare the return variable for the function. */
3259 retvar = declare_return_variable (id, return_slot, modify_dest, &use_retvar);
3261 if (DECL_IS_OPERATOR_NEW (fn))
3263 gcc_assert (TREE_CODE (retvar) == VAR_DECL
3264 && POINTER_TYPE_P (TREE_TYPE (retvar)));
3265 DECL_NO_TBAA_P (retvar) = 1;
3268 /* This is it. Duplicate the callee body. Assume callee is
3269 pre-gimplified. Note that we must not alter the caller
3270 function in any way before this point, as this CALL_EXPR may be
3271 a self-referential call; if we're calling ourselves, we need to
3272 duplicate our body before altering anything. */
3273 copy_body (id, bb->count, bb->frequency, bb, return_block);
3275 /* Add local vars in this inlined callee to caller. */
3276 t_step = id->src_cfun->local_decls;
3277 for (; t_step; t_step = TREE_CHAIN (t_step))
3279 var = TREE_VALUE (t_step);
3280 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3281 cfun->local_decls = tree_cons (NULL_TREE, var,
3284 cfun->local_decls = tree_cons (NULL_TREE, remap_decl (var, id),
3289 pointer_map_destroy (id->decl_map);
3292 /* If the inlined function returns a result that we care about,
3293 substitute the GIMPLE_CALL with an assignment of the return
3294 variable to the LHS of the call. That is, if STMT was
3295 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */
3296 if (use_retvar && gimple_call_lhs (stmt))
3298 gimple old_stmt = stmt;
3299 stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar);
3300 gsi_replace (&stmt_gsi, stmt, false);
3301 if (gimple_in_ssa_p (cfun))
3304 mark_symbols_for_renaming (stmt);
3306 maybe_clean_or_replace_eh_stmt (old_stmt, stmt);
3310 /* Handle the case of inlining a function with no return
3311 statement, which causes the return value to become undefined. */
3312 if (gimple_call_lhs (stmt)
3313 && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME)
3315 tree name = gimple_call_lhs (stmt);
3316 tree var = SSA_NAME_VAR (name);
3317 tree def = gimple_default_def (cfun, var);
3321 /* If the variable is used undefined, make this name
3322 undefined via a move. */
3323 stmt = gimple_build_assign (gimple_call_lhs (stmt), def);
3324 gsi_replace (&stmt_gsi, stmt, true);
3329 /* Otherwise make this variable undefined. */
3330 gsi_remove (&stmt_gsi, true);
3331 set_default_def (var, name);
3332 SSA_NAME_DEF_STMT (name) = gimple_build_nop ();
3336 gsi_remove (&stmt_gsi, true);
3339 if (purge_dead_abnormal_edges)
3340 gimple_purge_dead_abnormal_call_edges (return_block);
3342 /* If the value of the new expression is ignored, that's OK. We
3343 don't warn about this for CALL_EXPRs, so we shouldn't warn about
3344 the equivalent inlined version either. */
3345 if (is_gimple_assign (stmt))
3347 gcc_assert (gimple_assign_single_p (stmt)
3348 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)));
3349 TREE_USED (gimple_assign_rhs1 (stmt)) = 1;
3352 /* Output the inlining info for this abstract function, since it has been
3353 inlined. If we don't do this now, we can lose the information about the
3354 variables in the function when the blocks get blown away as soon as we
3355 remove the cgraph node. */
3356 (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
3358 /* Update callgraph if needed. */
3359 cgraph_remove_node (cg_edge->callee);
3361 id->block = NULL_TREE;
3362 successfully_inlined = TRUE;
3365 input_location = saved_location;
3366 return successfully_inlined;
3369 /* Expand call statements reachable from STMT_P.
3370 We can only have CALL_EXPRs as the "toplevel" tree code or nested
3371 in a MODIFY_EXPR. See tree-gimple.c:get_call_expr_in(). We can
3372 unfortunately not use that function here because we need a pointer
3373 to the CALL_EXPR, not the tree itself. */
3376 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
3378 gimple_stmt_iterator gsi;
3380 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3382 gimple stmt = gsi_stmt (gsi);
3384 if (is_gimple_call (stmt)
3385 && expand_call_inline (bb, stmt, id))
3393 /* Walk all basic blocks created after FIRST and try to fold every statement
3394 in the STATEMENTS pointer set. */
3397 fold_marked_statements (int first, struct pointer_set_t *statements)
3399 for (; first < n_basic_blocks; first++)
3400 if (BASIC_BLOCK (first))
3402 gimple_stmt_iterator gsi;
3404 for (gsi = gsi_start_bb (BASIC_BLOCK (first));
3407 if (pointer_set_contains (statements, gsi_stmt (gsi)))
3409 gimple old_stmt = gsi_stmt (gsi);
3411 if (fold_stmt (&gsi))
3413 /* Re-read the statement from GSI as fold_stmt() may
3415 gimple new_stmt = gsi_stmt (gsi);
3416 update_stmt (new_stmt);
3418 if (is_gimple_call (old_stmt))
3419 cgraph_update_edges_for_call_stmt (old_stmt, new_stmt);
3421 if (maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt))
3422 gimple_purge_dead_eh_edges (BASIC_BLOCK (first));
3428 /* Return true if BB has at least one abnormal outgoing edge. */
3431 has_abnormal_outgoing_edge_p (basic_block bb)
3436 FOR_EACH_EDGE (e, ei, bb->succs)
3437 if (e->flags & EDGE_ABNORMAL)
3443 /* Expand calls to inline functions in the body of FN. */
3446 optimize_inline_calls (tree fn)
3451 int last = n_basic_blocks;
3452 struct gimplify_ctx gctx;
3454 /* There is no point in performing inlining if errors have already
3455 occurred -- and we might crash if we try to inline invalid
3457 if (errorcount || sorrycount)
3461 memset (&id, 0, sizeof (id));
3463 id.src_node = id.dst_node = cgraph_node (fn);
3465 /* Or any functions that aren't finished yet. */
3466 prev_fn = NULL_TREE;
3467 if (current_function_decl)
3469 id.dst_fn = current_function_decl;
3470 prev_fn = current_function_decl;
3473 id.copy_decl = copy_decl_maybe_to_var;
3474 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3475 id.transform_new_cfg = false;
3476 id.transform_return_to_modify = true;
3477 id.transform_lang_insert_block = NULL;
3478 id.statements_to_fold = pointer_set_create ();
3480 push_gimplify_context (&gctx);
3482 /* We make no attempts to keep dominance info up-to-date. */
3483 free_dominance_info (CDI_DOMINATORS);
3484 free_dominance_info (CDI_POST_DOMINATORS);
3486 /* Register specific gimple functions. */
3487 gimple_register_cfg_hooks ();
3489 /* Reach the trees by walking over the CFG, and note the
3490 enclosing basic-blocks in the call edges. */
3491 /* We walk the blocks going forward, because inlined function bodies
3492 will split id->current_basic_block, and the new blocks will
3493 follow it; we'll trudge through them, processing their CALL_EXPRs
3496 gimple_expand_calls_inline (bb, &id);
3498 pop_gimplify_context (NULL);
3500 #ifdef ENABLE_CHECKING
3502 struct cgraph_edge *e;
3504 verify_cgraph_node (id.dst_node);
3506 /* Double check that we inlined everything we are supposed to inline. */
3507 for (e = id.dst_node->callees; e; e = e->next_callee)
3508 gcc_assert (e->inline_failed);
3512 /* Fold the statements before compacting/renumbering the basic blocks. */
3513 fold_marked_statements (last, id.statements_to_fold);
3514 pointer_set_destroy (id.statements_to_fold);
3516 /* Renumber the (code) basic_blocks consecutively. */
3518 /* Renumber the lexical scoping (non-code) blocks consecutively. */
3521 /* We are not going to maintain the cgraph edges up to date.
3522 Kill it so it won't confuse us. */
3523 cgraph_node_remove_callees (id.dst_node);
3525 fold_cond_expr_cond ();
3527 /* It would be nice to check SSA/CFG/statement consistency here, but it is
3528 not possible yet - the IPA passes might make various functions to not
3529 throw and they don't care to proactively update local EH info. This is
3530 done later in fixup_cfg pass that also execute the verification. */
3531 return (TODO_update_ssa
3533 | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
3534 | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
3537 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
3540 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
3542 enum tree_code code = TREE_CODE (*tp);
3543 enum tree_code_class cl = TREE_CODE_CLASS (code);
3545 /* We make copies of most nodes. */
3546 if (IS_EXPR_CODE_CLASS (cl)
3547 || code == TREE_LIST
3549 || code == TYPE_DECL
3550 || code == OMP_CLAUSE)
3552 /* Because the chain gets clobbered when we make a copy, we save it
3554 tree chain = NULL_TREE, new_tree;
3556 chain = TREE_CHAIN (*tp);
3558 /* Copy the node. */
3559 new_tree = copy_node (*tp);
3561 /* Propagate mudflap marked-ness. */
3562 if (flag_mudflap && mf_marked_p (*tp))
3567 /* Now, restore the chain, if appropriate. That will cause
3568 walk_tree to walk into the chain as well. */
3569 if (code == PARM_DECL
3570 || code == TREE_LIST
3571 || code == OMP_CLAUSE)
3572 TREE_CHAIN (*tp) = chain;
3574 /* For now, we don't update BLOCKs when we make copies. So, we
3575 have to nullify all BIND_EXPRs. */
3576 if (TREE_CODE (*tp) == BIND_EXPR)
3577 BIND_EXPR_BLOCK (*tp) = NULL_TREE;
3579 else if (code == CONSTRUCTOR)
3581 /* CONSTRUCTOR nodes need special handling because
3582 we need to duplicate the vector of elements. */
3585 new_tree = copy_node (*tp);
3587 /* Propagate mudflap marked-ness. */
3588 if (flag_mudflap && mf_marked_p (*tp))
3591 CONSTRUCTOR_ELTS (new_tree) = VEC_copy (constructor_elt, gc,
3592 CONSTRUCTOR_ELTS (*tp));
3595 else if (TREE_CODE_CLASS (code) == tcc_type)
3597 else if (TREE_CODE_CLASS (code) == tcc_declaration)
3599 else if (TREE_CODE_CLASS (code) == tcc_constant)
3602 gcc_assert (code != STATEMENT_LIST);
3606 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
3607 information indicating to what new SAVE_EXPR this one should be mapped,
3608 use that one. Otherwise, create a new node and enter it in ST. FN is
3609 the function into which the copy will be placed. */
3612 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
3614 struct pointer_map_t *st = (struct pointer_map_t *) st_;
3618 /* See if we already encountered this SAVE_EXPR. */
3619 n = (tree *) pointer_map_contains (st, *tp);
3621 /* If we didn't already remap this SAVE_EXPR, do so now. */
3624 t = copy_node (*tp);
3626 /* Remember this SAVE_EXPR. */
3627 *pointer_map_insert (st, *tp) = t;
3628 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3629 *pointer_map_insert (st, t) = t;
3633 /* We've already walked into this SAVE_EXPR; don't do it again. */
3638 /* Replace this SAVE_EXPR with the copy. */
3642 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
3643 copies the declaration and enters it in the splay_tree in DATA (which is
3644 really an `copy_body_data *'). */
3647 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
3650 copy_body_data *id = (copy_body_data *) data;
3652 /* Don't walk into types. */
3656 else if (TREE_CODE (*tp) == LABEL_EXPR)
3658 tree decl = TREE_OPERAND (*tp, 0);
3660 /* Copy the decl and remember the copy. */
3661 insert_decl_map (id, decl, id->copy_decl (decl, id));
3667 /* Perform any modifications to EXPR required when it is unsaved. Does
3668 not recurse into EXPR's subtrees. */
3671 unsave_expr_1 (tree expr)
3673 switch (TREE_CODE (expr))
3676 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
3677 It's OK for this to happen if it was part of a subtree that
3678 isn't immediately expanded, such as operand 2 of another
3680 if (TREE_OPERAND (expr, 1))
3683 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
3684 TREE_OPERAND (expr, 3) = NULL_TREE;
3692 /* Called via walk_tree when an expression is unsaved. Using the
3693 splay_tree pointed to by ST (which is really a `splay_tree'),
3694 remaps all local declarations to appropriate replacements. */
3697 unsave_r (tree *tp, int *walk_subtrees, void *data)
3699 copy_body_data *id = (copy_body_data *) data;
3700 struct pointer_map_t *st = id->decl_map;
3703 /* Only a local declaration (variable or label). */
3704 if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
3705 || TREE_CODE (*tp) == LABEL_DECL)
3707 /* Lookup the declaration. */
3708 n = (tree *) pointer_map_contains (st, *tp);
3710 /* If it's there, remap it. */
3715 else if (TREE_CODE (*tp) == STATEMENT_LIST)
3717 else if (TREE_CODE (*tp) == BIND_EXPR)
3718 copy_bind_expr (tp, walk_subtrees, id);
3719 else if (TREE_CODE (*tp) == SAVE_EXPR)
3720 remap_save_expr (tp, st, walk_subtrees);
3723 copy_tree_r (tp, walk_subtrees, NULL);
3725 /* Do whatever unsaving is required. */
3726 unsave_expr_1 (*tp);
3729 /* Keep iterating. */
3733 /* Copies everything in EXPR and replaces variables, labels
3734 and SAVE_EXPRs local to EXPR. */
3737 unsave_expr_now (tree expr)
3741 /* There's nothing to do for NULL_TREE. */
3746 memset (&id, 0, sizeof (id));
3747 id.src_fn = current_function_decl;
3748 id.dst_fn = current_function_decl;
3749 id.decl_map = pointer_map_create ();
3751 id.copy_decl = copy_decl_no_change;
3752 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3753 id.transform_new_cfg = false;
3754 id.transform_return_to_modify = false;
3755 id.transform_lang_insert_block = NULL;
3757 /* Walk the tree once to find local labels. */
3758 walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
3760 /* Walk the tree again, copying, remapping, and unsaving. */
3761 walk_tree (&expr, unsave_r, &id, NULL);
3764 pointer_map_destroy (id.decl_map);
3769 /* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local
3770 label, copies the declaration and enters it in the splay_tree in DATA (which
3771 is really a 'copy_body_data *'. */
3774 mark_local_labels_stmt (gimple_stmt_iterator *gsip,
3775 bool *handled_ops_p ATTRIBUTE_UNUSED,
3776 struct walk_stmt_info *wi)
3778 copy_body_data *id = (copy_body_data *) wi->info;
3779 gimple stmt = gsi_stmt (*gsip);
3781 if (gimple_code (stmt) == GIMPLE_LABEL)
3783 tree decl = gimple_label_label (stmt);
3785 /* Copy the decl and remember the copy. */
3786 insert_decl_map (id, decl, id->copy_decl (decl, id));
3793 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
3794 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
3795 remaps all local declarations to appropriate replacements in gimple
3799 replace_locals_op (tree *tp, int *walk_subtrees, void *data)
3801 struct walk_stmt_info *wi = (struct walk_stmt_info*) data;
3802 copy_body_data *id = (copy_body_data *) wi->info;
3803 struct pointer_map_t *st = id->decl_map;
3807 /* Only a local declaration (variable or label). */
3808 if ((TREE_CODE (expr) == VAR_DECL
3809 && !TREE_STATIC (expr))
3810 || TREE_CODE (expr) == LABEL_DECL)
3812 /* Lookup the declaration. */
3813 n = (tree *) pointer_map_contains (st, expr);
3815 /* If it's there, remap it. */
3820 else if (TREE_CODE (expr) == STATEMENT_LIST
3821 || TREE_CODE (expr) == BIND_EXPR
3822 || TREE_CODE (expr) == SAVE_EXPR)
3824 else if (TREE_CODE (expr) == TARGET_EXPR)
3826 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
3827 It's OK for this to happen if it was part of a subtree that
3828 isn't immediately expanded, such as operand 2 of another
3830 if (!TREE_OPERAND (expr, 1))
3832 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
3833 TREE_OPERAND (expr, 3) = NULL_TREE;
3837 /* Keep iterating. */
3842 /* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local.
3843 Using the splay_tree pointed to by ST (which is really a `splay_tree'),
3844 remaps all local declarations to appropriate replacements in gimple
3848 replace_locals_stmt (gimple_stmt_iterator *gsip,
3849 bool *handled_ops_p ATTRIBUTE_UNUSED,
3850 struct walk_stmt_info *wi)
3852 copy_body_data *id = (copy_body_data *) wi->info;
3853 gimple stmt = gsi_stmt (*gsip);
3855 if (gimple_code (stmt) == GIMPLE_BIND)
3857 tree block = gimple_bind_block (stmt);
3861 remap_block (&block, id);
3862 gimple_bind_set_block (stmt, block);
3865 /* This will remap a lot of the same decls again, but this should be
3867 if (gimple_bind_vars (stmt))
3868 gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), id));
3871 /* Keep iterating. */
3876 /* Copies everything in SEQ and replaces variables and labels local to
3877 current_function_decl. */
3880 copy_gimple_seq_and_replace_locals (gimple_seq seq)
3883 struct walk_stmt_info wi;
3884 struct pointer_set_t *visited;
3887 /* There's nothing to do for NULL_TREE. */
3892 memset (&id, 0, sizeof (id));
3893 id.src_fn = current_function_decl;
3894 id.dst_fn = current_function_decl;
3895 id.decl_map = pointer_map_create ();
3897 id.copy_decl = copy_decl_no_change;
3898 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3899 id.transform_new_cfg = false;
3900 id.transform_return_to_modify = false;
3901 id.transform_lang_insert_block = NULL;
3903 /* Walk the tree once to find local labels. */
3904 memset (&wi, 0, sizeof (wi));
3905 visited = pointer_set_create ();
3908 walk_gimple_seq (seq, mark_local_labels_stmt, NULL, &wi);
3909 pointer_set_destroy (visited);
3911 copy = gimple_seq_copy (seq);
3913 /* Walk the copy, remapping decls. */
3914 memset (&wi, 0, sizeof (wi));
3916 walk_gimple_seq (copy, replace_locals_stmt, replace_locals_op, &wi);
3919 pointer_map_destroy (id.decl_map);
3925 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
3928 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
3937 debug_find_tree (tree top, tree search)
3939 return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
3943 /* Declare the variables created by the inliner. Add all the variables in
3944 VARS to BIND_EXPR. */
3947 declare_inline_vars (tree block, tree vars)
3950 for (t = vars; t; t = TREE_CHAIN (t))
3952 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
3953 gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
3954 cfun->local_decls = tree_cons (NULL_TREE, t, cfun->local_decls);
3958 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
3961 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
3962 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
3963 VAR_DECL translation. */
3966 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
3968 /* Don't generate debug information for the copy if we wouldn't have
3969 generated it for the copy either. */
3970 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
3971 DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
3973 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
3974 declaration inspired this copy. */
3975 DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
3977 /* The new variable/label has no RTL, yet. */
3978 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
3979 && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
3980 SET_DECL_RTL (copy, NULL_RTX);
3982 /* These args would always appear unused, if not for this. */
3983 TREE_USED (copy) = 1;
3985 /* Set the context for the new declaration. */
3986 if (!DECL_CONTEXT (decl))
3987 /* Globals stay global. */
3989 else if (DECL_CONTEXT (decl) != id->src_fn)
3990 /* Things that weren't in the scope of the function we're inlining
3991 from aren't in the scope we're inlining to, either. */
3993 else if (TREE_STATIC (decl))
3994 /* Function-scoped static variables should stay in the original
3998 /* Ordinary automatic local variables are now in the scope of the
4000 DECL_CONTEXT (copy) = id->dst_fn;
4006 copy_decl_to_var (tree decl, copy_body_data *id)
4010 gcc_assert (TREE_CODE (decl) == PARM_DECL
4011 || TREE_CODE (decl) == RESULT_DECL);
4013 type = TREE_TYPE (decl);
4015 copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
4016 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
4017 TREE_READONLY (copy) = TREE_READONLY (decl);
4018 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
4019 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
4020 DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
4022 return copy_decl_for_dup_finish (id, decl, copy);
4025 /* Like copy_decl_to_var, but create a return slot object instead of a
4026 pointer variable for return by invisible reference. */
4029 copy_result_decl_to_var (tree decl, copy_body_data *id)
4033 gcc_assert (TREE_CODE (decl) == PARM_DECL
4034 || TREE_CODE (decl) == RESULT_DECL);
4036 type = TREE_TYPE (decl);
4037 if (DECL_BY_REFERENCE (decl))
4038 type = TREE_TYPE (type);
4040 copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
4041 TREE_READONLY (copy) = TREE_READONLY (decl);
4042 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
4043 if (!DECL_BY_REFERENCE (decl))
4045 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
4046 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
4047 DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
4050 return copy_decl_for_dup_finish (id, decl, copy);
4054 copy_decl_no_change (tree decl, copy_body_data *id)
4058 copy = copy_node (decl);
4060 /* The COPY is not abstract; it will be generated in DST_FN. */
4061 DECL_ABSTRACT (copy) = 0;
4062 lang_hooks.dup_lang_specific_decl (copy);
4064 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
4065 been taken; it's for internal bookkeeping in expand_goto_internal. */
4066 if (TREE_CODE (copy) == LABEL_DECL)
4068 TREE_ADDRESSABLE (copy) = 0;
4069 LABEL_DECL_UID (copy) = -1;
4072 return copy_decl_for_dup_finish (id, decl, copy);
4076 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
4078 if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
4079 return copy_decl_to_var (decl, id);
4081 return copy_decl_no_change (decl, id);
4084 /* Return a copy of the function's argument tree. */
4086 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id)
4088 tree *arg_copy, *parg;
4090 arg_copy = &orig_parm;
4091 for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
4093 tree new_tree = remap_decl (*parg, id);
4094 lang_hooks.dup_lang_specific_decl (new_tree);
4095 TREE_CHAIN (new_tree) = TREE_CHAIN (*parg);
4101 /* Return a copy of the function's static chain. */
4103 copy_static_chain (tree static_chain, copy_body_data * id)
4105 tree *chain_copy, *pvar;
4107 chain_copy = &static_chain;
4108 for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
4110 tree new_tree = remap_decl (*pvar, id);
4111 lang_hooks.dup_lang_specific_decl (new_tree);
4112 TREE_CHAIN (new_tree) = TREE_CHAIN (*pvar);
4115 return static_chain;
4118 /* Return true if the function is allowed to be versioned.
4119 This is a guard for the versioning functionality. */
4121 tree_versionable_function_p (tree fndecl)
4123 if (fndecl == NULL_TREE)
4125 /* ??? There are cases where a function is
4126 uninlinable but can be versioned. */
4127 if (!tree_inlinable_function_p (fndecl))
4133 /* Create a copy of a function's tree.
4134 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
4135 of the original function and the new copied function
4136 respectively. In case we want to replace a DECL
4137 tree with another tree while duplicating the function's
4138 body, TREE_MAP represents the mapping between these
4139 trees. If UPDATE_CLONES is set, the call_stmt fields
4140 of edges of clones of the function will be updated. */
4142 tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map,
4145 struct cgraph_node *old_version_node;
4146 struct cgraph_node *new_version_node;
4150 struct ipa_replace_map *replace_info;
4151 basic_block old_entry_block;
4153 tree old_current_function_decl = current_function_decl;
4155 gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
4156 && TREE_CODE (new_decl) == FUNCTION_DECL);
4157 DECL_POSSIBLY_INLINED (old_decl) = 1;
4159 old_version_node = cgraph_node (old_decl);
4160 new_version_node = cgraph_node (new_decl);
4162 DECL_ARTIFICIAL (new_decl) = 1;
4163 DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
4165 /* Prepare the data structures for the tree copy. */
4166 memset (&id, 0, sizeof (id));
4168 /* Generate a new name for the new version. */
4171 DECL_NAME (new_decl) = create_tmp_var_name (NULL);
4172 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
4173 SET_DECL_RTL (new_decl, NULL_RTX);
4174 id.statements_to_fold = pointer_set_create ();
4177 id.decl_map = pointer_map_create ();
4178 id.src_fn = old_decl;
4179 id.dst_fn = new_decl;
4180 id.src_node = old_version_node;
4181 id.dst_node = new_version_node;
4182 id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
4184 id.copy_decl = copy_decl_no_change;
4185 id.transform_call_graph_edges
4186 = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
4187 id.transform_new_cfg = true;
4188 id.transform_return_to_modify = false;
4189 id.transform_lang_insert_block = NULL;
4191 current_function_decl = new_decl;
4192 old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
4193 (DECL_STRUCT_FUNCTION (old_decl));
4194 initialize_cfun (new_decl, old_decl,
4195 old_entry_block->count,
4196 old_entry_block->frequency);
4197 push_cfun (DECL_STRUCT_FUNCTION (new_decl));
4199 /* Copy the function's static chain. */
4200 p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
4202 DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
4203 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
4205 /* Copy the function's arguments. */
4206 if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
4207 DECL_ARGUMENTS (new_decl) =
4208 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id);
4210 /* If there's a tree_map, prepare for substitution. */
4212 for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++)
4215 = (struct ipa_replace_map *) VARRAY_GENERIC_PTR (tree_map, i);
4216 if (replace_info->replace_p)
4217 insert_decl_map (&id, replace_info->old_tree,
4218 replace_info->new_tree);
4221 DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
4223 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4224 number_blocks (id.dst_fn);
4226 if (DECL_STRUCT_FUNCTION (old_decl)->local_decls != NULL_TREE)
4227 /* Add local vars. */
4228 for (t_step = DECL_STRUCT_FUNCTION (old_decl)->local_decls;
4229 t_step; t_step = TREE_CHAIN (t_step))
4231 tree var = TREE_VALUE (t_step);
4232 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
4233 cfun->local_decls = tree_cons (NULL_TREE, var, cfun->local_decls);
4236 tree_cons (NULL_TREE, remap_decl (var, &id),
4240 /* Copy the Function's body. */
4241 copy_body (&id, old_entry_block->count, old_entry_block->frequency, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR);
4243 if (DECL_RESULT (old_decl) != NULL_TREE)
4245 tree *res_decl = &DECL_RESULT (old_decl);
4246 DECL_RESULT (new_decl) = remap_decl (*res_decl, &id);
4247 lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
4250 /* Renumber the lexical scoping (non-code) blocks consecutively. */
4251 number_blocks (new_decl);
4254 pointer_map_destroy (id.decl_map);
4257 fold_marked_statements (0, id.statements_to_fold);
4258 pointer_set_destroy (id.statements_to_fold);
4259 fold_cond_expr_cond ();
4261 if (gimple_in_ssa_p (cfun))
4263 free_dominance_info (CDI_DOMINATORS);
4264 free_dominance_info (CDI_POST_DOMINATORS);
4266 delete_unreachable_blocks ();
4267 update_ssa (TODO_update_ssa);
4270 fold_cond_expr_cond ();
4271 if (need_ssa_update_p ())
4272 update_ssa (TODO_update_ssa);
4275 free_dominance_info (CDI_DOMINATORS);
4276 free_dominance_info (CDI_POST_DOMINATORS);
4278 current_function_decl = old_current_function_decl;
4279 gcc_assert (!current_function_decl
4280 || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
4284 /* Duplicate a type, fields and all. */
4287 build_duplicate_type (tree type)
4289 struct copy_body_data id;
4291 memset (&id, 0, sizeof (id));
4292 id.src_fn = current_function_decl;
4293 id.dst_fn = current_function_decl;
4295 id.decl_map = pointer_map_create ();
4296 id.copy_decl = copy_decl_no_change;
4298 type = remap_type_1 (type, &id);
4300 pointer_map_destroy (id.decl_map);
4302 TYPE_CANONICAL (type) = type;
4307 /* Return whether it is safe to inline a function because it used different
4308 target specific options or different optimization options. */
4310 tree_can_inline_p (tree caller, tree callee)
4312 /* Don't inline a function with a higher optimization level than the
4313 caller, or with different space constraints (hot/cold functions). */
4314 tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (caller);
4315 tree callee_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee);
4317 if (caller_tree != callee_tree)
4319 struct cl_optimization *caller_opt
4320 = TREE_OPTIMIZATION ((caller_tree)
4322 : optimization_default_node);
4324 struct cl_optimization *callee_opt
4325 = TREE_OPTIMIZATION ((callee_tree)
4327 : optimization_default_node);
4329 if ((caller_opt->optimize > callee_opt->optimize)
4330 || (caller_opt->optimize_size != callee_opt->optimize_size))
4334 /* Allow the backend to decide if inlining is ok. */
4335 return targetm.target_option.can_inline_p (caller, callee);