diff options
Diffstat (limited to 'contrib/gcc/tree-inline.c')
| -rw-r--r-- | contrib/gcc/tree-inline.c | 579 |
1 files changed, 522 insertions, 57 deletions
diff --git a/contrib/gcc/tree-inline.c b/contrib/gcc/tree-inline.c index 307c35c2bb1b..28ceda157f1f 100644 --- a/contrib/gcc/tree-inline.c +++ b/contrib/gcc/tree-inline.c @@ -38,11 +38,16 @@ Boston, MA 02111-1307, USA. */ /* This should be eventually be generalized to other languages, but this would require a shared function-as-trees infrastructure. */ -#include "c-common.h" +#ifndef INLINER_FOR_JAVA +#include "c-common.h" +#else /* INLINER_FOR_JAVA */ +#include "parse.h" +#include "java-tree.h" +#endif /* INLINER_FOR_JAVA */ /* 0 if we should not perform inlining. - 1 if we should expand functions calls inline at the tree level. - 2 if we should consider *all* functions to be inline + 1 if we should expand functions calls inline at the tree level. + 2 if we should consider *all* functions to be inline candidates. */ int flag_inline_trees = 0; @@ -102,7 +107,6 @@ typedef struct inline_data /* Prototypes. */ -static tree initialize_inlined_parameters PARAMS ((inline_data *, tree, tree)); static tree declare_return_variable PARAMS ((inline_data *, tree *)); static tree copy_body_r PARAMS ((tree *, int *, void *)); static tree copy_body PARAMS ((inline_data *)); @@ -110,8 +114,19 @@ static tree expand_call_inline PARAMS ((tree *, int *, void *)); static void expand_calls_inline PARAMS ((tree *, inline_data *)); static int inlinable_function_p PARAMS ((tree, inline_data *)); static tree remap_decl PARAMS ((tree, inline_data *)); +#ifndef INLINER_FOR_JAVA +static tree initialize_inlined_parameters PARAMS ((inline_data *, tree, tree)); static void remap_block PARAMS ((tree, tree, inline_data *)); static void copy_scope_stmt PARAMS ((tree *, int *, inline_data *)); +#else /* INLINER_FOR_JAVA */ +static tree initialize_inlined_parameters PARAMS ((inline_data *, tree, tree, tree)); +static void remap_block PARAMS ((tree *, tree, inline_data *)); +static tree add_stmt_to_compound PARAMS ((tree, tree, tree)); +#endif /* INLINER_FOR_JAVA */ +static tree find_alloca_call_1 PARAMS ((tree *, int *, void *)); +static tree find_alloca_call PARAMS ((tree)); +static tree find_builtin_longjmp_call_1 PARAMS ((tree *, int *, void *)); +static tree find_builtin_longjmp_call PARAMS ((tree)); /* The approximate number of instructions per statement. This number need not be particularly accurate; it is used only to make @@ -158,6 +173,7 @@ remap_decl (decl, id) copy_body_r, id, NULL); } +#ifndef INLINER_FOR_JAVA if (! DECL_NAME (t) && TREE_TYPE (t) && (*lang_hooks.tree_inlining.anon_aggr_type_p) (TREE_TYPE (t))) { @@ -166,7 +182,7 @@ remap_decl (decl, id) DECL_ANON_UNION_ELEMS. */ tree members = NULL; tree src; - + for (src = DECL_ANON_UNION_ELEMS (t); src; src = TREE_CHAIN (src)) { @@ -178,7 +194,8 @@ remap_decl (decl, id) } DECL_ANON_UNION_ELEMS (t) = nreverse (members); } - +#endif /* not INLINER_FOR_JAVA */ + /* Remember it, so that if we encounter this local entity again we can reuse this copy. */ n = splay_tree_insert (id->decl_map, @@ -189,17 +206,28 @@ remap_decl (decl, id) return (tree) n->value; } +#ifndef INLINER_FOR_JAVA /* Copy the SCOPE_STMT_BLOCK associated with SCOPE_STMT to contain remapped versions of the variables therein. And hook the new block into the block-tree. If non-NULL, the DECLS are declarations to add to use instead of the BLOCK_VARS in the old block. */ +#else /* INLINER_FOR_JAVA */ +/* Copy the BLOCK to contain remapped versions of the variables + therein. And hook the new block into the block-tree. */ +#endif /* INLINER_FOR_JAVA */ static void +#ifndef INLINER_FOR_JAVA remap_block (scope_stmt, decls, id) tree scope_stmt; +#else /* INLINER_FOR_JAVA */ +remap_block (block, decls, id) + tree *block; +#endif /* INLINER_FOR_JAVA */ tree decls; inline_data *id; { +#ifndef INLINER_FOR_JAVA /* We cannot do this in the cleanup for a TARGET_EXPR since we do not know whether or not expand_expr will actually write out the code we put there. If it does not, then we'll have more BLOCKs @@ -257,7 +285,7 @@ remap_block (scope_stmt, decls, id) /* We're building a clone; DECL_INITIAL is still error_mark_node, and current_binding_level is the parm binding level. */ - insert_block (new_block); + (*lang_hooks.decls.insert_block) (new_block); else { /* Attach this new block after the DECL_INITIAL block for the @@ -289,8 +317,72 @@ remap_block (scope_stmt, decls, id) abort (); SCOPE_STMT_BLOCK (scope_stmt) = (tree) n->value; } +#else /* INLINER_FOR_JAVA */ + tree old_block; + tree new_block; + tree old_var; + tree fn; + + /* Make the new block. */ + old_block = *block; + new_block = make_node (BLOCK); + TREE_USED (new_block) = TREE_USED (old_block); + BLOCK_ABSTRACT_ORIGIN (new_block) = old_block; + BLOCK_SUBBLOCKS (new_block) = BLOCK_SUBBLOCKS (old_block); + TREE_SIDE_EFFECTS (new_block) = TREE_SIDE_EFFECTS (old_block); + TREE_TYPE (new_block) = TREE_TYPE (old_block); + *block = new_block; + + /* Remap its variables. */ + for (old_var = decls ? decls : BLOCK_VARS (old_block); + old_var; + old_var = TREE_CHAIN (old_var)) + { + tree new_var; + + /* All local class initialization flags go in the outermost + scope. */ + if (LOCAL_CLASS_INITIALIZATION_FLAG_P (old_var)) + { + /* We may already have one. */ + if (! splay_tree_lookup (id->decl_map, (splay_tree_key) old_var)) + { + tree outermost_block; + new_var = remap_decl (old_var, id); + DECL_ABSTRACT_ORIGIN (new_var) = NULL; + outermost_block = DECL_SAVED_TREE (current_function_decl); + TREE_CHAIN (new_var) = BLOCK_VARS (outermost_block); + BLOCK_VARS (outermost_block) = new_var; + } + continue; + } + + /* Remap the variable. */ + new_var = remap_decl (old_var, id); + /* If we didn't remap this variable, so we can't mess with + its TREE_CHAIN. If we remapped this variable to + something other than a declaration (say, if we mapped it + to a constant), then we must similarly omit any mention + of it here. */ + if (!new_var || !DECL_P (new_var)) + ; + else + { + TREE_CHAIN (new_var) = BLOCK_VARS (new_block); + BLOCK_VARS (new_block) = new_var; + } + } + /* We put the BLOCK_VARS in reverse order; fix that now. */ + BLOCK_VARS (new_block) = nreverse (BLOCK_VARS (new_block)); + fn = VARRAY_TREE (id->fns, 0); + /* Remember the remapped block. */ + splay_tree_insert (id->decl_map, + (splay_tree_key) old_block, + (splay_tree_value) new_block); +#endif /* INLINER_FOR_JAVA */ } +#ifndef INLINER_FOR_JAVA /* Copy the SCOPE_STMT pointed to by TP. */ static void @@ -314,10 +406,10 @@ copy_scope_stmt (tp, walk_subtrees, id) /* Remap the associated block. */ remap_block (*tp, NULL_TREE, id); } +#endif /* not INLINER_FOR_JAVA */ /* Called from copy_body via walk_tree. DATA is really an `inline_data *'. */ - static tree copy_body_r (tp, walk_subtrees, data) tree *tp; @@ -340,29 +432,53 @@ copy_body_r (tp, walk_subtrees, data) abort (); #endif +#ifdef INLINER_FOR_JAVA + if (TREE_CODE (*tp) == BLOCK) + remap_block (tp, NULL_TREE, id); +#endif + /* If this is a RETURN_STMT, change it into an EXPR_STMT and a GOTO_STMT with the RET_LABEL as its target. */ +#ifndef INLINER_FOR_JAVA if (TREE_CODE (*tp) == RETURN_STMT && id->ret_label) +#else /* INLINER_FOR_JAVA */ + if (TREE_CODE (*tp) == RETURN_EXPR && id->ret_label) +#endif /* INLINER_FOR_JAVA */ { tree return_stmt = *tp; tree goto_stmt; /* Build the GOTO_STMT. */ +#ifndef INLINER_FOR_JAVA goto_stmt = build_stmt (GOTO_STMT, id->ret_label); TREE_CHAIN (goto_stmt) = TREE_CHAIN (return_stmt); GOTO_FAKE_P (goto_stmt) = 1; +#else /* INLINER_FOR_JAVA */ + tree assignment = TREE_OPERAND (return_stmt, 0); + goto_stmt = build1 (GOTO_EXPR, void_type_node, id->ret_label); + TREE_SIDE_EFFECTS (goto_stmt) = 1; +#endif /* INLINER_FOR_JAVA */ /* If we're returning something, just turn that into an assignment into the equivalent of the original RESULT_DECL. */ - if (RETURN_EXPR (return_stmt)) +#ifndef INLINER_FOR_JAVA + if (RETURN_STMT_EXPR (return_stmt)) { *tp = build_stmt (EXPR_STMT, - RETURN_EXPR (return_stmt)); + RETURN_STMT_EXPR (return_stmt)); STMT_IS_FULL_EXPR_P (*tp) = 1; /* And then jump to the end of the function. */ TREE_CHAIN (*tp) = goto_stmt; } +#else /* INLINER_FOR_JAVA */ + if (assignment) + { + copy_body_r (&assignment, walk_subtrees, data); + *tp = build (COMPOUND_EXPR, void_type_node, assignment, goto_stmt); + TREE_SIDE_EFFECTS (*tp) = 1; + } +#endif /* INLINER_FOR_JAVA */ /* If we're not returning anything just do the jump. */ else *tp = goto_stmt; @@ -394,10 +510,35 @@ copy_body_r (tp, walk_subtrees, data) else if (TREE_CODE (*tp) == UNSAVE_EXPR) /* UNSAVE_EXPRs should not be generated until expansion time. */ abort (); +#ifndef INLINER_FOR_JAVA /* For a SCOPE_STMT, we must copy the associated block so that we can write out debugging information for the inlined variables. */ else if (TREE_CODE (*tp) == SCOPE_STMT && !id->in_target_cleanup_p) copy_scope_stmt (tp, walk_subtrees, id); +#else /* INLINER_FOR_JAVA */ + else if (TREE_CODE (*tp) == LABELED_BLOCK_EXPR) + { + /* We need a new copy of this labeled block; the EXIT_BLOCK_EXPR + will refer to it, so save a copy ready for remapping. We + save it in the decl_map, although it isn't a decl. */ + tree new_block = copy_node (*tp); + splay_tree_insert (id->decl_map, + (splay_tree_key) *tp, + (splay_tree_value) new_block); + *tp = new_block; + } + else if (TREE_CODE (*tp) == EXIT_BLOCK_EXPR) + { + splay_tree_node n + = splay_tree_lookup (id->decl_map, + (splay_tree_key) TREE_OPERAND (*tp, 0)); + /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR. */ + if (! n) + abort (); + *tp = copy_node (*tp); + TREE_OPERAND (*tp, 0) = (tree) n->value; + } +#endif /* INLINER_FOR_JAVA */ /* Otherwise, just copy the node. Note that copy_tree_r already knows not to copy VAR_DECLs, etc., so this is safe. */ else @@ -456,15 +597,25 @@ copy_body (id) top of the stack in ID from the ARGS (presented as a TREE_LIST). */ static tree +#ifndef INLINER_FOR_JAVA initialize_inlined_parameters (id, args, fn) +#else /* INLINER_FOR_JAVA */ +initialize_inlined_parameters (id, args, fn, block) +#endif /* INLINER_FOR_JAVA */ inline_data *id; tree args; tree fn; +#ifdef INLINER_FOR_JAVA + tree block; +#endif /* INLINER_FOR_JAVA */ { tree init_stmts; tree parms; tree a; tree p; +#ifdef INLINER_FOR_JAVA + tree vars = NULL_TREE; +#endif /* INLINER_FOR_JAVA */ /* Figure out what the parameters are. */ parms = DECL_ARGUMENTS (fn); @@ -477,10 +628,13 @@ initialize_inlined_parameters (id, args, fn) for (p = parms, a = args; p; a = a ? TREE_CHAIN (a) : a, p = TREE_CHAIN (p)) { +#ifndef INLINER_FOR_JAVA tree init_stmt; + tree cleanup; +#endif /* not INLINER_FOR_JAVA */ tree var; tree value; - tree cleanup; + tree var_sub; /* Find the initializer. */ value = (*lang_hooks.tree_inlining.convert_parm_for_inlining) @@ -509,6 +663,10 @@ initialize_inlined_parameters (id, args, fn) if (DECL_P (value)) value = build1 (NOP_EXPR, TREE_TYPE (value), value); + /* If this is a constant, make sure it has the right type. */ + else if (TREE_TYPE (value) != TREE_TYPE (p)) + value = fold (build1 (NOP_EXPR, TREE_TYPE (p), value)); + splay_tree_insert (id->decl_map, (splay_tree_key) p, (splay_tree_value) value); @@ -518,17 +676,33 @@ initialize_inlined_parameters (id, args, fn) /* Make an equivalent VAR_DECL. */ var = copy_decl_for_inlining (p, fn, VARRAY_TREE (id->fns, 0)); + + /* See if the frontend wants to pass this by invisible reference. If + so, our new VAR_DECL will have REFERENCE_TYPE, and we need to + replace uses of the PARM_DECL with dereferences. */ + if (TREE_TYPE (var) != TREE_TYPE (p) + && POINTER_TYPE_P (TREE_TYPE (var)) + && TREE_TYPE (TREE_TYPE (var)) == TREE_TYPE (p)) + var_sub = build1 (INDIRECT_REF, TREE_TYPE (p), var); + else + var_sub = var; + /* Register the VAR_DECL as the equivalent for the PARM_DECL; that way, when the PARM_DECL is encountered, it will be automatically replaced by the VAR_DECL. */ splay_tree_insert (id->decl_map, (splay_tree_key) p, - (splay_tree_value) var); + (splay_tree_value) var_sub); /* Declare this new variable. */ +#ifndef INLINER_FOR_JAVA init_stmt = build_stmt (DECL_STMT, var); TREE_CHAIN (init_stmt) = init_stmts; init_stmts = init_stmt; +#else /* INLINER_FOR_JAVA */ + TREE_CHAIN (var) = vars; + vars = var; +#endif /* INLINER_FOR_JAVA */ /* Initialize this VAR_DECL from the equivalent argument. If the argument is an object, created via a constructor or copy, @@ -536,6 +710,7 @@ initialize_inlined_parameters (id, args, fn) representing the argument will be bound to VAR, and the object will be constructed in VAR. */ if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p))) +#ifndef INLINER_FOR_JAVA DECL_INITIAL (var) = value; else { @@ -562,8 +737,8 @@ initialize_inlined_parameters (id, args, fn) } /* See if we need to clean up the declaration. */ - cleanup = maybe_build_cleanup (var); - if (cleanup) + cleanup = (*lang_hooks.maybe_build_cleanup) (var); + if (cleanup) { tree cleanup_stmt; /* Build the cleanup statement. */ @@ -573,8 +748,23 @@ initialize_inlined_parameters (id, args, fn) TREE_CHAIN (cleanup_stmt) = init_stmts; init_stmts = cleanup_stmt; } +#else /* INLINER_FOR_JAVA */ + { + tree assignment = build (MODIFY_EXPR, TREE_TYPE (p), var, value); + init_stmts = add_stmt_to_compound (init_stmts, TREE_TYPE (p), + assignment); + } + else + { + /* Java objects don't ever need constructing when being + passed as arguments because only call by reference is + supported. */ + abort (); + } +#endif /* INLINER_FOR_JAVA */ } +#ifndef INLINER_FOR_JAVA /* Evaluate trailing arguments. */ for (; a; a = TREE_CHAIN (a)) { @@ -592,6 +782,10 @@ initialize_inlined_parameters (id, args, fn) /* The initialization statements have been built up in reverse order. Straighten them out now. */ return nreverse (init_stmts); +#else /* INLINER_FOR_JAVA */ + BLOCK_VARS (block) = nreverse (vars); + return init_stmts; +#endif /* INLINER_FOR_JAVA */ } /* Declare a return variable to replace the RESULT_DECL for the @@ -599,24 +793,38 @@ initialize_inlined_parameters (id, args, fn) The USE_STMT is filled in to contain a use of the declaration to indicate the return value of the function. */ +#ifndef INLINER_FOR_JAVA static tree declare_return_variable (id, use_stmt) struct inline_data *id; tree *use_stmt; +#else /* INLINER_FOR_JAVA */ +static tree +declare_return_variable (id, var) + struct inline_data *id; + tree *var; +#endif /* INLINER_FOR_JAVA */ { tree fn = VARRAY_TOP_TREE (id->fns); tree result = DECL_RESULT (fn); +#ifndef INLINER_FOR_JAVA tree var; +#endif /* not INLINER_FOR_JAVA */ int need_return_decl = 1; /* We don't need to do anything for functions that don't return anything. */ if (!result || VOID_TYPE_P (TREE_TYPE (result))) { +#ifndef INLINER_FOR_JAVA *use_stmt = NULL_TREE; +#else /* INLINER_FOR_JAVA */ + *var = NULL_TREE; +#endif /* INLINER_FOR_JAVA */ return NULL_TREE; } +#ifndef INLINER_FOR_JAVA var = ((*lang_hooks.tree_inlining.copy_res_decl_for_inlining) (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map, &need_return_decl, &id->target_exprs)); @@ -636,20 +844,31 @@ declare_return_variable (id, use_stmt) *use_stmt = build_stmt (EXPR_STMT, build1 (NOP_EXPR, TREE_TYPE (TREE_TYPE (fn)), var)); - TREE_ADDRESSABLE (*use_stmt) = 1; /* Build the declaration statement if FN does not return an aggregate. */ if (need_return_decl) return build_stmt (DECL_STMT, var); +#else /* INLINER_FOR_JAVA */ + *var = ((*lang_hooks.tree_inlining.copy_res_decl_for_inlining) + (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map, + &need_return_decl, NULL_TREE)); + + splay_tree_insert (id->decl_map, + (splay_tree_key) result, + (splay_tree_value) *var); + DECL_IGNORED_P (*var) = 1; + if (need_return_decl) + return *var; +#endif /* INLINER_FOR_JAVA */ /* If FN does return an aggregate, there's no need to declare the return variable; we're using a variable in our caller's frame. */ else return NULL_TREE; } -/* Returns non-zero if a function can be inlined as a tree. */ +/* Returns nonzero if a function can be inlined as a tree. */ int tree_inlinable_function_p (fn) @@ -658,7 +877,53 @@ tree_inlinable_function_p (fn) return inlinable_function_p (fn, NULL); } -/* Returns non-zero if FN is a function that can be inlined into the +/* If *TP is possibly call to alloca, return nonzero. */ +static tree +find_alloca_call_1 (tp, walk_subtrees, data) + tree *tp; + int *walk_subtrees ATTRIBUTE_UNUSED; + void *data ATTRIBUTE_UNUSED; +{ + if (alloca_call_p (*tp)) + return *tp; + return NULL; +} + +/* Return subexpression representing possible alloca call, if any. */ +static tree +find_alloca_call (exp) + tree exp; +{ + return walk_tree_without_duplicates (&exp, find_alloca_call_1, NULL); +} + +static tree +find_builtin_longjmp_call_1 (tp, walk_subtrees, data) + tree *tp; + int *walk_subtrees ATTRIBUTE_UNUSED; + void *data ATTRIBUTE_UNUSED; +{ + tree exp = *tp, decl; + + if (TREE_CODE (exp) == CALL_EXPR + && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR + && (decl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0), + TREE_CODE (decl) == FUNCTION_DECL) + && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL + && DECL_FUNCTION_CODE (decl) == BUILT_IN_LONGJMP) + return decl; + + return NULL; +} + +static tree +find_builtin_longjmp_call (exp) + tree exp; +{ + return walk_tree_without_duplicates (&exp, find_builtin_longjmp_call_1, NULL); +} + +/* Returns nonzero if FN is a function that can be inlined into the inlining context ID_. If ID_ is NULL, check whether the function can be inlined at all. */ @@ -668,6 +933,8 @@ inlinable_function_p (fn, id) inline_data *id; { int inlinable; + int currfn_insns; + int max_inline_insns_single = MAX_INLINE_INSNS_SINGLE; /* If we've already decided this function shouldn't be inlined, there's no need to check again. */ @@ -676,6 +943,15 @@ inlinable_function_p (fn, id) /* Assume it is not inlinable. */ inlinable = 0; + + /* We may be here either because fn is declared inline or because + we use -finline-functions. For the second case, we are more + restrictive. */ + if (DID_INLINE_FUNC (fn)) + max_inline_insns_single = MAX_INLINE_INSNS_AUTO; + + /* The number of instructions (estimated) of current function. */ + currfn_insns = DECL_NUM_STMTS (fn) * INSNS_PER_STMT; /* If we're not inlining things, then nothing is inlinable. */ if (! flag_inline_trees) @@ -688,11 +964,31 @@ inlinable_function_p (fn, id) DECL_INLINE set. */ else if (! DECL_INLINE (fn)) ; +#ifdef INLINER_FOR_JAVA + /* Synchronized methods can't be inlined. This is a bug. */ + else if (METHOD_SYNCHRONIZED (fn)) + ; +#endif /* INLINER_FOR_JAVA */ /* We can't inline functions that are too big. Only allow a single - function to eat up half of our budget. Make special allowance - for extern inline functions, though. */ + function to be of MAX_INLINE_INSNS_SINGLE size. Make special + allowance for extern inline functions, though. */ else if (! (*lang_hooks.tree_inlining.disregard_inline_limits) (fn) - && DECL_NUM_STMTS (fn) * INSNS_PER_STMT > MAX_INLINE_INSNS / 2) + && currfn_insns > max_inline_insns_single) + ; + /* We can't inline functions that call __builtin_longjmp at all. + The non-local goto machenery really requires the destination + be in a different function. If we allow the function calling + __builtin_longjmp to be inlined into the function calling + __builtin_setjmp, Things will Go Awry. */ + /* ??? Need front end help to identify "regular" non-local goto. */ + else if (find_builtin_longjmp_call (DECL_SAVED_TREE (fn))) + ; + /* Refuse to inline alloca call unless user explicitly forced so as this may + change program's memory overhead drastically when the function using alloca + is called in loop. In GCC present in SPEC2000 inlining into schedule_block + cause it to require 2GB of ram instead of 256MB. */ + else if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL + && find_alloca_call (DECL_SAVED_TREE (fn))) ; /* All is well. We can inline this function. Traditionally, GCC has refused to inline functions using alloca, or functions whose @@ -704,19 +1000,35 @@ inlinable_function_p (fn, id) /* Squirrel away the result so that we don't have to check again. */ DECL_UNINLINABLE (fn) = ! inlinable; - /* Even if this function is not itself too big to inline, it might - be that we've done so much inlining already that we don't want to - risk too much inlining any more and thus halve the acceptable - size. */ + /* In case we don't disregard the inlining limits and we basically + can inline this function, investigate further. */ if (! (*lang_hooks.tree_inlining.disregard_inline_limits) (fn) - && ((DECL_NUM_STMTS (fn) + (id ? id->inlined_stmts : 0)) * INSNS_PER_STMT - > MAX_INLINE_INSNS) - && DECL_NUM_STMTS (fn) * INSNS_PER_STMT > MAX_INLINE_INSNS / 4) - inlinable = 0; + && inlinable) + { + int sum_insns = (id ? id->inlined_stmts : 0) * INSNS_PER_STMT + + currfn_insns; + /* In the extreme case that we have exceeded the recursive inlining + limit by a huge factor (128), we just say no. Should not happen + in real life. */ + if (sum_insns > MAX_INLINE_INSNS * 128) + inlinable = 0; + /* If we did not hit the extreme limit, we use a linear function + with slope -1/MAX_INLINE_SLOPE to exceedingly decrease the + allowable size. We always allow a size of MIN_INLINE_INSNS + though. */ + else if ((sum_insns > MAX_INLINE_INSNS) + && (currfn_insns > MIN_INLINE_INSNS)) + { + int max_curr = MAX_INLINE_INSNS_SINGLE + - (sum_insns - MAX_INLINE_INSNS) / MAX_INLINE_SLOPE; + if (currfn_insns > max_curr) + inlinable = 0; + } + } if (inlinable && (*lang_hooks.tree_inlining.cannot_inline_tree_fn) (&fn)) inlinable = 0; - + /* If we don't have the function body available, we can't inline it. */ if (! DECL_SAVED_TREE (fn)) @@ -763,10 +1075,14 @@ expand_call_inline (tp, walk_subtrees, data) tree t; tree expr; tree stmt; +#ifndef INLINER_FOR_JAVA tree chain; - tree fn; tree scope_stmt; tree use_stmt; +#else /* INLINER_FOR_JAVA */ + tree retvar; +#endif /* INLINER_FOR_JAVA */ + tree fn; tree arg_inits; tree *inlined_body; splay_tree st; @@ -779,6 +1095,7 @@ expand_call_inline (tp, walk_subtrees, data) inside the body of a TARGET_EXPR. */ if (TREE_CODE (*tp) == TARGET_EXPR) { +#ifndef INLINER_FOR_JAVA int i, len = first_rtl_op (TARGET_EXPR); /* We're walking our own subtrees. */ @@ -804,6 +1121,22 @@ expand_call_inline (tp, walk_subtrees, data) VARRAY_POP (id->target_exprs); return NULL_TREE; +#else /* INLINER_FOR_JAVA */ + abort (); +#endif /* INLINER_FOR_JAVA */ + } + else if (TREE_CODE (t) == EXPR_WITH_FILE_LOCATION) + { + /* We're walking the subtree directly. */ + *walk_subtrees = 0; + /* Update the source position. */ + push_srcloc (EXPR_WFL_FILENAME (t), EXPR_WFL_LINENO (t)); + walk_tree (&EXPR_WFL_NODE (t), expand_call_inline, data, + id->tree_pruner); + /* Restore the original source position. */ + pop_srcloc (); + + return NULL_TREE; } if (TYPE_P (t)) @@ -837,7 +1170,15 @@ expand_call_inline (tp, walk_subtrees, data) /* Don't try to inline functions that are not well-suited to inlining. */ if (!inlinable_function_p (fn, id)) - return NULL_TREE; + { + if (warn_inline && DECL_INLINE (fn) && !DID_INLINE_FUNC (fn) + && !DECL_IN_SYSTEM_HEADER (fn)) + { + warning_with_decl (fn, "inlining failed in call to `%s'"); + warning ("called from here"); + } + return NULL_TREE; + } if (! (*lang_hooks.tree_inlining.start_inlining) (fn)) return NULL_TREE; @@ -847,8 +1188,9 @@ expand_call_inline (tp, walk_subtrees, data) line numbers corresponding to the function we are calling. We wrap the whole inlined body in an EXPR_WITH_FILE_AND_LINE as well because individual statements don't record the filename. */ - push_srcloc (fn->decl.filename, fn->decl.linenum); + push_srcloc (DECL_SOURCE_FILE (fn), DECL_SOURCE_LINE (fn)); +#ifndef INLINER_FOR_JAVA /* Build a statement-expression containing code to initialize the arguments, the actual inline expansion of the body, and a label for the return statements within the function to jump to. The @@ -858,6 +1200,15 @@ expand_call_inline (tp, walk_subtrees, data) /* There is no scope associated with the statement-expression. */ STMT_EXPR_NO_SCOPE (expr) = 1; stmt = STMT_EXPR_STMT (expr); +#else /* INLINER_FOR_JAVA */ + /* Build a block containing code to initialize the arguments, the + actual inline expansion of the body, and a label for the return + statements within the function to jump to. The type of the + statement expression is the return type of the function call. */ + stmt = NULL; + expr = build (BLOCK, TREE_TYPE (TREE_TYPE (fn)), stmt); +#endif /* INLINER_FOR_JAVA */ + /* Local declarations will be replaced by their equivalents in this map. */ st = id->decl_map; @@ -865,6 +1216,7 @@ expand_call_inline (tp, walk_subtrees, data) NULL, NULL); /* Initialize the parameters. */ +#ifndef INLINER_FOR_JAVA arg_inits = initialize_inlined_parameters (id, TREE_OPERAND (t, 1), fn); /* Expand any inlined calls in the initializers. Do this before we push FN on the stack of functions we are inlining; we want to @@ -873,6 +1225,22 @@ expand_call_inline (tp, walk_subtrees, data) expand_calls_inline (&arg_inits, id); /* And add them to the tree. */ COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), arg_inits); +#else /* INLINER_FOR_JAVA */ + arg_inits = initialize_inlined_parameters (id, TREE_OPERAND (t, 1), fn, expr); + if (arg_inits) + { + /* Expand any inlined calls in the initializers. Do this before we + push FN on the stack of functions we are inlining; we want to + inline calls to FN that appear in the initializers for the + parameters. */ + expand_calls_inline (&arg_inits, id); + + /* And add them to the tree. */ + BLOCK_EXPR_BODY (expr) = add_stmt_to_compound (BLOCK_EXPR_BODY (expr), + TREE_TYPE (arg_inits), + arg_inits); + } +#endif /* INLINER_FOR_JAVA */ /* Record the function we are about to inline so that we can avoid recursing into it. */ @@ -900,6 +1268,7 @@ expand_call_inline (tp, walk_subtrees, data) || TREE_CODE (DECL_INITIAL (fn)) != BLOCK) abort (); +#ifndef INLINER_FOR_JAVA /* Create a block to put the parameters in. We have to do this after the parameters have been remapped because remapping parameters is different from remapping ordinary variables. */ @@ -919,31 +1288,81 @@ expand_call_inline (tp, walk_subtrees, data) COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), declare_return_variable (id, &use_stmt)); +#else /* INLINER_FOR_JAVA */ + { + /* Declare the return variable for the function. */ + tree decl = declare_return_variable (id, &retvar); + if (retvar) + { + tree *next = &BLOCK_VARS (expr); + while (*next) + next = &TREE_CHAIN (*next); + *next = decl; + } + } +#endif /* INLINER_FOR_JAVA */ /* After we've initialized the parameters, we insert the body of the function itself. */ +#ifndef INLINER_FOR_JAVA inlined_body = &COMPOUND_BODY (stmt); while (*inlined_body) inlined_body = &TREE_CHAIN (*inlined_body); *inlined_body = copy_body (id); +#else /* INLINER_FOR_JAVA */ + { + tree new_body; + java_inlining_map_static_initializers (fn, id->decl_map); + new_body = copy_body (id); + TREE_TYPE (new_body) = TREE_TYPE (TREE_TYPE (fn)); + BLOCK_EXPR_BODY (expr) + = add_stmt_to_compound (BLOCK_EXPR_BODY (expr), + TREE_TYPE (new_body), new_body); + inlined_body = &BLOCK_EXPR_BODY (expr); + } +#endif /* INLINER_FOR_JAVA */ /* After the body of the function comes the RET_LABEL. This must come before we evaluate the returned value below, because that evalulation may cause RTL to be generated. */ +#ifndef INLINER_FOR_JAVA COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), build_stmt (LABEL_STMT, id->ret_label)); +#else /* INLINER_FOR_JAVA */ + { + tree label = build1 (LABEL_EXPR, void_type_node, id->ret_label); + BLOCK_EXPR_BODY (expr) + = add_stmt_to_compound (BLOCK_EXPR_BODY (expr), void_type_node, label); + TREE_SIDE_EFFECTS (label) = TREE_SIDE_EFFECTS (t); + } +#endif /* INLINER_FOR_JAVA */ /* Finally, mention the returned value so that the value of the statement-expression is the returned value of the function. */ +#ifndef INLINER_FOR_JAVA COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), use_stmt); - + /* Close the block for the parameters. */ scope_stmt = build_stmt (SCOPE_STMT, DECL_INITIAL (fn)); SCOPE_NO_CLEANUPS_P (scope_stmt) = 1; remap_block (scope_stmt, NULL_TREE, id); COMPOUND_BODY (stmt) = chainon (COMPOUND_BODY (stmt), scope_stmt); +#else /* INLINER_FOR_JAVA */ + if (retvar) + { + /* Mention the retvar. If the return type of the function was + promoted, convert it back to the expected type. */ + if (TREE_TYPE (TREE_TYPE (fn)) != TREE_TYPE (retvar)) + retvar = build1 (NOP_EXPR, TREE_TYPE (TREE_TYPE (fn)), retvar); + BLOCK_EXPR_BODY (expr) + = add_stmt_to_compound (BLOCK_EXPR_BODY (expr), + TREE_TYPE (retvar), retvar); + } + + java_inlining_merge_static_initializers (fn, id->decl_map); +#endif /* INLINER_FOR_JAVA */ /* Clean up. */ splay_tree_delete (id->decl_map); @@ -955,11 +1374,19 @@ expand_call_inline (tp, walk_subtrees, data) /* Replace the call by the inlined body. Wrap it in an EXPR_WITH_FILE_LOCATION so that we'll get debugging line notes pointing to the right place. */ +#ifndef INLINER_FOR_JAVA chain = TREE_CHAIN (*tp); *tp = build_expr_wfl (expr, DECL_SOURCE_FILE (fn), DECL_SOURCE_LINE (fn), /*col=*/0); +#else /* INLINER_FOR_JAVA */ + *tp = build_expr_wfl (expr, DECL_SOURCE_FILE (fn), + DECL_SOURCE_LINE_FIRST(fn), + /*col=*/0); +#endif /* INLINER_FOR_JAVA */ EXPR_WFL_EMIT_LINE_NOTE (*tp) = 1; +#ifndef INLINER_FOR_JAVA TREE_CHAIN (*tp) = chain; +#endif /* not INLINER_FOR_JAVA */ pop_srcloc (); /* If the value of the new expression is ignored, that's OK. We @@ -969,7 +1396,8 @@ expand_call_inline (tp, walk_subtrees, data) /* Our function now has more statements than it did before. */ DECL_NUM_STMTS (VARRAY_TREE (id->fns, 0)) += DECL_NUM_STMTS (fn); - id->inlined_stmts += DECL_NUM_STMTS (fn); + /* For accounting, subtract one for the saved call/ret. */ + id->inlined_stmts += DECL_NUM_STMTS (fn) - 1; /* Recurse into the body of the just inlined function. */ expand_calls_inline (inlined_body, id); @@ -988,7 +1416,6 @@ expand_call_inline (tp, walk_subtrees, data) /* Keep iterating. */ return NULL_TREE; } - /* Walk over the entire tree *TP, replacing CALL_EXPRs with inline expansions as appropriate. */ @@ -1014,7 +1441,7 @@ optimize_inline_calls (fn) { inline_data id; tree prev_fn; - + /* Clear out ID. */ memset (&id, 0, sizeof (id)); @@ -1031,7 +1458,7 @@ optimize_inline_calls (fn) prev_fn = ((*lang_hooks.tree_inlining.add_pending_fn_decls) (&id.fns, prev_fn)); - + /* Create the stack of TARGET_EXPRs. */ VARRAY_TREE_INIT (id.target_exprs, 32, "target_exprs"); @@ -1050,17 +1477,15 @@ optimize_inline_calls (fn) /* Clean up. */ htab_delete (id.tree_pruner); - VARRAY_FREE (id.fns); - VARRAY_FREE (id.target_exprs); if (DECL_LANG_SPECIFIC (fn)) { tree ifn = make_tree_vec (VARRAY_ACTIVE_SIZE (id.inlined_fns)); - - memcpy (&TREE_VEC_ELT (ifn, 0), &VARRAY_TREE (id.inlined_fns, 0), - VARRAY_ACTIVE_SIZE (id.inlined_fns) * sizeof (tree)); + + if (VARRAY_ACTIVE_SIZE (id.inlined_fns)) + memcpy (&TREE_VEC_ELT (ifn, 0), &VARRAY_TREE (id.inlined_fns, 0), + VARRAY_ACTIVE_SIZE (id.inlined_fns) * sizeof (tree)); DECL_INLINED_FNS (fn) = ifn; } - VARRAY_FREE (id.inlined_fns); } /* FN is a function that has a complete body, and CLONE is a function @@ -1090,9 +1515,6 @@ clone_body (clone, fn, arg_map) /* Actually copy the body. */ TREE_CHAIN (DECL_SAVED_TREE (clone)) = copy_body (&id); - - /* Clean up. */ - VARRAY_FREE (id.fns); } /* Apply FUNC to all the sub-trees of TP in a pre-order traversal. @@ -1102,7 +1524,7 @@ clone_body (clone, fn, arg_map) to record the nodes visited, and to avoid visiting a node more than once. */ -tree +tree walk_tree (tp, func, data, htab_) tree *tp; walk_tree_fn func; @@ -1113,7 +1535,7 @@ walk_tree (tp, func, data, htab_) enum tree_code code; int walk_subtrees; tree result; - + #define WALK_SUBTREE(NODE) \ do \ { \ @@ -1139,13 +1561,12 @@ walk_tree (tp, func, data, htab_) if (htab) { void **slot; - + /* Don't walk the same tree twice, if the user has requested that we avoid doing so. */ - if (htab_find (htab, *tp)) - return NULL_TREE; - /* If we haven't already seen this node, add it to the table. */ slot = htab_find_slot (htab, *tp, INSERT); + if (*slot) + return NULL_TREE; *slot = *tp; } @@ -1159,6 +1580,7 @@ walk_tree (tp, func, data, htab_) code = TREE_CODE (*tp); +#ifndef INLINER_FOR_JAVA /* Even if we didn't, FUNC may have decided that there was nothing interesting below this point in the tree. */ if (!walk_subtrees) @@ -1175,13 +1597,22 @@ walk_tree (tp, func, data, htab_) if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)) || TREE_CODE_CLASS (code) == 'r' || TREE_CODE_CLASS (code) == 's') +#else /* INLINER_FOR_JAVA */ + if (code != EXIT_BLOCK_EXPR + && code != SAVE_EXPR + && (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)) + || TREE_CODE_CLASS (code) == 'r' + || TREE_CODE_CLASS (code) == 's')) +#endif /* INLINER_FOR_JAVA */ { int i, len; +#ifndef INLINER_FOR_JAVA /* Set lineno here so we get the right instantiation context if we call instantiate_decl from inlinable_function_p. */ if (statement_code_p (code) && !STMT_LINENO_FOR_FN_P (*tp)) lineno = STMT_LINENO (*tp); +#endif /* not INLINER_FOR_JAVA */ /* Walk over all the sub-trees of this operand. */ len = first_rtl_op (code); @@ -1195,12 +1626,13 @@ walk_tree (tp, func, data, htab_) for (i = 0; i < len; ++i) WALK_SUBTREE (TREE_OPERAND (*tp, i)); +#ifndef INLINER_FOR_JAVA /* For statements, we also walk the chain so that we cover the entire statement tree. */ if (statement_code_p (code)) { - if (code == DECL_STMT - && DECL_STMT_DECL (*tp) + if (code == DECL_STMT + && DECL_STMT_DECL (*tp) && DECL_P (DECL_STMT_DECL (*tp))) { /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk @@ -1217,6 +1649,7 @@ walk_tree (tp, func, data, htab_) WALK_SUBTREE_TAIL (TREE_CHAIN (*tp)); } +#endif /* not INLINER_FOR_JAVA */ /* We didn't find what we were looking for. */ return NULL_TREE; } @@ -1255,6 +1688,7 @@ walk_tree (tp, func, data, htab_) case ENUMERAL_TYPE: case BLOCK: case RECORD_TYPE: + case CHAR_TYPE: /* None of thse have subtrees other than those already walked above. */ break; @@ -1318,6 +1752,14 @@ walk_tree (tp, func, data, htab_) WALK_SUBTREE (TREE_TYPE (*tp)); WALK_SUBTREE_TAIL (TYPE_OFFSET_BASETYPE (*tp)); +#ifdef INLINER_FOR_JAVA + case EXIT_BLOCK_EXPR: + WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 1)); + + case SAVE_EXPR: + WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0)); +#endif /* INLINER_FOR_JAVA */ + default: abort (); } @@ -1329,10 +1771,10 @@ walk_tree (tp, func, data, htab_) #undef WALK_SUBTREE_TAIL } -/* Like walk_tree, but does not walk duplicate nodes more than +/* Like walk_tree, but does not walk duplicate nodes more than once. */ -tree +tree walk_tree_without_duplicates (tp, func, data) tree *tp; walk_tree_fn func; @@ -1376,6 +1818,7 @@ copy_tree_r (tp, walk_subtrees, data) /* Now, restore the chain, if appropriate. That will cause walk_tree to walk into the chain as well. */ if (code == PARM_DECL || code == TREE_LIST +#ifndef INLINER_FOR_JAVA || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp) || statement_code_p (code)) TREE_CHAIN (*tp) = chain; @@ -1384,6 +1827,10 @@ copy_tree_r (tp, walk_subtrees, data) have to nullify all scope-statements. */ if (TREE_CODE (*tp) == SCOPE_STMT) SCOPE_STMT_BLOCK (*tp) = NULL_TREE; +#else /* INLINER_FOR_JAVA */ + || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp)) + TREE_CHAIN (*tp) = chain; +#endif /* INLINER_FOR_JAVA */ } else if (TREE_CODE_CLASS (code) == 't' && !variably_modified_type_p (*tp)) /* Types only need to be copied if they are variably modified. */ @@ -1409,7 +1856,7 @@ remap_save_expr (tp, st_, fn, walk_subtrees) /* See if we already encountered this SAVE_EXPR. */ n = splay_tree_lookup (st, (splay_tree_key) *tp); - + /* If we didn't already remap this SAVE_EXPR, do so now. */ if (!n) { @@ -1436,3 +1883,21 @@ remap_save_expr (tp, st_, fn, walk_subtrees) /* Replace this SAVE_EXPR with the copy. */ *tp = (tree) n->value; } + +#ifdef INLINER_FOR_JAVA +/* Add STMT to EXISTING if possible, otherwise create a new + COMPOUND_EXPR and add STMT to it. */ + +static tree +add_stmt_to_compound (existing, type, stmt) + tree existing, type, stmt; +{ + if (!stmt) + return existing; + else if (existing) + return build (COMPOUND_EXPR, type, existing, stmt); + else + return stmt; +} + +#endif /* INLINER_FOR_JAVA */ |