1 /* Control and data flow functions for trees.
2 Copyright 2001, 2002 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 /* This should be eventually be generalized to other languages, but
43 this would require a shared function-as-trees infrastructure. */
44 #ifndef INLINER_FOR_JAVA
46 #else /* INLINER_FOR_JAVA */
48 #include "java-tree.h"
49 #endif /* INLINER_FOR_JAVA */
51 /* 0 if we should not perform inlining.
52 1 if we should expand functions calls inline at the tree level.
53 2 if we should consider *all* functions to be inline
56 int flag_inline_trees
= 0;
60 o In order to make inlining-on-trees work, we pessimized
61 function-local static constants. In particular, they are now
62 always output, even when not addressed. Fix this by treating
63 function-local static constants just like global static
64 constants; the back-end already knows not to output them if they
67 o Provide heuristics to clamp inlining of recursive template
70 /* Data required for function inlining. */
72 typedef struct inline_data
74 /* A stack of the functions we are inlining. For example, if we are
75 compiling `f', which calls `g', which calls `h', and we are
76 inlining the body of `h', the stack will contain, `h', followed
77 by `g', followed by `f'. The first few elements of the stack may
78 contain other functions that we know we should not recurse into,
79 even though they are not directly being inlined. */
81 /* The index of the first element of FNS that really represents an
83 unsigned first_inlined_fn
;
84 /* The label to jump to when a return statement is encountered. If
85 this value is NULL, then return statements will simply be
86 remapped as return statements, rather than as jumps. */
88 /* The map from local declarations in the inlined function to
89 equivalents in the function into which it is being inlined. */
91 /* Nonzero if we are currently within the cleanup for a
93 int in_target_cleanup_p
;
94 /* A list of the functions current function has inlined. */
95 varray_type inlined_fns
;
96 /* The approximate number of statements we have inlined in the
97 current call stack. */
99 /* We use the same mechanism to build clones that we do to perform
100 inlining. However, there are a few places where we need to
101 distinguish between those two situations. This flag is true if
102 we are cloning, rather than inlining. */
104 /* Hash table used to prevent walk_tree from visiting the same node
105 umpteen million times. */
107 /* Decl of function we are inlining into. */
113 static tree declare_return_variable
PARAMS ((inline_data
*, tree
, tree
*));
114 static tree copy_body_r
PARAMS ((tree
*, int *, void *));
115 static tree copy_body
PARAMS ((inline_data
*));
116 static tree expand_call_inline
PARAMS ((tree
*, int *, void *));
117 static void expand_calls_inline
PARAMS ((tree
*, inline_data
*));
118 static int inlinable_function_p
PARAMS ((tree
, inline_data
*, int));
119 static tree remap_decl
PARAMS ((tree
, inline_data
*));
120 #ifndef INLINER_FOR_JAVA
121 static tree initialize_inlined_parameters
PARAMS ((inline_data
*, tree
, tree
));
122 static void remap_block
PARAMS ((tree
, tree
, inline_data
*));
123 static void copy_scope_stmt
PARAMS ((tree
*, int *, inline_data
*));
124 #else /* INLINER_FOR_JAVA */
125 static tree initialize_inlined_parameters
PARAMS ((inline_data
*, tree
, tree
, tree
));
126 static void remap_block
PARAMS ((tree
*, tree
, inline_data
*));
127 static tree add_stmt_to_compound
PARAMS ((tree
, tree
, tree
));
128 #endif /* INLINER_FOR_JAVA */
129 static tree find_alloca_call_1
PARAMS ((tree
*, int *, void *));
130 static tree find_alloca_call
PARAMS ((tree
));
131 static tree find_builtin_longjmp_call_1
PARAMS ((tree
*, int *, void *));
132 static tree find_builtin_longjmp_call
PARAMS ((tree
));
134 /* The approximate number of instructions per statement. This number
135 need not be particularly accurate; it is used only to make
136 decisions about when a function is too big to inline. */
137 #define INSNS_PER_STMT (10)
139 /* Remap DECL during the copying of the BLOCK tree for the function. */
142 remap_decl (decl
, id
)
149 /* We only remap local variables in the current function. */
150 fn
= VARRAY_TOP_TREE (id
->fns
);
151 if (! (*lang_hooks
.tree_inlining
.auto_var_in_fn_p
) (decl
, fn
))
154 /* See if we have remapped this declaration. */
155 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
156 /* If we didn't already have an equivalent for this declaration,
162 /* Make a copy of the variable or label. */
163 t
= copy_decl_for_inlining (decl
, fn
,
164 VARRAY_TREE (id
->fns
, 0));
166 /* The decl T could be a dynamic array or other variable size type,
167 in which case some fields need to be remapped because they may
168 contain SAVE_EXPRs. */
169 if (TREE_TYPE (t
) && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
170 && TYPE_DOMAIN (TREE_TYPE (t
)))
172 TREE_TYPE (t
) = copy_node (TREE_TYPE (t
));
173 TYPE_DOMAIN (TREE_TYPE (t
))
174 = copy_node (TYPE_DOMAIN (TREE_TYPE (t
)));
175 walk_tree (&TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (t
))),
176 copy_body_r
, id
, NULL
);
179 #ifndef INLINER_FOR_JAVA
180 if (! DECL_NAME (t
) && TREE_TYPE (t
)
181 && (*lang_hooks
.tree_inlining
.anon_aggr_type_p
) (TREE_TYPE (t
)))
183 /* For a VAR_DECL of anonymous type, we must also copy the
184 member VAR_DECLS here and rechain the
185 DECL_ANON_UNION_ELEMS. */
189 for (src
= DECL_ANON_UNION_ELEMS (t
); src
;
190 src
= TREE_CHAIN (src
))
192 tree member
= remap_decl (TREE_VALUE (src
), id
);
194 if (TREE_PURPOSE (src
))
196 members
= tree_cons (NULL
, member
, members
);
198 DECL_ANON_UNION_ELEMS (t
) = nreverse (members
);
200 #endif /* not INLINER_FOR_JAVA */
202 /* Remember it, so that if we encounter this local entity
203 again we can reuse this copy. */
204 n
= splay_tree_insert (id
->decl_map
,
205 (splay_tree_key
) decl
,
206 (splay_tree_value
) t
);
209 return (tree
) n
->value
;
212 #ifndef INLINER_FOR_JAVA
213 /* Copy the SCOPE_STMT_BLOCK associated with SCOPE_STMT to contain
214 remapped versions of the variables therein. And hook the new block
215 into the block-tree. If non-NULL, the DECLS are declarations to
216 add to use instead of the BLOCK_VARS in the old block. */
217 #else /* INLINER_FOR_JAVA */
218 /* Copy the BLOCK to contain remapped versions of the variables
219 therein. And hook the new block into the block-tree. */
220 #endif /* INLINER_FOR_JAVA */
223 #ifndef INLINER_FOR_JAVA
224 remap_block (scope_stmt
, decls
, id
)
226 #else /* INLINER_FOR_JAVA */
227 remap_block (block
, decls
, id
)
229 #endif /* INLINER_FOR_JAVA */
233 #ifndef INLINER_FOR_JAVA
234 /* We cannot do this in the cleanup for a TARGET_EXPR since we do
235 not know whether or not expand_expr will actually write out the
236 code we put there. If it does not, then we'll have more BLOCKs
237 than block-notes, and things will go awry. At some point, we
238 should make the back-end handle BLOCK notes in a tidier way,
239 without requiring a strict correspondence to the block-tree; then
240 this check can go. */
241 if (id
->in_target_cleanup_p
)
243 SCOPE_STMT_BLOCK (scope_stmt
) = NULL_TREE
;
247 /* If this is the beginning of a scope, remap the associated BLOCK. */
248 if (SCOPE_BEGIN_P (scope_stmt
) && SCOPE_STMT_BLOCK (scope_stmt
))
255 /* Make the new block. */
256 old_block
= SCOPE_STMT_BLOCK (scope_stmt
);
257 new_block
= make_node (BLOCK
);
258 TREE_USED (new_block
) = TREE_USED (old_block
);
259 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
260 SCOPE_STMT_BLOCK (scope_stmt
) = new_block
;
262 /* Remap its variables. */
263 for (old_var
= decls
? decls
: BLOCK_VARS (old_block
);
265 old_var
= TREE_CHAIN (old_var
))
269 /* Remap the variable. */
270 new_var
= remap_decl (old_var
, id
);
271 /* If we didn't remap this variable, so we can't mess with
272 its TREE_CHAIN. If we remapped this variable to
273 something other than a declaration (say, if we mapped it
274 to a constant), then we must similarly omit any mention
276 if (!new_var
|| !DECL_P (new_var
))
280 TREE_CHAIN (new_var
) = BLOCK_VARS (new_block
);
281 BLOCK_VARS (new_block
) = new_var
;
284 /* We put the BLOCK_VARS in reverse order; fix that now. */
285 BLOCK_VARS (new_block
) = nreverse (BLOCK_VARS (new_block
));
286 fn
= VARRAY_TREE (id
->fns
, 0);
288 /* We're building a clone; DECL_INITIAL is still
289 error_mark_node, and current_binding_level is the parm
291 (*lang_hooks
.decls
.insert_block
) (new_block
);
294 /* Attach this new block after the DECL_INITIAL block for the
295 function into which this block is being inlined. In
296 rest_of_compilation we will straighten out the BLOCK tree. */
298 if (DECL_INITIAL (fn
))
299 first_block
= &BLOCK_CHAIN (DECL_INITIAL (fn
));
301 first_block
= &DECL_INITIAL (fn
);
302 BLOCK_CHAIN (new_block
) = *first_block
;
303 *first_block
= new_block
;
305 /* Remember the remapped block. */
306 splay_tree_insert (id
->decl_map
,
307 (splay_tree_key
) old_block
,
308 (splay_tree_value
) new_block
);
310 /* If this is the end of a scope, set the SCOPE_STMT_BLOCK to be the
312 else if (SCOPE_END_P (scope_stmt
) && SCOPE_STMT_BLOCK (scope_stmt
))
316 /* Find this block in the table of remapped things. */
317 n
= splay_tree_lookup (id
->decl_map
,
318 (splay_tree_key
) SCOPE_STMT_BLOCK (scope_stmt
));
321 SCOPE_STMT_BLOCK (scope_stmt
) = (tree
) n
->value
;
323 #else /* INLINER_FOR_JAVA */
329 /* Make the new block. */
331 new_block
= make_node (BLOCK
);
332 TREE_USED (new_block
) = TREE_USED (old_block
);
333 BLOCK_ABSTRACT_ORIGIN (new_block
) = old_block
;
334 BLOCK_SUBBLOCKS (new_block
) = BLOCK_SUBBLOCKS (old_block
);
335 TREE_SIDE_EFFECTS (new_block
) = TREE_SIDE_EFFECTS (old_block
);
336 TREE_TYPE (new_block
) = TREE_TYPE (old_block
);
339 /* Remap its variables. */
340 for (old_var
= decls
? decls
: BLOCK_VARS (old_block
);
342 old_var
= TREE_CHAIN (old_var
))
346 /* All local class initialization flags go in the outermost
348 if (LOCAL_CLASS_INITIALIZATION_FLAG_P (old_var
))
350 /* We may already have one. */
351 if (! splay_tree_lookup (id
->decl_map
, (splay_tree_key
) old_var
))
353 tree outermost_block
;
354 new_var
= remap_decl (old_var
, id
);
355 DECL_ABSTRACT_ORIGIN (new_var
) = NULL
;
356 outermost_block
= DECL_SAVED_TREE (current_function_decl
);
357 TREE_CHAIN (new_var
) = BLOCK_VARS (outermost_block
);
358 BLOCK_VARS (outermost_block
) = new_var
;
363 /* Remap the variable. */
364 new_var
= remap_decl (old_var
, id
);
365 /* If we didn't remap this variable, so we can't mess with
366 its TREE_CHAIN. If we remapped this variable to
367 something other than a declaration (say, if we mapped it
368 to a constant), then we must similarly omit any mention
370 if (!new_var
|| !DECL_P (new_var
))
374 TREE_CHAIN (new_var
) = BLOCK_VARS (new_block
);
375 BLOCK_VARS (new_block
) = new_var
;
378 /* We put the BLOCK_VARS in reverse order; fix that now. */
379 BLOCK_VARS (new_block
) = nreverse (BLOCK_VARS (new_block
));
380 fn
= VARRAY_TREE (id
->fns
, 0);
381 /* Remember the remapped block. */
382 splay_tree_insert (id
->decl_map
,
383 (splay_tree_key
) old_block
,
384 (splay_tree_value
) new_block
);
385 #endif /* INLINER_FOR_JAVA */
388 #ifndef INLINER_FOR_JAVA
389 /* Copy the SCOPE_STMT pointed to by TP. */
392 copy_scope_stmt (tp
, walk_subtrees
, id
)
399 /* Remember whether or not this statement was nullified. When
400 making a copy, copy_tree_r always sets SCOPE_NULLIFIED_P (and
401 doesn't copy the SCOPE_STMT_BLOCK) to free callers from having to
402 deal with copying BLOCKs if they do not wish to do so. */
403 block
= SCOPE_STMT_BLOCK (*tp
);
404 /* Copy (and replace) the statement. */
405 copy_tree_r (tp
, walk_subtrees
, NULL
);
406 /* Restore the SCOPE_STMT_BLOCK. */
407 SCOPE_STMT_BLOCK (*tp
) = block
;
409 /* Remap the associated block. */
410 remap_block (*tp
, NULL_TREE
, id
);
412 #endif /* not INLINER_FOR_JAVA */
414 /* Called from copy_body via walk_tree. DATA is really an
417 copy_body_r (tp
, walk_subtrees
, data
)
426 id
= (inline_data
*) data
;
427 fn
= VARRAY_TOP_TREE (id
->fns
);
430 /* All automatic variables should have a DECL_CONTEXT indicating
431 what function they come from. */
432 if ((TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == LABEL_DECL
)
433 && DECL_NAMESPACE_SCOPE_P (*tp
))
434 if (! DECL_EXTERNAL (*tp
) && ! TREE_STATIC (*tp
))
438 #ifdef INLINER_FOR_JAVA
439 if (TREE_CODE (*tp
) == BLOCK
)
440 remap_block (tp
, NULL_TREE
, id
);
443 /* If this is a RETURN_STMT, change it into an EXPR_STMT and a
444 GOTO_STMT with the RET_LABEL as its target. */
445 #ifndef INLINER_FOR_JAVA
446 if (TREE_CODE (*tp
) == RETURN_STMT
&& id
->ret_label
)
447 #else /* INLINER_FOR_JAVA */
448 if (TREE_CODE (*tp
) == RETURN_EXPR
&& id
->ret_label
)
449 #endif /* INLINER_FOR_JAVA */
451 tree return_stmt
= *tp
;
454 /* Build the GOTO_STMT. */
455 #ifndef INLINER_FOR_JAVA
456 goto_stmt
= build_stmt (GOTO_STMT
, id
->ret_label
);
457 TREE_CHAIN (goto_stmt
) = TREE_CHAIN (return_stmt
);
458 GOTO_FAKE_P (goto_stmt
) = 1;
459 #else /* INLINER_FOR_JAVA */
460 tree assignment
= TREE_OPERAND (return_stmt
, 0);
461 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, id
->ret_label
);
462 TREE_SIDE_EFFECTS (goto_stmt
) = 1;
463 #endif /* INLINER_FOR_JAVA */
465 /* If we're returning something, just turn that into an
466 assignment into the equivalent of the original
468 #ifndef INLINER_FOR_JAVA
469 if (RETURN_STMT_EXPR (return_stmt
))
471 *tp
= build_stmt (EXPR_STMT
,
472 RETURN_STMT_EXPR (return_stmt
));
473 STMT_IS_FULL_EXPR_P (*tp
) = 1;
474 /* And then jump to the end of the function. */
475 TREE_CHAIN (*tp
) = goto_stmt
;
477 #else /* INLINER_FOR_JAVA */
480 copy_body_r (&assignment
, walk_subtrees
, data
);
481 *tp
= build (COMPOUND_EXPR
, void_type_node
, assignment
, goto_stmt
);
482 TREE_SIDE_EFFECTS (*tp
) = 1;
484 #endif /* INLINER_FOR_JAVA */
485 /* If we're not returning anything just do the jump. */
489 /* Local variables and labels need to be replaced by equivalent
490 variables. We don't want to copy static variables; there's only
491 one of those, no matter how many times we inline the containing
493 else if ((*lang_hooks
.tree_inlining
.auto_var_in_fn_p
) (*tp
, fn
))
497 /* Remap the declaration. */
498 new_decl
= remap_decl (*tp
, id
);
501 /* Replace this variable with the copy. */
502 STRIP_TYPE_NOPS (new_decl
);
506 else if (nonstatic_local_decl_p (*tp
)
507 && DECL_CONTEXT (*tp
) != VARRAY_TREE (id
->fns
, 0))
510 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
511 remap_save_expr (tp
, id
->decl_map
, VARRAY_TREE (id
->fns
, 0),
513 else if (TREE_CODE (*tp
) == UNSAVE_EXPR
)
514 /* UNSAVE_EXPRs should not be generated until expansion time. */
516 #ifndef INLINER_FOR_JAVA
517 /* For a SCOPE_STMT, we must copy the associated block so that we
518 can write out debugging information for the inlined variables. */
519 else if (TREE_CODE (*tp
) == SCOPE_STMT
&& !id
->in_target_cleanup_p
)
520 copy_scope_stmt (tp
, walk_subtrees
, id
);
521 #else /* INLINER_FOR_JAVA */
522 else if (TREE_CODE (*tp
) == LABELED_BLOCK_EXPR
)
524 /* We need a new copy of this labeled block; the EXIT_BLOCK_EXPR
525 will refer to it, so save a copy ready for remapping. We
526 save it in the decl_map, although it isn't a decl. */
527 tree new_block
= copy_node (*tp
);
528 splay_tree_insert (id
->decl_map
,
529 (splay_tree_key
) *tp
,
530 (splay_tree_value
) new_block
);
533 else if (TREE_CODE (*tp
) == EXIT_BLOCK_EXPR
)
536 = splay_tree_lookup (id
->decl_map
,
537 (splay_tree_key
) TREE_OPERAND (*tp
, 0));
538 /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR. */
541 *tp
= copy_node (*tp
);
542 TREE_OPERAND (*tp
, 0) = (tree
) n
->value
;
544 #endif /* INLINER_FOR_JAVA */
545 /* Otherwise, just copy the node. Note that copy_tree_r already
546 knows not to copy VAR_DECLs, etc., so this is safe. */
549 copy_tree_r (tp
, walk_subtrees
, NULL
);
551 /* The copied TARGET_EXPR has never been expanded, even if the
552 original node was expanded already. */
553 if (TREE_CODE (*tp
) == TARGET_EXPR
&& TREE_OPERAND (*tp
, 3))
555 TREE_OPERAND (*tp
, 1) = TREE_OPERAND (*tp
, 3);
556 TREE_OPERAND (*tp
, 3) = NULL_TREE
;
558 else if (TREE_CODE (*tp
) == MODIFY_EXPR
559 && TREE_OPERAND (*tp
, 0) == TREE_OPERAND (*tp
, 1)
560 && ((*lang_hooks
.tree_inlining
.auto_var_in_fn_p
)
561 (TREE_OPERAND (*tp
, 0), fn
)))
563 /* Some assignments VAR = VAR; don't generate any rtl code
564 and thus don't count as variable modification. Avoid
565 keeping bogosities like 0 = 0. */
566 tree decl
= TREE_OPERAND (*tp
, 0), value
;
569 n
= splay_tree_lookup (id
->decl_map
, (splay_tree_key
) decl
);
572 value
= (tree
) n
->value
;
573 STRIP_TYPE_NOPS (value
);
574 if (TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
580 /* Keep iterating. */
584 /* Make a copy of the body of FN so that it can be inserted inline in
593 body
= DECL_SAVED_TREE (VARRAY_TOP_TREE (id
->fns
));
594 walk_tree (&body
, copy_body_r
, id
, NULL
);
599 /* Generate code to initialize the parameters of the function at the
600 top of the stack in ID from the ARGS (presented as a TREE_LIST). */
603 #ifndef INLINER_FOR_JAVA
604 initialize_inlined_parameters (id
, args
, fn
)
605 #else /* INLINER_FOR_JAVA */
606 initialize_inlined_parameters (id
, args
, fn
, block
)
607 #endif /* INLINER_FOR_JAVA */
611 #ifdef INLINER_FOR_JAVA
613 #endif /* INLINER_FOR_JAVA */
619 #ifdef INLINER_FOR_JAVA
620 tree vars
= NULL_TREE
;
621 #endif /* INLINER_FOR_JAVA */
623 /* Figure out what the parameters are. */
624 parms
= DECL_ARGUMENTS (fn
);
626 /* Start with no initializations whatsoever. */
627 init_stmts
= NULL_TREE
;
629 /* Loop through the parameter declarations, replacing each with an
630 equivalent VAR_DECL, appropriately initialized. */
631 for (p
= parms
, a
= args
; p
;
632 a
= a
? TREE_CHAIN (a
) : a
, p
= TREE_CHAIN (p
))
634 #ifndef INLINER_FOR_JAVA
637 #endif /* not INLINER_FOR_JAVA */
642 /* Find the initializer. */
643 value
= (*lang_hooks
.tree_inlining
.convert_parm_for_inlining
)
644 (p
, a
? TREE_VALUE (a
) : NULL_TREE
, fn
);
646 /* If the parameter is never assigned to, we may not need to
647 create a new variable here at all. Instead, we may be able
648 to just use the argument value. */
649 if (TREE_READONLY (p
)
650 && !TREE_ADDRESSABLE (p
)
651 && value
&& !TREE_SIDE_EFFECTS (value
))
653 /* Simplify the value, if possible. */
654 value
= fold (DECL_P (value
) ? decl_constant_value (value
) : value
);
656 /* We can't risk substituting complex expressions. They
657 might contain variables that will be assigned to later.
658 Theoretically, we could check the expression to see if
659 all of the variables that determine its value are
660 read-only, but we don't bother. */
661 if (TREE_CONSTANT (value
) || TREE_READONLY_DECL_P (value
))
663 /* If this is a declaration, wrap it a NOP_EXPR so that
664 we don't try to put the VALUE on the list of
667 value
= build1 (NOP_EXPR
, TREE_TYPE (value
), value
);
669 /* If this is a constant, make sure it has the right type. */
670 else if (TREE_TYPE (value
) != TREE_TYPE (p
))
671 value
= fold (build1 (NOP_EXPR
, TREE_TYPE (p
), value
));
673 splay_tree_insert (id
->decl_map
,
675 (splay_tree_value
) value
);
680 /* Make an equivalent VAR_DECL. */
681 var
= copy_decl_for_inlining (p
, fn
, VARRAY_TREE (id
->fns
, 0));
683 /* See if the frontend wants to pass this by invisible reference. If
684 so, our new VAR_DECL will have REFERENCE_TYPE, and we need to
685 replace uses of the PARM_DECL with dereferences. */
686 if (TREE_TYPE (var
) != TREE_TYPE (p
)
687 && POINTER_TYPE_P (TREE_TYPE (var
))
688 && TREE_TYPE (TREE_TYPE (var
)) == TREE_TYPE (p
))
689 var_sub
= build1 (INDIRECT_REF
, TREE_TYPE (p
), var
);
693 /* Register the VAR_DECL as the equivalent for the PARM_DECL;
694 that way, when the PARM_DECL is encountered, it will be
695 automatically replaced by the VAR_DECL. */
696 splay_tree_insert (id
->decl_map
,
698 (splay_tree_value
) var_sub
);
700 /* Declare this new variable. */
701 #ifndef INLINER_FOR_JAVA
702 init_stmt
= build_stmt (DECL_STMT
, var
);
703 TREE_CHAIN (init_stmt
) = init_stmts
;
704 init_stmts
= init_stmt
;
705 #else /* INLINER_FOR_JAVA */
706 TREE_CHAIN (var
) = vars
;
708 #endif /* INLINER_FOR_JAVA */
710 /* Initialize this VAR_DECL from the equivalent argument. If
711 the argument is an object, created via a constructor or copy,
712 this will not result in an extra copy: the TARGET_EXPR
713 representing the argument will be bound to VAR, and the
714 object will be constructed in VAR. */
715 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p
)))
716 #ifndef INLINER_FOR_JAVA
717 DECL_INITIAL (var
) = value
;
720 /* Even if P was TREE_READONLY, the new VAR should not be.
721 In the original code, we would have constructed a
722 temporary, and then the function body would have never
723 changed the value of P. However, now, we will be
724 constructing VAR directly. The constructor body may
725 change its value multiple times as it is being
726 constructed. Therefore, it must not be TREE_READONLY;
727 the back-end assumes that TREE_READONLY variable is
728 assigned to only once. */
729 TREE_READONLY (var
) = 0;
731 /* Build a run-time initialization. */
732 init_stmt
= build_stmt (EXPR_STMT
,
733 build (INIT_EXPR
, TREE_TYPE (p
),
735 /* Add this initialization to the list. Note that we want the
736 declaration *after* the initialization because we are going
737 to reverse all the initialization statements below. */
738 TREE_CHAIN (init_stmt
) = init_stmts
;
739 init_stmts
= init_stmt
;
742 /* See if we need to clean up the declaration. */
743 cleanup
= (*lang_hooks
.maybe_build_cleanup
) (var
);
747 /* Build the cleanup statement. */
748 cleanup_stmt
= build_stmt (CLEANUP_STMT
, var
, cleanup
);
749 /* Add it to the *front* of the list; the list will be
751 TREE_CHAIN (cleanup_stmt
) = init_stmts
;
752 init_stmts
= cleanup_stmt
;
754 #else /* INLINER_FOR_JAVA */
756 tree assignment
= build (MODIFY_EXPR
, TREE_TYPE (p
), var
, value
);
757 init_stmts
= add_stmt_to_compound (init_stmts
, TREE_TYPE (p
),
762 /* Java objects don't ever need constructing when being
763 passed as arguments because only call by reference is
767 #endif /* INLINER_FOR_JAVA */
770 #ifndef INLINER_FOR_JAVA
771 /* Evaluate trailing arguments. */
772 for (; a
; a
= TREE_CHAIN (a
))
775 tree value
= TREE_VALUE (a
);
777 if (! value
|| ! TREE_SIDE_EFFECTS (value
))
780 init_stmt
= build_stmt (EXPR_STMT
, value
);
781 TREE_CHAIN (init_stmt
) = init_stmts
;
782 init_stmts
= init_stmt
;
785 /* The initialization statements have been built up in reverse
786 order. Straighten them out now. */
787 return nreverse (init_stmts
);
788 #else /* INLINER_FOR_JAVA */
789 BLOCK_VARS (block
) = nreverse (vars
);
791 #endif /* INLINER_FOR_JAVA */
794 /* Declare a return variable to replace the RESULT_DECL for the
795 function we are calling. An appropriate DECL_STMT is returned.
796 The USE_STMT is filled in to contain a use of the declaration to
797 indicate the return value of the function. */
799 #ifndef INLINER_FOR_JAVA
801 declare_return_variable (id
, return_slot_addr
, use_stmt
)
802 struct inline_data
*id
;
803 tree return_slot_addr
;
805 #else /* INLINER_FOR_JAVA */
807 declare_return_variable (id
, return_slot_addr
, var
)
808 struct inline_data
*id
;
809 tree return_slot_addr
;
811 #endif /* INLINER_FOR_JAVA */
813 tree fn
= VARRAY_TOP_TREE (id
->fns
);
814 tree result
= DECL_RESULT (fn
);
815 #ifndef INLINER_FOR_JAVA
817 #endif /* not INLINER_FOR_JAVA */
818 int need_return_decl
= 1;
820 /* We don't need to do anything for functions that don't return
822 if (!result
|| VOID_TYPE_P (TREE_TYPE (result
)))
824 #ifndef INLINER_FOR_JAVA
825 *use_stmt
= NULL_TREE
;
826 #else /* INLINER_FOR_JAVA */
828 #endif /* INLINER_FOR_JAVA */
832 #ifndef INLINER_FOR_JAVA
833 var
= ((*lang_hooks
.tree_inlining
.copy_res_decl_for_inlining
)
834 (result
, fn
, VARRAY_TREE (id
->fns
, 0), id
->decl_map
,
835 &need_return_decl
, return_slot_addr
));
837 /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
838 way, when the RESULT_DECL is encountered, it will be
839 automatically replaced by the VAR_DECL. */
840 splay_tree_insert (id
->decl_map
,
841 (splay_tree_key
) result
,
842 (splay_tree_value
) var
);
844 /* Build the USE_STMT. If the return type of the function was
845 promoted, convert it back to the expected type. */
846 if (TREE_TYPE (var
) == TREE_TYPE (TREE_TYPE (fn
)))
847 *use_stmt
= build_stmt (EXPR_STMT
, var
);
849 *use_stmt
= build_stmt (EXPR_STMT
,
850 build1 (NOP_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
852 TREE_ADDRESSABLE (*use_stmt
) = 1;
854 /* Build the declaration statement if FN does not return an
856 if (need_return_decl
)
857 return build_stmt (DECL_STMT
, var
);
858 #else /* INLINER_FOR_JAVA */
859 *var
= ((*lang_hooks
.tree_inlining
.copy_res_decl_for_inlining
)
860 (result
, fn
, VARRAY_TREE (id
->fns
, 0), id
->decl_map
,
861 &need_return_decl
, return_slot_addr
));
863 splay_tree_insert (id
->decl_map
,
864 (splay_tree_key
) result
,
865 (splay_tree_value
) *var
);
866 DECL_IGNORED_P (*var
) = 1;
867 if (need_return_decl
)
869 #endif /* INLINER_FOR_JAVA */
870 /* If FN does return an aggregate, there's no need to declare the
871 return variable; we're using a variable in our caller's frame. */
876 /* Returns nonzero if a function can be inlined as a tree. */
879 tree_inlinable_function_p (fn
, nolimit
)
883 return inlinable_function_p (fn
, NULL
, nolimit
);
886 /* If *TP is possibly call to alloca, return nonzero. */
888 find_alloca_call_1 (tp
, walk_subtrees
, data
)
890 int *walk_subtrees ATTRIBUTE_UNUSED
;
891 void *data ATTRIBUTE_UNUSED
;
893 if (alloca_call_p (*tp
))
898 /* Return subexpression representing possible alloca call, if any. */
900 find_alloca_call (exp
)
904 const char *file
= input_filename
;
905 tree ret
= walk_tree (&exp
, find_alloca_call_1
, NULL
, NULL
);
907 input_filename
= file
;
912 find_builtin_longjmp_call_1 (tp
, walk_subtrees
, data
)
914 int *walk_subtrees ATTRIBUTE_UNUSED
;
915 void *data ATTRIBUTE_UNUSED
;
917 tree exp
= *tp
, decl
;
919 if (TREE_CODE (exp
) == CALL_EXPR
920 && TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
921 && (decl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
922 TREE_CODE (decl
) == FUNCTION_DECL
)
923 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
924 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_LONGJMP
)
931 find_builtin_longjmp_call (exp
)
935 const char *file
= input_filename
;
936 tree ret
= walk_tree (&exp
, find_builtin_longjmp_call_1
, NULL
, NULL
);
938 input_filename
= file
;
942 /* Returns nonzero if FN is a function that can be inlined into the
943 inlining context ID_. If ID_ is NULL, check whether the function
944 can be inlined at all. */
947 inlinable_function_p (fn
, id
, nolimit
)
954 int max_inline_insns_single
= MAX_INLINE_INSNS_SINGLE
;
956 /* If we've already decided this function shouldn't be inlined,
957 there's no need to check again. */
958 if (DECL_UNINLINABLE (fn
))
961 /* Assume it is not inlinable. */
964 /* We may be here either because fn is declared inline or because
965 we use -finline-functions. For the second case, we are more
967 if (DID_INLINE_FUNC (fn
))
968 max_inline_insns_single
= MAX_INLINE_INSNS_AUTO
;
970 /* The number of instructions (estimated) of current function. */
971 currfn_insns
= DECL_NUM_STMTS (fn
) * INSNS_PER_STMT
;
973 /* If we're not inlining things, then nothing is inlinable. */
974 if (! flag_inline_trees
)
976 /* If we're not inlining all functions and the function was not
977 declared `inline', we don't inline it. Don't think of
978 disregarding DECL_INLINE when flag_inline_trees == 2; it's the
979 front-end that must set DECL_INLINE in this case, because
980 dwarf2out loses if a function is inlined that doesn't have
982 else if (! DECL_INLINE (fn
) && !nolimit
)
984 #ifdef INLINER_FOR_JAVA
985 /* Synchronized methods can't be inlined. This is a bug. */
986 else if (METHOD_SYNCHRONIZED (fn
))
988 #endif /* INLINER_FOR_JAVA */
989 /* We can't inline functions that are too big. Only allow a single
990 function to be of MAX_INLINE_INSNS_SINGLE size. Make special
991 allowance for extern inline functions, though. */
993 && ! (*lang_hooks
.tree_inlining
.disregard_inline_limits
) (fn
)
994 && currfn_insns
> max_inline_insns_single
)
996 /* We can't inline functions that call __builtin_longjmp at all.
997 The non-local goto machenery really requires the destination
998 be in a different function. If we allow the function calling
999 __builtin_longjmp to be inlined into the function calling
1000 __builtin_setjmp, Things will Go Awry. */
1001 /* ??? Need front end help to identify "regular" non-local goto. */
1002 else if (find_builtin_longjmp_call (DECL_SAVED_TREE (fn
)))
1004 /* Refuse to inline alloca call unless user explicitly forced so as this may
1005 change program's memory overhead drastically when the function using alloca
1006 is called in loop. In GCC present in SPEC2000 inlining into schedule_block
1007 cause it to require 2GB of ram instead of 256MB. */
1008 else if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)) == NULL
1009 && find_alloca_call (DECL_SAVED_TREE (fn
)))
1011 /* All is well. We can inline this function. Traditionally, GCC
1012 has refused to inline functions using alloca, or functions whose
1013 values are returned in a PARALLEL, and a few other such obscure
1014 conditions. We are not equally constrained at the tree level. */
1018 /* Squirrel away the result so that we don't have to check again. */
1019 DECL_UNINLINABLE (fn
) = ! inlinable
;
1021 /* In case we don't disregard the inlining limits and we basically
1022 can inline this function, investigate further. */
1023 if (! (*lang_hooks
.tree_inlining
.disregard_inline_limits
) (fn
)
1024 && inlinable
&& !nolimit
)
1026 int sum_insns
= (id
? id
->inlined_stmts
: 0) * INSNS_PER_STMT
1028 /* In the extreme case that we have exceeded the recursive inlining
1029 limit by a huge factor (128), we just say no. Should not happen
1031 if (sum_insns
> MAX_INLINE_INSNS
* 128)
1033 /* If we did not hit the extreme limit, we use a linear function
1034 with slope -1/MAX_INLINE_SLOPE to exceedingly decrease the
1035 allowable size. We always allow a size of MIN_INLINE_INSNS
1037 else if ((sum_insns
> MAX_INLINE_INSNS
)
1038 && (currfn_insns
> MIN_INLINE_INSNS
))
1040 int max_curr
= MAX_INLINE_INSNS_SINGLE
1041 - (sum_insns
- MAX_INLINE_INSNS
) / MAX_INLINE_SLOPE
;
1042 if (currfn_insns
> max_curr
)
1047 if (inlinable
&& (*lang_hooks
.tree_inlining
.cannot_inline_tree_fn
) (&fn
))
1050 /* If we don't have the function body available, we can't inline
1052 if (! DECL_SAVED_TREE (fn
))
1055 /* Check again, language hooks may have modified it. */
1056 if (! inlinable
|| DECL_UNINLINABLE (fn
))
1059 /* Don't do recursive inlining, either. We don't record this in
1060 DECL_UNINLINABLE; we may be able to inline this function later. */
1065 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (id
->fns
); ++i
)
1066 if (VARRAY_TREE (id
->fns
, i
) == fn
)
1069 if (DECL_INLINED_FNS (fn
))
1072 tree inlined_fns
= DECL_INLINED_FNS (fn
);
1074 for (j
= 0; j
< TREE_VEC_LENGTH (inlined_fns
); ++j
)
1075 if (TREE_VEC_ELT (inlined_fns
, j
) == VARRAY_TREE (id
->fns
, 0))
1080 /* Return the result. */
1084 /* If *TP is a CALL_EXPR, replace it with its inline expansion. */
1087 expand_call_inline (tp
, walk_subtrees
, data
)
1096 #ifndef INLINER_FOR_JAVA
1100 #else /* INLINER_FOR_JAVA */
1102 #endif /* INLINER_FOR_JAVA */
1108 tree return_slot_addr
;
1110 /* See what we've got. */
1111 id
= (inline_data
*) data
;
1114 /* Recurse, but letting recursive invocations know that we are
1115 inside the body of a TARGET_EXPR. */
1116 if (TREE_CODE (*tp
) == TARGET_EXPR
)
1118 #ifndef INLINER_FOR_JAVA
1119 int i
, len
= first_rtl_op (TARGET_EXPR
);
1121 /* We're walking our own subtrees. */
1124 /* Actually walk over them. This loop is the body of
1125 walk_trees, omitting the case where the TARGET_EXPR
1126 itself is handled. */
1127 for (i
= 0; i
< len
; ++i
)
1130 ++id
->in_target_cleanup_p
;
1131 walk_tree (&TREE_OPERAND (*tp
, i
), expand_call_inline
, data
,
1134 --id
->in_target_cleanup_p
;
1138 #else /* INLINER_FOR_JAVA */
1140 #endif /* INLINER_FOR_JAVA */
1144 /* Because types were not copied in copy_body, CALL_EXPRs beneath
1145 them should not be expanded. This can happen if the type is a
1146 dynamic array type, for example. */
1149 /* From here on, we're only interested in CALL_EXPRs. */
1150 if (TREE_CODE (t
) != CALL_EXPR
)
1153 /* First, see if we can figure out what function is being called.
1154 If we cannot, then there is no hope of inlining the function. */
1155 fn
= get_callee_fndecl (t
);
1159 /* If fn is a declaration of a function in a nested scope that was
1160 globally declared inline, we don't set its DECL_INITIAL.
1161 However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
1162 C++ front-end uses it for cdtors to refer to their internal
1163 declarations, that are not real functions. Fortunately those
1164 don't have trees to be saved, so we can tell by checking their
1166 if (! DECL_INITIAL (fn
)
1167 && DECL_ABSTRACT_ORIGIN (fn
)
1168 && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn
)))
1169 fn
= DECL_ABSTRACT_ORIGIN (fn
);
1171 /* Don't try to inline functions that are not well-suited to
1173 if ((!flag_unit_at_a_time
|| !DECL_SAVED_TREE (fn
)
1174 || !cgraph_global_info (fn
)->inline_once
)
1175 && !inlinable_function_p (fn
, id
, 0))
1178 if (! (*lang_hooks
.tree_inlining
.start_inlining
) (fn
))
1181 /* Set the current filename and line number to the function we are
1182 inlining so that when we create new _STMT nodes here they get
1183 line numbers corresponding to the function we are calling. We
1184 wrap the whole inlined body in an EXPR_WITH_FILE_AND_LINE as well
1185 because individual statements don't record the filename. */
1186 push_srcloc (DECL_SOURCE_FILE (fn
), DECL_SOURCE_LINE (fn
));
1188 #ifndef INLINER_FOR_JAVA
1189 /* Build a statement-expression containing code to initialize the
1190 arguments, the actual inline expansion of the body, and a label
1191 for the return statements within the function to jump to. The
1192 type of the statement expression is the return type of the
1194 expr
= build1 (STMT_EXPR
, TREE_TYPE (TREE_TYPE (fn
)), make_node (COMPOUND_STMT
));
1195 /* There is no scope associated with the statement-expression. */
1196 STMT_EXPR_NO_SCOPE (expr
) = 1;
1197 stmt
= STMT_EXPR_STMT (expr
);
1198 #else /* INLINER_FOR_JAVA */
1199 /* Build a block containing code to initialize the arguments, the
1200 actual inline expansion of the body, and a label for the return
1201 statements within the function to jump to. The type of the
1202 statement expression is the return type of the function call. */
1204 expr
= build (BLOCK
, TREE_TYPE (TREE_TYPE (fn
)), stmt
);
1205 #endif /* INLINER_FOR_JAVA */
1207 /* Local declarations will be replaced by their equivalents in this
1210 id
->decl_map
= splay_tree_new (splay_tree_compare_pointers
,
1213 /* Initialize the parameters. */
1214 args
= TREE_OPERAND (t
, 1);
1215 return_slot_addr
= NULL_TREE
;
1216 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (t
))
1218 return_slot_addr
= TREE_VALUE (args
);
1219 args
= TREE_CHAIN (args
);
1222 #ifndef INLINER_FOR_JAVA
1223 arg_inits
= initialize_inlined_parameters (id
, args
, fn
);
1224 /* Expand any inlined calls in the initializers. Do this before we
1225 push FN on the stack of functions we are inlining; we want to
1226 inline calls to FN that appear in the initializers for the
1228 expand_calls_inline (&arg_inits
, id
);
1229 /* And add them to the tree. */
1230 COMPOUND_BODY (stmt
) = chainon (COMPOUND_BODY (stmt
), arg_inits
);
1231 #else /* INLINER_FOR_JAVA */
1232 arg_inits
= initialize_inlined_parameters (id
, args
, fn
, expr
);
1235 /* Expand any inlined calls in the initializers. Do this before we
1236 push FN on the stack of functions we are inlining; we want to
1237 inline calls to FN that appear in the initializers for the
1239 expand_calls_inline (&arg_inits
, id
);
1241 /* And add them to the tree. */
1242 BLOCK_EXPR_BODY (expr
) = add_stmt_to_compound (BLOCK_EXPR_BODY (expr
),
1243 TREE_TYPE (arg_inits
),
1246 #endif /* INLINER_FOR_JAVA */
1248 /* Record the function we are about to inline so that we can avoid
1249 recursing into it. */
1250 VARRAY_PUSH_TREE (id
->fns
, fn
);
1252 /* Record the function we are about to inline if optimize_function
1253 has not been called on it yet and we don't have it in the list. */
1254 if (! DECL_INLINED_FNS (fn
))
1258 for (i
= VARRAY_ACTIVE_SIZE (id
->inlined_fns
) - 1; i
>= 0; i
--)
1259 if (VARRAY_TREE (id
->inlined_fns
, i
) == fn
)
1262 VARRAY_PUSH_TREE (id
->inlined_fns
, fn
);
1265 /* Return statements in the function body will be replaced by jumps
1266 to the RET_LABEL. */
1267 id
->ret_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
1268 DECL_CONTEXT (id
->ret_label
) = VARRAY_TREE (id
->fns
, 0);
1270 if (! DECL_INITIAL (fn
)
1271 || TREE_CODE (DECL_INITIAL (fn
)) != BLOCK
)
1274 #ifndef INLINER_FOR_JAVA
1275 /* Create a block to put the parameters in. We have to do this
1276 after the parameters have been remapped because remapping
1277 parameters is different from remapping ordinary variables. */
1278 scope_stmt
= build_stmt (SCOPE_STMT
, DECL_INITIAL (fn
));
1279 SCOPE_BEGIN_P (scope_stmt
) = 1;
1280 SCOPE_NO_CLEANUPS_P (scope_stmt
) = 1;
1281 remap_block (scope_stmt
, DECL_ARGUMENTS (fn
), id
);
1282 TREE_CHAIN (scope_stmt
) = COMPOUND_BODY (stmt
);
1283 COMPOUND_BODY (stmt
) = scope_stmt
;
1285 /* Tell the debugging backends that this block represents the
1286 outermost scope of the inlined function. */
1287 if (SCOPE_STMT_BLOCK (scope_stmt
))
1288 BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope_stmt
)) = DECL_ORIGIN (fn
);
1290 /* Declare the return variable for the function. */
1291 COMPOUND_BODY (stmt
)
1292 = chainon (COMPOUND_BODY (stmt
),
1293 declare_return_variable (id
, return_slot_addr
, &use_stmt
));
1294 #else /* INLINER_FOR_JAVA */
1296 /* Declare the return variable for the function. */
1297 tree decl
= declare_return_variable (id
, return_slot_addr
, &retvar
);
1300 tree
*next
= &BLOCK_VARS (expr
);
1302 next
= &TREE_CHAIN (*next
);
1306 #endif /* INLINER_FOR_JAVA */
1308 /* After we've initialized the parameters, we insert the body of the
1310 #ifndef INLINER_FOR_JAVA
1311 inlined_body
= &COMPOUND_BODY (stmt
);
1312 while (*inlined_body
)
1313 inlined_body
= &TREE_CHAIN (*inlined_body
);
1314 *inlined_body
= copy_body (id
);
1315 #else /* INLINER_FOR_JAVA */
1318 java_inlining_map_static_initializers (fn
, id
->decl_map
);
1319 new_body
= copy_body (id
);
1320 TREE_TYPE (new_body
) = TREE_TYPE (TREE_TYPE (fn
));
1321 BLOCK_EXPR_BODY (expr
)
1322 = add_stmt_to_compound (BLOCK_EXPR_BODY (expr
),
1323 TREE_TYPE (new_body
), new_body
);
1324 inlined_body
= &BLOCK_EXPR_BODY (expr
);
1326 #endif /* INLINER_FOR_JAVA */
1328 /* After the body of the function comes the RET_LABEL. This must come
1329 before we evaluate the returned value below, because that evaluation
1330 may cause RTL to be generated. */
1331 #ifndef INLINER_FOR_JAVA
1332 COMPOUND_BODY (stmt
)
1333 = chainon (COMPOUND_BODY (stmt
),
1334 build_stmt (LABEL_STMT
, id
->ret_label
));
1335 #else /* INLINER_FOR_JAVA */
1337 tree label
= build1 (LABEL_EXPR
, void_type_node
, id
->ret_label
);
1338 BLOCK_EXPR_BODY (expr
)
1339 = add_stmt_to_compound (BLOCK_EXPR_BODY (expr
), void_type_node
, label
);
1340 TREE_SIDE_EFFECTS (label
) = TREE_SIDE_EFFECTS (t
);
1342 #endif /* INLINER_FOR_JAVA */
1344 /* Finally, mention the returned value so that the value of the
1345 statement-expression is the returned value of the function. */
1346 #ifndef INLINER_FOR_JAVA
1347 COMPOUND_BODY (stmt
) = chainon (COMPOUND_BODY (stmt
), use_stmt
);
1349 /* Close the block for the parameters. */
1350 scope_stmt
= build_stmt (SCOPE_STMT
, DECL_INITIAL (fn
));
1351 SCOPE_NO_CLEANUPS_P (scope_stmt
) = 1;
1352 remap_block (scope_stmt
, NULL_TREE
, id
);
1353 COMPOUND_BODY (stmt
)
1354 = chainon (COMPOUND_BODY (stmt
), scope_stmt
);
1355 #else /* INLINER_FOR_JAVA */
1358 /* Mention the retvar. If the return type of the function was
1359 promoted, convert it back to the expected type. */
1360 if (TREE_TYPE (TREE_TYPE (fn
)) != TREE_TYPE (retvar
))
1361 retvar
= build1 (NOP_EXPR
, TREE_TYPE (TREE_TYPE (fn
)), retvar
);
1362 BLOCK_EXPR_BODY (expr
)
1363 = add_stmt_to_compound (BLOCK_EXPR_BODY (expr
),
1364 TREE_TYPE (retvar
), retvar
);
1367 java_inlining_merge_static_initializers (fn
, id
->decl_map
);
1368 #endif /* INLINER_FOR_JAVA */
1371 splay_tree_delete (id
->decl_map
);
1374 /* The new expression has side-effects if the old one did. */
1375 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (t
);
1377 /* Replace the call by the inlined body. Wrap it in an
1378 EXPR_WITH_FILE_LOCATION so that we'll get debugging line notes
1379 pointing to the right place. */
1380 #ifndef INLINER_FOR_JAVA
1381 chain
= TREE_CHAIN (*tp
);
1382 *tp
= build_expr_wfl (expr
, DECL_SOURCE_FILE (fn
), DECL_SOURCE_LINE (fn
),
1384 #else /* INLINER_FOR_JAVA */
1385 *tp
= build_expr_wfl (expr
, DECL_SOURCE_FILE (fn
),
1386 DECL_SOURCE_LINE_FIRST(fn
),
1388 #endif /* INLINER_FOR_JAVA */
1389 EXPR_WFL_EMIT_LINE_NOTE (*tp
) = 1;
1390 #ifndef INLINER_FOR_JAVA
1391 TREE_CHAIN (*tp
) = chain
;
1392 #endif /* not INLINER_FOR_JAVA */
1395 /* If the value of the new expression is ignored, that's OK. We
1396 don't warn about this for CALL_EXPRs, so we shouldn't warn about
1397 the equivalent inlined version either. */
1398 TREE_USED (*tp
) = 1;
1400 /* Our function now has more statements than it did before. */
1401 DECL_NUM_STMTS (VARRAY_TREE (id
->fns
, 0)) += DECL_NUM_STMTS (fn
);
1402 /* For accounting, subtract one for the saved call/ret. */
1403 id
->inlined_stmts
+= DECL_NUM_STMTS (fn
) - 1;
1405 /* Update callgraph if needed. */
1406 if (id
->decl
&& flag_unit_at_a_time
)
1408 cgraph_remove_call (id
->decl
, fn
);
1409 cgraph_create_edges (id
->decl
, *inlined_body
);
1412 /* Recurse into the body of the just inlined function. */
1413 expand_calls_inline (inlined_body
, id
);
1414 VARRAY_POP (id
->fns
);
1416 /* If we've returned to the top level, clear out the record of how
1417 much inlining has been done. */
1418 if (VARRAY_ACTIVE_SIZE (id
->fns
) == id
->first_inlined_fn
)
1419 id
->inlined_stmts
= 0;
1421 /* Don't walk into subtrees. We've already handled them above. */
1424 (*lang_hooks
.tree_inlining
.end_inlining
) (fn
);
1426 /* Keep iterating. */
1429 /* Walk over the entire tree *TP, replacing CALL_EXPRs with inline
1430 expansions as appropriate. */
1433 expand_calls_inline (tp
, id
)
1437 /* Search through *TP, replacing all calls to inline functions by
1438 appropriate equivalents. Use walk_tree in no-duplicates mode
1439 to avoid exponential time complexity. (We can't just use
1440 walk_tree_without_duplicates, because of the special TARGET_EXPR
1441 handling in expand_calls. The hash table is set up in
1442 optimize_function. */
1443 walk_tree (tp
, expand_call_inline
, id
, id
->tree_pruner
);
1446 /* Expand calls to inline functions in the body of FN. */
1449 optimize_inline_calls (fn
)
1456 memset (&id
, 0, sizeof (id
));
1459 /* Don't allow recursion into FN. */
1460 VARRAY_TREE_INIT (id
.fns
, 32, "fns");
1461 VARRAY_PUSH_TREE (id
.fns
, fn
);
1462 /* Or any functions that aren't finished yet. */
1463 prev_fn
= NULL_TREE
;
1464 if (current_function_decl
)
1466 VARRAY_PUSH_TREE (id
.fns
, current_function_decl
);
1467 prev_fn
= current_function_decl
;
1470 prev_fn
= ((*lang_hooks
.tree_inlining
.add_pending_fn_decls
)
1471 (&id
.fns
, prev_fn
));
1473 /* Create the list of functions this call will inline. */
1474 VARRAY_TREE_INIT (id
.inlined_fns
, 32, "inlined_fns");
1476 /* Keep track of the low-water mark, i.e., the point where the first
1477 real inlining is represented in ID.FNS. */
1478 id
.first_inlined_fn
= VARRAY_ACTIVE_SIZE (id
.fns
);
1480 /* Replace all calls to inline functions with the bodies of those
1482 id
.tree_pruner
= htab_create (37, htab_hash_pointer
,
1483 htab_eq_pointer
, NULL
);
1484 expand_calls_inline (&DECL_SAVED_TREE (fn
), &id
);
1487 htab_delete (id
.tree_pruner
);
1488 if (DECL_LANG_SPECIFIC (fn
))
1490 tree ifn
= make_tree_vec (VARRAY_ACTIVE_SIZE (id
.inlined_fns
));
1492 if (VARRAY_ACTIVE_SIZE (id
.inlined_fns
))
1493 memcpy (&TREE_VEC_ELT (ifn
, 0), &VARRAY_TREE (id
.inlined_fns
, 0),
1494 VARRAY_ACTIVE_SIZE (id
.inlined_fns
) * sizeof (tree
));
1495 DECL_INLINED_FNS (fn
) = ifn
;
1499 /* FN is a function that has a complete body, and CLONE is a function
1500 whose body is to be set to a copy of FN, mapping argument
1501 declarations according to the ARG_MAP splay_tree. */
1504 clone_body (clone
, fn
, arg_map
)
1510 /* Clone the body, as if we were making an inline call. But, remap
1511 the parameters in the callee to the parameters of caller. If
1512 there's an in-charge parameter, map it to an appropriate
1514 memset (&id
, 0, sizeof (id
));
1515 VARRAY_TREE_INIT (id
.fns
, 2, "fns");
1516 VARRAY_PUSH_TREE (id
.fns
, clone
);
1517 VARRAY_PUSH_TREE (id
.fns
, fn
);
1518 id
.decl_map
= (splay_tree
)arg_map
;
1520 /* Cloning is treated slightly differently from inlining. Set
1521 CLONING_P so that it's clear which operation we're performing. */
1522 id
.cloning_p
= true;
1524 /* Actually copy the body. */
1525 TREE_CHAIN (DECL_SAVED_TREE (clone
)) = copy_body (&id
);
1528 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.
1529 FUNC is called with the DATA and the address of each sub-tree. If
1530 FUNC returns a non-NULL value, the traversal is aborted, and the
1531 value returned by FUNC is returned. If HTAB is non-NULL it is used
1532 to record the nodes visited, and to avoid visiting a node more than
1536 walk_tree (tp
, func
, data
, htab_
)
1542 htab_t htab
= (htab_t
) htab_
;
1543 enum tree_code code
;
1547 #define WALK_SUBTREE(NODE) \
1550 result = walk_tree (&(NODE), func, data, htab); \
1556 #define WALK_SUBTREE_TAIL(NODE) \
1560 goto tail_recurse; \
1565 /* Skip empty subtrees. */
1573 /* Don't walk the same tree twice, if the user has requested
1574 that we avoid doing so. */
1575 slot
= htab_find_slot (htab
, *tp
, INSERT
);
1581 /* Call the function. */
1583 result
= (*func
) (tp
, &walk_subtrees
, data
);
1585 /* If we found something, return it. */
1589 code
= TREE_CODE (*tp
);
1591 #ifndef INLINER_FOR_JAVA
1592 /* Even if we didn't, FUNC may have decided that there was nothing
1593 interesting below this point in the tree. */
1596 if (STATEMENT_CODE_P (code
) || code
== TREE_LIST
1597 || (*lang_hooks
.tree_inlining
.tree_chain_matters_p
) (*tp
))
1598 /* But we still need to check our siblings. */
1599 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
1604 /* Handle common cases up front. */
1605 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1606 || TREE_CODE_CLASS (code
) == 'r'
1607 || TREE_CODE_CLASS (code
) == 's')
1608 #else /* INLINER_FOR_JAVA */
1609 if (code
!= EXIT_BLOCK_EXPR
1610 && code
!= SAVE_EXPR
1611 && (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1612 || TREE_CODE_CLASS (code
) == 'r'
1613 || TREE_CODE_CLASS (code
) == 's'))
1614 #endif /* INLINER_FOR_JAVA */
1618 #ifndef INLINER_FOR_JAVA
1619 /* Set lineno here so we get the right instantiation context
1620 if we call instantiate_decl from inlinable_function_p. */
1621 if (STATEMENT_CODE_P (code
) && !STMT_LINENO_FOR_FN_P (*tp
))
1622 lineno
= STMT_LINENO (*tp
);
1623 #endif /* not INLINER_FOR_JAVA */
1625 /* Walk over all the sub-trees of this operand. */
1626 len
= first_rtl_op (code
);
1627 /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
1628 But, we only want to walk once. */
1629 if (code
== TARGET_EXPR
1630 && TREE_OPERAND (*tp
, 3) == TREE_OPERAND (*tp
, 1))
1632 /* Go through the subtrees. We need to do this in forward order so
1633 that the scope of a FOR_EXPR is handled properly. */
1634 for (i
= 0; i
< len
; ++i
)
1635 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
1637 #ifndef INLINER_FOR_JAVA
1638 /* For statements, we also walk the chain so that we cover the
1639 entire statement tree. */
1640 if (STATEMENT_CODE_P (code
))
1642 if (code
== DECL_STMT
1643 && DECL_STMT_DECL (*tp
)
1644 && DECL_P (DECL_STMT_DECL (*tp
)))
1646 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
1647 into declarations that are just mentioned, rather than
1648 declared; they don't really belong to this part of the tree.
1649 And, we can see cycles: the initializer for a declaration can
1650 refer to the declaration itself. */
1651 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp
)));
1652 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp
)));
1653 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp
)));
1656 /* This can be tail-recursion optimized if we write it this way. */
1657 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
1660 #endif /* not INLINER_FOR_JAVA */
1661 /* We didn't find what we were looking for. */
1664 else if (TREE_CODE_CLASS (code
) == 'd')
1666 WALK_SUBTREE_TAIL (TREE_TYPE (*tp
));
1668 else if (TREE_CODE_CLASS (code
) == 't')
1670 WALK_SUBTREE (TYPE_SIZE (*tp
));
1671 WALK_SUBTREE (TYPE_SIZE_UNIT (*tp
));
1672 /* Also examine various special fields, below. */
1675 result
= (*lang_hooks
.tree_inlining
.walk_subtrees
) (tp
, &walk_subtrees
, func
,
1677 if (result
|| ! walk_subtrees
)
1680 /* Not one of the easy cases. We must explicitly go through the
1685 case IDENTIFIER_NODE
:
1700 /* None of thse have subtrees other than those already walked
1705 case REFERENCE_TYPE
:
1706 WALK_SUBTREE_TAIL (TREE_TYPE (*tp
));
1710 WALK_SUBTREE (TREE_VALUE (*tp
));
1711 WALK_SUBTREE_TAIL (TREE_CHAIN (*tp
));
1716 int len
= TREE_VEC_LENGTH (*tp
);
1721 /* Walk all elements but the first. */
1723 WALK_SUBTREE (TREE_VEC_ELT (*tp
, len
));
1725 /* Now walk the first one as a tail call. */
1726 WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp
, 0));
1730 WALK_SUBTREE (TREE_REALPART (*tp
));
1731 WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp
));
1734 WALK_SUBTREE_TAIL (CONSTRUCTOR_ELTS (*tp
));
1737 WALK_SUBTREE (TYPE_METHOD_BASETYPE (*tp
));
1741 WALK_SUBTREE (TREE_TYPE (*tp
));
1743 tree arg
= TYPE_ARG_TYPES (*tp
);
1745 /* We never want to walk into default arguments. */
1746 for (; arg
; arg
= TREE_CHAIN (arg
))
1747 WALK_SUBTREE (TREE_VALUE (arg
));
1752 WALK_SUBTREE (TREE_TYPE (*tp
));
1753 WALK_SUBTREE_TAIL (TYPE_DOMAIN (*tp
));
1756 WALK_SUBTREE (TYPE_MIN_VALUE (*tp
));
1757 WALK_SUBTREE_TAIL (TYPE_MAX_VALUE (*tp
));
1760 WALK_SUBTREE (TREE_TYPE (*tp
));
1761 WALK_SUBTREE_TAIL (TYPE_OFFSET_BASETYPE (*tp
));
1763 #ifdef INLINER_FOR_JAVA
1764 case EXIT_BLOCK_EXPR
:
1765 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 1));
1768 WALK_SUBTREE_TAIL (TREE_OPERAND (*tp
, 0));
1769 #endif /* INLINER_FOR_JAVA */
1775 /* We didn't find what we were looking for. */
1779 #undef WALK_SUBTREE_TAIL
1782 /* Like walk_tree, but does not walk duplicate nodes more than
1786 walk_tree_without_duplicates (tp
, func
, data
)
1794 htab
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1795 result
= walk_tree (tp
, func
, data
, htab
);
1800 /* Passed to walk_tree. Copies the node pointed to, if appropriate. */
1803 copy_tree_r (tp
, walk_subtrees
, data
)
1806 void *data ATTRIBUTE_UNUSED
;
1808 enum tree_code code
= TREE_CODE (*tp
);
1810 /* We make copies of most nodes. */
1811 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
1812 || TREE_CODE_CLASS (code
) == 'r'
1813 || TREE_CODE_CLASS (code
) == 'c'
1814 || TREE_CODE_CLASS (code
) == 's'
1815 || code
== TREE_LIST
1817 || (*lang_hooks
.tree_inlining
.tree_chain_matters_p
) (*tp
))
1819 /* Because the chain gets clobbered when we make a copy, we save it
1821 tree chain
= TREE_CHAIN (*tp
);
1823 /* Copy the node. */
1824 *tp
= copy_node (*tp
);
1826 /* Now, restore the chain, if appropriate. That will cause
1827 walk_tree to walk into the chain as well. */
1828 if (code
== PARM_DECL
|| code
== TREE_LIST
1829 #ifndef INLINER_FOR_JAVA
1830 || (*lang_hooks
.tree_inlining
.tree_chain_matters_p
) (*tp
)
1831 || STATEMENT_CODE_P (code
))
1832 TREE_CHAIN (*tp
) = chain
;
1834 /* For now, we don't update BLOCKs when we make copies. So, we
1835 have to nullify all scope-statements. */
1836 if (TREE_CODE (*tp
) == SCOPE_STMT
)
1837 SCOPE_STMT_BLOCK (*tp
) = NULL_TREE
;
1838 #else /* INLINER_FOR_JAVA */
1839 || (*lang_hooks
.tree_inlining
.tree_chain_matters_p
) (*tp
))
1840 TREE_CHAIN (*tp
) = chain
;
1841 #endif /* INLINER_FOR_JAVA */
1843 else if (TREE_CODE_CLASS (code
) == 't' && !variably_modified_type_p (*tp
))
1844 /* Types only need to be copied if they are variably modified. */
1850 /* The SAVE_EXPR pointed to by TP is being copied. If ST contains
1851 information indicating to what new SAVE_EXPR this one should be
1852 mapped, use that one. Otherwise, create a new node and enter it in
1853 ST. FN is the function into which the copy will be placed. */
1856 remap_save_expr (tp
, st_
, fn
, walk_subtrees
)
1862 splay_tree st
= (splay_tree
) st_
;
1865 /* See if we already encountered this SAVE_EXPR. */
1866 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
1868 /* If we didn't already remap this SAVE_EXPR, do so now. */
1871 tree t
= copy_node (*tp
);
1873 /* The SAVE_EXPR is now part of the function into which we
1874 are inlining this body. */
1875 SAVE_EXPR_CONTEXT (t
) = fn
;
1876 /* And we haven't evaluated it yet. */
1877 SAVE_EXPR_RTL (t
) = NULL_RTX
;
1878 /* Remember this SAVE_EXPR. */
1879 n
= splay_tree_insert (st
,
1880 (splay_tree_key
) *tp
,
1881 (splay_tree_value
) t
);
1882 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
1883 splay_tree_insert (st
, (splay_tree_key
) t
,
1884 (splay_tree_value
) error_mark_node
);
1887 /* We've already walked into this SAVE_EXPR, so we needn't do it
1891 /* Replace this SAVE_EXPR with the copy. */
1892 *tp
= (tree
) n
->value
;
1895 #ifdef INLINER_FOR_JAVA
1896 /* Add STMT to EXISTING if possible, otherwise create a new
1897 COMPOUND_EXPR and add STMT to it. */
1900 add_stmt_to_compound (existing
, type
, stmt
)
1901 tree existing
, type
, stmt
;
1906 return build (COMPOUND_EXPR
, type
, existing
, stmt
);
1911 #endif /* INLINER_FOR_JAVA */