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
declare_return_variable (inline_data
*, tree
, tree
*);
126 static tree
copy_body_r (tree
*, int *, void *);
127 static tree
copy_body (inline_data
*);
128 static tree
expand_call_inline (tree
*, int *, void *);
129 static void expand_calls_inline (tree
*, inline_data
*);
130 static bool inlinable_function_p (tree
);
131 static tree
remap_decl (tree
, inline_data
*);
132 static tree
remap_type (tree
, inline_data
*);
133 static tree
initialize_inlined_parameters (inline_data
*, tree
,
135 static void remap_block (tree
*, inline_data
*);
136 static tree
remap_decls (tree
, inline_data
*);
137 static void copy_bind_expr (tree
*, int *, inline_data
*);
138 static tree
mark_local_for_remap_r (tree
*, int *, void *);
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 if (TREE_PURPOSE (src
))
211 members
= tree_cons (NULL
, member
, members
);
213 DECL_ANON_UNION_ELEMS (t
) = nreverse (members
);
217 /* Remember it, so that if we encounter this local entity
218 again we can reuse this copy. */
219 insert_decl_map (id
, decl
, t
);
223 return unshare_expr ((tree
) n
->value
);
227 remap_type (tree type
, inline_data
*id
)
229 splay_tree_node node
;
235 /* See if we have remapped this type. */
236 node
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) type
);
238 return (tree
) node
->value
;
240 /* The type only needs remapping if it's variably modified by a variable
241 in the function we are inlining. */
242 if (! variably_modified_type_p (type
, VARRAY_TOP_TREE (id
->fns
)))
244 insert_decl_map (id
, type
, type
);
248 /* We do need a copy. build and register it now. If this is a pointer or
249 reference type, remap the designated type and make a new pointer or
251 if (TREE_CODE (type
) == POINTER_TYPE
)
253 new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type
), id
),
255 TYPE_REF_CAN_ALIAS_ALL (type
));
256 insert_decl_map (id
, type
, new);
259 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
261 new = build_reference_type_for_mode (remap_type (TREE_TYPE (type
), id
),
263 TYPE_REF_CAN_ALIAS_ALL (type
));
264 insert_decl_map (id
, type
, new);
268 new = copy_node (type
);
270 insert_decl_map (id
, type
, new);
272 /* This is a new type, not a copy of an old type. Need to reassociate
273 variants. We can handle everything except the main variant lazily. */
274 t
= TYPE_MAIN_VARIANT (type
);
277 t
= remap_type (t
, id
);
278 TYPE_MAIN_VARIANT (new) = t
;
279 TYPE_NEXT_VARIANT (new) = TYPE_MAIN_VARIANT (t
);
280 TYPE_NEXT_VARIANT (t
) = new;
284 TYPE_MAIN_VARIANT (new) = new;
285 TYPE_NEXT_VARIANT (new) = NULL
;
288 /* Lazily create pointer and reference types. */
289 TYPE_POINTER_TO (new) = NULL
;
290 TYPE_REFERENCE_TO (new) = NULL
;
292 switch (TREE_CODE (new))
299 t
= TYPE_MIN_VALUE (new);
300 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
301 walk_tree (&TYPE_MIN_VALUE (new), copy_body_r
, id
, NULL
);
303 t
= TYPE_MAX_VALUE (new);
304 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
305 walk_tree (&TYPE_MAX_VALUE (new), copy_body_r
, id
, NULL
);
309 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
310 walk_tree (&TYPE_ARG_TYPES (new), copy_body_r
, id
, NULL
);
314 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
315 TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id
);
320 case QUAL_UNION_TYPE
:
321 walk_tree (&TYPE_FIELDS (new), copy_body_r
, id
, NULL
);
328 /* Shouldn't have been thought variable sized. */
332 walk_tree (&TYPE_SIZE (new), copy_body_r
, id
, NULL
);
333 walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r
, id
, NULL
);
339 remap_decls (tree decls
, inline_data
*id
)
342 tree new_decls
= NULL_TREE
;
344 /* Remap its variables. */
345 for (old_var
= decls
; old_var
; old_var
= TREE_CHAIN (old_var
))
349 /* Remap the variable. */
350 new_var
= remap_decl (old_var
, id
);
352 /* If we didn't remap this variable, so we can't mess with its
353 TREE_CHAIN. If we remapped this variable to the return slot, it's
354 already declared somewhere else, so don't declare it here. */
355 if (!new_var
|| new_var
== id
->retvar
)
357 #ifdef ENABLE_CHECKING
358 else if (!DECL_P (new_var
))
363 TREE_CHAIN (new_var
) = new_decls
;
368 return nreverse (new_decls
);
371 /* Copy the BLOCK to contain remapped versions of the variables
372 therein. And hook the new block into the block-tree. */
375 remap_block (tree
*block
, inline_data
*id
)
381 /* Make the new block. */
383 new_block
= make_node (BLOCK
);
384 TREE_USED (new_block
) = TREE_USED (old_block
);
385 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
388 /* Remap its variables. */
389 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
), id
);
391 fn
= VARRAY_TREE (id
->fns
, 0);
393 /* FIXME! It shouldn't be so hard to manage blocks. Rebuilding them in
394 rest_of_compilation is a good start. */
396 /* We're building a clone; DECL_INITIAL is still
397 error_mark_node, and current_binding_level is the parm
399 lang_hooks
.decls
.insert_block (new_block
);
402 /* Attach this new block after the DECL_INITIAL block for the
403 function into which this block is being inlined. In
404 rest_of_compilation we will straighten out the BLOCK tree. */
406 if (DECL_INITIAL (fn
))
407 first_block
= &BLOCK_CHAIN (DECL_INITIAL (fn
));
409 first_block
= &DECL_INITIAL (fn
);
410 BLOCK_CHAIN (new_block
) = *first_block
;
411 *first_block
= new_block
;
414 /* Remember the remapped block. */
415 insert_decl_map (id
, old_block
, new_block
);
419 copy_statement_list (tree
*tp
)
421 tree_stmt_iterator oi
, ni
;
424 new = alloc_stmt_list ();
425 ni
= tsi_start (new);
426 oi
= tsi_start (*tp
);
429 for (; !tsi_end_p (oi
); tsi_next (&oi
))
430 tsi_link_after (&ni
, tsi_stmt (oi
), TSI_NEW_STMT
);
434 copy_bind_expr (tree
*tp
, int *walk_subtrees
, inline_data
*id
)
436 tree block
= BIND_EXPR_BLOCK (*tp
);
437 /* Copy (and replace) the statement. */
438 copy_tree_r (tp
, walk_subtrees
, NULL
);
441 remap_block (&block
, id
);
442 BIND_EXPR_BLOCK (*tp
) = block
;
445 if (BIND_EXPR_VARS (*tp
))
446 /* This will remap a lot of the same decls again, but this should be
448 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), id
);
451 /* Called from copy_body via walk_tree. DATA is really an `inline_data *'. */
454 copy_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
456 inline_data
*id
= (inline_data
*) data
;
457 tree fn
= VARRAY_TOP_TREE (id
->fns
);
460 /* All automatic variables should have a DECL_CONTEXT indicating
461 what function they come from. */
462 if ((TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == LABEL_DECL
)
463 && DECL_NAMESPACE_SCOPE_P (*tp
))
464 if (! DECL_EXTERNAL (*tp
) && ! TREE_STATIC (*tp
))
468 /* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
469 GOTO_EXPR with the RET_LABEL as its target. */
470 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->ret_label
)
472 tree return_stmt
= *tp
;
475 /* Build the GOTO_EXPR. */
476 tree assignment
= TREE_OPERAND (return_stmt
, 0);
477 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, id
->ret_label
);
478 TREE_USED (id
->ret_label
) = 1;
480 /* If we're returning something, just turn that into an
481 assignment into the equivalent of the original
485 /* Do not create a statement containing a naked RESULT_DECL. */
486 if (TREE_CODE (assignment
) == RESULT_DECL
)
487 gimplify_stmt (&assignment
);
489 *tp
= build (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
490 append_to_statement_list (assignment
, &BIND_EXPR_BODY (*tp
));
491 append_to_statement_list (goto_stmt
, &BIND_EXPR_BODY (*tp
));
493 /* If we're not returning anything just do the jump. */
497 /* Local variables and labels need to be replaced by equivalent
498 variables. We don't want to copy static variables; there's only
499 one of those, no matter how many times we inline the containing
500 function. Similarly for globals from an outer function. */
501 else if (lang_hooks
.tree_inlining
.auto_var_in_fn_p (*tp
, fn
))
505 /* Remap the declaration. */
506 new_decl
= remap_decl (*tp
, id
);
509 /* Replace this variable with the copy. */
510 STRIP_TYPE_NOPS (new_decl
);
514 else if (nonstatic_local_decl_p (*tp
)
515 && DECL_CONTEXT (*tp
) != VARRAY_TREE (id
->fns
, 0))
518 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
519 copy_statement_list (tp
);
520 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
521 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
522 else if (TREE_CODE (*tp
) == UNSAVE_EXPR
)
523 /* UNSAVE_EXPRs should not be generated until expansion time. */
525 else if (TREE_CODE (*tp
) == BIND_EXPR
)
526 copy_bind_expr (tp
, walk_subtrees
, id
);
527 else if (TREE_CODE (*tp
) == LABELED_BLOCK_EXPR
)
529 /* We need a new copy of this labeled block; the EXIT_BLOCK_EXPR
530 will refer to it, so save a copy ready for remapping. We
531 save it in the decl_map, although it isn't a decl. */
532 tree new_block
= copy_node (*tp
);
533 insert_decl_map (id
, *tp
, new_block
);
536 else if (TREE_CODE (*tp
) == EXIT_BLOCK_EXPR
)
539 = splay_tree_lookup (id
->decl_map
,
540 (splay_tree_key
) TREE_OPERAND (*tp
, 0));
541 /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR. */
544 *tp
= copy_node (*tp
);
545 TREE_OPERAND (*tp
, 0) = (tree
) n
->value
;
547 /* Types may need remapping as well. */
548 else if (TYPE_P (*tp
))
549 *tp
= remap_type (*tp
, id
);
551 /* Otherwise, just copy the node. Note that copy_tree_r already
552 knows not to copy VAR_DECLs, etc., so this is safe. */
557 if (TREE_CODE (*tp
) == MODIFY_EXPR
558 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
559 && (lang_hooks
.tree_inlining
.auto_var_in_fn_p
560 (TREE_OPERAND (*tp
, 0), fn
)))
562 /* Some assignments VAR = VAR; don't generate any rtl code
563 and thus don't count as variable modification. Avoid
564 keeping bogosities like 0 = 0. */
565 tree decl
= TREE_OPERAND (*tp
, 0), value
;
568 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
571 value
= (tree
) n
->value
;
572 STRIP_TYPE_NOPS (value
);
573 if (TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
576 return copy_body_r (tp
, walk_subtrees
, data
);
580 else if (TREE_CODE (*tp
) == ADDR_EXPR
581 && (lang_hooks
.tree_inlining
.auto_var_in_fn_p
582 (TREE_OPERAND (*tp
, 0), fn
)))
584 /* Get rid of &* from inline substitutions. It can occur when
585 someone takes the address of a parm or return slot passed by
586 invisible reference. */
587 tree decl
= TREE_OPERAND (*tp
, 0), value
;
590 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
593 value
= (tree
) n
->value
;
594 if (TREE_CODE (value
) == INDIRECT_REF
)
596 if (!lang_hooks
.types_compatible_p
597 (TREE_TYPE (*tp
), TREE_TYPE (TREE_OPERAND (value
, 0))))
598 *tp
= fold_convert (TREE_TYPE (*tp
),
599 TREE_OPERAND (value
, 0));
601 *tp
= TREE_OPERAND (value
, 0);
603 return copy_body_r (tp
, walk_subtrees
, data
);
607 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
609 /* Get rid of *& from inline substitutions that can happen when a
610 pointer argument is an ADDR_EXPR. */
611 tree decl
= TREE_OPERAND (*tp
, 0), value
;
614 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
617 value
= (tree
) n
->value
;
619 if (TREE_CODE (value
) == ADDR_EXPR
620 && (lang_hooks
.types_compatible_p
621 (TREE_TYPE (*tp
), TREE_TYPE (TREE_OPERAND (value
, 0)))))
623 *tp
= TREE_OPERAND (value
, 0);
624 return copy_body_r (tp
, walk_subtrees
, data
);
629 copy_tree_r (tp
, walk_subtrees
, NULL
);
631 if (TREE_CODE (*tp
) == CALL_EXPR
&& id
->node
&& get_callee_fndecl (*tp
))
635 struct cgraph_node
*node
;
636 struct cgraph_edge
*edge
;
638 for (node
= id
->node
->next_clone
; node
; node
= node
->next_clone
)
640 edge
= cgraph_edge (node
, old_node
);
642 edge
->call_expr
= *tp
;
649 struct cgraph_edge
*edge
650 = cgraph_edge (id
->current_node
, old_node
);
653 cgraph_clone_edge (edge
, id
->node
, *tp
);
657 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
659 /* The copied TARGET_EXPR has never been expanded, even if the
660 original node was expanded already. */
661 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
663 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
664 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
668 /* Keep iterating. */
672 /* Make a copy of the body of FN so that it can be inserted inline in
676 copy_body (inline_data
*id
)
679 tree fndecl
= VARRAY_TOP_TREE (id
->fns
);
681 if (fndecl
== current_function_decl
683 body
= cfun
->saved_tree
;
685 body
= DECL_SAVED_TREE (fndecl
);
686 walk_tree (&body
, copy_body_r
, id
, NULL
);
692 setup_one_parameter (inline_data
*id
, tree p
, tree value
, tree fn
,
693 tree
*init_stmts
, tree
*vars
, bool *gimplify_init_stmts_p
)
699 /* If the parameter is never assigned to, we may not need to
700 create a new variable here at all. Instead, we may be able
701 to just use the argument value. */
702 if (TREE_READONLY (p
)
703 && !TREE_ADDRESSABLE (p
)
704 && value
&& !TREE_SIDE_EFFECTS (value
))
706 /* We can't risk substituting complex expressions. They
707 might contain variables that will be assigned to later.
708 Theoretically, we could check the expression to see if
709 all of the variables that determine its value are
710 read-only, but we don't bother. */
711 /* We may produce non-gimple trees by adding NOPs or introduce
712 invalid sharing when operand is not really constant.
713 It is not big deal to prohibit constant propagation here as
714 we will constant propagate in DOM1 pass anyway. */
715 if (is_gimple_min_invariant (value
)
716 && lang_hooks
.types_compatible_p (TREE_TYPE (value
), TREE_TYPE (p
)))
718 insert_decl_map (id
, p
, value
);
723 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
724 here since the type of this decl must be visible to the calling
726 var
= copy_decl_for_inlining (p
, fn
, VARRAY_TREE (id
->fns
, 0));
728 /* See if the frontend wants to pass this by invisible reference. If
729 so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
730 replace uses of the PARM_DECL with dereferences. */
731 if (TREE_TYPE (var
) != TREE_TYPE (p
)
732 && POINTER_TYPE_P (TREE_TYPE (var
))
733 && TREE_TYPE (TREE_TYPE (var
)) == TREE_TYPE (p
))
735 insert_decl_map (id
, var
, var
);
736 var_sub
= build1 (INDIRECT_REF
, TREE_TYPE (p
), var
);
741 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
742 that way, when the PARM_DECL is encountered, it will be
743 automatically replaced by the VAR_DECL. */
744 insert_decl_map (id
, p
, var_sub
);
746 /* Declare this new variable. */
747 TREE_CHAIN (var
) = *vars
;
750 /* Make gimplifier happy about this variable. */
751 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
753 /* Even if P was TREE_READONLY, the new VAR should not be.
754 In the original code, we would have constructed a
755 temporary, and then the function body would have never
756 changed the value of P. However, now, we will be
757 constructing VAR directly. The constructor body may
758 change its value multiple times as it is being
759 constructed. Therefore, it must not be TREE_READONLY;
760 the back-end assumes that TREE_READONLY variable is
761 assigned to only once. */
762 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
763 TREE_READONLY (var
) = 0;
765 /* Initialize this VAR_DECL from the equivalent argument. Convert
766 the argument to the proper type in case it was promoted. */
769 tree rhs
= fold_convert (TREE_TYPE (var
), value
);
771 if (rhs
== error_mark_node
)
774 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
775 keep our trees in gimple form. */
776 init_stmt
= build (MODIFY_EXPR
, TREE_TYPE (var
), var
, rhs
);
777 append_to_statement_list (init_stmt
, init_stmts
);
779 /* If we did not create a gimple value and we did not create a gimple
780 cast of a gimple value, then we will need to gimplify INIT_STMTS
781 at the end. Note that is_gimple_cast only checks the outer
782 tree code, not its operand. Thus the explicit check that it's
783 operand is a gimple value. */
784 if (!is_gimple_val (rhs
)
785 && (!is_gimple_cast (rhs
)
786 || !is_gimple_val (TREE_OPERAND (rhs
, 0))))
787 *gimplify_init_stmts_p
= true;
791 /* Generate code to initialize the parameters of the function at the
792 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
795 initialize_inlined_parameters (inline_data
*id
, tree args
, tree static_chain
,
796 tree fn
, tree bind_expr
)
798 tree init_stmts
= NULL_TREE
;
802 tree vars
= NULL_TREE
;
803 bool gimplify_init_stmts_p
= false;
806 /* Figure out what the parameters are. */
807 parms
= DECL_ARGUMENTS (fn
);
808 if (fn
== current_function_decl
)
809 parms
= cfun
->saved_args
;
811 /* Loop through the parameter declarations, replacing each with an
812 equivalent VAR_DECL, appropriately initialized. */
813 for (p
= parms
, a
= args
; p
;
814 a
= a
? TREE_CHAIN (a
) : a
, p
= TREE_CHAIN (p
))
820 /* Find the initializer. */
821 value
= lang_hooks
.tree_inlining
.convert_parm_for_inlining
822 (p
, a
? TREE_VALUE (a
) : NULL_TREE
, fn
, argnum
);
824 setup_one_parameter (id
, p
, value
, fn
, &init_stmts
, &vars
,
825 &gimplify_init_stmts_p
);
828 /* Evaluate trailing arguments. */
829 for (; a
; a
= TREE_CHAIN (a
))
831 tree value
= TREE_VALUE (a
);
832 append_to_statement_list (value
, &init_stmts
);
835 /* Initialize the static chain. */
836 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
839 /* No static chain? Seems like a bug in tree-nested.c. */
843 setup_one_parameter (id
, p
, static_chain
, fn
, &init_stmts
, &vars
,
844 &gimplify_init_stmts_p
);
847 if (gimplify_init_stmts_p
)
848 gimplify_body (&init_stmts
, current_function_decl
);
850 declare_inline_vars (bind_expr
, vars
);
854 /* Declare a return variable to replace the RESULT_DECL for the
855 function we are calling. An appropriate decl is returned.
857 ??? Needs documentation of parameters. */
860 declare_return_variable (inline_data
*id
, tree return_slot_addr
, tree
*use_p
)
862 tree fn
= VARRAY_TOP_TREE (id
->fns
);
863 tree result
= DECL_RESULT (fn
);
864 int need_return_decl
= 1;
867 /* We don't need to do anything for functions that don't return
869 if (!result
|| VOID_TYPE_P (TREE_TYPE (result
)))
875 var
= (lang_hooks
.tree_inlining
.copy_res_decl_for_inlining
876 (result
, fn
, VARRAY_TREE (id
->fns
, 0), id
->decl_map
,
877 &need_return_decl
, return_slot_addr
));
879 /* Do not have the rest of GCC warn about this variable as it should
880 not be visible to the user. */
881 TREE_NO_WARNING (var
) = 1;
883 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
884 way, when the RESULT_DECL is encountered, it will be
885 automatically replaced by the VAR_DECL. */
886 insert_decl_map (id
, result
, var
);
888 /* Remember this so we can ignore it in remap_decls. */
891 /* Build the use expr. If the return type of the function was
892 promoted, convert it back to the expected type. */
893 if (return_slot_addr
)
894 /* The function returns through an explicit return slot, not a normal
897 else if (TREE_TYPE (var
) == TREE_TYPE (TREE_TYPE (fn
)))
899 else if (TREE_CODE (var
) == INDIRECT_REF
)
900 *use_p
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (fn
)),
901 TREE_OPERAND (var
, 0));
902 else if (TREE_ADDRESSABLE (TREE_TYPE (var
)))
905 *use_p
= build1 (NOP_EXPR
, TREE_TYPE (TREE_TYPE (fn
)), var
);
907 /* Build the declaration statement if FN does not return an
909 if (need_return_decl
)
911 /* If FN does return an aggregate, there's no need to declare the
912 return variable; we're using a variable in our caller's frame. */
917 /* Returns nonzero if a function can be inlined as a tree. */
920 tree_inlinable_function_p (tree fn
)
922 return inlinable_function_p (fn
);
925 static const char *inline_forbidden_reason
;
928 inline_forbidden_p_1 (tree
*nodep
, int *walk_subtrees ATTRIBUTE_UNUSED
,
932 tree fn
= (tree
) fnp
;
935 switch (TREE_CODE (node
))
938 /* Refuse to inline alloca call unless user explicitly forced so as
939 this may change program's memory overhead drastically when the
940 function using alloca is called in loop. In GCC present in
941 SPEC2000 inlining into schedule_block cause it to require 2GB of
942 RAM instead of 256MB. */
943 if (alloca_call_p (node
)
944 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
946 inline_forbidden_reason
947 = N_("%Jfunction '%F' can never be inlined because it uses "
948 "alloca (override using the always_inline attribute)");
951 t
= get_callee_fndecl (node
);
955 /* We cannot inline functions that call setjmp. */
956 if (setjmp_call_p (t
))
958 inline_forbidden_reason
959 = N_("%Jfunction '%F' can never be inlined because it uses setjmp");
963 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
964 switch (DECL_FUNCTION_CODE (t
))
966 /* We cannot inline functions that take a variable number of
968 case BUILT_IN_VA_START
:
969 case BUILT_IN_STDARG_START
:
970 case BUILT_IN_NEXT_ARG
:
971 case BUILT_IN_VA_END
:
972 inline_forbidden_reason
973 = N_("%Jfunction '%F' can never be inlined because it "
974 "uses variable argument lists");
977 case BUILT_IN_LONGJMP
:
978 /* We can't inline functions that call __builtin_longjmp at
979 all. The non-local goto machinery really requires the
980 destination be in a different function. If we allow the
981 function calling __builtin_longjmp to be inlined into the
982 function calling __builtin_setjmp, Things will Go Awry. */
983 inline_forbidden_reason
984 = N_("%Jfunction '%F' can never be inlined because "
985 "it uses setjmp-longjmp exception handling");
988 case BUILT_IN_NONLOCAL_GOTO
:
990 inline_forbidden_reason
991 = N_("%Jfunction '%F' can never be inlined because "
992 "it uses non-local goto");
1001 for (t
= BIND_EXPR_VARS (node
); t
; t
= TREE_CHAIN (t
))
1003 /* We cannot inline functions that contain other functions. */
1004 if (TREE_CODE (t
) == FUNCTION_DECL
&& DECL_INITIAL (t
))
1006 inline_forbidden_reason
1007 = N_("%Jfunction '%F' can never be inlined "
1008 "because it contains a nested function");
1015 t
= TREE_OPERAND (node
, 0);
1017 /* We will not inline a function which uses computed goto. The
1018 addresses of its local labels, which may be tucked into
1019 global storage, are of course not constant across
1020 instantiations, which causes unexpected behavior. */
1021 if (TREE_CODE (t
) != LABEL_DECL
)
1023 inline_forbidden_reason
1024 = N_("%Jfunction '%F' can never be inlined "
1025 "because it contains a computed goto");
1031 t
= TREE_OPERAND (node
, 0);
1032 if (DECL_NONLOCAL (t
))
1034 /* We cannot inline a function that receives a non-local goto
1035 because we cannot remap the destination label used in the
1036 function that is performing the non-local goto. */
1037 inline_forbidden_reason
1038 = N_("%Jfunction '%F' can never be inlined "
1039 "because it receives a non-local goto");
1046 /* We cannot inline a function of the form
1048 void F (int i) { struct S { int ar[i]; } s; }
1050 Attempting to do so produces a catch-22.
1051 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1052 UNION_TYPE nodes, then it goes into infinite recursion on a
1053 structure containing a pointer to its own type. If it doesn't,
1054 then the type node for S doesn't get adjusted properly when
1055 F is inlined, and we abort in find_function_data. */
1056 for (t
= TYPE_FIELDS (node
); t
; t
= TREE_CHAIN (t
))
1057 if (variably_modified_type_p (TREE_TYPE (t
), NULL
))
1059 inline_forbidden_reason
1060 = N_("%Jfunction '%F' can never be inlined "
1061 "because it uses variable sized variables");
1072 /* Return subexpression representing possible alloca call, if any. */
1074 inline_forbidden_p (tree fndecl
)
1076 location_t saved_loc
= input_location
;
1077 tree ret
= walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl
),
1078 inline_forbidden_p_1
, fndecl
);
1080 input_location
= saved_loc
;
1084 /* Returns nonzero if FN is a function that does not have any
1085 fundamental inline blocking properties. */
1088 inlinable_function_p (tree fn
)
1090 bool inlinable
= true;
1092 /* If we've already decided this function shouldn't be inlined,
1093 there's no need to check again. */
1094 if (DECL_UNINLINABLE (fn
))
1097 /* See if there is any language-specific reason it cannot be
1098 inlined. (It is important that this hook be called early because
1099 in C++ it may result in template instantiation.)
1100 If the function is not inlinable for language-specific reasons,
1101 it is left up to the langhook to explain why. */
1102 inlinable
= !lang_hooks
.tree_inlining
.cannot_inline_tree_fn (&fn
);
1104 /* If we don't have the function body available, we can't inline it.
1105 However, this should not be recorded since we also get here for
1106 forward declared inline functions. Therefore, return at once. */
1107 if (!DECL_SAVED_TREE (fn
))
1110 /* If we're not inlining at all, then we cannot inline this function. */
1111 else if (!flag_inline_trees
)
1114 /* Only try to inline functions if DECL_INLINE is set. This should be
1115 true for all functions declared `inline', and for all other functions
1116 as well with -finline-functions.
1118 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1119 it's the front-end that must set DECL_INLINE in this case, because
1120 dwarf2out loses if a function that does not have DECL_INLINE set is
1121 inlined anyway. That is why we have both DECL_INLINE and
1122 DECL_DECLARED_INLINE_P. */
1123 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1124 here should be redundant. */
1125 else if (!DECL_INLINE (fn
) && !flag_unit_at_a_time
)
1128 else if (inline_forbidden_p (fn
))
1130 /* See if we should warn about uninlinable functions. Previously,
1131 some of these warnings would be issued while trying to expand
1132 the function inline, but that would cause multiple warnings
1133 about functions that would for example call alloca. But since
1134 this a property of the function, just one warning is enough.
1135 As a bonus we can now give more details about the reason why a
1136 function is not inlinable.
1137 We only warn for functions declared `inline' by the user. */
1138 bool do_warning
= (warn_inline
1140 && DECL_DECLARED_INLINE_P (fn
)
1141 && !DECL_IN_SYSTEM_HEADER (fn
));
1143 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1144 sorry (inline_forbidden_reason
, fn
, fn
);
1145 else if (do_warning
)
1146 warning (inline_forbidden_reason
, fn
, fn
);
1151 /* Squirrel away the result so that we don't have to check again. */
1152 DECL_UNINLINABLE (fn
) = !inlinable
;
1157 /* Used by estimate_num_insns. Estimate number of instructions seen
1158 by given statement. */
1161 estimate_num_insns_1 (tree
*tp
, int *walk_subtrees
, void *data
)
1166 if (TYPE_P (x
) || DECL_P (x
))
1171 /* Assume that constants and references counts nothing. These should
1172 be majorized by amount of operations among them we count later
1173 and are common target of CSE and similar optimizations. */
1174 else if (TREE_CODE_CLASS (TREE_CODE (x
)) == 'c'
1175 || TREE_CODE_CLASS (TREE_CODE (x
)) == 'r')
1178 switch (TREE_CODE (x
))
1180 /* Containers have no cost. */
1189 case ARRAY_RANGE_REF
:
1191 case EXC_PTR_EXPR
: /* ??? */
1192 case FILTER_EXPR
: /* ??? */
1195 case LABELED_BLOCK_EXPR
:
1196 case WITH_CLEANUP_EXPR
:
1198 case VIEW_CONVERT_EXPR
:
1203 case EXIT_BLOCK_EXPR
:
1204 case CASE_LABEL_EXPR
:
1207 case EH_FILTER_EXPR
:
1208 case STATEMENT_LIST
:
1210 case NON_LVALUE_EXPR
:
1211 case ENTRY_VALUE_EXPR
:
1214 case TRY_CATCH_EXPR
:
1215 case TRY_FINALLY_EXPR
:
1224 /* We don't account constants for now. Assume that the cost is amortized
1225 by operations that do use them. We may re-consider this decision once
1226 we are able to optimize the tree before estimating it's size and break
1227 out static initializers. */
1228 case IDENTIFIER_NODE
:
1237 /* Recognize assignments of large structures and constructors of
1241 x
= TREE_OPERAND (x
, 0);
1248 size
= int_size_in_bytes (TREE_TYPE (x
));
1250 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO
)
1253 *count
+= ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
1257 /* Assign cost of 1 to usual operations.
1258 ??? We may consider mapping RTL costs to this. */
1265 case FIX_TRUNC_EXPR
:
1267 case FIX_FLOOR_EXPR
:
1268 case FIX_ROUND_EXPR
:
1286 case TRUTH_ANDIF_EXPR
:
1287 case TRUTH_ORIF_EXPR
:
1288 case TRUTH_AND_EXPR
:
1290 case TRUTH_XOR_EXPR
:
1291 case TRUTH_NOT_EXPR
:
1300 case UNORDERED_EXPR
:
1313 case PREDECREMENT_EXPR
:
1314 case PREINCREMENT_EXPR
:
1315 case POSTDECREMENT_EXPR
:
1316 case POSTINCREMENT_EXPR
:
1326 /* Few special cases of expensive operations. This is useful
1327 to avoid inlining on functions having too many of these. */
1328 case TRUNC_DIV_EXPR
:
1330 case FLOOR_DIV_EXPR
:
1331 case ROUND_DIV_EXPR
:
1332 case EXACT_DIV_EXPR
:
1333 case TRUNC_MOD_EXPR
:
1335 case FLOOR_MOD_EXPR
:
1336 case ROUND_MOD_EXPR
:
1342 tree decl
= get_callee_fndecl (x
);
1344 if (decl
&& DECL_BUILT_IN (decl
))
1345 switch (DECL_FUNCTION_CODE (decl
))
1347 case BUILT_IN_CONSTANT_P
:
1350 case BUILT_IN_EXPECT
:
1359 /* Abort here se we know we don't miss any nodes. */
1365 /* Estimate number of instructions that will be created by expanding EXPR. */
1368 estimate_num_insns (tree expr
)
1371 walk_tree_without_duplicates (&expr
, estimate_num_insns_1
, &num
);
1375 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1378 expand_call_inline (tree
*tp
, int *walk_subtrees
, void *data
)
1392 tree return_slot_addr
;
1393 location_t saved_location
;
1394 struct cgraph_edge
*edge
;
1397 /* See what we've got. */
1398 id
= (inline_data
*) data
;
1401 /* Set input_location here so we get the right instantiation context
1402 if we call instantiate_decl from inlinable_function_p. */
1403 saved_location
= input_location
;
1404 if (EXPR_HAS_LOCATION (t
))
1405 input_location
= EXPR_LOCATION (t
);
1407 /* Recurse, but letting recursive invocations know that we are
1408 inside the body of a TARGET_EXPR. */
1409 if (TREE_CODE (*tp
) == TARGET_EXPR
)
1412 int i
, len
= first_rtl_op (TARGET_EXPR
);
1414 /* We're walking our own subtrees. */
1417 /* Actually walk over them. This loop is the body of
1418 walk_trees, omitting the case where the TARGET_EXPR
1419 itself is handled. */
1420 for (i
= 0; i
< len
; ++i
)
1423 ++id
->in_target_cleanup_p
;
1424 walk_tree (&TREE_OPERAND (*tp
, i
), expand_call_inline
, data
,
1427 --id
->in_target_cleanup_p
;
1435 /* Because types were not copied in copy_body, CALL_EXPRs beneath
1436 them should not be expanded. This can happen if the type is a
1437 dynamic array type, for example. */
1440 /* From here on, we're only interested in CALL_EXPRs. */
1441 if (TREE_CODE (t
) != CALL_EXPR
)
1444 /* First, see if we can figure out what function is being called.
1445 If we cannot, then there is no hope of inlining the function. */
1446 fn
= get_callee_fndecl (t
);
1450 /* Turn forward declarations into real ones. */
1451 fn
= cgraph_node (fn
)->decl
;
1453 /* If fn is a declaration of a function in a nested scope that was
1454 globally declared inline, we don't set its DECL_INITIAL.
1455 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1456 C++ front-end uses it for cdtors to refer to their internal
1457 declarations, that are not real functions. Fortunately those
1458 don't have trees to be saved, so we can tell by checking their
1460 if (! DECL_INITIAL (fn
)
1461 && DECL_ABSTRACT_ORIGIN (fn
)
1462 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn
)))
1463 fn
= DECL_ABSTRACT_ORIGIN (fn
);
1465 /* Objective C and fortran still calls tree_rest_of_compilation directly.
1466 Kill this check once this is fixed. */
1467 if (!id
->current_node
->analyzed
)
1470 edge
= cgraph_edge (id
->current_node
, t
);
1472 /* Constant propagation on argument done during previous inlining
1473 may create new direct call. Produce an edge for it. */
1476 struct cgraph_node
*dest
= cgraph_node (fn
);
1478 /* We have missing edge in the callgraph. This can happen in one case
1479 where previous inlining turned indirect call into direct call by
1480 constant propagating arguments. In all other cases we hit a bug
1481 (incorrect node sharing is most common reason for missing edges. */
1484 cgraph_create_edge (id
->node
, dest
, t
)->inline_failed
1485 = N_("originally indirect function call not considered for inlining");
1489 /* Don't try to inline functions that are not well-suited to
1491 if (!cgraph_inline_p (edge
, &reason
))
1493 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1495 sorry ("%Jinlining failed in call to '%F': %s", fn
, fn
, reason
);
1496 sorry ("called from here");
1498 else if (warn_inline
&& DECL_DECLARED_INLINE_P (fn
)
1499 && !DECL_IN_SYSTEM_HEADER (fn
)
1502 warning ("%Jinlining failed in call to '%F': %s", fn
, fn
, reason
);
1503 warning ("called from here");
1508 #ifdef ENABLE_CHECKING
1509 if (edge
->callee
->decl
!= id
->node
->decl
)
1510 verify_cgraph_node (edge
->callee
);
1513 if (! lang_hooks
.tree_inlining
.start_inlining (fn
))
1516 /* Build a block containing code to initialize the arguments, the
1517 actual inline expansion of the body, and a label for the return
1518 statements within the function to jump to. The type of the
1519 statement expression is the return type of the function call. */
1521 expr
= build (BIND_EXPR
, TREE_TYPE (TREE_TYPE (fn
)), NULL_TREE
,
1522 stmt
, make_node (BLOCK
));
1523 BLOCK_ABSTRACT_ORIGIN (BIND_EXPR_BLOCK (expr
)) = fn
;
1525 /* Local declarations will be replaced by their equivalents in this
1528 id
->decl_map
= splay_tree_new (splay_tree_compare_pointers
,
1531 /* Initialize the parameters. */
1532 args
= TREE_OPERAND (t
, 1);
1533 return_slot_addr
= NULL_TREE
;
1534 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t
))
1536 return_slot_addr
= TREE_VALUE (args
);
1537 args
= TREE_CHAIN (args
);
1538 TREE_TYPE (expr
) = void_type_node
;
1541 arg_inits
= initialize_inlined_parameters (id
, args
, TREE_OPERAND (t
, 2),
1545 /* Expand any inlined calls in the initializers. Do this before we
1546 push FN on the stack of functions we are inlining; we want to
1547 inline calls to FN that appear in the initializers for the
1550 Note we need to save and restore the saved tree statement iterator
1551 to avoid having it clobbered by expand_calls_inline. */
1552 tree_stmt_iterator save_tsi
;
1555 expand_calls_inline (&arg_inits
, id
);
1558 /* And add them to the tree. */
1559 append_to_statement_list (arg_inits
, &BIND_EXPR_BODY (expr
));
1562 /* Record the function we are about to inline so that we can avoid
1563 recursing into it. */
1564 VARRAY_PUSH_TREE (id
->fns
, fn
);
1566 /* Record the function we are about to inline if optimize_function
1567 has not been called on it yet and we don't have it in the list. */
1568 if (! DECL_INLINED_FNS (fn
))
1572 for (i
= VARRAY_ACTIVE_SIZE (id
->inlined_fns
) - 1; i
>= 0; i
--)
1573 if (VARRAY_TREE (id
->inlined_fns
, i
) == fn
)
1576 VARRAY_PUSH_TREE (id
->inlined_fns
, fn
);
1579 /* Return statements in the function body will be replaced by jumps
1580 to the RET_LABEL. */
1581 id
->ret_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
1582 DECL_ARTIFICIAL (id
->ret_label
) = 1;
1583 DECL_CONTEXT (id
->ret_label
) = VARRAY_TREE (id
->fns
, 0);
1584 insert_decl_map (id
, id
->ret_label
, id
->ret_label
);
1586 if (! DECL_INITIAL (fn
)
1587 || TREE_CODE (DECL_INITIAL (fn
)) != BLOCK
)
1590 /* Declare the return variable for the function. */
1591 decl
= declare_return_variable (id
, return_slot_addr
, &use_retvar
);
1593 declare_inline_vars (expr
, decl
);
1595 /* After we've initialized the parameters, we insert the body of the
1598 struct cgraph_node
*old_node
= id
->current_node
;
1600 id
->current_node
= edge
->callee
;
1601 append_to_statement_list (copy_body (id
), &BIND_EXPR_BODY (expr
));
1602 id
->current_node
= old_node
;
1604 inlined_body
= &BIND_EXPR_BODY (expr
);
1606 /* After the body of the function comes the RET_LABEL. This must come
1607 before we evaluate the returned value below, because that evaluation
1608 may cause RTL to be generated. */
1609 if (TREE_USED (id
->ret_label
))
1611 tree label
= build1 (LABEL_EXPR
, void_type_node
, id
->ret_label
);
1612 append_to_statement_list (label
, &BIND_EXPR_BODY (expr
));
1615 /* Finally, mention the returned value so that the value of the
1616 statement-expression is the returned value of the function. */
1618 /* Set TREE_TYPE on BIND_EXPR? */
1619 append_to_statement_list_force (use_retvar
, &BIND_EXPR_BODY (expr
));
1622 splay_tree_delete (id
->decl_map
);
1625 /* The new expression has side-effects if the old one did. */
1626 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (t
);
1628 /* We want to create a new variable to hold the result of the inlined
1629 body. This new variable needs to be added to the function which we
1630 are inlining into, thus the saving and restoring of
1631 current_function_decl. */
1633 tree save_decl
= current_function_decl
;
1634 current_function_decl
= id
->node
->decl
;
1635 inline_result
= voidify_wrapper_expr (expr
, NULL
);
1636 current_function_decl
= save_decl
;
1639 /* If the inlined function returns a result that we care about,
1640 then we're going to need to splice in a MODIFY_EXPR. Otherwise
1641 the call was a standalone statement and we can just replace it
1642 with the BIND_EXPR inline representation of the called function. */
1643 if (TREE_CODE (tsi_stmt (id
->tsi
)) != CALL_EXPR
)
1645 tsi_link_before (&id
->tsi
, expr
, TSI_SAME_STMT
);
1646 *tp
= inline_result
;
1651 /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS on
1652 the call if it is to a "const" function. Thus the copy of
1653 TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above with
1654 result in TREE_SIDE_EFFECTS not being set for the inlined copy of a
1657 Unfortunately, that is wrong as inlining the function can create/expose
1658 interesting side effects (such as setting of a return value).
1660 The easiest solution is to simply recalculate TREE_SIDE_EFFECTS for
1661 the toplevel expression. */
1662 recalculate_side_effects (expr
);
1664 /* If the value of the new expression is ignored, that's OK. We
1665 don't warn about this for CALL_EXPRs, so we shouldn't warn about
1666 the equivalent inlined version either. */
1667 TREE_USED (*tp
) = 1;
1669 /* Update callgraph if needed. */
1670 cgraph_remove_node (edge
->callee
);
1672 /* Recurse into the body of the just inlined function. */
1673 expand_calls_inline (inlined_body
, id
);
1674 VARRAY_POP (id
->fns
);
1676 /* Don't walk into subtrees. We've already handled them above. */
1679 lang_hooks
.tree_inlining
.end_inlining (fn
);
1681 /* Keep iterating. */
1683 input_location
= saved_location
;
1688 expand_calls_inline (tree
*stmt_p
, inline_data
*id
)
1690 tree stmt
= *stmt_p
;
1691 enum tree_code code
= TREE_CODE (stmt
);
1696 case STATEMENT_LIST
:
1698 tree_stmt_iterator i
;
1701 for (i
= tsi_start (stmt
); !tsi_end_p (i
); )
1704 expand_calls_inline (tsi_stmt_ptr (i
), id
);
1707 if (TREE_CODE (new) == STATEMENT_LIST
)
1709 tsi_link_before (&i
, new, TSI_SAME_STMT
);
1719 expand_calls_inline (&COND_EXPR_THEN (stmt
), id
);
1720 expand_calls_inline (&COND_EXPR_ELSE (stmt
), id
);
1724 expand_calls_inline (&CATCH_BODY (stmt
), id
);
1727 case EH_FILTER_EXPR
:
1728 expand_calls_inline (&EH_FILTER_FAILURE (stmt
), id
);
1731 case TRY_CATCH_EXPR
:
1732 case TRY_FINALLY_EXPR
:
1733 expand_calls_inline (&TREE_OPERAND (stmt
, 0), id
);
1734 expand_calls_inline (&TREE_OPERAND (stmt
, 1), id
);
1738 expand_calls_inline (&BIND_EXPR_BODY (stmt
), id
);
1742 /* We're gimple. We should have gotten rid of all these. */
1746 stmt_p
= &TREE_OPERAND (stmt
, 0);
1748 if (!stmt
|| TREE_CODE (stmt
) != MODIFY_EXPR
)
1754 stmt_p
= &TREE_OPERAND (stmt
, 1);
1756 if (TREE_CODE (stmt
) != CALL_EXPR
)
1762 expand_call_inline (stmt_p
, &dummy
, id
);
1770 /* Expand calls to inline functions in the body of FN. */
1773 optimize_inline_calls (tree fn
)
1778 /* There is no point in performing inlining if errors have already
1779 occurred -- and we might crash if we try to inline invalid
1781 if (errorcount
|| sorrycount
)
1785 memset (&id
, 0, sizeof (id
));
1787 id
.current_node
= id
.node
= cgraph_node (fn
);
1788 /* Don't allow recursion into FN. */
1789 VARRAY_TREE_INIT (id
.fns
, 32, "fns");
1790 VARRAY_PUSH_TREE (id
.fns
, fn
);
1791 /* Or any functions that aren't finished yet. */
1792 prev_fn
= NULL_TREE
;
1793 if (current_function_decl
)
1795 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
1796 prev_fn
= current_function_decl
;
1799 prev_fn
= lang_hooks
.tree_inlining
.add_pending_fn_decls (&id
.fns
, prev_fn
);
1801 /* Create the list of functions this call will inline. */
1802 VARRAY_TREE_INIT (id
.inlined_fns
, 32, "inlined_fns");
1804 /* Keep track of the low-water mark, i.e., the point where the first
1805 real inlining is represented in ID.FNS. */
1806 id
.first_inlined_fn
= VARRAY_ACTIVE_SIZE (id
.fns
);
1808 /* Replace all calls to inline functions with the bodies of those
1810 id
.tree_pruner
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1811 expand_calls_inline (&DECL_SAVED_TREE (fn
), &id
);
1814 htab_delete (id
.tree_pruner
);
1815 if (DECL_LANG_SPECIFIC (fn
))
1817 tree ifn
= make_tree_vec (VARRAY_ACTIVE_SIZE (id
.inlined_fns
));
1819 if (VARRAY_ACTIVE_SIZE (id
.inlined_fns
))
1820 memcpy (&TREE_VEC_ELT (ifn
, 0), &VARRAY_TREE (id
.inlined_fns
, 0),
1821 VARRAY_ACTIVE_SIZE (id
.inlined_fns
) * sizeof (tree
));
1822 DECL_INLINED_FNS (fn
) = ifn
;
1825 #ifdef ENABLE_CHECKING
1827 struct cgraph_edge
*e
;
1829 verify_cgraph_node (id
.node
);
1831 /* Double check that we inlined everything we are supposed to inline. */
1832 for (e
= id
.node
->callees
; e
; e
= e
->next_callee
)
1833 if (!e
->inline_failed
)
1839 /* FN is a function that has a complete body, and CLONE is a function whose
1840 body is to be set to a copy of FN, mapping argument declarations according
1841 to the ARG_MAP splay_tree. */
1844 clone_body (tree clone
, tree fn
, void *arg_map
)
1848 /* Clone the body, as if we were making an inline call. But, remap the
1849 parameters in the callee to the parameters of caller. If there's an
1850 in-charge parameter, map it to an appropriate constant. */
1851 memset (&id
, 0, sizeof (id
));
1852 VARRAY_TREE_INIT (id
.fns
, 2, "fns");
1853 VARRAY_PUSH_TREE (id
.fns
, clone
);
1854 VARRAY_PUSH_TREE (id
.fns
, fn
);
1855 id
.decl_map
= (splay_tree
)arg_map
;
1857 /* Cloning is treated slightly differently from inlining. Set
1858 CLONING_P so that it's clear which operation we're performing. */
1859 id
.cloning_p
= true;
1861 /* Actually copy the body. */
1862 append_to_statement_list_force (copy_body (&id
), &DECL_SAVED_TREE (clone
));
1865 /* Save duplicate of body in FN. MAP is used to pass around splay tree
1866 used to update arguments in restore_body. */
1868 save_body (tree fn
, tree
*arg_copy
)
1873 memset (&id
, 0, sizeof (id
));
1874 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
1875 VARRAY_PUSH_TREE (id
.fns
, fn
);
1876 id
.node
= cgraph_node (fn
);
1878 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
1879 *arg_copy
= DECL_ARGUMENTS (fn
);
1881 for (parg
= arg_copy
; *parg
; parg
= &TREE_CHAIN (*parg
))
1883 tree
new = copy_node (*parg
);
1885 lang_hooks
.dup_lang_specific_decl (new);
1886 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg
);
1887 insert_decl_map (&id
, *parg
, new);
1888 TREE_CHAIN (new) = TREE_CHAIN (*parg
);
1892 insert_decl_map (&id
, DECL_RESULT (fn
), DECL_RESULT (fn
));
1894 /* Actually copy the body. */
1895 body
= copy_body (&id
);
1898 splay_tree_delete (id
.decl_map
);
1902 #define WALK_SUBTREE(NODE) \
1905 result = walk_tree (&(NODE), func, data, htab); \
1911 /* This is a subroutine of walk_tree that walks field of TYPE that are to
1912 be walked whenever a type is seen in the tree. Rest of operands and return
1913 value are as for walk_tree. */
1916 walk_type_fields (tree type
, walk_tree_fn func
, void *data
, void *htab
)
1918 tree result
= NULL_TREE
;
1920 switch (TREE_CODE (type
))
1923 case REFERENCE_TYPE
:
1924 /* We have to worry about mutually recursive pointers. These can't
1925 be written in C. They can in Ada. It's pathlogical, but
1926 there's an ACATS test (c38102a) that checks it. Deal with this
1927 by checking if we're pointing to another pointer, that one
1928 points to another pointer, that one does too, and we have no htab.
1929 If so, get a hash table. We check three levels deep to avoid
1930 the cost of the hash table if we don't need one. */
1931 if (POINTER_TYPE_P (TREE_TYPE (type
))
1932 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type
)))
1933 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type
))))
1936 result
= walk_tree_without_duplicates (&TREE_TYPE (type
),
1944 /* ... fall through ... */
1947 WALK_SUBTREE (TREE_TYPE (type
));
1951 WALK_SUBTREE (TYPE_METHOD_BASETYPE (type
));
1956 WALK_SUBTREE (TREE_TYPE (type
));
1960 /* We never want to walk into default arguments. */
1961 for (arg
= TYPE_ARG_TYPES (type
); arg
; arg
= TREE_CHAIN (arg
))
1962 WALK_SUBTREE (TREE_VALUE (arg
));
1967 /* Don't follow this nodes's type if a pointer for fear that we'll
1968 have infinite recursion. Those types are uninteresting anyway. */
1969 if (!POINTER_TYPE_P (TREE_TYPE (type
))
1970 && TREE_CODE (TREE_TYPE (type
)) != OFFSET_TYPE
)
1971 WALK_SUBTREE (TREE_TYPE (type
));
1972 WALK_SUBTREE (TYPE_DOMAIN (type
));
1980 WALK_SUBTREE (TYPE_MIN_VALUE (type
));
1981 WALK_SUBTREE (TYPE_MAX_VALUE (type
));
1985 WALK_SUBTREE (TREE_TYPE (type
));
1986 WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type
));
1996 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
1997 called with the DATA and the address of each sub-tree. If FUNC returns a
1998 non-NULL value, the traversal is aborted, and the value returned by FUNC
1999 is returned. If HTAB is non-NULL it is used to record the nodes visited,
2000 and to avoid visiting a node more than once. */
2003 walk_tree (tree
*tp
, walk_tree_fn func
, void *data
, void *htab_
)
2005 htab_t htab
= (htab_t
) htab_
;
2006 enum tree_code code
;
2010 #define WALK_SUBTREE_TAIL(NODE) \
2014 goto tail_recurse; \
2019 /* Skip empty subtrees. */
2027 /* Don't walk the same tree twice, if the user has requested
2028 that we avoid doing so. */
2029 slot
= htab_find_slot (htab
, *tp
, INSERT
);
2035 /* Call the function. */
2037 result
= (*func
) (tp
, &walk_subtrees
, data
);
2039 /* If we found something, return it. */
2043 code
= TREE_CODE (*tp
);
2045 /* Even if we didn't, FUNC may have decided that there was nothing
2046 interesting below this point in the tree. */
2049 if (code
== TREE_LIST
)
2050 /* But we still need to check our siblings. */
2051 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
2056 result
= lang_hooks
.tree_inlining
.walk_subtrees (tp
, &walk_subtrees
, func
,
2058 if (result
|| ! walk_subtrees
)
2061 /* If this is a DECL_EXPR, walk into various fields of the type that it's
2062 defining. We only want to walk into these fields of a type in this
2063 case. Note that decls get walked as part of the processing of a
2066 ??? Precisely which fields of types that we are supposed to walk in
2067 this case vs. the normal case aren't well defined. */
2068 if (code
== DECL_EXPR
2069 && TREE_CODE (DECL_EXPR_DECL (*tp
)) == TYPE_DECL
2070 && TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp
))) != ERROR_MARK
)
2072 tree
*type_p
= &TREE_TYPE (DECL_EXPR_DECL (*tp
));
2074 /* Call the function for the type. See if it returns anything or
2075 doesn't want us to continue. If we are to continue, walk both
2076 the normal fields and those for the declaration case. */
2077 result
= (*func
) (type_p
, &walk_subtrees
, data
);
2078 if (result
|| !walk_subtrees
)
2081 result
= walk_type_fields (*type_p
, func
, data
, htab_
);
2085 WALK_SUBTREE (TYPE_SIZE (*type_p
));
2086 WALK_SUBTREE (TYPE_SIZE_UNIT (*type_p
));
2088 /* If this is a record type, also walk the fields. */
2089 if (TREE_CODE (*type_p
) == RECORD_TYPE
2090 || TREE_CODE (*type_p
) == UNION_TYPE
2091 || TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
2095 for (field
= TYPE_FIELDS (*type_p
); field
;
2096 field
= TREE_CHAIN (field
))
2098 /* We'd like to look at the type of the field, but we can easily
2099 get infinite recursion. So assume it's pointed to elsewhere
2100 in the tree. Also, ignore things that aren't fields. */
2101 if (TREE_CODE (field
) != FIELD_DECL
)
2104 WALK_SUBTREE (DECL_FIELD_OFFSET (field
));
2105 WALK_SUBTREE (DECL_SIZE (field
));
2106 WALK_SUBTREE (DECL_SIZE_UNIT (field
));
2107 if (TREE_CODE (*type_p
) == QUAL_UNION_TYPE
)
2108 WALK_SUBTREE (DECL_QUALIFIER (field
));
2113 else if (code
!= EXIT_BLOCK_EXPR
2114 && code
!= SAVE_EXPR
2115 && code
!= BIND_EXPR
2116 && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
2120 /* Walk over all the sub-trees of this operand. */
2121 len
= first_rtl_op (code
);
2122 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
2123 But, we only want to walk once. */
2124 if (code
== TARGET_EXPR
2125 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
2128 /* Go through the subtrees. We need to do this in forward order so
2129 that the scope of a FOR_EXPR is handled properly. */
2130 #ifdef DEBUG_WALK_TREE
2131 for (i
= 0; i
< len
; ++i
)
2132 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
2134 for (i
= 0; i
< len
- 1; ++i
)
2135 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
2139 /* The common case is that we may tail recurse here. */
2140 if (code
!= BIND_EXPR
2141 && !TREE_CHAIN (*tp
))
2142 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
2144 WALK_SUBTREE (TREE_OPERAND (*tp
, len
- 1));
2149 /* If this is a type, walk the needed fields in the type. */
2150 else if (TYPE_P (*tp
))
2152 result
= walk_type_fields (*tp
, func
, data
, htab_
);
2158 /* Not one of the easy cases. We must explicitly go through the
2163 case IDENTIFIER_NODE
:
2169 case PLACEHOLDER_EXPR
:
2173 /* None of thse have subtrees other than those already walked
2178 WALK_SUBTREE (TREE_VALUE (*tp
));
2179 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
2184 int len
= TREE_VEC_LENGTH (*tp
);
2189 /* Walk all elements but the first. */
2191 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
2193 /* Now walk the first one as a tail call. */
2194 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
2198 WALK_SUBTREE (TREE_REALPART (*tp
));
2199 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
2202 WALK_SUBTREE_TAIL (CONSTRUCTOR_ELTS (*tp
));
2204 case EXIT_BLOCK_EXPR
:
2205 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 1));
2208 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
2213 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= TREE_CHAIN (decl
))
2215 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
2216 into declarations that are just mentioned, rather than
2217 declared; they don't really belong to this part of the tree.
2218 And, we can see cycles: the initializer for a declaration
2219 can refer to the declaration itself. */
2220 WALK_SUBTREE (DECL_INITIAL (decl
));
2221 WALK_SUBTREE (DECL_SIZE (decl
));
2222 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
2224 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
2227 case STATEMENT_LIST
:
2229 tree_stmt_iterator i
;
2230 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
2231 WALK_SUBTREE (*tsi_stmt_ptr (i
));
2236 /* ??? This could be a language-defined node. We really should make
2237 a hook for it, but right now just ignore it. */
2242 /* We didn't find what we were looking for. */
2246 #undef WALK_SUBTREE_TAIL
2249 /* Like walk_tree, but does not walk duplicate nodes more than once. */
2252 walk_tree_without_duplicates (tree
*tp
, walk_tree_fn func
, void *data
)
2257 htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
2258 result
= walk_tree (tp
, func
, data
, htab
);
2263 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
2266 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2268 enum tree_code code
= TREE_CODE (*tp
);
2270 /* We make copies of most nodes. */
2271 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
2272 || TREE_CODE_CLASS (code
) == 'c'
2273 || code
== TREE_LIST
2275 || code
== TYPE_DECL
)
2277 /* Because the chain gets clobbered when we make a copy, we save it
2279 tree chain
= TREE_CHAIN (*tp
);
2282 /* Copy the node. */
2283 new = copy_node (*tp
);
2285 /* Propagate mudflap marked-ness. */
2286 if (flag_mudflap
&& mf_marked_p (*tp
))
2291 /* Now, restore the chain, if appropriate. That will cause
2292 walk_tree to walk into the chain as well. */
2293 if (code
== PARM_DECL
|| code
== TREE_LIST
)
2294 TREE_CHAIN (*tp
) = chain
;
2296 /* For now, we don't update BLOCKs when we make copies. So, we
2297 have to nullify all BIND_EXPRs. */
2298 if (TREE_CODE (*tp
) == BIND_EXPR
)
2299 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
2302 else if (TREE_CODE_CLASS (code
) == 't')
2304 else if (TREE_CODE_CLASS (code
) == 'd')
2306 else if (code
== STATEMENT_LIST
)
2312 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2313 information indicating to what new SAVE_EXPR this one should be mapped,
2314 use that one. Otherwise, create a new node and enter it in ST. */
2317 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
2319 splay_tree st
= (splay_tree
) st_
;
2323 /* See if we already encountered this SAVE_EXPR. */
2324 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2326 /* If we didn't already remap this SAVE_EXPR, do so now. */
2329 t
= copy_node (*tp
);
2331 /* Remember this SAVE_EXPR. */
2332 splay_tree_insert (st
, (splay_tree_key
) *tp
, (splay_tree_value
) t
);
2333 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2334 splay_tree_insert (st
, (splay_tree_key
) t
, (splay_tree_value
) t
);
2338 /* We've already walked into this SAVE_EXPR; don't do it again. */
2340 t
= (tree
) n
->value
;
2343 /* Replace this SAVE_EXPR with the copy. */
2347 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
2348 copies the declaration and enters it in the splay_tree in DATA (which is
2349 really an `inline_data *'). */
2352 mark_local_for_remap_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
2355 inline_data
*id
= (inline_data
*) data
;
2357 /* Don't walk into types. */
2361 else if (TREE_CODE (*tp
) == LABEL_EXPR
)
2363 tree decl
= TREE_OPERAND (*tp
, 0);
2365 /* Copy the decl and remember the copy. */
2366 insert_decl_map (id
, decl
,
2367 copy_decl_for_inlining (decl
, DECL_CONTEXT (decl
),
2368 DECL_CONTEXT (decl
)));
2374 /* Called via walk_tree when an expression is unsaved. Using the
2375 splay_tree pointed to by ST (which is really a `splay_tree'),
2376 remaps all local declarations to appropriate replacements. */
2379 unsave_r (tree
*tp
, int *walk_subtrees
, void *data
)
2381 inline_data
*id
= (inline_data
*) data
;
2382 splay_tree st
= id
->decl_map
;
2385 /* Only a local declaration (variable or label). */
2386 if ((TREE_CODE (*tp
) == VAR_DECL
&& !TREE_STATIC (*tp
))
2387 || TREE_CODE (*tp
) == LABEL_DECL
)
2389 /* Lookup the declaration. */
2390 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2392 /* If it's there, remap it. */
2394 *tp
= (tree
) n
->value
;
2397 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
2398 copy_statement_list (tp
);
2399 else if (TREE_CODE (*tp
) == BIND_EXPR
)
2400 copy_bind_expr (tp
, walk_subtrees
, id
);
2401 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2402 remap_save_expr (tp
, st
, walk_subtrees
);
2405 copy_tree_r (tp
, walk_subtrees
, NULL
);
2407 /* Do whatever unsaving is required. */
2408 unsave_expr_1 (*tp
);
2411 /* Keep iterating. */
2415 /* Default lang hook for "unsave_expr_now". Copies everything in EXPR and
2416 replaces variables, labels and SAVE_EXPRs local to EXPR. */
2419 lhd_unsave_expr_now (tree expr
)
2423 /* There's nothing to do for NULL_TREE. */
2428 memset (&id
, 0, sizeof (id
));
2429 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
2430 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
2431 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2433 /* Walk the tree once to find local labels. */
2434 walk_tree_without_duplicates (&expr
, mark_local_for_remap_r
, &id
);
2436 /* Walk the tree again, copying, remapping, and unsaving. */
2437 walk_tree (&expr
, unsave_r
, &id
, NULL
);
2440 splay_tree_delete (id
.decl_map
);
2445 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
2448 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
2457 debug_find_tree (tree top
, tree search
)
2459 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
2462 /* Declare the variables created by the inliner. Add all the variables in
2463 VARS to BIND_EXPR. */
2466 declare_inline_vars (tree bind_expr
, tree vars
)
2469 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
2470 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
2472 add_var_to_bind_expr (bind_expr
, vars
);