#include "integrate.h"
#include "varray.h"
#include "hashtab.h"
+#include "pointer-set.h"
#include "splay-tree.h"
#include "langhooks.h"
#include "cgraph.h"
static tree remap_decls (tree, inline_data *);
static void copy_bind_expr (tree *, int *, inline_data *);
static tree mark_local_for_remap_r (tree *, int *, void *);
+static void unsave_expr_1 (tree);
static tree unsave_r (tree *, int *, void *);
static void declare_inline_vars (tree bind_expr, tree vars);
+static void remap_save_expr (tree *, void *, int *);
/* Insert a tree->tree mapping for ID. Despite the name suggests
that the trees should be variables, it is used for more than that. */
walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL);
walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL);
- /* If fields, do likewise for offset and qualifier. */
+ /* If fields, do likewise for offset and qualifier. */
if (TREE_CODE (t) == FIELD_DECL)
{
walk_tree (&DECL_FIELD_OFFSET (t), copy_body_r, id, NULL);
{
tree member = remap_decl (TREE_VALUE (src), id);
- if (TREE_PURPOSE (src))
- abort ();
+ gcc_assert (!TREE_PURPOSE (src));
members = tree_cons (NULL, member, members);
}
DECL_ANON_UNION_ELEMS (t) = nreverse (members);
case OFFSET_TYPE:
default:
/* Shouldn't have been thought variable sized. */
- abort ();
+ gcc_unreachable ();
}
walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
already declared somewhere else, so don't declare it here. */
if (!new_var || new_var == id->retvar)
;
-#ifdef ENABLE_CHECKING
- else if (!DECL_P (new_var))
- abort ();
-#endif
else
{
+ gcc_assert (DECL_P (new_var));
TREE_CHAIN (new_var) = new_decls;
new_decls = new_var;
}
what function they come from. */
if ((TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == LABEL_DECL)
&& DECL_NAMESPACE_SCOPE_P (*tp))
- if (! DECL_EXTERNAL (*tp) && ! TREE_STATIC (*tp))
- abort ();
+ gcc_assert (DECL_EXTERNAL (*tp) || TREE_STATIC (*tp));
#endif
/* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
/* Remap the declaration. */
new_decl = remap_decl (*tp, id);
- if (! new_decl)
- abort ();
+ gcc_assert (new_decl);
/* Replace this variable with the copy. */
STRIP_TYPE_NOPS (new_decl);
*tp = new_decl;
}
-#if 0
- else if (nonstatic_local_decl_p (*tp)
- && DECL_CONTEXT (*tp) != VARRAY_TREE (id->fns, 0))
- abort ();
-#endif
else if (TREE_CODE (*tp) == STATEMENT_LIST)
copy_statement_list (tp);
else if (TREE_CODE (*tp) == SAVE_EXPR)
remap_save_expr (tp, id->decl_map, walk_subtrees);
else if (TREE_CODE (*tp) == BIND_EXPR)
copy_bind_expr (tp, walk_subtrees, id);
- 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);
- insert_decl_map (id, *tp, 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;
- }
/* Types may need remapping as well. */
else if (TYPE_P (*tp))
*tp = remap_type (*tp, id);
+ /* If this is a constant, we have to copy the node iff the type will be
+ remapped. copy_tree_r will not copy a constant. */
+ else if (TREE_CODE_CLASS (TREE_CODE (*tp)) == tcc_constant)
+ {
+ tree new_type = remap_type (TREE_TYPE (*tp), id);
+
+ if (new_type == TREE_TYPE (*tp))
+ *walk_subtrees = 0;
+
+ else if (TREE_CODE (*tp) == INTEGER_CST)
+ *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp),
+ TREE_INT_CST_HIGH (*tp));
+ else
+ {
+ *tp = copy_node (*tp);
+ TREE_TYPE (*tp) = new_type;
+ }
+ }
+
/* Otherwise, just copy the node. Note that copy_tree_r already
knows not to copy VAR_DECLs, etc., so this is safe. */
else
STRIP_TYPE_NOPS (value);
if (TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
{
- *tp = value;
+ *tp = build_empty_stmt ();
return copy_body_r (tp, walk_subtrees, data);
}
}
for (node = id->node->next_clone; node; node = node->next_clone)
{
edge = cgraph_edge (node, old_node);
- if (edge)
- edge->call_expr = *tp;
- else
- abort ();
+ gcc_assert (edge);
+ edge->call_expr = *tp;
}
}
else
TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
TREE_OPERAND (*tp, 3) = NULL_TREE;
}
+
+ /* Variable substitution need not be simple. In particular, the
+ INDIRECT_REF substitution above. Make sure that TREE_CONSTANT
+ and friends are up-to-date. */
+ else if (TREE_CODE (*tp) == ADDR_EXPR)
+ {
+ walk_tree (&TREE_OPERAND (*tp, 0), copy_body_r, id, NULL);
+ recompute_tree_invarant_for_addr_expr (*tp);
+ *walk_subtrees = 0;
+ }
}
/* Keep iterating. */
/* Make an equivalent VAR_DECL. Note that we must NOT remap the type
here since the type of this decl must be visible to the calling
- function. */
+ function. */
var = copy_decl_for_inlining (p, fn, VARRAY_TREE (id->fns, 0));
/* Register the VAR_DECL as the equivalent for the PARM_DECL;
if (p)
{
/* No static chain? Seems like a bug in tree-nested.c. */
- if (!static_chain)
- abort ();
+ gcc_assert (static_chain);
- setup_one_parameter (id, p, static_chain, fn, &init_stmts, &vars,
- &gimplify_init_stmts_p);
+ setup_one_parameter (id, p, static_chain, fn, &init_stmts, &vars,
+ &gimplify_init_stmts_p);
}
if (gimplify_init_stmts_p)
{
/* The front end shouldn't have used both return_slot_addr and
a modify expression. */
- if (modify_dest)
- abort ();
+ gcc_assert (!modify_dest);
if (DECL_BY_REFERENCE (result))
var = return_slot_addr;
else
}
/* All types requiring non-trivial constructors should have been handled. */
- if (TREE_ADDRESSABLE (callee_type))
- abort ();
+ gcc_assert (!TREE_ADDRESSABLE (callee_type));
/* Attempt to avoid creating a new temporary variable. */
if (modify_dest)
}
}
- if (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) != INTEGER_CST)
- abort ();
+ gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
var = copy_decl_for_inlining (result, callee, caller);
DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
/* Do not have the rest of GCC warn about this variable as it should
- not be visible to the user. */
+ not be visible to the user. */
TREE_NO_WARNING (var) = 1;
/* Build the use expr. If the return type of the function was
&& !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
{
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined because it uses "
+ = N_("%Jfunction %qF can never be inlined because it uses "
"alloca (override using the always_inline attribute)");
return node;
}
if (setjmp_call_p (t))
{
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined because it uses setjmp");
+ = N_("%Jfunction %qF can never be inlined because it uses setjmp");
return node;
}
case BUILT_IN_NEXT_ARG:
case BUILT_IN_VA_END:
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined because it "
+ = N_("%Jfunction %qF can never be inlined because it "
"uses variable argument lists");
return node;
function calling __builtin_longjmp to be inlined into the
function calling __builtin_setjmp, Things will Go Awry. */
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined because "
+ = N_("%Jfunction %qF can never be inlined because "
"it uses setjmp-longjmp exception handling");
return node;
case BUILT_IN_NONLOCAL_GOTO:
/* Similarly. */
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined because "
+ = N_("%Jfunction %qF can never be inlined because "
"it uses non-local goto");
return node;
}
break;
- case BIND_EXPR:
- for (t = BIND_EXPR_VARS (node); t ; t = TREE_CHAIN (t))
- {
- /* We cannot inline functions that contain other functions. */
- if (TREE_CODE (t) == FUNCTION_DECL && DECL_INITIAL (t))
- {
- inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined "
- "because it contains a nested function");
- return node;
- }
- }
- break;
-
case GOTO_EXPR:
t = TREE_OPERAND (node, 0);
if (TREE_CODE (t) != LABEL_DECL)
{
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined "
+ = N_("%Jfunction %qF can never be inlined "
"because it contains a computed goto");
return node;
}
because we cannot remap the destination label used in the
function that is performing the non-local goto. */
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined "
+ = N_("%Jfunction %qF can never be inlined "
"because it receives a non-local goto");
return node;
}
UNION_TYPE nodes, then it goes into infinite recursion on a
structure containing a pointer to its own type. If it doesn't,
then the type node for S doesn't get adjusted properly when
- F is inlined, and we abort in find_function_data. */
+ F is inlined, and we abort in find_function_data.
+
+ ??? This is likely no longer true, but it's too late in the 4.0
+ cycle to try to find out. This should be checked for 4.1. */
for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
if (variably_modified_type_p (TREE_TYPE (t), NULL))
{
inline_forbidden_reason
- = N_("%Jfunction '%F' can never be inlined "
+ = N_("%Jfunction %qF can never be inlined "
"because it uses variable sized variables");
return node;
}
int *count = data;
tree x = *tp;
- if (TYPE_P (x) || DECL_P (x))
+ if (IS_TYPE_OR_DECL_P (x))
{
*walk_subtrees = 0;
return NULL;
/* Assume that constants and references counts nothing. These should
be majorized by amount of operations among them we count later
and are common target of CSE and similar optimizations. */
- else if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
- || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
+ else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x))
return NULL;
switch (TREE_CODE (x))
case FILTER_EXPR: /* ??? */
case COMPOUND_EXPR:
case BIND_EXPR:
- case LABELED_BLOCK_EXPR:
case WITH_CLEANUP_EXPR:
case NOP_EXPR:
case VIEW_CONVERT_EXPR:
case SAVE_EXPR:
case ADDR_EXPR:
case COMPLEX_EXPR:
- case EXIT_BLOCK_EXPR:
case CASE_LABEL_EXPR:
case SSA_NAME:
case CATCH_EXPR:
}
default:
/* Abort here se we know we don't miss any nodes. */
- abort ();
+ gcc_unreachable ();
}
return NULL;
}
where previous inlining turned indirect call into direct call by
constant propagating arguments. In all other cases we hit a bug
(incorrect node sharing is most common reason for missing edges. */
- if (!dest->needed)
- abort ();
+ gcc_assert (dest->needed || !flag_unit_at_a_time);
cgraph_create_edge (id->node, dest, t)->inline_failed
= N_("originally indirect function call not considered for inlining");
goto egress;
{
if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)))
{
- sorry ("%Jinlining failed in call to '%F': %s", fn, fn, reason);
+ sorry ("%Jinlining failed in call to %qF: %s", fn, fn, reason);
sorry ("called from here");
}
else if (warn_inline && DECL_DECLARED_INLINE_P (fn)
&& !DECL_IN_SYSTEM_HEADER (fn)
- && strlen (reason))
+ && strlen (reason)
+ && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn)))
{
- warning ("%Jinlining failed in call to '%F': %s", fn, fn, reason);
+ warning ("%Jinlining failed in call to %qF: %s", fn, fn, reason);
warning ("called from here");
}
goto egress;
DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
insert_decl_map (id, id->ret_label, id->ret_label);
- if (! DECL_INITIAL (fn)
- || TREE_CODE (DECL_INITIAL (fn)) != BLOCK)
- abort ();
+ gcc_assert (DECL_INITIAL (fn));
+ gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
/* Find the lhs to which the result of this call is assigned. */
modify_dest = tsi_stmt (id->tsi);
case COMPOUND_EXPR:
/* We're gimple. We should have gotten rid of all these. */
- abort ();
+ gcc_unreachable ();
case RETURN_EXPR:
stmt_p = &TREE_OPERAND (stmt, 0);
/* Double check that we inlined everything we are supposed to inline. */
for (e = id.node->callees; e; e = e->next_callee)
- if (!e->inline_failed)
- abort ();
+ gcc_assert (e->inline_failed);
}
#endif
}
#define WALK_SUBTREE(NODE) \
do \
{ \
- result = walk_tree (&(NODE), func, data, htab); \
+ result = walk_tree (&(NODE), func, data, pset); \
if (result) \
return result; \
} \
value are as for walk_tree. */
static tree
-walk_type_fields (tree type, walk_tree_fn func, void *data, void *htab)
+walk_type_fields (tree type, walk_tree_fn func, void *data,
+ struct pointer_set_t *pset)
{
tree result = NULL_TREE;
case POINTER_TYPE:
case REFERENCE_TYPE:
/* We have to worry about mutually recursive pointers. These can't
- be written in C. They can in Ada. It's pathlogical, but
+ be written in C. They can in Ada. It's pathological, but
there's an ACATS test (c38102a) that checks it. Deal with this
by checking if we're pointing to another pointer, that one
points to another pointer, that one does too, and we have no htab.
if (POINTER_TYPE_P (TREE_TYPE (type))
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
- && !htab)
+ && !pset)
{
result = walk_tree_without_duplicates (&TREE_TYPE (type),
func, data);
case ARRAY_TYPE:
/* Don't follow this nodes's type if a pointer for fear that we'll
- have infinite recursion. Those types are uninteresting anyway. */
+ have infinite recursion. Those types are uninteresting anyway. */
if (!POINTER_TYPE_P (TREE_TYPE (type))
&& TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE)
WALK_SUBTREE (TREE_TYPE (type));
/* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
called with the DATA and the address of each sub-tree. If FUNC returns a
non-NULL value, the traversal is aborted, and the value returned by FUNC
- is returned. If HTAB is non-NULL it is used to record the nodes visited,
+ is returned. If PSET is non-NULL it is used to record the nodes visited,
and to avoid visiting a node more than once. */
tree
-walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_)
+walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset)
{
- htab_t htab = (htab_t) htab_;
enum tree_code code;
int walk_subtrees;
tree result;
if (!*tp)
return NULL_TREE;
- if (htab)
- {
- void **slot;
-
- /* Don't walk the same tree twice, if the user has requested
- that we avoid doing so. */
- slot = htab_find_slot (htab, *tp, INSERT);
- if (*slot)
- return NULL_TREE;
- *slot = *tp;
- }
+ /* Don't walk the same tree twice, if the user has requested
+ that we avoid doing so. */
+ if (pset && pointer_set_insert (pset, *tp))
+ return NULL_TREE;
/* Call the function. */
walk_subtrees = 1;
}
result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func,
- data, htab);
+ data, pset);
if (result || ! walk_subtrees)
return result;
if (result || !walk_subtrees)
return NULL_TREE;
- result = walk_type_fields (*type_p, func, data, htab_);
+ result = walk_type_fields (*type_p, func, data, pset);
if (result)
return result;
}
}
- else if (code != EXIT_BLOCK_EXPR
- && code != SAVE_EXPR
+ else if (code != SAVE_EXPR
&& code != BIND_EXPR
&& IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
{
/* If this is a type, walk the needed fields in the type. */
else if (TYPE_P (*tp))
{
- result = walk_type_fields (*tp, func, data, htab_);
+ result = walk_type_fields (*tp, func, data, pset);
if (result)
return result;
}
case CONSTRUCTOR:
WALK_SUBTREE_TAIL (CONSTRUCTOR_ELTS (*tp));
- case EXIT_BLOCK_EXPR:
- WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 1));
-
case SAVE_EXPR:
WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
{
tree result;
- htab_t htab;
+ struct pointer_set_t *pset;
- htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
- result = walk_tree (tp, func, data, htab);
- htab_delete (htab);
+ pset = pointer_set_create ();
+ result = walk_tree (tp, func, data, pset);
+ pointer_set_destroy (pset);
return result;
}
/* We make copies of most nodes. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))
- || TREE_CODE_CLASS (code) == 'c'
|| code == TREE_LIST
|| code == TREE_VEC
|| code == TYPE_DECL)
BIND_EXPR_BLOCK (*tp) = NULL_TREE;
}
- else if (TREE_CODE_CLASS (code) == 't')
+ else if (TREE_CODE_CLASS (code) == tcc_type)
*walk_subtrees = 0;
- else if (TREE_CODE_CLASS (code) == 'd')
+ else if (TREE_CODE_CLASS (code) == tcc_declaration)
*walk_subtrees = 0;
- else if (code == STATEMENT_LIST)
- abort ();
-
+ else if (TREE_CODE_CLASS (code) == tcc_constant)
+ *walk_subtrees = 0;
+ else
+ gcc_assert (code != STATEMENT_LIST);
return NULL_TREE;
}
information indicating to what new SAVE_EXPR this one should be mapped,
use that one. Otherwise, create a new node and enter it in ST. */
-void
+static void
remap_save_expr (tree *tp, void *st_, int *walk_subtrees)
{
splay_tree st = (splay_tree) st_;
return NULL_TREE;
}
+/* Perform any modifications to EXPR required when it is unsaved. Does
+ not recurse into EXPR's subtrees. */
+
+static void
+unsave_expr_1 (tree expr)
+{
+ switch (TREE_CODE (expr))
+ {
+ case TARGET_EXPR:
+ /* Don't mess with a TARGET_EXPR that hasn't been expanded.
+ It's OK for this to happen if it was part of a subtree that
+ isn't immediately expanded, such as operand 2 of another
+ TARGET_EXPR. */
+ if (TREE_OPERAND (expr, 1))
+ break;
+
+ TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
+ TREE_OPERAND (expr, 3) = NULL_TREE;
+ break;
+
+ default:
+ break;
+ }
+}
+
/* Called via walk_tree when an expression is unsaved. Using the
splay_tree pointed to by ST (which is really a `splay_tree'),
remaps all local declarations to appropriate replacements. */
return NULL_TREE;
}
-/* Default lang hook for "unsave_expr_now". Copies everything in EXPR and
- replaces variables, labels and SAVE_EXPRs local to EXPR. */
+/* Copies everything in EXPR and replaces variables, labels
+ and SAVE_EXPRs local to EXPR. */
tree
-lhd_unsave_expr_now (tree expr)
+unsave_expr_now (tree expr)
{
inline_data id;
OSDN Git Service
