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);
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)
357 gcc_assert (DECL_P (new_var));
358 TREE_CHAIN (new_var) = new_decls;
363 return nreverse (new_decls);
366 /* Copy the BLOCK to contain remapped versions of the variables
367 therein. And hook the new block into the block-tree. */
370 remap_block (tree *block, inline_data *id)
376 /* Make the new block. */
378 new_block = make_node (BLOCK);
379 TREE_USED (new_block) = TREE_USED (old_block);
380 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
383 /* Remap its variables. */
384 BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), id);
386 fn = VARRAY_TREE (id->fns, 0);
388 /* FIXME! It shouldn't be so hard to manage blocks. Rebuilding them in
389 rest_of_compilation is a good start. */
391 /* We're building a clone; DECL_INITIAL is still
392 error_mark_node, and current_binding_level is the parm
394 lang_hooks.decls.insert_block (new_block);
397 /* Attach this new block after the DECL_INITIAL block for the
398 function into which this block is being inlined. In
399 rest_of_compilation we will straighten out the BLOCK tree. */
401 if (DECL_INITIAL (fn))
402 first_block = &BLOCK_CHAIN (DECL_INITIAL (fn));
404 first_block = &DECL_INITIAL (fn);
405 BLOCK_CHAIN (new_block) = *first_block;
406 *first_block = new_block;
409 /* Remember the remapped block. */
410 insert_decl_map (id, old_block, new_block);
414 copy_statement_list (tree *tp)
416 tree_stmt_iterator oi, ni;
419 new = alloc_stmt_list ();
420 ni = tsi_start (new);
421 oi = tsi_start (*tp);
424 for (; !tsi_end_p (oi); tsi_next (&oi))
425 tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT);
429 copy_bind_expr (tree *tp, int *walk_subtrees, inline_data *id)
431 tree block = BIND_EXPR_BLOCK (*tp);
432 /* Copy (and replace) the statement. */
433 copy_tree_r (tp, walk_subtrees, NULL);
436 remap_block (&block, id);
437 BIND_EXPR_BLOCK (*tp) = block;
440 if (BIND_EXPR_VARS (*tp))
441 /* This will remap a lot of the same decls again, but this should be
443 BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id);
446 /* Called from copy_body via walk_tree. DATA is really an `inline_data *'. */
449 copy_body_r (tree *tp, int *walk_subtrees, void *data)
451 inline_data *id = (inline_data *) data;
452 tree fn = VARRAY_TOP_TREE (id->fns);
455 /* All automatic variables should have a DECL_CONTEXT indicating
456 what function they come from. */
457 if ((TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == LABEL_DECL)
458 && DECL_NAMESPACE_SCOPE_P (*tp))
459 gcc_assert (DECL_EXTERNAL (*tp) || TREE_STATIC (*tp));
462 /* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
463 GOTO_EXPR with the RET_LABEL as its target. */
464 if (TREE_CODE (*tp) == RETURN_EXPR && id->ret_label)
466 tree return_stmt = *tp;
469 /* Build the GOTO_EXPR. */
470 tree assignment = TREE_OPERAND (return_stmt, 0);
471 goto_stmt = build1 (GOTO_EXPR, void_type_node, id->ret_label);
472 TREE_USED (id->ret_label) = 1;
474 /* If we're returning something, just turn that into an
475 assignment into the equivalent of the original
479 /* Do not create a statement containing a naked RESULT_DECL. */
480 if (TREE_CODE (assignment) == RESULT_DECL)
481 gimplify_stmt (&assignment);
483 *tp = build (BIND_EXPR, void_type_node, NULL, NULL, NULL);
484 append_to_statement_list (assignment, &BIND_EXPR_BODY (*tp));
485 append_to_statement_list (goto_stmt, &BIND_EXPR_BODY (*tp));
487 /* If we're not returning anything just do the jump. */
491 /* Local variables and labels need to be replaced by equivalent
492 variables. We don't want to copy static variables; there's only
493 one of those, no matter how many times we inline the containing
494 function. Similarly for globals from an outer function. */
495 else if (lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
499 /* Remap the declaration. */
500 new_decl = remap_decl (*tp, id);
501 gcc_assert (new_decl);
502 /* Replace this variable with the copy. */
503 STRIP_TYPE_NOPS (new_decl);
507 else if (TREE_CODE (*tp) == STATEMENT_LIST)
508 copy_statement_list (tp);
509 else if (TREE_CODE (*tp) == SAVE_EXPR)
510 remap_save_expr (tp, id->decl_map, walk_subtrees);
511 else if (TREE_CODE (*tp) == BIND_EXPR)
512 copy_bind_expr (tp, walk_subtrees, id);
513 /* Types may need remapping as well. */
514 else if (TYPE_P (*tp))
515 *tp = remap_type (*tp, id);
517 /* If this is a constant, we have to copy the node iff the type will be
518 remapped. copy_tree_r will not copy a constant. */
519 else if (TREE_CODE_CLASS (TREE_CODE (*tp)) == tcc_constant)
521 tree new_type = remap_type (TREE_TYPE (*tp), id);
523 if (new_type == TREE_TYPE (*tp))
526 else if (TREE_CODE (*tp) == INTEGER_CST)
527 *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
528 TREE_INT_CST_HIGH (*tp));
531 *tp = copy_node (*tp);
532 TREE_TYPE (*tp) = new_type;
536 /* Otherwise, just copy the node. Note that copy_tree_r already
537 knows not to copy VAR_DECLs, etc., so this is safe. */
542 if (TREE_CODE (*tp) == MODIFY_EXPR
543 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
544 && (lang_hooks.tree_inlining.auto_var_in_fn_p
545 (TREE_OPERAND (*tp, 0), fn)))
547 /* Some assignments VAR = VAR; don't generate any rtl code
548 and thus don't count as variable modification. Avoid
549 keeping bogosities like 0 = 0. */
550 tree decl = TREE_OPERAND (*tp, 0), value;
553 n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
556 value = (tree) n->value;
557 STRIP_TYPE_NOPS (value);
558 if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
560 *tp = build_empty_stmt ();
561 return copy_body_r (tp, walk_subtrees, data);
565 else if (TREE_CODE (*tp) == INDIRECT_REF)
567 /* Get rid of *& from inline substitutions that can happen when a
568 pointer argument is an ADDR_EXPR. */
569 tree decl = TREE_OPERAND (*tp, 0), value;
572 n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
575 value = (tree) n->value;
577 if (TREE_CODE (value) == ADDR_EXPR
578 && (lang_hooks.types_compatible_p
579 (TREE_TYPE (*tp), TREE_TYPE (TREE_OPERAND (value, 0)))))
581 *tp = TREE_OPERAND (value, 0);
582 return copy_body_r (tp, walk_subtrees, data);
587 copy_tree_r (tp, walk_subtrees, NULL);
589 if (TREE_CODE (*tp) == CALL_EXPR && id->node && get_callee_fndecl (*tp))
593 struct cgraph_node *node;
594 struct cgraph_edge *edge;
596 for (node = id->node->next_clone; node; node = node->next_clone)
598 edge = cgraph_edge (node, old_node);
600 edge->call_expr = *tp;
605 struct cgraph_edge *edge
606 = cgraph_edge (id->current_node, old_node);
609 cgraph_clone_edge (edge, id->node, *tp);
613 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
615 /* The copied TARGET_EXPR has never been expanded, even if the
616 original node was expanded already. */
617 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
619 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
620 TREE_OPERAND (*tp, 3) = NULL_TREE;
623 /* Variable substitution need not be simple. In particular, the
624 INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
625 and friends are up-to-date. */
626 else if (TREE_CODE (*tp) == ADDR_EXPR)
628 walk_tree (&TREE_OPERAND (*tp, 0), copy_body_r, id, NULL);
629 recompute_tree_invarant_for_addr_expr (*tp);
634 /* Keep iterating. */
638 /* Make a copy of the body of FN so that it can be inserted inline in
642 copy_body (inline_data *id)
645 tree fndecl = VARRAY_TOP_TREE (id->fns);
647 if (fndecl == current_function_decl
649 body = cfun->saved_tree;
651 body = DECL_SAVED_TREE (fndecl);
652 walk_tree (&body, copy_body_r, id, NULL);
657 /* Return true if VALUE is an ADDR_EXPR of an automatic variable
658 defined in function FN, or of a data member thereof. */
661 self_inlining_addr_expr (tree value, tree fn)
665 if (TREE_CODE (value) != ADDR_EXPR)
668 var = get_base_address (TREE_OPERAND (value, 0));
670 return var && lang_hooks.tree_inlining.auto_var_in_fn_p (var, fn);
674 setup_one_parameter (inline_data *id, tree p, tree value, tree fn,
675 tree *init_stmts, tree *vars, bool *gimplify_init_stmts_p)
680 /* If the parameter is never assigned to, we may not need to
681 create a new variable here at all. Instead, we may be able
682 to just use the argument value. */
683 if (TREE_READONLY (p)
684 && !TREE_ADDRESSABLE (p)
685 && value && !TREE_SIDE_EFFECTS (value))
687 /* We can't risk substituting complex expressions. They
688 might contain variables that will be assigned to later.
689 Theoretically, we could check the expression to see if
690 all of the variables that determine its value are
691 read-only, but we don't bother. */
692 /* We may produce non-gimple trees by adding NOPs or introduce
693 invalid sharing when operand is not really constant.
694 It is not big deal to prohibit constant propagation here as
695 we will constant propagate in DOM1 pass anyway. */
696 if (is_gimple_min_invariant (value)
697 && lang_hooks.types_compatible_p (TREE_TYPE (value), TREE_TYPE (p))
698 /* We have to be very careful about ADDR_EXPR. Make sure
699 the base variable isn't a local variable of the inlined
700 function, e.g., when doing recursive inlining, direct or
701 mutually-recursive or whatever, which is why we don't
702 just test whether fn == current_function_decl. */
703 && ! self_inlining_addr_expr (value, fn))
705 insert_decl_map (id, p, value);
710 /* Make an equivalent VAR_DECL. Note that we must NOT remap the type
711 here since the type of this decl must be visible to the calling
713 var = copy_decl_for_inlining (p, fn, VARRAY_TREE (id->fns, 0));
715 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
716 that way, when the PARM_DECL is encountered, it will be
717 automatically replaced by the VAR_DECL. */
718 insert_decl_map (id, p, var);
720 /* Declare this new variable. */
721 TREE_CHAIN (var) = *vars;
724 /* Make gimplifier happy about this variable. */
725 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
727 /* Even if P was TREE_READONLY, the new VAR should not be.
728 In the original code, we would have constructed a
729 temporary, and then the function body would have never
730 changed the value of P. However, now, we will be
731 constructing VAR directly. The constructor body may
732 change its value multiple times as it is being
733 constructed. Therefore, it must not be TREE_READONLY;
734 the back-end assumes that TREE_READONLY variable is
735 assigned to only once. */
736 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
737 TREE_READONLY (var) = 0;
739 /* Initialize this VAR_DECL from the equivalent argument. Convert
740 the argument to the proper type in case it was promoted. */
743 tree rhs = fold_convert (TREE_TYPE (var), value);
745 if (rhs == error_mark_node)
748 /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we
749 keep our trees in gimple form. */
750 init_stmt = build (MODIFY_EXPR, TREE_TYPE (var), var, rhs);
751 append_to_statement_list (init_stmt, init_stmts);
753 /* If we did not create a gimple value and we did not create a gimple
754 cast of a gimple value, then we will need to gimplify INIT_STMTS
755 at the end. Note that is_gimple_cast only checks the outer
756 tree code, not its operand. Thus the explicit check that it's
757 operand is a gimple value. */
758 if (!is_gimple_val (rhs)
759 && (!is_gimple_cast (rhs)
760 || !is_gimple_val (TREE_OPERAND (rhs, 0))))
761 *gimplify_init_stmts_p = true;
765 /* Generate code to initialize the parameters of the function at the
766 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
769 initialize_inlined_parameters (inline_data *id, tree args, tree static_chain,
770 tree fn, tree bind_expr)
772 tree init_stmts = NULL_TREE;
776 tree vars = NULL_TREE;
777 bool gimplify_init_stmts_p = false;
780 /* Figure out what the parameters are. */
781 parms = DECL_ARGUMENTS (fn);
782 if (fn == current_function_decl)
783 parms = cfun->saved_args;
785 /* Loop through the parameter declarations, replacing each with an
786 equivalent VAR_DECL, appropriately initialized. */
787 for (p = parms, a = args; p;
788 a = a ? TREE_CHAIN (a) : a, p = TREE_CHAIN (p))
794 /* Find the initializer. */
795 value = lang_hooks.tree_inlining.convert_parm_for_inlining
796 (p, a ? TREE_VALUE (a) : NULL_TREE, fn, argnum);
798 setup_one_parameter (id, p, value, fn, &init_stmts, &vars,
799 &gimplify_init_stmts_p);
802 /* Evaluate trailing arguments. */
803 for (; a; a = TREE_CHAIN (a))
805 tree value = TREE_VALUE (a);
806 append_to_statement_list (value, &init_stmts);
809 /* Initialize the static chain. */
810 p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
811 if (fn == current_function_decl)
812 p = DECL_STRUCT_FUNCTION (fn)->saved_static_chain_decl;
815 /* No static chain? Seems like a bug in tree-nested.c. */
816 gcc_assert (static_chain);
818 setup_one_parameter (id, p, static_chain, fn, &init_stmts, &vars,
819 &gimplify_init_stmts_p);
822 if (gimplify_init_stmts_p)
823 gimplify_body (&init_stmts, current_function_decl, false);
825 declare_inline_vars (bind_expr, vars);
829 /* Declare a return variable to replace the RESULT_DECL for the function we
830 are calling. RETURN_SLOT_ADDR, if non-null, was a fake parameter that
831 took the address of the result. MODIFY_DEST, if non-null, was the LHS of
832 the MODIFY_EXPR to which this call is the RHS.
834 The return value is a (possibly null) value that is the result of the
835 function as seen by the callee. *USE_P is a (possibly null) value that
836 holds the result as seen by the caller. */
839 declare_return_variable (inline_data *id, tree return_slot_addr,
840 tree modify_dest, tree *use_p)
842 tree callee = VARRAY_TOP_TREE (id->fns);
843 tree caller = VARRAY_TREE (id->fns, 0);
844 tree result = DECL_RESULT (callee);
845 tree callee_type = TREE_TYPE (result);
846 tree caller_type = TREE_TYPE (TREE_TYPE (callee));
849 /* We don't need to do anything for functions that don't return
851 if (!result || VOID_TYPE_P (callee_type))
857 /* If there was a return slot, then the return value is the
858 dereferenced address of that object. */
859 if (return_slot_addr)
861 /* The front end shouldn't have used both return_slot_addr and
862 a modify expression. */
863 gcc_assert (!modify_dest);
864 if (DECL_BY_REFERENCE (result))
865 var = return_slot_addr;
867 var = build_fold_indirect_ref (return_slot_addr);
872 /* All types requiring non-trivial constructors should have been handled. */
873 gcc_assert (!TREE_ADDRESSABLE (callee_type));
875 /* Attempt to avoid creating a new temporary variable. */
880 /* We can't use MODIFY_DEST if there's type promotion involved. */
881 if (!lang_hooks.types_compatible_p (caller_type, callee_type))
884 /* ??? If we're assigning to a variable sized type, then we must
885 reuse the destination variable, because we've no good way to
886 create variable sized temporaries at this point. */
887 else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
890 /* If the callee cannot possibly modify MODIFY_DEST, then we can
891 reuse it as the result of the call directly. Don't do this if
892 it would promote MODIFY_DEST to addressable. */
893 else if (!TREE_STATIC (modify_dest)
894 && !TREE_ADDRESSABLE (modify_dest)
895 && !TREE_ADDRESSABLE (result))
906 gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
908 var = copy_decl_for_inlining (result, callee, caller);
909 DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
910 DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list
911 = tree_cons (NULL_TREE, var,
912 DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
914 /* Do not have the rest of GCC warn about this variable as it should
915 not be visible to the user. */
916 TREE_NO_WARNING (var) = 1;
918 /* Build the use expr. If the return type of the function was
919 promoted, convert it back to the expected type. */
921 if (!lang_hooks.types_compatible_p (TREE_TYPE (var), caller_type))
922 use = fold_convert (caller_type, var);
925 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
926 way, when the RESULT_DECL is encountered, it will be
927 automatically replaced by the VAR_DECL. */
928 insert_decl_map (id, result, var);
930 /* Remember this so we can ignore it in remap_decls. */
937 /* Returns nonzero if a function can be inlined as a tree. */
940 tree_inlinable_function_p (tree fn)
942 return inlinable_function_p (fn);
945 static const char *inline_forbidden_reason;
948 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
952 tree fn = (tree) fnp;
955 switch (TREE_CODE (node))
958 /* Refuse to inline alloca call unless user explicitly forced so as
959 this may change program's memory overhead drastically when the
960 function using alloca is called in loop. In GCC present in
961 SPEC2000 inlining into schedule_block cause it to require 2GB of
962 RAM instead of 256MB. */
963 if (alloca_call_p (node)
964 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
966 inline_forbidden_reason
967 = N_("%Jfunction %qF can never be inlined because it uses "
968 "alloca (override using the always_inline attribute)");
971 t = get_callee_fndecl (node);
975 /* We cannot inline functions that call setjmp. */
976 if (setjmp_call_p (t))
978 inline_forbidden_reason
979 = N_("%Jfunction %qF can never be inlined because it uses setjmp");
983 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
984 switch (DECL_FUNCTION_CODE (t))
986 /* We cannot inline functions that take a variable number of
988 case BUILT_IN_VA_START:
989 case BUILT_IN_STDARG_START:
990 case BUILT_IN_NEXT_ARG:
991 case BUILT_IN_VA_END:
992 inline_forbidden_reason
993 = N_("%Jfunction %qF can never be inlined because it "
994 "uses variable argument lists");
997 case BUILT_IN_LONGJMP:
998 /* We can't inline functions that call __builtin_longjmp at
999 all. The non-local goto machinery really requires the
1000 destination be in a different function. If we allow the
1001 function calling __builtin_longjmp to be inlined into the
1002 function calling __builtin_setjmp, Things will Go Awry. */
1003 inline_forbidden_reason
1004 = N_("%Jfunction %qF can never be inlined because "
1005 "it uses setjmp-longjmp exception handling");
1008 case BUILT_IN_NONLOCAL_GOTO:
1010 inline_forbidden_reason
1011 = N_("%Jfunction %qF can never be inlined because "
1012 "it uses non-local goto");
1021 t = TREE_OPERAND (node, 0);
1023 /* We will not inline a function which uses computed goto. The
1024 addresses of its local labels, which may be tucked into
1025 global storage, are of course not constant across
1026 instantiations, which causes unexpected behavior. */
1027 if (TREE_CODE (t) != LABEL_DECL)
1029 inline_forbidden_reason
1030 = N_("%Jfunction %qF can never be inlined "
1031 "because it contains a computed goto");
1037 t = TREE_OPERAND (node, 0);
1038 if (DECL_NONLOCAL (t))
1040 /* We cannot inline a function that receives a non-local goto
1041 because we cannot remap the destination label used in the
1042 function that is performing the non-local goto. */
1043 inline_forbidden_reason
1044 = N_("%Jfunction %qF can never be inlined "
1045 "because it receives a non-local goto");
1052 /* We cannot inline a function of the form
1054 void F (int i) { struct S { int ar[i]; } s; }
1056 Attempting to do so produces a catch-22.
1057 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1058 UNION_TYPE nodes, then it goes into infinite recursion on a
1059 structure containing a pointer to its own type. If it doesn't,
1060 then the type node for S doesn't get adjusted properly when
1061 F is inlined, and we abort in find_function_data.
1063 ??? This is likely no longer true, but it's too late in the 4.0
1064 cycle to try to find out. This should be checked for 4.1. */
1065 for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1066 if (variably_modified_type_p (TREE_TYPE (t), NULL))
1068 inline_forbidden_reason
1069 = N_("%Jfunction %qF can never be inlined "
1070 "because it uses variable sized variables");
1081 /* Return subexpression representing possible alloca call, if any. */
1083 inline_forbidden_p (tree fndecl)
1085 location_t saved_loc = input_location;
1086 tree ret = walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
1087 inline_forbidden_p_1, fndecl);
1089 input_location = saved_loc;
1093 /* Returns nonzero if FN is a function that does not have any
1094 fundamental inline blocking properties. */
1097 inlinable_function_p (tree fn)
1099 bool inlinable = true;
1101 /* If we've already decided this function shouldn't be inlined,
1102 there's no need to check again. */
1103 if (DECL_UNINLINABLE (fn))
1106 /* See if there is any language-specific reason it cannot be
1107 inlined. (It is important that this hook be called early because
1108 in C++ it may result in template instantiation.)
1109 If the function is not inlinable for language-specific reasons,
1110 it is left up to the langhook to explain why. */
1111 inlinable = !lang_hooks.tree_inlining.cannot_inline_tree_fn (&fn);
1113 /* If we don't have the function body available, we can't inline it.
1114 However, this should not be recorded since we also get here for
1115 forward declared inline functions. Therefore, return at once. */
1116 if (!DECL_SAVED_TREE (fn))
1119 /* If we're not inlining at all, then we cannot inline this function. */
1120 else if (!flag_inline_trees)
1123 /* Only try to inline functions if DECL_INLINE is set. This should be
1124 true for all functions declared `inline', and for all other functions
1125 as well with -finline-functions.
1127 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1128 it's the front-end that must set DECL_INLINE in this case, because
1129 dwarf2out loses if a function that does not have DECL_INLINE set is
1130 inlined anyway. That is why we have both DECL_INLINE and
1131 DECL_DECLARED_INLINE_P. */
1132 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1133 here should be redundant. */
1134 else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
1137 else if (inline_forbidden_p (fn))
1139 /* See if we should warn about uninlinable functions. Previously,
1140 some of these warnings would be issued while trying to expand
1141 the function inline, but that would cause multiple warnings
1142 about functions that would for example call alloca. But since
1143 this a property of the function, just one warning is enough.
1144 As a bonus we can now give more details about the reason why a
1145 function is not inlinable.
1146 We only warn for functions declared `inline' by the user. */
1147 bool do_warning = (warn_inline
1149 && DECL_DECLARED_INLINE_P (fn)
1150 && !DECL_IN_SYSTEM_HEADER (fn));
1152 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1153 sorry (inline_forbidden_reason, fn, fn);
1154 else if (do_warning)
1155 warning (inline_forbidden_reason, fn, fn);
1160 /* Squirrel away the result so that we don't have to check again. */
1161 DECL_UNINLINABLE (fn) = !inlinable;
1166 /* Estimate the cost of a memory move. Use machine dependent
1167 word size and take possible memcpy call into account. */
1170 estimate_move_cost (tree type)
1174 size = int_size_in_bytes (type);
1176 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
1177 /* Cost of a memcpy call, 3 arguments and the call. */
1180 return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
1183 /* Used by estimate_num_insns. Estimate number of instructions seen
1184 by given statement. */
1187 estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
1192 if (IS_TYPE_OR_DECL_P (x))
1197 /* Assume that constants and references counts nothing. These should
1198 be majorized by amount of operations among them we count later
1199 and are common target of CSE and similar optimizations. */
1200 else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
1203 switch (TREE_CODE (x))
1205 /* Containers have no cost. */
1212 case ALIGN_INDIRECT_REF:
1213 case MISALIGNED_INDIRECT_REF:
1215 case ARRAY_RANGE_REF:
1217 case EXC_PTR_EXPR: /* ??? */
1218 case FILTER_EXPR: /* ??? */
1221 case WITH_CLEANUP_EXPR:
1223 case VIEW_CONVERT_EXPR:
1228 case CASE_LABEL_EXPR:
1231 case EH_FILTER_EXPR:
1232 case STATEMENT_LIST:
1234 case NON_LVALUE_EXPR:
1237 case TRY_CATCH_EXPR:
1238 case TRY_FINALLY_EXPR:
1245 case WITH_SIZE_EXPR:
1248 /* We don't account constants for now. Assume that the cost is amortized
1249 by operations that do use them. We may re-consider this decision once
1250 we are able to optimize the tree before estimating it's size and break
1251 out static initializers. */
1252 case IDENTIFIER_NODE:
1261 /* Try to estimate the cost of assignments. We have three cases to
1263 1) Simple assignments to registers;
1264 2) Stores to things that must live in memory. This includes
1265 "normal" stores to scalars, but also assignments of large
1266 structures, or constructors of big arrays;
1269 Let us look at the first two cases, assuming we have "a = b + C":
1270 <modify_expr <var_decl "a"> <plus_expr <var_decl "b"> <constant C>>
1271 If "a" is a GIMPLE register, the assignment to it is free on almost
1272 any target, because "a" usually ends up in a real register. Hence
1273 the only cost of this expression comes from the PLUS_EXPR, and we
1274 can ignore the MODIFY_EXPR.
1275 If "a" is not a GIMPLE register, the assignment to "a" will most
1276 likely be a real store, so the cost of the MODIFY_EXPR is the cost
1277 of moving something into "a", which we compute using the function
1280 The third case deals with TARGET_EXPRs, for which the semantics are
1281 that a temporary is assigned, unless the TARGET_EXPR itself is being
1282 assigned to something else. In the latter case we do not need the
1283 temporary. E.g. in <modify_expr <var_decl "a"> <target_expr>>, the
1284 MODIFY_EXPR is free. */
1287 /* Is the right and side a TARGET_EXPR? */
1288 if (TREE_CODE (TREE_OPERAND (x, 1)) == TARGET_EXPR)
1290 /* ... fall through ... */
1293 x = TREE_OPERAND (x, 0);
1294 /* Is this an assignments to a register? */
1295 if (is_gimple_reg (x))
1297 /* Otherwise it's a store, so fall through to compute the move cost. */
1300 *count += estimate_move_cost (TREE_TYPE (x));
1303 /* Assign cost of 1 to usual operations.
1304 ??? We may consider mapping RTL costs to this. */
1311 case FIX_TRUNC_EXPR:
1313 case FIX_FLOOR_EXPR:
1314 case FIX_ROUND_EXPR:
1332 case TRUTH_ANDIF_EXPR:
1333 case TRUTH_ORIF_EXPR:
1334 case TRUTH_AND_EXPR:
1336 case TRUTH_XOR_EXPR:
1337 case TRUTH_NOT_EXPR:
1346 case UNORDERED_EXPR:
1359 case PREDECREMENT_EXPR:
1360 case PREINCREMENT_EXPR:
1361 case POSTDECREMENT_EXPR:
1362 case POSTINCREMENT_EXPR:
1368 case REALIGN_LOAD_EXPR:
1374 /* Few special cases of expensive operations. This is useful
1375 to avoid inlining on functions having too many of these. */
1376 case TRUNC_DIV_EXPR:
1378 case FLOOR_DIV_EXPR:
1379 case ROUND_DIV_EXPR:
1380 case EXACT_DIV_EXPR:
1381 case TRUNC_MOD_EXPR:
1383 case FLOOR_MOD_EXPR:
1384 case ROUND_MOD_EXPR:
1390 tree decl = get_callee_fndecl (x);
1393 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
1394 switch (DECL_FUNCTION_CODE (decl))
1396 case BUILT_IN_CONSTANT_P:
1399 case BUILT_IN_EXPECT:
1405 /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining
1406 that does use function declaration to figure out the arguments. */
1409 for (arg = TREE_OPERAND (x, 1); arg; arg = TREE_CHAIN (arg))
1410 *count += estimate_move_cost (TREE_TYPE (TREE_VALUE (arg)));
1414 for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
1415 *count += estimate_move_cost (TREE_TYPE (arg));
1418 *count += PARAM_VALUE (PARAM_INLINE_CALL_COST);
1422 /* Abort here se we know we don't miss any nodes. */
1428 /* Estimate number of instructions that will be created by expanding EXPR. */
1431 estimate_num_insns (tree expr)
1434 walk_tree_without_duplicates (&expr, estimate_num_insns_1, &num);
1438 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1441 expand_call_inline (tree *tp, int *walk_subtrees, void *data)
1453 tree return_slot_addr;
1455 location_t saved_location;
1456 struct cgraph_edge *edge;
1459 /* See what we've got. */
1460 id = (inline_data *) data;
1463 /* Set input_location here so we get the right instantiation context
1464 if we call instantiate_decl from inlinable_function_p. */
1465 saved_location = input_location;
1466 if (EXPR_HAS_LOCATION (t))
1467 input_location = EXPR_LOCATION (t);
1469 /* Recurse, but letting recursive invocations know that we are
1470 inside the body of a TARGET_EXPR. */
1471 if (TREE_CODE (*tp) == TARGET_EXPR)
1474 int i, len = TREE_CODE_LENGTH (TARGET_EXPR);
1476 /* We're walking our own subtrees. */
1479 /* Actually walk over them. This loop is the body of
1480 walk_trees, omitting the case where the TARGET_EXPR
1481 itself is handled. */
1482 for (i = 0; i < len; ++i)
1485 ++id->in_target_cleanup_p;
1486 walk_tree (&TREE_OPERAND (*tp, i), expand_call_inline, data,
1489 --id->in_target_cleanup_p;
1497 /* Because types were not copied in copy_body, CALL_EXPRs beneath
1498 them should not be expanded. This can happen if the type is a
1499 dynamic array type, for example. */
1502 /* From here on, we're only interested in CALL_EXPRs. */
1503 if (TREE_CODE (t) != CALL_EXPR)
1506 /* First, see if we can figure out what function is being called.
1507 If we cannot, then there is no hope of inlining the function. */
1508 fn = get_callee_fndecl (t);
1512 /* Turn forward declarations into real ones. */
1513 fn = cgraph_node (fn)->decl;
1515 /* If fn is a declaration of a function in a nested scope that was
1516 globally declared inline, we don't set its DECL_INITIAL.
1517 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1518 C++ front-end uses it for cdtors to refer to their internal
1519 declarations, that are not real functions. Fortunately those
1520 don't have trees to be saved, so we can tell by checking their
1522 if (! DECL_INITIAL (fn)
1523 && DECL_ABSTRACT_ORIGIN (fn)
1524 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
1525 fn = DECL_ABSTRACT_ORIGIN (fn);
1527 /* Objective C and fortran still calls tree_rest_of_compilation directly.
1528 Kill this check once this is fixed. */
1529 if (!id->current_node->analyzed)
1532 edge = cgraph_edge (id->current_node, t);
1534 /* Constant propagation on argument done during previous inlining
1535 may create new direct call. Produce an edge for it. */
1538 struct cgraph_node *dest = cgraph_node (fn);
1540 /* We have missing edge in the callgraph. This can happen in one case
1541 where previous inlining turned indirect call into direct call by
1542 constant propagating arguments. In all other cases we hit a bug
1543 (incorrect node sharing is most common reason for missing edges. */
1544 gcc_assert (dest->needed || !flag_unit_at_a_time);
1545 cgraph_create_edge (id->node, dest, t)->inline_failed
1546 = N_("originally indirect function call not considered for inlining");
1550 /* Don't try to inline functions that are not well-suited to
1552 if (!cgraph_inline_p (edge, &reason))
1554 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1556 sorry ("%Jinlining failed in call to %qF: %s", fn, fn, reason);
1557 sorry ("called from here");
1559 else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
1560 && !DECL_IN_SYSTEM_HEADER (fn)
1562 && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn)))
1564 warning ("%Jinlining failed in call to %qF: %s", fn, fn, reason);
1565 warning ("called from here");
1570 #ifdef ENABLE_CHECKING
1571 if (edge->callee->decl != id->node->decl)
1572 verify_cgraph_node (edge->callee);
1575 if (! lang_hooks.tree_inlining.start_inlining (fn))
1578 /* Build a block containing code to initialize the arguments, the
1579 actual inline expansion of the body, and a label for the return
1580 statements within the function to jump to. The type of the
1581 statement expression is the return type of the function call. */
1583 expr = build (BIND_EXPR, void_type_node, NULL_TREE,
1584 stmt, make_node (BLOCK));
1585 BLOCK_ABSTRACT_ORIGIN (BIND_EXPR_BLOCK (expr)) = fn;
1587 /* Local declarations will be replaced by their equivalents in this
1590 id->decl_map = splay_tree_new (splay_tree_compare_pointers,
1593 /* Initialize the parameters. */
1594 args = TREE_OPERAND (t, 1);
1595 return_slot_addr = NULL_TREE;
1596 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t))
1598 return_slot_addr = TREE_VALUE (args);
1599 args = TREE_CHAIN (args);
1600 TREE_TYPE (expr) = void_type_node;
1603 arg_inits = initialize_inlined_parameters (id, args, TREE_OPERAND (t, 2),
1607 /* Expand any inlined calls in the initializers. Do this before we
1608 push FN on the stack of functions we are inlining; we want to
1609 inline calls to FN that appear in the initializers for the
1612 Note we need to save and restore the saved tree statement iterator
1613 to avoid having it clobbered by expand_calls_inline. */
1614 tree_stmt_iterator save_tsi;
1617 expand_calls_inline (&arg_inits, id);
1620 /* And add them to the tree. */
1621 append_to_statement_list (arg_inits, &BIND_EXPR_BODY (expr));
1624 /* Record the function we are about to inline so that we can avoid
1625 recursing into it. */
1626 VARRAY_PUSH_TREE (id->fns, fn);
1628 /* Return statements in the function body will be replaced by jumps
1629 to the RET_LABEL. */
1630 id->ret_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1631 DECL_ARTIFICIAL (id->ret_label) = 1;
1632 DECL_IGNORED_P (id->ret_label) = 1;
1633 DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
1634 insert_decl_map (id, id->ret_label, id->ret_label);
1636 gcc_assert (DECL_INITIAL (fn));
1637 gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
1639 /* Find the lhs to which the result of this call is assigned. */
1640 modify_dest = tsi_stmt (id->tsi);
1641 if (TREE_CODE (modify_dest) == MODIFY_EXPR)
1643 modify_dest = TREE_OPERAND (modify_dest, 0);
1645 /* The function which we are inlining might not return a value,
1646 in which case we should issue a warning that the function
1647 does not return a value. In that case the optimizers will
1648 see that the variable to which the value is assigned was not
1649 initialized. We do not want to issue a warning about that
1650 uninitialized variable. */
1651 if (DECL_P (modify_dest))
1652 TREE_NO_WARNING (modify_dest) = 1;
1657 /* Declare the return variable for the function. */
1658 declare_return_variable (id, return_slot_addr,
1659 modify_dest, &use_retvar);
1661 /* After we've initialized the parameters, we insert the body of the
1664 struct cgraph_node *old_node = id->current_node;
1667 id->current_node = edge->callee;
1668 copy = copy_body (id);
1670 /* If the function uses a return slot, then it may legitimately
1671 fall through while still returning a value, so we have to skip
1672 the warning here. */
1673 if (warn_return_type
1674 && !TREE_NO_WARNING (fn)
1675 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fn)))
1676 && return_slot_addr == NULL_TREE
1677 && block_may_fallthru (copy))
1679 warning ("control may reach end of non-void function %qD being inlined",
1681 TREE_NO_WARNING (fn) = 1;
1684 append_to_statement_list (copy, &BIND_EXPR_BODY (expr));
1685 id->current_node = old_node;
1687 inlined_body = &BIND_EXPR_BODY (expr);
1689 /* After the body of the function comes the RET_LABEL. This must come
1690 before we evaluate the returned value below, because that evaluation
1691 may cause RTL to be generated. */
1692 if (TREE_USED (id->ret_label))
1694 tree label = build1 (LABEL_EXPR, void_type_node, id->ret_label);
1695 append_to_statement_list (label, &BIND_EXPR_BODY (expr));
1699 splay_tree_delete (id->decl_map);
1702 /* Although, from the semantic viewpoint, the new expression has
1703 side-effects only if the old one did, it is not possible, from
1704 the technical viewpoint, to evaluate the body of a function
1705 multiple times without serious havoc. */
1706 TREE_SIDE_EFFECTS (expr) = 1;
1708 tsi_link_before (&id->tsi, expr, TSI_SAME_STMT);
1710 /* If the inlined function returns a result that we care about,
1711 then we're going to need to splice in a MODIFY_EXPR. Otherwise
1712 the call was a standalone statement and we can just replace it
1713 with the BIND_EXPR inline representation of the called function. */
1714 if (!use_retvar || !modify_dest)
1715 *tsi_stmt_ptr (id->tsi) = build_empty_stmt ();
1719 /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS on
1720 the call if it is to a "const" function. Thus the copy of
1721 TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above with
1722 result in TREE_SIDE_EFFECTS not being set for the inlined copy of a
1725 Unfortunately, that is wrong as inlining the function can create/expose
1726 interesting side effects (such as setting of a return value).
1728 The easiest solution is to simply recalculate TREE_SIDE_EFFECTS for
1729 the toplevel expression. */
1730 recalculate_side_effects (expr);
1732 /* Output the inlining info for this abstract function, since it has been
1733 inlined. If we don't do this now, we can lose the information about the
1734 variables in the function when the blocks get blown away as soon as we
1735 remove the cgraph node. */
1736 (*debug_hooks->outlining_inline_function) (edge->callee->decl);
1738 /* Update callgraph if needed. */
1739 cgraph_remove_node (edge->callee);
1741 /* Recurse into the body of the just inlined function. */
1742 expand_calls_inline (inlined_body, id);
1743 VARRAY_POP (id->fns);
1745 /* Don't walk into subtrees. We've already handled them above. */
1748 lang_hooks.tree_inlining.end_inlining (fn);
1750 /* Keep iterating. */
1752 input_location = saved_location;
1757 expand_calls_inline (tree *stmt_p, inline_data *id)
1759 tree stmt = *stmt_p;
1760 enum tree_code code = TREE_CODE (stmt);
1765 case STATEMENT_LIST:
1767 tree_stmt_iterator i;
1770 for (i = tsi_start (stmt); !tsi_end_p (i); )
1773 expand_calls_inline (tsi_stmt_ptr (i), id);
1776 if (TREE_CODE (new) == STATEMENT_LIST)
1778 tsi_link_before (&i, new, TSI_SAME_STMT);
1788 expand_calls_inline (&COND_EXPR_THEN (stmt), id);
1789 expand_calls_inline (&COND_EXPR_ELSE (stmt), id);
1793 expand_calls_inline (&CATCH_BODY (stmt), id);
1796 case EH_FILTER_EXPR:
1797 expand_calls_inline (&EH_FILTER_FAILURE (stmt), id);
1800 case TRY_CATCH_EXPR:
1801 case TRY_FINALLY_EXPR:
1802 expand_calls_inline (&TREE_OPERAND (stmt, 0), id);
1803 expand_calls_inline (&TREE_OPERAND (stmt, 1), id);
1807 expand_calls_inline (&BIND_EXPR_BODY (stmt), id);
1811 /* We're gimple. We should have gotten rid of all these. */
1815 stmt_p = &TREE_OPERAND (stmt, 0);
1817 if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
1823 stmt_p = &TREE_OPERAND (stmt, 1);
1825 if (TREE_CODE (stmt) == WITH_SIZE_EXPR)
1827 stmt_p = &TREE_OPERAND (stmt, 0);
1830 if (TREE_CODE (stmt) != CALL_EXPR)
1836 expand_call_inline (stmt_p, &dummy, id);
1844 /* Expand calls to inline functions in the body of FN. */
1847 optimize_inline_calls (tree fn)
1852 /* There is no point in performing inlining if errors have already
1853 occurred -- and we might crash if we try to inline invalid
1855 if (errorcount || sorrycount)
1859 memset (&id, 0, sizeof (id));
1861 id.current_node = id.node = cgraph_node (fn);
1862 /* Don't allow recursion into FN. */
1863 VARRAY_TREE_INIT (id.fns, 32, "fns");
1864 VARRAY_PUSH_TREE (id.fns, fn);
1865 /* Or any functions that aren't finished yet. */
1866 prev_fn = NULL_TREE;
1867 if (current_function_decl)
1869 VARRAY_PUSH_TREE (id.fns, current_function_decl);
1870 prev_fn = current_function_decl;
1873 prev_fn = lang_hooks.tree_inlining.add_pending_fn_decls (&id.fns, prev_fn);
1875 /* Keep track of the low-water mark, i.e., the point where the first
1876 real inlining is represented in ID.FNS. */
1877 id.first_inlined_fn = VARRAY_ACTIVE_SIZE (id.fns);
1879 /* Replace all calls to inline functions with the bodies of those
1881 id.tree_pruner = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1882 expand_calls_inline (&DECL_SAVED_TREE (fn), &id);
1885 htab_delete (id.tree_pruner);
1887 #ifdef ENABLE_CHECKING
1889 struct cgraph_edge *e;
1891 verify_cgraph_node (id.node);
1893 /* Double check that we inlined everything we are supposed to inline. */
1894 for (e = id.node->callees; e; e = e->next_callee)
1895 gcc_assert (e->inline_failed);
1900 /* FN is a function that has a complete body, and CLONE is a function whose
1901 body is to be set to a copy of FN, mapping argument declarations according
1902 to the ARG_MAP splay_tree. */
1905 clone_body (tree clone, tree fn, void *arg_map)
1909 /* Clone the body, as if we were making an inline call. But, remap the
1910 parameters in the callee to the parameters of caller. If there's an
1911 in-charge parameter, map it to an appropriate constant. */
1912 memset (&id, 0, sizeof (id));
1913 VARRAY_TREE_INIT (id.fns, 2, "fns");
1914 VARRAY_PUSH_TREE (id.fns, clone);
1915 VARRAY_PUSH_TREE (id.fns, fn);
1916 id.decl_map = (splay_tree)arg_map;
1918 /* Cloning is treated slightly differently from inlining. Set
1919 CLONING_P so that it's clear which operation we're performing. */
1920 id.cloning_p = true;
1922 /* Actually copy the body. */
1923 append_to_statement_list_force (copy_body (&id), &DECL_SAVED_TREE (clone));
1926 /* Make and return duplicate of body in FN. Put copies of DECL_ARGUMENTS
1927 in *arg_copy and of the static chain, if any, in *sc_copy. */
1930 save_body (tree fn, tree *arg_copy, tree *sc_copy)
1935 memset (&id, 0, sizeof (id));
1936 VARRAY_TREE_INIT (id.fns, 1, "fns");
1937 VARRAY_PUSH_TREE (id.fns, fn);
1938 id.node = cgraph_node (fn);
1940 id.decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
1941 *arg_copy = DECL_ARGUMENTS (fn);
1943 for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
1945 tree new = copy_node (*parg);
1947 lang_hooks.dup_lang_specific_decl (new);
1948 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*parg);
1949 insert_decl_map (&id, *parg, new);
1950 TREE_CHAIN (new) = TREE_CHAIN (*parg);
1954 *sc_copy = DECL_STRUCT_FUNCTION (fn)->static_chain_decl;
1957 tree new = copy_node (*sc_copy);
1959 lang_hooks.dup_lang_specific_decl (new);
1960 DECL_ABSTRACT_ORIGIN (new) = DECL_ORIGIN (*sc_copy);
1961 insert_decl_map (&id, *sc_copy, new);
1962 TREE_CHAIN (new) = TREE_CHAIN (*sc_copy);
1966 insert_decl_map (&id, DECL_RESULT (fn), DECL_RESULT (fn));
1968 /* Actually copy the body. */
1969 body = copy_body (&id);
1972 splay_tree_delete (id.decl_map);
1976 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
1979 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1981 enum tree_code code = TREE_CODE (*tp);
1983 /* We make copies of most nodes. */
1984 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
1985 || code == TREE_LIST
1987 || code == TYPE_DECL)
1989 /* Because the chain gets clobbered when we make a copy, we save it
1991 tree chain = TREE_CHAIN (*tp);
1994 /* Copy the node. */
1995 new = copy_node (*tp);
1997 /* Propagate mudflap marked-ness. */
1998 if (flag_mudflap && mf_marked_p (*tp))
2003 /* Now, restore the chain, if appropriate. That will cause
2004 walk_tree to walk into the chain as well. */
2005 if (code == PARM_DECL || code == TREE_LIST)
2006 TREE_CHAIN (*tp) = chain;
2008 /* For now, we don't update BLOCKs when we make copies. So, we
2009 have to nullify all BIND_EXPRs. */
2010 if (TREE_CODE (*tp) == BIND_EXPR)
2011 BIND_EXPR_BLOCK (*tp) = NULL_TREE;
2014 else if (TREE_CODE_CLASS (code) == tcc_type)
2016 else if (TREE_CODE_CLASS (code) == tcc_declaration)
2018 else if (TREE_CODE_CLASS (code) == tcc_constant)
2021 gcc_assert (code != STATEMENT_LIST);
2025 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2026 information indicating to what new SAVE_EXPR this one should be mapped,
2027 use that one. Otherwise, create a new node and enter it in ST. */
2030 remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
2032 splay_tree st = (splay_tree) st_;
2036 /* See if we already encountered this SAVE_EXPR. */
2037 n = splay_tree_lookup (st, (splay_tree_key) *tp);
2039 /* If we didn't already remap this SAVE_EXPR, do so now. */
2042 t = copy_node (*tp);
2044 /* Remember this SAVE_EXPR. */
2045 splay_tree_insert (st, (splay_tree_key) *tp, (splay_tree_value) t);
2046 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2047 splay_tree_insert (st, (splay_tree_key) t, (splay_tree_value) t);
2051 /* We've already walked into this SAVE_EXPR; don't do it again. */
2053 t = (tree) n->value;
2056 /* Replace this SAVE_EXPR with the copy. */
2060 /* Called via walk_tree. If *TP points to a DECL_STMT for a local label,
2061 copies the declaration and enters it in the splay_tree in DATA (which is
2062 really an `inline_data *'). */
2065 mark_local_for_remap_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2068 inline_data *id = (inline_data *) data;
2070 /* Don't walk into types. */
2074 else if (TREE_CODE (*tp) == LABEL_EXPR)
2076 tree decl = TREE_OPERAND (*tp, 0);
2078 /* Copy the decl and remember the copy. */
2079 insert_decl_map (id, decl,
2080 copy_decl_for_inlining (decl, DECL_CONTEXT (decl),
2081 DECL_CONTEXT (decl)));
2087 /* Perform any modifications to EXPR required when it is unsaved. Does
2088 not recurse into EXPR's subtrees. */
2091 unsave_expr_1 (tree expr)
2093 switch (TREE_CODE (expr))
2096 /* Don't mess with a TARGET_EXPR that hasn't been expanded.
2097 It's OK for this to happen if it was part of a subtree that
2098 isn't immediately expanded, such as operand 2 of another
2100 if (TREE_OPERAND (expr, 1))
2103 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
2104 TREE_OPERAND (expr, 3) = NULL_TREE;
2112 /* Called via walk_tree when an expression is unsaved. Using the
2113 splay_tree pointed to by ST (which is really a `splay_tree'),
2114 remaps all local declarations to appropriate replacements. */
2117 unsave_r (tree *tp, int *walk_subtrees, void *data)
2119 inline_data *id = (inline_data *) data;
2120 splay_tree st = id->decl_map;
2123 /* Only a local declaration (variable or label). */
2124 if ((TREE_CODE (*tp) == VAR_DECL && !TREE_STATIC (*tp))
2125 || TREE_CODE (*tp) == LABEL_DECL)
2127 /* Lookup the declaration. */
2128 n = splay_tree_lookup (st, (splay_tree_key) *tp);
2130 /* If it's there, remap it. */
2132 *tp = (tree) n->value;
2135 else if (TREE_CODE (*tp) == STATEMENT_LIST)
2136 copy_statement_list (tp);
2137 else if (TREE_CODE (*tp) == BIND_EXPR)
2138 copy_bind_expr (tp, walk_subtrees, id);
2139 else if (TREE_CODE (*tp) == SAVE_EXPR)
2140 remap_save_expr (tp, st, walk_subtrees);
2143 copy_tree_r (tp, walk_subtrees, NULL);
2145 /* Do whatever unsaving is required. */
2146 unsave_expr_1 (*tp);
2149 /* Keep iterating. */
2153 /* Copies everything in EXPR and replaces variables, labels
2154 and SAVE_EXPRs local to EXPR. */
2157 unsave_expr_now (tree expr)
2161 /* There's nothing to do for NULL_TREE. */
2166 memset (&id, 0, sizeof (id));
2167 VARRAY_TREE_INIT (id.fns, 1, "fns");
2168 VARRAY_PUSH_TREE (id.fns, current_function_decl);
2169 id.decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
2171 /* Walk the tree once to find local labels. */
2172 walk_tree_without_duplicates (&expr, mark_local_for_remap_r, &id);
2174 /* Walk the tree again, copying, remapping, and unsaving. */
2175 walk_tree (&expr, unsave_r, &id, NULL);
2178 splay_tree_delete (id.decl_map);
2183 /* Allow someone to determine if SEARCH is a child of TOP from gdb. */
2186 debug_find_tree_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
2195 debug_find_tree (tree top, tree search)
2197 return walk_tree_without_duplicates (&top, debug_find_tree_1, search) != 0;
2200 /* Declare the variables created by the inliner. Add all the variables in
2201 VARS to BIND_EXPR. */
2204 declare_inline_vars (tree bind_expr, tree vars)
2207 for (t = vars; t; t = TREE_CHAIN (t))
2208 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
2210 add_var_to_bind_expr (bind_expr, vars);