2 Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 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"
43 #include "tree-flow.h"
45 #include "diagnostic.h"
48 /* I'm not real happy about this, but we need to handle gimple and
50 #include "tree-iterator.h"
51 #include "tree-gimple.h"
53 /* 0 if we should not perform inlining.
54 1 if we should expand functions calls inline at the tree level.
55 2 if we should consider *all* functions to be inline
58 int flag_inline_trees
= 0;
62 o In order to make inlining-on-trees work, we pessimized
63 function-local static constants. In particular, they are now
64 always output, even when not addressed. Fix this by treating
65 function-local static constants just like global static
66 constants; the back-end already knows not to output them if they
69 o Provide heuristics to clamp inlining of recursive template
72 /* Data required for function inlining. */
74 typedef struct inline_data
76 /* A stack of the functions we are inlining. For example, if we are
77 compiling `f', which calls `g', which calls `h', and we are
78 inlining the body of `h', the stack will contain, `h', followed
79 by `g', followed by `f'. The first few elements of the stack may
80 contain other functions that we know we should not recurse into,
81 even though they are not directly being inlined. */
83 /* The index of the first element of FNS that really represents an
85 unsigned first_inlined_fn
;
86 /* The label to jump to when a return statement is encountered. If
87 this value is NULL, then return statements will simply be
88 remapped as return statements, rather than as jumps. */
90 /* The VAR_DECL for the return value. */
92 /* The map from local declarations in the inlined function to
93 equivalents in the function into which it is being inlined. */
95 /* Nonzero if we are currently within the cleanup for a
97 int in_target_cleanup_p
;
98 /* We use the same mechanism to build clones that we do to perform
99 inlining. However, there are a few places where we need to
100 distinguish between those two situations. This flag is true if
101 we are cloning, rather than inlining. */
103 /* Similarly for saving function body. */
105 /* Hash table used to prevent walk_tree from visiting the same node
106 umpteen million times. */
108 /* Callgraph node of function we are inlining into. */
109 struct cgraph_node
*node
;
110 /* Callgraph node of currently inlined function. */
111 struct cgraph_node
*current_node
;
112 /* Statement iterator. We need this so we can keep the tree in
113 gimple form when we insert the inlined function. It is not
114 used when we are not dealing with gimple trees. */
115 tree_stmt_iterator tsi
;
120 /* The approximate number of instructions per statement. This number
121 need not be particularly accurate; it is used only to make
122 decisions about when a function is too big to inline. */
123 #define INSNS_PER_STMT (10)
125 static tree
copy_body_r (tree
*, int *, void *);
126 static tree
copy_body (inline_data
*);
127 static tree
expand_call_inline (tree
*, int *, void *);
128 static void expand_calls_inline (tree
*, inline_data
*);
129 static bool inlinable_function_p (tree
);
130 static tree
remap_decl (tree
, inline_data
*);
131 static tree
remap_type (tree
, inline_data
*);
132 static tree
initialize_inlined_parameters (inline_data
*, tree
,
134 static void remap_block (tree
*, inline_data
*);
135 static tree
remap_decls (tree
, inline_data
*);
136 static void copy_bind_expr (tree
*, int *, inline_data
*);
137 static tree
mark_local_for_remap_r (tree
*, int *, void *);
138 static void unsave_expr_1 (tree
);
139 static tree
unsave_r (tree
*, int *, void *);
140 static void declare_inline_vars (tree bind_expr
, tree vars
);
141 static void remap_save_expr (tree
*, void *, int *);
143 /* Insert a tree->tree mapping for ID. Despite the name suggests
144 that the trees should be variables, it is used for more than that. */
147 insert_decl_map (inline_data
*id
, tree key
, tree value
)
149 splay_tree_insert (id
->decl_map
, (splay_tree_key
) key
,
150 (splay_tree_value
) value
);
152 /* Always insert an identity map as well. If we see this same new
153 node again, we won't want to duplicate it a second time. */
155 splay_tree_insert (id
->decl_map
, (splay_tree_key
) value
,
156 (splay_tree_value
) value
);
159 /* Remap DECL during the copying of the BLOCK tree for the function.
160 We are only called to remap local variables in the current function. */
163 remap_decl (tree decl
, inline_data
*id
)
165 splay_tree_node n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
166 tree fn
= VARRAY_TOP_TREE (id
->fns
);
168 /* See if we have remapped this declaration. If we didn't already have an
169 equivalent for this declaration, create one now. */
172 /* Make a copy of the variable or label. */
173 tree t
= copy_decl_for_inlining (decl
, fn
, VARRAY_TREE (id
->fns
, 0));
175 /* Remap types, if necessary. */
176 TREE_TYPE (t
) = remap_type (TREE_TYPE (t
), id
);
177 if (TREE_CODE (t
) == TYPE_DECL
)
178 DECL_ORIGINAL_TYPE (t
) = remap_type (DECL_ORIGINAL_TYPE (t
), id
);
179 else if (TREE_CODE (t
) == PARM_DECL
)
180 DECL_ARG_TYPE_AS_WRITTEN (t
)
181 = remap_type (DECL_ARG_TYPE_AS_WRITTEN (t
), id
);
183 /* Remap sizes as necessary. */
184 walk_tree (&DECL_SIZE (t
), copy_body_r
, id
, NULL
);
185 walk_tree (&DECL_SIZE_UNIT (t
), copy_body_r
, id
, NULL
);
187 /* If fields, do likewise for offset and qualifier. */
188 if (TREE_CODE (t
) == FIELD_DECL
)
190 walk_tree (&DECL_FIELD_OFFSET (t
), copy_body_r
, id
, NULL
);
191 if (TREE_CODE (DECL_CONTEXT (t
)) == QUAL_UNION_TYPE
)
192 walk_tree (&DECL_QUALIFIER (t
), copy_body_r
, id
, NULL
);
196 /* FIXME handle anon aggrs. */
197 if (! DECL_NAME (t
) && TREE_TYPE (t
)
198 && lang_hooks
.tree_inlining
.anon_aggr_type_p (TREE_TYPE (t
)))
200 /* For a VAR_DECL of anonymous type, we must also copy the
201 member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS. */
205 for (src
= DECL_ANON_UNION_ELEMS (t
); src
;
206 src
= TREE_CHAIN (src
))
208 tree member
= remap_decl (TREE_VALUE (src
), id
);
210 gcc_assert (!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
);
327 /* Shouldn't have been thought variable sized. */
331 walk_tree (&TYPE_SIZE (new), copy_body_r
, id
, NULL
);
332 walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r
, id
, NULL
);
338 remap_decls (tree decls
, inline_data
*id
)
341 tree new_decls
= NULL_TREE
;
343 /* Remap its variables. */
344 for (old_var
= decls
; old_var
; old_var
= TREE_CHAIN (old_var
))
348 /* Remap the variable. */
349 new_var
= remap_decl (old_var
, id
);
351 /* If we didn't remap this variable, so we can't mess with its
352 TREE_CHAIN. If we remapped this variable to the return slot, it's
353 already declared somewhere else, so don't declare it here. */
354 if (!new_var
|| new_var
== id
->retvar
)
358 gcc_assert (DECL_P (new_var
));
359 TREE_CHAIN (new_var
) = new_decls
;
364 return nreverse (new_decls
);
367 /* Copy the BLOCK to contain remapped versions of the variables
368 therein. And hook the new block into the block-tree. */
371 remap_block (tree
*block
, inline_data
*id
)
377 /* Make the new block. */
379 new_block
= make_node (BLOCK
);
380 TREE_USED (new_block
) = TREE_USED (old_block
);
381 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
384 /* Remap its variables. */
385 BLOCK_VARS (new_block
) = remap_decls (BLOCK_VARS (old_block
), id
);
387 fn
= VARRAY_TREE (id
->fns
, 0);
389 /* FIXME! It shouldn't be so hard to manage blocks. Rebuilding them in
390 rest_of_compilation is a good start. */
392 /* We're building a clone; DECL_INITIAL is still
393 error_mark_node, and current_binding_level is the parm
395 lang_hooks
.decls
.insert_block (new_block
);
398 /* Attach this new block after the DECL_INITIAL block for the
399 function into which this block is being inlined. In
400 rest_of_compilation we will straighten out the BLOCK tree. */
402 if (DECL_INITIAL (fn
))
403 first_block
= &BLOCK_CHAIN (DECL_INITIAL (fn
));
405 first_block
= &DECL_INITIAL (fn
);
406 BLOCK_CHAIN (new_block
) = *first_block
;
407 *first_block
= new_block
;
410 /* Remember the remapped block. */
411 insert_decl_map (id
, old_block
, new_block
);
415 copy_statement_list (tree
*tp
)
417 tree_stmt_iterator oi
, ni
;
420 new = alloc_stmt_list ();
421 ni
= tsi_start (new);
422 oi
= tsi_start (*tp
);
425 for (; !tsi_end_p (oi
); tsi_next (&oi
))
426 tsi_link_after (&ni
, tsi_stmt (oi
), TSI_NEW_STMT
);
430 copy_bind_expr (tree
*tp
, int *walk_subtrees
, inline_data
*id
)
432 tree block
= BIND_EXPR_BLOCK (*tp
);
433 /* Copy (and replace) the statement. */
434 copy_tree_r (tp
, walk_subtrees
, NULL
);
437 remap_block (&block
, id
);
438 BIND_EXPR_BLOCK (*tp
) = block
;
441 if (BIND_EXPR_VARS (*tp
))
442 /* This will remap a lot of the same decls again, but this should be
444 BIND_EXPR_VARS (*tp
) = remap_decls (BIND_EXPR_VARS (*tp
), id
);
447 /* Called from copy_body via walk_tree. DATA is really an `inline_data *'. */
450 copy_body_r (tree
*tp
, int *walk_subtrees
, void *data
)
452 inline_data
*id
= (inline_data
*) data
;
453 tree fn
= VARRAY_TOP_TREE (id
->fns
);
456 /* All automatic variables should have a DECL_CONTEXT indicating
457 what function they come from. */
458 if ((TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == LABEL_DECL
)
459 && DECL_NAMESPACE_SCOPE_P (*tp
))
460 gcc_assert (DECL_EXTERNAL (*tp
) || TREE_STATIC (*tp
));
463 /* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
464 GOTO_EXPR with the RET_LABEL as its target. */
465 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->ret_label
)
467 tree return_stmt
= *tp
;
470 /* Build the GOTO_EXPR. */
471 tree assignment
= TREE_OPERAND (return_stmt
, 0);
472 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, id
->ret_label
);
473 TREE_USED (id
->ret_label
) = 1;
475 /* If we're returning something, just turn that into an
476 assignment into the equivalent of the original
480 /* Do not create a statement containing a naked RESULT_DECL. */
481 if (TREE_CODE (assignment
) == RESULT_DECL
)
482 gimplify_stmt (&assignment
);
484 *tp
= build (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
485 append_to_statement_list (assignment
, &BIND_EXPR_BODY (*tp
));
486 append_to_statement_list (goto_stmt
, &BIND_EXPR_BODY (*tp
));
488 /* If we're not returning anything just do the jump. */
492 /* Local variables and labels need to be replaced by equivalent
493 variables. We don't want to copy static variables; there's only
494 one of those, no matter how many times we inline the containing
495 function. Similarly for globals from an outer function. */
496 else if (lang_hooks
.tree_inlining
.auto_var_in_fn_p (*tp
, fn
))
500 /* Remap the declaration. */
501 new_decl
= remap_decl (*tp
, id
);
502 gcc_assert (new_decl
);
503 /* Replace this variable with the copy. */
504 STRIP_TYPE_NOPS (new_decl
);
508 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
509 copy_statement_list (tp
);
510 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
511 remap_save_expr (tp
, id
->decl_map
, walk_subtrees
);
512 else if (TREE_CODE (*tp
) == BIND_EXPR
)
513 copy_bind_expr (tp
, walk_subtrees
, id
);
514 /* Types may need remapping as well. */
515 else if (TYPE_P (*tp
))
516 *tp
= remap_type (*tp
, id
);
518 /* If this is a constant, we have to copy the node iff the type will be
519 remapped. copy_tree_r will not copy a constant. */
520 else if (TREE_CODE_CLASS (TREE_CODE (*tp
)) == tcc_constant
)
522 tree new_type
= remap_type (TREE_TYPE (*tp
), id
);
524 if (new_type
== TREE_TYPE (*tp
))
527 else if (TREE_CODE (*tp
) == INTEGER_CST
)
528 *tp
= build_int_cst_wide (new_type
, TREE_INT_CST_LOW (*tp
),
529 TREE_INT_CST_HIGH (*tp
));
532 *tp
= copy_node (*tp
);
533 TREE_TYPE (*tp
) = new_type
;
537 /* Otherwise, just copy the node. Note that copy_tree_r already
538 knows not to copy VAR_DECLs, etc., so this is safe. */
543 if (TREE_CODE (*tp
) == MODIFY_EXPR
544 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
545 && (lang_hooks
.tree_inlining
.auto_var_in_fn_p
546 (TREE_OPERAND (*tp
, 0), fn
)))
548 /* Some assignments VAR = VAR; don't generate any rtl code
549 and thus don't count as variable modification. Avoid
550 keeping bogosities like 0 = 0. */
551 tree decl
= TREE_OPERAND (*tp
, 0), value
;
554 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
557 value
= (tree
) n
->value
;
558 STRIP_TYPE_NOPS (value
);
559 if (TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
561 *tp
= build_empty_stmt ();
562 return copy_body_r (tp
, walk_subtrees
, data
);
566 else if (TREE_CODE (*tp
) == INDIRECT_REF
)
568 /* Get rid of *& from inline substitutions that can happen when a
569 pointer argument is an ADDR_EXPR. */
570 tree decl
= TREE_OPERAND (*tp
, 0), value
;
573 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
576 value
= (tree
) n
->value
;
578 if (TREE_CODE (value
) == ADDR_EXPR
579 && (lang_hooks
.types_compatible_p
580 (TREE_TYPE (*tp
), TREE_TYPE (TREE_OPERAND (value
, 0)))))
582 *tp
= TREE_OPERAND (value
, 0);
583 return copy_body_r (tp
, walk_subtrees
, data
);
588 copy_tree_r (tp
, walk_subtrees
, NULL
);
590 if (TREE_CODE (*tp
) == CALL_EXPR
&& id
->node
&& get_callee_fndecl (*tp
))
594 struct cgraph_node
*node
;
595 struct cgraph_edge
*edge
;
597 for (node
= id
->node
->next_clone
; node
; node
= node
->next_clone
)
599 edge
= cgraph_edge (node
, old_node
);
601 edge
->call_expr
= *tp
;
606 struct cgraph_edge
*edge
607 = cgraph_edge (id
->current_node
, old_node
);
610 cgraph_clone_edge (edge
, id
->node
, *tp
);
614 TREE_TYPE (*tp
) = remap_type (TREE_TYPE (*tp
), id
);
616 /* The copied TARGET_EXPR has never been expanded, even if the
617 original node was expanded already. */
618 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
620 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
621 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
624 /* Variable substitution need not be simple. In particular, the
625 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
626 and friends are up-to-date. */
627 else if (TREE_CODE (*tp
) == ADDR_EXPR
)
629 walk_tree (&TREE_OPERAND (*tp
, 0), copy_body_r
, id
, NULL
);
630 recompute_tree_invarant_for_addr_expr (*tp
);
635 /* Keep iterating. */
639 /* Make a copy of the body of FN so that it can be inserted inline in
643 copy_body (inline_data
*id
)
646 tree fndecl
= VARRAY_TOP_TREE (id
->fns
);
648 if (fndecl
== current_function_decl
650 body
= cfun
->saved_tree
;
652 body
= DECL_SAVED_TREE (fndecl
);
653 walk_tree (&body
, copy_body_r
, id
, NULL
);
658 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
659 defined in function FN, or of a data member thereof. */
662 self_inlining_addr_expr (tree value
, tree fn
)
666 if (TREE_CODE (value
) != ADDR_EXPR
)
669 var
= get_base_address (TREE_OPERAND (value
, 0));
671 return var
&& lang_hooks
.tree_inlining
.auto_var_in_fn_p (var
, fn
);
675 setup_one_parameter (inline_data
*id
, tree p
, tree value
, tree fn
,
676 tree
*init_stmts
, tree
*vars
, bool *gimplify_init_stmts_p
)
681 /* If the parameter is never assigned to, we may not need to
682 create a new variable here at all. Instead, we may be able
683 to just use the argument value. */
684 if (TREE_READONLY (p
)
685 && !TREE_ADDRESSABLE (p
)
686 && value
&& !TREE_SIDE_EFFECTS (value
))
688 /* We can't risk substituting complex expressions. They
689 might contain variables that will be assigned to later.
690 Theoretically, we could check the expression to see if
691 all of the variables that determine its value are
692 read-only, but we don't bother. */
693 /* We may produce non-gimple trees by adding NOPs or introduce
694 invalid sharing when operand is not really constant.
695 It is not big deal to prohibit constant propagation here as
696 we will constant propagate in DOM1 pass anyway. */
697 if (is_gimple_min_invariant (value
)
698 && lang_hooks
.types_compatible_p (TREE_TYPE (value
), TREE_TYPE (p
))
699 /* We have to be very careful about ADDR_EXPR. Make sure
700 the base variable isn't a local variable of the inlined
701 function, e.g., when doing recursive inlining, direct or
702 mutually-recursive or whatever, which is why we don't
703 just test whether fn == current_function_decl. */
704 && ! self_inlining_addr_expr (value
, fn
))
706 insert_decl_map (id
, p
, value
);
711 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
712 here since the type of this decl must be visible to the calling
714 var
= copy_decl_for_inlining (p
, fn
, VARRAY_TREE (id
->fns
, 0));
716 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
717 that way, when the PARM_DECL is encountered, it will be
718 automatically replaced by the VAR_DECL. */
719 insert_decl_map (id
, p
, var
);
721 /* Declare this new variable. */
722 TREE_CHAIN (var
) = *vars
;
725 /* Make gimplifier happy about this variable. */
726 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
728 /* Even if P was TREE_READONLY, the new VAR should not be.
729 In the original code, we would have constructed a
730 temporary, and then the function body would have never
731 changed the value of P. However, now, we will be
732 constructing VAR directly. The constructor body may
733 change its value multiple times as it is being
734 constructed. Therefore, it must not be TREE_READONLY;
735 the back-end assumes that TREE_READONLY variable is
736 assigned to only once. */
737 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
738 TREE_READONLY (var
) = 0;
740 /* Initialize this VAR_DECL from the equivalent argument. Convert
741 the argument to the proper type in case it was promoted. */
744 tree rhs
= fold_convert (TREE_TYPE (var
), value
);
746 if (rhs
== error_mark_node
)
749 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
750 keep our trees in gimple form. */
751 init_stmt
= build (MODIFY_EXPR
, TREE_TYPE (var
), var
, rhs
);
752 append_to_statement_list (init_stmt
, init_stmts
);
754 /* If we did not create a gimple value and we did not create a gimple
755 cast of a gimple value, then we will need to gimplify INIT_STMTS
756 at the end. Note that is_gimple_cast only checks the outer
757 tree code, not its operand. Thus the explicit check that it's
758 operand is a gimple value. */
759 if (!is_gimple_val (rhs
)
760 && (!is_gimple_cast (rhs
)
761 || !is_gimple_val (TREE_OPERAND (rhs
, 0))))
762 *gimplify_init_stmts_p
= true;
766 /* Generate code to initialize the parameters of the function at the
767 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
770 initialize_inlined_parameters (inline_data
*id
, tree args
, tree static_chain
,
771 tree fn
, tree bind_expr
)
773 tree init_stmts
= NULL_TREE
;
777 tree vars
= NULL_TREE
;
778 bool gimplify_init_stmts_p
= false;
781 /* Figure out what the parameters are. */
782 parms
= DECL_ARGUMENTS (fn
);
783 if (fn
== current_function_decl
)
784 parms
= cfun
->saved_args
;
786 /* Loop through the parameter declarations, replacing each with an
787 equivalent VAR_DECL, appropriately initialized. */
788 for (p
= parms
, a
= args
; p
;
789 a
= a
? TREE_CHAIN (a
) : a
, p
= TREE_CHAIN (p
))
795 /* Find the initializer. */
796 value
= lang_hooks
.tree_inlining
.convert_parm_for_inlining
797 (p
, a
? TREE_VALUE (a
) : NULL_TREE
, fn
, argnum
);
799 setup_one_parameter (id
, p
, value
, fn
, &init_stmts
, &vars
,
800 &gimplify_init_stmts_p
);
803 /* Evaluate trailing arguments. */
804 for (; a
; a
= TREE_CHAIN (a
))
806 tree value
= TREE_VALUE (a
);
807 append_to_statement_list (value
, &init_stmts
);
810 /* Initialize the static chain. */
811 p
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
812 if (fn
== current_function_decl
)
813 p
= DECL_STRUCT_FUNCTION (fn
)->saved_static_chain_decl
;
816 /* No static chain? Seems like a bug in tree-nested.c. */
817 gcc_assert (static_chain
);
819 setup_one_parameter (id
, p
, static_chain
, fn
, &init_stmts
, &vars
,
820 &gimplify_init_stmts_p
);
823 if (gimplify_init_stmts_p
)
824 gimplify_body (&init_stmts
, current_function_decl
, false);
826 declare_inline_vars (bind_expr
, vars
);
830 /* Declare a return variable to replace the RESULT_DECL for the function we
831 are calling. RETURN_SLOT_ADDR, if non-null, was a fake parameter that
832 took the address of the result. MODIFY_DEST, if non-null, was the LHS of
833 the MODIFY_EXPR to which this call is the RHS.
835 The return value is a (possibly null) value that is the result of the
836 function as seen by the callee. *USE_P is a (possibly null) value that
837 holds the result as seen by the caller. */
840 declare_return_variable (inline_data
*id
, tree return_slot_addr
,
841 tree modify_dest
, tree
*use_p
)
843 tree callee
= VARRAY_TOP_TREE (id
->fns
);
844 tree caller
= VARRAY_TREE (id
->fns
, 0);
845 tree result
= DECL_RESULT (callee
);
846 tree callee_type
= TREE_TYPE (result
);
847 tree caller_type
= TREE_TYPE (TREE_TYPE (callee
));
850 /* We don't need to do anything for functions that don't return
852 if (!result
|| VOID_TYPE_P (callee_type
))
858 /* If there was a return slot, then the return value is the
859 dereferenced address of that object. */
860 if (return_slot_addr
)
862 /* The front end shouldn't have used both return_slot_addr and
863 a modify expression. */
864 gcc_assert (!modify_dest
);
865 if (DECL_BY_REFERENCE (result
))
866 var
= return_slot_addr
;
868 var
= build_fold_indirect_ref (return_slot_addr
);
873 /* All types requiring non-trivial constructors should have been handled. */
874 gcc_assert (!TREE_ADDRESSABLE (callee_type
));
876 /* Attempt to avoid creating a new temporary variable. */
881 /* We can't use MODIFY_DEST if there's type promotion involved. */
882 if (!lang_hooks
.types_compatible_p (caller_type
, callee_type
))
885 /* ??? If we're assigning to a variable sized type, then we must
886 reuse the destination variable, because we've no good way to
887 create variable sized temporaries at this point. */
888 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type
)) != INTEGER_CST
)
891 /* If the callee cannot possibly modify MODIFY_DEST, then we can
892 reuse it as the result of the call directly. Don't do this if
893 it would promote MODIFY_DEST to addressable. */
894 else if (!TREE_STATIC (modify_dest
)
895 && !TREE_ADDRESSABLE (modify_dest
)
896 && !TREE_ADDRESSABLE (result
))
907 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type
)) == INTEGER_CST
);
909 var
= copy_decl_for_inlining (result
, callee
, caller
);
910 DECL_SEEN_IN_BIND_EXPR_P (var
) = 1;
911 DECL_STRUCT_FUNCTION (caller
)->unexpanded_var_list
912 = tree_cons (NULL_TREE
, var
,
913 DECL_STRUCT_FUNCTION (caller
)->unexpanded_var_list
);
915 /* Do not have the rest of GCC warn about this variable as it should
916 not be visible to the user. */
917 TREE_NO_WARNING (var
) = 1;
919 /* Build the use expr. If the return type of the function was
920 promoted, convert it back to the expected type. */
922 if (!lang_hooks
.types_compatible_p (TREE_TYPE (var
), caller_type
))
923 use
= fold_convert (caller_type
, var
);
926 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
927 way, when the RESULT_DECL is encountered, it will be
928 automatically replaced by the VAR_DECL. */
929 insert_decl_map (id
, result
, var
);
931 /* Remember this so we can ignore it in remap_decls. */
938 /* Returns nonzero if a function can be inlined as a tree. */
941 tree_inlinable_function_p (tree fn
)
943 return inlinable_function_p (fn
);
946 static const char *inline_forbidden_reason
;
949 inline_forbidden_p_1 (tree
*nodep
, int *walk_subtrees ATTRIBUTE_UNUSED
,
953 tree fn
= (tree
) fnp
;
956 switch (TREE_CODE (node
))
959 /* Refuse to inline alloca call unless user explicitly forced so as
960 this may change program's memory overhead drastically when the
961 function using alloca is called in loop. In GCC present in
962 SPEC2000 inlining into schedule_block cause it to require 2GB of
963 RAM instead of 256MB. */
964 if (alloca_call_p (node
)
965 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
967 inline_forbidden_reason
968 = N_("%Jfunction %qF can never be inlined because it uses "
969 "alloca (override using the always_inline attribute)");
972 t
= get_callee_fndecl (node
);
976 /* We cannot inline functions that call setjmp. */
977 if (setjmp_call_p (t
))
979 inline_forbidden_reason
980 = N_("%Jfunction %qF can never be inlined because it uses setjmp");
984 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
985 switch (DECL_FUNCTION_CODE (t
))
987 /* We cannot inline functions that take a variable number of
989 case BUILT_IN_VA_START
:
990 case BUILT_IN_STDARG_START
:
991 case BUILT_IN_NEXT_ARG
:
992 case BUILT_IN_VA_END
:
993 inline_forbidden_reason
994 = N_("%Jfunction %qF can never be inlined because it "
995 "uses variable argument lists");
998 case BUILT_IN_LONGJMP
:
999 /* We can't inline functions that call __builtin_longjmp at
1000 all. The non-local goto machinery really requires the
1001 destination be in a different function. If we allow the
1002 function calling __builtin_longjmp to be inlined into the
1003 function calling __builtin_setjmp, Things will Go Awry. */
1004 inline_forbidden_reason
1005 = N_("%Jfunction %qF can never be inlined because "
1006 "it uses setjmp-longjmp exception handling");
1009 case BUILT_IN_NONLOCAL_GOTO
:
1011 inline_forbidden_reason
1012 = N_("%Jfunction %qF can never be inlined because "
1013 "it uses non-local goto");
1022 t
= TREE_OPERAND (node
, 0);
1024 /* We will not inline a function which uses computed goto. The
1025 addresses of its local labels, which may be tucked into
1026 global storage, are of course not constant across
1027 instantiations, which causes unexpected behavior. */
1028 if (TREE_CODE (t
) != LABEL_DECL
)
1030 inline_forbidden_reason
1031 = N_("%Jfunction %qF can never be inlined "
1032 "because it contains a computed goto");
1038 t
= TREE_OPERAND (node
, 0);
1039 if (DECL_NONLOCAL (t
))
1041 /* We cannot inline a function that receives a non-local goto
1042 because we cannot remap the destination label used in the
1043 function that is performing the non-local goto. */
1044 inline_forbidden_reason
1045 = N_("%Jfunction %qF can never be inlined "
1046 "because it receives a non-local goto");
1053 /* We cannot inline a function of the form
1055 void F (int i) { struct S { int ar[i]; } s; }
1057 Attempting to do so produces a catch-22.
1058 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1059 UNION_TYPE nodes, then it goes into infinite recursion on a
1060 structure containing a pointer to its own type. If it doesn't,
1061 then the type node for S doesn't get adjusted properly when
1062 F is inlined, and we abort in find_function_data.
1064 ??? This is likely no longer true, but it's too late in the 4.0
1065 cycle to try to find out. This should be checked for 4.1. */
1066 for (t
= TYPE_FIELDS (node
); t
; t
= TREE_CHAIN (t
))
1067 if (variably_modified_type_p (TREE_TYPE (t
), NULL
))
1069 inline_forbidden_reason
1070 = N_("%Jfunction %qF can never be inlined "
1071 "because it uses variable sized variables");
1082 /* Return subexpression representing possible alloca call, if any. */
1084 inline_forbidden_p (tree fndecl
)
1086 location_t saved_loc
= input_location
;
1087 tree ret
= walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl
),
1088 inline_forbidden_p_1
, fndecl
);
1090 input_location
= saved_loc
;
1094 /* Returns nonzero if FN is a function that does not have any
1095 fundamental inline blocking properties. */
1098 inlinable_function_p (tree fn
)
1100 bool inlinable
= true;
1102 /* If we've already decided this function shouldn't be inlined,
1103 there's no need to check again. */
1104 if (DECL_UNINLINABLE (fn
))
1107 /* See if there is any language-specific reason it cannot be
1108 inlined. (It is important that this hook be called early because
1109 in C++ it may result in template instantiation.)
1110 If the function is not inlinable for language-specific reasons,
1111 it is left up to the langhook to explain why. */
1112 inlinable
= !lang_hooks
.tree_inlining
.cannot_inline_tree_fn (&fn
);
1114 /* If we don't have the function body available, we can't inline it.
1115 However, this should not be recorded since we also get here for
1116 forward declared inline functions. Therefore, return at once. */
1117 if (!DECL_SAVED_TREE (fn
))
1120 /* If we're not inlining at all, then we cannot inline this function. */
1121 else if (!flag_inline_trees
)
1124 /* Only try to inline functions if DECL_INLINE is set. This should be
1125 true for all functions declared `inline', and for all other functions
1126 as well with -finline-functions.
1128 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1129 it's the front-end that must set DECL_INLINE in this case, because
1130 dwarf2out loses if a function that does not have DECL_INLINE set is
1131 inlined anyway. That is why we have both DECL_INLINE and
1132 DECL_DECLARED_INLINE_P. */
1133 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1134 here should be redundant. */
1135 else if (!DECL_INLINE (fn
) && !flag_unit_at_a_time
)
1138 else if (inline_forbidden_p (fn
))
1140 /* See if we should warn about uninlinable functions. Previously,
1141 some of these warnings would be issued while trying to expand
1142 the function inline, but that would cause multiple warnings
1143 about functions that would for example call alloca. But since
1144 this a property of the function, just one warning is enough.
1145 As a bonus we can now give more details about the reason why a
1146 function is not inlinable.
1147 We only warn for functions declared `inline' by the user. */
1148 bool do_warning
= (warn_inline
1150 && DECL_DECLARED_INLINE_P (fn
)
1151 && !DECL_IN_SYSTEM_HEADER (fn
));
1153 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1154 sorry (inline_forbidden_reason
, fn
, fn
);
1155 else if (do_warning
)
1156 warning (inline_forbidden_reason
, fn
, fn
);
1161 /* Squirrel away the result so that we don't have to check again. */
1162 DECL_UNINLINABLE (fn
) = !inlinable
;
1167 /* Estimate the cost of a memory move. Use machine dependent
1168 word size and take possible memcpy call into account. */
1171 estimate_move_cost (tree type
)
1175 size
= int_size_in_bytes (type
);
1177 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO
)
1178 /* Cost of a memcpy call, 3 arguments and the call. */
1181 return ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
1184 /* Used by estimate_num_insns. Estimate number of instructions seen
1185 by given statement. */
1188 estimate_num_insns_1 (tree
*tp
, int *walk_subtrees
, void *data
)
1193 if (IS_TYPE_OR_DECL_P (x
))
1198 /* Assume that constants and references counts nothing. These should
1199 be majorized by amount of operations among them we count later
1200 and are common target of CSE and similar optimizations. */
1201 else if (CONSTANT_CLASS_P (x
) || REFERENCE_CLASS_P (x
))
1204 switch (TREE_CODE (x
))
1206 /* Containers have no cost. */
1213 case ALIGN_INDIRECT_REF
:
1214 case MISALIGNED_INDIRECT_REF
:
1216 case ARRAY_RANGE_REF
:
1218 case EXC_PTR_EXPR
: /* ??? */
1219 case FILTER_EXPR
: /* ??? */
1222 case WITH_CLEANUP_EXPR
:
1224 case VIEW_CONVERT_EXPR
:
1229 case CASE_LABEL_EXPR
:
1232 case EH_FILTER_EXPR
:
1233 case STATEMENT_LIST
:
1235 case NON_LVALUE_EXPR
:
1238 case TRY_CATCH_EXPR
:
1239 case TRY_FINALLY_EXPR
:
1246 case WITH_SIZE_EXPR
:
1249 /* We don't account constants for now. Assume that the cost is amortized
1250 by operations that do use them. We may re-consider this decision once
1251 we are able to optimize the tree before estimating it's size and break
1252 out static initializers. */
1253 case IDENTIFIER_NODE
:
1262 /* Try to estimate the cost of assignments. We have three cases to
1264 1) Simple assignments to registers;
1265 2) Stores to things that must live in memory. This includes
1266 "normal" stores to scalars, but also assignments of large
1267 structures, or constructors of big arrays;
1270 Let us look at the first two cases, assuming we have "a = b + C":
1271 <modify_expr <var_decl "a"> <plus_expr <var_decl "b"> <constant C>>
1272 If "a" is a GIMPLE register, the assignment to it is free on almost
1273 any target, because "a" usually ends up in a real register. Hence
1274 the only cost of this expression comes from the PLUS_EXPR, and we
1275 can ignore the MODIFY_EXPR.
1276 If "a" is not a GIMPLE register, the assignment to "a" will most
1277 likely be a real store, so the cost of the MODIFY_EXPR is the cost
1278 of moving something into "a", which we compute using the function
1281 The third case deals with TARGET_EXPRs, for which the semantics are
1282 that a temporary is assigned, unless the TARGET_EXPR itself is being
1283 assigned to something else. In the latter case we do not need the
1284 temporary. E.g. in <modify_expr <var_decl "a"> <target_expr>>, the
1285 MODIFY_EXPR is free. */
1288 /* Is the right and side a TARGET_EXPR? */
1289 if (TREE_CODE (TREE_OPERAND (x
, 1)) == TARGET_EXPR
)
1291 /* ... fall through ... */
1294 x
= TREE_OPERAND (x
, 0);
1295 /* Is this an assignments to a register? */
1296 if (is_gimple_reg (x
))
1298 /* Otherwise it's a store, so fall through to compute the move cost. */
1301 *count
+= estimate_move_cost (TREE_TYPE (x
));
1304 /* Assign cost of 1 to usual operations.
1305 ??? We may consider mapping RTL costs to this. */
1312 case FIX_TRUNC_EXPR
:
1314 case FIX_FLOOR_EXPR
:
1315 case FIX_ROUND_EXPR
:
1333 case TRUTH_ANDIF_EXPR
:
1334 case TRUTH_ORIF_EXPR
:
1335 case TRUTH_AND_EXPR
:
1337 case TRUTH_XOR_EXPR
:
1338 case TRUTH_NOT_EXPR
:
1347 case UNORDERED_EXPR
:
1360 case PREDECREMENT_EXPR
:
1361 case PREINCREMENT_EXPR
:
1362 case POSTDECREMENT_EXPR
:
1363 case POSTINCREMENT_EXPR
:
1369 case REALIGN_LOAD_EXPR
:
1375 /* Few special cases of expensive operations. This is useful
1376 to avoid inlining on functions having too many of these. */
1377 case TRUNC_DIV_EXPR
:
1379 case FLOOR_DIV_EXPR
:
1380 case ROUND_DIV_EXPR
:
1381 case EXACT_DIV_EXPR
:
1382 case TRUNC_MOD_EXPR
:
1384 case FLOOR_MOD_EXPR
:
1385 case ROUND_MOD_EXPR
:
1391 tree decl
= get_callee_fndecl (x
);
1394 if (decl
&& DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
1395 switch (DECL_FUNCTION_CODE (decl
))
1397 case BUILT_IN_CONSTANT_P
:
1400 case BUILT_IN_EXPECT
:
1406 /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
1407 that does use function declaration to figure out the arguments. */
1410 for (arg
= TREE_OPERAND (x
, 1); arg
; arg
= TREE_CHAIN (arg
))
1411 *count
+= estimate_move_cost (TREE_TYPE (TREE_VALUE (arg
)));
1415 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= TREE_CHAIN (arg
))
1416 *count
+= estimate_move_cost (TREE_TYPE (arg
));
1419 *count
+= PARAM_VALUE (PARAM_INLINE_CALL_COST
);
1423 /* Abort here se we know we don't miss any nodes. */
1429 /* Estimate number of instructions that will be created by expanding EXPR. */
1432 estimate_num_insns (tree expr
)
1435 walk_tree_without_duplicates (&expr
, estimate_num_insns_1
, &num
);
1439 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1442 expand_call_inline (tree
*tp
, int *walk_subtrees
, void *data
)
1454 tree return_slot_addr
;
1456 location_t saved_location
;
1457 struct cgraph_edge
*edge
;
1460 /* See what we've got. */
1461 id
= (inline_data
*) data
;
1464 /* Set input_location here so we get the right instantiation context
1465 if we call instantiate_decl from inlinable_function_p. */
1466 saved_location
= input_location
;
1467 if (EXPR_HAS_LOCATION (t
))
1468 input_location
= EXPR_LOCATION (t
);
1470 /* Recurse, but letting recursive invocations know that we are
1471 inside the body of a TARGET_EXPR. */
1472 if (TREE_CODE (*tp
) == TARGET_EXPR
)
1475 int i
, len
= TREE_CODE_LENGTH (TARGET_EXPR
);
1477 /* We're walking our own subtrees. */
1480 /* Actually walk over them. This loop is the body of
1481 walk_trees, omitting the case where the TARGET_EXPR
1482 itself is handled. */
1483 for (i
= 0; i
< len
; ++i
)
1486 ++id
->in_target_cleanup_p
;
1487 walk_tree (&TREE_OPERAND (*tp
, i
), expand_call_inline
, data
,
1490 --id
->in_target_cleanup_p
;
1498 /* Because types were not copied in copy_body, CALL_EXPRs beneath
1499 them should not be expanded. This can happen if the type is a
1500 dynamic array type, for example. */
1503 /* From here on, we're only interested in CALL_EXPRs. */
1504 if (TREE_CODE (t
) != CALL_EXPR
)
1507 /* First, see if we can figure out what function is being called.
1508 If we cannot, then there is no hope of inlining the function. */
1509 fn
= get_callee_fndecl (t
);
1513 /* Turn forward declarations into real ones. */
1514 fn
= cgraph_node (fn
)->decl
;
1516 /* If fn is a declaration of a function in a nested scope that was
1517 globally declared inline, we don't set its DECL_INITIAL.
1518 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1519 C++ front-end uses it for cdtors to refer to their internal
1520 declarations, that are not real functions. Fortunately those
1521 don't have trees to be saved, so we can tell by checking their
1523 if (! DECL_INITIAL (fn
)
1524 && DECL_ABSTRACT_ORIGIN (fn
)
1525 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn
)))
1526 fn
= DECL_ABSTRACT_ORIGIN (fn
);
1528 /* Objective C and fortran still calls tree_rest_of_compilation directly.
1529 Kill this check once this is fixed. */
1530 if (!id
->current_node
->analyzed
)
1533 edge
= cgraph_edge (id
->current_node
, t
);
1535 /* Constant propagation on argument done during previous inlining
1536 may create new direct call. Produce an edge for it. */
1539 struct cgraph_node
*dest
= cgraph_node (fn
);
1541 /* We have missing edge in the callgraph. This can happen in one case
1542 where previous inlining turned indirect call into direct call by
1543 constant propagating arguments. In all other cases we hit a bug
1544 (incorrect node sharing is most common reason for missing edges. */
1545 gcc_assert (dest
->needed
|| !flag_unit_at_a_time
);
1546 cgraph_create_edge (id
->node
, dest
, t
)->inline_failed
1547 = N_("originally indirect function call not considered for inlining");
1551 /* Don't try to inline functions that are not well-suited to
1553 if (!cgraph_inline_p (edge
, &reason
))
1555 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)))
1557 sorry ("%Jinlining failed in call to %qF: %s", fn
, fn
, reason
);
1558 sorry ("called from here");
1560 else if (warn_inline
&& DECL_DECLARED_INLINE_P (fn
)
1561 && !DECL_IN_SYSTEM_HEADER (fn
)
1563 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn
)))
1565 warning ("%Jinlining failed in call to %qF: %s", fn
, fn
, reason
);
1566 warning ("called from here");
1571 #ifdef ENABLE_CHECKING
1572 if (edge
->callee
->decl
!= id
->node
->decl
)
1573 verify_cgraph_node (edge
->callee
);
1576 if (! lang_hooks
.tree_inlining
.start_inlining (fn
))
1579 /* Build a block containing code to initialize the arguments, the
1580 actual inline expansion of the body, and a label for the return
1581 statements within the function to jump to. The type of the
1582 statement expression is the return type of the function call. */
1584 expr
= build (BIND_EXPR
, void_type_node
, NULL_TREE
,
1585 stmt
, make_node (BLOCK
));
1586 BLOCK_ABSTRACT_ORIGIN (BIND_EXPR_BLOCK (expr
)) = fn
;
1588 /* Local declarations will be replaced by their equivalents in this
1591 id
->decl_map
= splay_tree_new (splay_tree_compare_pointers
,
1594 /* Initialize the parameters. */
1595 args
= TREE_OPERAND (t
, 1);
1596 return_slot_addr
= NULL_TREE
;
1597 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t
))
1599 return_slot_addr
= TREE_VALUE (args
);
1600 args
= TREE_CHAIN (args
);
1601 TREE_TYPE (expr
) = void_type_node
;
1604 arg_inits
= initialize_inlined_parameters (id
, args
, TREE_OPERAND (t
, 2),
1608 /* Expand any inlined calls in the initializers. Do this before we
1609 push FN on the stack of functions we are inlining; we want to
1610 inline calls to FN that appear in the initializers for the
1613 Note we need to save and restore the saved tree statement iterator
1614 to avoid having it clobbered by expand_calls_inline. */
1615 tree_stmt_iterator save_tsi
;
1618 expand_calls_inline (&arg_inits
, id
);
1621 /* And add them to the tree. */
1622 append_to_statement_list (arg_inits
, &BIND_EXPR_BODY (expr
));
1625 /* Record the function we are about to inline so that we can avoid
1626 recursing into it. */
1627 VARRAY_PUSH_TREE (id
->fns
, fn
);
1629 /* Return statements in the function body will be replaced by jumps
1630 to the RET_LABEL. */
1631 id
->ret_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
1632 DECL_ARTIFICIAL (id
->ret_label
) = 1;
1633 DECL_IGNORED_P (id
->ret_label
) = 1;
1634 DECL_CONTEXT (id
->ret_label
) = VARRAY_TREE (id
->fns
, 0);
1635 insert_decl_map (id
, id
->ret_label
, id
->ret_label
);
1637 gcc_assert (DECL_INITIAL (fn
));
1638 gcc_assert (TREE_CODE (DECL_INITIAL (fn
)) == BLOCK
);
1640 /* Find the lhs to which the result of this call is assigned. */
1641 modify_dest
= tsi_stmt (id
->tsi
);
1642 if (TREE_CODE (modify_dest
) == MODIFY_EXPR
)
1644 modify_dest
= TREE_OPERAND (modify_dest
, 0);
1646 /* The function which we are inlining might not return a value,
1647 in which case we should issue a warning that the function
1648 does not return a value. In that case the optimizers will
1649 see that the variable to which the value is assigned was not
1650 initialized. We do not want to issue a warning about that
1651 uninitialized variable. */
1652 if (DECL_P (modify_dest
))
1653 TREE_NO_WARNING (modify_dest
) = 1;
1658 /* Declare the return variable for the function. */
1659 declare_return_variable (id
, return_slot_addr
,
1660 modify_dest
, &use_retvar
);
1662 /* After we've initialized the parameters, we insert the body of the
1665 struct cgraph_node
*old_node
= id
->current_node
;
1668 id
->current_node
= edge
->callee
;
1669 copy
= copy_body (id
);
1671 /* If the function uses a return slot, then it may legitimately
1672 fall through while still returning a value, so we have to skip
1673 the warning here. */
1674 if (warn_return_type
1675 && !TREE_NO_WARNING (fn
)
1676 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fn
)))
1677 && return_slot_addr
== NULL_TREE
1678 && block_may_fallthru (copy
))
1680 warning ("control may reach end of non-void function %qD being inlined",
1682 TREE_NO_WARNING (fn
) = 1;
1685 append_to_statement_list (copy
, &BIND_EXPR_BODY (expr
));
1686 id
->current_node
= old_node
;
1688 inlined_body
= &BIND_EXPR_BODY (expr
);
1690 /* After the body of the function comes the RET_LABEL. This must come
1691 before we evaluate the returned value below, because that evaluation
1692 may cause RTL to be generated. */
1693 if (TREE_USED (id
->ret_label
))
1695 tree label
= build1 (LABEL_EXPR
, void_type_node
, id
->ret_label
);
1696 append_to_statement_list (label
, &BIND_EXPR_BODY (expr
));
1700 splay_tree_delete (id
->decl_map
);
1703 /* Although, from the semantic viewpoint, the new expression has
1704 side-effects only if the old one did, it is not possible, from
1705 the technical viewpoint, to evaluate the body of a function
1706 multiple times without serious havoc. */
1707 TREE_SIDE_EFFECTS (expr
) = 1;
1709 tsi_link_before (&id
->tsi
, expr
, TSI_SAME_STMT
);
1711 /* If the inlined function returns a result that we care about,
1712 then we're going to need to splice in a MODIFY_EXPR. Otherwise
1713 the call was a standalone statement and we can just replace it
1714 with the BIND_EXPR inline representation of the called function. */
1715 if (!use_retvar
|| !modify_dest
)
1716 *tsi_stmt_ptr (id
->tsi
) = build_empty_stmt ();
1720 /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS on
1721 the call if it is to a "const" function. Thus the copy of
1722 TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above with
1723 result in TREE_SIDE_EFFECTS not being set for the inlined copy of a
1726 Unfortunately, that is wrong as inlining the function can create/expose
1727 interesting side effects (such as setting of a return value).
1729 The easiest solution is to simply recalculate TREE_SIDE_EFFECTS for
1730 the toplevel expression. */
1731 recalculate_side_effects (expr
);
1733 /* Output the inlining info for this abstract function, since it has been
1734 inlined. If we don't do this now, we can lose the information about the
1735 variables in the function when the blocks get blown away as soon as we
1736 remove the cgraph node. */
1737 (*debug_hooks
->outlining_inline_function
) (edge
->callee
->decl
);
1739 /* Update callgraph if needed. */
1740 cgraph_remove_node (edge
->callee
);
1742 /* Recurse into the body of the just inlined function. */
1743 expand_calls_inline (inlined_body
, id
);
1744 VARRAY_POP (id
->fns
);
1746 /* Don't walk into subtrees. We've already handled them above. */
1749 lang_hooks
.tree_inlining
.end_inlining (fn
);
1751 /* Keep iterating. */
1753 input_location
= saved_location
;
1758 expand_calls_inline (tree
*stmt_p
, inline_data
*id
)
1760 tree stmt
= *stmt_p
;
1761 enum tree_code code
= TREE_CODE (stmt
);
1766 case STATEMENT_LIST
:
1768 tree_stmt_iterator i
;
1771 for (i
= tsi_start (stmt
); !tsi_end_p (i
); )
1774 expand_calls_inline (tsi_stmt_ptr (i
), id
);
1777 if (TREE_CODE (new) == STATEMENT_LIST
)
1779 tsi_link_before (&i
, new, TSI_SAME_STMT
);
1789 expand_calls_inline (&COND_EXPR_THEN (stmt
), id
);
1790 expand_calls_inline (&COND_EXPR_ELSE (stmt
), id
);
1794 expand_calls_inline (&CATCH_BODY (stmt
), id
);
1797 case EH_FILTER_EXPR
:
1798 expand_calls_inline (&EH_FILTER_FAILURE (stmt
), id
);
1801 case TRY_CATCH_EXPR
:
1802 case TRY_FINALLY_EXPR
:
1803 expand_calls_inline (&TREE_OPERAND (stmt
, 0), id
);
1804 expand_calls_inline (&TREE_OPERAND (stmt
, 1), id
);
1808 expand_calls_inline (&BIND_EXPR_BODY (stmt
), id
);
1812 /* We're gimple. We should have gotten rid of all these. */
1816 stmt_p
= &TREE_OPERAND (stmt
, 0);
1818 if (!stmt
|| TREE_CODE (stmt
) != MODIFY_EXPR
)
1824 stmt_p
= &TREE_OPERAND (stmt
, 1);
1826 if (TREE_CODE (stmt
) == WITH_SIZE_EXPR
)
1828 stmt_p
= &TREE_OPERAND (stmt
, 0);
1831 if (TREE_CODE (stmt
) != CALL_EXPR
)
1837 expand_call_inline (stmt_p
, &dummy
, id
);
1845 /* Expand calls to inline functions in the body of FN. */
1848 optimize_inline_calls (tree fn
)
1853 /* There is no point in performing inlining if errors have already
1854 occurred -- and we might crash if we try to inline invalid
1856 if (errorcount
|| sorrycount
)
1860 memset (&id
, 0, sizeof (id
));
1862 id
.current_node
= id
.node
= cgraph_node (fn
);
1863 /* Don't allow recursion into FN. */
1864 VARRAY_TREE_INIT (id
.fns
, 32, "fns");
1865 VARRAY_PUSH_TREE (id
.fns
, fn
);
1866 /* Or any functions that aren't finished yet. */
1867 prev_fn
= NULL_TREE
;
1868 if (current_function_decl
)
1870 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
1871 prev_fn
= current_function_decl
;
1874 prev_fn
= lang_hooks
.tree_inlining
.add_pending_fn_decls (&id
.fns
, prev_fn
);
1876 /* Keep track of the low-water mark, i.e., the point where the first
1877 real inlining is represented in ID.FNS. */
1878 id
.first_inlined_fn
= VARRAY_ACTIVE_SIZE (id
.fns
);
1880 /* Replace all calls to inline functions with the bodies of those
1882 id
.tree_pruner
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1883 expand_calls_inline (&DECL_SAVED_TREE (fn
), &id
);
1886 htab_delete (id
.tree_pruner
);
1888 #ifdef ENABLE_CHECKING
1890 struct cgraph_edge
*e
;
1892 verify_cgraph_node (id
.node
);
1894 /* Double check that we inlined everything we are supposed to inline. */
1895 for (e
= id
.node
->callees
; e
; e
= e
->next_callee
)
1896 gcc_assert (e
->inline_failed
);
1901 /* FN is a function that has a complete body, and CLONE is a function whose
1902 body is to be set to a copy of FN, mapping argument declarations according
1903 to the ARG_MAP splay_tree. */
1906 clone_body (tree clone
, tree fn
, void *arg_map
)
1910 /* Clone the body, as if we were making an inline call. But, remap the
1911 parameters in the callee to the parameters of caller. If there's an
1912 in-charge parameter, map it to an appropriate constant. */
1913 memset (&id
, 0, sizeof (id
));
1914 VARRAY_TREE_INIT (id
.fns
, 2, "fns");
1915 VARRAY_PUSH_TREE (id
.fns
, clone
);
1916 VARRAY_PUSH_TREE (id
.fns
, fn
);
1917 id
.decl_map
= (splay_tree
)arg_map
;
1919 /* Cloning is treated slightly differently from inlining. Set
1920 CLONING_P so that it's clear which operation we're performing. */
1921 id
.cloning_p
= true;
1923 /* Actually copy the body. */
1924 append_to_statement_list_force (copy_body (&id
), &DECL_SAVED_TREE (clone
));
1927 /* Make and return duplicate of body in FN. Put copies of DECL_ARGUMENTS
1928 in *arg_copy and of the static chain, if any, in *sc_copy. */
1931 save_body (tree fn
, tree
*arg_copy
, tree
*sc_copy
)
1936 memset (&id
, 0, sizeof (id
));
1937 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
1938 VARRAY_PUSH_TREE (id
.fns
, fn
);
1939 id
.node
= cgraph_node (fn
);
1941 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
1942 *arg_copy
= DECL_ARGUMENTS (fn
);
1944 for (parg
= arg_copy
; *parg
; parg
= &TREE_CHAIN (*parg
))
1946 tree
new = copy_node (*parg
);
1948 lang_hooks
.dup_lang_specific_decl (new);
1949 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg
);
1950 insert_decl_map (&id
, *parg
, new);
1951 TREE_CHAIN (new) = TREE_CHAIN (*parg
);
1955 *sc_copy
= DECL_STRUCT_FUNCTION (fn
)->static_chain_decl
;
1958 tree
new = copy_node (*sc_copy
);
1960 lang_hooks
.dup_lang_specific_decl (new);
1961 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*sc_copy
);
1962 insert_decl_map (&id
, *sc_copy
, new);
1963 TREE_CHAIN (new) = TREE_CHAIN (*sc_copy
);
1967 insert_decl_map (&id
, DECL_RESULT (fn
), DECL_RESULT (fn
));
1969 /* Actually copy the body. */
1970 body
= copy_body (&id
);
1973 splay_tree_delete (id
.decl_map
);
1977 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
1980 copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1982 enum tree_code code
= TREE_CODE (*tp
);
1984 /* We make copies of most nodes. */
1985 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1986 || code
== TREE_LIST
1988 || code
== TYPE_DECL
)
1990 /* Because the chain gets clobbered when we make a copy, we save it
1992 tree chain
= TREE_CHAIN (*tp
);
1995 /* Copy the node. */
1996 new = copy_node (*tp
);
1998 /* Propagate mudflap marked-ness. */
1999 if (flag_mudflap
&& mf_marked_p (*tp
))
2004 /* Now, restore the chain, if appropriate. That will cause
2005 walk_tree to walk into the chain as well. */
2006 if (code
== PARM_DECL
|| code
== TREE_LIST
)
2007 TREE_CHAIN (*tp
) = chain
;
2009 /* For now, we don't update BLOCKs when we make copies. So, we
2010 have to nullify all BIND_EXPRs. */
2011 if (TREE_CODE (*tp
) == BIND_EXPR
)
2012 BIND_EXPR_BLOCK (*tp
) = NULL_TREE
;
2015 else if (TREE_CODE_CLASS (code
) == tcc_type
)
2017 else if (TREE_CODE_CLASS (code
) == tcc_declaration
)
2019 else if (TREE_CODE_CLASS (code
) == tcc_constant
)
2022 gcc_assert (code
!= STATEMENT_LIST
);
2026 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2027 information indicating to what new SAVE_EXPR this one should be mapped,
2028 use that one. Otherwise, create a new node and enter it in ST. */
2031 remap_save_expr (tree
*tp
, void *st_
, int *walk_subtrees
)
2033 splay_tree st
= (splay_tree
) st_
;
2037 /* See if we already encountered this SAVE_EXPR. */
2038 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2040 /* If we didn't already remap this SAVE_EXPR, do so now. */
2043 t
= copy_node (*tp
);
2045 /* Remember this SAVE_EXPR. */
2046 splay_tree_insert (st
, (splay_tree_key
) *tp
, (splay_tree_value
) t
);
2047 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2048 splay_tree_insert (st
, (splay_tree_key
) t
, (splay_tree_value
) t
);
2052 /* We've already walked into this SAVE_EXPR; don't do it again. */
2054 t
= (tree
) n
->value
;
2057 /* Replace this SAVE_EXPR with the copy. */
2061 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
2062 copies the declaration and enters it in the splay_tree in DATA (which is
2063 really an `inline_data *'). */
2066 mark_local_for_remap_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
2069 inline_data
*id
= (inline_data
*) data
;
2071 /* Don't walk into types. */
2075 else if (TREE_CODE (*tp
) == LABEL_EXPR
)
2077 tree decl
= TREE_OPERAND (*tp
, 0);
2079 /* Copy the decl and remember the copy. */
2080 insert_decl_map (id
, decl
,
2081 copy_decl_for_inlining (decl
, DECL_CONTEXT (decl
),
2082 DECL_CONTEXT (decl
)));
2088 /* Perform any modifications to EXPR required when it is unsaved. Does
2089 not recurse into EXPR's subtrees. */
2092 unsave_expr_1 (tree expr
)
2094 switch (TREE_CODE (expr
))
2097 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
2098 It's OK for this to happen if it was part of a subtree that
2099 isn't immediately expanded, such as operand 2 of another
2101 if (TREE_OPERAND (expr
, 1))
2104 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
2105 TREE_OPERAND (expr
, 3) = NULL_TREE
;
2113 /* Called via walk_tree when an expression is unsaved. Using the
2114 splay_tree pointed to by ST (which is really a `splay_tree'),
2115 remaps all local declarations to appropriate replacements. */
2118 unsave_r (tree
*tp
, int *walk_subtrees
, void *data
)
2120 inline_data
*id
= (inline_data
*) data
;
2121 splay_tree st
= id
->decl_map
;
2124 /* Only a local declaration (variable or label). */
2125 if ((TREE_CODE (*tp
) == VAR_DECL
&& !TREE_STATIC (*tp
))
2126 || TREE_CODE (*tp
) == LABEL_DECL
)
2128 /* Lookup the declaration. */
2129 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2131 /* If it's there, remap it. */
2133 *tp
= (tree
) n
->value
;
2136 else if (TREE_CODE (*tp
) == STATEMENT_LIST
)
2137 copy_statement_list (tp
);
2138 else if (TREE_CODE (*tp
) == BIND_EXPR
)
2139 copy_bind_expr (tp
, walk_subtrees
, id
);
2140 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2141 remap_save_expr (tp
, st
, walk_subtrees
);
2144 copy_tree_r (tp
, walk_subtrees
, NULL
);
2146 /* Do whatever unsaving is required. */
2147 unsave_expr_1 (*tp
);
2150 /* Keep iterating. */
2154 /* Copies everything in EXPR and replaces variables, labels
2155 and SAVE_EXPRs local to EXPR. */
2158 unsave_expr_now (tree expr
)
2162 /* There's nothing to do for NULL_TREE. */
2167 memset (&id
, 0, sizeof (id
));
2168 VARRAY_TREE_INIT (id
.fns
, 1, "fns");
2169 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
2170 id
.decl_map
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2172 /* Walk the tree once to find local labels. */
2173 walk_tree_without_duplicates (&expr
, mark_local_for_remap_r
, &id
);
2175 /* Walk the tree again, copying, remapping, and unsaving. */
2176 walk_tree (&expr
, unsave_r
, &id
, NULL
);
2179 splay_tree_delete (id
.decl_map
);
2184 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
2187 debug_find_tree_1 (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
, void *data
)
2196 debug_find_tree (tree top
, tree search
)
2198 return walk_tree_without_duplicates (&top
, debug_find_tree_1
, search
) != 0;
2201 /* Declare the variables created by the inliner. Add all the variables in
2202 VARS to BIND_EXPR. */
2205 declare_inline_vars (tree bind_expr
, tree vars
)
2208 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
2209 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
2211 add_var_to_bind_expr (bind_expr
, vars
);