2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
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
59 #include "tree-gimple.h"
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 GIMPLE_MODIFY_STMTs 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_body_r (). */
93 /* 0 if we should not perform inlining.
94 1 if we should expand functions calls inline at the tree level.
95 2 if we should consider *all* functions to be inline
98 int flag_inline_trees = 0;
102 o In order to make inlining-on-trees work, we pessimized
103 function-local static constants. In particular, they are now
104 always output, even when not addressed. Fix this by treating
105 function-local static constants just like global static
106 constants; the back-end already knows not to output them if they
109 o Provide heuristics to clamp inlining of recursive template
113 /* Weights that estimate_num_insns uses for heuristics in inlining. */
115 eni_weights eni_inlining_weights;
117 /* Weights that estimate_num_insns uses to estimate the size of the
120 eni_weights eni_size_weights;
122 /* Weights that estimate_num_insns uses to estimate the time necessary
123 to execute the produced code. */
125 eni_weights eni_time_weights;
129 static tree declare_return_variable (copy_body_data *, tree, tree, tree *);
130 static tree copy_generic_body (copy_body_data *);
131 static bool inlinable_function_p (tree);
132 static void remap_block (tree *, copy_body_data *);
133 static tree remap_decls (tree, copy_body_data *);
134 static void copy_bind_expr (tree *, int *, copy_body_data *);
135 static tree mark_local_for_remap_r (tree *, int *, void *);
136 static void unsave_expr_1 (tree);
137 static tree unsave_r (tree *, int *, void *);
138 static void declare_inline_vars (tree, tree);
139 static void remap_save_expr (tree *, void *, int *);
140 static void add_lexical_block (tree current_block, tree new_block);
141 static tree copy_decl_to_var (tree, copy_body_data *);
142 static tree copy_result_decl_to_var (tree, copy_body_data *);
143 static tree copy_decl_no_change (tree, copy_body_data *);
144 static tree copy_decl_maybe_to_var (tree, copy_body_data *);
146 /* Insert a tree->tree mapping for ID. Despite the name suggests
147 that the trees should be variables, it is used for more than that. */
150 insert_decl_map (copy_body_data *id, tree key, tree value)
152 *pointer_map_insert (id->decl_map, key) = value;
154 /* Always insert an identity map as well. If we see this same new
155 node again, we won't want to duplicate it a second time. */
157 *pointer_map_insert (id->decl_map, value) = value;
160 /* Construct new SSA name for old NAME. ID is the inline context. */
163 remap_ssa_name (tree name, copy_body_data *id)
168 gcc_assert (TREE_CODE (name) == SSA_NAME);
170 n = (tree *) pointer_map_contains (id->decl_map, name);
174 /* Do not set DEF_STMT yet as statement is not copied yet. We do that
176 new = remap_decl (SSA_NAME_VAR (name), id);
177 /* We might've substituted constant or another SSA_NAME for
180 Replace the SSA name representing RESULT_DECL by variable during
181 inlining: this saves us from need to introduce PHI node in a case
182 return value is just partly initialized. */
183 if ((TREE_CODE (new) == VAR_DECL || TREE_CODE (new) == PARM_DECL)
184 && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
185 || !id->transform_return_to_modify))
187 new = make_ssa_name (new, NULL);
188 insert_decl_map (id, name, new);
189 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new)
190 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
191 TREE_TYPE (new) = TREE_TYPE (SSA_NAME_VAR (new));
192 if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (name)))
194 /* By inlining function having uninitialized variable, we might
195 extend the lifetime (variable might get reused). This cause
196 ICE in the case we end up extending lifetime of SSA name across
197 abnormal edge, but also increase register presure.
199 We simply initialize all uninitialized vars by 0 except for case
200 we are inlining to very first BB. We can avoid this for all
201 BBs that are not withing strongly connected regions of the CFG,
202 but this is bit expensive to test.
204 if (id->entry_bb && is_gimple_reg (SSA_NAME_VAR (name))
205 && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL
206 && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest
207 || EDGE_COUNT (id->entry_bb->preds) != 1))
209 block_stmt_iterator bsi = bsi_last (id->entry_bb);
211 = build_gimple_modify_stmt (new,
212 fold_convert (TREE_TYPE (new),
214 bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
215 SSA_NAME_DEF_STMT (new) = init_stmt;
216 SSA_NAME_IS_DEFAULT_DEF (new) = 0;
220 SSA_NAME_DEF_STMT (new) = build_empty_stmt ();
221 if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) == name)
222 set_default_def (SSA_NAME_VAR (new), new);
227 insert_decl_map (id, name, new);
231 /* Remap DECL during the copying of the BLOCK tree for the function. */
234 remap_decl (tree decl, copy_body_data *id)
239 /* We only remap local variables in the current function. */
242 /* See if we have remapped this declaration. */
244 n = (tree *) pointer_map_contains (id->decl_map, decl);
246 /* If we didn't already have an equivalent for this declaration,
250 /* Make a copy of the variable or label. */
251 tree t = id->copy_decl (decl, id);
253 /* Remember it, so that if we encounter this local entity again
254 we can reuse this copy. Do this early because remap_type may
255 need this decl for TYPE_STUB_DECL. */
256 insert_decl_map (id, decl, t);
261 /* Remap types, if necessary. */
262 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
263 if (TREE_CODE (t) == TYPE_DECL)
264 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
266 /* Remap sizes as necessary. */
267 walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL);
268 walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL);
270 /* If fields, do likewise for offset and qualifier. */
271 if (TREE_CODE (t) == FIELD_DECL)
273 walk_tree (&DECL_FIELD_OFFSET (t), copy_body_r, id, NULL);
274 if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE)
275 walk_tree (&DECL_QUALIFIER (t), copy_body_r, id, NULL);
278 if (cfun && gimple_in_ssa_p (cfun)
279 && (TREE_CODE (t) == VAR_DECL
280 || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL))
282 tree def = gimple_default_def (id->src_cfun, decl);
284 if (TREE_CODE (decl) != PARM_DECL && def)
286 tree map = remap_ssa_name (def, id);
287 /* Watch out RESULT_DECLs whose SSA names map directly
289 if (TREE_CODE (map) == SSA_NAME
290 && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (map)))
291 set_default_def (t, map);
293 add_referenced_var (t);
298 return unshare_expr (*n);
302 remap_type_1 (tree type, copy_body_data *id)
306 /* We do need a copy. build and register it now. If this is a pointer or
307 reference type, remap the designated type and make a new pointer or
309 if (TREE_CODE (type) == POINTER_TYPE)
311 new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
313 TYPE_REF_CAN_ALIAS_ALL (type));
314 insert_decl_map (id, type, new);
317 else if (TREE_CODE (type) == REFERENCE_TYPE)
319 new = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
321 TYPE_REF_CAN_ALIAS_ALL (type));
322 insert_decl_map (id, type, new);
326 new = copy_node (type);
328 insert_decl_map (id, type, new);
330 /* This is a new type, not a copy of an old type. Need to reassociate
331 variants. We can handle everything except the main variant lazily. */
332 t = TYPE_MAIN_VARIANT (type);
335 t = remap_type (t, id);
336 TYPE_MAIN_VARIANT (new) = t;
337 TYPE_NEXT_VARIANT (new) = TYPE_NEXT_VARIANT (t);
338 TYPE_NEXT_VARIANT (t) = new;
342 TYPE_MAIN_VARIANT (new) = new;
343 TYPE_NEXT_VARIANT (new) = NULL;
346 if (TYPE_STUB_DECL (type))
347 TYPE_STUB_DECL (new) = remap_decl (TYPE_STUB_DECL (type), id);
349 /* Lazily create pointer and reference types. */
350 TYPE_POINTER_TO (new) = NULL;
351 TYPE_REFERENCE_TO (new) = NULL;
353 switch (TREE_CODE (new))
357 case FIXED_POINT_TYPE:
360 t = TYPE_MIN_VALUE (new);
361 if (t && TREE_CODE (t) != INTEGER_CST)
362 walk_tree (&TYPE_MIN_VALUE (new), copy_body_r, id, NULL);
364 t = TYPE_MAX_VALUE (new);
365 if (t && TREE_CODE (t) != INTEGER_CST)
366 walk_tree (&TYPE_MAX_VALUE (new), copy_body_r, id, NULL);
370 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
371 walk_tree (&TYPE_ARG_TYPES (new), copy_body_r, id, NULL);
375 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
376 TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id);
381 case QUAL_UNION_TYPE:
385 for (f = TYPE_FIELDS (new); f ; f = TREE_CHAIN (f))
387 t = remap_decl (f, id);
388 DECL_CONTEXT (t) = new;
392 TYPE_FIELDS (new) = nreverse (nf);
398 /* Shouldn't have been thought variable sized. */
402 walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
403 walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r, id, NULL);
409 remap_type (tree type, copy_body_data *id)
416 /* See if we have remapped this type. */
417 node = (tree *) pointer_map_contains (id->decl_map, type);
421 /* The type only needs remapping if it's variably modified. */
422 if (! variably_modified_type_p (type, id->src_fn))
424 insert_decl_map (id, type, type);
428 return remap_type_1 (type, id);
432 remap_decls (tree decls, copy_body_data *id)
435 tree new_decls = NULL_TREE;
437 /* Remap its variables. */
438 for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
442 /* We can not chain the local static declarations into the unexpanded_var_list
443 as we can't duplicate them or break one decl rule. Go ahead and link
444 them into unexpanded_var_list. */
445 if (!auto_var_in_fn_p (old_var, id->src_fn)
446 && !DECL_EXTERNAL (old_var))
448 cfun->unexpanded_var_list = tree_cons (NULL_TREE, old_var,
449 cfun->unexpanded_var_list);
453 /* Remap the variable. */
454 new_var = remap_decl (old_var, id);
456 /* If we didn't remap this variable, so 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 lang_hooks.decls.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)
512 remap_block (&new, id);
513 gcc_assert (new != block);
514 for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
515 add_lexical_block (new, remap_blocks (t, id));
520 copy_statement_list (tree *tp)
522 tree_stmt_iterator oi, ni;
525 new = alloc_stmt_list ();
526 ni = tsi_start (new);
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);
552 /* Called from copy_body_id via walk_tree. DATA is really an
553 `copy_body_data *'. */
556 copy_body_r (tree *tp, int *walk_subtrees, void *data)
558 copy_body_data *id = (copy_body_data *) data;
559 tree fn = id->src_fn;
562 /* Begin by recognizing trees that we'll completely rewrite for the
563 inlining context. Our output for these trees is completely
564 different from out input (e.g. RETURN_EXPR is deleted, and morphs
565 into an edge). Further down, we'll handle trees that get
566 duplicated and/or tweaked. */
568 /* When requested, RETURN_EXPRs should be transformed to just the
569 contained GIMPLE_MODIFY_STMT. The branch semantics of the return will
570 be handled elsewhere by manipulating the CFG rather than a statement. */
571 if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify)
573 tree assignment = TREE_OPERAND (*tp, 0);
575 /* If we're returning something, just turn that into an
576 assignment into the equivalent of the original RESULT_DECL.
577 If the "assignment" is just the result decl, the result
578 decl has already been set (e.g. a recent "foo (&result_decl,
579 ...)"); just toss the entire RETURN_EXPR. */
580 if (assignment && TREE_CODE (assignment) == GIMPLE_MODIFY_STMT)
582 /* Replace the RETURN_EXPR with (a copy of) the
583 GIMPLE_MODIFY_STMT hanging underneath. */
584 *tp = copy_node (assignment);
586 else /* Else the RETURN_EXPR returns no value. */
589 return (tree) (void *)1;
592 else if (TREE_CODE (*tp) == SSA_NAME)
594 *tp = remap_ssa_name (*tp, id);
599 /* Local variables and labels need to be replaced by equivalent
600 variables. We don't want to copy static variables; there's only
601 one of those, no matter how many times we inline the containing
602 function. Similarly for globals from an outer function. */
603 else if (auto_var_in_fn_p (*tp, fn))
607 /* Remap the declaration. */
608 new_decl = remap_decl (*tp, id);
609 gcc_assert (new_decl);
610 /* Replace this variable with the copy. */
611 STRIP_TYPE_NOPS (new_decl);
615 else if (TREE_CODE (*tp) == STATEMENT_LIST)
616 copy_statement_list (tp);
617 else if (TREE_CODE (*tp) == SAVE_EXPR)
618 remap_save_expr (tp, id->decl_map, walk_subtrees);
619 else if (TREE_CODE (*tp) == LABEL_DECL
620 && (! DECL_CONTEXT (*tp)
621 || decl_function_context (*tp) == id->src_fn))
622 /* These may need to be remapped for EH handling. */
623 *tp = remap_decl (*tp, id);
624 else if (TREE_CODE (*tp) == BIND_EXPR)
625 copy_bind_expr (tp, walk_subtrees, id);
626 /* Types may need remapping as well. */
627 else if (TYPE_P (*tp))
628 *tp = remap_type (*tp, id);
630 /* If this is a constant, we have to copy the node iff the type will be
631 remapped. copy_tree_r will not copy a constant. */
632 else if (CONSTANT_CLASS_P (*tp))
634 tree new_type = remap_type (TREE_TYPE (*tp), id);
636 if (new_type == TREE_TYPE (*tp))
639 else if (TREE_CODE (*tp) == INTEGER_CST)
640 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
641 TREE_INT_CST_HIGH (*tp));
644 *tp = copy_node (*tp);
645 TREE_TYPE (*tp) = new_type;
649 /* Otherwise, just copy the node. Note that copy_tree_r already
650 knows not to copy VAR_DECLs, etc., so this is safe. */
653 /* Here we handle trees that are not completely rewritten.
654 First we detect some inlining-induced bogosities for
656 if (TREE_CODE (*tp) == GIMPLE_MODIFY_STMT
657 && GIMPLE_STMT_OPERAND (*tp, 0) == GIMPLE_STMT_OPERAND (*tp, 1)
658 && (auto_var_in_fn_p (GIMPLE_STMT_OPERAND (*tp, 0), fn)))
660 /* Some assignments VAR = VAR; don't generate any rtl code
661 and thus don't count as variable modification. Avoid
662 keeping bogosities like 0 = 0. */
663 tree decl = GIMPLE_STMT_OPERAND (*tp, 0), value;
666 n = (tree *) pointer_map_contains (id->decl_map, decl);
670 STRIP_TYPE_NOPS (value);
671 if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
673 *tp = build_empty_stmt ();
674 return copy_body_r (tp, walk_subtrees, data);
678 else if (TREE_CODE (*tp) == INDIRECT_REF)
680 /* Get rid of *& from inline substitutions that can happen when a
681 pointer argument is an ADDR_EXPR. */
682 tree decl = TREE_OPERAND (*tp, 0);
685 n = (tree *) pointer_map_contains (id->decl_map, decl);
690 /* If we happen to get an ADDR_EXPR in n->value, strip
691 it manually here as we'll eventually get ADDR_EXPRs
692 which lie about their types pointed to. In this case
693 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
694 but we absolutely rely on that. As fold_indirect_ref
695 does other useful transformations, try that first, though. */
696 tree type = TREE_TYPE (TREE_TYPE (*n));
697 new = unshare_expr (*n);
699 *tp = fold_indirect_ref_1 (type, new);
702 if (TREE_CODE (new) == ADDR_EXPR)
703 *tp = TREE_OPERAND (new, 0);
706 *tp = build1 (INDIRECT_REF, type, new);
707 TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
715 /* Here is the "usual case". Copy this tree node, and then
716 tweak some special cases. */
717 copy_tree_r (tp, walk_subtrees, NULL);
719 /* Global variables we didn't seen yet needs to go into referenced
721 if (gimple_in_ssa_p (cfun) && TREE_CODE (*tp) == VAR_DECL)
722 add_referenced_var (*tp);
724 /* If EXPR has block defined, map it to newly constructed block.
725 When inlining we want EXPRs without block appear in the block
727 if (EXPR_P (*tp) || GIMPLE_STMT_P (*tp))
729 new_block = id->block;
730 if (TREE_BLOCK (*tp))
733 n = (tree *) pointer_map_contains (id->decl_map,
738 TREE_BLOCK (*tp) = new_block;
741 if (TREE_CODE (*tp) == RESX_EXPR && id->eh_region_offset)
742 TREE_OPERAND (*tp, 0) =
745 id->eh_region_offset + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0)));
747 if (!GIMPLE_TUPLE_P (*tp) && TREE_CODE (*tp) != OMP_CLAUSE)
748 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
750 /* The copied TARGET_EXPR has never been expanded, even if the
751 original node was expanded already. */
752 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
754 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
755 TREE_OPERAND (*tp, 3) = NULL_TREE;
758 /* Variable substitution need not be simple. In particular, the
759 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
760 and friends are up-to-date. */
761 else if (TREE_CODE (*tp) == ADDR_EXPR)
763 int invariant = TREE_INVARIANT (*tp);
764 walk_tree (&TREE_OPERAND (*tp, 0), copy_body_r, id, NULL);
765 /* Handle the case where we substituted an INDIRECT_REF
766 into the operand of the ADDR_EXPR. */
767 if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF)
768 *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
770 recompute_tree_invariant_for_addr_expr (*tp);
771 /* If this used to be invariant, but is not any longer,
772 then regimplification is probably needed. */
773 if (invariant && !TREE_INVARIANT (*tp))
774 id->regimplify = true;
779 /* Keep iterating. */
783 /* Copy basic block, scale profile accordingly. Edges will be taken care of
787 copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, int count_scale)
789 block_stmt_iterator bsi, copy_bsi;
790 basic_block copy_basic_block;
792 /* create_basic_block() will append every new block to
793 basic_block_info automatically. */
794 copy_basic_block = create_basic_block (NULL, (void *) 0,
795 (basic_block) bb->prev_bb->aux);
796 copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
798 /* We are going to rebuild frequencies from scratch. These values have just
799 small importance to drive canonicalize_loop_headers. */
800 copy_basic_block->frequency = ((gcov_type)bb->frequency
801 * frequency_scale / REG_BR_PROB_BASE);
802 if (copy_basic_block->frequency > BB_FREQ_MAX)
803 copy_basic_block->frequency = BB_FREQ_MAX;
804 copy_bsi = bsi_start (copy_basic_block);
806 for (bsi = bsi_start (bb);
807 !bsi_end_p (bsi); bsi_next (&bsi))
809 tree stmt = bsi_stmt (bsi);
810 tree orig_stmt = stmt;
812 id->regimplify = false;
813 walk_tree (&stmt, copy_body_r, id, NULL);
815 /* RETURN_EXPR might be removed,
816 this is signalled by making stmt pointer NULL. */
821 gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt);
823 /* With return slot optimization we can end up with
824 non-gimple (foo *)&this->m, fix that here. */
825 if ((TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
826 && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == NOP_EXPR
827 && !is_gimple_val (TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 0)))
829 gimplify_stmt (&stmt);
831 bsi_insert_after (©_bsi, stmt, BSI_NEW_STMT);
833 /* Process new statement. gimplify_stmt possibly turned statement
834 into multiple statements, we need to process all of them. */
835 while (!bsi_end_p (copy_bsi))
837 tree *stmtp = bsi_stmt_ptr (copy_bsi);
839 call = get_call_expr_in (stmt);
841 if (call && CALL_EXPR_VA_ARG_PACK (call) && id->call_expr)
843 /* __builtin_va_arg_pack () should be replaced by
844 all arguments corresponding to ... in the caller. */
845 tree p, *argarray, new_call, *call_ptr;
846 int nargs = call_expr_nargs (id->call_expr);
848 for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
851 argarray = (tree *) alloca ((nargs + call_expr_nargs (call))
854 memcpy (argarray, CALL_EXPR_ARGP (call),
855 call_expr_nargs (call) * sizeof (*argarray));
856 memcpy (argarray + call_expr_nargs (call),
857 CALL_EXPR_ARGP (id->call_expr)
858 + (call_expr_nargs (id->call_expr) - nargs),
859 nargs * sizeof (*argarray));
861 new_call = build_call_array (TREE_TYPE (call),
863 nargs + call_expr_nargs (call),
865 /* Copy all CALL_EXPR flags, locus and block, except
866 CALL_EXPR_VA_ARG_PACK flag. */
867 CALL_EXPR_STATIC_CHAIN (new_call)
868 = CALL_EXPR_STATIC_CHAIN (call);
869 CALL_EXPR_TAILCALL (new_call) = CALL_EXPR_TAILCALL (call);
870 CALL_EXPR_RETURN_SLOT_OPT (new_call)
871 = CALL_EXPR_RETURN_SLOT_OPT (call);
872 CALL_FROM_THUNK_P (new_call) = CALL_FROM_THUNK_P (call);
873 CALL_CANNOT_INLINE_P (new_call)
874 = CALL_CANNOT_INLINE_P (call);
875 TREE_NOTHROW (new_call) = TREE_NOTHROW (call);
876 SET_EXPR_LOCUS (new_call, EXPR_LOCUS (call));
877 TREE_BLOCK (new_call) = TREE_BLOCK (call);
880 if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT)
881 call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1);
882 if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR)
883 call_ptr = &TREE_OPERAND (*call_ptr, 0);
884 gcc_assert (*call_ptr == call);
885 if (call_ptr == stmtp)
887 bsi_replace (©_bsi, new_call, true);
888 stmtp = bsi_stmt_ptr (copy_bsi);
893 *call_ptr = new_call;
900 && (decl = get_callee_fndecl (call))
901 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
902 && DECL_FUNCTION_CODE (decl)
903 == BUILT_IN_VA_ARG_PACK_LEN)
905 /* __builtin_va_arg_pack_len () should be replaced by
906 the number of anonymous arguments. */
907 int nargs = call_expr_nargs (id->call_expr);
908 tree count, *call_ptr, p;
910 for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p))
913 count = build_int_cst (integer_type_node, nargs);
915 if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT)
916 call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1);
917 if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR)
918 call_ptr = &TREE_OPERAND (*call_ptr, 0);
919 gcc_assert (*call_ptr == call && call_ptr != stmtp);
926 /* Statements produced by inlining can be unfolded, especially
927 when we constant propagated some operands. We can't fold
928 them right now for two reasons:
929 1) folding require SSA_NAME_DEF_STMTs to be correct
930 2) we can't change function calls to builtins.
931 So we just mark statement for later folding. We mark
932 all new statements, instead just statements that has changed
933 by some nontrivial substitution so even statements made
934 foldable indirectly are updated. If this turns out to be
935 expensive, copy_body can be told to watch for nontrivial
937 if (id->statements_to_fold)
938 pointer_set_insert (id->statements_to_fold, stmt);
939 /* We're duplicating a CALL_EXPR. Find any corresponding
940 callgraph edges and update or duplicate them. */
941 if (call && (decl = get_callee_fndecl (call)))
943 struct cgraph_node *node;
944 struct cgraph_edge *edge;
946 switch (id->transform_call_graph_edges)
948 case CB_CGE_DUPLICATE:
949 edge = cgraph_edge (id->src_node, orig_stmt);
951 cgraph_clone_edge (edge, id->dst_node, stmt,
952 REG_BR_PROB_BASE, 1, edge->frequency, true);
955 case CB_CGE_MOVE_CLONES:
956 for (node = id->dst_node->next_clone;
958 node = node->next_clone)
960 edge = cgraph_edge (node, orig_stmt);
962 cgraph_set_call_stmt (edge, stmt);
967 edge = cgraph_edge (id->dst_node, orig_stmt);
969 cgraph_set_call_stmt (edge, stmt);
976 /* If you think we can abort here, you are wrong.
977 There is no region 0 in tree land. */
978 gcc_assert (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt)
981 if (tree_could_throw_p (stmt)
982 /* When we are cloning for inlining, we are supposed to
983 construct a clone that calls precisely the same functions
984 as original. However IPA optimizers might've proved
985 earlier some function calls as non-trapping that might
986 render some basic blocks dead that might become
989 We can't update SSA with unreachable blocks in CFG and thus
990 we prevent the scenario by preserving even the "dead" eh
991 edges until the point they are later removed by
993 || (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES
994 && lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) > 0))
996 int region = lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt);
997 /* Add an entry for the copied tree in the EH hashtable.
998 When cloning or versioning, use the hashtable in
999 cfun, and just copy the EH number. When inlining, use the
1000 hashtable in the caller, and adjust the region number. */
1002 add_stmt_to_eh_region (stmt, region + id->eh_region_offset);
1004 /* If this tree doesn't have a region associated with it,
1005 and there is a "current region,"
1006 then associate this tree with the current region
1007 and add edges associated with this region. */
1008 if ((lookup_stmt_eh_region_fn (id->src_cfun,
1010 && id->eh_region > 0)
1011 && tree_could_throw_p (stmt))
1012 add_stmt_to_eh_region (stmt, id->eh_region);
1014 if (gimple_in_ssa_p (cfun))
1019 find_new_referenced_vars (bsi_stmt_ptr (copy_bsi));
1020 FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
1021 if (TREE_CODE (def) == SSA_NAME)
1022 SSA_NAME_DEF_STMT (def) = stmt;
1024 bsi_next (©_bsi);
1026 copy_bsi = bsi_last (copy_basic_block);
1029 return copy_basic_block;
1032 /* Inserting Single Entry Multiple Exit region in SSA form into code in SSA
1033 form is quite easy, since dominator relationship for old basic blocks does
1036 There is however exception where inlining might change dominator relation
1037 across EH edges from basic block within inlined functions destinating
1038 to landing pads in function we inline into.
1040 The function fills in PHI_RESULTs of such PHI nodes if they refer
1041 to gimple regs. Otherwise, the function mark PHI_RESULT of such
1042 PHI nodes for renaming. For non-gimple regs, renaming is safe: the
1043 EH edges are abnormal and SSA_NAME_OCCURS_IN_ABNORMAL_PHI must be
1044 set, and this means that there will be no overlapping live ranges
1045 for the underlying symbol.
1047 This might change in future if we allow redirecting of EH edges and
1048 we might want to change way build CFG pre-inlining to include
1049 all the possible edges then. */
1051 update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb,
1052 bool can_throw, bool nonlocal_goto)
1057 FOR_EACH_EDGE (e, ei, bb->succs)
1059 || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK)
1063 gcc_assert (e->flags & EDGE_ABNORMAL);
1065 gcc_assert (e->flags & EDGE_EH);
1067 gcc_assert (!(e->flags & EDGE_EH));
1068 for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
1072 /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */
1073 gcc_assert (!e->dest->aux);
1075 gcc_assert (SSA_NAME_OCCURS_IN_ABNORMAL_PHI
1076 (PHI_RESULT (phi)));
1078 if (!is_gimple_reg (PHI_RESULT (phi)))
1080 mark_sym_for_renaming
1081 (SSA_NAME_VAR (PHI_RESULT (phi)));
1085 re = find_edge (ret_bb, e->dest);
1087 gcc_assert ((re->flags & (EDGE_EH | EDGE_ABNORMAL))
1088 == (e->flags & (EDGE_EH | EDGE_ABNORMAL)));
1090 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
1091 USE_FROM_PTR (PHI_ARG_DEF_PTR_FROM_EDGE (phi, re)));
1096 /* Copy edges from BB into its copy constructed earlier, scale profile
1097 accordingly. Edges will be taken care of later. Assume aux
1098 pointers to point to the copies of each BB. */
1100 copy_edges_for_bb (basic_block bb, int count_scale, basic_block ret_bb)
1102 basic_block new_bb = (basic_block) bb->aux;
1105 block_stmt_iterator bsi;
1108 /* Use the indices from the original blocks to create edges for the
1110 FOR_EACH_EDGE (old_edge, ei, bb->succs)
1111 if (!(old_edge->flags & EDGE_EH))
1115 flags = old_edge->flags;
1117 /* Return edges do get a FALLTHRU flag when the get inlined. */
1118 if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
1119 && old_edge->dest->aux != EXIT_BLOCK_PTR)
1120 flags |= EDGE_FALLTHRU;
1121 new = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
1122 new->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
1123 new->probability = old_edge->probability;
1126 if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
1129 for (bsi = bsi_start (new_bb); !bsi_end_p (bsi);)
1132 bool can_throw, nonlocal_goto;
1134 copy_stmt = bsi_stmt (bsi);
1135 update_stmt (copy_stmt);
1136 if (gimple_in_ssa_p (cfun))
1137 mark_symbols_for_renaming (copy_stmt);
1138 /* Do this before the possible split_block. */
1141 /* If this tree could throw an exception, there are two
1142 cases where we need to add abnormal edge(s): the
1143 tree wasn't in a region and there is a "current
1144 region" in the caller; or the original tree had
1145 EH edges. In both cases split the block after the tree,
1146 and add abnormal edge(s) as needed; we need both
1147 those from the callee and the caller.
1148 We check whether the copy can throw, because the const
1149 propagation can change an INDIRECT_REF which throws
1150 into a COMPONENT_REF which doesn't. If the copy
1151 can throw, the original could also throw. */
1153 can_throw = tree_can_throw_internal (copy_stmt);
1154 nonlocal_goto = tree_can_make_abnormal_goto (copy_stmt);
1156 if (can_throw || nonlocal_goto)
1158 if (!bsi_end_p (bsi))
1159 /* Note that bb's predecessor edges aren't necessarily
1160 right at this point; split_block doesn't care. */
1162 edge e = split_block (new_bb, copy_stmt);
1165 new_bb->aux = e->src->aux;
1166 bsi = bsi_start (new_bb);
1171 make_eh_edges (copy_stmt);
1174 make_abnormal_goto_edges (bb_for_stmt (copy_stmt), true);
1176 if ((can_throw || nonlocal_goto)
1177 && gimple_in_ssa_p (cfun))
1178 update_ssa_across_abnormal_edges (bb_for_stmt (copy_stmt), ret_bb,
1179 can_throw, nonlocal_goto);
1183 /* Copy the PHIs. All blocks and edges are copied, some blocks
1184 was possibly split and new outgoing EH edges inserted.
1185 BB points to the block of original function and AUX pointers links
1186 the original and newly copied blocks. */
1189 copy_phis_for_bb (basic_block bb, copy_body_data *id)
1191 basic_block new_bb = bb->aux;
1195 for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
1197 tree res = PHI_RESULT (phi);
1202 if (is_gimple_reg (res))
1204 walk_tree (&new_res, copy_body_r, id, NULL);
1205 SSA_NAME_DEF_STMT (new_res)
1206 = new_phi = create_phi_node (new_res, new_bb);
1207 FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
1209 edge old_edge = find_edge (new_edge->src->aux, bb);
1210 tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
1213 walk_tree (&new_arg, copy_body_r, id, NULL);
1214 gcc_assert (new_arg);
1215 /* With return slot optimization we can end up with
1216 non-gimple (foo *)&this->m, fix that here. */
1217 if (TREE_CODE (new_arg) != SSA_NAME
1218 && TREE_CODE (new_arg) != FUNCTION_DECL
1219 && !is_gimple_val (new_arg))
1221 tree stmts = NULL_TREE;
1222 new_arg = force_gimple_operand (new_arg, &stmts,
1224 bsi_insert_on_edge_immediate (new_edge, stmts);
1226 add_phi_arg (new_phi, new_arg, new_edge);
1232 /* Wrapper for remap_decl so it can be used as a callback. */
1234 remap_decl_1 (tree decl, void *data)
1236 return remap_decl (decl, (copy_body_data *) data);
1239 /* Build struct function and associated datastructures for the new clone
1240 NEW_FNDECL to be build. CALLEE_FNDECL is the original */
1243 initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count,
1246 struct function *new_cfun
1247 = (struct function *) ggc_alloc_cleared (sizeof (struct function));
1248 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1249 int count_scale, frequency_scale;
1251 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1252 count_scale = (REG_BR_PROB_BASE * count
1253 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1257 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1258 frequency_scale = (REG_BR_PROB_BASE * frequency
1260 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1262 frequency_scale = count_scale;
1264 /* Register specific tree functions. */
1265 tree_register_cfg_hooks ();
1266 *new_cfun = *DECL_STRUCT_FUNCTION (callee_fndecl);
1267 new_cfun->funcdef_no = get_next_funcdef_no ();
1268 VALUE_HISTOGRAMS (new_cfun) = NULL;
1269 new_cfun->unexpanded_var_list = NULL;
1270 new_cfun->cfg = NULL;
1271 new_cfun->decl = new_fndecl /*= copy_node (callee_fndecl)*/;
1272 DECL_STRUCT_FUNCTION (new_fndecl) = new_cfun;
1273 push_cfun (new_cfun);
1274 init_empty_tree_cfg ();
1276 ENTRY_BLOCK_PTR->count =
1277 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1279 ENTRY_BLOCK_PTR->frequency =
1280 (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1281 frequency_scale / REG_BR_PROB_BASE);
1282 EXIT_BLOCK_PTR->count =
1283 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale /
1285 EXIT_BLOCK_PTR->frequency =
1286 (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency *
1287 frequency_scale / REG_BR_PROB_BASE);
1289 init_eh_for_function ();
1291 if (src_cfun->gimple_df)
1294 cfun->gimple_df->in_ssa_p = true;
1295 init_ssa_operands ();
1300 /* Make a copy of the body of FN so that it can be inserted inline in
1301 another function. Walks FN via CFG, returns new fndecl. */
1304 copy_cfg_body (copy_body_data * id, gcov_type count, int frequency,
1305 basic_block entry_block_map, basic_block exit_block_map)
1307 tree callee_fndecl = id->src_fn;
1308 /* Original cfun for the callee, doesn't change. */
1309 struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1310 struct function *cfun_to_copy;
1312 tree new_fndecl = NULL;
1313 int count_scale, frequency_scale;
1316 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count)
1317 count_scale = (REG_BR_PROB_BASE * count
1318 / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count);
1322 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency)
1323 frequency_scale = (REG_BR_PROB_BASE * frequency
1325 ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency);
1327 frequency_scale = count_scale;
1329 /* Register specific tree functions. */
1330 tree_register_cfg_hooks ();
1332 /* Must have a CFG here at this point. */
1333 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
1334 (DECL_STRUCT_FUNCTION (callee_fndecl)));
1336 cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl);
1339 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map;
1340 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map;
1341 entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1342 exit_block_map->aux = EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy);
1344 /* Duplicate any exception-handling regions. */
1347 id->eh_region_offset
1348 = duplicate_eh_regions (cfun_to_copy, remap_decl_1, id,
1351 /* Use aux pointers to map the original blocks to copy. */
1352 FOR_EACH_BB_FN (bb, cfun_to_copy)
1354 basic_block new = copy_bb (id, bb, frequency_scale, count_scale);
1359 last = last_basic_block;
1360 /* Now that we've duplicated the blocks, duplicate their edges. */
1361 FOR_ALL_BB_FN (bb, cfun_to_copy)
1362 copy_edges_for_bb (bb, count_scale, exit_block_map);
1363 if (gimple_in_ssa_p (cfun))
1364 FOR_ALL_BB_FN (bb, cfun_to_copy)
1365 copy_phis_for_bb (bb, id);
1366 FOR_ALL_BB_FN (bb, cfun_to_copy)
1368 ((basic_block)bb->aux)->aux = NULL;
1371 /* Zero out AUX fields of newly created block during EH edge
1373 for (; last < last_basic_block; last++)
1374 BASIC_BLOCK (last)->aux = NULL;
1375 entry_block_map->aux = NULL;
1376 exit_block_map->aux = NULL;
1381 /* Make a copy of the body of FN so that it can be inserted inline in
1382 another function. */
1385 copy_generic_body (copy_body_data *id)
1388 tree fndecl = id->src_fn;
1390 body = DECL_SAVED_TREE (fndecl);
1391 walk_tree (&body, copy_body_r, id, NULL);
1397 copy_body (copy_body_data *id, gcov_type count, int frequency,
1398 basic_block entry_block_map, basic_block exit_block_map)
1400 tree fndecl = id->src_fn;
1403 /* If this body has a CFG, walk CFG and copy. */
1404 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl)));
1405 body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map);
1410 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
1411 defined in function FN, or of a data member thereof. */
1414 self_inlining_addr_expr (tree value, tree fn)
1418 if (TREE_CODE (value) != ADDR_EXPR)
1421 var = get_base_address (TREE_OPERAND (value, 0));
1423 return var && auto_var_in_fn_p (var, fn);
1427 setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
1428 basic_block bb, tree *vars)
1434 tree def = (gimple_in_ssa_p (cfun)
1435 ? gimple_default_def (id->src_cfun, p) : NULL);
1438 && value != error_mark_node
1439 && !useless_type_conversion_p (TREE_TYPE (p), TREE_TYPE (value)))
1440 rhs = fold_build1 (NOP_EXPR, TREE_TYPE (p), value);
1442 /* If the parameter is never assigned to, has no SSA_NAMEs created,
1443 we may not need to create a new variable here at all. Instead, we may
1444 be able to just use the argument value. */
1445 if (TREE_READONLY (p)
1446 && !TREE_ADDRESSABLE (p)
1447 && value && !TREE_SIDE_EFFECTS (value)
1450 /* We may produce non-gimple trees by adding NOPs or introduce
1451 invalid sharing when operand is not really constant.
1452 It is not big deal to prohibit constant propagation here as
1453 we will constant propagate in DOM1 pass anyway. */
1454 if (is_gimple_min_invariant (value)
1455 && useless_type_conversion_p (TREE_TYPE (p),
1457 /* We have to be very careful about ADDR_EXPR. Make sure
1458 the base variable isn't a local variable of the inlined
1459 function, e.g., when doing recursive inlining, direct or
1460 mutually-recursive or whatever, which is why we don't
1461 just test whether fn == current_function_decl. */
1462 && ! self_inlining_addr_expr (value, fn))
1464 insert_decl_map (id, p, value);
1469 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
1470 here since the type of this decl must be visible to the calling
1472 var = copy_decl_to_var (p, id);
1473 if (gimple_in_ssa_p (cfun) && TREE_CODE (var) == VAR_DECL)
1476 add_referenced_var (var);
1479 /* See if the frontend wants to pass this by invisible reference. If
1480 so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
1481 replace uses of the PARM_DECL with dereferences. */
1482 if (TREE_TYPE (var) != TREE_TYPE (p)
1483 && POINTER_TYPE_P (TREE_TYPE (var))
1484 && TREE_TYPE (TREE_TYPE (var)) == TREE_TYPE (p))
1486 insert_decl_map (id, var, var);
1487 var_sub = build_fold_indirect_ref (var);
1492 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
1493 that way, when the PARM_DECL is encountered, it will be
1494 automatically replaced by the VAR_DECL. */
1495 insert_decl_map (id, p, var_sub);
1497 /* Declare this new variable. */
1498 TREE_CHAIN (var) = *vars;
1501 /* Make gimplifier happy about this variable. */
1502 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1504 /* Even if P was TREE_READONLY, the new VAR should not be.
1505 In the original code, we would have constructed a
1506 temporary, and then the function body would have never
1507 changed the value of P. However, now, we will be
1508 constructing VAR directly. The constructor body may
1509 change its value multiple times as it is being
1510 constructed. Therefore, it must not be TREE_READONLY;
1511 the back-end assumes that TREE_READONLY variable is
1512 assigned to only once. */
1513 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
1514 TREE_READONLY (var) = 0;
1516 /* If there is no setup required and we are in SSA, take the easy route
1517 replacing all SSA names representing the function parameter by the
1518 SSA name passed to function.
1520 We need to construct map for the variable anyway as it might be used
1521 in different SSA names when parameter is set in function.
1523 FIXME: This usually kills the last connection in between inlined
1524 function parameter and the actual value in debug info. Can we do
1525 better here? If we just inserted the statement, copy propagation
1526 would kill it anyway as it always did in older versions of GCC.
1528 We might want to introduce a notion that single SSA_NAME might
1529 represent multiple variables for purposes of debugging. */
1530 if (gimple_in_ssa_p (cfun) && rhs && def && is_gimple_reg (p)
1531 && (TREE_CODE (rhs) == SSA_NAME
1532 || is_gimple_min_invariant (rhs))
1533 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
1535 insert_decl_map (id, def, rhs);
1539 /* If the value of argument is never used, don't care about initializing
1541 if (gimple_in_ssa_p (cfun) && !def && is_gimple_reg (p))
1543 gcc_assert (!value || !TREE_SIDE_EFFECTS (value));
1547 /* Initialize this VAR_DECL from the equivalent argument. Convert
1548 the argument to the proper type in case it was promoted. */
1551 block_stmt_iterator bsi = bsi_last (bb);
1553 if (rhs == error_mark_node)
1555 insert_decl_map (id, p, var_sub);
1559 STRIP_USELESS_TYPE_CONVERSION (rhs);
1561 /* We want to use GIMPLE_MODIFY_STMT, not INIT_EXPR here so that we
1562 keep our trees in gimple form. */
1563 if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p))
1565 def = remap_ssa_name (def, id);
1566 init_stmt = build_gimple_modify_stmt (def, rhs);
1567 SSA_NAME_DEF_STMT (def) = init_stmt;
1568 SSA_NAME_IS_DEFAULT_DEF (def) = 0;
1569 set_default_def (var, NULL);
1572 init_stmt = build_gimple_modify_stmt (var, rhs);
1574 /* If we did not create a gimple value and we did not create a gimple
1575 cast of a gimple value, then we will need to gimplify INIT_STMTS
1576 at the end. Note that is_gimple_cast only checks the outer
1577 tree code, not its operand. Thus the explicit check that its
1578 operand is a gimple value. */
1579 if ((!is_gimple_val (rhs)
1580 && (!is_gimple_cast (rhs)
1581 || !is_gimple_val (TREE_OPERAND (rhs, 0))))
1582 || !is_gimple_reg (var))
1584 tree_stmt_iterator i;
1586 push_gimplify_context ();
1587 gimplify_stmt (&init_stmt);
1588 if (gimple_in_ssa_p (cfun)
1589 && init_stmt && TREE_CODE (init_stmt) == STATEMENT_LIST)
1591 /* The replacement can expose previously unreferenced
1593 for (i = tsi_start (init_stmt); !tsi_end_p (i); tsi_next (&i))
1594 find_new_referenced_vars (tsi_stmt_ptr (i));
1596 pop_gimplify_context (NULL);
1599 /* If VAR represents a zero-sized variable, it's possible that the
1600 assignment statment may result in no gimple statements. */
1602 bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT);
1603 if (gimple_in_ssa_p (cfun))
1604 for (;!bsi_end_p (bsi); bsi_next (&bsi))
1605 mark_symbols_for_renaming (bsi_stmt (bsi));
1609 /* Generate code to initialize the parameters of the function at the
1610 top of the stack in ID from the CALL_EXPR EXP. */
1613 initialize_inlined_parameters (copy_body_data *id, tree exp,
1614 tree fn, basic_block bb)
1619 tree vars = NULL_TREE;
1620 call_expr_arg_iterator iter;
1621 tree static_chain = CALL_EXPR_STATIC_CHAIN (exp);
1623 /* Figure out what the parameters are. */
1624 parms = DECL_ARGUMENTS (fn);
1626 /* Loop through the parameter declarations, replacing each with an
1627 equivalent VAR_DECL, appropriately initialized. */
1628 for (p = parms, a = first_call_expr_arg (exp, &iter); p;
1629 a = next_call_expr_arg (&iter), p = TREE_CHAIN (p))
1630 setup_one_parameter (id, p, a, fn, bb, &vars);
1632 /* Initialize the static chain. */
1633 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
1634 gcc_assert (fn != current_function_decl);
1637 /* No static chain? Seems like a bug in tree-nested.c. */
1638 gcc_assert (static_chain);
1640 setup_one_parameter (id, p, static_chain, fn, bb, &vars);
1643 declare_inline_vars (id->block, vars);
1646 /* Declare a return variable to replace the RESULT_DECL for the
1647 function we are calling. An appropriate DECL_STMT is returned.
1648 The USE_STMT is filled to contain a use of the declaration to
1649 indicate the return value of the function.
1651 RETURN_SLOT, if non-null is place where to store the result. It
1652 is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null,
1653 was the LHS of the GIMPLE_MODIFY_STMT to which this call is the RHS.
1655 The return value is a (possibly null) value that is the result of the
1656 function as seen by the callee. *USE_P is a (possibly null) value that
1657 holds the result as seen by the caller. */
1660 declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
1663 tree callee = id->src_fn;
1664 tree caller = id->dst_fn;
1665 tree result = DECL_RESULT (callee);
1666 tree callee_type = TREE_TYPE (result);
1667 tree caller_type = TREE_TYPE (TREE_TYPE (callee));
1670 /* We don't need to do anything for functions that don't return
1672 if (!result || VOID_TYPE_P (callee_type))
1678 /* If there was a return slot, then the return value is the
1679 dereferenced address of that object. */
1682 /* The front end shouldn't have used both return_slot and
1683 a modify expression. */
1684 gcc_assert (!modify_dest);
1685 if (DECL_BY_REFERENCE (result))
1687 tree return_slot_addr = build_fold_addr_expr (return_slot);
1688 STRIP_USELESS_TYPE_CONVERSION (return_slot_addr);
1690 /* We are going to construct *&return_slot and we can't do that
1691 for variables believed to be not addressable.
1693 FIXME: This check possibly can match, because values returned
1694 via return slot optimization are not believed to have address
1695 taken by alias analysis. */
1696 gcc_assert (TREE_CODE (return_slot) != SSA_NAME);
1697 if (gimple_in_ssa_p (cfun))
1699 HOST_WIDE_INT bitsize;
1700 HOST_WIDE_INT bitpos;
1702 enum machine_mode mode;
1706 base = get_inner_reference (return_slot, &bitsize, &bitpos,
1708 &mode, &unsignedp, &volatilep,
1710 if (TREE_CODE (base) == INDIRECT_REF)
1711 base = TREE_OPERAND (base, 0);
1712 if (TREE_CODE (base) == SSA_NAME)
1713 base = SSA_NAME_VAR (base);
1714 mark_sym_for_renaming (base);
1716 var = return_slot_addr;
1721 gcc_assert (TREE_CODE (var) != SSA_NAME);
1723 if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1724 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1725 && !DECL_GIMPLE_REG_P (result)
1727 DECL_GIMPLE_REG_P (var) = 0;
1732 /* All types requiring non-trivial constructors should have been handled. */
1733 gcc_assert (!TREE_ADDRESSABLE (callee_type));
1735 /* Attempt to avoid creating a new temporary variable. */
1737 && TREE_CODE (modify_dest) != SSA_NAME)
1739 bool use_it = false;
1741 /* We can't use MODIFY_DEST if there's type promotion involved. */
1742 if (!useless_type_conversion_p (callee_type, caller_type))
1745 /* ??? If we're assigning to a variable sized type, then we must
1746 reuse the destination variable, because we've no good way to
1747 create variable sized temporaries at this point. */
1748 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
1751 /* If the callee cannot possibly modify MODIFY_DEST, then we can
1752 reuse it as the result of the call directly. Don't do this if
1753 it would promote MODIFY_DEST to addressable. */
1754 else if (TREE_ADDRESSABLE (result))
1758 tree base_m = get_base_address (modify_dest);
1760 /* If the base isn't a decl, then it's a pointer, and we don't
1761 know where that's going to go. */
1762 if (!DECL_P (base_m))
1764 else if (is_global_var (base_m))
1766 else if ((TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1767 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1768 && !DECL_GIMPLE_REG_P (result)
1769 && DECL_GIMPLE_REG_P (base_m))
1771 else if (!TREE_ADDRESSABLE (base_m))
1783 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
1785 var = copy_result_decl_to_var (result, id);
1786 if (gimple_in_ssa_p (cfun))
1789 add_referenced_var (var);
1792 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
1793 DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list
1794 = tree_cons (NULL_TREE, var,
1795 DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
1797 /* Do not have the rest of GCC warn about this variable as it should
1798 not be visible to the user. */
1799 TREE_NO_WARNING (var) = 1;
1801 declare_inline_vars (id->block, var);
1803 /* Build the use expr. If the return type of the function was
1804 promoted, convert it back to the expected type. */
1806 if (!useless_type_conversion_p (caller_type, TREE_TYPE (var)))
1807 use = fold_convert (caller_type, var);
1809 STRIP_USELESS_TYPE_CONVERSION (use);
1811 if (DECL_BY_REFERENCE (result))
1812 var = build_fold_addr_expr (var);
1815 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
1816 way, when the RESULT_DECL is encountered, it will be
1817 automatically replaced by the VAR_DECL. */
1818 insert_decl_map (id, result, var);
1820 /* Remember this so we can ignore it in remap_decls. */
1827 /* Returns nonzero if a function can be inlined as a tree. */
1830 tree_inlinable_function_p (tree fn)
1832 return inlinable_function_p (fn);
1835 static const char *inline_forbidden_reason;
1838 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
1842 tree fn = (tree) fnp;
1845 switch (TREE_CODE (node))
1848 /* Refuse to inline alloca call unless user explicitly forced so as
1849 this may change program's memory overhead drastically when the
1850 function using alloca is called in loop. In GCC present in
1851 SPEC2000 inlining into schedule_block cause it to require 2GB of
1852 RAM instead of 256MB. */
1853 if (alloca_call_p (node)
1854 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1856 inline_forbidden_reason
1857 = G_("function %q+F can never be inlined because it uses "
1858 "alloca (override using the always_inline attribute)");
1861 t = get_callee_fndecl (node);
1865 /* We cannot inline functions that call setjmp. */
1866 if (setjmp_call_p (t))
1868 inline_forbidden_reason
1869 = G_("function %q+F can never be inlined because it uses setjmp");
1873 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
1874 switch (DECL_FUNCTION_CODE (t))
1876 /* We cannot inline functions that take a variable number of
1878 case BUILT_IN_VA_START:
1879 case BUILT_IN_STDARG_START:
1880 case BUILT_IN_NEXT_ARG:
1881 case BUILT_IN_VA_END:
1882 inline_forbidden_reason
1883 = G_("function %q+F can never be inlined because it "
1884 "uses variable argument lists");
1887 case BUILT_IN_LONGJMP:
1888 /* We can't inline functions that call __builtin_longjmp at
1889 all. The non-local goto machinery really requires the
1890 destination be in a different function. If we allow the
1891 function calling __builtin_longjmp to be inlined into the
1892 function calling __builtin_setjmp, Things will Go Awry. */
1893 inline_forbidden_reason
1894 = G_("function %q+F can never be inlined because "
1895 "it uses setjmp-longjmp exception handling");
1898 case BUILT_IN_NONLOCAL_GOTO:
1900 inline_forbidden_reason
1901 = G_("function %q+F can never be inlined because "
1902 "it uses non-local goto");
1905 case BUILT_IN_RETURN:
1906 case BUILT_IN_APPLY_ARGS:
1907 /* If a __builtin_apply_args caller would be inlined,
1908 it would be saving arguments of the function it has
1909 been inlined into. Similarly __builtin_return would
1910 return from the function the inline has been inlined into. */
1911 inline_forbidden_reason
1912 = G_("function %q+F can never be inlined because "
1913 "it uses __builtin_return or __builtin_apply_args");
1922 t = TREE_OPERAND (node, 0);
1924 /* We will not inline a function which uses computed goto. The
1925 addresses of its local labels, which may be tucked into
1926 global storage, are of course not constant across
1927 instantiations, which causes unexpected behavior. */
1928 if (TREE_CODE (t) != LABEL_DECL)
1930 inline_forbidden_reason
1931 = G_("function %q+F can never be inlined "
1932 "because it contains a computed goto");
1938 t = TREE_OPERAND (node, 0);
1939 if (DECL_NONLOCAL (t))
1941 /* We cannot inline a function that receives a non-local goto
1942 because we cannot remap the destination label used in the
1943 function that is performing the non-local goto. */
1944 inline_forbidden_reason
1945 = G_("function %q+F can never be inlined "
1946 "because it receives a non-local goto");
1953 /* We cannot inline a function of the form
1955 void F (int i) { struct S { int ar[i]; } s; }
1957 Attempting to do so produces a catch-22.
1958 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1959 UNION_TYPE nodes, then it goes into infinite recursion on a
1960 structure containing a pointer to its own type. If it doesn't,
1961 then the type node for S doesn't get adjusted properly when
1964 ??? This is likely no longer true, but it's too late in the 4.0
1965 cycle to try to find out. This should be checked for 4.1. */
1966 for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1967 if (variably_modified_type_p (TREE_TYPE (t), NULL))
1969 inline_forbidden_reason
1970 = G_("function %q+F can never be inlined "
1971 "because it uses variable sized variables");
1983 inline_forbidden_p_2 (tree *nodep, int *walk_subtrees,
1987 tree fn = (tree) fnp;
1989 if (TREE_CODE (node) == LABEL_DECL && DECL_CONTEXT (node) == fn)
1991 inline_forbidden_reason
1992 = G_("function %q+F can never be inlined "
1993 "because it saves address of local label in a static variable");
2003 /* Return subexpression representing possible alloca call, if any. */
2005 inline_forbidden_p (tree fndecl)
2007 location_t saved_loc = input_location;
2008 block_stmt_iterator bsi;
2010 tree ret = NULL_TREE;
2011 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
2014 FOR_EACH_BB_FN (bb, fun)
2015 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2017 ret = walk_tree_without_duplicates (bsi_stmt_ptr (bsi),
2018 inline_forbidden_p_1, fndecl);
2023 for (step = fun->unexpanded_var_list; step; step = TREE_CHAIN (step))
2025 tree decl = TREE_VALUE (step);
2026 if (TREE_CODE (decl) == VAR_DECL
2027 && TREE_STATIC (decl)
2028 && !DECL_EXTERNAL (decl)
2029 && DECL_INITIAL (decl))
2030 ret = walk_tree_without_duplicates (&DECL_INITIAL (decl),
2031 inline_forbidden_p_2, fndecl);
2037 input_location = saved_loc;
2041 /* Returns nonzero if FN is a function that does not have any
2042 fundamental inline blocking properties. */
2045 inlinable_function_p (tree fn)
2047 bool inlinable = true;
2051 /* If we've already decided this function shouldn't be inlined,
2052 there's no need to check again. */
2053 if (DECL_UNINLINABLE (fn))
2056 /* We only warn for functions declared `inline' by the user. */
2057 do_warning = (warn_inline
2059 && DECL_DECLARED_INLINE_P (fn)
2060 && !DECL_IN_SYSTEM_HEADER (fn));
2062 always_inline = lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn));
2064 if (flag_really_no_inline
2065 && always_inline == NULL)
2068 warning (OPT_Winline, "function %q+F can never be inlined because it "
2069 "is suppressed using -fno-inline", fn);
2073 /* Don't auto-inline anything that might not be bound within
2074 this unit of translation. */
2075 else if (!DECL_DECLARED_INLINE_P (fn)
2076 && DECL_REPLACEABLE_P (fn))
2079 else if (!function_attribute_inlinable_p (fn))
2082 warning (OPT_Winline, "function %q+F can never be inlined because it "
2083 "uses attributes conflicting with inlining", fn);
2087 /* If we don't have the function body available, we can't inline it.
2088 However, this should not be recorded since we also get here for
2089 forward declared inline functions. Therefore, return at once. */
2090 if (!DECL_SAVED_TREE (fn))
2093 /* If we're not inlining at all, then we cannot inline this function. */
2094 else if (!flag_inline_trees)
2097 /* Only try to inline functions if DECL_INLINE is set. This should be
2098 true for all functions declared `inline', and for all other functions
2099 as well with -finline-functions.
2101 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
2102 it's the front-end that must set DECL_INLINE in this case, because
2103 dwarf2out loses if a function that does not have DECL_INLINE set is
2104 inlined anyway. That is why we have both DECL_INLINE and
2105 DECL_DECLARED_INLINE_P. */
2106 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
2107 here should be redundant. */
2108 else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
2111 else if (inline_forbidden_p (fn))
2113 /* See if we should warn about uninlinable functions. Previously,
2114 some of these warnings would be issued while trying to expand
2115 the function inline, but that would cause multiple warnings
2116 about functions that would for example call alloca. But since
2117 this a property of the function, just one warning is enough.
2118 As a bonus we can now give more details about the reason why a
2119 function is not inlinable. */
2121 sorry (inline_forbidden_reason, fn);
2122 else if (do_warning)
2123 warning (OPT_Winline, inline_forbidden_reason, fn);
2128 /* Squirrel away the result so that we don't have to check again. */
2129 DECL_UNINLINABLE (fn) = !inlinable;
2134 /* Estimate the cost of a memory move. Use machine dependent
2135 word size and take possible memcpy call into account. */
2138 estimate_move_cost (tree type)
2142 size = int_size_in_bytes (type);
2144 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
2145 /* Cost of a memcpy call, 3 arguments and the call. */
2148 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
2151 /* Arguments for estimate_num_insns_1. */
2155 /* Used to return the number of insns. */
2158 /* Weights of various constructs. */
2159 eni_weights *weights;
2162 /* Used by estimate_num_insns. Estimate number of instructions seen
2163 by given statement. */
2166 estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
2168 struct eni_data *d = data;
2172 if (IS_TYPE_OR_DECL_P (x))
2177 /* Assume that constants and references counts nothing. These should
2178 be majorized by amount of operations among them we count later
2179 and are common target of CSE and similar optimizations. */
2180 else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
2183 switch (TREE_CODE (x))
2185 /* Containers have no cost. */
2192 case ALIGN_INDIRECT_REF:
2193 case MISALIGNED_INDIRECT_REF:
2195 case ARRAY_RANGE_REF:
2197 case EXC_PTR_EXPR: /* ??? */
2198 case FILTER_EXPR: /* ??? */
2201 case WITH_CLEANUP_EXPR:
2204 case VIEW_CONVERT_EXPR:
2209 case CASE_LABEL_EXPR:
2212 case EH_FILTER_EXPR:
2213 case STATEMENT_LIST:
2215 case NON_LVALUE_EXPR:
2218 case TRY_CATCH_EXPR:
2219 case TRY_FINALLY_EXPR:
2226 case WITH_SIZE_EXPR:
2230 case OMP_SECTIONS_SWITCH:
2231 case OMP_ATOMIC_STORE:
2234 /* We don't account constants for now. Assume that the cost is amortized
2235 by operations that do use them. We may re-consider this decision once
2236 we are able to optimize the tree before estimating its size and break
2237 out static initializers. */
2238 case IDENTIFIER_NODE:
2248 /* CHANGE_DYNAMIC_TYPE_EXPR explicitly expands to nothing. */
2249 case CHANGE_DYNAMIC_TYPE_EXPR:
2253 /* Try to estimate the cost of assignments. We have three cases to
2255 1) Simple assignments to registers;
2256 2) Stores to things that must live in memory. This includes
2257 "normal" stores to scalars, but also assignments of large
2258 structures, or constructors of big arrays;
2261 Let us look at the first two cases, assuming we have "a = b + C":
2262 <GIMPLE_MODIFY_STMT <var_decl "a">
2263 <plus_expr <var_decl "b"> <constant C>>
2264 If "a" is a GIMPLE register, the assignment to it is free on almost
2265 any target, because "a" usually ends up in a real register. Hence
2266 the only cost of this expression comes from the PLUS_EXPR, and we
2267 can ignore the GIMPLE_MODIFY_STMT.
2268 If "a" is not a GIMPLE register, the assignment to "a" will most
2269 likely be a real store, so the cost of the GIMPLE_MODIFY_STMT is the cost
2270 of moving something into "a", which we compute using the function
2273 The third case deals with TARGET_EXPRs, for which the semantics are
2274 that a temporary is assigned, unless the TARGET_EXPR itself is being
2275 assigned to something else. In the latter case we do not need the
2277 <GIMPLE_MODIFY_STMT <var_decl "a"> <target_expr>>, the
2278 GIMPLE_MODIFY_STMT is free. */
2280 case GIMPLE_MODIFY_STMT:
2281 /* Is the right and side a TARGET_EXPR? */
2282 if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR)
2284 /* ... fall through ... */
2287 x = GENERIC_TREE_OPERAND (x, 0);
2288 /* Is this an assignments to a register? */
2289 if (is_gimple_reg (x))
2291 /* Otherwise it's a store, so fall through to compute the move cost. */
2294 d->count += estimate_move_cost (TREE_TYPE (x));
2297 /* Assign cost of 1 to usual operations.
2298 ??? We may consider mapping RTL costs to this. */
2303 case POINTER_PLUS_EXPR:
2307 case FIXED_CONVERT_EXPR:
2308 case FIX_TRUNC_EXPR:
2320 case VEC_LSHIFT_EXPR:
2321 case VEC_RSHIFT_EXPR:
2328 case TRUTH_ANDIF_EXPR:
2329 case TRUTH_ORIF_EXPR:
2330 case TRUTH_AND_EXPR:
2332 case TRUTH_XOR_EXPR:
2333 case TRUTH_NOT_EXPR:
2342 case UNORDERED_EXPR:
2353 case PREDECREMENT_EXPR:
2354 case PREINCREMENT_EXPR:
2355 case POSTDECREMENT_EXPR:
2356 case POSTINCREMENT_EXPR:
2360 case REALIGN_LOAD_EXPR:
2362 case REDUC_MAX_EXPR:
2363 case REDUC_MIN_EXPR:
2364 case REDUC_PLUS_EXPR:
2365 case WIDEN_SUM_EXPR:
2367 case VEC_WIDEN_MULT_HI_EXPR:
2368 case VEC_WIDEN_MULT_LO_EXPR:
2369 case VEC_UNPACK_HI_EXPR:
2370 case VEC_UNPACK_LO_EXPR:
2371 case VEC_UNPACK_FLOAT_HI_EXPR:
2372 case VEC_UNPACK_FLOAT_LO_EXPR:
2373 case VEC_PACK_TRUNC_EXPR:
2374 case VEC_PACK_SAT_EXPR:
2375 case VEC_PACK_FIX_TRUNC_EXPR:
2377 case WIDEN_MULT_EXPR:
2379 case VEC_EXTRACT_EVEN_EXPR:
2380 case VEC_EXTRACT_ODD_EXPR:
2381 case VEC_INTERLEAVE_HIGH_EXPR:
2382 case VEC_INTERLEAVE_LOW_EXPR:
2389 /* TODO: Cost of a switch should be derived from the number of
2391 d->count += d->weights->switch_cost;
2394 /* Few special cases of expensive operations. This is useful
2395 to avoid inlining on functions having too many of these. */
2396 case TRUNC_DIV_EXPR:
2398 case FLOOR_DIV_EXPR:
2399 case ROUND_DIV_EXPR:
2400 case EXACT_DIV_EXPR:
2401 case TRUNC_MOD_EXPR:
2403 case FLOOR_MOD_EXPR:
2404 case ROUND_MOD_EXPR:
2406 d->count += d->weights->div_mod_cost;
2410 tree decl = get_callee_fndecl (x);
2412 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
2413 cost = d->weights->target_builtin_call_cost;
2415 cost = d->weights->call_cost;
2417 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
2418 switch (DECL_FUNCTION_CODE (decl))
2420 case BUILT_IN_CONSTANT_P:
2423 case BUILT_IN_EXPECT:
2425 /* Prefetch instruction is not expensive. */
2426 case BUILT_IN_PREFETCH:
2433 /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
2434 that does use function declaration to figure out the arguments. */
2438 call_expr_arg_iterator iter;
2439 FOR_EACH_CALL_EXPR_ARG (a, iter, x)
2440 d->count += estimate_move_cost (TREE_TYPE (a));
2445 for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
2446 d->count += estimate_move_cost (TREE_TYPE (arg));
2462 case OMP_ATOMIC_LOAD:
2463 /* OpenMP directives are generally very expensive. */
2464 d->count += d->weights->omp_cost;
2473 /* Estimate number of instructions that will be created by expanding EXPR.
2474 WEIGHTS contains weights attributed to various constructs. */
2477 estimate_num_insns (tree expr, eni_weights *weights)
2479 struct pointer_set_t *visited_nodes;
2481 block_stmt_iterator bsi;
2482 struct function *my_function;
2483 struct eni_data data;
2486 data.weights = weights;
2488 /* If we're given an entire function, walk the CFG. */
2489 if (TREE_CODE (expr) == FUNCTION_DECL)
2491 my_function = DECL_STRUCT_FUNCTION (expr);
2492 gcc_assert (my_function && my_function->cfg);
2493 visited_nodes = pointer_set_create ();
2494 FOR_EACH_BB_FN (bb, my_function)
2496 for (bsi = bsi_start (bb);
2500 walk_tree (bsi_stmt_ptr (bsi), estimate_num_insns_1,
2501 &data, visited_nodes);
2504 pointer_set_destroy (visited_nodes);
2507 walk_tree_without_duplicates (&expr, estimate_num_insns_1, &data);
2512 /* Initializes weights used by estimate_num_insns. */
2515 init_inline_once (void)
2517 eni_inlining_weights.call_cost = PARAM_VALUE (PARAM_INLINE_CALL_COST);
2518 eni_inlining_weights.target_builtin_call_cost = 1;
2519 eni_inlining_weights.div_mod_cost = 10;
2520 eni_inlining_weights.switch_cost = 1;
2521 eni_inlining_weights.omp_cost = 40;
2523 eni_size_weights.call_cost = 1;
2524 eni_size_weights.target_builtin_call_cost = 1;
2525 eni_size_weights.div_mod_cost = 1;
2526 eni_size_weights.switch_cost = 10;
2527 eni_size_weights.omp_cost = 40;
2529 /* Estimating time for call is difficult, since we have no idea what the
2530 called function does. In the current uses of eni_time_weights,
2531 underestimating the cost does less harm than overestimating it, so
2532 we choose a rather small value here. */
2533 eni_time_weights.call_cost = 10;
2534 eni_time_weights.target_builtin_call_cost = 10;
2535 eni_time_weights.div_mod_cost = 10;
2536 eni_time_weights.switch_cost = 4;
2537 eni_time_weights.omp_cost = 40;
2540 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
2542 add_lexical_block (tree current_block, tree new_block)
2546 /* Walk to the last sub-block. */
2547 for (blk_p = &BLOCK_SUBBLOCKS (current_block);
2549 blk_p = &BLOCK_CHAIN (*blk_p))
2552 BLOCK_SUPERCONTEXT (new_block) = current_block;
2555 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
2558 expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data)
2564 struct pointer_map_t *st;
2567 location_t saved_location;
2568 struct cgraph_edge *cg_edge;
2570 basic_block return_block;
2572 block_stmt_iterator bsi, stmt_bsi;
2573 bool successfully_inlined = FALSE;
2574 bool purge_dead_abnormal_edges;
2578 /* See what we've got. */
2579 id = (copy_body_data *) data;
2582 /* Set input_location here so we get the right instantiation context
2583 if we call instantiate_decl from inlinable_function_p. */
2584 saved_location = input_location;
2585 if (EXPR_HAS_LOCATION (t))
2586 input_location = EXPR_LOCATION (t);
2588 /* From here on, we're only interested in CALL_EXPRs. */
2589 if (TREE_CODE (t) != CALL_EXPR)
2592 /* First, see if we can figure out what function is being called.
2593 If we cannot, then there is no hope of inlining the function. */
2594 fn = get_callee_fndecl (t);
2598 /* Turn forward declarations into real ones. */
2599 fn = cgraph_node (fn)->decl;
2601 /* If fn is a declaration of a function in a nested scope that was
2602 globally declared inline, we don't set its DECL_INITIAL.
2603 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
2604 C++ front-end uses it for cdtors to refer to their internal
2605 declarations, that are not real functions. Fortunately those
2606 don't have trees to be saved, so we can tell by checking their
2608 if (! DECL_INITIAL (fn)
2609 && DECL_ABSTRACT_ORIGIN (fn)
2610 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
2611 fn = DECL_ABSTRACT_ORIGIN (fn);
2613 /* Objective C and fortran still calls tree_rest_of_compilation directly.
2614 Kill this check once this is fixed. */
2615 if (!id->dst_node->analyzed)
2618 cg_edge = cgraph_edge (id->dst_node, stmt);
2620 /* Constant propagation on argument done during previous inlining
2621 may create new direct call. Produce an edge for it. */
2624 struct cgraph_node *dest = cgraph_node (fn);
2626 /* We have missing edge in the callgraph. This can happen in one case
2627 where previous inlining turned indirect call into direct call by
2628 constant propagating arguments. In all other cases we hit a bug
2629 (incorrect node sharing is most common reason for missing edges. */
2630 gcc_assert (dest->needed || !flag_unit_at_a_time);
2631 cgraph_create_edge (id->dst_node, dest, stmt,
2632 bb->count, CGRAPH_FREQ_BASE,
2633 bb->loop_depth)->inline_failed
2634 = N_("originally indirect function call not considered for inlining");
2637 fprintf (dump_file, "Created new direct edge to %s",
2638 cgraph_node_name (dest));
2643 /* Don't try to inline functions that are not well-suited to
2645 if (!cgraph_inline_p (cg_edge, &reason))
2647 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))
2648 /* Avoid warnings during early inline pass. */
2649 && (!flag_unit_at_a_time || cgraph_global_info_ready))
2651 sorry ("inlining failed in call to %q+F: %s", fn, reason);
2652 sorry ("called from here");
2654 else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
2655 && !DECL_IN_SYSTEM_HEADER (fn)
2657 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn))
2658 /* Avoid warnings during early inline pass. */
2659 && (!flag_unit_at_a_time || cgraph_global_info_ready))
2661 warning (OPT_Winline, "inlining failed in call to %q+F: %s",
2663 warning (OPT_Winline, "called from here");
2667 fn = cg_edge->callee->decl;
2669 #ifdef ENABLE_CHECKING
2670 if (cg_edge->callee->decl != id->dst_node->decl)
2671 verify_cgraph_node (cg_edge->callee);
2674 /* We will be inlining this callee. */
2675 id->eh_region = lookup_stmt_eh_region (stmt);
2677 /* Split the block holding the CALL_EXPR. */
2678 e = split_block (bb, stmt);
2680 return_block = e->dest;
2683 /* split_block splits after the statement; work around this by
2684 moving the call into the second block manually. Not pretty,
2685 but seems easier than doing the CFG manipulation by hand
2686 when the CALL_EXPR is in the last statement of BB. */
2687 stmt_bsi = bsi_last (bb);
2688 bsi_remove (&stmt_bsi, false);
2690 /* If the CALL_EXPR was in the last statement of BB, it may have
2691 been the source of abnormal edges. In this case, schedule
2692 the removal of dead abnormal edges. */
2693 bsi = bsi_start (return_block);
2694 if (bsi_end_p (bsi))
2696 bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
2697 purge_dead_abnormal_edges = true;
2701 bsi_insert_before (&bsi, stmt, BSI_NEW_STMT);
2702 purge_dead_abnormal_edges = false;
2705 stmt_bsi = bsi_start (return_block);
2707 /* Build a block containing code to initialize the arguments, the
2708 actual inline expansion of the body, and a label for the return
2709 statements within the function to jump to. The type of the
2710 statement expression is the return type of the function call. */
2711 id->block = make_node (BLOCK);
2712 BLOCK_ABSTRACT_ORIGIN (id->block) = fn;
2713 BLOCK_SOURCE_LOCATION (id->block) = input_location;
2714 add_lexical_block (TREE_BLOCK (stmt), id->block);
2716 /* Local declarations will be replaced by their equivalents in this
2719 id->decl_map = pointer_map_create ();
2721 /* Record the function we are about to inline. */
2723 id->src_node = cg_edge->callee;
2724 id->src_cfun = DECL_STRUCT_FUNCTION (fn);
2727 gcc_assert (!id->src_cfun->after_inlining);
2730 initialize_inlined_parameters (id, t, fn, bb);
2732 if (DECL_INITIAL (fn))
2733 add_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id));
2735 /* Return statements in the function body will be replaced by jumps
2736 to the RET_LABEL. */
2738 gcc_assert (DECL_INITIAL (fn));
2739 gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
2741 /* Find the lhs to which the result of this call is assigned. */
2743 if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
2745 modify_dest = GIMPLE_STMT_OPERAND (stmt, 0);
2747 /* The function which we are inlining might not return a value,
2748 in which case we should issue a warning that the function
2749 does not return a value. In that case the optimizers will
2750 see that the variable to which the value is assigned was not
2751 initialized. We do not want to issue a warning about that
2752 uninitialized variable. */
2753 if (DECL_P (modify_dest))
2754 TREE_NO_WARNING (modify_dest) = 1;
2755 if (CALL_EXPR_RETURN_SLOT_OPT (t))
2757 return_slot = modify_dest;
2764 /* Declare the return variable for the function. */
2765 declare_return_variable (id, return_slot,
2766 modify_dest, &use_retvar);
2768 /* This is it. Duplicate the callee body. Assume callee is
2769 pre-gimplified. Note that we must not alter the caller
2770 function in any way before this point, as this CALL_EXPR may be
2771 a self-referential call; if we're calling ourselves, we need to
2772 duplicate our body before altering anything. */
2773 copy_body (id, bb->count, bb->frequency, bb, return_block);
2775 /* Add local vars in this inlined callee to caller. */
2776 t_step = id->src_cfun->unexpanded_var_list;
2777 for (; t_step; t_step = TREE_CHAIN (t_step))
2779 var = TREE_VALUE (t_step);
2780 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
2781 cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
2782 cfun->unexpanded_var_list);
2784 cfun->unexpanded_var_list = tree_cons (NULL_TREE, remap_decl (var, id),
2785 cfun->unexpanded_var_list);
2789 pointer_map_destroy (id->decl_map);
2792 /* If the inlined function returns a result that we care about,
2793 clobber the CALL_EXPR with a reference to the return variable. */
2794 if (use_retvar && (TREE_CODE (bsi_stmt (stmt_bsi)) != CALL_EXPR))
2797 if (gimple_in_ssa_p (cfun))
2800 mark_symbols_for_renaming (stmt);
2802 maybe_clean_or_replace_eh_stmt (stmt, stmt);
2805 /* We're modifying a TSI owned by gimple_expand_calls_inline();
2806 tsi_delink() will leave the iterator in a sane state. */
2808 /* Handle case of inlining function that miss return statement so
2809 return value becomes undefined. */
2810 if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
2811 && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME)
2813 tree name = TREE_OPERAND (stmt, 0);
2814 tree var = SSA_NAME_VAR (TREE_OPERAND (stmt, 0));
2815 tree def = gimple_default_def (cfun, var);
2817 /* If the variable is used undefined, make this name undefined via
2821 TREE_OPERAND (stmt, 1) = def;
2824 /* Otherwise make this variable undefined. */
2827 bsi_remove (&stmt_bsi, true);
2828 set_default_def (var, name);
2829 SSA_NAME_DEF_STMT (name) = build_empty_stmt ();
2833 bsi_remove (&stmt_bsi, true);
2836 if (purge_dead_abnormal_edges)
2837 tree_purge_dead_abnormal_call_edges (return_block);
2839 /* If the value of the new expression is ignored, that's OK. We
2840 don't warn about this for CALL_EXPRs, so we shouldn't warn about
2841 the equivalent inlined version either. */
2842 TREE_USED (*tp) = 1;
2844 /* Output the inlining info for this abstract function, since it has been
2845 inlined. If we don't do this now, we can lose the information about the
2846 variables in the function when the blocks get blown away as soon as we
2847 remove the cgraph node. */
2848 (*debug_hooks->outlining_inline_function) (cg_edge->callee->decl);
2850 /* Update callgraph if needed. */
2851 cgraph_remove_node (cg_edge->callee);
2853 id->block = NULL_TREE;
2854 successfully_inlined = TRUE;
2857 input_location = saved_location;
2858 return successfully_inlined;
2861 /* Expand call statements reachable from STMT_P.
2862 We can only have CALL_EXPRs as the "toplevel" tree code or nested
2863 in a GIMPLE_MODIFY_STMT. See tree-gimple.c:get_call_expr_in(). We can
2864 unfortunately not use that function here because we need a pointer
2865 to the CALL_EXPR, not the tree itself. */
2868 gimple_expand_calls_inline (basic_block bb, copy_body_data *id)
2870 block_stmt_iterator bsi;
2872 /* Register specific tree functions. */
2873 tree_register_cfg_hooks ();
2874 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2876 tree *expr_p = bsi_stmt_ptr (bsi);
2877 tree stmt = *expr_p;
2879 if (TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT)
2880 expr_p = &GIMPLE_STMT_OPERAND (*expr_p, 1);
2881 if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR)
2882 expr_p = &TREE_OPERAND (*expr_p, 0);
2883 if (TREE_CODE (*expr_p) == CALL_EXPR)
2884 if (expand_call_inline (bb, stmt, expr_p, id))
2890 /* Walk all basic blocks created after FIRST and try to fold every statement
2891 in the STATEMENTS pointer set. */
2893 fold_marked_statements (int first, struct pointer_set_t *statements)
2895 for (;first < n_basic_blocks;first++)
2896 if (BASIC_BLOCK (first))
2898 block_stmt_iterator bsi;
2899 for (bsi = bsi_start (BASIC_BLOCK (first));
2900 !bsi_end_p (bsi); bsi_next (&bsi))
2901 if (pointer_set_contains (statements, bsi_stmt (bsi)))
2903 tree old_stmt = bsi_stmt (bsi);
2904 if (fold_stmt (bsi_stmt_ptr (bsi)))
2906 update_stmt (bsi_stmt (bsi));
2907 if (maybe_clean_or_replace_eh_stmt (old_stmt, bsi_stmt (bsi)))
2908 tree_purge_dead_eh_edges (BASIC_BLOCK (first));
2914 /* Return true if BB has at least one abnormal outgoing edge. */
2917 has_abnormal_outgoing_edge_p (basic_block bb)
2922 FOR_EACH_EDGE (e, ei, bb->succs)
2923 if (e->flags & EDGE_ABNORMAL)
2929 /* Expand calls to inline functions in the body of FN. */
2932 optimize_inline_calls (tree fn)
2937 int last = n_basic_blocks;
2938 /* There is no point in performing inlining if errors have already
2939 occurred -- and we might crash if we try to inline invalid
2941 if (errorcount || sorrycount)
2945 memset (&id, 0, sizeof (id));
2947 id.src_node = id.dst_node = cgraph_node (fn);
2949 /* Or any functions that aren't finished yet. */
2950 prev_fn = NULL_TREE;
2951 if (current_function_decl)
2953 id.dst_fn = current_function_decl;
2954 prev_fn = current_function_decl;
2957 id.copy_decl = copy_decl_maybe_to_var;
2958 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
2959 id.transform_new_cfg = false;
2960 id.transform_return_to_modify = true;
2961 id.transform_lang_insert_block = false;
2962 id.statements_to_fold = pointer_set_create ();
2964 push_gimplify_context ();
2966 /* We make no attempts to keep dominance info up-to-date. */
2967 free_dominance_info (CDI_DOMINATORS);
2968 free_dominance_info (CDI_POST_DOMINATORS);
2970 /* Reach the trees by walking over the CFG, and note the
2971 enclosing basic-blocks in the call edges. */
2972 /* We walk the blocks going forward, because inlined function bodies
2973 will split id->current_basic_block, and the new blocks will
2974 follow it; we'll trudge through them, processing their CALL_EXPRs
2977 gimple_expand_calls_inline (bb, &id);
2979 pop_gimplify_context (NULL);
2981 #ifdef ENABLE_CHECKING
2983 struct cgraph_edge *e;
2985 verify_cgraph_node (id.dst_node);
2987 /* Double check that we inlined everything we are supposed to inline. */
2988 for (e = id.dst_node->callees; e; e = e->next_callee)
2989 gcc_assert (e->inline_failed);
2993 /* Fold the statements before compacting/renumbering the basic blocks. */
2994 fold_marked_statements (last, id.statements_to_fold);
2995 pointer_set_destroy (id.statements_to_fold);
2997 /* Renumber the (code) basic_blocks consecutively. */
2999 /* Renumber the lexical scoping (non-code) blocks consecutively. */
3002 /* We are not going to maintain the cgraph edges up to date.
3003 Kill it so it won't confuse us. */
3004 cgraph_node_remove_callees (id.dst_node);
3006 fold_cond_expr_cond ();
3007 /* It would be nice to check SSA/CFG/statement consistency here, but it is
3008 not possible yet - the IPA passes might make various functions to not
3009 throw and they don't care to proactively update local EH info. This is
3010 done later in fixup_cfg pass that also execute the verification. */
3011 return (TODO_update_ssa | TODO_cleanup_cfg
3012 | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0)
3013 | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0));
3016 /* FN is a function that has a complete body, and CLONE is a function whose
3017 body is to be set to a copy of FN, mapping argument declarations according
3018 to the ARG_MAP splay_tree. */
3021 clone_body (tree clone, tree fn, void *arg_map)
3025 /* Clone the body, as if we were making an inline call. But, remap the
3026 parameters in the callee to the parameters of caller. */
3027 memset (&id, 0, sizeof (id));
3030 id.src_cfun = DECL_STRUCT_FUNCTION (fn);
3031 id.decl_map = (struct pointer_map_t *)arg_map;
3033 id.copy_decl = copy_decl_no_change;
3034 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3035 id.transform_new_cfg = true;
3036 id.transform_return_to_modify = false;
3037 id.transform_lang_insert_block = true;
3039 /* We're not inside any EH region. */
3042 /* Actually copy the body. */
3043 append_to_statement_list_force (copy_generic_body (&id), &DECL_SAVED_TREE (clone));
3046 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
3049 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
3051 enum tree_code code = TREE_CODE (*tp);
3052 enum tree_code_class cl = TREE_CODE_CLASS (code);
3054 /* We make copies of most nodes. */
3055 if (IS_EXPR_CODE_CLASS (cl)
3056 || IS_GIMPLE_STMT_CODE_CLASS (cl)
3057 || code == TREE_LIST
3059 || code == TYPE_DECL
3060 || code == OMP_CLAUSE)
3062 /* Because the chain gets clobbered when we make a copy, we save it
3064 tree chain = NULL_TREE, new;
3066 if (!GIMPLE_TUPLE_P (*tp))
3067 chain = TREE_CHAIN (*tp);
3069 /* Copy the node. */
3070 new = copy_node (*tp);
3072 /* Propagate mudflap marked-ness. */
3073 if (flag_mudflap && mf_marked_p (*tp))
3078 /* Now, restore the chain, if appropriate. That will cause
3079 walk_tree to walk into the chain as well. */
3080 if (code == PARM_DECL
3081 || code == TREE_LIST
3082 || code == OMP_CLAUSE)
3083 TREE_CHAIN (*tp) = chain;
3085 /* For now, we don't update BLOCKs when we make copies. So, we
3086 have to nullify all BIND_EXPRs. */
3087 if (TREE_CODE (*tp) == BIND_EXPR)
3088 BIND_EXPR_BLOCK (*tp) = NULL_TREE;
3090 else if (code == CONSTRUCTOR)
3092 /* CONSTRUCTOR nodes need special handling because
3093 we need to duplicate the vector of elements. */
3096 new = copy_node (*tp);
3098 /* Propagate mudflap marked-ness. */
3099 if (flag_mudflap && mf_marked_p (*tp))
3102 CONSTRUCTOR_ELTS (new) = VEC_copy (constructor_elt, gc,
3103 CONSTRUCTOR_ELTS (*tp));
3106 else if (TREE_CODE_CLASS (code) == tcc_type)
3108 else if (TREE_CODE_CLASS (code) == tcc_declaration)
3110 else if (TREE_CODE_CLASS (code) == tcc_constant)
3113 gcc_assert (code != STATEMENT_LIST);
3117 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
3118 information indicating to what new SAVE_EXPR this one should be mapped,
3119 use that one. Otherwise, create a new node and enter it in ST. FN is
3120 the function into which the copy will be placed. */
3123 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
3125 struct pointer_map_t *st = (struct pointer_map_t *) st_;
3129 /* See if we already encountered this SAVE_EXPR. */
3130 n = (tree *) pointer_map_contains (st, *tp);
3132 /* If we didn't already remap this SAVE_EXPR, do so now. */
3135 t = copy_node (*tp);
3137 /* Remember this SAVE_EXPR. */
3138 *pointer_map_insert (st, *tp) = t;
3139 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3140 *pointer_map_insert (st, t) = t;
3144 /* We've already walked into this SAVE_EXPR; don't do it again. */
3149 /* Replace this SAVE_EXPR with the copy. */
3153 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
3154 copies the declaration and enters it in the splay_tree in DATA (which is
3155 really an `copy_body_data *'). */
3158 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
3161 copy_body_data *id = (copy_body_data *) data;
3163 /* Don't walk into types. */
3167 else if (TREE_CODE (*tp) == LABEL_EXPR)
3169 tree decl = TREE_OPERAND (*tp, 0);
3171 /* Copy the decl and remember the copy. */
3172 insert_decl_map (id, decl, id->copy_decl (decl, id));
3178 /* Perform any modifications to EXPR required when it is unsaved. Does
3179 not recurse into EXPR's subtrees. */
3182 unsave_expr_1 (tree expr)
3184 switch (TREE_CODE (expr))
3187 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
3188 It's OK for this to happen if it was part of a subtree that
3189 isn't immediately expanded, such as operand 2 of another
3191 if (TREE_OPERAND (expr, 1))
3194 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
3195 TREE_OPERAND (expr, 3) = NULL_TREE;
3203 /* Called via walk_tree when an expression is unsaved. Using the
3204 splay_tree pointed to by ST (which is really a `splay_tree'),
3205 remaps all local declarations to appropriate replacements. */
3208 unsave_r (tree *tp, int *walk_subtrees, void *data)
3210 copy_body_data *id = (copy_body_data *) data;
3211 struct pointer_map_t *st = id->decl_map;
3214 /* Only a local declaration (variable or label). */
3215 if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
3216 || TREE_CODE (*tp) == LABEL_DECL)
3218 /* Lookup the declaration. */
3219 n = (tree *) pointer_map_contains (st, *tp);
3221 /* If it's there, remap it. */
3226 else if (TREE_CODE (*tp) == STATEMENT_LIST)
3227 copy_statement_list (tp);
3228 else if (TREE_CODE (*tp) == BIND_EXPR)
3229 copy_bind_expr (tp, walk_subtrees, id);
3230 else if (TREE_CODE (*tp) == SAVE_EXPR)
3231 remap_save_expr (tp, st, walk_subtrees);
3234 copy_tree_r (tp, walk_subtrees, NULL);
3236 /* Do whatever unsaving is required. */
3237 unsave_expr_1 (*tp);
3240 /* Keep iterating. */
3244 /* Copies everything in EXPR and replaces variables, labels
3245 and SAVE_EXPRs local to EXPR. */
3248 unsave_expr_now (tree expr)
3252 /* There's nothing to do for NULL_TREE. */
3257 memset (&id, 0, sizeof (id));
3258 id.src_fn = current_function_decl;
3259 id.dst_fn = current_function_decl;
3260 id.decl_map = pointer_map_create ();
3262 id.copy_decl = copy_decl_no_change;
3263 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
3264 id.transform_new_cfg = false;
3265 id.transform_return_to_modify = false;
3266 id.transform_lang_insert_block = false;
3268 /* Walk the tree once to find local labels. */
3269 walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
3271 /* Walk the tree again, copying, remapping, and unsaving. */
3272 walk_tree (&expr, unsave_r, &id, NULL);
3275 pointer_map_destroy (id.decl_map);
3280 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
3283 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
3292 debug_find_tree (tree top, tree search)
3294 return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
3298 /* Declare the variables created by the inliner. Add all the variables in
3299 VARS to BIND_EXPR. */
3302 declare_inline_vars (tree block, tree vars)
3305 for (t = vars; t; t = TREE_CHAIN (t))
3307 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
3308 gcc_assert (!TREE_STATIC (t) && !TREE_ASM_WRITTEN (t));
3309 cfun->unexpanded_var_list =
3310 tree_cons (NULL_TREE, t,
3311 cfun->unexpanded_var_list);
3315 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars);
3319 /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN,
3320 but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to
3321 VAR_DECL translation. */
3324 copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
3326 /* Don't generate debug information for the copy if we wouldn't have
3327 generated it for the copy either. */
3328 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
3329 DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
3331 /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
3332 declaration inspired this copy. */
3333 DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
3335 /* The new variable/label has no RTL, yet. */
3336 if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
3337 && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
3338 SET_DECL_RTL (copy, NULL_RTX);
3340 /* These args would always appear unused, if not for this. */
3341 TREE_USED (copy) = 1;
3343 /* Set the context for the new declaration. */
3344 if (!DECL_CONTEXT (decl))
3345 /* Globals stay global. */
3347 else if (DECL_CONTEXT (decl) != id->src_fn)
3348 /* Things that weren't in the scope of the function we're inlining
3349 from aren't in the scope we're inlining to, either. */
3351 else if (TREE_STATIC (decl))
3352 /* Function-scoped static variables should stay in the original
3356 /* Ordinary automatic local variables are now in the scope of the
3358 DECL_CONTEXT (copy) = id->dst_fn;
3364 copy_decl_to_var (tree decl, copy_body_data *id)
3368 gcc_assert (TREE_CODE (decl) == PARM_DECL
3369 || TREE_CODE (decl) == RESULT_DECL);
3371 type = TREE_TYPE (decl);
3373 copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3374 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3375 TREE_READONLY (copy) = TREE_READONLY (decl);
3376 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3377 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3378 DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3380 return copy_decl_for_dup_finish (id, decl, copy);
3383 /* Like copy_decl_to_var, but create a return slot object instead of a
3384 pointer variable for return by invisible reference. */
3387 copy_result_decl_to_var (tree decl, copy_body_data *id)
3391 gcc_assert (TREE_CODE (decl) == PARM_DECL
3392 || TREE_CODE (decl) == RESULT_DECL);
3394 type = TREE_TYPE (decl);
3395 if (DECL_BY_REFERENCE (decl))
3396 type = TREE_TYPE (type);
3398 copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
3399 TREE_READONLY (copy) = TREE_READONLY (decl);
3400 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
3401 if (!DECL_BY_REFERENCE (decl))
3403 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
3404 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (decl);
3405 DECL_NO_TBAA_P (copy) = DECL_NO_TBAA_P (decl);
3408 return copy_decl_for_dup_finish (id, decl, copy);
3413 copy_decl_no_change (tree decl, copy_body_data *id)
3417 copy = copy_node (decl);
3419 /* The COPY is not abstract; it will be generated in DST_FN. */
3420 DECL_ABSTRACT (copy) = 0;
3421 lang_hooks.dup_lang_specific_decl (copy);
3423 /* TREE_ADDRESSABLE isn't used to indicate that a label's address has
3424 been taken; it's for internal bookkeeping in expand_goto_internal. */
3425 if (TREE_CODE (copy) == LABEL_DECL)
3427 TREE_ADDRESSABLE (copy) = 0;
3428 LABEL_DECL_UID (copy) = -1;
3431 return copy_decl_for_dup_finish (id, decl, copy);
3435 copy_decl_maybe_to_var (tree decl, copy_body_data *id)
3437 if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
3438 return copy_decl_to_var (decl, id);
3440 return copy_decl_no_change (decl, id);
3443 /* Return a copy of the function's argument tree. */
3445 copy_arguments_for_versioning (tree orig_parm, copy_body_data * id)
3447 tree *arg_copy, *parg;
3449 arg_copy = &orig_parm;
3450 for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
3452 tree new = remap_decl (*parg, id);
3453 lang_hooks.dup_lang_specific_decl (new);
3454 TREE_CHAIN (new) = TREE_CHAIN (*parg);
3460 /* Return a copy of the function's static chain. */
3462 copy_static_chain (tree static_chain, copy_body_data * id)
3464 tree *chain_copy, *pvar;
3466 chain_copy = &static_chain;
3467 for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
3469 tree new = remap_decl (*pvar, id);
3470 lang_hooks.dup_lang_specific_decl (new);
3471 TREE_CHAIN (new) = TREE_CHAIN (*pvar);
3474 return static_chain;
3477 /* Return true if the function is allowed to be versioned.
3478 This is a guard for the versioning functionality. */
3480 tree_versionable_function_p (tree fndecl)
3482 if (fndecl == NULL_TREE)
3484 /* ??? There are cases where a function is
3485 uninlinable but can be versioned. */
3486 if (!tree_inlinable_function_p (fndecl))
3492 /* Create a copy of a function's tree.
3493 OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes
3494 of the original function and the new copied function
3495 respectively. In case we want to replace a DECL
3496 tree with another tree while duplicating the function's
3497 body, TREE_MAP represents the mapping between these
3498 trees. If UPDATE_CLONES is set, the call_stmt fields
3499 of edges of clones of the function will be updated. */
3501 tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map,
3504 struct cgraph_node *old_version_node;
3505 struct cgraph_node *new_version_node;
3509 struct ipa_replace_map *replace_info;
3510 basic_block old_entry_block;
3512 tree old_current_function_decl = current_function_decl;
3514 gcc_assert (TREE_CODE (old_decl) == FUNCTION_DECL
3515 && TREE_CODE (new_decl) == FUNCTION_DECL);
3516 DECL_POSSIBLY_INLINED (old_decl) = 1;
3518 old_version_node = cgraph_node (old_decl);
3519 new_version_node = cgraph_node (new_decl);
3521 DECL_ARTIFICIAL (new_decl) = 1;
3522 DECL_ABSTRACT_ORIGIN (new_decl) = DECL_ORIGIN (old_decl);
3524 /* Prepare the data structures for the tree copy. */
3525 memset (&id, 0, sizeof (id));
3527 /* Generate a new name for the new version. */
3530 DECL_NAME (new_decl) = create_tmp_var_name (NULL);
3531 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
3532 SET_DECL_RTL (new_decl, NULL_RTX);
3533 id.statements_to_fold = pointer_set_create ();
3536 id.decl_map = pointer_map_create ();
3537 id.src_fn = old_decl;
3538 id.dst_fn = new_decl;
3539 id.src_node = old_version_node;
3540 id.dst_node = new_version_node;
3541 id.src_cfun = DECL_STRUCT_FUNCTION (old_decl);
3543 id.copy_decl = copy_decl_no_change;
3544 id.transform_call_graph_edges
3545 = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE;
3546 id.transform_new_cfg = true;
3547 id.transform_return_to_modify = false;
3548 id.transform_lang_insert_block = false;
3550 current_function_decl = new_decl;
3551 old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION
3552 (DECL_STRUCT_FUNCTION (old_decl));
3553 initialize_cfun (new_decl, old_decl,
3554 old_entry_block->count,
3555 old_entry_block->frequency);
3556 push_cfun (DECL_STRUCT_FUNCTION (new_decl));
3558 /* Copy the function's static chain. */
3559 p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl;
3561 DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl =
3562 copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl,
3564 /* Copy the function's arguments. */
3565 if (DECL_ARGUMENTS (old_decl) != NULL_TREE)
3566 DECL_ARGUMENTS (new_decl) =
3567 copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id);
3569 /* If there's a tree_map, prepare for substitution. */
3571 for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++)
3573 replace_info = VARRAY_GENERIC_PTR (tree_map, i);
3574 if (replace_info->replace_p)
3575 insert_decl_map (&id, replace_info->old_tree,
3576 replace_info->new_tree);
3579 DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id);
3581 /* Renumber the lexical scoping (non-code) blocks consecutively. */
3582 number_blocks (id.dst_fn);
3584 if (DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list != NULL_TREE)
3585 /* Add local vars. */
3586 for (t_step = DECL_STRUCT_FUNCTION (old_decl)->unexpanded_var_list;
3587 t_step; t_step = TREE_CHAIN (t_step))
3589 tree var = TREE_VALUE (t_step);
3590 if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
3591 cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
3592 cfun->unexpanded_var_list);
3594 cfun->unexpanded_var_list =
3595 tree_cons (NULL_TREE, remap_decl (var, &id),
3596 cfun->unexpanded_var_list);
3599 /* Copy the Function's body. */
3600 copy_body (&id, old_entry_block->count, old_entry_block->frequency, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR);
3602 if (DECL_RESULT (old_decl) != NULL_TREE)
3604 tree *res_decl = &DECL_RESULT (old_decl);
3605 DECL_RESULT (new_decl) = remap_decl (*res_decl, &id);
3606 lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl));
3609 /* Renumber the lexical scoping (non-code) blocks consecutively. */
3610 number_blocks (new_decl);
3613 pointer_map_destroy (id.decl_map);
3616 fold_marked_statements (0, id.statements_to_fold);
3617 pointer_set_destroy (id.statements_to_fold);
3618 fold_cond_expr_cond ();
3620 if (gimple_in_ssa_p (cfun))
3622 free_dominance_info (CDI_DOMINATORS);
3623 free_dominance_info (CDI_POST_DOMINATORS);
3625 delete_unreachable_blocks ();
3626 update_ssa (TODO_update_ssa);
3629 fold_cond_expr_cond ();
3630 if (need_ssa_update_p ())
3631 update_ssa (TODO_update_ssa);
3634 free_dominance_info (CDI_DOMINATORS);
3635 free_dominance_info (CDI_POST_DOMINATORS);
3637 current_function_decl = old_current_function_decl;
3638 gcc_assert (!current_function_decl
3639 || DECL_STRUCT_FUNCTION (current_function_decl) == cfun);
3643 /* Duplicate a type, fields and all. */
3646 build_duplicate_type (tree type)
3648 struct copy_body_data id;
3650 memset (&id, 0, sizeof (id));
3651 id.src_fn = current_function_decl;
3652 id.dst_fn = current_function_decl;
3654 id.decl_map = pointer_map_create ();
3655 id.copy_decl = copy_decl_no_change;
3657 type = remap_type_1 (type, &id);
3659 pointer_map_destroy (id.decl_map);