2 Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
28 #include "tree-inline.h"
34 #include "insn-config.h"
37 #include "splay-tree.h"
38 #include "langhooks.h"
39 #include "basic-block.h"
40 #include "tree-iterator.h"
43 #include "tree-mudflap.h"
44 #include "tree-flow.h"
47 #include "tree-flow.h"
48 #include "diagnostic.h"
51 #include "pointer-set.h"
52 #include "integrate.h"
54 /* I'm not real happy about this, but we need to handle gimple and
56 #include "tree-gimple.h"
58 /* Inlining, Saving, Cloning
60 Inlining: a function body is duplicated, but the PARM_DECLs are
61 remapped into VAR_DECLs, and non-void RETURN_EXPRs become
62 MODIFY_EXPRs that store to a dedicated returned-value variable.
63 The duplicated eh_region info of the copy will later be appended
64 to the info for the caller; the eh_region info in copied throwing
65 statements and RESX_EXPRs is adjusted accordingly.
67 Saving: make a semantically-identical copy of the function body.
68 Necessary when we want to generate code for the body (a destructive
69 operation), but we expect to need this body in the future (e.g. for
70 inlining into another function).
72 Cloning: (only in C++) We have one body for a con/de/structor, and
73 multiple function decls, each with a unique parameter list.
74 Duplicate the body, using the given splay tree; some parameters
75 will become constants (like 0 or 1).
77 All of these will simultaneously lookup any callgraph edges. If
78 we're going to inline the duplicated function body, and the given
79 function has some cloned callgraph nodes (one for each place this
80 function will be inlined) those callgraph edges will be duplicated.
81 If we're saving or cloning the body, those callgraph edges will be
82 updated to point into the new body. (Note that the original
83 callgraph node and edge list will not be altered.)
85 See the CALL_EXPR handling case in copy_body_r (). */
87 /* 0 if we should not perform inlining.
88 1 if we should expand functions calls inline at the tree level.
89 2 if we should consider *all* functions to be inline
92 int flag_inline_trees
= 0;
96 o In order to make inlining-on-trees work, we pessimized
97 function-local static constants. In particular, they are now
98 always output, even when not addressed. Fix this by treating
99 function-local static constants just like global static
100 constants; the back-end already knows not to output them if they
103 o Provide heuristics to clamp inlining of recursive template
106 /* Data required for function inlining. */
108 typedef struct inline_data
110 /* FUNCTION_DECL for function being inlined. */
112 /* FUNCTION_DECL for function being inlined into. */
114 /* struct function for function being inlined. Usually this is the same
115 as DECL_STRUCT_FUNCTION (callee), but can be different if saved_cfg
116 and saved_eh are in use. */
117 struct function
*callee_cfun
;
118 /* The VAR_DECL for the return value. */
120 /* The map from local declarations in the inlined function to
121 equivalents in the function into which it is being inlined. */
123 /* We use the same mechanism to build clones that we do to perform
124 inlining. However, there are a few places where we need to
125 distinguish between those two situations. This flag is true if
126 we are cloning, rather than inlining. */
128 /* Similarly for saving function body. */
130 /* Callgraph node of function we are inlining into. */
131 struct cgraph_node
*node
;
132 /* Callgraph node of currently inlined function. */
133 struct cgraph_node
*current_node
;
136 /* Exception region the inlined call lie in. */
138 /* Take region number in the function being copied, add this value and
139 get eh region number of the duplicate in the function we inline into. */
140 int eh_region_offset
;
145 static tree
declare_return_variable (inline_data
*, tree
, tree
, tree
*);
146 static tree
copy_body_r (tree
*, int *, void *);
147 static tree
copy_generic_body (inline_data
*);
148 static bool inlinable_function_p (tree
);
149 static tree
remap_decl (tree
, inline_data
*);
150 static tree
remap_type (tree
, inline_data
*);
151 static void remap_block (tree
*, inline_data
*);
152 static tree
remap_decl (tree
, inline_data
*);
153 static tree
remap_decls (tree
, inline_data
*);
154 static void copy_bind_expr (tree
*, int *, inline_data
*);
155 static tree
mark_local_for_remap_r (tree
*, int *, void *);
156 static void unsave_expr_1 (tree
);
157 static tree
unsave_r (tree
*, int *, void *);
158 static void declare_inline_vars (tree
, tree
);
159 static void remap_save_expr (tree
*, void *, int *);
161 static inline bool inlining_p (inline_data
*id
);
162 static void add_lexical_block (tree current_block
, tree new_block
);
164 /* Insert a tree->tree mapping for ID. Despite the name suggests
165 that the trees should be variables, it is used for more than that. */
168 insert_decl_map (inline_data
*id
, tree key
, tree value
)
170 splay_tree_insert (id
->decl_map
, (splay_tree_key
) key
,
171 (splay_tree_value
) value
);
173 /* Always insert an identity map as well. If we see this same new
174 node again, we won't want to duplicate it a second time. */
176 splay_tree_insert (id
->decl_map
, (splay_tree_key
) value
,
177 (splay_tree_value
) value
);
180 /* Remap DECL during the copying of the BLOCK tree for the function. */
183 remap_decl (tree decl
, inline_data
*id
)
188 /* We only remap local variables in the current function. */
191 /* See if we have remapped this declaration. */
193 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
195 /* If we didn't already have an equivalent for this declaration,
199 /* Make a copy of the variable or label. */
201 t
= copy_decl_for_inlining (decl
, fn
, id
->caller
);
203 /* Remember it, so that if we encounter this local entity again
204 we can reuse this copy. Do this early because remap_type may
205 need this decl for TYPE_STUB_DECL. */
206 insert_decl_map (id
, decl
, t
);
208 /* Remap types, if necessary. */
209 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
210 if (TREE_CODE (t
) == TYPE_DECL
)
211 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
213 /* Remap sizes as necessary. */
214 walk_tree (&DECL_SIZE (t
), copy_body_r
, id
, NULL
);
215 walk_tree (&DECL_SIZE_UNIT (t
), copy_body_r
, id
, NULL
);
217 /* If fields, do likewise for offset and qualifier. */
218 if (TREE_CODE (t
) == FIELD_DECL
)
220 walk_tree (&DECL_FIELD_OFFSET (t
), copy_body_r
, id
, NULL
);
221 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
222 walk_tree (&DECL_QUALIFIER (t
), copy_body_r
, id
, NULL
);
226 /* FIXME handle anon aggrs. */
227 if (! DECL_NAME (t
) && TREE_TYPE (t
)
228 && lang_hooks
.tree_inlining
.anon_aggr_type_p (TREE_TYPE (t
)))
230 /* For a VAR_DECL of anonymous type, we must also copy the
231 member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS. */
235 for (src
= DECL_ANON_UNION_ELEMS (t
); src
;
236 src
= TREE_CHAIN (src
))
238 tree member
= remap_decl (TREE_VALUE (src
), id
);
240 gcc_assert (!TREE_PURPOSE (src
));
241 members
= tree_cons (NULL
, member
, members
);
243 DECL_ANON_UNION_ELEMS (t
) = nreverse (members
);
247 /* Remember it, so that if we encounter this local entity
248 again we can reuse this copy. */
249 insert_decl_map (id
, decl
, t
);
253 return unshare_expr ((tree
) n
->value
);
257 remap_type (tree type
, inline_data
*id
)
259 splay_tree_node node
;
265 /* See if we have remapped this type. */
266 node
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) type
);
268 return (tree
) node
->value
;
270 /* The type only needs remapping if it's variably modified. */
271 if (! variably_modified_type_p (type
, id
->callee
))
273 insert_decl_map (id
, type
, type
);
277 /* We do need a copy. build and register it now. If this is a pointer or
278 reference type, remap the designated type and make a new pointer or
280 if (TREE_CODE (type
) == POINTER_TYPE
)
282 new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
284 TYPE_REF_CAN_ALIAS_ALL (type
));
285 insert_decl_map (id
, type
, new);
288 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
290 new = build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
292 TYPE_REF_CAN_ALIAS_ALL (type
));
293 insert_decl_map (id
, type
, new);
297 new = copy_node (type
);
299 insert_decl_map (id
, type
, new);
301 /* This is a new type, not a copy of an old type. Need to reassociate
302 variants. We can handle everything except the main variant lazily. */
303 t
= TYPE_MAIN_VARIANT (type
);
306 t
= remap_type (t
, id
);
307 TYPE_MAIN_VARIANT (new) = t
;
308 TYPE_NEXT_VARIANT (new) = TYPE_MAIN_VARIANT (t
);
309 TYPE_NEXT_VARIANT (t
) = new;
313 TYPE_MAIN_VARIANT (new) = new;
314 TYPE_NEXT_VARIANT (new) = NULL
;
317 if (TYPE_STUB_DECL (type
))
318 TYPE_STUB_DECL (new) = remap_decl (TYPE_STUB_DECL (type
), id
);
320 /* Lazily create pointer and reference types. */
321 TYPE_POINTER_TO (new) = NULL
;
322 TYPE_REFERENCE_TO (new) = NULL
;
324 switch (TREE_CODE (new))
331 t
= TYPE_MIN_VALUE (new);
332 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
333 walk_tree (&TYPE_MIN_VALUE (new), copy_body_r
, id
, NULL
);
335 t
= TYPE_MAX_VALUE (new);
336 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
337 walk_tree (&TYPE_MAX_VALUE (new), copy_body_r
, id
, NULL
);
341 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
342 walk_tree (&TYPE_ARG_TYPES (new), copy_body_r
, id
, NULL
);
346 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
347 TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id
);
352 case QUAL_UNION_TYPE
:
353 walk_tree (&TYPE_FIELDS (new), copy_body_r
, id
, NULL
);
358 /* Shouldn't have been thought variable sized. */
362 walk_tree (&TYPE_SIZE (new), copy_body_r
, id
, NULL
);
363 walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r
, id
, NULL
);
369 remap_decls (tree decls
, inline_data
*id
)
372 tree new_decls
= NULL_TREE
;
374 /* Remap its variables. */
375 for (old_var
= decls
; old_var
; old_var
= TREE_CHAIN (old_var
))
379 /* We can not chain the local static declarations into the unexpanded_var_list
380 as we can't duplicate them or break one decl rule. Go ahead and link
381 them into unexpanded_var_list. */
382 if (!lang_hooks
.tree_inlining
.auto_var_in_fn_p (old_var
, id
->callee
)
383 && !DECL_EXTERNAL (old_var
))
385 cfun
->unexpanded_var_list
= tree_cons (NULL_TREE
, old_var
,
386 cfun
->unexpanded_var_list
);
390 /* Remap the variable. */
391 new_var
= remap_decl (old_var
, id
);
393 /* If we didn't remap this variable, so we can't mess with its
394 TREE_CHAIN. If we remapped this variable to the return slot, it's
395 already declared somewhere else, so don't declare it here. */
396 if (!new_var
|| new_var
== id
->retvar
)
400 gcc_assert (DECL_P (new_var
));
401 TREE_CHAIN (new_var
) = new_decls
;
406 return nreverse (new_decls
);
409 /* Copy the BLOCK to contain remapped versions of the variables
410 therein. And hook the new block into the block-tree. */
413 remap_block (tree
*block
, inline_data
*id
)
419 /* Make the new block. */
421 new_block
= make_node (BLOCK
);
422 TREE_USED (new_block
) = TREE_USED (old_block
);
423 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
426 /* Remap its variables. */
427 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
), id
);
431 /* We're building a clone; DECL_INITIAL is still
432 error_mark_node, and current_binding_level is the parm
434 lang_hooks
.decls
.insert_block (new_block
);
435 /* Remember the remapped block. */
436 insert_decl_map (id
, old_block
, new_block
);
439 /* Copy the whole block tree and root it in id->block. */
441 remap_blocks (tree block
, inline_data
*id
)
449 remap_block (&new, id
);
450 gcc_assert (new != block
);
451 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
452 add_lexical_block (new, remap_blocks (t
, id
));
457 copy_statement_list (tree
*tp
)
459 tree_stmt_iterator oi
, ni
;
462 new = alloc_stmt_list ();
463 ni
= tsi_start (new);
464 oi
= tsi_start (*tp
);
467 for (; !tsi_end_p (oi
); tsi_next (&oi
))
468 tsi_link_after (&ni
, tsi_stmt (oi
), TSI_NEW_STMT
);
472 copy_bind_expr (tree
*tp
, int *walk_subtrees
, inline_data
*id
)
474 tree block
= BIND_EXPR_BLOCK (*tp
);
475 /* Copy (and replace) the statement. */
476 copy_tree_r (tp
, walk_subtrees
, NULL
);
479 remap_block (&block
, id
);
480 BIND_EXPR_BLOCK (*tp
) = block
;
483 if (BIND_EXPR_VARS (*tp
))
484 /* This will remap a lot of the same decls again, but this should be
486 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), id
);
489 /* Called from copy_body_id via walk_tree. DATA is really an
493 copy_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
495 inline_data
*id
= (inline_data
*) data
;
496 tree fn
= id
->callee
;
499 /* Begin by recognizing trees that we'll completely rewrite for the
500 inlining context. Our output for these trees is completely
501 different from out input (e.g. RETURN_EXPR is deleted, and morphs
502 into an edge). Further down, we'll handle trees that get
503 duplicated and/or tweaked. */
505 /* If this is a RETURN_STMT, change it into an EXPR_STMT and a
506 GOTO_STMT with the RET_LABEL as its target. */
507 if (TREE_CODE (*tp
) == RETURN_EXPR
&& inlining_p (id
))
509 tree assignment
= TREE_OPERAND (*tp
, 0);
511 /* If we're returning something, just turn that into an
512 assignment into the equivalent of the original RESULT_DECL.
513 If the "assignment" is just the result decl, the result
514 decl has already been set (e.g. a recent "foo (&result_decl,
515 ...)"); just toss the entire RETURN_EXPR. */
516 if (assignment
&& TREE_CODE (assignment
) == MODIFY_EXPR
)
518 /* Replace the RETURN_EXPR with (a copy of) the
519 MODIFY_EXPR hanging underneath. */
520 *tp
= copy_node (assignment
);
522 else /* Else the RETURN_EXPR returns no value. */
529 /* Local variables and labels need to be replaced by equivalent
530 variables. We don't want to copy static variables; there's only
531 one of those, no matter how many times we inline the containing
532 function. Similarly for globals from an outer function. */
533 else if (lang_hooks
.tree_inlining
.auto_var_in_fn_p (*tp
, fn
))
537 /* Remap the declaration. */
538 new_decl
= remap_decl (*tp
, id
);
539 gcc_assert (new_decl
);
540 /* Replace this variable with the copy. */
541 STRIP_TYPE_NOPS (new_decl
);
545 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
546 copy_statement_list (tp
);
547 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
548 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
549 else if (TREE_CODE (*tp
) == LABEL_DECL
550 && (! DECL_CONTEXT (*tp
)
551 || decl_function_context (*tp
) == id
->callee
))
552 /* These may need to be remapped for EH handling. */
553 *tp
= remap_decl (*tp
, id
);
554 else if (TREE_CODE (*tp
) == BIND_EXPR
)
555 copy_bind_expr (tp
, walk_subtrees
, id
);
556 /* Types may need remapping as well. */
557 else if (TYPE_P (*tp
))
558 *tp
= remap_type (*tp
, id
);
560 /* If this is a constant, we have to copy the node iff the type will be
561 remapped. copy_tree_r will not copy a constant. */
562 else if (CONSTANT_CLASS_P (*tp
))
564 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
566 if (new_type
== TREE_TYPE (*tp
))
569 else if (TREE_CODE (*tp
) == INTEGER_CST
)
570 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
571 TREE_INT_CST_HIGH (*tp
));
574 *tp
= copy_node (*tp
);
575 TREE_TYPE (*tp
) = new_type
;
579 /* Otherwise, just copy the node. Note that copy_tree_r already
580 knows not to copy VAR_DECLs, etc., so this is safe. */
583 /* Here we handle trees that are not completely rewritten.
584 First we detect some inlining-induced bogosities for
586 if (TREE_CODE (*tp
) == MODIFY_EXPR
587 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
588 && (lang_hooks
.tree_inlining
.auto_var_in_fn_p
589 (TREE_OPERAND (*tp
, 0), fn
)))
591 /* Some assignments VAR = VAR; don't generate any rtl code
592 and thus don't count as variable modification. Avoid
593 keeping bogosities like 0 = 0. */
594 tree decl
= TREE_OPERAND (*tp
, 0), value
;
597 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
600 value
= (tree
) n
->value
;
601 STRIP_TYPE_NOPS (value
);
602 if (TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
604 *tp
= build_empty_stmt ();
605 return copy_body_r (tp
, walk_subtrees
, data
);
609 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
611 /* Get rid of *& from inline substitutions that can happen when a
612 pointer argument is an ADDR_EXPR. */
613 tree decl
= TREE_OPERAND (*tp
, 0);
616 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
619 /* If we happen to get an ADDR_EXPR in n->value, strip
620 it manually here as we'll eventually get ADDR_EXPRs
621 which lie about their types pointed to. In this case
622 build_fold_indirect_ref wouldn't strip the INDIRECT_REF,
623 but we absolutely rely on that. As fold_indirect_ref
624 does other useful transformations, try that first, though. */
625 tree type
= TREE_TYPE (TREE_TYPE ((tree
)n
->value
));
626 *tp
= fold_indirect_ref_1 (type
, (tree
)n
->value
);
629 if (TREE_CODE ((tree
)n
->value
) == ADDR_EXPR
)
630 *tp
= TREE_OPERAND ((tree
)n
->value
, 0);
632 *tp
= build1 (INDIRECT_REF
, type
, (tree
)n
->value
);
639 /* Here is the "usual case". Copy this tree node, and then
640 tweak some special cases. */
641 copy_tree_r (tp
, walk_subtrees
, NULL
);
643 /* If EXPR has block defined, map it to newly constructed block.
644 When inlining we want EXPRs without block appear in the block
646 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (*tp
))))
648 new_block
= id
->block
;
649 if (TREE_BLOCK (*tp
))
652 n
= splay_tree_lookup (id
->decl_map
,
653 (splay_tree_key
) TREE_BLOCK (*tp
));
655 new_block
= (tree
) n
->value
;
657 TREE_BLOCK (*tp
) = new_block
;
660 if (TREE_CODE (*tp
) == RESX_EXPR
&& id
->eh_region_offset
)
661 TREE_OPERAND (*tp
, 0) =
664 id
->eh_region_offset
+ TREE_INT_CST_LOW (TREE_OPERAND (*tp
, 0)));
666 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
668 /* The copied TARGET_EXPR has never been expanded, even if the
669 original node was expanded already. */
670 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
672 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
673 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
676 /* Variable substitution need not be simple. In particular, the
677 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
678 and friends are up-to-date. */
679 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
681 walk_tree (&TREE_OPERAND (*tp
, 0), copy_body_r
, id
, NULL
);
682 recompute_tree_invarant_for_addr_expr (*tp
);
687 /* Keep iterating. */
691 /* Copy basic block, scale profile accordingly. Edges will be taken care of
695 copy_bb (inline_data
*id
, basic_block bb
, int frequency_scale
, int count_scale
)
697 block_stmt_iterator bsi
, copy_bsi
;
698 basic_block copy_basic_block
;
700 /* create_basic_block() will append every new block to
701 basic_block_info automatically. */
702 copy_basic_block
= create_basic_block (NULL
, (void *) 0, bb
->prev_bb
->aux
);
703 copy_basic_block
->count
= bb
->count
* count_scale
/ REG_BR_PROB_BASE
;
704 copy_basic_block
->frequency
= (bb
->frequency
705 * frequency_scale
/ REG_BR_PROB_BASE
);
706 copy_bsi
= bsi_start (copy_basic_block
);
708 for (bsi
= bsi_start (bb
);
709 !bsi_end_p (bsi
); bsi_next (&bsi
))
711 tree stmt
= bsi_stmt (bsi
);
712 tree orig_stmt
= stmt
;
714 walk_tree (&stmt
, copy_body_r
, id
, NULL
);
716 /* RETURN_EXPR might be removed,
717 this is signalled by making stmt pointer NULL. */
721 bsi_insert_after (©_bsi
, stmt
, BSI_NEW_STMT
);
722 call
= get_call_expr_in (stmt
);
723 /* We're duplicating a CALL_EXPR. Find any corresponding
724 callgraph edges and update or duplicate them. */
725 if (call
&& (decl
= get_callee_fndecl (call
)))
729 struct cgraph_node
*node
;
730 struct cgraph_edge
*edge
;
732 /* We're saving a copy of the body, so we'll update the
733 callgraph nodes in place. Note that we avoid
734 altering the original callgraph node; we begin with
736 for (node
= id
->node
->next_clone
;
738 node
= node
->next_clone
)
740 edge
= cgraph_edge (node
, orig_stmt
);
742 edge
->call_stmt
= stmt
;
747 struct cgraph_edge
*edge
;
749 /* We're cloning or inlining this body; duplicate the
750 associate callgraph nodes. */
751 edge
= cgraph_edge (id
->current_node
, orig_stmt
);
753 cgraph_clone_edge (edge
, id
->node
, stmt
,
754 REG_BR_PROB_BASE
, 1);
757 /* If you think we can abort here, you are wrong.
758 There is no region 0 in tree land. */
759 gcc_assert (lookup_stmt_eh_region_fn (id
->callee_cfun
, orig_stmt
)
762 if (tree_could_throw_p (stmt
))
764 int region
= lookup_stmt_eh_region_fn (id
->callee_cfun
, orig_stmt
);
765 /* Add an entry for the copied tree in the EH hashtable.
766 When saving or cloning or versioning, use the hashtable in
767 cfun, and just copy the EH number. When inlining, use the
768 hashtable in the caller, and adjust the region number. */
770 add_stmt_to_eh_region (stmt
, region
+ id
->eh_region_offset
);
772 /* If this tree doesn't have a region associated with it,
773 and there is a "current region,"
774 then associate this tree with the current region
775 and add edges associated with this region. */
776 if ((lookup_stmt_eh_region_fn (id
->callee_cfun
,
778 && id
->eh_region
> 0)
779 && tree_could_throw_p (stmt
))
780 add_stmt_to_eh_region (stmt
, id
->eh_region
);
784 return copy_basic_block
;
787 /* Copy edges from BB into its copy constructed earlier, scale profile
788 accordingly. Edges will be taken care of later. Assume aux
789 pointers to point to the copies of each BB. */
791 copy_edges_for_bb (basic_block bb
, int count_scale
)
793 basic_block new_bb
= bb
->aux
;
796 block_stmt_iterator bsi
;
799 /* Use the indices from the original blocks to create edges for the
801 FOR_EACH_EDGE (old_edge
, ei
, bb
->succs
)
802 if (!(old_edge
->flags
& EDGE_EH
))
806 flags
= old_edge
->flags
;
808 /* Return edges do get a FALLTHRU flag when the get inlined. */
809 if (old_edge
->dest
->index
== EXIT_BLOCK
&& !old_edge
->flags
810 && old_edge
->dest
->aux
!= EXIT_BLOCK_PTR
)
811 flags
|= EDGE_FALLTHRU
;
812 new = make_edge (new_bb
, old_edge
->dest
->aux
, flags
);
813 new->count
= old_edge
->count
* count_scale
/ REG_BR_PROB_BASE
;
814 new->probability
= old_edge
->probability
;
817 if (bb
->index
== ENTRY_BLOCK
|| bb
->index
== EXIT_BLOCK
)
820 for (bsi
= bsi_start (new_bb
); !bsi_end_p (bsi
);)
824 copy_stmt
= bsi_stmt (bsi
);
825 update_stmt (copy_stmt
);
826 /* Do this before the possible split_block. */
829 /* If this tree could throw an exception, there are two
830 cases where we need to add abnormal edge(s): the
831 tree wasn't in a region and there is a "current
832 region" in the caller; or the original tree had
833 EH edges. In both cases split the block after the tree,
834 and add abnormal edge(s) as needed; we need both
835 those from the callee and the caller.
836 We check whether the copy can throw, because the const
837 propagation can change an INDIRECT_REF which throws
838 into a COMPONENT_REF which doesn't. If the copy
839 can throw, the original could also throw. */
841 if (tree_can_throw_internal (copy_stmt
))
843 if (!bsi_end_p (bsi
))
844 /* Note that bb's predecessor edges aren't necessarily
845 right at this point; split_block doesn't care. */
847 edge e
= split_block (new_bb
, copy_stmt
);
849 bsi
= bsi_start (new_bb
);
852 make_eh_edges (copy_stmt
);
857 /* Wrapper for remap_decl so it can be used as a callback. */
859 remap_decl_1 (tree decl
, void *data
)
861 return remap_decl (decl
, data
);
864 /* Make a copy of the body of FN so that it can be inserted inline in
865 another function. Walks FN via CFG, returns new fndecl. */
868 copy_cfg_body (inline_data
* id
, gcov_type count
, int frequency
,
869 basic_block entry_block_map
, basic_block exit_block_map
)
871 tree callee_fndecl
= id
->callee
;
872 /* Original cfun for the callee, doesn't change. */
873 struct function
*callee_cfun
= DECL_STRUCT_FUNCTION (callee_fndecl
);
874 /* Copy, built by this function. */
875 struct function
*new_cfun
;
876 /* Place to copy from; when a copy of the function was saved off earlier,
877 use that instead of the main copy. */
878 struct function
*cfun_to_copy
=
879 (struct function
*) ggc_alloc_cleared (sizeof (struct function
));
881 tree new_fndecl
= NULL
;
882 bool saving_or_cloning
;
883 int count_scale
, frequency_scale
;
885 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->count
)
886 count_scale
= (REG_BR_PROB_BASE
* count
887 / ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->count
);
891 if (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->frequency
)
892 frequency_scale
= (REG_BR_PROB_BASE
* frequency
894 ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->frequency
);
896 frequency_scale
= count_scale
;
898 /* Register specific tree functions. */
899 tree_register_cfg_hooks ();
901 /* Must have a CFG here at this point. */
902 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION
903 (DECL_STRUCT_FUNCTION (callee_fndecl
)));
905 *cfun_to_copy
= *DECL_STRUCT_FUNCTION (callee_fndecl
);
907 /* If there is a saved_cfg+saved_args lurking in the
908 struct function, a copy of the callee body was saved there, and
909 the 'struct cgraph edge' nodes have been fudged to point into the
910 saved body. Accordingly, we want to copy that saved body so the
911 callgraph edges will be recognized and cloned properly. */
912 if (cfun_to_copy
->saved_cfg
)
914 cfun_to_copy
->cfg
= cfun_to_copy
->saved_cfg
;
915 cfun_to_copy
->eh
= cfun_to_copy
->saved_eh
;
917 id
->callee_cfun
= cfun_to_copy
;
919 /* If saving or cloning a function body, create new basic_block_info
920 and label_to_block_maps. Otherwise, we're duplicating a function
921 body for inlining; insert our new blocks and labels into the
923 saving_or_cloning
= (id
->saving_p
|| id
->cloning_p
);
924 if (saving_or_cloning
)
927 (struct function
*) ggc_alloc_cleared (sizeof (struct function
));
928 *new_cfun
= *DECL_STRUCT_FUNCTION (callee_fndecl
);
929 new_cfun
->cfg
= NULL
;
930 new_cfun
->decl
= new_fndecl
= copy_node (callee_fndecl
);
931 new_cfun
->ib_boundaries_block
= (varray_type
) 0;
932 DECL_STRUCT_FUNCTION (new_fndecl
) = new_cfun
;
933 push_cfun (new_cfun
);
934 init_empty_tree_cfg ();
936 ENTRY_BLOCK_PTR
->count
=
937 (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->count
* count_scale
/
939 ENTRY_BLOCK_PTR
->frequency
=
940 (ENTRY_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->frequency
*
941 frequency_scale
/ REG_BR_PROB_BASE
);
942 EXIT_BLOCK_PTR
->count
=
943 (EXIT_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->count
* count_scale
/
945 EXIT_BLOCK_PTR
->frequency
=
946 (EXIT_BLOCK_PTR_FOR_FUNCTION (callee_cfun
)->frequency
*
947 frequency_scale
/ REG_BR_PROB_BASE
);
949 entry_block_map
= ENTRY_BLOCK_PTR
;
950 exit_block_map
= EXIT_BLOCK_PTR
;
953 ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= entry_block_map
;
954 EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy
)->aux
= exit_block_map
;
957 /* Duplicate any exception-handling regions. */
960 if (saving_or_cloning
)
961 init_eh_for_function ();
962 id
->eh_region_offset
= duplicate_eh_regions (cfun_to_copy
,
965 gcc_assert (inlining_p (id
) || !id
->eh_region_offset
);
967 /* Use aux pointers to map the original blocks to copy. */
968 FOR_EACH_BB_FN (bb
, cfun_to_copy
)
969 bb
->aux
= copy_bb (id
, bb
, frequency_scale
, count_scale
);
970 /* Now that we've duplicated the blocks, duplicate their edges. */
971 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
972 copy_edges_for_bb (bb
, count_scale
);
973 FOR_ALL_BB_FN (bb
, cfun_to_copy
)
976 if (saving_or_cloning
)
982 /* Make a copy of the body of FN so that it can be inserted inline in
986 copy_generic_body (inline_data
*id
)
989 tree fndecl
= id
->callee
;
991 body
= DECL_SAVED_TREE (fndecl
);
992 walk_tree (&body
, copy_body_r
, id
, NULL
);
998 copy_body (inline_data
*id
, gcov_type count
, int frequency
,
999 basic_block entry_block_map
, basic_block exit_block_map
)
1001 tree fndecl
= id
->callee
;
1004 /* If this body has a CFG, walk CFG and copy. */
1005 gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl
)));
1006 body
= copy_cfg_body (id
, count
, frequency
, entry_block_map
, exit_block_map
);
1011 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
1012 defined in function FN, or of a data member thereof. */
1015 self_inlining_addr_expr (tree value
, tree fn
)
1019 if (TREE_CODE (value
) != ADDR_EXPR
)
1022 var
= get_base_address (TREE_OPERAND (value
, 0));
1024 return var
&& lang_hooks
.tree_inlining
.auto_var_in_fn_p (var
, fn
);
1028 setup_one_parameter (inline_data
*id
, tree p
, tree value
, tree fn
,
1029 basic_block bb
, tree
*vars
)
1035 /* If the parameter is never assigned to, we may not need to
1036 create a new variable here at all. Instead, we may be able
1037 to just use the argument value. */
1038 if (TREE_READONLY (p
)
1039 && !TREE_ADDRESSABLE (p
)
1040 && value
&& !TREE_SIDE_EFFECTS (value
))
1042 /* We may produce non-gimple trees by adding NOPs or introduce
1043 invalid sharing when operand is not really constant.
1044 It is not big deal to prohibit constant propagation here as
1045 we will constant propagate in DOM1 pass anyway. */
1046 if (is_gimple_min_invariant (value
)
1047 && lang_hooks
.types_compatible_p (TREE_TYPE (value
), TREE_TYPE (p
))
1048 /* We have to be very careful about ADDR_EXPR. Make sure
1049 the base variable isn't a local variable of the inlined
1050 function, e.g., when doing recursive inlining, direct or
1051 mutually-recursive or whatever, which is why we don't
1052 just test whether fn == current_function_decl. */
1053 && ! self_inlining_addr_expr (value
, fn
))
1055 insert_decl_map (id
, p
, value
);
1060 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
1061 here since the type of this decl must be visible to the calling
1063 var
= copy_decl_for_inlining (p
, fn
, id
->caller
);
1065 /* See if the frontend wants to pass this by invisible reference. If
1066 so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
1067 replace uses of the PARM_DECL with dereferences. */
1068 if (TREE_TYPE (var
) != TREE_TYPE (p
)
1069 && POINTER_TYPE_P (TREE_TYPE (var
))
1070 && TREE_TYPE (TREE_TYPE (var
)) == TREE_TYPE (p
))
1072 insert_decl_map (id
, var
, var
);
1073 var_sub
= build_fold_indirect_ref (var
);
1078 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
1079 that way, when the PARM_DECL is encountered, it will be
1080 automatically replaced by the VAR_DECL. */
1081 insert_decl_map (id
, p
, var_sub
);
1083 /* Declare this new variable. */
1084 TREE_CHAIN (var
) = *vars
;
1087 /* Make gimplifier happy about this variable. */
1088 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
1090 /* Even if P was TREE_READONLY, the new VAR should not be.
1091 In the original code, we would have constructed a
1092 temporary, and then the function body would have never
1093 changed the value of P. However, now, we will be
1094 constructing VAR directly. The constructor body may
1095 change its value multiple times as it is being
1096 constructed. Therefore, it must not be TREE_READONLY;
1097 the back-end assumes that TREE_READONLY variable is
1098 assigned to only once. */
1099 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
1100 TREE_READONLY (var
) = 0;
1102 /* Initialize this VAR_DECL from the equivalent argument. Convert
1103 the argument to the proper type in case it was promoted. */
1106 tree rhs
= fold_convert (TREE_TYPE (var
), value
);
1107 block_stmt_iterator bsi
= bsi_last (bb
);
1109 if (rhs
== error_mark_node
)
1112 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
1113 keep our trees in gimple form. */
1114 init_stmt
= build (MODIFY_EXPR
, TREE_TYPE (var
), var
, rhs
);
1116 /* If we did not create a gimple value and we did not create a gimple
1117 cast of a gimple value, then we will need to gimplify INIT_STMTS
1118 at the end. Note that is_gimple_cast only checks the outer
1119 tree code, not its operand. Thus the explicit check that its
1120 operand is a gimple value. */
1121 if (!is_gimple_val (rhs
)
1122 && (!is_gimple_cast (rhs
)
1123 || !is_gimple_val (TREE_OPERAND (rhs
, 0))))
1124 gimplify_stmt (&init_stmt
);
1125 bsi_insert_after (&bsi
, init_stmt
, BSI_NEW_STMT
);
1129 /* Generate code to initialize the parameters of the function at the
1130 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
1133 initialize_inlined_parameters (inline_data
*id
, tree args
, tree static_chain
,
1134 tree fn
, basic_block bb
)
1139 tree vars
= NULL_TREE
;
1142 /* Figure out what the parameters are. */
1143 parms
= DECL_ARGUMENTS (fn
);
1144 if (fn
== current_function_decl
)
1145 parms
= cfun
->saved_args
;
1147 /* Loop through the parameter declarations, replacing each with an
1148 equivalent VAR_DECL, appropriately initialized. */
1149 for (p
= parms
, a
= args
; p
;
1150 a
= a
? TREE_CHAIN (a
) : a
, p
= TREE_CHAIN (p
))
1156 /* Find the initializer. */
1157 value
= lang_hooks
.tree_inlining
.convert_parm_for_inlining
1158 (p
, a
? TREE_VALUE (a
) : NULL_TREE
, fn
, argnum
);
1160 setup_one_parameter (id
, p
, value
, fn
, bb
, &vars
);
1163 /* Initialize the static chain. */
1164 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
1165 if (fn
== current_function_decl
)
1166 p
= DECL_STRUCT_FUNCTION (fn
)->saved_static_chain_decl
;
1169 /* No static chain? Seems like a bug in tree-nested.c. */
1170 gcc_assert (static_chain
);
1172 setup_one_parameter (id
, p
, static_chain
, fn
, bb
, &vars
);
1175 declare_inline_vars (id
->block
, vars
);
1178 /* Declare a return variable to replace the RESULT_DECL for the
1179 function we are calling. An appropriate DECL_STMT is returned.
1180 The USE_STMT is filled to contain a use of the declaration to
1181 indicate the return value of the function.
1183 RETURN_SLOT_ADDR, if non-null, was a fake parameter that
1184 took the address of the result. MODIFY_DEST, if non-null, was the LHS of
1185 the MODIFY_EXPR to which this call is the RHS.
1187 The return value is a (possibly null) value that is the result of the
1188 function as seen by the callee. *USE_P is a (possibly null) value that
1189 holds the result as seen by the caller. */
1192 declare_return_variable (inline_data
*id
, tree return_slot_addr
,
1193 tree modify_dest
, tree
*use_p
)
1195 tree callee
= id
->callee
;
1196 tree caller
= id
->caller
;
1197 tree result
= DECL_RESULT (callee
);
1198 tree callee_type
= TREE_TYPE (result
);
1199 tree caller_type
= TREE_TYPE (TREE_TYPE (callee
));
1202 /* We don't need to do anything for functions that don't return
1204 if (!result
|| VOID_TYPE_P (callee_type
))
1210 /* If there was a return slot, then the return value is the
1211 dereferenced address of that object. */
1212 if (return_slot_addr
)
1214 /* The front end shouldn't have used both return_slot_addr and
1215 a modify expression. */
1216 gcc_assert (!modify_dest
);
1217 if (DECL_BY_REFERENCE (result
))
1218 var
= return_slot_addr
;
1220 var
= build_fold_indirect_ref (return_slot_addr
);
1225 /* All types requiring non-trivial constructors should have been handled. */
1226 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
1228 /* Attempt to avoid creating a new temporary variable. */
1231 bool use_it
= false;
1233 /* We can't use MODIFY_DEST if there's type promotion involved. */
1234 if (!lang_hooks
.types_compatible_p (caller_type
, callee_type
))
1237 /* ??? If we're assigning to a variable sized type, then we must
1238 reuse the destination variable, because we've no good way to
1239 create variable sized temporaries at this point. */
1240 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
1243 /* If the callee cannot possibly modify MODIFY_DEST, then we can
1244 reuse it as the result of the call directly. Don't do this if
1245 it would promote MODIFY_DEST to addressable. */
1246 else if (!TREE_STATIC (modify_dest
)
1247 && !TREE_ADDRESSABLE (modify_dest
)
1248 && !TREE_ADDRESSABLE (result
))
1259 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
1261 var
= copy_decl_for_inlining (result
, callee
, caller
);
1263 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
1264 DECL_STRUCT_FUNCTION (caller
)->unexpanded_var_list
1265 = tree_cons (NULL_TREE
, var
,
1266 DECL_STRUCT_FUNCTION (caller
)->unexpanded_var_list
);
1268 /* Do not have the rest of GCC warn about this variable as it should
1269 not be visible to the user. */
1270 TREE_NO_WARNING (var
) = 1;
1272 /* Build the use expr. If the return type of the function was
1273 promoted, convert it back to the expected type. */
1275 if (!lang_hooks
.types_compatible_p (TREE_TYPE (var
), caller_type
))
1276 use
= fold_convert (caller_type
, var
);
1279 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
1280 way, when the RESULT_DECL is encountered, it will be
1281 automatically replaced by the VAR_DECL. */
1282 insert_decl_map (id
, result
, var
);
1284 /* Remember this so we can ignore it in remap_decls. */
1291 /* Returns nonzero if a function can be inlined as a tree. */
1294 tree_inlinable_function_p (tree fn
)
1296 return inlinable_function_p (fn
);
1299 static const char *inline_forbidden_reason
;
1302 inline_forbidden_p_1 (tree
*nodep
, int *walk_subtrees ATTRIBUTE_UNUSED
,
1306 tree fn
= (tree
) fnp
;
1309 switch (TREE_CODE (node
))
1312 /* Refuse to inline alloca call unless user explicitly forced so as
1313 this may change program's memory overhead drastically when the
1314 function using alloca is called in loop. In GCC present in
1315 SPEC2000 inlining into schedule_block cause it to require 2GB of
1316 RAM instead of 256MB. */
1317 if (alloca_call_p (node
)
1318 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1320 inline_forbidden_reason
1321 = G_("function %q+F can never be inlined because it uses "
1322 "alloca (override using the always_inline attribute)");
1325 t
= get_callee_fndecl (node
);
1329 /* We cannot inline functions that call setjmp. */
1330 if (setjmp_call_p (t
))
1332 inline_forbidden_reason
1333 = G_("function %q+F can never be inlined because it uses setjmp");
1337 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
1338 switch (DECL_FUNCTION_CODE (t
))
1340 /* We cannot inline functions that take a variable number of
1342 case BUILT_IN_VA_START
:
1343 case BUILT_IN_STDARG_START
:
1344 case BUILT_IN_NEXT_ARG
:
1345 case BUILT_IN_VA_END
:
1346 inline_forbidden_reason
1347 = G_("function %q+F can never be inlined because it "
1348 "uses variable argument lists");
1351 case BUILT_IN_LONGJMP
:
1352 /* We can't inline functions that call __builtin_longjmp at
1353 all. The non-local goto machinery really requires the
1354 destination be in a different function. If we allow the
1355 function calling __builtin_longjmp to be inlined into the
1356 function calling __builtin_setjmp, Things will Go Awry. */
1357 inline_forbidden_reason
1358 = G_("function %q+F can never be inlined because "
1359 "it uses setjmp-longjmp exception handling");
1362 case BUILT_IN_NONLOCAL_GOTO
:
1364 inline_forbidden_reason
1365 = G_("function %q+F can never be inlined because "
1366 "it uses non-local goto");
1369 case BUILT_IN_RETURN
:
1370 case BUILT_IN_APPLY_ARGS
:
1371 /* If a __builtin_apply_args caller would be inlined,
1372 it would be saving arguments of the function it has
1373 been inlined into. Similarly __builtin_return would
1374 return from the function the inline has been inlined into. */
1375 inline_forbidden_reason
1376 = G_("function %q+F can never be inlined because "
1377 "it uses __builtin_return or __builtin_apply_args");
1386 t
= TREE_OPERAND (node
, 0);
1388 /* We will not inline a function which uses computed goto. The
1389 addresses of its local labels, which may be tucked into
1390 global storage, are of course not constant across
1391 instantiations, which causes unexpected behavior. */
1392 if (TREE_CODE (t
) != LABEL_DECL
)
1394 inline_forbidden_reason
1395 = G_("function %q+F can never be inlined "
1396 "because it contains a computed goto");
1402 t
= TREE_OPERAND (node
, 0);
1403 if (DECL_NONLOCAL (t
))
1405 /* We cannot inline a function that receives a non-local goto
1406 because we cannot remap the destination label used in the
1407 function that is performing the non-local goto. */
1408 inline_forbidden_reason
1409 = G_("function %q+F can never be inlined "
1410 "because it receives a non-local goto");
1417 /* We cannot inline a function of the form
1419 void F (int i) { struct S { int ar[i]; } s; }
1421 Attempting to do so produces a catch-22.
1422 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1423 UNION_TYPE nodes, then it goes into infinite recursion on a
1424 structure containing a pointer to its own type. If it doesn't,
1425 then the type node for S doesn't get adjusted properly when
1428 ??? This is likely no longer true, but it's too late in the 4.0
1429 cycle to try to find out. This should be checked for 4.1. */
1430 for (t
= TYPE_FIELDS (node
); t
; t
= TREE_CHAIN (t
))
1431 if (variably_modified_type_p (TREE_TYPE (t
), NULL
))
1433 inline_forbidden_reason
1434 = G_("function %q+F can never be inlined "
1435 "because it uses variable sized variables");
1446 /* Return subexpression representing possible alloca call, if any. */
1448 inline_forbidden_p (tree fndecl
)
1450 location_t saved_loc
= input_location
;
1451 block_stmt_iterator bsi
;
1453 tree ret
= NULL_TREE
;
1455 FOR_EACH_BB_FN (bb
, DECL_STRUCT_FUNCTION (fndecl
))
1456 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
1458 ret
= walk_tree_without_duplicates (bsi_stmt_ptr (bsi
),
1459 inline_forbidden_p_1
, fndecl
);
1465 input_location
= saved_loc
;
1469 /* Returns nonzero if FN is a function that does not have any
1470 fundamental inline blocking properties. */
1473 inlinable_function_p (tree fn
)
1475 bool inlinable
= true;
1477 /* If we've already decided this function shouldn't be inlined,
1478 there's no need to check again. */
1479 if (DECL_UNINLINABLE (fn
))
1482 /* See if there is any language-specific reason it cannot be
1483 inlined. (It is important that this hook be called early because
1484 in C++ it may result in template instantiation.)
1485 If the function is not inlinable for language-specific reasons,
1486 it is left up to the langhook to explain why. */
1487 inlinable
= !lang_hooks
.tree_inlining
.cannot_inline_tree_fn (&fn
);
1489 /* If we don't have the function body available, we can't inline it.
1490 However, this should not be recorded since we also get here for
1491 forward declared inline functions. Therefore, return at once. */
1492 if (!DECL_SAVED_TREE (fn
))
1495 /* If we're not inlining at all, then we cannot inline this function. */
1496 else if (!flag_inline_trees
)
1499 /* Only try to inline functions if DECL_INLINE is set. This should be
1500 true for all functions declared `inline', and for all other functions
1501 as well with -finline-functions.
1503 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1504 it's the front-end that must set DECL_INLINE in this case, because
1505 dwarf2out loses if a function that does not have DECL_INLINE set is
1506 inlined anyway. That is why we have both DECL_INLINE and
1507 DECL_DECLARED_INLINE_P. */
1508 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1509 here should be redundant. */
1510 else if (!DECL_INLINE (fn
) && !flag_unit_at_a_time
)
1513 else if (inline_forbidden_p (fn
))
1515 /* See if we should warn about uninlinable functions. Previously,
1516 some of these warnings would be issued while trying to expand
1517 the function inline, but that would cause multiple warnings
1518 about functions that would for example call alloca. But since
1519 this a property of the function, just one warning is enough.
1520 As a bonus we can now give more details about the reason why a
1521 function is not inlinable.
1522 We only warn for functions declared `inline' by the user. */
1523 bool do_warning
= (warn_inline
1525 && DECL_DECLARED_INLINE_P (fn
)
1526 && !DECL_IN_SYSTEM_HEADER (fn
));
1528 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1529 sorry (inline_forbidden_reason
, fn
);
1530 else if (do_warning
)
1531 warning (0, inline_forbidden_reason
, fn
);
1536 /* Squirrel away the result so that we don't have to check again. */
1537 DECL_UNINLINABLE (fn
) = !inlinable
;
1542 /* Estimate the cost of a memory move. Use machine dependent
1543 word size and take possible memcpy call into account. */
1546 estimate_move_cost (tree type
)
1550 size
= int_size_in_bytes (type
);
1552 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO
)
1553 /* Cost of a memcpy call, 3 arguments and the call. */
1556 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
1559 /* Used by estimate_num_insns. Estimate number of instructions seen
1560 by given statement. */
1563 estimate_num_insns_1 (tree
*tp
, int *walk_subtrees
, void *data
)
1568 if (IS_TYPE_OR_DECL_P (x
))
1573 /* Assume that constants and references counts nothing. These should
1574 be majorized by amount of operations among them we count later
1575 and are common target of CSE and similar optimizations. */
1576 else if (CONSTANT_CLASS_P (x
) || REFERENCE_CLASS_P (x
))
1579 switch (TREE_CODE (x
))
1581 /* Containers have no cost. */
1588 case ALIGN_INDIRECT_REF
:
1589 case MISALIGNED_INDIRECT_REF
:
1591 case ARRAY_RANGE_REF
:
1593 case EXC_PTR_EXPR
: /* ??? */
1594 case FILTER_EXPR
: /* ??? */
1597 case WITH_CLEANUP_EXPR
:
1599 case VIEW_CONVERT_EXPR
:
1604 case CASE_LABEL_EXPR
:
1607 case EH_FILTER_EXPR
:
1608 case STATEMENT_LIST
:
1610 case NON_LVALUE_EXPR
:
1613 case TRY_CATCH_EXPR
:
1614 case TRY_FINALLY_EXPR
:
1621 case WITH_SIZE_EXPR
:
1624 /* We don't account constants for now. Assume that the cost is amortized
1625 by operations that do use them. We may re-consider this decision once
1626 we are able to optimize the tree before estimating its size and break
1627 out static initializers. */
1628 case IDENTIFIER_NODE
:
1637 /* Try to estimate the cost of assignments. We have three cases to
1639 1) Simple assignments to registers;
1640 2) Stores to things that must live in memory. This includes
1641 "normal" stores to scalars, but also assignments of large
1642 structures, or constructors of big arrays;
1645 Let us look at the first two cases, assuming we have "a = b + C":
1646 <modify_expr <var_decl "a"> <plus_expr <var_decl "b"> <constant C>>
1647 If "a" is a GIMPLE register, the assignment to it is free on almost
1648 any target, because "a" usually ends up in a real register. Hence
1649 the only cost of this expression comes from the PLUS_EXPR, and we
1650 can ignore the MODIFY_EXPR.
1651 If "a" is not a GIMPLE register, the assignment to "a" will most
1652 likely be a real store, so the cost of the MODIFY_EXPR is the cost
1653 of moving something into "a", which we compute using the function
1656 The third case deals with TARGET_EXPRs, for which the semantics are
1657 that a temporary is assigned, unless the TARGET_EXPR itself is being
1658 assigned to something else. In the latter case we do not need the
1659 temporary. E.g. in <modify_expr <var_decl "a"> <target_expr>>, the
1660 MODIFY_EXPR is free. */
1663 /* Is the right and side a TARGET_EXPR? */
1664 if (TREE_CODE (TREE_OPERAND (x
, 1)) == TARGET_EXPR
)
1666 /* ... fall through ... */
1669 x
= TREE_OPERAND (x
, 0);
1670 /* Is this an assignments to a register? */
1671 if (is_gimple_reg (x
))
1673 /* Otherwise it's a store, so fall through to compute the move cost. */
1676 *count
+= estimate_move_cost (TREE_TYPE (x
));
1679 /* Assign cost of 1 to usual operations.
1680 ??? We may consider mapping RTL costs to this. */
1688 case FIX_TRUNC_EXPR
:
1690 case FIX_FLOOR_EXPR
:
1691 case FIX_ROUND_EXPR
:
1703 case VEC_LSHIFT_EXPR
:
1704 case VEC_RSHIFT_EXPR
:
1711 case TRUTH_ANDIF_EXPR
:
1712 case TRUTH_ORIF_EXPR
:
1713 case TRUTH_AND_EXPR
:
1715 case TRUTH_XOR_EXPR
:
1716 case TRUTH_NOT_EXPR
:
1725 case UNORDERED_EXPR
:
1738 case PREDECREMENT_EXPR
:
1739 case PREINCREMENT_EXPR
:
1740 case POSTDECREMENT_EXPR
:
1741 case POSTINCREMENT_EXPR
:
1747 case REALIGN_LOAD_EXPR
:
1749 case REDUC_MAX_EXPR
:
1750 case REDUC_MIN_EXPR
:
1751 case REDUC_PLUS_EXPR
:
1757 /* Few special cases of expensive operations. This is useful
1758 to avoid inlining on functions having too many of these. */
1759 case TRUNC_DIV_EXPR
:
1761 case FLOOR_DIV_EXPR
:
1762 case ROUND_DIV_EXPR
:
1763 case EXACT_DIV_EXPR
:
1764 case TRUNC_MOD_EXPR
:
1766 case FLOOR_MOD_EXPR
:
1767 case ROUND_MOD_EXPR
:
1773 tree decl
= get_callee_fndecl (x
);
1776 if (decl
&& DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
1777 switch (DECL_FUNCTION_CODE (decl
))
1779 case BUILT_IN_CONSTANT_P
:
1782 case BUILT_IN_EXPECT
:
1788 /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
1789 that does use function declaration to figure out the arguments. */
1792 for (arg
= TREE_OPERAND (x
, 1); arg
; arg
= TREE_CHAIN (arg
))
1793 *count
+= estimate_move_cost (TREE_TYPE (TREE_VALUE (arg
)));
1797 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
1798 *count
+= estimate_move_cost (TREE_TYPE (arg
));
1801 *count
+= PARAM_VALUE (PARAM_INLINE_CALL_COST
);
1810 /* Estimate number of instructions that will be created by expanding EXPR. */
1813 estimate_num_insns (tree expr
)
1816 struct pointer_set_t
*visited_nodes
;
1818 block_stmt_iterator bsi
;
1819 struct function
*my_function
;
1821 /* If we're given an entire function, walk the CFG. */
1822 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1824 my_function
= DECL_STRUCT_FUNCTION (expr
);
1825 gcc_assert (my_function
&& my_function
->cfg
);
1826 visited_nodes
= pointer_set_create ();
1827 FOR_EACH_BB_FN (bb
, my_function
)
1829 for (bsi
= bsi_start (bb
);
1833 walk_tree (bsi_stmt_ptr (bsi
), estimate_num_insns_1
,
1834 &num
, visited_nodes
);
1837 pointer_set_destroy (visited_nodes
);
1840 walk_tree_without_duplicates (&expr
, estimate_num_insns_1
, &num
);
1845 typedef struct function
*function_p
;
1847 DEF_VEC_P(function_p
);
1848 DEF_VEC_ALLOC_P(function_p
,heap
);
1850 /* Initialized with NOGC, making this poisonous to the garbage collector. */
1851 static VEC(function_p
,heap
) *cfun_stack
;
1854 push_cfun (struct function
*new_cfun
)
1856 VEC_safe_push (function_p
, heap
, cfun_stack
, cfun
);
1863 cfun
= VEC_pop (function_p
, cfun_stack
);
1866 /* Install new lexical TREE_BLOCK underneath 'current_block'. */
1868 add_lexical_block (tree current_block
, tree new_block
)
1872 /* Walk to the last sub-block. */
1873 for (blk_p
= &BLOCK_SUBBLOCKS (current_block
);
1875 blk_p
= &TREE_CHAIN (*blk_p
))
1878 BLOCK_SUPERCONTEXT (new_block
) = current_block
;
1881 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1884 expand_call_inline (basic_block bb
, tree stmt
, tree
*tp
, void *data
)
1892 tree return_slot_addr
;
1894 location_t saved_location
;
1895 struct cgraph_edge
*cg_edge
;
1897 basic_block return_block
;
1899 block_stmt_iterator bsi
, stmt_bsi
;
1900 bool successfully_inlined
= FALSE
;
1903 struct cgraph_node
*old_node
;
1906 /* See what we've got. */
1907 id
= (inline_data
*) data
;
1910 /* Set input_location here so we get the right instantiation context
1911 if we call instantiate_decl from inlinable_function_p. */
1912 saved_location
= input_location
;
1913 if (EXPR_HAS_LOCATION (t
))
1914 input_location
= EXPR_LOCATION (t
);
1916 /* From here on, we're only interested in CALL_EXPRs. */
1917 if (TREE_CODE (t
) != CALL_EXPR
)
1920 /* First, see if we can figure out what function is being called.
1921 If we cannot, then there is no hope of inlining the function. */
1922 fn
= get_callee_fndecl (t
);
1926 /* Turn forward declarations into real ones. */
1927 fn
= cgraph_node (fn
)->decl
;
1929 /* If fn is a declaration of a function in a nested scope that was
1930 globally declared inline, we don't set its DECL_INITIAL.
1931 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1932 C++ front-end uses it for cdtors to refer to their internal
1933 declarations, that are not real functions. Fortunately those
1934 don't have trees to be saved, so we can tell by checking their
1936 if (! DECL_INITIAL (fn
)
1937 && DECL_ABSTRACT_ORIGIN (fn
)
1938 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn
)))
1939 fn
= DECL_ABSTRACT_ORIGIN (fn
);
1941 /* Objective C and fortran still calls tree_rest_of_compilation directly.
1942 Kill this check once this is fixed. */
1943 if (!id
->current_node
->analyzed
)
1946 cg_edge
= cgraph_edge (id
->current_node
, stmt
);
1948 /* Constant propagation on argument done during previous inlining
1949 may create new direct call. Produce an edge for it. */
1952 struct cgraph_node
*dest
= cgraph_node (fn
);
1954 /* We have missing edge in the callgraph. This can happen in one case
1955 where previous inlining turned indirect call into direct call by
1956 constant propagating arguments. In all other cases we hit a bug
1957 (incorrect node sharing is most common reason for missing edges. */
1958 gcc_assert (dest
->needed
|| !flag_unit_at_a_time
);
1959 cgraph_create_edge (id
->node
, dest
, stmt
,
1960 bb
->count
, bb
->loop_depth
)->inline_failed
1961 = N_("originally indirect function call not considered for inlining");
1965 /* Don't try to inline functions that are not well-suited to
1967 if (!cgraph_inline_p (cg_edge
, &reason
))
1969 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1971 sorry ("inlining failed in call to %q+F: %s", fn
, reason
);
1972 sorry ("called from here");
1974 else if (warn_inline
&& DECL_DECLARED_INLINE_P (fn
)
1975 && !DECL_IN_SYSTEM_HEADER (fn
)
1977 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
))
1978 /* Avoid warnings during early inline pass. */
1979 && (!flag_unit_at_a_time
|| cgraph_global_info_ready
))
1981 warning (OPT_Winline
, "inlining failed in call to %q+F: %s",
1983 warning (OPT_Winline
, "called from here");
1988 #ifdef ENABLE_CHECKING
1989 if (cg_edge
->callee
->decl
!= id
->node
->decl
)
1990 verify_cgraph_node (cg_edge
->callee
);
1993 /* We will be inlining this callee. */
1995 id
->eh_region
= lookup_stmt_eh_region (stmt
);
1997 /* Split the block holding the CALL_EXPR. */
1999 e
= split_block (bb
, stmt
);
2001 return_block
= e
->dest
;
2004 /* split_block splits before the statement, work around this by moving
2005 the call into the first half_bb. Not pretty, but seems easier than
2006 doing the CFG manipulation by hand when the CALL_EXPR is in the last
2008 stmt_bsi
= bsi_last (bb
);
2009 bsi
= bsi_start (return_block
);
2010 if (!bsi_end_p (bsi
))
2011 bsi_move_before (&stmt_bsi
, &bsi
);
2014 tree stmt
= bsi_stmt (stmt_bsi
);
2015 bsi_remove (&stmt_bsi
);
2016 bsi_insert_after (&bsi
, stmt
, BSI_NEW_STMT
);
2018 stmt_bsi
= bsi_start (return_block
);
2020 /* Build a block containing code to initialize the arguments, the
2021 actual inline expansion of the body, and a label for the return
2022 statements within the function to jump to. The type of the
2023 statement expression is the return type of the function call. */
2024 id
->block
= make_node (BLOCK
);
2025 BLOCK_ABSTRACT_ORIGIN (id
->block
) = fn
;
2026 add_lexical_block (TREE_BLOCK (stmt
), id
->block
);
2029 /* Local declarations will be replaced by their equivalents in this
2032 id
->decl_map
= splay_tree_new (splay_tree_compare_pointers
,
2035 /* Initialize the parameters. */
2036 args
= TREE_OPERAND (t
, 1);
2038 initialize_inlined_parameters (id
, args
, TREE_OPERAND (t
, 2), fn
, bb
);
2040 /* Record the function we are about to inline. */
2043 if (DECL_STRUCT_FUNCTION (fn
)->saved_blocks
)
2044 add_lexical_block (id
->block
, remap_blocks (DECL_STRUCT_FUNCTION (fn
)->saved_blocks
, id
));
2045 else if (DECL_INITIAL (fn
))
2046 add_lexical_block (id
->block
, remap_blocks (DECL_INITIAL (fn
), id
));
2048 /* Return statements in the function body will be replaced by jumps
2049 to the RET_LABEL. */
2051 gcc_assert (DECL_INITIAL (fn
));
2052 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
2054 /* Find the lhs to which the result of this call is assigned. */
2055 return_slot_addr
= NULL
;
2056 if (TREE_CODE (stmt
) == MODIFY_EXPR
)
2058 modify_dest
= TREE_OPERAND (stmt
, 0);
2060 /* The function which we are inlining might not return a value,
2061 in which case we should issue a warning that the function
2062 does not return a value. In that case the optimizers will
2063 see that the variable to which the value is assigned was not
2064 initialized. We do not want to issue a warning about that
2065 uninitialized variable. */
2066 if (DECL_P (modify_dest
))
2067 TREE_NO_WARNING (modify_dest
) = 1;
2068 if (CALL_EXPR_RETURN_SLOT_OPT (t
))
2070 return_slot_addr
= build_fold_addr_expr (modify_dest
);
2077 /* Declare the return variable for the function. */
2078 decl
= declare_return_variable (id
, return_slot_addr
,
2079 modify_dest
, &use_retvar
);
2080 /* Do this only if declare_return_variable created a new one. */
2081 if (decl
&& !return_slot_addr
&& decl
!= modify_dest
)
2082 declare_inline_vars (id
->block
, decl
);
2084 /* After we've initialized the parameters, we insert the body of the
2086 old_node
= id
->current_node
;
2088 /* Anoint the callee-to-be-duplicated as the "current_node." When
2089 CALL_EXPRs within callee are duplicated, the edges from callee to
2090 callee's callees (caller's grandchildren) will be cloned. */
2091 id
->current_node
= cg_edge
->callee
;
2093 /* This is it. Duplicate the callee body. Assume callee is
2094 pre-gimplified. Note that we must not alter the caller
2095 function in any way before this point, as this CALL_EXPR may be
2096 a self-referential call; if we're calling ourselves, we need to
2097 duplicate our body before altering anything. */
2098 copy_body (id
, bb
->count
, bb
->frequency
, bb
, return_block
);
2099 id
->current_node
= old_node
;
2101 /* Add local vars in this inlined callee to caller. */
2102 t_step
= id
->callee_cfun
->unexpanded_var_list
;
2103 if (id
->callee_cfun
->saved_unexpanded_var_list
)
2104 t_step
= id
->callee_cfun
->saved_unexpanded_var_list
;
2105 for (; t_step
; t_step
= TREE_CHAIN (t_step
))
2107 var
= TREE_VALUE (t_step
);
2108 if (TREE_STATIC (var
) && !TREE_ASM_WRITTEN (var
))
2109 cfun
->unexpanded_var_list
= tree_cons (NULL_TREE
, var
,
2110 cfun
->unexpanded_var_list
);
2112 cfun
->unexpanded_var_list
= tree_cons (NULL_TREE
, remap_decl (var
, id
),
2113 cfun
->unexpanded_var_list
);
2117 splay_tree_delete (id
->decl_map
);
2120 /* If the inlined function returns a result that we care about,
2121 clobber the CALL_EXPR with a reference to the return variable. */
2122 if (use_retvar
&& (TREE_CODE (bsi_stmt (stmt_bsi
)) != CALL_EXPR
))
2125 maybe_clean_or_replace_eh_stmt (stmt
, stmt
);
2128 /* We're modifying a TSI owned by gimple_expand_calls_inline();
2129 tsi_delink() will leave the iterator in a sane state. */
2130 bsi_remove (&stmt_bsi
);
2133 if (bsi_end_p (bsi
))
2134 tree_purge_dead_eh_edges (return_block
);
2136 /* If the value of the new expression is ignored, that's OK. We
2137 don't warn about this for CALL_EXPRs, so we shouldn't warn about
2138 the equivalent inlined version either. */
2139 TREE_USED (*tp
) = 1;
2141 /* Output the inlining info for this abstract function, since it has been
2142 inlined. If we don't do this now, we can lose the information about the
2143 variables in the function when the blocks get blown away as soon as we
2144 remove the cgraph node. */
2145 (*debug_hooks
->outlining_inline_function
) (cg_edge
->callee
->decl
);
2147 /* Update callgraph if needed. */
2148 cgraph_remove_node (cg_edge
->callee
);
2150 /* Declare the 'auto' variables added with this inlined body. */
2151 record_vars (BLOCK_VARS (id
->block
));
2152 id
->block
= NULL_TREE
;
2153 successfully_inlined
= TRUE
;
2156 input_location
= saved_location
;
2157 return successfully_inlined
;
2160 /* Expand call statements reachable from STMT_P.
2161 We can only have CALL_EXPRs as the "toplevel" tree code or nested
2162 in a MODIFY_EXPR. See tree-gimple.c:get_call_expr_in(). We can
2163 unfortunately not use that function here because we need a pointer
2164 to the CALL_EXPR, not the tree itself. */
2167 gimple_expand_calls_inline (basic_block bb
, inline_data
*id
)
2169 block_stmt_iterator bsi
;
2171 /* Register specific tree functions. */
2172 tree_register_cfg_hooks ();
2173 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
2175 tree
*expr_p
= bsi_stmt_ptr (bsi
);
2176 tree stmt
= *expr_p
;
2178 if (TREE_CODE (*expr_p
) == MODIFY_EXPR
)
2179 expr_p
= &TREE_OPERAND (*expr_p
, 1);
2180 if (TREE_CODE (*expr_p
) == WITH_SIZE_EXPR
)
2181 expr_p
= &TREE_OPERAND (*expr_p
, 0);
2182 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2183 if (expand_call_inline (bb
, stmt
, expr_p
, id
))
2189 /* Expand calls to inline functions in the body of FN. */
2192 optimize_inline_calls (tree fn
)
2197 /* There is no point in performing inlining if errors have already
2198 occurred -- and we might crash if we try to inline invalid
2200 if (errorcount
|| sorrycount
)
2204 memset (&id
, 0, sizeof (id
));
2206 id
.current_node
= id
.node
= cgraph_node (fn
);
2208 /* Or any functions that aren't finished yet. */
2209 prev_fn
= NULL_TREE
;
2210 if (current_function_decl
)
2212 id
.caller
= current_function_decl
;
2213 prev_fn
= current_function_decl
;
2215 push_gimplify_context ();
2217 /* Reach the trees by walking over the CFG, and note the
2218 enclosing basic-blocks in the call edges. */
2219 /* We walk the blocks going forward, because inlined function bodies
2220 will split id->current_basic_block, and the new blocks will
2221 follow it; we'll trudge through them, processing their CALL_EXPRs
2224 gimple_expand_calls_inline (bb
, &id
);
2227 pop_gimplify_context (NULL
);
2228 /* Renumber the (code) basic_blocks consecutively. */
2230 /* Renumber the lexical scoping (non-code) blocks consecutively. */
2233 #ifdef ENABLE_CHECKING
2235 struct cgraph_edge
*e
;
2237 verify_cgraph_node (id
.node
);
2239 /* Double check that we inlined everything we are supposed to inline. */
2240 for (e
= id
.node
->callees
; e
; e
= e
->next_callee
)
2241 gcc_assert (e
->inline_failed
);
2244 /* We need to rescale frequencies again to peak at REG_BR_PROB_BASE
2245 as inlining loops might increase the maximum. */
2246 if (ENTRY_BLOCK_PTR
->count
)
2248 fold_cond_expr_cond ();
2251 /* FN is a function that has a complete body, and CLONE is a function whose
2252 body is to be set to a copy of FN, mapping argument declarations according
2253 to the ARG_MAP splay_tree. */
2256 clone_body (tree clone
, tree fn
, void *arg_map
)
2260 /* Clone the body, as if we were making an inline call. But, remap the
2261 parameters in the callee to the parameters of caller. */
2262 memset (&id
, 0, sizeof (id
));
2265 id
.callee_cfun
= DECL_STRUCT_FUNCTION (fn
);
2266 id
.decl_map
= (splay_tree
)arg_map
;
2268 /* Cloning is treated slightly differently from inlining. Set
2269 CLONING_P so that it's clear which operation we're performing. */
2270 id
.cloning_p
= true;
2272 /* We're not inside any EH region. */
2275 /* Actually copy the body. */
2276 append_to_statement_list_force (copy_generic_body (&id
), &DECL_SAVED_TREE (clone
));
2279 /* Save duplicate body in FN. MAP is used to pass around splay tree
2280 used to update arguments in restore_body. */
2282 /* Make and return duplicate of body in FN. Put copies of DECL_ARGUMENTS
2283 in *arg_copy and of the static chain, if any, in *sc_copy. */
2286 save_body (tree fn
, tree
*arg_copy
, tree
*sc_copy
)
2289 tree newdecl
, *parg
;
2290 basic_block fn_entry_block
;
2293 memset (&id
, 0, sizeof (id
));
2295 id
.callee_cfun
= DECL_STRUCT_FUNCTION (fn
);
2297 id
.node
= cgraph_node (fn
);
2299 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2300 *arg_copy
= DECL_ARGUMENTS (fn
);
2302 for (parg
= arg_copy
; *parg
; parg
= &TREE_CHAIN (*parg
))
2304 tree
new = copy_node (*parg
);
2306 lang_hooks
.dup_lang_specific_decl (new);
2307 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg
);
2308 insert_decl_map (&id
, *parg
, new);
2309 TREE_CHAIN (new) = TREE_CHAIN (*parg
);
2313 *sc_copy
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
2316 tree
new = copy_node (*sc_copy
);
2318 lang_hooks
.dup_lang_specific_decl (new);
2319 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*sc_copy
);
2320 insert_decl_map (&id
, *sc_copy
, new);
2321 TREE_CHAIN (new) = TREE_CHAIN (*sc_copy
);
2325 /* We're not inside any EH region. */
2328 insert_decl_map (&id
, DECL_RESULT (fn
), DECL_RESULT (fn
));
2330 DECL_STRUCT_FUNCTION (fn
)->saved_blocks
2331 = remap_blocks (DECL_INITIAL (fn
), &id
);
2332 for (t_step
= id
.callee_cfun
->unexpanded_var_list
;
2334 t_step
= TREE_CHAIN (t_step
))
2336 tree var
= TREE_VALUE (t_step
);
2337 if (TREE_STATIC (var
) && !TREE_ASM_WRITTEN (var
))
2338 cfun
->saved_unexpanded_var_list
2339 = tree_cons (NULL_TREE
, var
, cfun
->saved_unexpanded_var_list
);
2341 cfun
->saved_unexpanded_var_list
2342 = tree_cons (NULL_TREE
, remap_decl (var
, &id
),
2343 cfun
->saved_unexpanded_var_list
);
2346 /* Actually copy the body, including a new (struct function *) and CFG.
2347 EH info is also duplicated so its labels point into the copied
2348 CFG, not the original. */
2349 fn_entry_block
= ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fn
));
2350 newdecl
= copy_body (&id
, fn_entry_block
->count
, fn_entry_block
->frequency
,
2352 DECL_STRUCT_FUNCTION (fn
)->saved_cfg
= DECL_STRUCT_FUNCTION (newdecl
)->cfg
;
2353 DECL_STRUCT_FUNCTION (fn
)->saved_eh
= DECL_STRUCT_FUNCTION (newdecl
)->eh
;
2356 splay_tree_delete (id
.decl_map
);
2359 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
2362 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2364 enum tree_code code
= TREE_CODE (*tp
);
2366 /* We make copies of most nodes. */
2367 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
2368 || code
== TREE_LIST
2370 || code
== TYPE_DECL
)
2372 /* Because the chain gets clobbered when we make a copy, we save it
2374 tree chain
= TREE_CHAIN (*tp
);
2377 /* Copy the node. */
2378 new = copy_node (*tp
);
2380 /* Propagate mudflap marked-ness. */
2381 if (flag_mudflap
&& mf_marked_p (*tp
))
2386 /* Now, restore the chain, if appropriate. That will cause
2387 walk_tree to walk into the chain as well. */
2388 if (code
== PARM_DECL
|| code
== TREE_LIST
)
2389 TREE_CHAIN (*tp
) = chain
;
2391 /* For now, we don't update BLOCKs when we make copies. So, we
2392 have to nullify all BIND_EXPRs. */
2393 if (TREE_CODE (*tp
) == BIND_EXPR
)
2394 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
2397 else if (TREE_CODE_CLASS (code
) == tcc_type
)
2399 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
2401 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
2404 gcc_assert (code
!= STATEMENT_LIST
);
2408 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2409 information indicating to what new SAVE_EXPR this one should be mapped,
2410 use that one. Otherwise, create a new node and enter it in ST. FN is
2411 the function into which the copy will be placed. */
2414 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
2416 splay_tree st
= (splay_tree
) st_
;
2420 /* See if we already encountered this SAVE_EXPR. */
2421 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2423 /* If we didn't already remap this SAVE_EXPR, do so now. */
2426 t
= copy_node (*tp
);
2428 /* Remember this SAVE_EXPR. */
2429 splay_tree_insert (st
, (splay_tree_key
) *tp
, (splay_tree_value
) t
);
2430 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2431 splay_tree_insert (st
, (splay_tree_key
) t
, (splay_tree_value
) t
);
2435 /* We've already walked into this SAVE_EXPR; don't do it again. */
2437 t
= (tree
) n
->value
;
2440 /* Replace this SAVE_EXPR with the copy. */
2444 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
2445 copies the declaration and enters it in the splay_tree in DATA (which is
2446 really an `inline_data *'). */
2449 mark_local_for_remap_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
2452 inline_data
*id
= (inline_data
*) data
;
2454 /* Don't walk into types. */
2458 else if (TREE_CODE (*tp
) == LABEL_EXPR
)
2460 tree decl
= TREE_OPERAND (*tp
, 0);
2462 /* Copy the decl and remember the copy. */
2463 insert_decl_map (id
, decl
,
2464 copy_decl_for_inlining (decl
, DECL_CONTEXT (decl
),
2465 DECL_CONTEXT (decl
)));
2471 /* Perform any modifications to EXPR required when it is unsaved. Does
2472 not recurse into EXPR's subtrees. */
2475 unsave_expr_1 (tree expr
)
2477 switch (TREE_CODE (expr
))
2480 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
2481 It's OK for this to happen if it was part of a subtree that
2482 isn't immediately expanded, such as operand 2 of another
2484 if (TREE_OPERAND (expr
, 1))
2487 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
2488 TREE_OPERAND (expr
, 3) = NULL_TREE
;
2496 /* Called via walk_tree when an expression is unsaved. Using the
2497 splay_tree pointed to by ST (which is really a `splay_tree'),
2498 remaps all local declarations to appropriate replacements. */
2501 unsave_r (tree
*tp
, int *walk_subtrees
, void *data
)
2503 inline_data
*id
= (inline_data
*) data
;
2504 splay_tree st
= id
->decl_map
;
2507 /* Only a local declaration (variable or label). */
2508 if ((TREE_CODE (*tp
) == VAR_DECL
&& !TREE_STATIC (*tp
))
2509 || TREE_CODE (*tp
) == LABEL_DECL
)
2511 /* Lookup the declaration. */
2512 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2514 /* If it's there, remap it. */
2516 *tp
= (tree
) n
->value
;
2519 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
2520 copy_statement_list (tp
);
2521 else if (TREE_CODE (*tp
) == BIND_EXPR
)
2522 copy_bind_expr (tp
, walk_subtrees
, id
);
2523 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2524 remap_save_expr (tp
, st
, walk_subtrees
);
2527 copy_tree_r (tp
, walk_subtrees
, NULL
);
2529 /* Do whatever unsaving is required. */
2530 unsave_expr_1 (*tp
);
2533 /* Keep iterating. */
2537 /* Copies everything in EXPR and replaces variables, labels
2538 and SAVE_EXPRs local to EXPR. */
2541 unsave_expr_now (tree expr
)
2545 /* There's nothing to do for NULL_TREE. */
2550 memset (&id
, 0, sizeof (id
));
2551 id
.callee
= current_function_decl
;
2552 id
.caller
= current_function_decl
;
2553 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2555 /* Walk the tree once to find local labels. */
2556 walk_tree_without_duplicates (&expr
, mark_local_for_remap_r
, &id
);
2558 /* Walk the tree again, copying, remapping, and unsaving. */
2559 walk_tree (&expr
, unsave_r
, &id
, NULL
);
2562 splay_tree_delete (id
.decl_map
);
2567 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
2570 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
2579 debug_find_tree (tree top
, tree search
)
2581 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
2585 /* Declare the variables created by the inliner. Add all the variables in
2586 VARS to BIND_EXPR. */
2589 declare_inline_vars (tree block
, tree vars
)
2592 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
2593 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
2596 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), vars
);
2599 /* Returns true if we're inlining. */
2601 inlining_p (inline_data
*id
)
2603 return (!id
->saving_p
&& !id
->cloning_p
);