#include "machmode.h"
#include "version.h"
-#include "location.h"
+#include "input.h"
/* Codes of tree nodes */
unsigned public_flag : 1;
unsigned private_flag : 1;
unsigned protected_flag : 1;
- unsigned bounded_flag : 1;
unsigned deprecated_flag : 1;
+ unsigned unused_1 : 1;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
- unsigned unused_1 : 1;
+ unsigned unused_2 : 1;
};
/* The following table lists the uses of each of the above flags and
TREE_UNSIGNED in
INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL
- DECL_BUILT_IN_NONANSI in
- FUNCTION_DECL
SAVE_EXPR_NOPLACEHOLDER in
SAVE_EXPR
TREE_NOTHROW in
CALL_EXPR, FUNCTION_DECL
- bounded_flag:
-
- TREE_BOUNDED in
- expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL,
- IDENTIFIER_NODE
- TYPE_BOUNDED in
- ..._TYPE
-
deprecated_flag:
TREE_DEPRECATED in
__t; })
/* These checks have to be special cased. */
-#define CST_OR_CONSTRUCTOR_CHECK(t) __extension__ \
-({ const tree __t = (t); \
- enum tree_code const __c = TREE_CODE(__t); \
- if (__c != CONSTRUCTOR && TREE_CODE_CLASS(__c) != 'c') \
- tree_check_failed (__t, CONSTRUCTOR, __FILE__, __LINE__, \
- __FUNCTION__); \
- __t; })
#define EXPR_CHECK(t) __extension__ \
({ const tree __t = (t); \
char const __c = TREE_CODE_CLASS(TREE_CODE(__t)); \
__FILE__, __LINE__, __FUNCTION__); \
&__t->vec.a[__i]; }))
+/* Special checks for TREE_OPERANDs. */
+#define TREE_OPERAND_CHECK(t, i) __extension__ \
+(*({const tree __t = EXPR_CHECK(t); \
+ const int __i = (i); \
+ if (__i < 0 || __i >= TREE_CODE_LENGTH (TREE_CODE (__t))) \
+ tree_operand_check_failed (__i, TREE_CODE (__t), \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->exp.operands[__i]; }))
+
+#define TREE_OPERAND_CHECK_CODE(t, code, i) __extension__ \
+(*({const tree __t = t; \
+ const int __i = (i); \
+ const enum tree_code __code = code; \
+ if (TREE_CODE (__t) != __code) \
+ tree_check_failed (__t, __code, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ if (__i < 0 || __i >= TREE_CODE_LENGTH (__code)) \
+ tree_operand_check_failed (__i, __code, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->exp.operands[__i]; }))
+
+#define TREE_RTL_OPERAND_CHECK(t, code, i) __extension__ \
+(*(rtx *) \
+ ({const tree __t = t; \
+ const int __i = (i); \
+ const enum tree_code __code = code; \
+ if (TREE_CODE (__t) != __code) \
+ tree_check_failed (__t, __code, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ if (__i < 0 || __i >= TREE_CODE_LENGTH (__code)) \
+ tree_operand_check_failed (__i, __code, \
+ __FILE__, __LINE__, __FUNCTION__); \
+ &__t->exp.operands[__i]; }))
+
extern void tree_check_failed PARAMS ((const tree, enum tree_code,
const char *, int, const char *))
ATTRIBUTE_NORETURN;
int, const char *))
ATTRIBUTE_NORETURN;
+extern void tree_operand_check_failed PARAMS ((int, enum tree_code,
+ const char *, int, const char *))
+ ATTRIBUTE_NORETURN;
+
#else /* not ENABLE_TREE_CHECKING, or not gcc */
#define TREE_CHECK(t, code) (t)
#define TREE_CLASS_CHECK(t, code) (t)
-#define CST_OR_CONSTRUCTOR_CHECK(t) (t)
#define EXPR_CHECK(t) (t)
#define TREE_VEC_ELT_CHECK(t, i) ((t)->vec.a[i])
+#define TREE_OPERAND_CHECK(t, i) ((t)->exp.operands[i])
+#define TREE_OPERAND_CHECK_CODE(t, code, i) ((t)->exp.operands[i])
+#define TREE_RTL_OPERAND_CHECK(t, code, i) (*(rtx *) &((t)->exp.operands[i]))
#endif
== TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
(EXP) = TREE_OPERAND (EXP, 0)
+/* Like STRIP_NOPS, but don't alter the TREE_TYPE main variant either. */
+
+#define STRIP_MAIN_TYPE_NOPS(EXP) \
+ while ((TREE_CODE (EXP) == NOP_EXPR \
+ || TREE_CODE (EXP) == CONVERT_EXPR \
+ || TREE_CODE (EXP) == NON_LVALUE_EXPR) \
+ && TREE_OPERAND (EXP, 0) != error_mark_node \
+ && (TYPE_MAIN_VARIANT (TREE_TYPE (EXP)) \
+ == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
+ (EXP) = TREE_OPERAND (EXP, 0)
+
/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
#define STRIP_TYPE_NOPS(EXP) \
|| TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
|| TREE_CODE (TYPE) == SET_TYPE)
-/* Nonzero if TYPE represents an unbounded pointer or unbounded
- reference type. (It should be renamed to INDIRECT_TYPE_P.) */
+/* Nonzero if TYPE represents a pointer or reference type.
+ (It should be renamed to INDIRECT_TYPE_P.) */
#define POINTER_TYPE_P(TYPE) \
(TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
-/* Nonzero if TYPE represents a bounded pointer or bounded reference type. */
-
-#define BOUNDED_INDIRECT_TYPE_P(TYPE) \
- (TREE_CODE (TYPE) == RECORD_TYPE && TREE_TYPE (TYPE))
-
-/* Nonzero if TYPE represents a bounded pointer type. */
-
-#define BOUNDED_POINTER_TYPE_P(TYPE) \
- (BOUNDED_INDIRECT_TYPE_P (TYPE) \
- && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == POINTER_TYPE)
-
-/* Nonzero if TYPE represents a bounded reference type. Bounded
- reference types have two specific uses: (1) When a reference is
- seated to a variable-length RECORD_TYPE that has an array of
- indeterminate length as its final field. For all other objects, it
- is sufficient to check bounds at the time the reference is seated,
- and assume that all future uses of the reference are safe, since
- the address of references cannot change. (2) When a reference
- supertype is seated to a subtype object. The bounds "remember"
- the true size of the complete object, so that subsequent upcasts of
- the address of the reference will be checked properly (is such a
- thing valid C++?). */
-
-#define BOUNDED_REFERENCE_TYPE_P(TYPE) \
- (BOUNDED_INDIRECT_TYPE_P (TYPE) \
- && TREE_CODE (TYPE_BOUNDED_SUBTYPE (TYPE)) == REFERENCE_TYPE)
-
-/* Nonzero if TYPE represents a pointer or reference type, either
- bounded or unbounded. */
-
-#define MAYBE_BOUNDED_INDIRECT_TYPE_P(TYPE) \
- (POINTER_TYPE_P (TYPE) || BOUNDED_INDIRECT_TYPE_P (TYPE))
-
-/* Nonzero if TYPE represents a pointer type, either bounded or unbounded. */
-
-#define MAYBE_BOUNDED_POINTER_TYPE_P(TYPE) \
- (TREE_CODE (TYPE) == POINTER_TYPE || BOUNDED_POINTER_TYPE_P (TYPE))
-
-/* Nonzero if TYPE represents a reference type, either bounded or
- unbounded. */
-
-#define MAYBE_BOUNDED_REFERENCE_TYPE_P(TYPE) \
- (TREE_CODE (TYPE) == REFERENCE_TYPE || BOUNDED_REFERENCE_TYPE_P (TYPE))
-
/* Nonzero if this type is a complete type. */
#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
#define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
/* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type.
- In FIELD_DECL nodes, means an unsigned bit field.
- The same bit is used in functions as DECL_BUILT_IN_NONANSI. */
+ In FIELD_DECL nodes, means an unsigned bit field. */
#define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
#define TYPE_TRAP_SIGNED(NODE) \
In a BLOCK node, this is BLOCK_HANDLER_BLOCK. */
#define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)
-/* In a ..._TYPE node, nonzero means that the type's size and layout,
- (or the size and layout of its arguments and/or return value in the
- case of a FUNCTION_TYPE or METHOD_TYPE) was changed by the presence
- of pointer bounds. Use TYPE_BOUNDED instead of this macro when the
- node is a type, because eventually we may make that a different
- bit. TYPE_BOUNDED doesn't mean that this type is a bounded indirect
- type--use BOUNDED_POINTER_TYPE_P, BOUNDED_REFERENCE_TYPE_P,
- BOUNDED_INDIRECT_TYPE_P to test for that.
-
- In a FUNCTION_DECL, nonzero means that the size and layout of one
- of its arguments and/or return value was changed by the presence of
- pointer bounds. This value can differ from the value of
- TYPE_BOUNDED (TREE_TYPE (fundecl)) if the function was implicitly
- declared, then later called with pointer args, or was declared with
- a variable argument list and is later called with pointer values in
- the variable argument list.
-
- In a VAR_DECL, PARM_DECL or FIELD_DECL, TREE_BOUNDED matches the value
- of the decl's type's BOUNDED_POINTER_TYPE_P.
-
- In a CONSTRUCTOR or other expression, nonzero means the value is a
- bounded pointer. It is insufficient to determine the boundedness
- of an expression EXP with BOUNDED_POINTER_TYPE_P (TREE_TYPE (EXP)),
- since we allow pointer to be temporarily cast to integer for
- rounding up to an alignment boundary in a way that preserves the
- pointer's bounds.
-
- In an IDENTIFIER_NODE, nonzero means that the name is prefixed with
- BP_PREFIX (see varasm.c). This occurs for the DECL_ASSEMBLER_NAME
- of a function that has bounded pointer(s) for its return type and/or
- argument type(s). */
-
-#define TREE_BOUNDED(NODE) ((NODE)->common.bounded_flag)
-
/* Nonzero in an IDENTIFIER_NODE if the use of the name is defined as a
deprecated feature by __attribute__((deprecated)). */
#define TREE_DEPRECATED(NODE) ((NODE)->common.deprecated_flag)
struct tree_int_cst GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language
- (rtl) info */
/* A sub-struct is necessary here because the function `const_hash'
wants to scan both words as a unit and taking the address of the
sub-struct yields the properly inclusive bounded pointer. */
} int_cst;
};
-/* In REAL_CST, STRING_CST, COMPLEX_CST, VECTOR_CST nodes, and
- CONSTRUCTOR nodes, and generally in all kinds of constants that
- could be given labels (rather than being immediate). */
-
-#define TREE_CST_RTL(NODE) (CST_OR_CONSTRUCTOR_CHECK (NODE)->real_cst.rtl)
-
/* In a REAL_CST node. struct real_value is an opaque entity, with
manipulators defined in real.h. We don't want tree.h depending on
real.h and transitively on tm.h. */
struct tree_real_cst GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language (rtl) info */
struct real_value * real_cst_ptr;
};
struct tree_string GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language (rtl) info */
int length;
const char *pointer;
};
struct tree_complex GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language (rtl) info */
tree real;
tree imag;
};
struct tree_vector GTY(())
{
struct tree_common common;
- rtx rtl;
tree elements;
};
\f
(IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
#define IDENTIFIER_POINTER(NODE) \
((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
+#define IDENTIFIER_HASH_VALUE(NODE) \
+ (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
/* Translate a hash table identifier pointer to a tree_identifier
pointer, and vice versa. */
/* Define fields and accessors for some nodes that represent expressions. */
/* In a SAVE_EXPR node. */
-#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND (SAVE_EXPR_CHECK (NODE), 1)
-#define SAVE_EXPR_RTL(NODE) (*(rtx *) &SAVE_EXPR_CHECK (NODE)->exp.operands[2])
+#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND_CHECK_CODE (NODE, SAVE_EXPR, 1)
+#define SAVE_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, SAVE_EXPR, 2)
+
#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (SAVE_EXPR_CHECK (NODE))
/* Nonzero if the SAVE_EXPRs value should be kept, even if it occurs
both in normal code and in a handler. (Normally, in a handler, all
#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (SAVE_EXPR_CHECK (NODE))
/* In a RTL_EXPR node. */
-#define RTL_EXPR_SEQUENCE(NODE) \
- (*(rtx *) &RTL_EXPR_CHECK (NODE)->exp.operands[0])
-#define RTL_EXPR_RTL(NODE) (*(rtx *) &RTL_EXPR_CHECK (NODE)->exp.operands[1])
+#define RTL_EXPR_SEQUENCE(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 0)
+#define RTL_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 1)
/* In a WITH_CLEANUP_EXPR node. */
#define WITH_CLEANUP_EXPR_RTL(NODE) \
- (*(rtx *) &WITH_CLEANUP_EXPR_CHECK (NODE)->exp.operands[2])
+ TREE_RTL_OPERAND_CHECK (NODE, WITH_CLEANUP_EXPR, 2)
/* In a CONSTRUCTOR node. */
-#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (CONSTRUCTOR_CHECK (NODE), 1)
+#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND_CHECK_CODE (NODE, CONSTRUCTOR, 0)
/* In ordinary expression nodes. */
-#define TREE_OPERAND(NODE, I) (EXPR_CHECK (NODE)->exp.operands[I])
+#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)
/* In a LABELED_BLOCK_EXPR node. */
#define LABELED_BLOCK_LABEL(NODE) \
- TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 0)
+ TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 0)
#define LABELED_BLOCK_BODY(NODE) \
- TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 1)
+ TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 1)
/* In an EXIT_BLOCK_EXPR node. */
#define EXIT_BLOCK_LABELED_BLOCK(NODE) \
- TREE_OPERAND (EXIT_BLOCK_EXPR_CHECK (NODE), 0)
-#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND (EXIT_BLOCK_EXPR_CHECK (NODE), 1)
+ TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 0)
+#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 1)
/* In a LOOP_EXPR node. */
-#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (LOOP_EXPR_CHECK (NODE), 0)
+#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
/* In an EXPR_WITH_FILE_LOCATION node. */
#define EXPR_WFL_EMIT_LINE_NOTE(NODE) \
(EXPR_WITH_FILE_LOCATION_CHECK (NODE)->common.public_flag)
#define EXPR_WFL_NODE(NODE) \
- TREE_OPERAND (EXPR_WITH_FILE_LOCATION_CHECK (NODE), 0)
+ TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 0)
#define EXPR_WFL_FILENAME_NODE(NODE) \
- TREE_OPERAND (EXPR_WITH_FILE_LOCATION_CHECK (NODE), 1)
+ TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 1)
#define EXPR_WFL_FILENAME(NODE) \
IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (NODE))
/* ??? Java uses this in all expressions. */
(EXPR_WFL_LINECOL(NODE) = ((LINE) << 12) | ((COL) & 0xfff))
/* In a TARGET_EXPR node. */
-#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND (TARGET_EXPR_CHECK (NODE), 0)
-#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND (TARGET_EXPR_CHECK (NODE), 1)
-#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND (TARGET_EXPR_CHECK (NODE), 2)
+#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
+#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
+#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
struct tree_exp GTY(())
{
structure containing an array. */
#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (TYPE_CHECK (NODE)->type.values)
-/* Indirect types present difficulties because they may be represented
- as either POINTER_TYPE/REFERENCE_TYPE nodes (unbounded) or as
- RECORD_TYPE nodes (bounded). Bounded and unbounded pointers might
- be logically equivalent, but physically different. Simple
- comparison of the main variant only tells if the types are
- logically equivalent. Use this predicate to compare for physical
- equivalency. */
-
-/* Types have the same main variant, and have the same boundedness. */
-#define TYPE_MAIN_VARIANTS_PHYSICALLY_EQUAL_P(TYPE1, TYPE2) \
- (TYPE_MAIN_VARIANT (TYPE1) == TYPE_MAIN_VARIANT (TYPE2) \
- && TREE_CODE (TYPE1) == TREE_CODE (TYPE2))
-
-/* Return the type variant that has no qualifiers (i.e., the main variant),
- except that the boundedness qualifier is preserved. */
-#define TYPE_MAIN_PHYSICAL_VARIANT(TYPE) \
- (BOUNDED_POINTER_TYPE_P (TYPE) \
- ? build_qualified_type (TYPE, TYPE_QUAL_BOUNDED) \
- : TYPE_MAIN_VARIANT (TYPE))
-
/* For aggregate types, information about this type, as a base type
for itself. Used in a language-dependent way for types that are
neither a RECORD_TYPE, QUAL_UNION_TYPE, nor a UNION_TYPE. */
the term. */
#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
-/* If nonzero, this type's size and layout, (or the size and layout of
- its arguments and/or return value in the case of a FUNCTION_TYPE or
- METHOD_TYPE) was changed by the presence of pointer bounds. */
-#define TYPE_BOUNDED(NODE) (TYPE_CHECK (NODE)->common.bounded_flag)
-
/* There is a TYPE_QUAL value for each type qualifier. They can be
combined by bitwise-or to form the complete set of qualifiers for a
type. */
#define TYPE_QUAL_CONST 0x1
#define TYPE_QUAL_VOLATILE 0x2
#define TYPE_QUAL_RESTRICT 0x4
-#define TYPE_QUAL_BOUNDED 0x8
/* The set of type qualifiers for this type. */
#define TYPE_QUALS(NODE) \
((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
| (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
- | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT) \
- | (BOUNDED_INDIRECT_TYPE_P (NODE) * TYPE_QUAL_BOUNDED))
-
-/* The set of qualifiers pertinent to an expression node. */
-#define TREE_EXPR_QUALS(NODE) \
- ((TREE_READONLY (NODE) * TYPE_QUAL_CONST) \
- | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
- | (TREE_BOUNDED (NODE) * TYPE_QUAL_BOUNDED))
-
-/* The set of qualifiers pertinent to a FUNCTION_DECL node. */
-#define TREE_FUNC_QUALS(NODE) \
- ((TREE_READONLY (NODE) * TYPE_QUAL_CONST) \
- | (TREE_THIS_VOLATILE (NODE) * TYPE_QUAL_VOLATILE))
+ | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
/* These flags are available for each language front end to use internally. */
#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
compact a way as possible. */
#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
-/* A bounded pointer or bounded reference type (collectively called
- indirect types) is represented as a RECORD_TYPE node containing
- three pointer fields whose type is the corresponding unbounded
- POINTER_TYPE or REFERENCE_TYPE. A RECORD_TYPE node that represents
- a bounded indirect type differs from a normal RECORD_TYPE node in
- that its TREE_TYPE is non-NULL and has the pointed-to type just as
- a POINTER_TYPE or REFERENCE_TYPE node has. The bounded RECORD_TYPE
- nodes are stored on the same type variant chain alongside the
- variants of the underlaying indirect types nodes. The main variant
- of such chains is always the unbounded type. */
-
-/* Access the field decls of a bounded-pointer type. */
-#define TYPE_BOUNDED_VALUE(TYPE) TYPE_FIELDS (TYPE)
-#define TYPE_BOUNDED_BASE(TYPE) TREE_CHAIN (TYPE_BOUNDED_VALUE (TYPE))
-#define TYPE_BOUNDED_EXTENT(TYPE) TREE_CHAIN (TYPE_BOUNDED_BASE (TYPE))
-
-/* Access the simple-pointer subtype of a bounded-pointer type. */
-#define TYPE_BOUNDED_SUBTYPE(TYPE) TREE_TYPE (TYPE_BOUNDED_VALUE (TYPE))
-
-/* Find the unbounded counterpart to a type, or return TYPE if it is
- already unbounded. */
-#define TYPE_UNBOUNDED_VARIANT(TYPE) \
- (BOUNDED_POINTER_TYPE_P (TYPE) ? TYPE_BOUNDED_SUBTYPE (TYPE) : (TYPE))
-
-/* This field comprises two bits, for values in the range 0..3:
-
- depth=0 means that type is a scalar, or an aggregate that contains
- only depth=0 types, or a function that has only depth=0 types for
- its return value and argument types.
-
- depth=1 means that type is a pointer to a depth=0 type, or an
- aggregate that contains only depth=0 and depth=1 types, or a
- function that has only depth=0 and depth=1 types for its return
- value and argument types.
-
- The meanings of depth=2 and depth=3 are obvious by induction.
- Varargs functions are depth=3. The type `va_list' is depth=3.
-
- The purpose of measuring pointer depth of a type is to determine
- the eligibility of a function for an automatically-generated
- bounded-pointer thunk. A depth=0 functions needs no thunk. A
- depth=1 function is eligible for an automatic thunk. Functions
- with depth 2 or more are too complex to get automatic thunks.
-
- Function decls also have a pointer_depth field, since we also
- consider the actual argument types for functions. */
-
-#define TYPE_POINTER_DEPTH(TYPE) (TYPE_CHECK (TYPE)->type.pointer_depth)
-
-/* In a FUNCTION_TYPE node, this bit stores the value of
- default_pointer_boundedness at the time TYPE was created. It is
- useful for choosing default boundedness of function arguments for
- non-prototype function decls and for varargs/stdarg lists. */
-#define TYPE_AMBIENT_BOUNDEDNESS(TYPE) \
- (FUNCTION_TYPE_CHECK (TYPE)->type.transparent_union_flag)
-
-#define MAX_POINTER_DEPTH 2
-#define VA_LIST_POINTER_DEPTH 3
-
struct die_struct;
struct tree_type GTY(())
unsigned transparent_union_flag : 1;
unsigned packed_flag : 1;
unsigned restrict_flag : 1;
- unsigned pointer_depth : 2;
+ unsigned spare : 2;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
where it is called. */
#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inline_flag)
+/* Nonzero in a FUNCTION_DECL means this function has been found inlinable
+ only by virtue of -finline-functions */
+#define DID_INLINE_FUNC(NODE) \
+ (FUNCTION_DECL_CHECK (NODE)->decl.inlined_function_flag)
+
/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
/* List of FUNCTION_DECLs inlined into this function's body. */
#define DECL_INLINED_FNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inlined_fns)
-/* Nonzero in a FUNCTION_DECL means this is a built-in function
- that is not specified by ansi C and that users are supposed to be allowed
- to redefine for any purpose whatever. */
-#define DECL_BUILT_IN_NONANSI(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->common.unsigned_flag)
-
/* Nonzero in a FUNCTION_DECL means this function should be treated
as if it were a malloc, meaning it returns a pointer that is
not an alias. */
#define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \
(DECL_POINTER_ALIAS_SET (NODE) != - 1)
-/* The pointer_depth field comprises two bits for values in the range
- 0..3. The value is normally equal to TYPE_POINTER_DEPTH of decl's
- type node, but for functions it migth be greater. For example,
- this can happen when the function is declared to accept a parameter
- of type void* (depth=1), but is actually called with an argument of
- type foo** (depth=2). The function type will get the formal
- parameter's depth, but the function decl will get the actual
- argument's depth. */
-#define DECL_POINTER_DEPTH(DECL) (DECL_CHECK (DECL)->decl.pointer_depth)
-
struct function;
struct tree_decl GTY(())
ENUM_BITFIELD(built_in_class) built_in_class : 2;
unsigned pure_flag : 1;
- unsigned pointer_depth : 2;
unsigned non_addressable : 1;
unsigned user_align : 1;
unsigned uninlinable : 1;
unsigned thread_local_flag : 1;
- /* Two unused bits. */
+ unsigned inlined_function_flag : 1;
+ unsigned unused : 3;
+ /* three unused bits. */
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
extern tree build_int_2_wide PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT));
extern tree build_vector PARAMS ((tree, tree));
+extern tree build_constructor PARAMS ((tree, tree));
extern tree build_real_from_int_cst PARAMS ((tree, tree));
extern tree build_complex PARAMS ((tree, tree, tree));
extern tree build_string PARAMS ((int, const char *));
extern int tree_int_cst_compare PARAMS ((tree, tree));
extern int host_integerp PARAMS ((tree, int));
extern HOST_WIDE_INT tree_low_cst PARAMS ((tree, int));
+extern int tree_int_cst_msb PARAMS ((tree));
extern int tree_int_cst_sgn PARAMS ((tree));
extern int tree_expr_nonnegative_p PARAMS ((tree));
extern int rtl_expr_nonnegative_p PARAMS ((rtx));
tree bitpos;
/* The alignment of the record so far, in bits. */
unsigned int record_align;
- /* The alignment of the record so far, not including padding, in bits. */
+ /* The alignment of the record so far, ignoring #pragma pack and
+ __attribute__ ((packed)), in bits. */
unsigned int unpacked_align;
- /* The alignment of the record so far, allowing for the record to be
- padded only at the end, in bits. */
- unsigned int unpadded_align;
/* The previous field layed out. */
tree prev_field;
/* The static variables (i.e., class variables, as opposed to
tree pending_statics;
/* Bits remaining in the current alignment group */
int remaining_in_alignment;
+ /* True if we've seen a packed field that didn't have normal
+ alignment anyway. */
int packed_maybe_necessary;
} *record_layout_info;
extern tree convert PARAMS ((tree, tree));
extern unsigned int expr_align PARAMS ((tree));
+extern tree expr_first PARAMS ((tree));
+extern tree expr_last PARAMS ((tree));
+extern int expr_length PARAMS ((tree));
extern tree size_in_bytes PARAMS ((tree));
extern HOST_WIDE_INT int_size_in_bytes PARAMS ((tree));
extern tree bit_position PARAMS ((tree));
extern tree save_expr PARAMS ((tree));
+/* Look inside EXPR and into any simple arithmetic operations. Return
+ the innermost non-arithmetic node. */
+
+extern tree skip_simple_arithmetic PARAMS ((tree));
+
+/* Return TRUE if EXPR is a SAVE_EXPR or wraps simple arithmetic around a
+ SAVE_EXPR. Return FALSE otherwise. */
+
+extern bool saved_expr_p PARAMS ((tree));
+
/* Returns the index of the first non-tree operand for CODE, or the number
of operands if all are trees. */
Note that we only allow such expressions within simple arithmetic
or a COND_EXPR. */
-extern int contains_placeholder_p PARAMS ((tree));
+extern bool contains_placeholder_p PARAMS ((tree));
+
+/* This macro calls the above function but short-circuits the common
+ case of a constant to save time. Also check for null. */
+
+#define CONTAINS_PLACEHOLDER_P(EXP) \
+ ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
+
+/* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
+ This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
+ positions. */
+
+extern bool type_contains_placeholder_p PARAMS ((tree));
/* Return 1 if EXP contains any expressions that produce cleanups for an
outer scope to deal with. Used by fold. */
\f
/* Declare commonly used variables for tree structure. */
-/* Points to the name of the input file from which the current input
- being parsed originally came (before it went into cpp). */
-extern const char *input_filename;
-
-/* Current line number in input file. */
-extern int lineno;
-
/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
Zero means allow extended lvalues. */
extern int readonly_fields_p PARAMS ((tree));
extern int objects_must_conflict_p PARAMS ((tree, tree));
-struct obstack;
-
/* In tree.c */
extern int really_constant_p PARAMS ((tree));
extern int int_fits_type_p PARAMS ((tree, tree));
extern int tree_log2 PARAMS ((tree));
extern int tree_floor_log2 PARAMS ((tree));
extern int simple_cst_equal PARAMS ((tree, tree));
+extern unsigned int iterative_hash_expr PARAMS ((tree, unsigned int));
extern int compare_tree_int PARAMS ((tree,
unsigned HOST_WIDE_INT));
extern int type_list_equal PARAMS ((tree, tree));
extern unsigned int type_hash_list PARAMS ((tree));
extern int simple_cst_list_equal PARAMS ((tree, tree));
extern void dump_tree_statistics PARAMS ((void));
-extern void print_obstack_statistics PARAMS ((const char *,
- struct obstack *));
-#ifdef BUFSIZ
-extern void print_obstack_name PARAMS ((char *, FILE *,
- const char *));
-#endif
extern void expand_function_end PARAMS ((const char *, int, int));
extern void expand_function_start PARAMS ((tree, int));
extern void expand_pending_sizes PARAMS ((tree));
extern int real_onep PARAMS ((tree));
extern int real_twop PARAMS ((tree));
extern int real_minus_onep PARAMS ((tree));
-extern void gcc_obstack_init PARAMS ((struct obstack *));
extern void init_ttree PARAMS ((void));
extern void build_common_tree_nodes PARAMS ((int));
extern void build_common_tree_nodes_2 PARAMS ((int));
extern void init_function_for_compilation PARAMS ((void));
extern void init_function_start PARAMS ((tree, const char *, int));
extern void assign_parms PARAMS ((tree));
-extern void put_var_into_stack PARAMS ((tree));
+extern void put_var_into_stack PARAMS ((tree, int));
extern void flush_addressof PARAMS ((tree));
extern void uninitialized_vars_warning PARAMS ((tree));
extern void setjmp_args_warning PARAMS ((void));
extern HOST_WIDE_INT all_cases_count PARAMS ((tree, int *));
extern void check_for_full_enumeration_handling PARAMS ((tree));
extern void declare_nonlocal_label PARAMS ((tree));
+extern void default_flag_random_seed PARAMS ((void));
/* If KIND=='I', return a suitable global initializer (constructor) name.
If KIND=='D', return a suitable global clean-up (destructor) name. */
/* Assign the RTX to declaration. */
extern void set_decl_rtl PARAMS ((tree, rtx));
-
-/* In callgraph.c */
-void cgraph_finalize_function PARAMS ((tree, tree));
-void cgraph_finalize_compilation_unit PARAMS ((void));
-void cgraph_create_edges PARAMS ((tree, tree));
-void dump_cgraph PARAMS ((FILE *));
-void cgraph_optimize PARAMS ((void));
-void cgraph_remove_call PARAMS ((tree, tree));
-bool cgraph_calls_p PARAMS ((tree, tree));
-
\f
/* Redefine abort to report an internal error w/o coredump, and
reporting the location of the error in the source file. This logic
OSDN Git Service
