int in_target_cleanup_p;
/* A list of the functions current function has inlined. */
varray_type inlined_fns;
- /* The approximate number of statements we have inlined in the
+ /* The approximate number of instructions we have inlined in the
current call stack. */
- int inlined_stmts;
+ int inlined_insns;
/* We use the same mechanism to build clones that we do to perform
inlining. However, there are a few places where we need to
distinguish between those two situations. This flag is true if
htab_t tree_pruner;
/* Decl of function we are inlining into. */
tree decl;
+ tree current_decl;
} inline_data;
/* Prototypes. */
-static tree declare_return_variable PARAMS ((inline_data *, tree, tree *));
-static tree copy_body_r PARAMS ((tree *, int *, void *));
-static tree copy_body PARAMS ((inline_data *));
-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 *, int));
-static tree remap_decl PARAMS ((tree, inline_data *));
+static tree declare_return_variable (inline_data *, tree, tree *);
+static tree copy_body_r (tree *, int *, void *);
+static tree copy_body (inline_data *);
+static tree expand_call_inline (tree *, int *, void *);
+static void expand_calls_inline (tree *, inline_data *);
+static bool inlinable_function_p (tree);
+static int limits_allow_inlining (tree, inline_data *);
+static tree remap_decl (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 *));
+static tree initialize_inlined_parameters (inline_data *, tree, tree);
+static void remap_block (tree, tree, inline_data *);
+static void copy_scope_stmt (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));
+static tree initialize_inlined_parameters (inline_data *, tree, tree, tree);
+static void remap_block (tree *, tree, inline_data *);
+static tree add_stmt_to_compound (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
- decisions about when a function is too big to inline. */
-#define INSNS_PER_STMT (10)
+static tree find_alloca_call_1 (tree *, int *, void *);
+static tree find_alloca_call (tree);
+static tree find_builtin_longjmp_call_1 (tree *, int *, void *);
+static tree find_builtin_longjmp_call (tree);
/* Remap DECL during the copying of the BLOCK tree for the function. */
static tree
-remap_decl (decl, id)
- tree decl;
- inline_data *id;
+remap_decl (tree decl, inline_data *id)
{
splay_tree_node n;
tree fn;
static void
#ifndef INLINER_FOR_JAVA
-remap_block (scope_stmt, decls, id)
- tree scope_stmt;
+remap_block (tree scope_stmt, tree decls, inline_data *id)
#else /* INLINER_FOR_JAVA */
-remap_block (block, decls, id)
- tree *block;
+remap_block (tree *block, tree decls, inline_data *id)
#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
/* Copy the SCOPE_STMT pointed to by TP. */
static void
-copy_scope_stmt (tp, walk_subtrees, id)
- tree *tp;
- int *walk_subtrees;
- inline_data *id;
+copy_scope_stmt (tree *tp, int *walk_subtrees, inline_data *id)
{
tree block;
/* Called from copy_body via walk_tree. DATA is really an
`inline_data *'. */
static tree
-copy_body_r (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees;
- void *data;
+copy_body_r (tree *tp, int *walk_subtrees, void *data)
{
inline_data* id;
tree fn;
another function. */
static tree
-copy_body (id)
- inline_data *id;
+copy_body (inline_data *id)
{
tree body;
static tree
#ifndef INLINER_FOR_JAVA
-initialize_inlined_parameters (id, args, fn)
+initialize_inlined_parameters (inline_data *id, tree args, tree 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;
+initialize_inlined_parameters (inline_data *id, tree args, tree fn, tree block)
#endif /* INLINER_FOR_JAVA */
{
tree init_stmts;
#ifndef INLINER_FOR_JAVA
static tree
-declare_return_variable (id, return_slot_addr, use_stmt)
- struct inline_data *id;
- tree return_slot_addr;
- tree *use_stmt;
+declare_return_variable (struct inline_data *id, tree return_slot_addr,
+ tree *use_stmt)
#else /* INLINER_FOR_JAVA */
static tree
-declare_return_variable (id, return_slot_addr, var)
- struct inline_data *id;
- tree return_slot_addr;
- tree *var;
+declare_return_variable (struct inline_data *id, tree return_slot_addr,
+ tree *var)
#endif /* INLINER_FOR_JAVA */
{
tree fn = VARRAY_TOP_TREE (id->fns);
/* Returns nonzero if a function can be inlined as a tree. */
-int
-tree_inlinable_function_p (fn, nolimit)
- tree fn;
- int nolimit;
+bool
+tree_inlinable_function_p (tree fn)
{
- return inlinable_function_p (fn, NULL, nolimit);
+ return inlinable_function_p (fn);
}
/* 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;
+find_alloca_call_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
if (alloca_call_p (*tp))
return *tp;
/* Return subexpression representing possible alloca call, if any. */
static tree
-find_alloca_call (exp)
- tree exp;
+find_alloca_call (tree exp)
{
location_t saved_loc = input_location;
- tree ret = walk_tree (&exp, find_alloca_call_1, NULL, NULL);
+ tree ret = walk_tree_without_duplicates
+ (&exp, find_alloca_call_1, NULL);
input_location = saved_loc;
return ret;
}
static tree
-find_builtin_longjmp_call_1 (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+find_builtin_longjmp_call_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
tree exp = *tp, decl;
}
static tree
-find_builtin_longjmp_call (exp)
- tree exp;
+find_builtin_longjmp_call (tree exp)
{
location_t saved_loc = input_location;
- tree ret = walk_tree (&exp, find_builtin_longjmp_call_1, NULL, NULL);
+ tree ret = walk_tree_without_duplicates
+ (&exp, find_builtin_longjmp_call_1, NULL);
input_location = saved_loc;
return ret;
}
-/* 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. */
+/* Returns nonzero if FN is a function that does not have any
+ fundamental inline blocking properties. */
-static int
-inlinable_function_p (fn, id, nolimit)
- tree fn;
- inline_data *id;
- int nolimit;
+static bool
+inlinable_function_p (tree fn)
{
- int inlinable;
- int currfn_insns;
- int max_inline_insns_single = MAX_INLINE_INSNS_SINGLE;
+ bool inlinable = true;
+ bool calls_builtin_longjmp = false;
+ bool calls_alloca = false;
/* If we've already decided this function shouldn't be inlined,
there's no need to check again. */
if (DECL_UNINLINABLE (fn))
- return 0;
+ return false;
/* See if there is any language-specific reason it cannot be
inlined. (It is important that this hook be called early because
- in C++ it may result in template instantiation.) */
+ in C++ it may result in template instantiation.)
+ If the function is not inlinable for language-specific reasons,
+ it is left up to the langhook to explain why. */
inlinable = !(*lang_hooks.tree_inlining.cannot_inline_tree_fn) (&fn);
-
- /* 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)
- inlinable = 0;
- /* If we're not inlining all functions and the function was not
- declared `inline', we don't inline it. Don't think of
- disregarding DECL_INLINE when flag_inline_trees == 2; it's the
- front-end that must set DECL_INLINE in this case, because
- dwarf2out loses if a function is inlined that doesn't have
- DECL_INLINE set. */
- else if (! DECL_INLINE (fn) && !nolimit)
- inlinable = 0;
+
+ /* If we don't have the function body available, we can't inline it.
+ However, this should not be recorded since we also get here for
+ forward declared inline functions. Therefore, return at once. */
+ if (!DECL_SAVED_TREE (fn))
+ return false;
+
+ /* If we're not inlining at all, then we cannot inline this function. */
+ else if (!flag_inline_trees)
+ inlinable = false;
+
+ /* Only try to inline functions if DECL_INLINE is set. This should be
+ true for all functions declared `inline', and for all other functions
+ as well with -finline-functions.
+
+ Don't think of disregarding DECL_INLINE when flag_inline_trees == 2;
+ it's the front-end that must set DECL_INLINE in this case, because
+ dwarf2out loses if a function that does not have DECL_INLINE set is
+ inlined anyway. That is why we have both DECL_INLINE and
+ DECL_DECLARED_INLINE_P. */
+ /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time
+ here should be redundant. */
+ else if (!DECL_INLINE (fn) && !flag_unit_at_a_time)
+ inlinable = false;
+
#ifdef INLINER_FOR_JAVA
/* Synchronized methods can't be inlined. This is a bug. */
else if (METHOD_SYNCHRONIZED (fn))
- inlinable = 0;
+ inlinable = false;
#endif /* INLINER_FOR_JAVA */
- /* We can't inline functions that are too big. Only allow a single
- function to be of MAX_INLINE_INSNS_SINGLE size. Make special
- allowance for extern inline functions, though. */
- else if (!nolimit
- && ! (*lang_hooks.tree_inlining.disregard_inline_limits) (fn)
- && currfn_insns > max_inline_insns_single)
- inlinable = 0;
+
/* We can't inline functions that call __builtin_longjmp at all.
- The non-local goto machenery really requires the destination
+ The non-local goto machinery 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)))
- inlinable = 0;
- /* 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. */
+ calls_builtin_longjmp = true;
+
+ /* 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)))
- inlinable = 0;
+ calls_alloca = true;
- /* Squirrel away the result so that we don't have to check again. */
- DECL_UNINLINABLE (fn) = ! inlinable;
-
- /* 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)
- && inlinable && !nolimit)
+ if (calls_builtin_longjmp || calls_alloca)
{
- 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;
- }
+ /* See if we should warn about uninlinable functions. Previously,
+ some of these warnings would be issued while trying to expand
+ the function inline, but that would cause multiple warnings
+ about functions that would for example call alloca. But since
+ this a property of the function, just one warning is enough.
+ As a bonus we can now give more details about the reason why a
+ function is not inlinable.
+ We only warn for functions declared `inline' by the user. */
+ bool do_warning = (warn_inline
+ && DECL_INLINE (fn)
+ && DECL_DECLARED_INLINE_P (fn)
+ && !DECL_IN_SYSTEM_HEADER (fn));
+
+ if (do_warning && calls_builtin_longjmp)
+ warning ("%Hfunction '%F' can never be inlined because it uses "
+ "setjmp-longjmp exception handling",
+ &DECL_SOURCE_LOCATION (fn), fn);
+ if (do_warning && calls_alloca)
+ warning ("%Hfunction '%F' can never be inlined because it uses "
+ "setjmp-longjmp exception handling",
+ &DECL_SOURCE_LOCATION (fn), fn);
+
+ inlinable = false;
}
- /* If we don't have the function body available, we can't inline
- it. */
- if (! DECL_SAVED_TREE (fn))
- inlinable = 0;
+ /* Squirrel away the result so that we don't have to check again. */
+ DECL_UNINLINABLE (fn) = !inlinable;
+
+ return inlinable;
+}
+
+/* We can't inline functions that are too big. Only allow a single
+ function to be of MAX_INLINE_INSNS_SINGLE size. Make special
+ allowance for extern inline functions, though.
+
+ Return nonzero if the function FN can be inlined into the inlining
+ context ID. */
- /* Check again, language hooks may have modified it. */
- if (! inlinable || DECL_UNINLINABLE (fn))
+static int
+limits_allow_inlining (tree fn, inline_data *id)
+{
+ int estimated_insns = 0;
+ size_t i;
+
+ /* Don't even bother if the function is not inlinable. */
+ if (!inlinable_function_p (fn))
return 0;
- /* Don't do recursive inlining, either. We don't record this in
- DECL_UNINLINABLE; we may be able to inline this function later. */
- if (id)
+ /* Investigate the size of the function. Return at once
+ if the function body size is too large. */
+ if (!(*lang_hooks.tree_inlining.disregard_inline_limits) (fn))
{
- size_t i;
+ int currfn_max_inline_insns;
+
+ /* If we haven't already done so, get an estimate of the number of
+ instructions that will be produces when expanding this function. */
+ if (!DECL_ESTIMATED_INSNS (fn))
+ DECL_ESTIMATED_INSNS (fn)
+ = (*lang_hooks.tree_inlining.estimate_num_insns) (fn);
+ estimated_insns = DECL_ESTIMATED_INSNS (fn);
+
+ /* We may be here either because fn is declared inline or because
+ we use -finline-functions. For the second case, we are more
+ restrictive.
+
+ FIXME: -finline-functions should imply -funit-at-a-time, it's
+ about equally expensive but unit-at-a-time produces
+ better code. */
+ currfn_max_inline_insns = DECL_DECLARED_INLINE_P (fn) ?
+ MAX_INLINE_INSNS_SINGLE : MAX_INLINE_INSNS_AUTO;
+
+ /* If the function is too big to be inlined, adieu. */
+ if (estimated_insns > currfn_max_inline_insns)
+ return 0;
+
+ /* We now know that we don't disregard the inlining limits and that
+ we basically should be able to inline this function.
+ We always allow inlining functions if we estimate that they are
+ smaller than MIN_INLINE_INSNS. Otherwise, investigate further. */
+ if (estimated_insns > MIN_INLINE_INSNS)
+ {
+ int sum_insns = (id ? id->inlined_insns : 0) + estimated_insns;
- for (i = 0; i < VARRAY_ACTIVE_SIZE (id->fns); ++i)
- if (VARRAY_TREE (id->fns, i) == fn)
- return 0;
+ /* In the extreme case that we have exceeded the recursive inlining
+ limit by a huge factor (128), we just say no.
- if (DECL_INLINED_FNS (fn))
- {
- int j;
- tree inlined_fns = DECL_INLINED_FNS (fn);
+ FIXME: Should not happen in real life, but people have reported
+ that it actually does!? */
+ if (sum_insns > MAX_INLINE_INSNS * 128)
+ return 0;
- for (j = 0; j < TREE_VEC_LENGTH (inlined_fns); ++j)
- if (TREE_VEC_ELT (inlined_fns, j) == VARRAY_TREE (id->fns, 0))
- return 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. */
+ else if (sum_insns > MAX_INLINE_INSNS)
+ {
+ if (estimated_insns > currfn_max_inline_insns
+ - (sum_insns - MAX_INLINE_INSNS) / MAX_INLINE_SLOPE)
+ return 0;
+ }
}
}
- /* Return the result. */
- return inlinable;
+ /* Don't allow recursive inlining. */
+ for (i = 0; i < VARRAY_ACTIVE_SIZE (id->fns); ++i)
+ if (VARRAY_TREE (id->fns, i) == fn)
+ return 0;
+
+ if (DECL_INLINED_FNS (fn))
+ {
+ int j;
+ tree inlined_fns = DECL_INLINED_FNS (fn);
+
+ for (j = 0; j < TREE_VEC_LENGTH (inlined_fns); ++j)
+ if (TREE_VEC_ELT (inlined_fns, j) == VARRAY_TREE (id->fns, 0))
+ return 0;
+ }
+
+ /* Go ahead, this function can be inlined. */
+ return 1;
}
/* If *TP is a CALL_EXPR, replace it with its inline expansion. */
static tree
-expand_call_inline (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees;
- void *data;
+expand_call_inline (tree *tp, int *walk_subtrees, void *data)
{
inline_data *id;
tree t;
*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,
+ walk_tree (&EXPR_WFL_NODE (t), expand_call_inline, data,
id->tree_pruner);
/* Restore the original source position. */
pop_srcloc ();
if (!fn)
return NULL_TREE;
+ /* Turn forward declarations into real ones. */
+ if (flag_unit_at_a_time)
+ fn = cgraph_node (fn)->decl;
+
/* If fn is a declaration of a function in a nested scope that was
globally declared inline, we don't set its DECL_INITIAL.
However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the
/* Don't try to inline functions that are not well-suited to
inlining. */
- if ((!flag_unit_at_a_time || !DECL_SAVED_TREE (fn)
- || !cgraph_global_info (fn)->inline_once)
- && !inlinable_function_p (fn, id, 0))
+ if ((flag_unit_at_a_time
+ && (!DECL_SAVED_TREE (fn) || !cgraph_inline_p (id->current_decl, fn)))
+ || (!flag_unit_at_a_time && !limits_allow_inlining (fn, id)))
{
- if (warn_inline && DECL_INLINE (fn) && !DID_INLINE_FUNC (fn)
+ if (warn_inline && DECL_INLINE (fn) && DECL_DECLARED_INLINE_P (fn)
&& !DECL_IN_SYSTEM_HEADER (fn))
{
- warning_with_decl (fn, "inlining failed in call to `%s'");
+ warning ("%Hinlining failed in call to '%F'",
+ &DECL_SOURCE_LOCATION (fn), fn);
warning ("called from here");
}
return NULL_TREE;
TREE_USED (*tp) = 1;
/* Our function now has more statements than it did before. */
- DECL_NUM_STMTS (VARRAY_TREE (id->fns, 0)) += DECL_NUM_STMTS (fn);
+ DECL_ESTIMATED_INSNS (VARRAY_TREE (id->fns, 0)) += DECL_ESTIMATED_INSNS (fn);
/* For accounting, subtract one for the saved call/ret. */
- id->inlined_stmts += DECL_NUM_STMTS (fn) - 1;
+ id->inlined_insns += DECL_ESTIMATED_INSNS (fn) - 1;
/* Update callgraph if needed. */
if (id->decl && flag_unit_at_a_time)
}
/* Recurse into the body of the just inlined function. */
- expand_calls_inline (inlined_body, id);
+ {
+ tree old_decl = id->current_decl;
+ id->current_decl = fn;
+ expand_calls_inline (inlined_body, id);
+ id->current_decl = old_decl;
+ }
VARRAY_POP (id->fns);
/* If we've returned to the top level, clear out the record of how
much inlining has been done. */
if (VARRAY_ACTIVE_SIZE (id->fns) == id->first_inlined_fn)
- id->inlined_stmts = 0;
+ id->inlined_insns = 0;
/* Don't walk into subtrees. We've already handled them above. */
*walk_subtrees = 0;
expansions as appropriate. */
static void
-expand_calls_inline (tp, id)
- tree *tp;
- inline_data *id;
+expand_calls_inline (tree *tp, inline_data *id)
{
/* Search through *TP, replacing all calls to inline functions by
appropriate equivalents. Use walk_tree in no-duplicates mode
/* Expand calls to inline functions in the body of FN. */
void
-optimize_inline_calls (fn)
- tree fn;
+optimize_inline_calls (tree fn)
{
inline_data id;
tree prev_fn;
memset (&id, 0, sizeof (id));
id.decl = fn;
+ id.current_decl = fn;
/* Don't allow recursion into FN. */
VARRAY_TREE_INIT (id.fns, 32, "fns");
VARRAY_PUSH_TREE (id.fns, fn);
+ if (!DECL_ESTIMATED_INSNS (fn))
+ DECL_ESTIMATED_INSNS (fn)
+ = (*lang_hooks.tree_inlining.estimate_num_insns) (fn);
/* Or any functions that aren't finished yet. */
prev_fn = NULL_TREE;
if (current_function_decl)
declarations according to the ARG_MAP splay_tree. */
void
-clone_body (clone, fn, arg_map)
- tree clone, fn;
- void *arg_map;
+clone_body (tree clone, tree fn, void *arg_map)
{
inline_data id;
once. */
tree
-walk_tree (tp, func, data, htab_)
- tree *tp;
- walk_tree_fn func;
- void *data;
- void *htab_;
+walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_)
{
htab_t htab = (htab_t) htab_;
enum tree_code code;
}
/* Handle common cases up front. */
- if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
- || TREE_CODE_CLASS (code) == 'r'
- || TREE_CODE_CLASS (code) == 's')
+ if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
#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'))
+ && IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
#endif /* INLINER_FOR_JAVA */
{
int i, len;
once. */
tree
-walk_tree_without_duplicates (tp, func, data)
- tree *tp;
- walk_tree_fn func;
- void *data;
+walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
{
tree result;
htab_t htab;
/* Passed to walk_tree. Copies the node pointed to, if appropriate. */
tree
-copy_tree_r (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees;
- void *data ATTRIBUTE_UNUSED;
+copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{
enum tree_code code = TREE_CODE (*tp);
/* We make copies of most nodes. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
- || TREE_CODE_CLASS (code) == 'r'
|| TREE_CODE_CLASS (code) == 'c'
- || TREE_CODE_CLASS (code) == 's'
|| code == TREE_LIST
|| code == TREE_VEC
|| (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp))
ST. FN is the function into which the copy will be placed. */
void
-remap_save_expr (tp, st_, fn, walk_subtrees)
- tree *tp;
- void *st_;
- tree fn;
- int *walk_subtrees;
+remap_save_expr (tree *tp, void *st_, tree fn, int *walk_subtrees)
{
splay_tree st = (splay_tree) st_;
splay_tree_node n;
COMPOUND_EXPR and add STMT to it. */
static tree
-add_stmt_to_compound (existing, type, stmt)
- tree existing, type, stmt;
+add_stmt_to_compound (tree existing, tree type, tree stmt)
{
if (!stmt)
return existing;
OSDN Git Service
