1 /* Control and data flow functions for trees.
2 Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Alexandre Oliva <aoliva@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
28 #include "tree-inline.h"
34 #include "insn-config.h"
35 #include "integrate.h"
38 #include "splay-tree.h"
39 #include "langhooks.h"
42 #include "diagnostic.h"
44 /* This should be eventually be generalized to other languages, but
45 this would require a shared function-as-trees infrastructure. */
46 #ifndef INLINER_FOR_JAVA
48 #else /* INLINER_FOR_JAVA */
50 #include "java-tree.h"
51 #endif /* INLINER_FOR_JAVA */
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 map from local declarations in the inlined function to
91 equivalents in the function into which it is being inlined. */
93 /* Nonzero if we are currently within the cleanup for a
95 int in_target_cleanup_p;
96 /* A list of the functions current function has inlined. */
97 varray_type inlined_fns;
98 /* We use the same mechanism to build clones that we do to perform
99 inlining. However, there are a few places where we need to
100 distinguish between those two situations. This flag is true if
101 we are cloning, rather than inlining. */
103 /* Hash table used to prevent walk_tree from visiting the same node
104 umpteen million times. */
106 /* Decl of function we are inlining into. */
113 static tree declare_return_variable (inline_data *, tree, tree *);
114 static tree copy_body_r (tree *, int *, void *);
115 static tree copy_body (inline_data *);
116 static tree expand_call_inline (tree *, int *, void *);
117 static void expand_calls_inline (tree *, inline_data *);
118 static bool inlinable_function_p (tree);
119 static tree remap_decl (tree, inline_data *);
120 static tree remap_type (tree, inline_data *);
121 #ifndef INLINER_FOR_JAVA
122 static tree initialize_inlined_parameters (inline_data *, tree, tree);
123 static void remap_block (tree, tree, inline_data *);
124 static void copy_scope_stmt (tree *, int *, inline_data *);
125 #else /* INLINER_FOR_JAVA */
126 static tree initialize_inlined_parameters (inline_data *, tree, tree, tree);
127 static void remap_block (tree *, tree, inline_data *);
128 static tree add_stmt_to_compound (tree, tree, tree);
129 #endif /* INLINER_FOR_JAVA */
131 /* Remap DECL during the copying of the BLOCK tree for the function. */
134 remap_decl (tree decl, inline_data *id)
139 /* We only remap local variables in the current function. */
140 fn = VARRAY_TOP_TREE (id->fns);
141 if (! (*lang_hooks.tree_inlining.auto_var_in_fn_p) (decl, fn))
144 /* See if we have remapped this declaration. */
145 n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
147 /* If we didn't already have an equivalent for this declaration,
153 /* Make a copy of the variable or label. */
154 t = copy_decl_for_inlining (decl, fn, VARRAY_TREE (id->fns, 0));
156 /* Remap types, if necessary. */
157 TREE_TYPE (t) = remap_type (TREE_TYPE (t), id);
158 if (TREE_CODE (t) == TYPE_DECL)
159 DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id);
160 else if (TREE_CODE (t) == PARM_DECL)
161 DECL_ARG_TYPE_AS_WRITTEN (t)
162 = remap_type (DECL_ARG_TYPE_AS_WRITTEN (t), id);
164 /* Remap sizes as necessary. */
165 walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL);
166 walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL);
168 #ifndef INLINER_FOR_JAVA
169 if (! DECL_NAME (t) && TREE_TYPE (t)
170 && (*lang_hooks.tree_inlining.anon_aggr_type_p) (TREE_TYPE (t)))
172 /* For a VAR_DECL of anonymous type, we must also copy the
173 member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS. */
177 for (src = DECL_ANON_UNION_ELEMS (t); src;
178 src = TREE_CHAIN (src))
180 tree member = remap_decl (TREE_VALUE (src), id);
182 if (TREE_PURPOSE (src))
184 members = tree_cons (NULL, member, members);
186 DECL_ANON_UNION_ELEMS (t) = nreverse (members);
188 #endif /* not INLINER_FOR_JAVA */
190 /* Remember it, so that if we encounter this local entity
191 again we can reuse this copy. */
192 n = splay_tree_insert (id->decl_map,
193 (splay_tree_key) decl,
194 (splay_tree_value) t);
197 return (tree) n->value;
201 remap_type (tree type, inline_data *id)
203 splay_tree_node node;
209 /* See if we have remapped this type. */
210 node = splay_tree_lookup (id->decl_map, (splay_tree_key) type);
212 return (tree) node->value;
214 /* The type only needs remapping if it's variably modified. */
215 if (! variably_modified_type_p (type))
217 splay_tree_insert (id->decl_map, (splay_tree_key) type,
218 (splay_tree_value) type);
222 /* We do need a copy. build and register it now. */
223 new = copy_node (type);
224 splay_tree_insert (id->decl_map, (splay_tree_key) type,
225 (splay_tree_value) new);
227 /* This is a new type, not a copy of an old type. Need to reassociate
228 variants. We can handle everything except the main variant lazily. */
229 t = TYPE_MAIN_VARIANT (type);
232 t = remap_type (t, id);
233 TYPE_MAIN_VARIANT (new) = t;
234 TYPE_NEXT_VARIANT (new) = TYPE_MAIN_VARIANT (t);
235 TYPE_NEXT_VARIANT (t) = new;
239 TYPE_MAIN_VARIANT (new) = new;
240 TYPE_NEXT_VARIANT (new) = NULL;
243 /* Lazily create pointer and reference types. */
244 TYPE_POINTER_TO (new) = NULL;
245 TYPE_REFERENCE_TO (new) = NULL;
247 switch (TREE_CODE (new))
254 t = TYPE_MIN_VALUE (new);
255 if (t && TREE_CODE (t) != INTEGER_CST)
256 walk_tree (&TYPE_MIN_VALUE (new), copy_body_r, id, NULL);
257 t = TYPE_MAX_VALUE (new);
258 if (t && TREE_CODE (t) != INTEGER_CST)
259 walk_tree (&TYPE_MAX_VALUE (new), copy_body_r, id, NULL);
263 TREE_TYPE (new) = t = remap_type (TREE_TYPE (new), id);
264 if (TYPE_MODE (new) == ptr_mode)
265 TYPE_POINTER_TO (t) = new;
269 TREE_TYPE (new) = t = remap_type (TREE_TYPE (new), id);
270 if (TYPE_MODE (new) == ptr_mode)
271 TYPE_REFERENCE_TO (t) = new;
276 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
277 walk_tree (&TYPE_ARG_TYPES (new), copy_body_r, id, NULL);
281 TREE_TYPE (new) = remap_type (TREE_TYPE (new), id);
282 TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id);
287 case QUAL_UNION_TYPE:
288 walk_tree (&TYPE_FIELDS (new), copy_body_r, id, NULL);
295 /* Shouldn't have been thought variable sized. */
299 walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
300 walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r, id, NULL);
305 #ifndef INLINER_FOR_JAVA
306 /* Copy the SCOPE_STMT_BLOCK associated with SCOPE_STMT to contain
307 remapped versions of the variables therein. And hook the new block
308 into the block-tree. If non-NULL, the DECLS are declarations to
309 add to use instead of the BLOCK_VARS in the old block. */
310 #else /* INLINER_FOR_JAVA */
311 /* Copy the BLOCK to contain remapped versions of the variables
312 therein. And hook the new block into the block-tree. */
313 #endif /* INLINER_FOR_JAVA */
316 #ifndef INLINER_FOR_JAVA
317 remap_block (tree scope_stmt, tree decls, inline_data *id)
318 #else /* INLINER_FOR_JAVA */
319 remap_block (tree *block, tree decls, inline_data *id)
320 #endif /* INLINER_FOR_JAVA */
322 #ifndef INLINER_FOR_JAVA
323 /* We cannot do this in the cleanup for a TARGET_EXPR since we do
324 not know whether or not expand_expr will actually write out the
325 code we put there. If it does not, then we'll have more BLOCKs
326 than block-notes, and things will go awry. At some point, we
327 should make the back-end handle BLOCK notes in a tidier way,
328 without requiring a strict correspondence to the block-tree; then
329 this check can go. */
330 if (id->in_target_cleanup_p)
332 SCOPE_STMT_BLOCK (scope_stmt) = NULL_TREE;
336 /* If this is the beginning of a scope, remap the associated BLOCK. */
337 if (SCOPE_BEGIN_P (scope_stmt) && SCOPE_STMT_BLOCK (scope_stmt))
344 /* Make the new block. */
345 old_block = SCOPE_STMT_BLOCK (scope_stmt);
346 new_block = make_node (BLOCK);
347 TREE_USED (new_block) = TREE_USED (old_block);
348 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
349 SCOPE_STMT_BLOCK (scope_stmt) = new_block;
351 /* Remap its variables. */
352 for (old_var = decls ? decls : BLOCK_VARS (old_block);
354 old_var = TREE_CHAIN (old_var))
358 /* Remap the variable. */
359 new_var = remap_decl (old_var, id);
360 /* If we didn't remap this variable, so we can't mess with
361 its TREE_CHAIN. If we remapped this variable to
362 something other than a declaration (say, if we mapped it
363 to a constant), then we must similarly omit any mention
365 if (!new_var || !DECL_P (new_var))
369 TREE_CHAIN (new_var) = BLOCK_VARS (new_block);
370 BLOCK_VARS (new_block) = new_var;
373 /* We put the BLOCK_VARS in reverse order; fix that now. */
374 BLOCK_VARS (new_block) = nreverse (BLOCK_VARS (new_block));
375 fn = VARRAY_TREE (id->fns, 0);
377 /* We're building a clone; DECL_INITIAL is still
378 error_mark_node, and current_binding_level is the parm
380 (*lang_hooks.decls.insert_block) (new_block);
383 /* Attach this new block after the DECL_INITIAL block for the
384 function into which this block is being inlined. In
385 rest_of_compilation we will straighten out the BLOCK tree. */
387 if (DECL_INITIAL (fn))
388 first_block = &BLOCK_CHAIN (DECL_INITIAL (fn));
390 first_block = &DECL_INITIAL (fn);
391 BLOCK_CHAIN (new_block) = *first_block;
392 *first_block = new_block;
394 /* Remember the remapped block. */
395 splay_tree_insert (id->decl_map,
396 (splay_tree_key) old_block,
397 (splay_tree_value) new_block);
399 /* If this is the end of a scope, set the SCOPE_STMT_BLOCK to be the
401 else if (SCOPE_END_P (scope_stmt) && SCOPE_STMT_BLOCK (scope_stmt))
405 /* Find this block in the table of remapped things. */
406 n = splay_tree_lookup (id->decl_map,
407 (splay_tree_key) SCOPE_STMT_BLOCK (scope_stmt));
410 SCOPE_STMT_BLOCK (scope_stmt) = (tree) n->value;
412 #else /* INLINER_FOR_JAVA */
418 /* Make the new block. */
420 new_block = make_node (BLOCK);
421 TREE_USED (new_block) = TREE_USED (old_block);
422 BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
423 BLOCK_SUBBLOCKS (new_block) = BLOCK_SUBBLOCKS (old_block);
424 TREE_SIDE_EFFECTS (new_block) = TREE_SIDE_EFFECTS (old_block);
425 TREE_TYPE (new_block) = TREE_TYPE (old_block);
428 /* Remap its variables. */
429 for (old_var = decls ? decls : BLOCK_VARS (old_block);
431 old_var = TREE_CHAIN (old_var))
435 /* All local class initialization flags go in the outermost
437 if (LOCAL_CLASS_INITIALIZATION_FLAG_P (old_var))
439 /* We may already have one. */
440 if (! splay_tree_lookup (id->decl_map, (splay_tree_key) old_var))
442 tree outermost_block;
443 new_var = remap_decl (old_var, id);
444 DECL_ABSTRACT_ORIGIN (new_var) = NULL;
445 outermost_block = DECL_SAVED_TREE (current_function_decl);
446 TREE_CHAIN (new_var) = BLOCK_VARS (outermost_block);
447 BLOCK_VARS (outermost_block) = new_var;
452 /* Remap the variable. */
453 new_var = remap_decl (old_var, id);
454 /* If we didn't remap this variable, so we can't mess with
455 its TREE_CHAIN. If we remapped this variable to
456 something other than a declaration (say, if we mapped it
457 to a constant), then we must similarly omit any mention
459 if (!new_var || !DECL_P (new_var))
463 TREE_CHAIN (new_var) = BLOCK_VARS (new_block);
464 BLOCK_VARS (new_block) = new_var;
467 /* We put the BLOCK_VARS in reverse order; fix that now. */
468 BLOCK_VARS (new_block) = nreverse (BLOCK_VARS (new_block));
469 fn = VARRAY_TREE (id->fns, 0);
470 /* Remember the remapped block. */
471 splay_tree_insert (id->decl_map,
472 (splay_tree_key) old_block,
473 (splay_tree_value) new_block);
474 #endif /* INLINER_FOR_JAVA */
477 #ifndef INLINER_FOR_JAVA
478 /* Copy the SCOPE_STMT pointed to by TP. */
481 copy_scope_stmt (tree *tp, int *walk_subtrees, inline_data *id)
485 /* Remember whether or not this statement was nullified. When
486 making a copy, copy_tree_r always sets SCOPE_NULLIFIED_P (and
487 doesn't copy the SCOPE_STMT_BLOCK) to free callers from having to
488 deal with copying BLOCKs if they do not wish to do so. */
489 block = SCOPE_STMT_BLOCK (*tp);
490 /* Copy (and replace) the statement. */
491 copy_tree_r (tp, walk_subtrees, NULL);
492 /* Restore the SCOPE_STMT_BLOCK. */
493 SCOPE_STMT_BLOCK (*tp) = block;
495 /* Remap the associated block. */
496 remap_block (*tp, NULL_TREE, id);
498 #endif /* not INLINER_FOR_JAVA */
500 /* Called from copy_body via walk_tree. DATA is really an
503 copy_body_r (tree *tp, int *walk_subtrees, void *data)
509 id = (inline_data *) data;
510 fn = VARRAY_TOP_TREE (id->fns);
513 /* All automatic variables should have a DECL_CONTEXT indicating
514 what function they come from. */
515 if ((TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == LABEL_DECL)
516 && DECL_NAMESPACE_SCOPE_P (*tp))
517 if (! DECL_EXTERNAL (*tp) && ! TREE_STATIC (*tp))
521 #ifdef INLINER_FOR_JAVA
522 if (TREE_CODE (*tp) == BLOCK)
523 remap_block (tp, NULL_TREE, id);
526 /* If this is a RETURN_STMT, change it into an EXPR_STMT and a
527 GOTO_STMT with the RET_LABEL as its target. */
528 #ifndef INLINER_FOR_JAVA
529 if (TREE_CODE (*tp) == RETURN_STMT && id->ret_label)
530 #else /* INLINER_FOR_JAVA */
531 if (TREE_CODE (*tp) == RETURN_EXPR && id->ret_label)
532 #endif /* INLINER_FOR_JAVA */
534 tree return_stmt = *tp;
537 /* Build the GOTO_STMT. */
538 #ifndef INLINER_FOR_JAVA
539 goto_stmt = build_stmt (GOTO_STMT, id->ret_label);
540 TREE_CHAIN (goto_stmt) = TREE_CHAIN (return_stmt);
541 GOTO_FAKE_P (goto_stmt) = 1;
542 #else /* INLINER_FOR_JAVA */
543 tree assignment = TREE_OPERAND (return_stmt, 0);
544 goto_stmt = build1 (GOTO_EXPR, void_type_node, id->ret_label);
545 TREE_SIDE_EFFECTS (goto_stmt) = 1;
546 #endif /* INLINER_FOR_JAVA */
548 /* If we're returning something, just turn that into an
549 assignment into the equivalent of the original
551 #ifndef INLINER_FOR_JAVA
552 if (RETURN_STMT_EXPR (return_stmt))
554 *tp = build_stmt (EXPR_STMT,
555 RETURN_STMT_EXPR (return_stmt));
556 STMT_IS_FULL_EXPR_P (*tp) = 1;
557 /* And then jump to the end of the function. */
558 TREE_CHAIN (*tp) = goto_stmt;
560 #else /* INLINER_FOR_JAVA */
563 copy_body_r (&assignment, walk_subtrees, data);
564 *tp = build (COMPOUND_EXPR, void_type_node, assignment, goto_stmt);
565 TREE_SIDE_EFFECTS (*tp) = 1;
567 #endif /* INLINER_FOR_JAVA */
568 /* If we're not returning anything just do the jump. */
572 /* Local variables and labels need to be replaced by equivalent
573 variables. We don't want to copy static variables; there's only
574 one of those, no matter how many times we inline the containing
576 We do not also want to copy the label which we put into
577 GOTO_STMT which replaced RETURN_STMT. */
578 else if (*tp != id->ret_label
579 && (*lang_hooks.tree_inlining.auto_var_in_fn_p) (*tp, fn))
583 /* Remap the declaration. */
584 new_decl = remap_decl (*tp, id);
587 /* Replace this variable with the copy. */
588 STRIP_TYPE_NOPS (new_decl);
592 else if (nonstatic_local_decl_p (*tp)
593 && DECL_CONTEXT (*tp) != VARRAY_TREE (id->fns, 0))
596 else if (TREE_CODE (*tp) == SAVE_EXPR)
597 remap_save_expr (tp, id->decl_map, VARRAY_TREE (id->fns, 0),
599 else if (TREE_CODE (*tp) == UNSAVE_EXPR)
600 /* UNSAVE_EXPRs should not be generated until expansion time. */
602 #ifndef INLINER_FOR_JAVA
603 /* For a SCOPE_STMT, we must copy the associated block so that we
604 can write out debugging information for the inlined variables. */
605 else if (TREE_CODE (*tp) == SCOPE_STMT && !id->in_target_cleanup_p)
606 copy_scope_stmt (tp, walk_subtrees, id);
607 #else /* INLINER_FOR_JAVA */
608 else if (TREE_CODE (*tp) == LABELED_BLOCK_EXPR)
610 /* We need a new copy of this labeled block; the EXIT_BLOCK_EXPR
611 will refer to it, so save a copy ready for remapping. We
612 save it in the decl_map, although it isn't a decl. */
613 tree new_block = copy_node (*tp);
614 splay_tree_insert (id->decl_map,
615 (splay_tree_key) *tp,
616 (splay_tree_value) new_block);
619 else if (TREE_CODE (*tp) == EXIT_BLOCK_EXPR)
622 = splay_tree_lookup (id->decl_map,
623 (splay_tree_key) TREE_OPERAND (*tp, 0));
624 /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR. */
627 *tp = copy_node (*tp);
628 TREE_OPERAND (*tp, 0) = (tree) n->value;
630 #endif /* INLINER_FOR_JAVA */
631 /* Types may need remapping as well. */
632 else if (TYPE_P (*tp))
633 *tp = remap_type (*tp, id);
635 /* Otherwise, just copy the node. Note that copy_tree_r already
636 knows not to copy VAR_DECLs, etc., so this is safe. */
639 if (TREE_CODE (*tp) == MODIFY_EXPR
640 && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1)
641 && ((*lang_hooks.tree_inlining.auto_var_in_fn_p)
642 (TREE_OPERAND (*tp, 0), fn)))
644 /* Some assignments VAR = VAR; don't generate any rtl code
645 and thus don't count as variable modification. Avoid
646 keeping bogosities like 0 = 0. */
647 tree decl = TREE_OPERAND (*tp, 0), value;
650 n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
653 value = (tree) n->value;
654 STRIP_TYPE_NOPS (value);
655 if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
658 return copy_body_r (tp, walk_subtrees, data);
662 else if (TREE_CODE (*tp) == ADDR_EXPR
663 && ((*lang_hooks.tree_inlining.auto_var_in_fn_p)
664 (TREE_OPERAND (*tp, 0), fn)))
666 /* Get rid of &* from inline substitutions. It can occur when
667 someone takes the address of a parm or return slot passed by
668 invisible reference. */
669 tree decl = TREE_OPERAND (*tp, 0), value;
672 n = splay_tree_lookup (id->decl_map, (splay_tree_key) decl);
675 value = (tree) n->value;
676 if (TREE_CODE (value) == INDIRECT_REF)
678 *tp = convert (TREE_TYPE (*tp), TREE_OPERAND (value, 0));
679 return copy_body_r (tp, walk_subtrees, data);
684 copy_tree_r (tp, walk_subtrees, NULL);
686 TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id);
688 /* The copied TARGET_EXPR has never been expanded, even if the
689 original node was expanded already. */
690 if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
692 TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
693 TREE_OPERAND (*tp, 3) = NULL_TREE;
697 /* Keep iterating. */
701 /* Make a copy of the body of FN so that it can be inserted inline in
705 copy_body (inline_data *id)
709 body = DECL_SAVED_TREE (VARRAY_TOP_TREE (id->fns));
710 walk_tree (&body, copy_body_r, id, NULL);
715 /* Generate code to initialize the parameters of the function at the
716 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
719 #ifndef INLINER_FOR_JAVA
720 initialize_inlined_parameters (inline_data *id, tree args, tree fn)
721 #else /* INLINER_FOR_JAVA */
722 initialize_inlined_parameters (inline_data *id, tree args, tree fn, tree block)
723 #endif /* INLINER_FOR_JAVA */
729 #ifdef INLINER_FOR_JAVA
730 tree vars = NULL_TREE;
731 #endif /* INLINER_FOR_JAVA */
734 /* Figure out what the parameters are. */
738 /* Start with no initializations whatsoever. */
739 init_stmts = NULL_TREE;
741 /* Loop through the parameter declarations, replacing each with an
742 equivalent VAR_DECL, appropriately initialized. */
743 for (p = parms, a = args; p;
744 a = a ? TREE_CHAIN (a) : a, p = TREE_CHAIN (p))
746 #ifndef INLINER_FOR_JAVA
749 #endif /* not INLINER_FOR_JAVA */
756 /* Find the initializer. */
757 value = (*lang_hooks.tree_inlining.convert_parm_for_inlining)
758 (p, a ? TREE_VALUE (a) : NULL_TREE, fn, argnum);
760 /* If the parameter is never assigned to, we may not need to
761 create a new variable here at all. Instead, we may be able
762 to just use the argument value. */
763 if (TREE_READONLY (p)
764 && !TREE_ADDRESSABLE (p)
765 && value && !TREE_SIDE_EFFECTS (value))
767 /* Simplify the value, if possible. */
768 value = fold (DECL_P (value) ? decl_constant_value (value) : value);
770 /* We can't risk substituting complex expressions. They
771 might contain variables that will be assigned to later.
772 Theoretically, we could check the expression to see if
773 all of the variables that determine its value are
774 read-only, but we don't bother. */
775 if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
777 /* If this is a declaration, wrap it a NOP_EXPR so that
778 we don't try to put the VALUE on the list of
781 value = build1 (NOP_EXPR, TREE_TYPE (value), value);
783 /* If this is a constant, make sure it has the right type. */
784 else if (TREE_TYPE (value) != TREE_TYPE (p))
785 value = fold (build1 (NOP_EXPR, TREE_TYPE (p), value));
787 splay_tree_insert (id->decl_map,
789 (splay_tree_value) value);
794 /* Make an equivalent VAR_DECL. */
795 var = copy_decl_for_inlining (p, fn, VARRAY_TREE (id->fns, 0));
797 /* See if the frontend wants to pass this by invisible reference. If
798 so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
799 replace uses of the PARM_DECL with dereferences. */
800 if (TREE_TYPE (var) != TREE_TYPE (p)
801 && POINTER_TYPE_P (TREE_TYPE (var))
802 && TREE_TYPE (TREE_TYPE (var)) == TREE_TYPE (p))
803 var_sub = build1 (INDIRECT_REF, TREE_TYPE (p), var);
807 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
808 that way, when the PARM_DECL is encountered, it will be
809 automatically replaced by the VAR_DECL. */
810 splay_tree_insert (id->decl_map,
812 (splay_tree_value) var_sub);
814 /* Declare this new variable. */
815 #ifndef INLINER_FOR_JAVA
816 init_stmt = build_stmt (DECL_STMT, var);
817 TREE_CHAIN (init_stmt) = init_stmts;
818 init_stmts = init_stmt;
819 #else /* INLINER_FOR_JAVA */
820 TREE_CHAIN (var) = vars;
822 #endif /* INLINER_FOR_JAVA */
824 /* Initialize this VAR_DECL from the equivalent argument. If
825 the argument is an object, created via a constructor or copy,
826 this will not result in an extra copy: the TARGET_EXPR
827 representing the argument will be bound to VAR, and the
828 object will be constructed in VAR. */
829 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
830 #ifndef INLINER_FOR_JAVA
831 DECL_INITIAL (var) = value;
834 /* Even if P was TREE_READONLY, the new VAR should not be.
835 In the original code, we would have constructed a
836 temporary, and then the function body would have never
837 changed the value of P. However, now, we will be
838 constructing VAR directly. The constructor body may
839 change its value multiple times as it is being
840 constructed. Therefore, it must not be TREE_READONLY;
841 the back-end assumes that TREE_READONLY variable is
842 assigned to only once. */
843 TREE_READONLY (var) = 0;
845 /* Build a run-time initialization. */
846 init_stmt = build_stmt (EXPR_STMT,
847 build (INIT_EXPR, TREE_TYPE (p),
849 /* Add this initialization to the list. Note that we want the
850 declaration *after* the initialization because we are going
851 to reverse all the initialization statements below. */
852 TREE_CHAIN (init_stmt) = init_stmts;
853 init_stmts = init_stmt;
856 /* See if we need to clean up the declaration. */
857 cleanup = (*lang_hooks.maybe_build_cleanup) (var);
861 /* Build the cleanup statement. */
862 cleanup_stmt = build_stmt (CLEANUP_STMT, var, cleanup);
863 /* Add it to the *front* of the list; the list will be
865 TREE_CHAIN (cleanup_stmt) = init_stmts;
866 init_stmts = cleanup_stmt;
868 #else /* INLINER_FOR_JAVA */
870 tree assignment = build (MODIFY_EXPR, TREE_TYPE (p), var, value);
871 init_stmts = add_stmt_to_compound (init_stmts, TREE_TYPE (p),
876 /* Java objects don't ever need constructing when being
877 passed as arguments because only call by reference is
881 #endif /* INLINER_FOR_JAVA */
884 #ifndef INLINER_FOR_JAVA
885 /* Evaluate trailing arguments. */
886 for (; a; a = TREE_CHAIN (a))
889 tree value = TREE_VALUE (a);
891 if (! value || ! TREE_SIDE_EFFECTS (value))
894 init_stmt = build_stmt (EXPR_STMT, value);
895 TREE_CHAIN (init_stmt) = init_stmts;
896 init_stmts = init_stmt;
899 /* The initialization statements have been built up in reverse
900 order. Straighten them out now. */
901 return nreverse (init_stmts);
902 #else /* INLINER_FOR_JAVA */
903 BLOCK_VARS (block) = nreverse (vars);
905 #endif /* INLINER_FOR_JAVA */
908 /* Declare a return variable to replace the RESULT_DECL for the
909 function we are calling. An appropriate DECL_STMT is returned.
910 The USE_STMT is filled in to contain a use of the declaration to
911 indicate the return value of the function. */
913 #ifndef INLINER_FOR_JAVA
915 declare_return_variable (struct inline_data *id, tree return_slot_addr,
917 #else /* INLINER_FOR_JAVA */
919 declare_return_variable (struct inline_data *id, tree return_slot_addr,
921 #endif /* INLINER_FOR_JAVA */
923 tree fn = VARRAY_TOP_TREE (id->fns);
924 tree result = DECL_RESULT (fn);
925 #ifndef INLINER_FOR_JAVA
927 #endif /* not INLINER_FOR_JAVA */
928 int need_return_decl = 1;
930 /* We don't need to do anything for functions that don't return
932 if (!result || VOID_TYPE_P (TREE_TYPE (result)))
934 #ifndef INLINER_FOR_JAVA
935 *use_stmt = NULL_TREE;
936 #else /* INLINER_FOR_JAVA */
938 #endif /* INLINER_FOR_JAVA */
942 #ifndef INLINER_FOR_JAVA
943 var = ((*lang_hooks.tree_inlining.copy_res_decl_for_inlining)
944 (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map,
945 &need_return_decl, return_slot_addr));
947 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
948 way, when the RESULT_DECL is encountered, it will be
949 automatically replaced by the VAR_DECL. */
950 splay_tree_insert (id->decl_map,
951 (splay_tree_key) result,
952 (splay_tree_value) var);
954 /* Build the USE_STMT. If the return type of the function was
955 promoted, convert it back to the expected type. */
956 if (TREE_TYPE (var) == TREE_TYPE (TREE_TYPE (fn)))
957 *use_stmt = build_stmt (EXPR_STMT, var);
959 *use_stmt = build_stmt (EXPR_STMT,
960 build1 (NOP_EXPR, TREE_TYPE (TREE_TYPE (fn)),
962 TREE_ADDRESSABLE (*use_stmt) = 1;
964 /* Build the declaration statement if FN does not return an
966 if (need_return_decl)
967 return build_stmt (DECL_STMT, var);
968 #else /* INLINER_FOR_JAVA */
969 *var = ((*lang_hooks.tree_inlining.copy_res_decl_for_inlining)
970 (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map,
971 &need_return_decl, return_slot_addr));
973 splay_tree_insert (id->decl_map,
974 (splay_tree_key) result,
975 (splay_tree_value) *var);
976 DECL_IGNORED_P (*var) = 1;
977 if (need_return_decl)
979 #endif /* INLINER_FOR_JAVA */
980 /* If FN does return an aggregate, there's no need to declare the
981 return variable; we're using a variable in our caller's frame. */
986 /* Returns nonzero if a function can be inlined as a tree. */
989 tree_inlinable_function_p (tree fn)
991 return inlinable_function_p (fn);
994 static const char *inline_forbidden_reason;
997 inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
1001 tree fn = (tree) fnp;
1004 switch (TREE_CODE (node))
1007 /* Refuse to inline alloca call unless user explicitly forced so as
1008 this may change program's memory overhead drastically when the
1009 function using alloca is called in loop. In GCC present in
1010 SPEC2000 inlining into schedule_block cause it to require 2GB of
1011 RAM instead of 256MB. */
1012 if (alloca_call_p (node)
1013 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1015 inline_forbidden_reason
1016 = N_("%Jfunction '%F' can never be inlined because it uses "
1017 "alloca (override using the always_inline attribute)");
1020 t = get_callee_fndecl (node);
1025 /* We cannot inline functions that call setjmp. */
1026 if (setjmp_call_p (t))
1028 inline_forbidden_reason
1029 = N_("%Jfunction '%F' can never be inlined because it uses setjmp");
1033 if (DECL_BUILT_IN (t))
1034 switch (DECL_FUNCTION_CODE (t))
1036 /* We cannot inline functions that take a variable number of
1038 case BUILT_IN_VA_START:
1039 case BUILT_IN_STDARG_START:
1040 case BUILT_IN_NEXT_ARG:
1041 case BUILT_IN_VA_END:
1043 inline_forbidden_reason
1044 = N_("%Jfunction '%F' can never be inlined because it "
1045 "uses variable argument lists");
1048 case BUILT_IN_LONGJMP:
1050 /* We can't inline functions that call __builtin_longjmp at
1051 all. The non-local goto machinery really requires the
1052 destination be in a different function. If we allow the
1053 function calling __builtin_longjmp to be inlined into the
1054 function calling __builtin_setjmp, Things will Go Awry. */
1055 /* ??? Need front end help to identify "regular" non-local
1057 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
1059 inline_forbidden_reason
1060 = N_("%Jfunction '%F' can never be inlined because "
1061 "it uses setjmp-longjmp exception handling");
1071 #ifndef INLINER_FOR_JAVA
1073 /* We cannot inline functions that contain other functions. */
1074 if (TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
1075 && DECL_INITIAL (TREE_OPERAND (node, 0)))
1077 inline_forbidden_reason
1078 = N_("%Jfunction '%F' can never be inlined "
1079 "because it contains a nested function");
1086 t = TREE_OPERAND (node, 0);
1088 /* We will not inline a function which uses computed goto. The
1089 addresses of its local labels, which may be tucked into
1090 global storage, are of course not constant across
1091 instantiations, which causes unexpected behavior. */
1092 if (TREE_CODE (t) != LABEL_DECL)
1094 inline_forbidden_reason
1095 = N_("%Jfunction '%F' can never be inlined "
1096 "because it contains a computed goto");
1100 /* We cannot inline a nested function that jumps to a nonlocal
1102 if (TREE_CODE (t) == LABEL_DECL && DECL_CONTEXT (t) != fn)
1104 inline_forbidden_reason
1105 = N_("%Jfunction '%F' can never be inlined "
1106 "because it contains a nonlocal goto");
1114 /* We cannot inline a function of the form
1116 void F (int i) { struct S { int ar[i]; } s; }
1118 Attempting to do so produces a catch-22.
1119 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
1120 UNION_TYPE nodes, then it goes into infinite recursion on a
1121 structure containing a pointer to its own type. If it doesn't,
1122 then the type node for S doesn't get adjusted properly when
1123 F is inlined, and we abort in find_function_data. */
1124 for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
1125 if (variably_modified_type_p (TREE_TYPE (t)))
1127 inline_forbidden_reason
1128 = N_("%Jfunction '%F' can never be inlined "
1129 "because it uses variable sized variables");
1140 /* Return subexpression representing possible alloca call, if any. */
1142 inline_forbidden_p (tree fndecl)
1144 location_t saved_loc = input_location;
1145 tree ret = walk_tree_without_duplicates
1146 (&DECL_SAVED_TREE (fndecl), inline_forbidden_p_1, fndecl);
1147 input_location = saved_loc;
1151 /* Returns nonzero if FN is a function that does not have any
1152 fundamental inline blocking properties. */
1155 inlinable_function_p (tree fn)
1157 bool inlinable = true;
1159 /* If we've already decided this function shouldn't be inlined,
1160 there's no need to check again. */
1161 if (DECL_UNINLINABLE (fn))
1164 /* See if there is any language-specific reason it cannot be
1165 inlined. (It is important that this hook be called early because
1166 in C++ it may result in template instantiation.)
1167 If the function is not inlinable for language-specific reasons,
1168 it is left up to the langhook to explain why. */
1169 inlinable = !(*lang_hooks.tree_inlining.cannot_inline_tree_fn) (&fn);
1171 /* If we don't have the function body available, we can't inline it.
1172 However, this should not be recorded since we also get here for
1173 forward declared inline functions. Therefore, return at once. */
1174 if (!DECL_SAVED_TREE (fn))
1177 /* If we're not inlining at all, then we cannot inline this function. */
1178 else if (!flag_inline_trees)
1181 /* Only try to inline functions if DECL_INLINE is set. This should be
1182 true for all functions declared `inline', and for all other functions
1183 as well with -finline-functions.
1185 Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
1186 it's the front-end that must set DECL_INLINE in this case, because
1187 dwarf2out loses if a function that does not have DECL_INLINE set is
1188 inlined anyway. That is why we have both DECL_INLINE and
1189 DECL_DECLARED_INLINE_P. */
1190 /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
1191 here should be redundant. */
1192 else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
1195 #ifdef INLINER_FOR_JAVA
1196 /* Synchronized methods can't be inlined. This is a bug. */
1197 else if (METHOD_SYNCHRONIZED (fn))
1199 #endif /* INLINER_FOR_JAVA */
1201 else if (inline_forbidden_p (fn))
1203 /* See if we should warn about uninlinable functions. Previously,
1204 some of these warnings would be issued while trying to expand
1205 the function inline, but that would cause multiple warnings
1206 about functions that would for example call alloca. But since
1207 this a property of the function, just one warning is enough.
1208 As a bonus we can now give more details about the reason why a
1209 function is not inlinable.
1210 We only warn for functions declared `inline' by the user. */
1211 bool do_warning = (warn_inline
1213 && DECL_DECLARED_INLINE_P (fn)
1214 && !DECL_IN_SYSTEM_HEADER (fn));
1216 if (lookup_attribute ("always_inline",
1217 DECL_ATTRIBUTES (fn)))
1218 sorry (inline_forbidden_reason, fn, fn);
1219 else if (do_warning)
1220 warning (inline_forbidden_reason, fn, fn);
1225 /* Squirrel away the result so that we don't have to check again. */
1226 DECL_UNINLINABLE (fn) = !inlinable;
1231 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1234 expand_call_inline (tree *tp, int *walk_subtrees, void *data)
1240 #ifndef INLINER_FOR_JAVA
1244 #else /* INLINER_FOR_JAVA */
1246 #endif /* INLINER_FOR_JAVA */
1252 tree return_slot_addr;
1255 /* See what we've got. */
1256 id = (inline_data *) data;
1259 /* Recurse, but letting recursive invocations know that we are
1260 inside the body of a TARGET_EXPR. */
1261 if (TREE_CODE (*tp) == TARGET_EXPR)
1263 #ifndef INLINER_FOR_JAVA
1264 int i, len = first_rtl_op (TARGET_EXPR);
1266 /* We're walking our own subtrees. */
1269 /* Actually walk over them. This loop is the body of
1270 walk_trees, omitting the case where the TARGET_EXPR
1271 itself is handled. */
1272 for (i = 0; i < len; ++i)
1275 ++id->in_target_cleanup_p;
1276 walk_tree (&TREE_OPERAND (*tp, i), expand_call_inline, data,
1279 --id->in_target_cleanup_p;
1283 #else /* INLINER_FOR_JAVA */
1285 #endif /* INLINER_FOR_JAVA */
1287 else if (TREE_CODE (t) == EXPR_WITH_FILE_LOCATION)
1289 /* We're walking the subtree directly. */
1291 /* Update the source position. */
1292 push_srcloc (EXPR_WFL_FILENAME (t), EXPR_WFL_LINENO (t));
1293 walk_tree (&EXPR_WFL_NODE (t), expand_call_inline, data,
1295 /* Restore the original source position. */
1302 /* Because types were not copied in copy_body, CALL_EXPRs beneath
1303 them should not be expanded. This can happen if the type is a
1304 dynamic array type, for example. */
1307 /* From here on, we're only interested in CALL_EXPRs. */
1308 if (TREE_CODE (t) != CALL_EXPR)
1311 /* First, see if we can figure out what function is being called.
1312 If we cannot, then there is no hope of inlining the function. */
1313 fn = get_callee_fndecl (t);
1317 /* Turn forward declarations into real ones. */
1318 fn = cgraph_node (fn)->decl;
1320 /* If fn is a declaration of a function in a nested scope that was
1321 globally declared inline, we don't set its DECL_INITIAL.
1322 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1323 C++ front-end uses it for cdtors to refer to their internal
1324 declarations, that are not real functions. Fortunately those
1325 don't have trees to be saved, so we can tell by checking their
1327 if (! DECL_INITIAL (fn)
1328 && DECL_ABSTRACT_ORIGIN (fn)
1329 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn)))
1330 fn = DECL_ABSTRACT_ORIGIN (fn);
1332 /* Don't try to inline functions that are not well-suited to
1334 if (!cgraph_inline_p (id->current_decl, fn, &reason))
1336 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
1338 sorry ("%Jinlining failed in call to '%F': %s", fn, fn, reason);
1339 sorry ("called from here");
1341 else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
1342 && !DECL_IN_SYSTEM_HEADER (fn)
1345 warning ("%Jinlining failed in call to '%F': %s", fn, fn, reason);
1346 warning ("called from here");
1351 if (! (*lang_hooks.tree_inlining.start_inlining) (fn))
1354 /* Set the current filename and line number to the function we are
1355 inlining so that when we create new _STMT nodes here they get
1356 line numbers corresponding to the function we are calling. We
1357 wrap the whole inlined body in an EXPR_WITH_FILE_AND_LINE as well
1358 because individual statements don't record the filename. */
1359 push_srcloc (DECL_SOURCE_FILE (fn), DECL_SOURCE_LINE (fn));
1361 #ifndef INLINER_FOR_JAVA
1362 /* Build a statement-expression containing code to initialize the
1363 arguments, the actual inline expansion of the body, and a label
1364 for the return statements within the function to jump to. The
1365 type of the statement expression is the return type of the
1367 expr = build1 (STMT_EXPR, TREE_TYPE (TREE_TYPE (fn)), make_node (COMPOUND_STMT));
1368 /* There is no scope associated with the statement-expression. */
1369 STMT_EXPR_NO_SCOPE (expr) = 1;
1370 if (lookup_attribute ("warn_unused_result",
1371 TYPE_ATTRIBUTES (TREE_TYPE (fn))))
1372 STMT_EXPR_WARN_UNUSED_RESULT (expr) = 1;
1373 stmt = STMT_EXPR_STMT (expr);
1374 #else /* INLINER_FOR_JAVA */
1375 /* Build a block containing code to initialize the arguments, the
1376 actual inline expansion of the body, and a label for the return
1377 statements within the function to jump to. The type of the
1378 statement expression is the return type of the function call. */
1380 expr = build (BLOCK, TREE_TYPE (TREE_TYPE (fn)), stmt);
1381 #endif /* INLINER_FOR_JAVA */
1383 /* Local declarations will be replaced by their equivalents in this
1386 id->decl_map = splay_tree_new (splay_tree_compare_pointers,
1389 /* Initialize the parameters. */
1390 args = TREE_OPERAND (t, 1);
1391 return_slot_addr = NULL_TREE;
1392 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t))
1394 return_slot_addr = TREE_VALUE (args);
1395 args = TREE_CHAIN (args);
1398 #ifndef INLINER_FOR_JAVA
1399 arg_inits = initialize_inlined_parameters (id, args, fn);
1400 /* Expand any inlined calls in the initializers. Do this before we
1401 push FN on the stack of functions we are inlining; we want to
1402 inline calls to FN that appear in the initializers for the
1404 expand_calls_inline (&arg_inits, id);
1405 /* And add them to the tree. */
1406 COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), arg_inits);
1407 #else /* INLINER_FOR_JAVA */
1408 arg_inits = initialize_inlined_parameters (id, args, fn, expr);
1411 /* Expand any inlined calls in the initializers. Do this before we
1412 push FN on the stack of functions we are inlining; we want to
1413 inline calls to FN that appear in the initializers for the
1415 expand_calls_inline (&arg_inits, id);
1417 /* And add them to the tree. */
1418 BLOCK_EXPR_BODY (expr) = add_stmt_to_compound (BLOCK_EXPR_BODY (expr),
1419 TREE_TYPE (arg_inits),
1422 #endif /* INLINER_FOR_JAVA */
1424 /* Record the function we are about to inline so that we can avoid
1425 recursing into it. */
1426 VARRAY_PUSH_TREE (id->fns, fn);
1428 /* Record the function we are about to inline if optimize_function
1429 has not been called on it yet and we don't have it in the list. */
1430 if (! DECL_INLINED_FNS (fn))
1434 for (i = VARRAY_ACTIVE_SIZE (id->inlined_fns) - 1; i >= 0; i--)
1435 if (VARRAY_TREE (id->inlined_fns, i) == fn)
1438 VARRAY_PUSH_TREE (id->inlined_fns, fn);
1441 /* Return statements in the function body will be replaced by jumps
1442 to the RET_LABEL. */
1443 id->ret_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
1444 DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
1446 if (! DECL_INITIAL (fn)
1447 || TREE_CODE (DECL_INITIAL (fn)) != BLOCK)
1450 #ifndef INLINER_FOR_JAVA
1451 /* Create a block to put the parameters in. We have to do this
1452 after the parameters have been remapped because remapping
1453 parameters is different from remapping ordinary variables. */
1454 scope_stmt = build_stmt (SCOPE_STMT, DECL_INITIAL (fn));
1455 SCOPE_BEGIN_P (scope_stmt) = 1;
1456 SCOPE_NO_CLEANUPS_P (scope_stmt) = 1;
1457 remap_block (scope_stmt, DECL_ARGUMENTS (fn), id);
1458 TREE_CHAIN (scope_stmt) = COMPOUND_BODY (stmt);
1459 COMPOUND_BODY (stmt) = scope_stmt;
1461 /* Tell the debugging backends that this block represents the
1462 outermost scope of the inlined function. */
1463 if (SCOPE_STMT_BLOCK (scope_stmt))
1464 BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope_stmt)) = DECL_ORIGIN (fn);
1466 /* Declare the return variable for the function. */
1467 COMPOUND_BODY (stmt)
1468 = chainon (COMPOUND_BODY (stmt),
1469 declare_return_variable (id, return_slot_addr, &use_stmt));
1470 #else /* INLINER_FOR_JAVA */
1472 /* Declare the return variable for the function. */
1473 tree decl = declare_return_variable (id, return_slot_addr, &retvar);
1476 tree *next = &BLOCK_VARS (expr);
1478 next = &TREE_CHAIN (*next);
1482 #endif /* INLINER_FOR_JAVA */
1484 /* After we've initialized the parameters, we insert the body of the
1486 #ifndef INLINER_FOR_JAVA
1487 inlined_body = &COMPOUND_BODY (stmt);
1488 while (*inlined_body)
1489 inlined_body = &TREE_CHAIN (*inlined_body);
1490 *inlined_body = copy_body (id);
1491 #else /* INLINER_FOR_JAVA */
1494 java_inlining_map_static_initializers (fn, id->decl_map);
1495 new_body = copy_body (id);
1496 TREE_TYPE (new_body) = TREE_TYPE (TREE_TYPE (fn));
1497 BLOCK_EXPR_BODY (expr)
1498 = add_stmt_to_compound (BLOCK_EXPR_BODY (expr),
1499 TREE_TYPE (new_body), new_body);
1500 inlined_body = &BLOCK_EXPR_BODY (expr);
1502 #endif /* INLINER_FOR_JAVA */
1504 /* After the body of the function comes the RET_LABEL. This must come
1505 before we evaluate the returned value below, because that evaluation
1506 may cause RTL to be generated. */
1507 #ifndef INLINER_FOR_JAVA
1508 COMPOUND_BODY (stmt)
1509 = chainon (COMPOUND_BODY (stmt),
1510 build_stmt (LABEL_STMT, id->ret_label));
1511 #else /* INLINER_FOR_JAVA */
1513 tree label = build1 (LABEL_EXPR, void_type_node, id->ret_label);
1514 BLOCK_EXPR_BODY (expr)
1515 = add_stmt_to_compound (BLOCK_EXPR_BODY (expr), void_type_node, label);
1516 TREE_SIDE_EFFECTS (label) = TREE_SIDE_EFFECTS (t);
1518 #endif /* INLINER_FOR_JAVA */
1520 /* Finally, mention the returned value so that the value of the
1521 statement-expression is the returned value of the function. */
1522 #ifndef INLINER_FOR_JAVA
1523 COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), use_stmt);
1525 /* Close the block for the parameters. */
1526 scope_stmt = build_stmt (SCOPE_STMT, DECL_INITIAL (fn));
1527 SCOPE_NO_CLEANUPS_P (scope_stmt) = 1;
1528 remap_block (scope_stmt, NULL_TREE, id);
1529 COMPOUND_BODY (stmt)
1530 = chainon (COMPOUND_BODY (stmt), scope_stmt);
1531 #else /* INLINER_FOR_JAVA */
1534 /* Mention the retvar. If the return type of the function was
1535 promoted, convert it back to the expected type. */
1536 if (TREE_TYPE (TREE_TYPE (fn)) != TREE_TYPE (retvar))
1537 retvar = build1 (NOP_EXPR, TREE_TYPE (TREE_TYPE (fn)), retvar);
1538 BLOCK_EXPR_BODY (expr)
1539 = add_stmt_to_compound (BLOCK_EXPR_BODY (expr),
1540 TREE_TYPE (retvar), retvar);
1543 java_inlining_merge_static_initializers (fn, id->decl_map);
1544 #endif /* INLINER_FOR_JAVA */
1547 splay_tree_delete (id->decl_map);
1550 /* The new expression has side-effects if the old one did. */
1551 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (t);
1553 /* Replace the call by the inlined body. Wrap it in an
1554 EXPR_WITH_FILE_LOCATION so that we'll get debugging line notes
1555 pointing to the right place. */
1556 #ifndef INLINER_FOR_JAVA
1557 chain = TREE_CHAIN (*tp);
1558 #endif /* INLINER_FOR_JAVA */
1559 *tp = build_expr_wfl (expr, DECL_SOURCE_FILE (fn), DECL_SOURCE_LINE (fn),
1561 EXPR_WFL_EMIT_LINE_NOTE (*tp) = 1;
1562 #ifndef INLINER_FOR_JAVA
1563 TREE_CHAIN (*tp) = chain;
1564 #endif /* not INLINER_FOR_JAVA */
1567 /* If the value of the new expression is ignored, that's OK. We
1568 don't warn about this for CALL_EXPRs, so we shouldn't warn about
1569 the equivalent inlined version either. */
1570 TREE_USED (*tp) = 1;
1572 /* Update callgraph if needed. */
1575 cgraph_remove_call (id->decl, fn);
1576 cgraph_create_edges (id->decl, *inlined_body);
1579 /* Recurse into the body of the just inlined function. */
1581 tree old_decl = id->current_decl;
1582 id->current_decl = fn;
1583 expand_calls_inline (inlined_body, id);
1584 id->current_decl = old_decl;
1586 VARRAY_POP (id->fns);
1588 /* Don't walk into subtrees. We've already handled them above. */
1591 (*lang_hooks.tree_inlining.end_inlining) (fn);
1593 /* Keep iterating. */
1596 /* Walk over the entire tree *TP, replacing CALL_EXPRs with inline
1597 expansions as appropriate. */
1600 expand_calls_inline (tree *tp, inline_data *id)
1602 /* Search through *TP, replacing all calls to inline functions by
1603 appropriate equivalents. Use walk_tree in no-duplicates mode
1604 to avoid exponential time complexity. (We can't just use
1605 walk_tree_without_duplicates, because of the special TARGET_EXPR
1606 handling in expand_calls. The hash table is set up in
1607 optimize_function. */
1608 walk_tree (tp, expand_call_inline, id, id->tree_pruner);
1611 /* Expand calls to inline functions in the body of FN. */
1614 optimize_inline_calls (tree fn)
1619 /* There is no point in performing inlining if errors have already
1620 occurred -- and we might crash if we try to inline invalid
1622 if (errorcount || sorrycount)
1626 memset (&id, 0, sizeof (id));
1629 id.current_decl = fn;
1630 /* Don't allow recursion into FN. */
1631 VARRAY_TREE_INIT (id.fns, 32, "fns");
1632 VARRAY_PUSH_TREE (id.fns, fn);
1633 /* Or any functions that aren't finished yet. */
1634 prev_fn = NULL_TREE;
1635 if (current_function_decl)
1637 VARRAY_PUSH_TREE (id.fns, current_function_decl);
1638 prev_fn = current_function_decl;
1641 prev_fn = ((*lang_hooks.tree_inlining.add_pending_fn_decls)
1642 (&id.fns, prev_fn));
1644 /* Create the list of functions this call will inline. */
1645 VARRAY_TREE_INIT (id.inlined_fns, 32, "inlined_fns");
1647 /* Keep track of the low-water mark, i.e., the point where the first
1648 real inlining is represented in ID.FNS. */
1649 id.first_inlined_fn = VARRAY_ACTIVE_SIZE (id.fns);
1651 /* Replace all calls to inline functions with the bodies of those
1653 id.tree_pruner = htab_create (37, htab_hash_pointer,
1654 htab_eq_pointer, NULL);
1655 expand_calls_inline (&DECL_SAVED_TREE (fn), &id);
1658 htab_delete (id.tree_pruner);
1659 if (DECL_LANG_SPECIFIC (fn))
1661 tree ifn = make_tree_vec (VARRAY_ACTIVE_SIZE (id.inlined_fns));
1663 if (VARRAY_ACTIVE_SIZE (id.inlined_fns))
1664 memcpy (&TREE_VEC_ELT (ifn, 0), &VARRAY_TREE (id.inlined_fns, 0),
1665 VARRAY_ACTIVE_SIZE (id.inlined_fns) * sizeof (tree));
1666 DECL_INLINED_FNS (fn) = ifn;
1670 /* FN is a function that has a complete body, and CLONE is a function
1671 whose body is to be set to a copy of FN, mapping argument
1672 declarations according to the ARG_MAP splay_tree. */
1675 clone_body (tree clone, tree fn, void *arg_map)
1679 /* Clone the body, as if we were making an inline call. But, remap
1680 the parameters in the callee to the parameters of caller. If
1681 there's an in-charge parameter, map it to an appropriate
1683 memset (&id, 0, sizeof (id));
1684 VARRAY_TREE_INIT (id.fns, 2, "fns");
1685 VARRAY_PUSH_TREE (id.fns, clone);
1686 VARRAY_PUSH_TREE (id.fns, fn);
1687 id.decl_map = (splay_tree)arg_map;
1689 /* Cloning is treated slightly differently from inlining. Set
1690 CLONING_P so that it's clear which operation we're performing. */
1691 id.cloning_p = true;
1693 /* Actually copy the body. */
1694 TREE_CHAIN (DECL_SAVED_TREE (clone)) = copy_body (&id);
1697 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.
1698 FUNC is called with the DATA and the address of each sub-tree. If
1699 FUNC returns a non-NULL value, the traversal is aborted, and the
1700 value returned by FUNC is returned. If HTAB is non-NULL it is used
1701 to record the nodes visited, and to avoid visiting a node more than
1705 walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_)
1707 htab_t htab = (htab_t) htab_;
1708 enum tree_code code;
1712 #define WALK_SUBTREE(NODE) \
1715 result = walk_tree (&(NODE), func, data, htab); \
1721 #define WALK_SUBTREE_TAIL(NODE) \
1725 goto tail_recurse; \
1730 /* Skip empty subtrees. */
1738 /* Don't walk the same tree twice, if the user has requested
1739 that we avoid doing so. */
1740 slot = htab_find_slot (htab, *tp, INSERT);
1746 /* Call the function. */
1748 result = (*func) (tp, &walk_subtrees, data);
1750 /* If we found something, return it. */
1754 code = TREE_CODE (*tp);
1756 #ifndef INLINER_FOR_JAVA
1757 /* Even if we didn't, FUNC may have decided that there was nothing
1758 interesting below this point in the tree. */
1761 if (STATEMENT_CODE_P (code) || code == TREE_LIST
1762 || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp))
1763 /* But we still need to check our siblings. */
1764 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
1769 /* Handle common cases up front. */
1770 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
1771 #else /* INLINER_FOR_JAVA */
1772 if (code != EXIT_BLOCK_EXPR
1773 && code != SAVE_EXPR
1774 && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
1775 #endif /* INLINER_FOR_JAVA */
1779 #ifndef INLINER_FOR_JAVA
1780 /* Set lineno here so we get the right instantiation context
1781 if we call instantiate_decl from inlinable_function_p. */
1782 if (STATEMENT_CODE_P (code) && !STMT_LINENO_FOR_FN_P (*tp))
1783 input_line = STMT_LINENO (*tp);
1784 #endif /* not INLINER_FOR_JAVA */
1786 /* Walk over all the sub-trees of this operand. */
1787 len = first_rtl_op (code);
1788 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
1789 But, we only want to walk once. */
1790 if (code == TARGET_EXPR
1791 && TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1))
1793 /* Go through the subtrees. We need to do this in forward order so
1794 that the scope of a FOR_EXPR is handled properly. */
1795 for (i = 0; i < len; ++i)
1796 WALK_SUBTREE (TREE_OPERAND (*tp, i));
1798 #ifndef INLINER_FOR_JAVA
1799 /* For statements, we also walk the chain so that we cover the
1800 entire statement tree. */
1801 if (STATEMENT_CODE_P (code))
1803 if (code == DECL_STMT
1804 && DECL_STMT_DECL (*tp)
1805 && DECL_P (DECL_STMT_DECL (*tp)))
1807 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
1808 into declarations that are just mentioned, rather than
1809 declared; they don't really belong to this part of the tree.
1810 And, we can see cycles: the initializer for a declaration can
1811 refer to the declaration itself. */
1812 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp)));
1813 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp)));
1814 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp)));
1815 WALK_SUBTREE (TREE_TYPE (*tp));
1818 /* This can be tail-recursion optimized if we write it this way. */
1819 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
1822 #endif /* not INLINER_FOR_JAVA */
1823 /* We didn't find what we were looking for. */
1826 else if (TREE_CODE_CLASS (code) == 'd')
1828 WALK_SUBTREE_TAIL (TREE_TYPE (*tp));
1830 else if (TREE_CODE_CLASS (code) == 't')
1832 WALK_SUBTREE (TYPE_SIZE (*tp));
1833 WALK_SUBTREE (TYPE_SIZE_UNIT (*tp));
1834 /* Also examine various special fields, below. */
1837 result = (*lang_hooks.tree_inlining.walk_subtrees) (tp, &walk_subtrees, func,
1839 if (result || ! walk_subtrees)
1842 /* Not one of the easy cases. We must explicitly go through the
1847 case IDENTIFIER_NODE:
1862 case PLACEHOLDER_EXPR:
1863 /* None of these have subtrees other than those already walked
1868 case REFERENCE_TYPE:
1869 WALK_SUBTREE_TAIL (TREE_TYPE (*tp));
1873 WALK_SUBTREE (TREE_VALUE (*tp));
1874 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
1879 int len = TREE_VEC_LENGTH (*tp);
1884 /* Walk all elements but the first. */
1886 WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
1888 /* Now walk the first one as a tail call. */
1889 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
1893 WALK_SUBTREE (TREE_REALPART (*tp));
1894 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
1897 WALK_SUBTREE_TAIL (CONSTRUCTOR_ELTS (*tp));
1900 WALK_SUBTREE (TYPE_METHOD_BASETYPE (*tp));
1904 WALK_SUBTREE (TREE_TYPE (*tp));
1906 tree arg = TYPE_ARG_TYPES (*tp);
1908 /* We never want to walk into default arguments. */
1909 for (; arg; arg = TREE_CHAIN (arg))
1910 WALK_SUBTREE (TREE_VALUE (arg));
1915 WALK_SUBTREE (TREE_TYPE (*tp));
1916 WALK_SUBTREE_TAIL (TYPE_DOMAIN (*tp));
1919 WALK_SUBTREE (TYPE_MIN_VALUE (*tp));
1920 WALK_SUBTREE_TAIL (TYPE_MAX_VALUE (*tp));
1923 WALK_SUBTREE (TREE_TYPE (*tp));
1924 WALK_SUBTREE_TAIL (TYPE_OFFSET_BASETYPE (*tp));
1926 #ifdef INLINER_FOR_JAVA
1927 case EXIT_BLOCK_EXPR:
1928 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 1));
1931 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
1932 #endif /* INLINER_FOR_JAVA */
1938 /* We didn't find what we were looking for. */
1942 #undef WALK_SUBTREE_TAIL
1945 /* Like walk_tree, but does not walk duplicate nodes more than
1949 walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
1954 htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1955 result = walk_tree (tp, func, data, htab);
1960 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
1963 copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1965 enum tree_code code = TREE_CODE (*tp);
1967 /* We make copies of most nodes. */
1968 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
1969 || TREE_CODE_CLASS (code) == 'c'
1970 || code == TREE_LIST
1972 || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp))
1974 /* Because the chain gets clobbered when we make a copy, we save it
1976 tree chain = TREE_CHAIN (*tp);
1978 /* Copy the node. */
1979 *tp = copy_node (*tp);
1981 /* Now, restore the chain, if appropriate. That will cause
1982 walk_tree to walk into the chain as well. */
1983 if (code == PARM_DECL || code == TREE_LIST
1984 #ifndef INLINER_FOR_JAVA
1985 || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp)
1986 || STATEMENT_CODE_P (code))
1987 TREE_CHAIN (*tp) = chain;
1989 /* For now, we don't update BLOCKs when we make copies. So, we
1990 have to nullify all scope-statements. */
1991 if (TREE_CODE (*tp) == SCOPE_STMT)
1992 SCOPE_STMT_BLOCK (*tp) = NULL_TREE;
1993 #else /* INLINER_FOR_JAVA */
1994 || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp))
1995 TREE_CHAIN (*tp) = chain;
1996 #endif /* INLINER_FOR_JAVA */
1998 else if (TREE_CODE_CLASS (code) == 't')
2004 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
2005 information indicating to what new SAVE_EXPR this one should be
2006 mapped, use that one. Otherwise, create a new node and enter it in
2007 ST. FN is the function into which the copy will be placed. */
2010 remap_save_expr (tree *tp, void *st_, tree fn, int *walk_subtrees)
2012 splay_tree st = (splay_tree) st_;
2015 /* See if we already encountered this SAVE_EXPR. */
2016 n = splay_tree_lookup (st, (splay_tree_key) *tp);
2018 /* If we didn't already remap this SAVE_EXPR, do so now. */
2021 tree t = copy_node (*tp);
2023 /* The SAVE_EXPR is now part of the function into which we
2024 are inlining this body. */
2025 SAVE_EXPR_CONTEXT (t) = fn;
2026 /* And we haven't evaluated it yet. */
2027 SAVE_EXPR_RTL (t) = NULL_RTX;
2028 /* Remember this SAVE_EXPR. */
2029 n = splay_tree_insert (st,
2030 (splay_tree_key) *tp,
2031 (splay_tree_value) t);
2032 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2033 splay_tree_insert (st, (splay_tree_key) t, (splay_tree_value) t);
2036 /* We've already walked into this SAVE_EXPR, so we needn't do it
2040 /* Replace this SAVE_EXPR with the copy. */
2041 *tp = (tree) n->value;
2044 #ifdef INLINER_FOR_JAVA
2045 /* Add STMT to EXISTING if possible, otherwise create a new
2046 COMPOUND_EXPR and add STMT to it. */
2049 add_stmt_to_compound (tree existing, tree type, tree stmt)
2054 return build (COMPOUND_EXPR, type, existing, stmt);
2059 #endif /* INLINER_FOR_JAVA */