2 Copyright 2001, 2002, 2003, 2004 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, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
28 #include "tree-inline.h"
34 #include "insn-config.h"
35 #include "integrate.h"
38 #include "splay-tree.h"
39 #include "langhooks.h"
42 #include "tree-mudflap.h"
44 #include "diagnostic.h"
46 /* I'm not real happy about this, but we need to handle gimple and
48 #include "tree-iterator.h"
49 #include "tree-gimple.h"
51 /* 0 if we should not perform inlining.
52 1 if we should expand functions calls inline at the tree level.
53 2 if we should consider *all* functions to be inline
56 int flag_inline_trees
= 0;
60 o In order to make inlining-on-trees work, we pessimized
61 function-local static constants. In particular, they are now
62 always output, even when not addressed. Fix this by treating
63 function-local static constants just like global static
64 constants; the back-end already knows not to output them if they
67 o Provide heuristics to clamp inlining of recursive template
70 /* Data required for function inlining. */
72 typedef struct inline_data
74 /* A stack of the functions we are inlining. For example, if we are
75 compiling `f', which calls `g', which calls `h', and we are
76 inlining the body of `h', the stack will contain, `h', followed
77 by `g', followed by `f'. The first few elements of the stack may
78 contain other functions that we know we should not recurse into,
79 even though they are not directly being inlined. */
81 /* The index of the first element of FNS that really represents an
83 unsigned first_inlined_fn
;
84 /* The label to jump to when a return statement is encountered. If
85 this value is NULL, then return statements will simply be
86 remapped as return statements, rather than as jumps. */
88 /* The VAR_DECL for the return value. */
90 /* The map from local declarations in the inlined function to
91 equivalents in the function into which it is being inlined. */
93 /* Nonzero if we are currently within the cleanup for a
95 int in_target_cleanup_p
;
96 /* A list of the functions current function has inlined. */
97 varray_type inlined_fns
;
98 /* We use the same mechanism to build clones that we do to perform
99 inlining. However, there are a few places where we need to
100 distinguish between those two situations. This flag is true if
101 we are cloning, rather than inlining. */
103 /* Similarly for saving function body. */
105 /* Hash table used to prevent walk_tree from visiting the same node
106 umpteen million times. */
108 /* Callgraph node of function we are inlining into. */
109 struct cgraph_node
*node
;
110 /* Callgraph node of currently inlined function. */
111 struct cgraph_node
*current_node
;
112 /* Statement iterator. We need this so we can keep the tree in
113 gimple form when we insert the inlined function. It is not
114 used when we are not dealing with gimple trees. */
115 tree_stmt_iterator tsi
;
120 /* The approximate number of instructions per statement. This number
121 need not be particularly accurate; it is used only to make
122 decisions about when a function is too big to inline. */
123 #define INSNS_PER_STMT (10)
125 static tree
copy_body_r (tree
*, int *, void *);
126 static tree
copy_body (inline_data
*);
127 static tree
expand_call_inline (tree
*, int *, void *);
128 static void expand_calls_inline (tree
*, inline_data
*);
129 static bool inlinable_function_p (tree
);
130 static tree
remap_decl (tree
, inline_data
*);
131 static tree
remap_type (tree
, inline_data
*);
132 static tree
initialize_inlined_parameters (inline_data
*, tree
,
134 static void remap_block (tree
*, inline_data
*);
135 static tree
remap_decls (tree
, inline_data
*);
136 static void copy_bind_expr (tree
*, int *, inline_data
*);
137 static tree
mark_local_for_remap_r (tree
*, int *, void *);
138 static void unsave_expr_1 (tree
);
139 static tree
unsave_r (tree
*, int *, void *);
140 static void declare_inline_vars (tree bind_expr
, tree vars
);
142 /* Insert a tree->tree mapping for ID. Despite the name suggests
143 that the trees should be variables, it is used for more than that. */
146 insert_decl_map (inline_data
*id
, tree key
, tree value
)
148 splay_tree_insert (id
->decl_map
, (splay_tree_key
) key
,
149 (splay_tree_value
) value
);
151 /* Always insert an identity map as well. If we see this same new
152 node again, we won't want to duplicate it a second time. */
154 splay_tree_insert (id
->decl_map
, (splay_tree_key
) value
,
155 (splay_tree_value
) value
);
158 /* Remap DECL during the copying of the BLOCK tree for the function.
159 We are only called to remap local variables in the current function. */
162 remap_decl (tree decl
, inline_data
*id
)
164 splay_tree_node n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
165 tree fn
= VARRAY_TOP_TREE (id
->fns
);
167 /* See if we have remapped this declaration. If we didn't already have an
168 equivalent for this declaration, create one now. */
171 /* Make a copy of the variable or label. */
172 tree t
= copy_decl_for_inlining (decl
, fn
, VARRAY_TREE (id
->fns
, 0));
174 /* Remap types, if necessary. */
175 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
176 if (TREE_CODE (t
) == TYPE_DECL
)
177 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
178 else if (TREE_CODE (t
) == PARM_DECL
)
179 DECL_ARG_TYPE_AS_WRITTEN (t
)
180 = remap_type (DECL_ARG_TYPE_AS_WRITTEN (t
), id
);
182 /* Remap sizes as necessary. */
183 walk_tree (&DECL_SIZE (t
), copy_body_r
, id
, NULL
);
184 walk_tree (&DECL_SIZE_UNIT (t
), copy_body_r
, id
, NULL
);
186 /* If fields, do likewise for offset and qualifier. */
187 if (TREE_CODE (t
) == FIELD_DECL
)
189 walk_tree (&DECL_FIELD_OFFSET (t
), copy_body_r
, id
, NULL
);
190 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
191 walk_tree (&DECL_QUALIFIER (t
), copy_body_r
, id
, NULL
);
195 /* FIXME handle anon aggrs. */
196 if (! DECL_NAME (t
) && TREE_TYPE (t
)
197 && lang_hooks
.tree_inlining
.anon_aggr_type_p (TREE_TYPE (t
)))
199 /* For a VAR_DECL of anonymous type, we must also copy the
200 member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS. */
204 for (src
= DECL_ANON_UNION_ELEMS (t
); src
;
205 src
= TREE_CHAIN (src
))
207 tree member
= remap_decl (TREE_VALUE (src
), id
);
209 gcc_assert (!TREE_PURPOSE (src
));
210 members
= tree_cons (NULL
, member
, members
);
212 DECL_ANON_UNION_ELEMS (t
) = nreverse (members
);
216 /* Remember it, so that if we encounter this local entity
217 again we can reuse this copy. */
218 insert_decl_map (id
, decl
, t
);
222 return unshare_expr ((tree
) n
->value
);
226 remap_type (tree type
, inline_data
*id
)
228 splay_tree_node node
;
234 /* See if we have remapped this type. */
235 node
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) type
);
237 return (tree
) node
->value
;
239 /* The type only needs remapping if it's variably modified by a variable
240 in the function we are inlining. */
241 if (! variably_modified_type_p (type
, VARRAY_TOP_TREE (id
->fns
)))
243 insert_decl_map (id
, type
, type
);
247 /* We do need a copy. build and register it now. If this is a pointer or
248 reference type, remap the designated type and make a new pointer or
250 if (TREE_CODE (type
) == POINTER_TYPE
)
252 new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
254 TYPE_REF_CAN_ALIAS_ALL (type
));
255 insert_decl_map (id
, type
, new);
258 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
260 new = build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
262 TYPE_REF_CAN_ALIAS_ALL (type
));
263 insert_decl_map (id
, type
, new);
267 new = copy_node (type
);
269 insert_decl_map (id
, type
, new);
271 /* This is a new type, not a copy of an old type. Need to reassociate
272 variants. We can handle everything except the main variant lazily. */
273 t
= TYPE_MAIN_VARIANT (type
);
276 t
= remap_type (t
, id
);
277 TYPE_MAIN_VARIANT (new) = t
;
278 TYPE_NEXT_VARIANT (new) = TYPE_MAIN_VARIANT (t
);
279 TYPE_NEXT_VARIANT (t
) = new;
283 TYPE_MAIN_VARIANT (new) = new;
284 TYPE_NEXT_VARIANT (new) = NULL
;
287 /* Lazily create pointer and reference types. */
288 TYPE_POINTER_TO (new) = NULL
;
289 TYPE_REFERENCE_TO (new) = NULL
;
291 switch (TREE_CODE (new))
298 t
= TYPE_MIN_VALUE (new);
299 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
300 walk_tree (&TYPE_MIN_VALUE (new), copy_body_r
, id
, NULL
);
302 t
= TYPE_MAX_VALUE (new);
303 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
304 walk_tree (&TYPE_MAX_VALUE (new), copy_body_r
, id
, NULL
);
308 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
309 walk_tree (&TYPE_ARG_TYPES (new), copy_body_r
, id
, NULL
);
313 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
314 TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id
);
319 case QUAL_UNION_TYPE
:
320 walk_tree (&TYPE_FIELDS (new), copy_body_r
, id
, NULL
);
327 /* Shouldn't have been thought variable sized. */
331 walk_tree (&TYPE_SIZE (new), copy_body_r
, id
, NULL
);
332 walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r
, id
, NULL
);
338 remap_decls (tree decls
, inline_data
*id
)
341 tree new_decls
= NULL_TREE
;
343 /* Remap its variables. */
344 for (old_var
= decls
; old_var
; old_var
= TREE_CHAIN (old_var
))
348 /* Remap the variable. */
349 new_var
= remap_decl (old_var
, id
);
351 /* If we didn't remap this variable, so we can't mess with its
352 TREE_CHAIN. If we remapped this variable to the return slot, it's
353 already declared somewhere else, so don't declare it here. */
354 if (!new_var
|| new_var
== id
->retvar
)
358 gcc_assert (DECL_P (new_var
));
359 TREE_CHAIN (new_var
) = new_decls
;
364 return nreverse (new_decls
);
367 /* Copy the BLOCK to contain remapped versions of the variables
368 therein. And hook the new block into the block-tree. */
371 remap_block (tree
*block
, inline_data
*id
)
377 /* Make the new block. */
379 new_block
= make_node (BLOCK
);
380 TREE_USED (new_block
) = TREE_USED (old_block
);
381 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
384 /* Remap its variables. */
385 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
), id
);
387 fn
= VARRAY_TREE (id
->fns
, 0);
389 /* FIXME! It shouldn't be so hard to manage blocks. Rebuilding them in
390 rest_of_compilation is a good start. */
392 /* We're building a clone; DECL_INITIAL is still
393 error_mark_node, and current_binding_level is the parm
395 lang_hooks
.decls
.insert_block (new_block
);
398 /* Attach this new block after the DECL_INITIAL block for the
399 function into which this block is being inlined. In
400 rest_of_compilation we will straighten out the BLOCK tree. */
402 if (DECL_INITIAL (fn
))
403 first_block
= &BLOCK_CHAIN (DECL_INITIAL (fn
));
405 first_block
= &DECL_INITIAL (fn
);
406 BLOCK_CHAIN (new_block
) = *first_block
;
407 *first_block
= new_block
;
410 /* Remember the remapped block. */
411 insert_decl_map (id
, old_block
, new_block
);
415 copy_statement_list (tree
*tp
)
417 tree_stmt_iterator oi
, ni
;
420 new = alloc_stmt_list ();
421 ni
= tsi_start (new);
422 oi
= tsi_start (*tp
);
425 for (; !tsi_end_p (oi
); tsi_next (&oi
))
426 tsi_link_after (&ni
, tsi_stmt (oi
), TSI_NEW_STMT
);
430 copy_bind_expr (tree
*tp
, int *walk_subtrees
, inline_data
*id
)
432 tree block
= BIND_EXPR_BLOCK (*tp
);
433 /* Copy (and replace) the statement. */
434 copy_tree_r (tp
, walk_subtrees
, NULL
);
437 remap_block (&block
, id
);
438 BIND_EXPR_BLOCK (*tp
) = block
;
441 if (BIND_EXPR_VARS (*tp
))
442 /* This will remap a lot of the same decls again, but this should be
444 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), id
);
447 /* Called from copy_body via walk_tree. DATA is really an `inline_data *'. */
450 copy_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
452 inline_data
*id
= (inline_data
*) data
;
453 tree fn
= VARRAY_TOP_TREE (id
->fns
);
456 /* All automatic variables should have a DECL_CONTEXT indicating
457 what function they come from. */
458 if ((TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == LABEL_DECL
)
459 && DECL_NAMESPACE_SCOPE_P (*tp
))
460 gcc_assert (DECL_EXTERNAL (*tp
) || TREE_STATIC (*tp
));
463 /* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
464 GOTO_EXPR with the RET_LABEL as its target. */
465 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->ret_label
)
467 tree return_stmt
= *tp
;
470 /* Build the GOTO_EXPR. */
471 tree assignment
= TREE_OPERAND (return_stmt
, 0);
472 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, id
->ret_label
);
473 TREE_USED (id
->ret_label
) = 1;
475 /* If we're returning something, just turn that into an
476 assignment into the equivalent of the original
480 /* Do not create a statement containing a naked RESULT_DECL. */
481 if (TREE_CODE (assignment
) == RESULT_DECL
)
482 gimplify_stmt (&assignment
);
484 *tp
= build (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
485 append_to_statement_list (assignment
, &BIND_EXPR_BODY (*tp
));
486 append_to_statement_list (goto_stmt
, &BIND_EXPR_BODY (*tp
));
488 /* If we're not returning anything just do the jump. */
492 /* Local variables and labels need to be replaced by equivalent
493 variables. We don't want to copy static variables; there's only
494 one of those, no matter how many times we inline the containing
495 function. Similarly for globals from an outer function. */
496 else if (lang_hooks
.tree_inlining
.auto_var_in_fn_p (*tp
, fn
))
500 /* Remap the declaration. */
501 new_decl
= remap_decl (*tp
, id
);
502 gcc_assert (new_decl
);
503 /* Replace this variable with the copy. */
504 STRIP_TYPE_NOPS (new_decl
);
507 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
508 copy_statement_list (tp
);
509 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
510 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
511 else if (TREE_CODE (*tp
) == BIND_EXPR
)
512 copy_bind_expr (tp
, walk_subtrees
, id
);
513 else if (TREE_CODE (*tp
) == LABELED_BLOCK_EXPR
)
515 /* We need a new copy of this labeled block; the EXIT_BLOCK_EXPR
516 will refer to it, so save a copy ready for remapping. We
517 save it in the decl_map, although it isn't a decl. */
518 tree new_block
= copy_node (*tp
);
519 insert_decl_map (id
, *tp
, new_block
);
522 else if (TREE_CODE (*tp
) == EXIT_BLOCK_EXPR
)
525 = splay_tree_lookup (id
->decl_map
,
526 (splay_tree_key
) TREE_OPERAND (*tp
, 0));
527 /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR. */
529 *tp
= copy_node (*tp
);
530 TREE_OPERAND (*tp
, 0) = (tree
) n
->value
;
532 /* Types may need remapping as well. */
533 else if (TYPE_P (*tp
))
534 *tp
= remap_type (*tp
, id
);
536 /* Otherwise, just copy the node. Note that copy_tree_r already
537 knows not to copy VAR_DECLs, etc., so this is safe. */
542 if (TREE_CODE (*tp
) == MODIFY_EXPR
543 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
544 && (lang_hooks
.tree_inlining
.auto_var_in_fn_p
545 (TREE_OPERAND (*tp
, 0), fn
)))
547 /* Some assignments VAR = VAR; don't generate any rtl code
548 and thus don't count as variable modification. Avoid
549 keeping bogosities like 0 = 0. */
550 tree decl
= TREE_OPERAND (*tp
, 0), value
;
553 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
556 value
= (tree
) n
->value
;
557 STRIP_TYPE_NOPS (value
);
558 if (TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
561 return copy_body_r (tp
, walk_subtrees
, data
);
565 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
567 /* Get rid of *& from inline substitutions that can happen when a
568 pointer argument is an ADDR_EXPR. */
569 tree decl
= TREE_OPERAND (*tp
, 0), value
;
572 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
575 value
= (tree
) n
->value
;
577 if (TREE_CODE (value
) == ADDR_EXPR
578 && (lang_hooks
.types_compatible_p
579 (TREE_TYPE (*tp
), TREE_TYPE (TREE_OPERAND (value
, 0)))))
581 *tp
= TREE_OPERAND (value
, 0);
582 return copy_body_r (tp
, walk_subtrees
, data
);
587 copy_tree_r (tp
, walk_subtrees
, NULL
);
589 if (TREE_CODE (*tp
) == CALL_EXPR
&& id
->node
&& get_callee_fndecl (*tp
))
593 struct cgraph_node
*node
;
594 struct cgraph_edge
*edge
;
596 for (node
= id
->node
->next_clone
; node
; node
= node
->next_clone
)
598 edge
= cgraph_edge (node
, old_node
);
600 edge
->call_expr
= *tp
;
605 struct cgraph_edge
*edge
606 = cgraph_edge (id
->current_node
, old_node
);
609 cgraph_clone_edge (edge
, id
->node
, *tp
);
613 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
615 /* The copied TARGET_EXPR has never been expanded, even if the
616 original node was expanded already. */
617 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
619 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
620 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
623 /* Variable substitution need not be simple. In particular, the
624 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
625 and friends are up-to-date. */
626 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
628 walk_tree (&TREE_OPERAND (*tp
, 0), copy_body_r
, id
, NULL
);
629 recompute_tree_invarant_for_addr_expr (*tp
);
634 /* Keep iterating. */
638 /* Make a copy of the body of FN so that it can be inserted inline in
642 copy_body (inline_data
*id
)
645 tree fndecl
= VARRAY_TOP_TREE (id
->fns
);
647 if (fndecl
== current_function_decl
649 body
= cfun
->saved_tree
;
651 body
= DECL_SAVED_TREE (fndecl
);
652 walk_tree (&body
, copy_body_r
, id
, NULL
);
658 setup_one_parameter (inline_data
*id
, tree p
, tree value
, tree fn
,
659 tree
*init_stmts
, tree
*vars
, bool *gimplify_init_stmts_p
)
664 /* If the parameter is never assigned to, we may not need to
665 create a new variable here at all. Instead, we may be able
666 to just use the argument value. */
667 if (TREE_READONLY (p
)
668 && !TREE_ADDRESSABLE (p
)
669 && value
&& !TREE_SIDE_EFFECTS (value
))
671 /* We can't risk substituting complex expressions. They
672 might contain variables that will be assigned to later.
673 Theoretically, we could check the expression to see if
674 all of the variables that determine its value are
675 read-only, but we don't bother. */
676 /* We may produce non-gimple trees by adding NOPs or introduce
677 invalid sharing when operand is not really constant.
678 It is not big deal to prohibit constant propagation here as
679 we will constant propagate in DOM1 pass anyway. */
680 if (is_gimple_min_invariant (value
)
681 && lang_hooks
.types_compatible_p (TREE_TYPE (value
), TREE_TYPE (p
)))
683 insert_decl_map (id
, p
, value
);
688 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
689 here since the type of this decl must be visible to the calling
691 var
= copy_decl_for_inlining (p
, fn
, VARRAY_TREE (id
->fns
, 0));
693 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
694 that way, when the PARM_DECL is encountered, it will be
695 automatically replaced by the VAR_DECL. */
696 insert_decl_map (id
, p
, var
);
698 /* Declare this new variable. */
699 TREE_CHAIN (var
) = *vars
;
702 /* Make gimplifier happy about this variable. */
703 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
705 /* Even if P was TREE_READONLY, the new VAR should not be.
706 In the original code, we would have constructed a
707 temporary, and then the function body would have never
708 changed the value of P. However, now, we will be
709 constructing VAR directly. The constructor body may
710 change its value multiple times as it is being
711 constructed. Therefore, it must not be TREE_READONLY;
712 the back-end assumes that TREE_READONLY variable is
713 assigned to only once. */
714 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
715 TREE_READONLY (var
) = 0;
717 /* Initialize this VAR_DECL from the equivalent argument. Convert
718 the argument to the proper type in case it was promoted. */
721 tree rhs
= fold_convert (TREE_TYPE (var
), value
);
723 if (rhs
== error_mark_node
)
726 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
727 keep our trees in gimple form. */
728 init_stmt
= build (MODIFY_EXPR
, TREE_TYPE (var
), var
, rhs
);
729 append_to_statement_list (init_stmt
, init_stmts
);
731 /* If we did not create a gimple value and we did not create a gimple
732 cast of a gimple value, then we will need to gimplify INIT_STMTS
733 at the end. Note that is_gimple_cast only checks the outer
734 tree code, not its operand. Thus the explicit check that it's
735 operand is a gimple value. */
736 if (!is_gimple_val (rhs
)
737 && (!is_gimple_cast (rhs
)
738 || !is_gimple_val (TREE_OPERAND (rhs
, 0))))
739 *gimplify_init_stmts_p
= true;
743 /* Generate code to initialize the parameters of the function at the
744 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
747 initialize_inlined_parameters (inline_data
*id
, tree args
, tree static_chain
,
748 tree fn
, tree bind_expr
)
750 tree init_stmts
= NULL_TREE
;
754 tree vars
= NULL_TREE
;
755 bool gimplify_init_stmts_p
= false;
758 /* Figure out what the parameters are. */
759 parms
= DECL_ARGUMENTS (fn
);
760 if (fn
== current_function_decl
)
761 parms
= cfun
->saved_args
;
763 /* Loop through the parameter declarations, replacing each with an
764 equivalent VAR_DECL, appropriately initialized. */
765 for (p
= parms
, a
= args
; p
;
766 a
= a
? TREE_CHAIN (a
) : a
, p
= TREE_CHAIN (p
))
772 /* Find the initializer. */
773 value
= lang_hooks
.tree_inlining
.convert_parm_for_inlining
774 (p
, a
? TREE_VALUE (a
) : NULL_TREE
, fn
, argnum
);
776 setup_one_parameter (id
, p
, value
, fn
, &init_stmts
, &vars
,
777 &gimplify_init_stmts_p
);
780 /* Evaluate trailing arguments. */
781 for (; a
; a
= TREE_CHAIN (a
))
783 tree value
= TREE_VALUE (a
);
784 append_to_statement_list (value
, &init_stmts
);
787 /* Initialize the static chain. */
788 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
791 /* No static chain? Seems like a bug in tree-nested.c. */
792 gcc_assert (static_chain
);
794 setup_one_parameter (id
, p
, static_chain
, fn
, &init_stmts
, &vars
,
795 &gimplify_init_stmts_p
);
798 if (gimplify_init_stmts_p
)
799 gimplify_body (&init_stmts
, current_function_decl
);
801 declare_inline_vars (bind_expr
, vars
);
805 /* Declare a return variable to replace the RESULT_DECL for the function we
806 are calling. RETURN_SLOT_ADDR, if non-null, was a fake parameter that
807 took the address of the result. MODIFY_DEST, if non-null, was the LHS of
808 the MODIFY_EXPR to which this call is the RHS.
810 The return value is a (possibly null) value that is the result of the
811 function as seen by the callee. *USE_P is a (possibly null) value that
812 holds the result as seen by the caller. */
815 declare_return_variable (inline_data
*id
, tree return_slot_addr
,
816 tree modify_dest
, tree
*use_p
)
818 tree callee
= VARRAY_TOP_TREE (id
->fns
);
819 tree caller
= VARRAY_TREE (id
->fns
, 0);
820 tree result
= DECL_RESULT (callee
);
821 tree callee_type
= TREE_TYPE (result
);
822 tree caller_type
= TREE_TYPE (TREE_TYPE (callee
));
825 /* We don't need to do anything for functions that don't return
827 if (!result
|| VOID_TYPE_P (callee_type
))
833 /* If there was a return slot, then the return value is the
834 dereferenced address of that object. */
835 if (return_slot_addr
)
837 /* The front end shouldn't have used both return_slot_addr and
838 a modify expression. */
839 gcc_assert (!modify_dest
);
840 if (DECL_BY_REFERENCE (result
))
841 var
= return_slot_addr
;
843 var
= build_fold_indirect_ref (return_slot_addr
);
848 /* All types requiring non-trivial constructors should have been handled. */
849 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
851 /* Attempt to avoid creating a new temporary variable. */
856 /* We can't use MODIFY_DEST if there's type promotion involved. */
857 if (!lang_hooks
.types_compatible_p (caller_type
, callee_type
))
860 /* ??? If we're assigning to a variable sized type, then we must
861 reuse the destination variable, because we've no good way to
862 create variable sized temporaries at this point. */
863 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
866 /* If the callee cannot possibly modify MODIFY_DEST, then we can
867 reuse it as the result of the call directly. Don't do this if
868 it would promote MODIFY_DEST to addressable. */
869 else if (!TREE_STATIC (modify_dest
)
870 && !TREE_ADDRESSABLE (modify_dest
)
871 && !TREE_ADDRESSABLE (result
))
882 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
884 var
= copy_decl_for_inlining (result
, callee
, caller
);
885 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
886 DECL_STRUCT_FUNCTION (caller
)->unexpanded_var_list
887 = tree_cons (NULL_TREE
, var
,
888 DECL_STRUCT_FUNCTION (caller
)->unexpanded_var_list
);
890 /* Do not have the rest of GCC warn about this variable as it should
891 not be visible to the user. */
892 TREE_NO_WARNING (var
) = 1;
894 /* Build the use expr. If the return type of the function was
895 promoted, convert it back to the expected type. */
897 if (!lang_hooks
.types_compatible_p (TREE_TYPE (var
), caller_type
))
898 use
= fold_convert (caller_type
, var
);
901 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
902 way, when the RESULT_DECL is encountered, it will be
903 automatically replaced by the VAR_DECL. */
904 insert_decl_map (id
, result
, var
);
906 /* Remember this so we can ignore it in remap_decls. */
913 /* Returns nonzero if a function can be inlined as a tree. */
916 tree_inlinable_function_p (tree fn
)
918 return inlinable_function_p (fn
);
921 static const char *inline_forbidden_reason
;
924 inline_forbidden_p_1 (tree
*nodep
, int *walk_subtrees ATTRIBUTE_UNUSED
,
928 tree fn
= (tree
) fnp
;
931 switch (TREE_CODE (node
))
934 /* Refuse to inline alloca call unless user explicitly forced so as
935 this may change program's memory overhead drastically when the
936 function using alloca is called in loop. In GCC present in
937 SPEC2000 inlining into schedule_block cause it to require 2GB of
938 RAM instead of 256MB. */
939 if (alloca_call_p (node
)
940 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
942 inline_forbidden_reason
943 = N_("%Jfunction '%F' can never be inlined because it uses "
944 "alloca (override using the always_inline attribute)");
947 t
= get_callee_fndecl (node
);
951 /* We cannot inline functions that call setjmp. */
952 if (setjmp_call_p (t
))
954 inline_forbidden_reason
955 = N_("%Jfunction '%F' can never be inlined because it uses setjmp");
959 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
960 switch (DECL_FUNCTION_CODE (t
))
962 /* We cannot inline functions that take a variable number of
964 case BUILT_IN_VA_START
:
965 case BUILT_IN_STDARG_START
:
966 case BUILT_IN_NEXT_ARG
:
967 case BUILT_IN_VA_END
:
968 inline_forbidden_reason
969 = N_("%Jfunction '%F' can never be inlined because it "
970 "uses variable argument lists");
973 case BUILT_IN_LONGJMP
:
974 /* We can't inline functions that call __builtin_longjmp at
975 all. The non-local goto machinery really requires the
976 destination be in a different function. If we allow the
977 function calling __builtin_longjmp to be inlined into the
978 function calling __builtin_setjmp, Things will Go Awry. */
979 inline_forbidden_reason
980 = N_("%Jfunction '%F' can never be inlined because "
981 "it uses setjmp-longjmp exception handling");
984 case BUILT_IN_NONLOCAL_GOTO
:
986 inline_forbidden_reason
987 = N_("%Jfunction '%F' can never be inlined because "
988 "it uses non-local goto");
997 for (t
= BIND_EXPR_VARS (node
); t
; t
= TREE_CHAIN (t
))
999 /* We cannot inline functions that contain other functions. */
1000 if (TREE_CODE (t
) == FUNCTION_DECL
&& DECL_INITIAL (t
))
1002 inline_forbidden_reason
1003 = N_("%Jfunction '%F' can never be inlined "
1004 "because it contains a nested function");
1011 t
= TREE_OPERAND (node
, 0);
1013 /* We will not inline a function which uses computed goto. The
1014 addresses of its local labels, which may be tucked into
1015 global storage, are of course not constant across
1016 instantiations, which causes unexpected behavior. */
1017 if (TREE_CODE (t
) != LABEL_DECL
)
1019 inline_forbidden_reason
1020 = N_("%Jfunction '%F' can never be inlined "
1021 "because it contains a computed goto");
1027 t
= TREE_OPERAND (node
, 0);
1028 if (DECL_NONLOCAL (t
))
1030 /* We cannot inline a function that receives a non-local goto
1031 because we cannot remap the destination label used in the
1032 function that is performing the non-local goto. */
1033 inline_forbidden_reason
1034 = N_("%Jfunction '%F' can never be inlined "
1035 "because it receives a non-local goto");
1042 /* We cannot inline a function of the form
1044 void F (int i) { struct S { int ar[i]; } s; }
1046 Attempting to do so produces a catch-22.
1047 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1048 UNION_TYPE nodes, then it goes into infinite recursion on a
1049 structure containing a pointer to its own type. If it doesn't,
1050 then the type node for S doesn't get adjusted properly when
1051 F is inlined, and we abort in find_function_data. */
1052 for (t
= TYPE_FIELDS (node
); t
; t
= TREE_CHAIN (t
))
1053 if (variably_modified_type_p (TREE_TYPE (t
), NULL
))
1055 inline_forbidden_reason
1056 = N_("%Jfunction '%F' can never be inlined "
1057 "because it uses variable sized variables");
1068 /* Return subexpression representing possible alloca call, if any. */
1070 inline_forbidden_p (tree fndecl
)
1072 location_t saved_loc
= input_location
;
1073 tree ret
= walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl
),
1074 inline_forbidden_p_1
, fndecl
);
1076 input_location
= saved_loc
;
1080 /* Returns nonzero if FN is a function that does not have any
1081 fundamental inline blocking properties. */
1084 inlinable_function_p (tree fn
)
1086 bool inlinable
= true;
1088 /* If we've already decided this function shouldn't be inlined,
1089 there's no need to check again. */
1090 if (DECL_UNINLINABLE (fn
))
1093 /* See if there is any language-specific reason it cannot be
1094 inlined. (It is important that this hook be called early because
1095 in C++ it may result in template instantiation.)
1096 If the function is not inlinable for language-specific reasons,
1097 it is left up to the langhook to explain why. */
1098 inlinable
= !lang_hooks
.tree_inlining
.cannot_inline_tree_fn (&fn
);
1100 /* If we don't have the function body available, we can't inline it.
1101 However, this should not be recorded since we also get here for
1102 forward declared inline functions. Therefore, return at once. */
1103 if (!DECL_SAVED_TREE (fn
))
1106 /* If we're not inlining at all, then we cannot inline this function. */
1107 else if (!flag_inline_trees
)
1110 /* Only try to inline functions if DECL_INLINE is set. This should be
1111 true for all functions declared `inline', and for all other functions
1112 as well with -finline-functions.
1114 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1115 it's the front-end that must set DECL_INLINE in this case, because
1116 dwarf2out loses if a function that does not have DECL_INLINE set is
1117 inlined anyway. That is why we have both DECL_INLINE and
1118 DECL_DECLARED_INLINE_P. */
1119 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1120 here should be redundant. */
1121 else if (!DECL_INLINE (fn
) && !flag_unit_at_a_time
)
1124 else if (inline_forbidden_p (fn
))
1126 /* See if we should warn about uninlinable functions. Previously,
1127 some of these warnings would be issued while trying to expand
1128 the function inline, but that would cause multiple warnings
1129 about functions that would for example call alloca. But since
1130 this a property of the function, just one warning is enough.
1131 As a bonus we can now give more details about the reason why a
1132 function is not inlinable.
1133 We only warn for functions declared `inline' by the user. */
1134 bool do_warning
= (warn_inline
1136 && DECL_DECLARED_INLINE_P (fn
)
1137 && !DECL_IN_SYSTEM_HEADER (fn
));
1139 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1140 sorry (inline_forbidden_reason
, fn
, fn
);
1141 else if (do_warning
)
1142 warning (inline_forbidden_reason
, fn
, fn
);
1147 /* Squirrel away the result so that we don't have to check again. */
1148 DECL_UNINLINABLE (fn
) = !inlinable
;
1153 /* Used by estimate_num_insns. Estimate number of instructions seen
1154 by given statement. */
1157 estimate_num_insns_1 (tree
*tp
, int *walk_subtrees
, void *data
)
1162 if (IS_TYPE_OR_DECL_P (x
))
1167 /* Assume that constants and references counts nothing. These should
1168 be majorized by amount of operations among them we count later
1169 and are common target of CSE and similar optimizations. */
1170 else if (CONSTANT_CLASS_P (x
) || REFERENCE_CLASS_P (x
))
1173 switch (TREE_CODE (x
))
1175 /* Containers have no cost. */
1183 case ARRAY_RANGE_REF
:
1185 case EXC_PTR_EXPR
: /* ??? */
1186 case FILTER_EXPR
: /* ??? */
1189 case LABELED_BLOCK_EXPR
:
1190 case WITH_CLEANUP_EXPR
:
1192 case VIEW_CONVERT_EXPR
:
1196 case EXIT_BLOCK_EXPR
:
1197 case CASE_LABEL_EXPR
:
1200 case EH_FILTER_EXPR
:
1201 case STATEMENT_LIST
:
1203 case NON_LVALUE_EXPR
:
1206 case TRY_CATCH_EXPR
:
1207 case TRY_FINALLY_EXPR
:
1214 case WITH_SIZE_EXPR
:
1217 /* We don't account constants for now. Assume that the cost is amortized
1218 by operations that do use them. We may re-consider this decision once
1219 we are able to optimize the tree before estimating it's size and break
1220 out static initializers. */
1221 case IDENTIFIER_NODE
:
1230 /* Recognize assignments of large structures and constructors of
1234 x
= TREE_OPERAND (x
, 0);
1241 size
= int_size_in_bytes (TREE_TYPE (x
));
1243 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO
)
1246 *count
+= ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
1250 /* Assign cost of 1 to usual operations.
1251 ??? We may consider mapping RTL costs to this. */
1258 case FIX_TRUNC_EXPR
:
1260 case FIX_FLOOR_EXPR
:
1261 case FIX_ROUND_EXPR
:
1279 case TRUTH_ANDIF_EXPR
:
1280 case TRUTH_ORIF_EXPR
:
1281 case TRUTH_AND_EXPR
:
1283 case TRUTH_XOR_EXPR
:
1284 case TRUTH_NOT_EXPR
:
1293 case UNORDERED_EXPR
:
1306 case PREDECREMENT_EXPR
:
1307 case PREINCREMENT_EXPR
:
1308 case POSTDECREMENT_EXPR
:
1309 case POSTINCREMENT_EXPR
:
1319 /* Few special cases of expensive operations. This is useful
1320 to avoid inlining on functions having too many of these. */
1321 case TRUNC_DIV_EXPR
:
1323 case FLOOR_DIV_EXPR
:
1324 case ROUND_DIV_EXPR
:
1325 case EXACT_DIV_EXPR
:
1326 case TRUNC_MOD_EXPR
:
1328 case FLOOR_MOD_EXPR
:
1329 case ROUND_MOD_EXPR
:
1335 tree decl
= get_callee_fndecl (x
);
1337 if (decl
&& DECL_BUILT_IN (decl
))
1338 switch (DECL_FUNCTION_CODE (decl
))
1340 case BUILT_IN_CONSTANT_P
:
1343 case BUILT_IN_EXPECT
:
1352 /* Abort here se we know we don't miss any nodes. */
1358 /* Estimate number of instructions that will be created by expanding EXPR. */
1361 estimate_num_insns (tree expr
)
1364 walk_tree_without_duplicates (&expr
, estimate_num_insns_1
, &num
);
1368 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1371 expand_call_inline (tree
*tp
, int *walk_subtrees
, void *data
)
1384 tree return_slot_addr
;
1386 location_t saved_location
;
1387 struct cgraph_edge
*edge
;
1390 /* See what we've got. */
1391 id
= (inline_data
*) data
;
1394 /* Set input_location here so we get the right instantiation context
1395 if we call instantiate_decl from inlinable_function_p. */
1396 saved_location
= input_location
;
1397 if (EXPR_HAS_LOCATION (t
))
1398 input_location
= EXPR_LOCATION (t
);
1400 /* Recurse, but letting recursive invocations know that we are
1401 inside the body of a TARGET_EXPR. */
1402 if (TREE_CODE (*tp
) == TARGET_EXPR
)
1405 int i
, len
= first_rtl_op (TARGET_EXPR
);
1407 /* We're walking our own subtrees. */
1410 /* Actually walk over them. This loop is the body of
1411 walk_trees, omitting the case where the TARGET_EXPR
1412 itself is handled. */
1413 for (i
= 0; i
< len
; ++i
)
1416 ++id
->in_target_cleanup_p
;
1417 walk_tree (&TREE_OPERAND (*tp
, i
), expand_call_inline
, data
,
1420 --id
->in_target_cleanup_p
;
1428 /* Because types were not copied in copy_body, CALL_EXPRs beneath
1429 them should not be expanded. This can happen if the type is a
1430 dynamic array type, for example. */
1433 /* From here on, we're only interested in CALL_EXPRs. */
1434 if (TREE_CODE (t
) != CALL_EXPR
)
1437 /* First, see if we can figure out what function is being called.
1438 If we cannot, then there is no hope of inlining the function. */
1439 fn
= get_callee_fndecl (t
);
1443 /* Turn forward declarations into real ones. */
1444 fn
= cgraph_node (fn
)->decl
;
1446 /* If fn is a declaration of a function in a nested scope that was
1447 globally declared inline, we don't set its DECL_INITIAL.
1448 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1449 C++ front-end uses it for cdtors to refer to their internal
1450 declarations, that are not real functions. Fortunately those
1451 don't have trees to be saved, so we can tell by checking their
1453 if (! DECL_INITIAL (fn
)
1454 && DECL_ABSTRACT_ORIGIN (fn
)
1455 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn
)))
1456 fn
= DECL_ABSTRACT_ORIGIN (fn
);
1458 /* Objective C and fortran still calls tree_rest_of_compilation directly.
1459 Kill this check once this is fixed. */
1460 if (!id
->current_node
->analyzed
)
1463 edge
= cgraph_edge (id
->current_node
, t
);
1465 /* Constant propagation on argument done during previous inlining
1466 may create new direct call. Produce an edge for it. */
1469 struct cgraph_node
*dest
= cgraph_node (fn
);
1471 /* We have missing edge in the callgraph. This can happen in one case
1472 where previous inlining turned indirect call into direct call by
1473 constant propagating arguments. In all other cases we hit a bug
1474 (incorrect node sharing is most common reason for missing edges. */
1475 gcc_assert (dest
->needed
|| flag_unit_at_a_time
);
1476 cgraph_create_edge (id
->node
, dest
, t
)->inline_failed
1477 = N_("originally indirect function call not considered for inlining");
1481 /* Don't try to inline functions that are not well-suited to
1483 if (!cgraph_inline_p (edge
, &reason
))
1485 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1487 sorry ("%Jinlining failed in call to '%F': %s", fn
, fn
, reason
);
1488 sorry ("called from here");
1490 else if (warn_inline
&& DECL_DECLARED_INLINE_P (fn
)
1491 && !DECL_IN_SYSTEM_HEADER (fn
)
1494 warning ("%Jinlining failed in call to '%F': %s", fn
, fn
, reason
);
1495 warning ("called from here");
1500 #ifdef ENABLE_CHECKING
1501 if (edge
->callee
->decl
!= id
->node
->decl
)
1502 verify_cgraph_node (edge
->callee
);
1505 if (! lang_hooks
.tree_inlining
.start_inlining (fn
))
1508 /* Build a block containing code to initialize the arguments, the
1509 actual inline expansion of the body, and a label for the return
1510 statements within the function to jump to. The type of the
1511 statement expression is the return type of the function call. */
1513 expr
= build (BIND_EXPR
, void_type_node
, NULL_TREE
,
1514 stmt
, make_node (BLOCK
));
1515 BLOCK_ABSTRACT_ORIGIN (BIND_EXPR_BLOCK (expr
)) = fn
;
1517 /* Local declarations will be replaced by their equivalents in this
1520 id
->decl_map
= splay_tree_new (splay_tree_compare_pointers
,
1523 /* Initialize the parameters. */
1524 args
= TREE_OPERAND (t
, 1);
1525 return_slot_addr
= NULL_TREE
;
1526 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t
))
1528 return_slot_addr
= TREE_VALUE (args
);
1529 args
= TREE_CHAIN (args
);
1530 TREE_TYPE (expr
) = void_type_node
;
1533 arg_inits
= initialize_inlined_parameters (id
, args
, TREE_OPERAND (t
, 2),
1537 /* Expand any inlined calls in the initializers. Do this before we
1538 push FN on the stack of functions we are inlining; we want to
1539 inline calls to FN that appear in the initializers for the
1542 Note we need to save and restore the saved tree statement iterator
1543 to avoid having it clobbered by expand_calls_inline. */
1544 tree_stmt_iterator save_tsi
;
1547 expand_calls_inline (&arg_inits
, id
);
1550 /* And add them to the tree. */
1551 append_to_statement_list (arg_inits
, &BIND_EXPR_BODY (expr
));
1554 /* Record the function we are about to inline so that we can avoid
1555 recursing into it. */
1556 VARRAY_PUSH_TREE (id
->fns
, fn
);
1558 /* Record the function we are about to inline if optimize_function
1559 has not been called on it yet and we don't have it in the list. */
1560 if (! DECL_INLINED_FNS (fn
))
1564 for (i
= VARRAY_ACTIVE_SIZE (id
->inlined_fns
) - 1; i
>= 0; i
--)
1565 if (VARRAY_TREE (id
->inlined_fns
, i
) == fn
)
1568 VARRAY_PUSH_TREE (id
->inlined_fns
, fn
);
1571 /* Return statements in the function body will be replaced by jumps
1572 to the RET_LABEL. */
1573 id
->ret_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
1574 DECL_ARTIFICIAL (id
->ret_label
) = 1;
1575 DECL_CONTEXT (id
->ret_label
) = VARRAY_TREE (id
->fns
, 0);
1576 insert_decl_map (id
, id
->ret_label
, id
->ret_label
);
1578 gcc_assert (DECL_INITIAL (fn
));
1579 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
1581 /* Find the lhs to which the result of this call is assigned. */
1582 modify_dest
= tsi_stmt (id
->tsi
);
1583 if (TREE_CODE (modify_dest
) == MODIFY_EXPR
)
1584 modify_dest
= TREE_OPERAND (modify_dest
, 0);
1588 /* Declare the return variable for the function. */
1589 decl
= declare_return_variable (id
, return_slot_addr
,
1590 modify_dest
, &use_retvar
);
1592 /* After we've initialized the parameters, we insert the body of the
1595 struct cgraph_node
*old_node
= id
->current_node
;
1597 id
->current_node
= edge
->callee
;
1598 append_to_statement_list (copy_body (id
), &BIND_EXPR_BODY (expr
));
1599 id
->current_node
= old_node
;
1601 inlined_body
= &BIND_EXPR_BODY (expr
);
1603 /* After the body of the function comes the RET_LABEL. This must come
1604 before we evaluate the returned value below, because that evaluation
1605 may cause RTL to be generated. */
1606 if (TREE_USED (id
->ret_label
))
1608 tree label
= build1 (LABEL_EXPR
, void_type_node
, id
->ret_label
);
1609 append_to_statement_list (label
, &BIND_EXPR_BODY (expr
));
1613 splay_tree_delete (id
->decl_map
);
1616 /* The new expression has side-effects if the old one did. */
1617 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (t
);
1619 tsi_link_before (&id
->tsi
, expr
, TSI_SAME_STMT
);
1621 /* If the inlined function returns a result that we care about,
1622 then we're going to need to splice in a MODIFY_EXPR. Otherwise
1623 the call was a standalone statement and we can just replace it
1624 with the BIND_EXPR inline representation of the called function. */
1625 if (!use_retvar
|| !modify_dest
)
1626 *tsi_stmt_ptr (id
->tsi
) = build_empty_stmt ();
1630 /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS on
1631 the call if it is to a "const" function. Thus the copy of
1632 TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above with
1633 result in TREE_SIDE_EFFECTS not being set for the inlined copy of a
1636 Unfortunately, that is wrong as inlining the function can create/expose
1637 interesting side effects (such as setting of a return value).
1639 The easiest solution is to simply recalculate TREE_SIDE_EFFECTS for
1640 the toplevel expression. */
1641 recalculate_side_effects (expr
);
1643 /* Update callgraph if needed. */
1644 cgraph_remove_node (edge
->callee
);
1646 /* Recurse into the body of the just inlined function. */
1647 expand_calls_inline (inlined_body
, id
);
1648 VARRAY_POP (id
->fns
);
1650 /* Don't walk into subtrees. We've already handled them above. */
1653 lang_hooks
.tree_inlining
.end_inlining (fn
);
1655 /* Keep iterating. */
1657 input_location
= saved_location
;
1662 expand_calls_inline (tree
*stmt_p
, inline_data
*id
)
1664 tree stmt
= *stmt_p
;
1665 enum tree_code code
= TREE_CODE (stmt
);
1670 case STATEMENT_LIST
:
1672 tree_stmt_iterator i
;
1675 for (i
= tsi_start (stmt
); !tsi_end_p (i
); )
1678 expand_calls_inline (tsi_stmt_ptr (i
), id
);
1681 if (TREE_CODE (new) == STATEMENT_LIST
)
1683 tsi_link_before (&i
, new, TSI_SAME_STMT
);
1693 expand_calls_inline (&COND_EXPR_THEN (stmt
), id
);
1694 expand_calls_inline (&COND_EXPR_ELSE (stmt
), id
);
1698 expand_calls_inline (&CATCH_BODY (stmt
), id
);
1701 case EH_FILTER_EXPR
:
1702 expand_calls_inline (&EH_FILTER_FAILURE (stmt
), id
);
1705 case TRY_CATCH_EXPR
:
1706 case TRY_FINALLY_EXPR
:
1707 expand_calls_inline (&TREE_OPERAND (stmt
, 0), id
);
1708 expand_calls_inline (&TREE_OPERAND (stmt
, 1), id
);
1712 expand_calls_inline (&BIND_EXPR_BODY (stmt
), id
);
1716 /* We're gimple. We should have gotten rid of all these. */
1720 stmt_p
= &TREE_OPERAND (stmt
, 0);
1722 if (!stmt
|| TREE_CODE (stmt
) != MODIFY_EXPR
)
1728 stmt_p
= &TREE_OPERAND (stmt
, 1);
1730 if (TREE_CODE (stmt
) == WITH_SIZE_EXPR
)
1732 stmt_p
= &TREE_OPERAND (stmt
, 0);
1735 if (TREE_CODE (stmt
) != CALL_EXPR
)
1741 expand_call_inline (stmt_p
, &dummy
, id
);
1749 /* Expand calls to inline functions in the body of FN. */
1752 optimize_inline_calls (tree fn
)
1758 /* There is no point in performing inlining if errors have already
1759 occurred -- and we might crash if we try to inline invalid
1761 if (errorcount
|| sorrycount
)
1765 memset (&id
, 0, sizeof (id
));
1767 id
.current_node
= id
.node
= cgraph_node (fn
);
1768 /* Don't allow recursion into FN. */
1769 VARRAY_TREE_INIT (id
.fns
, 32, "fns");
1770 VARRAY_PUSH_TREE (id
.fns
, fn
);
1771 /* Or any functions that aren't finished yet. */
1772 prev_fn
= NULL_TREE
;
1773 if (current_function_decl
)
1775 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
1776 prev_fn
= current_function_decl
;
1779 prev_fn
= lang_hooks
.tree_inlining
.add_pending_fn_decls (&id
.fns
, prev_fn
);
1781 /* Create the list of functions this call will inline. */
1782 VARRAY_TREE_INIT (id
.inlined_fns
, 32, "inlined_fns");
1784 /* Keep track of the low-water mark, i.e., the point where the first
1785 real inlining is represented in ID.FNS. */
1786 id
.first_inlined_fn
= VARRAY_ACTIVE_SIZE (id
.fns
);
1788 /* Replace all calls to inline functions with the bodies of those
1790 id
.tree_pruner
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1791 expand_calls_inline (&DECL_SAVED_TREE (fn
), &id
);
1794 htab_delete (id
.tree_pruner
);
1795 ifn
= make_tree_vec (VARRAY_ACTIVE_SIZE (id
.inlined_fns
));
1796 if (VARRAY_ACTIVE_SIZE (id
.inlined_fns
))
1797 memcpy (&TREE_VEC_ELT (ifn
, 0), &VARRAY_TREE (id
.inlined_fns
, 0),
1798 VARRAY_ACTIVE_SIZE (id
.inlined_fns
) * sizeof (tree
));
1799 DECL_INLINED_FNS (fn
) = ifn
;
1801 #ifdef ENABLE_CHECKING
1803 struct cgraph_edge
*e
;
1805 verify_cgraph_node (id
.node
);
1807 /* Double check that we inlined everything we are supposed to inline. */
1808 for (e
= id
.node
->callees
; e
; e
= e
->next_callee
)
1809 gcc_assert (e
->inline_failed
);
1814 /* FN is a function that has a complete body, and CLONE is a function whose
1815 body is to be set to a copy of FN, mapping argument declarations according
1816 to the ARG_MAP splay_tree. */
1819 clone_body (tree clone
, tree fn
, void *arg_map
)
1823 /* Clone the body, as if we were making an inline call. But, remap the
1824 parameters in the callee to the parameters of caller. If there's an
1825 in-charge parameter, map it to an appropriate constant. */
1826 memset (&id
, 0, sizeof (id
));
1827 VARRAY_TREE_INIT (id
.fns
, 2, "fns");
1828 VARRAY_PUSH_TREE (id
.fns
, clone
);
1829 VARRAY_PUSH_TREE (id
.fns
, fn
);
1830 id
.decl_map
= (splay_tree
)arg_map
;
1832 /* Cloning is treated slightly differently from inlining. Set
1833 CLONING_P so that it's clear which operation we're performing. */
1834 id
.cloning_p
= true;
1836 /* Actually copy the body. */
1837 append_to_statement_list_force (copy_body (&id
), &DECL_SAVED_TREE (clone
));
1840 /* Make and return duplicate of body in FN. Put copies of DECL_ARGUMENTS
1841 in *arg_copy and of the static chain, if any, in *sc_copy. */
1844 save_body (tree fn
, tree
*arg_copy
, tree
*sc_copy
)
1849 memset (&id
, 0, sizeof (id
));
1850 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
1851 VARRAY_PUSH_TREE (id
.fns
, fn
);
1852 id
.node
= cgraph_node (fn
);
1854 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
1855 *arg_copy
= DECL_ARGUMENTS (fn
);
1857 for (parg
= arg_copy
; *parg
; parg
= &TREE_CHAIN (*parg
))
1859 tree
new = copy_node (*parg
);
1861 lang_hooks
.dup_lang_specific_decl (new);
1862 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg
);
1863 insert_decl_map (&id
, *parg
, new);
1864 TREE_CHAIN (new) = TREE_CHAIN (*parg
);
1868 *sc_copy
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
1871 tree
new = copy_node (*sc_copy
);
1873 lang_hooks
.dup_lang_specific_decl (new);
1874 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*sc_copy
);
1875 insert_decl_map (&id
, *sc_copy
, new);
1876 TREE_CHAIN (new) = TREE_CHAIN (*sc_copy
);
1880 insert_decl_map (&id
, DECL_RESULT (fn
), DECL_RESULT (fn
));
1882 /* Actually copy the body. */
1883 body
= copy_body (&id
);
1886 splay_tree_delete (id
.decl_map
);
1890 #define WALK_SUBTREE(NODE) \
1893 result = walk_tree (&(NODE), func, data, htab); \
1899 /* This is a subroutine of walk_tree that walks field of TYPE that are to
1900 be walked whenever a type is seen in the tree. Rest of operands and return
1901 value are as for walk_tree. */
1904 walk_type_fields (tree type
, walk_tree_fn func
, void *data
, void *htab
)
1906 tree result
= NULL_TREE
;
1908 switch (TREE_CODE (type
))
1911 case REFERENCE_TYPE
:
1912 /* We have to worry about mutually recursive pointers. These can't
1913 be written in C. They can in Ada. It's pathological, but
1914 there's an ACATS test (c38102a) that checks it. Deal with this
1915 by checking if we're pointing to another pointer, that one
1916 points to another pointer, that one does too, and we have no htab.
1917 If so, get a hash table. We check three levels deep to avoid
1918 the cost of the hash table if we don't need one. */
1919 if (POINTER_TYPE_P (TREE_TYPE (type
))
1920 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
1921 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
1924 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
1932 /* ... fall through ... */
1935 WALK_SUBTREE (TREE_TYPE (type
));
1939 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
1944 WALK_SUBTREE (TREE_TYPE (type
));
1948 /* We never want to walk into default arguments. */
1949 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
1950 WALK_SUBTREE (TREE_VALUE (arg
));
1955 /* Don't follow this nodes's type if a pointer for fear that we'll
1956 have infinite recursion. Those types are uninteresting anyway. */
1957 if (!POINTER_TYPE_P (TREE_TYPE (type
))
1958 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
)
1959 WALK_SUBTREE (TREE_TYPE (type
));
1960 WALK_SUBTREE (TYPE_DOMAIN (type
));
1968 WALK_SUBTREE (TYPE_MIN_VALUE (type
));
1969 WALK_SUBTREE (TYPE_MAX_VALUE (type
));
1973 WALK_SUBTREE (TREE_TYPE (type
));
1974 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
1984 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
1985 called with the DATA and the address of each sub-tree. If FUNC returns a
1986 non-NULL value, the traversal is aborted, and the value returned by FUNC
1987 is returned. If HTAB is non-NULL it is used to record the nodes visited,
1988 and to avoid visiting a node more than once. */
1991 walk_tree (tree
*tp
, walk_tree_fn func
, void *data
, void *htab_
)
1993 htab_t htab
= (htab_t
) htab_
;
1994 enum tree_code code
;
1998 #define WALK_SUBTREE_TAIL(NODE) \
2002 goto tail_recurse; \
2007 /* Skip empty subtrees. */
2015 /* Don't walk the same tree twice, if the user has requested
2016 that we avoid doing so. */
2017 slot
= htab_find_slot (htab
, *tp
, INSERT
);
2023 /* Call the function. */
2025 result
= (*func
) (tp
, &walk_subtrees
, data
);
2027 /* If we found something, return it. */
2031 code
= TREE_CODE (*tp
);
2033 /* Even if we didn't, FUNC may have decided that there was nothing
2034 interesting below this point in the tree. */
2037 if (code
== TREE_LIST
)
2038 /* But we still need to check our siblings. */
2039 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
2044 result
= lang_hooks
.tree_inlining
.walk_subtrees (tp
, &walk_subtrees
, func
,
2046 if (result
|| ! walk_subtrees
)
2049 /* If this is a DECL_EXPR, walk into various fields of the type that it's
2050 defining. We only want to walk into these fields of a type in this
2051 case. Note that decls get walked as part of the processing of a
2054 ??? Precisely which fields of types that we are supposed to walk in
2055 this case vs. the normal case aren't well defined. */
2056 if (code
== DECL_EXPR
2057 && TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
2058 && TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp
))) != ERROR_MARK
)
2060 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
2062 /* Call the function for the type. See if it returns anything or
2063 doesn't want us to continue. If we are to continue, walk both
2064 the normal fields and those for the declaration case. */
2065 result
= (*func
) (type_p
, &walk_subtrees
, data
);
2066 if (result
|| !walk_subtrees
)
2069 result
= walk_type_fields (*type_p
, func
, data
, htab_
);
2073 WALK_SUBTREE (TYPE_SIZE (*type_p
));
2074 WALK_SUBTREE (TYPE_SIZE_UNIT (*type_p
));
2076 /* If this is a record type, also walk the fields. */
2077 if (TREE_CODE (*type_p
) == RECORD_TYPE
2078 || TREE_CODE (*type_p
) == UNION_TYPE
2079 || TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
2083 for (field
= TYPE_FIELDS (*type_p
); field
;
2084 field
= TREE_CHAIN (field
))
2086 /* We'd like to look at the type of the field, but we can easily
2087 get infinite recursion. So assume it's pointed to elsewhere
2088 in the tree. Also, ignore things that aren't fields. */
2089 if (TREE_CODE (field
) != FIELD_DECL
)
2092 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
2093 WALK_SUBTREE (DECL_SIZE (field
));
2094 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
2095 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
2096 WALK_SUBTREE (DECL_QUALIFIER (field
));
2101 else if (code
!= EXIT_BLOCK_EXPR
2102 && code
!= SAVE_EXPR
2103 && code
!= BIND_EXPR
2104 && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
2108 /* Walk over all the sub-trees of this operand. */
2109 len
= first_rtl_op (code
);
2110 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
2111 But, we only want to walk once. */
2112 if (code
== TARGET_EXPR
2113 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
2116 /* Go through the subtrees. We need to do this in forward order so
2117 that the scope of a FOR_EXPR is handled properly. */
2118 #ifdef DEBUG_WALK_TREE
2119 for (i
= 0; i
< len
; ++i
)
2120 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
2122 for (i
= 0; i
< len
- 1; ++i
)
2123 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
2127 /* The common case is that we may tail recurse here. */
2128 if (code
!= BIND_EXPR
2129 && !TREE_CHAIN (*tp
))
2130 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
2132 WALK_SUBTREE (TREE_OPERAND (*tp
, len
- 1));
2137 /* If this is a type, walk the needed fields in the type. */
2138 else if (TYPE_P (*tp
))
2140 result
= walk_type_fields (*tp
, func
, data
, htab_
);
2146 /* Not one of the easy cases. We must explicitly go through the
2151 case IDENTIFIER_NODE
:
2157 case PLACEHOLDER_EXPR
:
2161 /* None of thse have subtrees other than those already walked
2166 WALK_SUBTREE (TREE_VALUE (*tp
));
2167 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
2172 int len
= TREE_VEC_LENGTH (*tp
);
2177 /* Walk all elements but the first. */
2179 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
2181 /* Now walk the first one as a tail call. */
2182 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
2186 WALK_SUBTREE (TREE_REALPART (*tp
));
2187 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
2190 WALK_SUBTREE_TAIL (CONSTRUCTOR_ELTS (*tp
));
2192 case EXIT_BLOCK_EXPR
:
2193 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 1));
2196 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
2201 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= TREE_CHAIN (decl
))
2203 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
2204 into declarations that are just mentioned, rather than
2205 declared; they don't really belong to this part of the tree.
2206 And, we can see cycles: the initializer for a declaration
2207 can refer to the declaration itself. */
2208 WALK_SUBTREE (DECL_INITIAL (decl
));
2209 WALK_SUBTREE (DECL_SIZE (decl
));
2210 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
2212 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
2215 case STATEMENT_LIST
:
2217 tree_stmt_iterator i
;
2218 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
2219 WALK_SUBTREE (*tsi_stmt_ptr (i
));
2224 /* ??? This could be a language-defined node. We really should make
2225 a hook for it, but right now just ignore it. */
2230 /* We didn't find what we were looking for. */
2234 #undef WALK_SUBTREE_TAIL
2237 /* Like walk_tree, but does not walk duplicate nodes more than once. */
2240 walk_tree_without_duplicates (tree
*tp
, walk_tree_fn func
, void *data
)
2245 htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
2246 result
= walk_tree (tp
, func
, data
, htab
);
2251 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
2254 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2256 enum tree_code code
= TREE_CODE (*tp
);
2258 /* We make copies of most nodes. */
2259 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
2260 || code
== TREE_LIST
2262 || code
== TYPE_DECL
)
2264 /* Because the chain gets clobbered when we make a copy, we save it
2266 tree chain
= TREE_CHAIN (*tp
);
2269 /* Copy the node. */
2270 new = copy_node (*tp
);
2272 /* Propagate mudflap marked-ness. */
2273 if (flag_mudflap
&& mf_marked_p (*tp
))
2278 /* Now, restore the chain, if appropriate. That will cause
2279 walk_tree to walk into the chain as well. */
2280 if (code
== PARM_DECL
|| code
== TREE_LIST
)
2281 TREE_CHAIN (*tp
) = chain
;
2283 /* For now, we don't update BLOCKs when we make copies. So, we
2284 have to nullify all BIND_EXPRs. */
2285 if (TREE_CODE (*tp
) == BIND_EXPR
)
2286 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
2289 else if (TREE_CODE_CLASS (code
) == tcc_type
)
2291 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
2293 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
2296 gcc_assert (code
!= STATEMENT_LIST
);
2300 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2301 information indicating to what new SAVE_EXPR this one should be mapped,
2302 use that one. Otherwise, create a new node and enter it in ST. */
2305 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
2307 splay_tree st
= (splay_tree
) st_
;
2311 /* See if we already encountered this SAVE_EXPR. */
2312 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2314 /* If we didn't already remap this SAVE_EXPR, do so now. */
2317 t
= copy_node (*tp
);
2319 /* Remember this SAVE_EXPR. */
2320 splay_tree_insert (st
, (splay_tree_key
) *tp
, (splay_tree_value
) t
);
2321 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2322 splay_tree_insert (st
, (splay_tree_key
) t
, (splay_tree_value
) t
);
2326 /* We've already walked into this SAVE_EXPR; don't do it again. */
2328 t
= (tree
) n
->value
;
2331 /* Replace this SAVE_EXPR with the copy. */
2335 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
2336 copies the declaration and enters it in the splay_tree in DATA (which is
2337 really an `inline_data *'). */
2340 mark_local_for_remap_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
2343 inline_data
*id
= (inline_data
*) data
;
2345 /* Don't walk into types. */
2349 else if (TREE_CODE (*tp
) == LABEL_EXPR
)
2351 tree decl
= TREE_OPERAND (*tp
, 0);
2353 /* Copy the decl and remember the copy. */
2354 insert_decl_map (id
, decl
,
2355 copy_decl_for_inlining (decl
, DECL_CONTEXT (decl
),
2356 DECL_CONTEXT (decl
)));
2362 /* Perform any modifications to EXPR required when it is unsaved. Does
2363 not recurse into EXPR's subtrees. */
2366 unsave_expr_1 (tree expr
)
2368 switch (TREE_CODE (expr
))
2371 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
2372 It's OK for this to happen if it was part of a subtree that
2373 isn't immediately expanded, such as operand 2 of another
2375 if (TREE_OPERAND (expr
, 1))
2378 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
2379 TREE_OPERAND (expr
, 3) = NULL_TREE
;
2387 /* Called via walk_tree when an expression is unsaved. Using the
2388 splay_tree pointed to by ST (which is really a `splay_tree'),
2389 remaps all local declarations to appropriate replacements. */
2392 unsave_r (tree
*tp
, int *walk_subtrees
, void *data
)
2394 inline_data
*id
= (inline_data
*) data
;
2395 splay_tree st
= id
->decl_map
;
2398 /* Only a local declaration (variable or label). */
2399 if ((TREE_CODE (*tp
) == VAR_DECL
&& !TREE_STATIC (*tp
))
2400 || TREE_CODE (*tp
) == LABEL_DECL
)
2402 /* Lookup the declaration. */
2403 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2405 /* If it's there, remap it. */
2407 *tp
= (tree
) n
->value
;
2410 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
2411 copy_statement_list (tp
);
2412 else if (TREE_CODE (*tp
) == BIND_EXPR
)
2413 copy_bind_expr (tp
, walk_subtrees
, id
);
2414 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2415 remap_save_expr (tp
, st
, walk_subtrees
);
2418 copy_tree_r (tp
, walk_subtrees
, NULL
);
2420 /* Do whatever unsaving is required. */
2421 unsave_expr_1 (*tp
);
2424 /* Keep iterating. */
2428 /* Copies everything in EXPR and replaces variables, labels
2429 and SAVE_EXPRs local to EXPR. */
2432 unsave_expr_now (tree expr
)
2436 /* There's nothing to do for NULL_TREE. */
2441 memset (&id
, 0, sizeof (id
));
2442 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
2443 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
2444 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2446 /* Walk the tree once to find local labels. */
2447 walk_tree_without_duplicates (&expr
, mark_local_for_remap_r
, &id
);
2449 /* Walk the tree again, copying, remapping, and unsaving. */
2450 walk_tree (&expr
, unsave_r
, &id
, NULL
);
2453 splay_tree_delete (id
.decl_map
);
2458 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
2461 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
2470 debug_find_tree (tree top
, tree search
)
2472 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
2475 /* Declare the variables created by the inliner. Add all the variables in
2476 VARS to BIND_EXPR. */
2479 declare_inline_vars (tree bind_expr
, tree vars
)
2482 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
2483 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
2485 add_var_to_bind_expr (bind_expr
, vars
);