+ (PHI_ARG_CAPACITY (node) - 1) *
sizeof (struct phi_arg_d));
- case EPHI_NODE: return (sizeof (struct tree_ephi_node)
- + (EPHI_ARG_CAPACITY (node) - 1) *
- sizeof (struct ephi_arg_d));
-
case SSA_NAME: return sizeof (struct tree_ssa_name);
- case EUSE_NODE: return sizeof (struct tree_euse_node);
-
- case EKILL_NODE:
- case EEXIT_NODE: return sizeof (struct tree_eref_common);
case STATEMENT_LIST: return sizeof (struct tree_statement_list);
case BLOCK: return sizeof (struct tree_block);
+ case VALUE_HANDLE: return sizeof (struct tree_value_handle);
default:
return lang_hooks.tree_size (code);
#endif
struct tree_common ttmp;
- /* We can't allocate a TREE_VEC, PHI_NODE, EPHI_NODE or STRING_CST
+ /* We can't allocate a TREE_VEC, PHI_NODE, or STRING_CST
without knowing how many elements it will have. */
- if (code == TREE_VEC || code == PHI_NODE || code == EPHI_NODE)
+ if (code == TREE_VEC || code == PHI_NODE)
abort ();
TREE_SET_CODE ((tree)&ttmp, code);
case INIT_EXPR:
case MODIFY_EXPR:
case VA_ARG_EXPR:
- case RTL_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
if (contains_placeholder_p (inner))
return t;
- t = build3 (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl,
- NULL_TREE);
+ t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
/* This expression might be placed ahead of a jump to ensure that the
value was computed on both sides of the jump. So make sure it isn't
{
switch (code)
{
- case SAVE_EXPR:
- return 2;
case GOTO_SUBROUTINE_EXPR:
- case RTL_EXPR:
return 0;
case WITH_CLEANUP_EXPR:
return 2;
case TREE_LIST: return TS_LIST;
case TREE_VEC: return TS_VEC;
case PHI_NODE: return TS_PHI_NODE;
- case EPHI_NODE: return TS_EPHI_NODE;
- case EUSE_NODE: return TS_EUSE_NODE;
- case EKILL_NODE: return TS_EREF_NODE;
- case EEXIT_NODE: return TS_EREF_NODE;
case SSA_NAME: return TS_SSA_NAME;
case PLACEHOLDER_EXPR: return TS_COMMON;
case STATEMENT_LIST: return TS_STATEMENT_LIST;
case BLOCK: return TS_BLOCK;
+ case VALUE_HANDLE: return TS_VALUE_HANDLE;
default:
abort ();
{
switch (TREE_CODE (expr))
{
- case SAVE_EXPR:
- if (! SAVE_EXPR_PERSISTENT_P (expr))
- SAVE_EXPR_RTL (expr) = 0;
- break;
-
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
TREE_OPERAND (expr, 3) = NULL_TREE;
break;
- case RTL_EXPR:
- /* I don't yet know how to emit a sequence multiple times. */
- if (RTL_EXPR_SEQUENCE (expr) != 0)
- abort ();
- break;
-
default:
break;
}
SAVE_EXPRs basically *only* appear replicated in an expression tree,
occasionally across the whole of a function. It is therefore only
safe to unsave a SAVE_EXPR if you know that all occurrences appear
- below the UNSAVE_EXPR.
-
- RTL_EXPRs consume their rtl during evaluation. It is therefore
- never possible to unsave them. */
+ below the UNSAVE_EXPR. */
int
unsafe_for_reeval (tree expr)
switch (code)
{
case SAVE_EXPR:
- case RTL_EXPR:
return 2;
/* A label can only be emitted once. */
contains_placeholder_p (tree exp)
{
enum tree_code code;
- int result;
if (!exp)
return 0;
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
- case SAVE_EXPR:
- /* If we already know this doesn't have a placeholder, don't
- check again. */
- if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
- return 0;
-
- SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
- result = CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
- if (result)
- SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
-
- return result;
-
default:
break;
}
}
return 0;
+ case DECL_EXPR:
+ return (DECL_INITIAL (DECL_EXPR_DECL (exp))
+ && has_cleanups (DECL_INITIAL (DECL_EXPR_DECL (exp))));
+
default:
break;
}
if (op0 == TREE_OPERAND (exp, 0))
return exp;
- new = fold (build2 (code, TREE_TYPE (exp), op0, TREE_OPERAND (exp, 1)));
+ new = fold (build (code, TREE_TYPE (exp), op0, TREE_OPERAND (exp, 1),
+ NULL_TREE));
}
else
switch (TREE_CODE_CLASS (code))
case COMPONENT_REF:
result = build_nt (COMPONENT_REF,
stabilize_reference (TREE_OPERAND (ref, 0)),
- TREE_OPERAND (ref, 1));
+ TREE_OPERAND (ref, 1), NULL_TREE);
break;
case BIT_FIELD_REF:
case ARRAY_REF:
result = build_nt (ARRAY_REF,
stabilize_reference (TREE_OPERAND (ref, 0)),
- stabilize_reference_1 (TREE_OPERAND (ref, 1)));
+ stabilize_reference_1 (TREE_OPERAND (ref, 1)),
+ TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
break;
case ARRAY_RANGE_REF:
result = build_nt (ARRAY_RANGE_REF,
stabilize_reference (TREE_OPERAND (ref, 0)),
- stabilize_reference_1 (TREE_OPERAND (ref, 1)));
+ stabilize_reference_1 (TREE_OPERAND (ref, 1)),
+ TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
break;
case COMPOUND_EXPR:
volatiles. */
return stabilize_reference_1 (ref);
- case RTL_EXPR:
- result = build1 (INDIRECT_REF, TREE_TYPE (ref),
- save_expr (build1 (ADDR_EXPR,
- build_pointer_type (TREE_TYPE (ref)),
- ref)));
- break;
-
/* If arg isn't a kind of lvalue we recognize, make no change.
Caller should recognize the error for an invalid lvalue. */
default:
\f
/* Low-level constructors for expressions. */
-/* A helper function for build1 and constant folders.
- Set TREE_CONSTANT and TREE_INVARIANT for an ADDR_EXPR. */
+/* A helper function for build1 and constant folders. Set TREE_CONSTANT,
+ TREE_INVARIANT, and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
void
recompute_tree_invarant_for_addr_expr (tree t)
{
- tree node = TREE_OPERAND (t, 0);
- bool tc = false, ti = false;
+ tree node;
+ bool tc = true, ti = true, se = false;
- /* Addresses of constants and static variables are constant;
- all other decl addresses are invariant. */
- if (staticp (node))
- tc = ti = true;
- else
+ /* We started out assuming this address is both invariant and constant, but
+ does not have side effects. Now go down any handled components and see if
+ any of them involve offsets that are either non-constant or non-invariant.
+ Also check for side-effects.
+
+ ??? Note that this code makes no attempt to deal with the case where
+ taking the address of something causes a copy due to misalignment. */
+
+#define UPDATE_TITCSE(NODE) \
+do { tree _node = (NODE); \
+ if (_node && !TREE_INVARIANT (_node)) ti = false; \
+ if (_node && !TREE_CONSTANT (_node)) tc = false; \
+ if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
+
+ for (node = TREE_OPERAND (t, 0); handled_component_p (node);
+ node = TREE_OPERAND (node, 0))
{
- /* Step past constant offsets. */
- while (1)
+ /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
+ array reference (probably made temporarily by the G++ front end),
+ so ignore all the operands. */
+ if ((TREE_CODE (node) == ARRAY_REF
+ || TREE_CODE (node) == ARRAY_RANGE_REF)
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
{
- if (TREE_CODE (node) == COMPONENT_REF
- && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL
- && ! DECL_BIT_FIELD (TREE_OPERAND (node, 1)))
- ;
- else if (TREE_CODE (node) == ARRAY_REF
- && TREE_CONSTANT (TREE_OPERAND (node, 1)))
- ;
- else
- break;
- node = TREE_OPERAND (node, 0);
+ UPDATE_TITCSE (TREE_OPERAND (node, 1));
+ UPDATE_TITCSE (array_ref_low_bound (node));
+ UPDATE_TITCSE (array_ref_element_size (node));
}
- if (DECL_P (node))
- ti = true;
+ /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
+ FIELD_DECL, apparently. The G++ front end can put something else
+ there, at least temporarily. */
+ else if (TREE_CODE (node) == COMPONENT_REF
+ && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
+ UPDATE_TITCSE (component_ref_field_offset (node));
+ else if (TREE_CODE (node) == BIT_FIELD_REF)
+ UPDATE_TITCSE (TREE_OPERAND (node, 2));
+ }
+
+ /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
+ it. If it's a decl, it's definitely invariant and it's constant if the
+ decl is static. (Taking the address of a volatile variable is not
+ volatile.) If it's a constant, the address is both invariant and
+ constant. Otherwise it's neither. */
+ if (TREE_CODE (node) == INDIRECT_REF)
+ UPDATE_TITCSE (node);
+ else if (DECL_P (node))
+ {
+ if (!staticp (node))
+ tc = false;
+ }
+ else if (TREE_CODE_CLASS (TREE_CODE (node)) == 'c')
+ ;
+ else
+ {
+ ti = tc = false;
+ se |= TREE_SIDE_EFFECTS (node);
}
TREE_CONSTANT (t) = tc;
TREE_INVARIANT (t) = ti;
+ TREE_SIDE_EFFECTS (t) = se;
+#undef UPDATE_TITCSE
}
/* Build an expression of code CODE, data type TYPE, and operands as
TREE_SET_CODE (t, code);
TREE_TYPE (t) = type;
+#ifdef USE_MAPPED_LOCATION
+ SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
+#else
SET_EXPR_LOCUS (t, NULL);
+#endif
TREE_COMPLEXITY (t) = 0;
TREE_OPERAND (t, 0) = node;
TREE_BLOCK (t) = NULL_TREE;
case INIT_EXPR:
case MODIFY_EXPR:
case VA_ARG_EXPR:
- case RTL_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case ADDR_EXPR:
if (node)
- {
- recompute_tree_invarant_for_addr_expr (t);
-
- /* The address of a volatile decl or reference does not have
- side-effects. But be careful not to ignore side-effects from
- other sources deeper in the expression--if node is a _REF and
- one of its operands has side-effects, so do we. */
- if (TREE_THIS_VOLATILE (node))
- {
- TREE_SIDE_EFFECTS (t) = 0;
- if (!DECL_P (node))
- {
- int i = first_rtl_op (TREE_CODE (node)) - 1;
- for (; i >= 0; --i)
- {
- if (TREE_SIDE_EFFECTS (TREE_OPERAND (node, i)))
- TREE_SIDE_EFFECTS (t) = 1;
- }
- }
- }
- }
+ recompute_tree_invarant_for_addr_expr (t);
break;
default:
TREE_CONSTANT (t) = 1;
if (TREE_CODE_CLASS (code) == '1' && node && TREE_INVARIANT (node))
TREE_INVARIANT (t) = 1;
+ if (TREE_CODE_CLASS (code) == 'r' && node && TREE_THIS_VOLATILE (node))
+ TREE_THIS_VOLATILE (t) = 1;
break;
}
TREE_CONSTANT (t) = constant;
TREE_INVARIANT (t) = invariant;
TREE_SIDE_EFFECTS (t) = side_effects;
+ TREE_THIS_VOLATILE (t)
+ = TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
return t;
}
}
TREE_SIDE_EFFECTS (t) = side_effects;
+ TREE_THIS_VOLATILE (t)
+ = TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
return t;
}
PROCESS_ARG(3);
TREE_SIDE_EFFECTS (t) = side_effects;
+ TREE_THIS_VOLATILE (t)
+ = TREE_CODE_CLASS (code) == 'r' && arg0 && TREE_THIS_VOLATILE (arg0);
return t;
}
return block;
}
+#if 1 /* ! defined(USE_MAPPED_LOCATION) */
+/* ??? gengtype doesn't handle conditionals */
static GTY(()) tree last_annotated_node;
+#endif
+
+#ifdef USE_MAPPED_LOCATION
+
+expanded_location
+expand_location (source_location loc)
+{
+ expanded_location xloc;
+ if (loc == 0) { xloc.file = NULL; xloc.line = 0; }
+ else
+ {
+ const struct line_map *map = linemap_lookup (&line_table, loc);
+ xloc.file = map->to_file;
+ xloc.line = SOURCE_LINE (map, loc);
+ };
+ return xloc;
+}
+
+#else
/* Record the exact location where an expression or an identifier were
encountered. */
{
annotate_with_file_line (node, locus.file, locus.line);
}
+#endif
\f
/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
is ATTRIBUTE. */
|| tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
TYPE_MAX_VALUE (b->type)))
&& (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
- && tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
+ || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
TYPE_MIN_VALUE (b->type))));
case OFFSET_TYPE:
case BIT_AND_EXPR:
case NE_EXPR:
case EQ_EXPR:
+ case UNORDERED_EXPR:
+ case ORDERED_EXPR:
+ case UNEQ_EXPR:
+ case LTGT_EXPR:
+ case TRUTH_AND_EXPR:
+ case TRUTH_XOR_EXPR:
+ case TRUTH_OR_EXPR:
return true;
default:
code = TREE_CODE (t);
class = TREE_CODE_CLASS (code);
- if (class == 'd')
+ if (class == 'd'
+ || TREE_CODE (t) == VALUE_HANDLE)
{
/* Decls we can just compare by pointer. */
val = iterative_hash_object (t, val);
&& (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
&& (! uns || final_prec <= innerprec || unsignedp))
{
- win = build2 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
- TREE_OPERAND (op, 1));
+ win = build3 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
+ TREE_OPERAND (op, 1), NULL_TREE);
TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
}
/* Since type_for_size always gives an integer type. */
&& TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
/* Ensure field is laid out already. */
- && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
+ && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
+ && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
{
unsigned HOST_WIDE_INT innerprec
= tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
{
if (first)
uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
- win = build2 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
- TREE_OPERAND (op, 1));
+ win = build3 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
+ TREE_OPERAND (op, 1), NULL_TREE);
TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
}
if (TREE_CODE (decl) == ERROR_MARK)
return 0;
- if (TREE_CODE (decl) == SAVE_EXPR)
- context = SAVE_EXPR_CONTEXT (decl);
-
/* C++ virtual functions use DECL_CONTEXT for the class of the vtable
where we look up the function at runtime. Such functions always take
a first argument of type 'pointer to real context'.
\f
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-/* Complain that the tree code of NODE does not match the expected CODE.
- FILE, LINE, and FUNCTION are of the caller. */
+/* Complain that the tree code of NODE does not match the expected 0
+ terminated list of trailing codes. FILE, LINE, and FUNCTION are of
+ the caller. */
void
-tree_check_failed (const tree node, enum tree_code code, const char *file,
- int line, const char *function)
-{
+tree_check_failed (const tree node, const char *file,
+ int line, const char *function, ...)
+{
+ va_list args;
+ char *buffer;
+ unsigned length = 0;
+ int code;
+
+ va_start (args, function);
+ while ((code = va_arg (args, int)))
+ length += 4 + strlen (tree_code_name[code]);
+ va_end (args);
+ va_start (args, function);
+ buffer = alloca (length);
+ length = 0;
+ while ((code = va_arg (args, int)))
+ {
+ if (length)
+ {
+ strcpy (buffer + length, " or ");
+ length += 4;
+ }
+ strcpy (buffer + length, tree_code_name[code]);
+ length += strlen (tree_code_name[code]);
+ }
+ va_end (args);
+
internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
- tree_code_name[code], tree_code_name[TREE_CODE (node)],
+ buffer, tree_code_name[TREE_CODE (node)],
function, trim_filename (file), line);
}
-/* Similar to above except that we allowed the code to be one of two
- different codes. */
+/* Complain that the tree code of NODE does match the expected 0
+ terminated list of trailing codes. FILE, LINE, and FUNCTION are of
+ the caller. */
void
-tree_check2_failed (const tree node, enum tree_code code1,
- enum tree_code code2, const char *file,
- int line, const char *function)
-{
- internal_error ("tree check: expected %s or %s, have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2],
- tree_code_name[TREE_CODE (node)],
- function, trim_filename (file), line);
-}
-
-/* Likewise for three different codes. */
-
-void
-tree_check3_failed (const tree node, enum tree_code code1,
- enum tree_code code2, enum tree_code code3,
- const char *file, int line, const char *function)
-{
- internal_error ("tree check: expected %s, %s or %s; have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2],
- tree_code_name[code3], tree_code_name[TREE_CODE (node)],
+tree_not_check_failed (const tree node, const char *file,
+ int line, const char *function, ...)
+{
+ va_list args;
+ char *buffer;
+ unsigned length = 0;
+ int code;
+
+ va_start (args, function);
+ while ((code = va_arg (args, int)))
+ length += 4 + strlen (tree_code_name[code]);
+ va_end (args);
+ va_start (args, function);
+ buffer = alloca (length);
+ length = 0;
+ while ((code = va_arg (args, int)))
+ {
+ if (length)
+ {
+ strcpy (buffer + length, " or ");
+ length += 4;
+ }
+ strcpy (buffer + length, tree_code_name[code]);
+ length += strlen (tree_code_name[code]);
+ }
+ va_end (args);
+
+ internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
+ buffer, tree_code_name[TREE_CODE (node)],
function, trim_filename (file), line);
}
-/* ... and for four different codes. */
-
-void
-tree_check4_failed (const tree node, enum tree_code code1,
- enum tree_code code2, enum tree_code code3,
- enum tree_code code4, const char *file, int line,
- const char *function)
-{
- internal_error
- ("tree check: expected %s, %s, %s or %s; have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2], tree_code_name[code3],
- tree_code_name[code4], tree_code_name[TREE_CODE (node)], function,
- trim_filename (file), line);
-}
-
-/* ... and for five different codes. */
-
-void
-tree_check5_failed (const tree node, enum tree_code code1,
- enum tree_code code2, enum tree_code code3,
- enum tree_code code4, enum tree_code code5,
- const char *file, int line, const char *function)
-{
- internal_error
- ("tree check: expected %s, %s, %s, %s or %s; have %s in %s, at %s:%d",
- tree_code_name[code1], tree_code_name[code2], tree_code_name[code3],
- tree_code_name[code4], tree_code_name[code5],
- tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
-}
-
/* Similar to tree_check_failed, except that we check for a class of tree
code, given in CL. */
idx + 1, len, function, trim_filename (file), line);
}
-/* Similar to above, except that the check is for the bounds of a EPHI_NODE's
- (dynamically sized) vector. */
-
-void
-ephi_node_elt_check_failed (int idx, int len, const char *file, int line,
- const char *function)
-{
- internal_error
- ("tree check: accessed elt %d of ephi_node with %d elts in %s, at %s:%d",
- idx + 1, len, function, trim_filename (file), line);
-}
-
/* Similar to above, except that the check is for the bounds of a PHI_NODE's
(dynamically sized) vector. */
return build1 (NOP_EXPR, void_type_node, size_zero_node);
}
-bool
-is_essa_node (tree t)
-{
- if (TREE_CODE (t) == EPHI_NODE || TREE_CODE (t) == EUSE_NODE
- || TREE_CODE (t) == EEXIT_NODE || TREE_CODE (t) == EKILL_NODE)
- return true;
- return false;
-}
-
/* Return true if T (assumed to be a DECL) must be assigned a memory
location. */
OSDN Git Service
