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. */
161 remap_decl (tree decl
, inline_data
*id
)
166 /* We only remap local variables in the current function. */
167 fn
= VARRAY_TOP_TREE (id
->fns
);
169 /* We need to remap statics, too, so that they get expanded even if the
170 inline function is never emitted out of line. We might as well also
171 remap extern decls so that they show up in the debug info. */
172 if (! lang_hooks
.tree_inlining
.auto_var_in_fn_p (decl
, fn
))
176 /* See if we have remapped this declaration. */
177 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
179 /* If we didn't already have an equivalent for this declaration,
185 /* Make a copy of the variable or label. */
186 t
= copy_decl_for_inlining (decl
, fn
, VARRAY_TREE (id
->fns
, 0));
188 /* Remap types, if necessary. */
189 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
190 if (TREE_CODE (t
) == TYPE_DECL
)
191 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
192 else if (TREE_CODE (t
) == PARM_DECL
)
193 DECL_ARG_TYPE_AS_WRITTEN (t
)
194 = remap_type (DECL_ARG_TYPE_AS_WRITTEN (t
), id
);
196 /* Remap sizes as necessary. */
197 walk_tree (&DECL_SIZE (t
), copy_body_r
, id
, NULL
);
198 walk_tree (&DECL_SIZE_UNIT (t
), copy_body_r
, id
, NULL
);
201 /* FIXME handle anon aggrs. */
202 if (! DECL_NAME (t
) && TREE_TYPE (t
)
203 && lang_hooks
.tree_inlining
.anon_aggr_type_p (TREE_TYPE (t
)))
205 /* For a VAR_DECL of anonymous type, we must also copy the
206 member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS. */
210 for (src
= DECL_ANON_UNION_ELEMS (t
); src
;
211 src
= TREE_CHAIN (src
))
213 tree member
= remap_decl (TREE_VALUE (src
), id
);
215 if (TREE_PURPOSE (src
))
217 members
= tree_cons (NULL
, member
, members
);
219 DECL_ANON_UNION_ELEMS (t
) = nreverse (members
);
223 /* Remember it, so that if we encounter this local entity
224 again we can reuse this copy. */
225 insert_decl_map (id
, decl
, t
);
229 return unshare_expr ((tree
) n
->value
);
233 remap_type (tree type
, inline_data
*id
)
235 splay_tree_node node
;
241 /* See if we have remapped this type. */
242 node
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) type
);
244 return (tree
) node
->value
;
246 /* The type only needs remapping if it's variably modified. */
247 if (! variably_modified_type_p (type
))
249 insert_decl_map (id
, type
, type
);
253 /* We do need a copy. build and register it now. */
254 new = copy_node (type
);
255 insert_decl_map (id
, type
, new);
257 /* This is a new type, not a copy of an old type. Need to reassociate
258 variants. We can handle everything except the main variant lazily. */
259 t
= TYPE_MAIN_VARIANT (type
);
262 t
= remap_type (t
, id
);
263 TYPE_MAIN_VARIANT (new) = t
;
264 TYPE_NEXT_VARIANT (new) = TYPE_MAIN_VARIANT (t
);
265 TYPE_NEXT_VARIANT (t
) = new;
269 TYPE_MAIN_VARIANT (new) = new;
270 TYPE_NEXT_VARIANT (new) = NULL
;
273 /* Lazily create pointer and reference types. */
274 TYPE_POINTER_TO (new) = NULL
;
275 TYPE_REFERENCE_TO (new) = NULL
;
277 switch (TREE_CODE (new))
284 t
= TYPE_MIN_VALUE (new);
285 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
286 walk_tree (&TYPE_MIN_VALUE (new), copy_body_r
, id
, NULL
);
288 t
= TYPE_MAX_VALUE (new);
289 if (t
&& TREE_CODE (t
) != INTEGER_CST
)
290 walk_tree (&TYPE_MAX_VALUE (new), copy_body_r
, id
, NULL
);
294 TREE_TYPE (new) = t
= remap_type (TREE_TYPE (new), id
);
295 TYPE_NEXT_PTR_TO (new) = TYPE_POINTER_TO (t
);
296 TYPE_POINTER_TO (t
) = new;
300 TREE_TYPE (new) = t
= remap_type (TREE_TYPE (new), id
);
301 TYPE_NEXT_REF_TO (new) = TYPE_REFERENCE_TO (t
);
302 TYPE_REFERENCE_TO (t
) = new;
307 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
308 walk_tree (&TYPE_ARG_TYPES (new), copy_body_r
, id
, NULL
);
312 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id
);
313 TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id
);
318 case QUAL_UNION_TYPE
:
319 walk_tree (&TYPE_FIELDS (new), copy_body_r
, id
, NULL
);
326 /* Shouldn't have been thought variable sized. */
330 walk_tree (&TYPE_SIZE (new), copy_body_r
, id
, NULL
);
331 walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r
, id
, NULL
);
337 remap_decls (tree decls
, inline_data
*id
)
340 tree new_decls
= NULL_TREE
;
342 /* Remap its variables. */
343 for (old_var
= decls
; old_var
; old_var
= TREE_CHAIN (old_var
))
347 /* Remap the variable. */
348 new_var
= remap_decl (old_var
, id
);
350 /* If we didn't remap this variable, so we can't mess with its
351 TREE_CHAIN. If we remapped this variable to the return slot, it's
352 already declared somewhere else, so don't declare it here. */
353 if (!new_var
|| new_var
== id
->retvar
)
355 #ifdef ENABLE_CHECKING
356 else if (!DECL_P (new_var
))
361 TREE_CHAIN (new_var
) = new_decls
;
366 return nreverse (new_decls
);
369 /* Copy the BLOCK to contain remapped versions of the variables
370 therein. And hook the new block into the block-tree. */
373 remap_block (tree
*block
, inline_data
*id
)
379 /* Make the new block. */
381 new_block
= make_node (BLOCK
);
382 TREE_USED (new_block
) = TREE_USED (old_block
);
383 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
386 /* Remap its variables. */
387 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
), id
);
389 fn
= VARRAY_TREE (id
->fns
, 0);
391 /* FIXME! It shouldn't be so hard to manage blocks. Rebuilding them in
392 rest_of_compilation is a good start. */
394 /* We're building a clone; DECL_INITIAL is still
395 error_mark_node, and current_binding_level is the parm
397 lang_hooks
.decls
.insert_block (new_block
);
400 /* Attach this new block after the DECL_INITIAL block for the
401 function into which this block is being inlined. In
402 rest_of_compilation we will straighten out the BLOCK tree. */
404 if (DECL_INITIAL (fn
))
405 first_block
= &BLOCK_CHAIN (DECL_INITIAL (fn
));
407 first_block
= &DECL_INITIAL (fn
);
408 BLOCK_CHAIN (new_block
) = *first_block
;
409 *first_block
= new_block
;
412 /* Remember the remapped block. */
413 insert_decl_map (id
, old_block
, new_block
);
417 copy_statement_list (tree
*tp
)
419 tree_stmt_iterator oi
, ni
;
422 new = alloc_stmt_list ();
423 ni
= tsi_start (new);
424 oi
= tsi_start (*tp
);
427 for (; !tsi_end_p (oi
); tsi_next (&oi
))
428 tsi_link_after (&ni
, tsi_stmt (oi
), TSI_NEW_STMT
);
432 copy_bind_expr (tree
*tp
, int *walk_subtrees
, inline_data
*id
)
434 tree block
= BIND_EXPR_BLOCK (*tp
);
435 /* Copy (and replace) the statement. */
436 copy_tree_r (tp
, walk_subtrees
, NULL
);
439 remap_block (&block
, id
);
440 BIND_EXPR_BLOCK (*tp
) = block
;
443 if (BIND_EXPR_VARS (*tp
))
444 /* This will remap a lot of the same decls again, but this should be
446 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), id
);
449 /* Called from copy_body via walk_tree. DATA is really an
452 copy_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
458 id
= (inline_data
*) data
;
459 fn
= VARRAY_TOP_TREE (id
->fns
);
462 /* All automatic variables should have a DECL_CONTEXT indicating
463 what function they come from. */
464 if ((TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == LABEL_DECL
)
465 && DECL_NAMESPACE_SCOPE_P (*tp
))
466 if (! DECL_EXTERNAL (*tp
) && ! TREE_STATIC (*tp
))
470 /* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
471 GOTO_EXPR with the RET_LABEL as its target. */
472 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->ret_label
)
474 tree return_stmt
= *tp
;
477 /* Build the GOTO_EXPR. */
478 tree assignment
= TREE_OPERAND (return_stmt
, 0);
479 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, id
->ret_label
);
480 TREE_USED (id
->ret_label
) = 1;
482 /* If we're returning something, just turn that into an
483 assignment into the equivalent of the original
487 /* Do not create a statement containing a naked RESULT_DECL. */
488 if (lang_hooks
.gimple_before_inlining
)
489 if (TREE_CODE (assignment
) == RESULT_DECL
)
490 gimplify_stmt (&assignment
);
492 *tp
= build (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
493 append_to_statement_list (assignment
, &BIND_EXPR_BODY (*tp
));
494 append_to_statement_list (goto_stmt
, &BIND_EXPR_BODY (*tp
));
496 /* If we're not returning anything just do the jump. */
500 /* Local variables and labels need to be replaced by equivalent
501 variables. We don't want to copy static variables; there's only
502 one of those, no matter how many times we inline the containing
504 else if (lang_hooks
.tree_inlining
.auto_var_in_fn_p (*tp
, fn
))
508 /* Remap the declaration. */
509 new_decl
= remap_decl (*tp
, id
);
512 /* Replace this variable with the copy. */
513 STRIP_TYPE_NOPS (new_decl
);
517 else if (nonstatic_local_decl_p (*tp
)
518 && DECL_CONTEXT (*tp
) != VARRAY_TREE (id
->fns
, 0))
521 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
522 copy_statement_list (tp
);
523 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
524 remap_save_expr (tp
, id
->decl_map
, VARRAY_TREE (id
->fns
, 0),
526 else if (TREE_CODE (*tp
) == UNSAVE_EXPR
)
527 /* UNSAVE_EXPRs should not be generated until expansion time. */
529 else if (TREE_CODE (*tp
) == BIND_EXPR
)
530 copy_bind_expr (tp
, walk_subtrees
, id
);
531 else if (TREE_CODE (*tp
) == LABELED_BLOCK_EXPR
)
533 /* We need a new copy of this labeled block; the EXIT_BLOCK_EXPR
534 will refer to it, so save a copy ready for remapping. We
535 save it in the decl_map, although it isn't a decl. */
536 tree new_block
= copy_node (*tp
);
537 insert_decl_map (id
, *tp
, new_block
);
540 else if (TREE_CODE (*tp
) == EXIT_BLOCK_EXPR
)
543 = splay_tree_lookup (id
->decl_map
,
544 (splay_tree_key
) TREE_OPERAND (*tp
, 0));
545 /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR. */
548 *tp
= copy_node (*tp
);
549 TREE_OPERAND (*tp
, 0) = (tree
) n
->value
;
551 /* Types may need remapping as well. */
552 else if (TYPE_P (*tp
))
553 *tp
= remap_type (*tp
, id
);
555 /* Otherwise, just copy the node. Note that copy_tree_r already
556 knows not to copy VAR_DECLs, etc., so this is safe. */
561 if (TREE_CODE (*tp
) == MODIFY_EXPR
562 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
563 && (lang_hooks
.tree_inlining
.auto_var_in_fn_p
564 (TREE_OPERAND (*tp
, 0), fn
)))
566 /* Some assignments VAR = VAR; don't generate any rtl code
567 and thus don't count as variable modification. Avoid
568 keeping bogosities like 0 = 0. */
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
;
576 STRIP_TYPE_NOPS (value
);
577 if (TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
580 return copy_body_r (tp
, walk_subtrees
, data
);
584 else if (TREE_CODE (*tp
) == ADDR_EXPR
585 && (lang_hooks
.tree_inlining
.auto_var_in_fn_p
586 (TREE_OPERAND (*tp
, 0), fn
)))
588 /* Get rid of &* from inline substitutions. It can occur when
589 someone takes the address of a parm or return slot passed by
590 invisible reference. */
591 tree decl
= TREE_OPERAND (*tp
, 0), value
;
594 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
597 value
= (tree
) n
->value
;
598 if (TREE_CODE (value
) == INDIRECT_REF
)
600 /* Assume that the argument types properly match the
601 parameter types. We can't compare them well enough
602 without a comptypes langhook, and we don't want to
603 call convert and introduce a NOP_EXPR to convert
604 between two equivalent types (i.e. that only differ
605 in use of typedef names). */
606 *tp
= TREE_OPERAND (value
, 0);
607 return copy_body_r (tp
, walk_subtrees
, data
);
611 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
613 /* Get rid of *& from inline substitutions that can happen when a
614 pointer argument is an ADDR_EXPR. */
615 tree decl
= TREE_OPERAND (*tp
, 0), value
;
618 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
621 value
= (tree
) n
->value
;
623 if (TREE_CODE (value
) == ADDR_EXPR
)
625 *tp
= TREE_OPERAND (value
, 0);
626 return copy_body_r (tp
, walk_subtrees
, data
);
631 copy_tree_r (tp
, walk_subtrees
, NULL
);
633 if (TREE_CODE (*tp
) == CALL_EXPR
&& id
->node
&& get_callee_fndecl (*tp
))
637 struct cgraph_node
*node
;
638 struct cgraph_edge
*edge
;
640 for (node
= id
->node
->next_clone
; node
; node
= node
->next_clone
)
642 edge
= cgraph_edge (node
, old_node
);
644 edge
->call_expr
= *tp
;
651 struct cgraph_edge
*edge
;
653 edge
= cgraph_edge (id
->current_node
, old_node
);
655 cgraph_clone_edge (edge
, id
->node
, *tp
);
659 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
661 /* The copied TARGET_EXPR has never been expanded, even if the
662 original node was expanded already. */
663 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
665 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
666 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
670 /* Keep iterating. */
674 /* Make a copy of the body of FN so that it can be inserted inline in
678 copy_body (inline_data
*id
)
681 tree fndecl
= VARRAY_TOP_TREE (id
->fns
);
683 if (fndecl
== current_function_decl
685 body
= cfun
->saved_tree
;
687 body
= DECL_SAVED_TREE (fndecl
);
688 walk_tree (&body
, copy_body_r
, id
, NULL
);
694 setup_one_parameter (inline_data
*id
, tree p
, tree value
,
695 tree fn
, tree
*init_stmts
, tree
*vars
,
696 bool *gimplify_init_stmts_p
)
702 /* If the parameter is never assigned to, we may not need to
703 create a new variable here at all. Instead, we may be able
704 to just use the argument value. */
705 if (TREE_READONLY (p
)
706 && !TREE_ADDRESSABLE (p
)
707 && value
&& !TREE_SIDE_EFFECTS (value
))
709 /* We can't risk substituting complex expressions. They
710 might contain variables that will be assigned to later.
711 Theoretically, we could check the expression to see if
712 all of the variables that determine its value are
713 read-only, but we don't bother. */
714 if ((TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
715 /* We may produce non-gimple trees by adding NOPs or introduce
716 invalid sharing when operand is not really constant.
717 It is not big deal to prohibit constant propagation here as
718 we will constant propagate in DOM1 pass anyway. */
719 && (!lang_hooks
.gimple_before_inlining
720 || (is_gimple_min_invariant (value
)
721 && TREE_TYPE (value
) == TREE_TYPE (p
))))
723 /* If this is a declaration, wrap it a NOP_EXPR so that
724 we don't try to put the VALUE on the list of BLOCK_VARS. */
726 value
= build1 (NOP_EXPR
, TREE_TYPE (value
), value
);
728 /* If this is a constant, make sure it has the right type. */
729 else if (TREE_TYPE (value
) != TREE_TYPE (p
))
730 value
= fold (build1 (NOP_EXPR
, TREE_TYPE (p
), value
));
732 insert_decl_map (id
, p
, value
);
737 /* Make an equivalent VAR_DECL. */
738 var
= copy_decl_for_inlining (p
, fn
, VARRAY_TREE (id
->fns
, 0));
740 /* See if the frontend wants to pass this by invisible reference. If
741 so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
742 replace uses of the PARM_DECL with dereferences. */
743 if (TREE_TYPE (var
) != TREE_TYPE (p
)
744 && POINTER_TYPE_P (TREE_TYPE (var
))
745 && TREE_TYPE (TREE_TYPE (var
)) == TREE_TYPE (p
))
747 insert_decl_map (id
, var
, var
);
748 var_sub
= build1 (INDIRECT_REF
, TREE_TYPE (p
), var
);
753 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
754 that way, when the PARM_DECL is encountered, it will be
755 automatically replaced by the VAR_DECL. */
756 insert_decl_map (id
, p
, var_sub
);
758 /* Declare this new variable. */
759 TREE_CHAIN (var
) = *vars
;
762 /* Make gimplifier happy about this variable. */
763 var
->decl
.seen_in_bind_expr
= lang_hooks
.gimple_before_inlining
;
765 /* Even if P was TREE_READONLY, the new VAR should not be.
766 In the original code, we would have constructed a
767 temporary, and then the function body would have never
768 changed the value of P. However, now, we will be
769 constructing VAR directly. The constructor body may
770 change its value multiple times as it is being
771 constructed. Therefore, it must not be TREE_READONLY;
772 the back-end assumes that TREE_READONLY variable is
773 assigned to only once. */
774 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
775 TREE_READONLY (var
) = 0;
777 /* Initialize this VAR_DECL from the equivalent argument. Convert
778 the argument to the proper type in case it was promoted. */
781 tree rhs
= fold_convert (TREE_TYPE (var
), value
);
783 if (rhs
== error_mark_node
)
786 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
787 keep our trees in gimple form. */
788 init_stmt
= build (MODIFY_EXPR
, TREE_TYPE (var
), var
, rhs
);
789 append_to_statement_list (init_stmt
, init_stmts
);
791 /* If we did not create a gimple value and we did not create a gimple
792 cast of a gimple value, then we will need to gimplify INIT_STMTS
793 at the end. Note that is_gimple_cast only checks the outer
794 tree code, not its operand. Thus the explicit check that it's
795 operand is a gimple value. */
796 if (!is_gimple_val (rhs
)
797 && (!is_gimple_cast (rhs
)
798 || !is_gimple_val (TREE_OPERAND (rhs
, 0))))
799 *gimplify_init_stmts_p
= true;
803 /* Generate code to initialize the parameters of the function at the
804 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
807 initialize_inlined_parameters (inline_data
*id
, tree args
, tree static_chain
,
808 tree fn
, tree bind_expr
)
810 tree init_stmts
= NULL_TREE
;
814 tree vars
= NULL_TREE
;
815 bool gimplify_init_stmts_p
= false;
818 /* Figure out what the parameters are. */
819 parms
= DECL_ARGUMENTS (fn
);
820 if (fn
== current_function_decl
)
821 parms
= cfun
->saved_args
;
823 /* Loop through the parameter declarations, replacing each with an
824 equivalent VAR_DECL, appropriately initialized. */
825 for (p
= parms
, a
= args
; p
;
826 a
= a
? TREE_CHAIN (a
) : a
, p
= TREE_CHAIN (p
))
832 /* Find the initializer. */
833 value
= lang_hooks
.tree_inlining
.convert_parm_for_inlining
834 (p
, a
? TREE_VALUE (a
) : NULL_TREE
, fn
, argnum
);
836 setup_one_parameter (id
, p
, value
, fn
, &init_stmts
, &vars
,
837 &gimplify_init_stmts_p
);
840 /* Evaluate trailing arguments. */
841 for (; a
; a
= TREE_CHAIN (a
))
843 tree value
= TREE_VALUE (a
);
844 append_to_statement_list (value
, &init_stmts
);
847 /* Initialize the static chain. */
848 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
851 /* No static chain? Seems like a bug in tree-nested.c. */
855 setup_one_parameter (id
, p
, static_chain
, fn
, &init_stmts
, &vars
,
856 &gimplify_init_stmts_p
);
859 if (gimplify_init_stmts_p
&& lang_hooks
.gimple_before_inlining
)
860 gimplify_body (&init_stmts
, fn
);
862 declare_inline_vars (bind_expr
, vars
);
866 /* Declare a return variable to replace the RESULT_DECL for the
867 function we are calling. An appropriate DECL_STMT is returned.
868 The USE_STMT is filled in to contain a use of the declaration to
869 indicate the return value of the function. */
872 declare_return_variable (inline_data
*id
, tree return_slot_addr
, tree
*use_p
)
874 tree fn
= VARRAY_TOP_TREE (id
->fns
);
875 tree result
= DECL_RESULT (fn
);
876 int need_return_decl
= 1;
879 /* We don't need to do anything for functions that don't return
881 if (!result
|| VOID_TYPE_P (TREE_TYPE (result
)))
887 var
= (lang_hooks
.tree_inlining
.copy_res_decl_for_inlining
888 (result
, fn
, VARRAY_TREE (id
->fns
, 0), id
->decl_map
,
889 &need_return_decl
, return_slot_addr
));
891 /* Do not have the rest of GCC warn about this variable as it should
892 not be visible to the user. */
893 TREE_NO_WARNING (var
) = 1;
895 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
896 way, when the RESULT_DECL is encountered, it will be
897 automatically replaced by the VAR_DECL. */
898 insert_decl_map (id
, result
, var
);
900 /* Remember this so we can ignore it in remap_decls. */
903 /* Build the use expr. If the return type of the function was
904 promoted, convert it back to the expected type. */
905 if (return_slot_addr
)
906 /* The function returns through an explicit return slot, not a normal
909 else if (TREE_TYPE (var
) == TREE_TYPE (TREE_TYPE (fn
)))
911 else if (TREE_CODE (var
) == INDIRECT_REF
)
912 *use_p
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (fn
)),
913 TREE_OPERAND (var
, 0));
914 else if (TREE_ADDRESSABLE (TREE_TYPE (var
)))
917 *use_p
= build1 (NOP_EXPR
, TREE_TYPE (TREE_TYPE (fn
)), var
);
919 /* Build the declaration statement if FN does not return an
921 if (need_return_decl
)
923 /* If FN does return an aggregate, there's no need to declare the
924 return variable; we're using a variable in our caller's frame. */
929 /* Returns nonzero if a function can be inlined as a tree. */
932 tree_inlinable_function_p (tree fn
)
934 return inlinable_function_p (fn
);
937 static const char *inline_forbidden_reason
;
940 inline_forbidden_p_1 (tree
*nodep
, int *walk_subtrees ATTRIBUTE_UNUSED
,
944 tree fn
= (tree
) fnp
;
947 switch (TREE_CODE (node
))
950 /* Refuse to inline alloca call unless user explicitly forced so as
951 this may change program's memory overhead drastically when the
952 function using alloca is called in loop. In GCC present in
953 SPEC2000 inlining into schedule_block cause it to require 2GB of
954 RAM instead of 256MB. */
955 if (alloca_call_p (node
)
956 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
958 inline_forbidden_reason
959 = N_("%Jfunction '%F' can never be inlined because it uses "
960 "alloca (override using the always_inline attribute)");
963 t
= get_callee_fndecl (node
);
968 /* We cannot inline functions that call setjmp. */
969 if (setjmp_call_p (t
))
971 inline_forbidden_reason
972 = N_("%Jfunction '%F' can never be inlined because it uses setjmp");
976 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
977 switch (DECL_FUNCTION_CODE (t
))
979 /* We cannot inline functions that take a variable number of
981 case BUILT_IN_VA_START
:
982 case BUILT_IN_STDARG_START
:
983 case BUILT_IN_NEXT_ARG
:
984 case BUILT_IN_VA_END
:
985 inline_forbidden_reason
986 = N_("%Jfunction '%F' can never be inlined because it "
987 "uses variable argument lists");
990 case BUILT_IN_LONGJMP
:
991 /* We can't inline functions that call __builtin_longjmp at
992 all. The non-local goto machinery really requires the
993 destination be in a different function. If we allow the
994 function calling __builtin_longjmp to be inlined into the
995 function calling __builtin_setjmp, Things will Go Awry. */
996 inline_forbidden_reason
997 = N_("%Jfunction '%F' can never be inlined because "
998 "it uses setjmp-longjmp exception handling");
1001 case BUILT_IN_NONLOCAL_GOTO
:
1003 inline_forbidden_reason
1004 = N_("%Jfunction '%F' can never be inlined because "
1005 "it uses non-local goto");
1014 for (t
= BIND_EXPR_VARS (node
); t
; t
= TREE_CHAIN (t
))
1016 /* We cannot inline functions that contain other functions. */
1017 if (TREE_CODE (t
) == FUNCTION_DECL
&& DECL_INITIAL (t
))
1019 inline_forbidden_reason
1020 = N_("%Jfunction '%F' can never be inlined "
1021 "because it contains a nested function");
1028 t
= TREE_OPERAND (node
, 0);
1030 /* We will not inline a function which uses computed goto. The
1031 addresses of its local labels, which may be tucked into
1032 global storage, are of course not constant across
1033 instantiations, which causes unexpected behavior. */
1034 if (TREE_CODE (t
) != LABEL_DECL
)
1036 inline_forbidden_reason
1037 = N_("%Jfunction '%F' can never be inlined "
1038 "because it contains a computed goto");
1044 t
= TREE_OPERAND (node
, 0);
1045 if (DECL_NONLOCAL (t
))
1047 /* We cannot inline a function that receives a non-local goto
1048 because we cannot remap the destination label used in the
1049 function that is performing the non-local goto. */
1050 inline_forbidden_reason
1051 = N_("%Jfunction '%F' can never be inlined "
1052 "because it receives a non-local goto");
1058 /* We cannot inline a function of the form
1060 void F (int i) { struct S { int ar[i]; } s; }
1062 Attempting to do so produces a catch-22.
1063 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1064 UNION_TYPE nodes, then it goes into infinite recursion on a
1065 structure containing a pointer to its own type. If it doesn't,
1066 then the type node for S doesn't get adjusted properly when
1067 F is inlined, and we abort in find_function_data. */
1068 for (t
= TYPE_FIELDS (node
); t
; t
= TREE_CHAIN (t
))
1069 if (variably_modified_type_p (TREE_TYPE (t
)))
1071 inline_forbidden_reason
1072 = N_("%Jfunction '%F' can never be inlined "
1073 "because it uses variable sized variables");
1084 /* Return subexpression representing possible alloca call, if any. */
1086 inline_forbidden_p (tree fndecl
)
1088 location_t saved_loc
= input_location
;
1089 tree ret
= walk_tree_without_duplicates
1090 (&DECL_SAVED_TREE (fndecl
), inline_forbidden_p_1
, fndecl
);
1091 input_location
= saved_loc
;
1095 /* Returns nonzero if FN is a function that does not have any
1096 fundamental inline blocking properties. */
1099 inlinable_function_p (tree fn
)
1101 bool inlinable
= true;
1103 /* If we've already decided this function shouldn't be inlined,
1104 there's no need to check again. */
1105 if (DECL_UNINLINABLE (fn
))
1108 /* See if there is any language-specific reason it cannot be
1109 inlined. (It is important that this hook be called early because
1110 in C++ it may result in template instantiation.)
1111 If the function is not inlinable for language-specific reasons,
1112 it is left up to the langhook to explain why. */
1113 inlinable
= !lang_hooks
.tree_inlining
.cannot_inline_tree_fn (&fn
);
1115 /* If we don't have the function body available, we can't inline it.
1116 However, this should not be recorded since we also get here for
1117 forward declared inline functions. Therefore, return at once. */
1118 if (!DECL_SAVED_TREE (fn
))
1121 /* If we're not inlining at all, then we cannot inline this function. */
1122 else if (!flag_inline_trees
)
1125 /* Only try to inline functions if DECL_INLINE is set. This should be
1126 true for all functions declared `inline', and for all other functions
1127 as well with -finline-functions.
1129 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1130 it's the front-end that must set DECL_INLINE in this case, because
1131 dwarf2out loses if a function that does not have DECL_INLINE set is
1132 inlined anyway. That is why we have both DECL_INLINE and
1133 DECL_DECLARED_INLINE_P. */
1134 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1135 here should be redundant. */
1136 else if (!DECL_INLINE (fn
) && !flag_unit_at_a_time
)
1139 #ifdef INLINER_FOR_JAVA
1140 /* Synchronized methods can't be inlined. This is a bug. */
1141 else if (METHOD_SYNCHRONIZED (fn
))
1143 #endif /* INLINER_FOR_JAVA */
1145 else if (inline_forbidden_p (fn
))
1147 /* See if we should warn about uninlinable functions. Previously,
1148 some of these warnings would be issued while trying to expand
1149 the function inline, but that would cause multiple warnings
1150 about functions that would for example call alloca. But since
1151 this a property of the function, just one warning is enough.
1152 As a bonus we can now give more details about the reason why a
1153 function is not inlinable.
1154 We only warn for functions declared `inline' by the user. */
1155 bool do_warning
= (warn_inline
1157 && DECL_DECLARED_INLINE_P (fn
)
1158 && !DECL_IN_SYSTEM_HEADER (fn
));
1160 if (lookup_attribute ("always_inline",
1161 DECL_ATTRIBUTES (fn
)))
1162 sorry (inline_forbidden_reason
, fn
, fn
);
1163 else if (do_warning
)
1164 warning (inline_forbidden_reason
, fn
, fn
);
1169 /* Squirrel away the result so that we don't have to check again. */
1170 DECL_UNINLINABLE (fn
) = !inlinable
;
1175 /* Used by estimate_num_insns. Estimate number of instructions seen
1176 by given statement. */
1178 estimate_num_insns_1 (tree
*tp
, int *walk_subtrees
, void *data
)
1183 if (TYPE_P (x
) || DECL_P (x
))
1188 /* Assume that constants and references counts nothing. These should
1189 be majorized by amount of operations among them we count later
1190 and are common target of CSE and similar optimizations. */
1191 if (TREE_CODE_CLASS (TREE_CODE (x
)) == 'c'
1192 || TREE_CODE_CLASS (TREE_CODE (x
)) == 'r')
1194 switch (TREE_CODE (x
))
1196 /* Containers have no cost. */
1205 case ARRAY_RANGE_REF
:
1207 case EXC_PTR_EXPR
: /* ??? */
1208 case FILTER_EXPR
: /* ??? */
1211 case LABELED_BLOCK_EXPR
:
1212 case WITH_CLEANUP_EXPR
:
1214 case VIEW_CONVERT_EXPR
:
1218 case REFERENCE_EXPR
:
1222 case EXIT_BLOCK_EXPR
:
1223 case CASE_LABEL_EXPR
:
1226 case EH_FILTER_EXPR
:
1227 case STATEMENT_LIST
:
1229 case NON_LVALUE_EXPR
:
1230 case ENTRY_VALUE_EXPR
:
1233 case TRY_CATCH_EXPR
:
1234 case TRY_FINALLY_EXPR
:
1242 /* We don't account constants for now. Assume that the cost is amortized
1243 by operations that do use them. We may re-consider this decision once
1244 we are able to optimize the tree before estimating it's size and break
1245 out static initializers. */
1246 case IDENTIFIER_NODE
:
1254 /* Recognize assignments of large structures and constructors of
1263 size
= int_size_in_bytes (TREE_TYPE (x
));
1265 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO
)
1268 *count
+= ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
1272 /* Assign cost of 1 to usual operations.
1273 ??? We may consider mapping RTL costs to this. */
1280 case FIX_TRUNC_EXPR
:
1282 case FIX_FLOOR_EXPR
:
1283 case FIX_ROUND_EXPR
:
1301 case TRUTH_ANDIF_EXPR
:
1302 case TRUTH_ORIF_EXPR
:
1303 case TRUTH_AND_EXPR
:
1305 case TRUTH_XOR_EXPR
:
1306 case TRUTH_NOT_EXPR
:
1315 case UNORDERED_EXPR
:
1328 case PREDECREMENT_EXPR
:
1329 case PREINCREMENT_EXPR
:
1330 case POSTDECREMENT_EXPR
:
1331 case POSTINCREMENT_EXPR
:
1341 /* Few special cases of expensive operations. This is useful
1342 to avoid inlining on functions having too many of these. */
1343 case TRUNC_DIV_EXPR
:
1345 case FLOOR_DIV_EXPR
:
1346 case ROUND_DIV_EXPR
:
1347 case EXACT_DIV_EXPR
:
1348 case TRUNC_MOD_EXPR
:
1350 case FLOOR_MOD_EXPR
:
1351 case ROUND_MOD_EXPR
:
1357 tree decl
= get_callee_fndecl (x
);
1359 if (decl
&& DECL_BUILT_IN (decl
))
1360 switch (DECL_FUNCTION_CODE (decl
))
1362 case BUILT_IN_CONSTANT_P
:
1365 case BUILT_IN_EXPECT
:
1374 /* Abort here se we know we don't miss any nodes. */
1380 /* Estimate number of instructions that will be created by expanding EXPR. */
1382 estimate_num_insns (tree expr
)
1385 walk_tree_without_duplicates (&expr
, estimate_num_insns_1
, &num
);
1389 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1392 expand_call_inline (tree
*tp
, int *walk_subtrees
, void *data
)
1406 tree return_slot_addr
;
1407 location_t saved_location
;
1408 struct cgraph_edge
*edge
;
1411 /* See what we've got. */
1412 id
= (inline_data
*) data
;
1415 /* Set input_location here so we get the right instantiation context
1416 if we call instantiate_decl from inlinable_function_p. */
1417 saved_location
= input_location
;
1418 if (EXPR_HAS_LOCATION (t
))
1419 input_location
= EXPR_LOCATION (t
);
1421 /* Recurse, but letting recursive invocations know that we are
1422 inside the body of a TARGET_EXPR. */
1423 if (TREE_CODE (*tp
) == TARGET_EXPR
)
1426 int i
, len
= first_rtl_op (TARGET_EXPR
);
1428 /* We're walking our own subtrees. */
1431 /* Actually walk over them. This loop is the body of
1432 walk_trees, omitting the case where the TARGET_EXPR
1433 itself is handled. */
1434 for (i
= 0; i
< len
; ++i
)
1437 ++id
->in_target_cleanup_p
;
1438 walk_tree (&TREE_OPERAND (*tp
, i
), expand_call_inline
, data
,
1441 --id
->in_target_cleanup_p
;
1449 /* Because types were not copied in copy_body, CALL_EXPRs beneath
1450 them should not be expanded. This can happen if the type is a
1451 dynamic array type, for example. */
1454 /* From here on, we're only interested in CALL_EXPRs. */
1455 if (TREE_CODE (t
) != CALL_EXPR
)
1458 /* First, see if we can figure out what function is being called.
1459 If we cannot, then there is no hope of inlining the function. */
1460 fn
= get_callee_fndecl (t
);
1464 /* Turn forward declarations into real ones. */
1465 fn
= cgraph_node (fn
)->decl
;
1467 /* If fn is a declaration of a function in a nested scope that was
1468 globally declared inline, we don't set its DECL_INITIAL.
1469 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1470 C++ front-end uses it for cdtors to refer to their internal
1471 declarations, that are not real functions. Fortunately those
1472 don't have trees to be saved, so we can tell by checking their
1474 if (! DECL_INITIAL (fn
)
1475 && DECL_ABSTRACT_ORIGIN (fn
)
1476 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn
)))
1477 fn
= DECL_ABSTRACT_ORIGIN (fn
);
1479 /* Objective C and fortran still calls tree_rest_of_compilation directly.
1480 Kill this check once this is fixed. */
1481 if (!id
->current_node
->analyzed
)
1484 edge
= cgraph_edge (id
->current_node
, t
);
1486 /* Constant propagation on argument done during previous inlining
1487 may create new direct call. Produce an edge for it. */
1490 struct cgraph_node
*dest
= cgraph_node (fn
);
1492 /* We have missing edge in the callgraph. This can happen in one case
1493 where previous inlining turned indirect call into direct call by
1494 constant propagating arguments. In all other cases we hit a bug
1495 (incorrect node sharing is most common reason for missing edges. */
1498 cgraph_create_edge (id
->node
, dest
, t
)->inline_failed
1499 = N_("originally indirect function call not considered for inlining");
1503 /* Don't try to inline functions that are not well-suited to
1505 if (!cgraph_inline_p (edge
, &reason
))
1507 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1509 sorry ("%Jinlining failed in call to '%F': %s", fn
, fn
, reason
);
1510 sorry ("called from here");
1512 else if (warn_inline
&& DECL_DECLARED_INLINE_P (fn
)
1513 && !DECL_IN_SYSTEM_HEADER (fn
)
1516 warning ("%Jinlining failed in call to '%F': %s", fn
, fn
, reason
);
1517 warning ("called from here");
1522 #ifdef ENABLE_CHECKING
1523 if (edge
->callee
->decl
!= id
->node
->decl
)
1524 verify_cgraph_node (edge
->callee
);
1527 if (! lang_hooks
.tree_inlining
.start_inlining (fn
))
1530 /* Build a block containing code to initialize the arguments, the
1531 actual inline expansion of the body, and a label for the return
1532 statements within the function to jump to. The type of the
1533 statement expression is the return type of the function call. */
1535 expr
= build (BIND_EXPR
, TREE_TYPE (TREE_TYPE (fn
)), NULL_TREE
,
1536 stmt
, make_node (BLOCK
));
1537 BLOCK_ABSTRACT_ORIGIN (BIND_EXPR_BLOCK (expr
)) = fn
;
1539 /* Local declarations will be replaced by their equivalents in this
1542 id
->decl_map
= splay_tree_new (splay_tree_compare_pointers
,
1545 /* Initialize the parameters. */
1546 args
= TREE_OPERAND (t
, 1);
1547 return_slot_addr
= NULL_TREE
;
1548 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t
))
1550 return_slot_addr
= TREE_VALUE (args
);
1551 args
= TREE_CHAIN (args
);
1552 TREE_TYPE (expr
) = void_type_node
;
1555 arg_inits
= initialize_inlined_parameters (id
, args
, TREE_OPERAND (t
, 2),
1559 /* Expand any inlined calls in the initializers. Do this before we
1560 push FN on the stack of functions we are inlining; we want to
1561 inline calls to FN that appear in the initializers for the
1564 Note we need to save and restore the saved tree statement iterator
1565 to avoid having it clobbered by expand_calls_inline. */
1566 tree_stmt_iterator save_tsi
;
1569 expand_calls_inline (&arg_inits
, id
);
1572 /* And add them to the tree. */
1573 append_to_statement_list (arg_inits
, &BIND_EXPR_BODY (expr
));
1576 /* Record the function we are about to inline so that we can avoid
1577 recursing into it. */
1578 VARRAY_PUSH_TREE (id
->fns
, fn
);
1580 /* Record the function we are about to inline if optimize_function
1581 has not been called on it yet and we don't have it in the list. */
1582 if (! DECL_INLINED_FNS (fn
))
1586 for (i
= VARRAY_ACTIVE_SIZE (id
->inlined_fns
) - 1; i
>= 0; i
--)
1587 if (VARRAY_TREE (id
->inlined_fns
, i
) == fn
)
1590 VARRAY_PUSH_TREE (id
->inlined_fns
, fn
);
1593 /* Return statements in the function body will be replaced by jumps
1594 to the RET_LABEL. */
1595 id
->ret_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
1596 DECL_ARTIFICIAL (id
->ret_label
) = 1;
1597 DECL_CONTEXT (id
->ret_label
) = VARRAY_TREE (id
->fns
, 0);
1598 insert_decl_map (id
, id
->ret_label
, id
->ret_label
);
1600 if (! DECL_INITIAL (fn
)
1601 || TREE_CODE (DECL_INITIAL (fn
)) != BLOCK
)
1604 /* Declare the return variable for the function. */
1605 decl
= declare_return_variable (id
, return_slot_addr
, &use_retvar
);
1607 declare_inline_vars (expr
, decl
);
1609 /* After we've initialized the parameters, we insert the body of the
1612 struct cgraph_node
*old_node
= id
->current_node
;
1614 id
->current_node
= edge
->callee
;
1615 append_to_statement_list (copy_body (id
), &BIND_EXPR_BODY (expr
));
1616 id
->current_node
= old_node
;
1618 inlined_body
= &BIND_EXPR_BODY (expr
);
1620 /* After the body of the function comes the RET_LABEL. This must come
1621 before we evaluate the returned value below, because that evaluation
1622 may cause RTL to be generated. */
1623 if (TREE_USED (id
->ret_label
))
1625 tree label
= build1 (LABEL_EXPR
, void_type_node
, id
->ret_label
);
1626 append_to_statement_list (label
, &BIND_EXPR_BODY (expr
));
1629 /* Finally, mention the returned value so that the value of the
1630 statement-expression is the returned value of the function. */
1632 /* Set TREE_TYPE on BIND_EXPR? */
1633 append_to_statement_list_force (use_retvar
, &BIND_EXPR_BODY (expr
));
1636 splay_tree_delete (id
->decl_map
);
1639 /* The new expression has side-effects if the old one did. */
1640 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (t
);
1642 /* If we are working with gimple form, then we need to keep the tree
1643 in gimple form. If we are not in gimple form, we can just replace
1644 *tp with the new BIND_EXPR. */
1645 if (lang_hooks
.gimple_before_inlining
)
1649 /* Keep the new trees in gimple form. */
1650 BIND_EXPR_BODY (expr
)
1651 = rationalize_compound_expr (BIND_EXPR_BODY (expr
));
1653 /* We want to create a new variable to hold the result of the
1654 inlined body. This new variable needs to be added to the
1655 function which we are inlining into, thus the saving and
1656 restoring of current_function_decl. */
1657 save_decl
= current_function_decl
;
1658 current_function_decl
= id
->node
->decl
;
1659 inline_result
= voidify_wrapper_expr (expr
, NULL
);
1660 current_function_decl
= save_decl
;
1662 /* If the inlined function returns a result that we care about,
1663 then we're going to need to splice in a MODIFY_EXPR. Otherwise
1664 the call was a standalone statement and we can just replace it
1665 with the BIND_EXPR inline representation of the called function. */
1666 if (TREE_CODE (tsi_stmt (id
->tsi
)) != CALL_EXPR
)
1668 tsi_link_before (&id
->tsi
, expr
, TSI_SAME_STMT
);
1669 *tp
= inline_result
;
1674 /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS
1675 on the call if it is to a "const" function. Thus the copy of
1676 TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above
1677 with result in TREE_SIDE_EFFECTS not being set for the inlined
1678 copy of a "const" function.
1680 Unfortunately, that is wrong as inlining the function
1681 can create/expose interesting side effects (such as setting
1684 The easiest solution is to simply recalculate TREE_SIDE_EFFECTS
1685 for the toplevel expression. */
1686 recalculate_side_effects (expr
);
1691 /* If the value of the new expression is ignored, that's OK. We
1692 don't warn about this for CALL_EXPRs, so we shouldn't warn about
1693 the equivalent inlined version either. */
1694 TREE_USED (*tp
) = 1;
1696 /* Update callgraph if needed. */
1697 cgraph_remove_node (edge
->callee
);
1699 /* Recurse into the body of the just inlined function. */
1700 expand_calls_inline (inlined_body
, id
);
1701 VARRAY_POP (id
->fns
);
1703 /* Don't walk into subtrees. We've already handled them above. */
1706 lang_hooks
.tree_inlining
.end_inlining (fn
);
1708 /* Keep iterating. */
1710 input_location
= saved_location
;
1715 gimple_expand_calls_inline (tree
*stmt_p
, inline_data
*id
)
1717 tree stmt
= *stmt_p
;
1718 enum tree_code code
= TREE_CODE (stmt
);
1723 case STATEMENT_LIST
:
1725 tree_stmt_iterator i
;
1728 for (i
= tsi_start (stmt
); !tsi_end_p (i
); )
1731 gimple_expand_calls_inline (tsi_stmt_ptr (i
), id
);
1734 if (TREE_CODE (new) == STATEMENT_LIST
)
1736 tsi_link_before (&i
, new, TSI_SAME_STMT
);
1746 gimple_expand_calls_inline (&COND_EXPR_THEN (stmt
), id
);
1747 gimple_expand_calls_inline (&COND_EXPR_ELSE (stmt
), id
);
1750 gimple_expand_calls_inline (&CATCH_BODY (stmt
), id
);
1752 case EH_FILTER_EXPR
:
1753 gimple_expand_calls_inline (&EH_FILTER_FAILURE (stmt
), id
);
1755 case TRY_CATCH_EXPR
:
1756 case TRY_FINALLY_EXPR
:
1757 gimple_expand_calls_inline (&TREE_OPERAND (stmt
, 0), id
);
1758 gimple_expand_calls_inline (&TREE_OPERAND (stmt
, 1), id
);
1761 gimple_expand_calls_inline (&BIND_EXPR_BODY (stmt
), id
);
1765 /* We're gimple. We should have gotten rid of all these. */
1769 stmt_p
= &TREE_OPERAND (stmt
, 0);
1771 if (!stmt
|| TREE_CODE (stmt
) != MODIFY_EXPR
)
1775 stmt_p
= &TREE_OPERAND (stmt
, 1);
1777 if (TREE_CODE (stmt
) != CALL_EXPR
)
1781 expand_call_inline (stmt_p
, &dummy
, id
);
1789 /* Walk over the entire tree *TP, replacing CALL_EXPRs with inline
1790 expansions as appropriate. */
1793 expand_calls_inline (tree
*tp
, inline_data
*id
)
1795 /* If we are not in gimple form, then we want to walk the tree
1796 recursively as we do not know anything about the structure
1799 if (!lang_hooks
.gimple_before_inlining
)
1801 walk_tree (tp
, expand_call_inline
, id
, id
->tree_pruner
);
1805 /* We are in gimple form. We want to stay in gimple form. Walk
1806 the statements, inlining calls in each statement. By walking
1807 the statements, we have enough information to keep the tree
1808 in gimple form as we insert inline bodies. */
1810 gimple_expand_calls_inline (tp
, id
);
1813 /* Expand calls to inline functions in the body of FN. */
1816 optimize_inline_calls (tree fn
)
1821 /* There is no point in performing inlining if errors have already
1822 occurred -- and we might crash if we try to inline invalid
1824 if (errorcount
|| sorrycount
)
1828 memset (&id
, 0, sizeof (id
));
1830 id
.current_node
= id
.node
= cgraph_node (fn
);
1831 /* Don't allow recursion into FN. */
1832 VARRAY_TREE_INIT (id
.fns
, 32, "fns");
1833 VARRAY_PUSH_TREE (id
.fns
, fn
);
1834 /* Or any functions that aren't finished yet. */
1835 prev_fn
= NULL_TREE
;
1836 if (current_function_decl
)
1838 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
1839 prev_fn
= current_function_decl
;
1842 prev_fn
= (lang_hooks
.tree_inlining
.add_pending_fn_decls
1843 (&id
.fns
, prev_fn
));
1845 /* Create the list of functions this call will inline. */
1846 VARRAY_TREE_INIT (id
.inlined_fns
, 32, "inlined_fns");
1848 /* Keep track of the low-water mark, i.e., the point where the first
1849 real inlining is represented in ID.FNS. */
1850 id
.first_inlined_fn
= VARRAY_ACTIVE_SIZE (id
.fns
);
1852 /* Replace all calls to inline functions with the bodies of those
1854 id
.tree_pruner
= htab_create (37, htab_hash_pointer
,
1855 htab_eq_pointer
, NULL
);
1856 expand_calls_inline (&DECL_SAVED_TREE (fn
), &id
);
1859 htab_delete (id
.tree_pruner
);
1860 if (DECL_LANG_SPECIFIC (fn
))
1862 tree ifn
= make_tree_vec (VARRAY_ACTIVE_SIZE (id
.inlined_fns
));
1864 if (VARRAY_ACTIVE_SIZE (id
.inlined_fns
))
1865 memcpy (&TREE_VEC_ELT (ifn
, 0), &VARRAY_TREE (id
.inlined_fns
, 0),
1866 VARRAY_ACTIVE_SIZE (id
.inlined_fns
) * sizeof (tree
));
1867 DECL_INLINED_FNS (fn
) = ifn
;
1870 #ifdef ENABLE_CHECKING
1872 struct cgraph_edge
*e
;
1874 verify_cgraph_node (id
.node
);
1876 /* Double check that we inlined everything we are supposed to inline. */
1877 for (e
= id
.node
->callees
; e
; e
= e
->next_callee
)
1878 if (!e
->inline_failed
)
1884 /* FN is a function that has a complete body, and CLONE is a function
1885 whose body is to be set to a copy of FN, mapping argument
1886 declarations according to the ARG_MAP splay_tree. */
1889 clone_body (tree clone
, tree fn
, void *arg_map
)
1893 /* Clone the body, as if we were making an inline call. But, remap
1894 the parameters in the callee to the parameters of caller. If
1895 there's an in-charge parameter, map it to an appropriate
1897 memset (&id
, 0, sizeof (id
));
1898 VARRAY_TREE_INIT (id
.fns
, 2, "fns");
1899 VARRAY_PUSH_TREE (id
.fns
, clone
);
1900 VARRAY_PUSH_TREE (id
.fns
, fn
);
1901 id
.decl_map
= (splay_tree
)arg_map
;
1903 /* Cloning is treated slightly differently from inlining. Set
1904 CLONING_P so that it's clear which operation we're performing. */
1905 id
.cloning_p
= true;
1907 /* Actually copy the body. */
1908 append_to_statement_list_force (copy_body (&id
), &DECL_SAVED_TREE (clone
));
1911 /* Save duplicate of body in FN. MAP is used to pass around splay tree
1912 used to update arguments in restore_body. */
1914 save_body (tree fn
, tree
*arg_copy
)
1919 memset (&id
, 0, sizeof (id
));
1920 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
1921 VARRAY_PUSH_TREE (id
.fns
, fn
);
1922 id
.node
= cgraph_node (fn
);
1924 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
1925 *arg_copy
= DECL_ARGUMENTS (fn
);
1926 for (parg
= arg_copy
; *parg
; parg
= &TREE_CHAIN (*parg
))
1928 tree
new = copy_node (*parg
);
1929 lang_hooks
.dup_lang_specific_decl (new);
1930 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg
);
1931 insert_decl_map (&id
, *parg
, new);
1932 TREE_CHAIN (new) = TREE_CHAIN (*parg
);
1935 insert_decl_map (&id
, DECL_RESULT (fn
), DECL_RESULT (fn
));
1937 /* Actually copy the body. */
1938 body
= copy_body (&id
);
1941 splay_tree_delete (id
.decl_map
);
1945 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.
1946 FUNC is called with the DATA and the address of each sub-tree. If
1947 FUNC returns a non-NULL value, the traversal is aborted, and the
1948 value returned by FUNC is returned. If HTAB is non-NULL it is used
1949 to record the nodes visited, and to avoid visiting a node more than
1953 walk_tree (tree
*tp
, walk_tree_fn func
, void *data
, void *htab_
)
1955 htab_t htab
= (htab_t
) htab_
;
1956 enum tree_code code
;
1960 #define WALK_SUBTREE(NODE) \
1963 result = walk_tree (&(NODE), func, data, htab); \
1969 #define WALK_SUBTREE_TAIL(NODE) \
1973 goto tail_recurse; \
1978 /* Skip empty subtrees. */
1986 /* Don't walk the same tree twice, if the user has requested
1987 that we avoid doing so. */
1988 slot
= htab_find_slot (htab
, *tp
, INSERT
);
1994 /* Call the function. */
1996 result
= (*func
) (tp
, &walk_subtrees
, data
);
1998 /* If we found something, return it. */
2002 code
= TREE_CODE (*tp
);
2004 /* Even if we didn't, FUNC may have decided that there was nothing
2005 interesting below this point in the tree. */
2008 if (code
== TREE_LIST
)
2009 /* But we still need to check our siblings. */
2010 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
2015 result
= lang_hooks
.tree_inlining
.walk_subtrees (tp
, &walk_subtrees
, func
,
2017 if (result
|| ! walk_subtrees
)
2020 if (code
!= EXIT_BLOCK_EXPR
2021 && code
!= SAVE_EXPR
2022 && code
!= BIND_EXPR
2023 && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
2027 /* Walk over all the sub-trees of this operand. */
2028 len
= first_rtl_op (code
);
2029 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
2030 But, we only want to walk once. */
2031 if (code
== TARGET_EXPR
2032 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
2034 /* Go through the subtrees. We need to do this in forward order so
2035 that the scope of a FOR_EXPR is handled properly. */
2036 #ifdef DEBUG_WALK_TREE
2037 for (i
= 0; i
< len
; ++i
)
2038 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
2040 for (i
= 0; i
< len
- 1; ++i
)
2041 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
2045 /* The common case is that we may tail recurse here. */
2046 if (code
!= BIND_EXPR
2047 && !TREE_CHAIN (*tp
))
2048 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, len
- 1));
2050 WALK_SUBTREE (TREE_OPERAND (*tp
, len
- 1));
2054 else if (TREE_CODE_CLASS (code
) == 'd')
2056 WALK_SUBTREE_TAIL (TREE_TYPE (*tp
));
2060 if (TREE_CODE_CLASS (code
) == 't')
2062 WALK_SUBTREE (TYPE_SIZE (*tp
));
2063 WALK_SUBTREE (TYPE_SIZE_UNIT (*tp
));
2064 /* Also examine various special fields, below. */
2067 /* Not one of the easy cases. We must explicitly go through the
2072 case IDENTIFIER_NODE
:
2086 case PLACEHOLDER_EXPR
:
2088 /* None of thse have subtrees other than those already walked
2093 case REFERENCE_TYPE
:
2094 WALK_SUBTREE_TAIL (TREE_TYPE (*tp
));
2098 WALK_SUBTREE (TREE_VALUE (*tp
));
2099 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
2104 int len
= TREE_VEC_LENGTH (*tp
);
2109 /* Walk all elements but the first. */
2111 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
2113 /* Now walk the first one as a tail call. */
2114 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
2118 WALK_SUBTREE (TREE_REALPART (*tp
));
2119 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
2122 WALK_SUBTREE_TAIL (CONSTRUCTOR_ELTS (*tp
));
2125 WALK_SUBTREE (TYPE_METHOD_BASETYPE (*tp
));
2129 WALK_SUBTREE (TREE_TYPE (*tp
));
2131 tree arg
= TYPE_ARG_TYPES (*tp
);
2133 /* We never want to walk into default arguments. */
2134 for (; arg
; arg
= TREE_CHAIN (arg
))
2135 WALK_SUBTREE (TREE_VALUE (arg
));
2140 WALK_SUBTREE (TREE_TYPE (*tp
));
2141 WALK_SUBTREE_TAIL (TYPE_DOMAIN (*tp
));
2145 WALK_SUBTREE (TYPE_MIN_VALUE (*tp
));
2146 WALK_SUBTREE_TAIL (TYPE_MAX_VALUE (*tp
));
2149 WALK_SUBTREE (TREE_TYPE (*tp
));
2150 WALK_SUBTREE_TAIL (TYPE_OFFSET_BASETYPE (*tp
));
2152 case EXIT_BLOCK_EXPR
:
2153 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 1));
2156 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
2161 for (decl
= BIND_EXPR_VARS (*tp
); decl
; decl
= TREE_CHAIN (decl
))
2163 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
2164 into declarations that are just mentioned, rather than
2165 declared; they don't really belong to this part of the tree.
2166 And, we can see cycles: the initializer for a declaration can
2167 refer to the declaration itself. */
2168 WALK_SUBTREE (DECL_INITIAL (decl
));
2169 WALK_SUBTREE (DECL_SIZE (decl
));
2170 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
2171 WALK_SUBTREE (TREE_TYPE (decl
));
2173 WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp
));
2176 case STATEMENT_LIST
:
2178 tree_stmt_iterator i
;
2179 for (i
= tsi_start (*tp
); !tsi_end_p (i
); tsi_next (&i
))
2180 WALK_SUBTREE (*tsi_stmt_ptr (i
));
2189 /* We didn't find what we were looking for. */
2193 #undef WALK_SUBTREE_TAIL
2196 /* Like walk_tree, but does not walk duplicate nodes more than
2200 walk_tree_without_duplicates (tree
*tp
, walk_tree_fn func
, void *data
)
2205 htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
2206 result
= walk_tree (tp
, func
, data
, htab
);
2211 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
2214 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2216 enum tree_code code
= TREE_CODE (*tp
);
2218 /* We make copies of most nodes. */
2219 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
2220 || TREE_CODE_CLASS (code
) == 'c'
2221 || code
== TREE_LIST
2223 || code
== TYPE_DECL
)
2225 /* Because the chain gets clobbered when we make a copy, we save it
2227 tree chain
= TREE_CHAIN (*tp
);
2230 /* Copy the node. */
2231 new = copy_node (*tp
);
2233 /* Propagate mudflap marked-ness. */
2234 if (flag_mudflap
&& mf_marked_p (*tp
))
2239 /* Now, restore the chain, if appropriate. That will cause
2240 walk_tree to walk into the chain as well. */
2241 if (code
== PARM_DECL
|| code
== TREE_LIST
)
2242 TREE_CHAIN (*tp
) = chain
;
2244 /* For now, we don't update BLOCKs when we make copies. So, we
2245 have to nullify all BIND_EXPRs. */
2246 if (TREE_CODE (*tp
) == BIND_EXPR
)
2247 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
2249 else if (TREE_CODE_CLASS (code
) == 't')
2251 else if (TREE_CODE_CLASS (code
) == 'd')
2253 else if (code
== STATEMENT_LIST
)
2259 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2260 information indicating to what new SAVE_EXPR this one should be
2261 mapped, use that one. Otherwise, create a new node and enter it in
2262 ST. FN is the function into which the copy will be placed. */
2265 remap_save_expr (tree
*tp
, void *st_
, tree fn
, int *walk_subtrees
)
2267 splay_tree st
= (splay_tree
) st_
;
2271 /* See if we already encountered this SAVE_EXPR. */
2272 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2274 /* If we didn't already remap this SAVE_EXPR, do so now. */
2277 t
= copy_node (*tp
);
2279 /* The SAVE_EXPR is now part of the function into which we
2280 are inlining this body. */
2281 SAVE_EXPR_CONTEXT (t
) = fn
;
2282 /* And we haven't evaluated it yet. */
2283 SAVE_EXPR_RTL (t
) = NULL_RTX
;
2284 /* Remember this SAVE_EXPR. */
2285 splay_tree_insert (st
, (splay_tree_key
) *tp
, (splay_tree_value
) t
);
2286 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2287 splay_tree_insert (st
, (splay_tree_key
) t
, (splay_tree_value
) t
);
2291 /* We've already walked into this SAVE_EXPR; don't do it again. */
2293 t
= (tree
) n
->value
;
2296 /* Replace this SAVE_EXPR with the copy. */
2300 /* Called via walk_tree. If *TP points to a DECL_STMT for a local
2301 declaration, copies the declaration and enters it in the splay_tree
2302 in DATA (which is really an `inline_data *'). */
2305 mark_local_for_remap_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
2309 inline_data
*id
= (inline_data
*) data
;
2312 /* Don't walk into types. */
2319 if (TREE_CODE (t
) == LABEL_EXPR
)
2320 decl
= TREE_OPERAND (t
, 0);
2322 /* We don't need to handle anything else ahead of time. */
2330 copy
= copy_decl_for_inlining (decl
,
2331 DECL_CONTEXT (decl
),
2332 DECL_CONTEXT (decl
));
2334 /* Remember the copy. */
2335 insert_decl_map (id
, decl
, copy
);
2341 /* Called via walk_tree when an expression is unsaved. Using the
2342 splay_tree pointed to by ST (which is really a `splay_tree'),
2343 remaps all local declarations to appropriate replacements. */
2346 unsave_r (tree
*tp
, int *walk_subtrees
, void *data
)
2348 inline_data
*id
= (inline_data
*) data
;
2349 splay_tree st
= id
->decl_map
;
2352 /* Only a local declaration (variable or label). */
2353 if ((TREE_CODE (*tp
) == VAR_DECL
&& !TREE_STATIC (*tp
))
2354 || TREE_CODE (*tp
) == LABEL_DECL
)
2356 /* Lookup the declaration. */
2357 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2359 /* If it's there, remap it. */
2361 *tp
= (tree
) n
->value
;
2363 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
2364 copy_statement_list (tp
);
2365 else if (TREE_CODE (*tp
) == BIND_EXPR
)
2366 copy_bind_expr (tp
, walk_subtrees
, id
);
2367 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2368 remap_save_expr (tp
, st
, current_function_decl
, walk_subtrees
);
2371 copy_tree_r (tp
, walk_subtrees
, NULL
);
2373 /* Do whatever unsaving is required. */
2374 unsave_expr_1 (*tp
);
2377 /* Keep iterating. */
2381 /* Default lang hook for "unsave_expr_now". Copies everything in EXPR and
2382 replaces variables, labels and SAVE_EXPRs local to EXPR. */
2385 lhd_unsave_expr_now (tree expr
)
2389 /* There's nothing to do for NULL_TREE. */
2394 memset (&id
, 0, sizeof (id
));
2395 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
2396 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
2397 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2399 /* Walk the tree once to find local labels. */
2400 walk_tree_without_duplicates (&expr
, mark_local_for_remap_r
, &id
);
2402 /* Walk the tree again, copying, remapping, and unsaving. */
2403 walk_tree (&expr
, unsave_r
, &id
, NULL
);
2406 splay_tree_delete (id
.decl_map
);
2411 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
2413 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
2421 extern bool debug_find_tree (tree top
, tree search
);
2424 debug_find_tree (tree top
, tree search
)
2426 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
2430 /* Declare the variables created by the inliner. Add all the variables in
2431 VARS to BIND_EXPR. */
2434 declare_inline_vars (tree bind_expr
, tree vars
)
2436 if (lang_hooks
.gimple_before_inlining
)
2439 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
2440 vars
->decl
.seen_in_bind_expr
= 1;
2443 add_var_to_bind_expr (bind_expr
, vars
);