/* Front-end tree definitions for GNU compiler.
- Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
- Free Software Foundation, Inc.
+ Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+ 2001, 2002 Free Software Foundation, Inc.
This file is part of GCC.
and `x' for anything else (TREE_LIST, IDENTIFIER, etc). */
#define MAX_TREE_CODES 256
-extern char tree_code_type[MAX_TREE_CODES];
+extern const char tree_code_type[];
#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
/* Returns non-zero iff CLASS is the tree-code class of an
expression. */
#define IS_EXPR_CODE_CLASS(CLASS) \
- (CLASS == '<' || CLASS == '1' || CLASS == '2' || CLASS == 'e')
+ ((CLASS) == '<' || (CLASS) == '1' || (CLASS) == '2' || (CLASS) == 'e')
/* Number of argument-words in each kind of tree-node. */
-extern int tree_code_length[MAX_TREE_CODES];
+extern const unsigned char tree_code_length[];
#define TREE_CODE_LENGTH(CODE) tree_code_length[(int) (CODE)]
/* Names of tree components. */
-extern const char *tree_code_name[MAX_TREE_CODES];
+extern const char *const tree_code_name[];
\f
/* Classify which part of the compiler has defined a given builtin function.
Note that we assume below that this is no more than two bits. */
See the accessor macros, defined below, for documentation of the
fields. */
-struct tree_common
+struct tree_common GTY(())
{
tree chain;
tree type;
- void *aux;
+
ENUM_BITFIELD(tree_code) code : 8;
+
unsigned side_effects_flag : 1;
unsigned constant_flag : 1;
unsigned addressable_flag : 1;
unsigned readonly_flag : 1;
unsigned unsigned_flag : 1;
unsigned asm_written_flag: 1;
+ unsigned unused_0 : 1;
unsigned used_flag : 1;
unsigned nothrow_flag : 1;
unsigned private_flag : 1;
unsigned protected_flag : 1;
unsigned bounded_flag : 1;
+ unsigned deprecated_flag : 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;
- /* This flag is presently unused. However, language front-ends
- should not make use of this flag; it is reserved for future
- expansion. */
- unsigned dummy : 1;
+ unsigned unused_1 : 1;
};
/* The following table lists the uses of each of the above flags and
TREE_ADDRESSABLE in
VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
- ..._TYPE, IDENTIFIER_NODE
+ ..._TYPE, IDENTIFIER_NODE.
+ In a STMT_EXPR, it means we want the result of the enclosed
+ expression.
static_flag:
TREE_VIA_VIRTUAL in
TREE_LIST or TREE_VEC
TREE_CONSTANT_OVERFLOW in
- INTEGER_CST, REAL_CST, COMPLEX_CST
+ INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
TREE_SYMBOL_REFERENCED in
IDENTIFIER_NODE
+ CLEANUP_EH_ONLY in
+ TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT,
+ TREE_LIST elements of a block's cleanup list.
public_flag:
TREE_OVERFLOW in
- INTEGER_CST, REAL_CST, COMPLEX_CST
+ INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
TREE_PUBLIC in
VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
TREE_VIA_PUBLIC in
TREE_VIA_PRIVATE in
TREE_LIST or TREE_VEC
TREE_PRIVATE in
- ??? unspecified nodes
+ ..._DECL
protected_flag:
TREE_VIA_PROTECTED in
TREE_LIST
+ TREE_VEC
TREE_PROTECTED in
BLOCK
- ??? unspecified nodes
+ ..._DECL
side_effects_flag:
IDENTIFIER_NODE
TYPE_BOUNDED in
..._TYPE
+
+ deprecated_flag:
+
+ TREE_DEPRECATED in
+ ..._DECL
*/
/* Define accessors for the fields that all tree nodes have
Codes are defined in tree.def. */
#define TREE_CODE(NODE) ((enum tree_code) (NODE)->common.code)
#define TREE_SET_CODE(NODE, VALUE) \
-((NODE)->common.code = (ENUM_BITFIELD(tree_code)) (VALUE))
+((NODE)->common.code = (ENUM_BITFIELD (tree_code)) (VALUE))
/* When checking is enabled, errors will be generated if a tree node
is accessed incorrectly. The macros abort with a fatal error. */
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
#define TREE_CHECK(t, code) __extension__ \
-({ const tree __t = t; \
+({ const tree __t = (t); \
if (TREE_CODE(__t) != (code)) \
tree_check_failed (__t, code, __FILE__, __LINE__, __FUNCTION__); \
__t; })
#define TREE_CLASS_CHECK(t, class) __extension__ \
-({ const tree __t = t; \
+({ const tree __t = (t); \
if (TREE_CODE_CLASS(TREE_CODE(__t)) != (class)) \
- tree_class_check_failed (__t, class, __FILE__, __LINE__, __FUNCTION__); \
+ tree_class_check_failed (__t, class, __FILE__, __LINE__, \
+ __FUNCTION__); \
__t; })
/* These checks have to be special cased. */
#define CST_OR_CONSTRUCTOR_CHECK(t) __extension__ \
-({ const tree __t = t; \
- enum tree_code __c = TREE_CODE(__t); \
+({ 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__); \
+ tree_check_failed (__t, CONSTRUCTOR, __FILE__, __LINE__, \
+ __FUNCTION__); \
__t; })
#define EXPR_CHECK(t) __extension__ \
-({ const tree __t = t; \
- char __c = TREE_CODE_CLASS(TREE_CODE(__t)); \
+({ const tree __t = (t); \
+ char const __c = TREE_CODE_CLASS(TREE_CODE(__t)); \
if (__c != 'r' && __c != 's' && __c != '<' \
&& __c != '1' && __c != '2' && __c != 'e') \
- tree_class_check_failed(__t, 'e', __FILE__, __LINE__, __FUNCTION__); \
+ tree_class_check_failed (__t, 'e', __FILE__, __LINE__, \
+ __FUNCTION__); \
__t; })
extern void tree_check_failed PARAMS ((const tree, enum tree_code,
&& TREE_OPERAND (EXP, 0) != error_mark_node \
&& (TYPE_MODE (TREE_TYPE (EXP)) \
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
- (EXP) = TREE_OPERAND (EXP, 0);
+ (EXP) = TREE_OPERAND (EXP, 0)
/* Like STRIP_NOPS, but don't let the signedness change either. */
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
&& (TREE_UNSIGNED (TREE_TYPE (EXP)) \
== TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
- (EXP) = TREE_OPERAND (EXP, 0);
+ (EXP) = TREE_OPERAND (EXP, 0)
/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
&& TREE_OPERAND (EXP, 0) != error_mark_node \
&& (TREE_TYPE (EXP) \
== TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
- (EXP) = TREE_OPERAND (EXP, 0);
+ (EXP) = TREE_OPERAND (EXP, 0)
/* Nonzero if TYPE represents an integral type. Note that we do not
include COMPLEX types here. */
#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. */
+/* 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 complete or is cv void. */
#define COMPLETE_OR_VOID_TYPE_P(NODE) \
- (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
+ (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
/* Nonzero if this type is complete or is an array with unspecified bound. */
#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
- (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : NODE))
+ (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
/* Nonzero if TYPE represents a type. */
construct the address of this field. This is used for aliasing
purposes: see record_component_aliases.
In CONSTRUCTOR nodes, it means object constructed must be in memory.
- In LABEL_DECL nodes, it means a goto for this label has been seen
+ In LABEL_DECL nodes, it means a goto for this label has been seen
from a place outside all binding contours that restore stack levels.
In ..._TYPE nodes, it means that objects of this type must
be fully addressable. This means that pieces of this
In a CONSTRUCTOR, nonzero means allocate static storage. */
#define TREE_STATIC(NODE) ((NODE)->common.static_flag)
+/* In a TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT, or element of a
+ block's cleanup list, means that the pertinent cleanup should only be
+ executed if an exception is thrown, not on normal exit of its scope. */
+#define CLEANUP_EH_ONLY(NODE) ((NODE)->common.static_flag)
+
/* In a CONVERT_EXPR, NOP_EXPR or COMPOUND_EXPR, this means the node was
made implicitly and should not lead to an "unused value" warning. */
#define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag)
chain is via a `virtual' declaration. */
#define TREE_VIA_VIRTUAL(NODE) ((NODE)->common.static_flag)
-/* In an INTEGER_CST, REAL_CST, or COMPLEX_CST, this means there was an
- overflow in folding. This is distinct from TREE_OVERFLOW because ANSI C
- requires a diagnostic when overflows occur in constant expressions. */
+/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means
+ there was an overflow in folding. This is distinct from
+ TREE_OVERFLOW because ANSI C requires a diagnostic when overflows
+ occur in constant expressions. */
#define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag)
/* In an IDENTIFIER_NODE, this means that assemble_name was called with
this string as an argument. */
-#define TREE_SYMBOL_REFERENCED(NODE) ((NODE)->common.static_flag)
+#define TREE_SYMBOL_REFERENCED(NODE) \
+ (IDENTIFIER_NODE_CHECK (NODE)->common.static_flag)
-/* In an INTEGER_CST, REAL_CST, of COMPLEX_CST, this means there was an
- overflow in folding, and no warning has been issued for this subexpression.
- TREE_OVERFLOW implies TREE_CONSTANT_OVERFLOW, but not vice versa. */
+/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
+ there was an overflow in folding, and no warning has been issued
+ for this subexpression. TREE_OVERFLOW implies
+ TREE_CONSTANT_OVERFLOW, but not vice versa. */
#define TREE_OVERFLOW(NODE) ((NODE)->common.public_flag)
/* In a VAR_DECL or FUNCTION_DECL,
/* Ditto, for `private' declarations. */
#define TREE_VIA_PRIVATE(NODE) ((NODE)->common.private_flag)
-/* Nonzero for TREE_LIST node means that the path to the
+/* Nonzero for TREE_LIST or TREE_VEC node means that the path to the
base class is via a `protected' declaration, which preserves
protected fields from the base class as protected.
OVERLOADED. */
#define TREE_READONLY(NODE) ((NODE)->common.readonly_flag)
/* Non-zero if NODE is a _DECL with TREE_READONLY set. */
-#define TREE_READONLY_DECL_P(NODE) \
- (TREE_READONLY (NODE) && DECL_P (NODE))
+#define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE))
/* Value of expression is constant.
Always appears in all ..._CST nodes.
The same bit is used in functions as DECL_BUILT_IN_NONANSI. */
#define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
-#define TYPE_TRAP_SIGNED(NODE) (flag_trapv && ! TREE_UNSIGNED (NODE))
+#define TYPE_TRAP_SIGNED(NODE) \
+ (flag_trapv && ! TREE_UNSIGNED (TYPE_CHECK (NODE)))
/* Nonzero in a VAR_DECL means assembler code has been written.
Nonzero in a FUNCTION_DECL means that the function has been compiled.
an exception. In a CALL_EXPR, nonzero means the call cannot throw. */
#define TREE_NOTHROW(NODE) ((NODE)->common.nothrow_flag)
+/* In a type, nonzero means that all objects of the type are guaranteed by the
+ language or front-end to be properly aligned, so we can indicate that a MEM
+ of this type is aligned at least to the alignment of the type, even if it
+ doesn't appear that it is. We see this, for example, in object-oriented
+ languages where a tag field may show this is an object of a more-aligned
+ variant of the more generic type. */
+#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag)
+
/* Used in classes in C++. */
#define TREE_PRIVATE(NODE) ((NODE)->common.private_flag)
/* Used in classes in C++.
#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)
+
/* These flags are available for each language front end to use internally. */
#define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0)
#define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1)
#define TREE_INT_CST_LOW(NODE) (TREE_INT_CST (NODE).low)
#define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high)
-#define INT_CST_LT(A, B) \
-(TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
- || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
- && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
-
-#define INT_CST_LT_UNSIGNED(A, B) \
-(((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
- < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
- || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
- == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
- && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
-
-struct tree_int_cst
+#define INT_CST_LT(A, B) \
+ (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
+ || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
+ && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
+
+#define INT_CST_LT_UNSIGNED(A, B) \
+ (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
+ < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
+ || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
+ == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
+ && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
+
+struct tree_int_cst GTY(())
{
struct tree_common common;
rtx rtl; /* acts as link to register transfer language
/* 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. */
- struct {
+ struct tree_int_cst_lowhi {
unsigned HOST_WIDE_INT low;
HOST_WIDE_INT high;
} int_cst;
};
-/* In REAL_CST, STRING_CST, COMPLEX_CST nodes, and CONSTRUCTOR nodes,
- and generally in all kinds of constants that could
- be given labels (rather than being immediate). */
+/* 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. */
-/* We can represent a real value as either a `double' or a string.
- Strings don't allow for any optimization, but they do allow
- for cross-compilation. */
-
-#define TREE_REAL_CST(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst)
+/* In a REAL_CST node. struct realvaluetype 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 realvaluetype;
-#include "real.h"
+#define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
+#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
-struct tree_real_cst
+struct tree_real_cst GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language
- (rtl) info */
- REAL_VALUE_TYPE real_cst;
+ rtx rtl; /* acts as link to register transfer language (rtl) info */
+ struct realvaluetype * real_cst_ptr;
};
/* In a STRING_CST */
#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
#define TREE_STRING_POINTER(NODE) (STRING_CST_CHECK (NODE)->string.pointer)
-struct tree_string
+struct tree_string GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language
- (rtl) info */
+ rtx rtl; /* acts as link to register transfer language (rtl) info */
int length;
const char *pointer;
};
#define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
-struct tree_complex
+struct tree_complex GTY(())
{
struct tree_common common;
- rtx rtl; /* acts as link to register transfer language
- (rtl) info */
+ rtx rtl; /* acts as link to register transfer language (rtl) info */
tree real;
tree imag;
};
+
+/* In a VECTOR_CST node. */
+#define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements)
+
+struct tree_vector GTY(())
+{
+ struct tree_common common;
+ rtx rtl;
+ tree elements;
+};
\f
#include "hashtable.h"
/* Define fields and accessors for some special-purpose tree nodes. */
#define IDENTIFIER_LENGTH(NODE) \
- (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
+ (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
#define IDENTIFIER_POINTER(NODE) \
- ((char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
+ ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
/* Translate a hash table identifier pointer to a tree_identifier
pointer, and vice versa. */
#define HT_IDENT_TO_GCC_IDENT(NODE) \
- ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
-#define GCC_IDENT_TO_HT_IDENT(NODE) \
- (&((struct tree_identifier *) (NODE))->id)
+ ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
+#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
-struct tree_identifier
+struct tree_identifier GTY(())
{
struct tree_common common;
struct ht_identifier id;
#define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
#define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
-struct tree_list
+struct tree_list GTY(())
{
struct tree_common common;
tree purpose;
/* In a TREE_VEC node. */
#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length)
#define TREE_VEC_ELT(NODE,I) (TREE_VEC_CHECK (NODE)->vec.a[I])
-#define TREE_VEC_END(NODE) ((void) TREE_VEC_CHECK (NODE),&((NODE)->vec.a[(NODE)->vec.length]))
+#define TREE_VEC_END(NODE) \
+ ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))
-struct tree_vec
+struct tree_vec GTY(())
{
struct tree_common common;
int length;
- tree a[1];
+ tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
};
/* Define fields and accessors for some nodes that represent expressions. */
/* In a SAVE_EXPR node. */
-#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND(NODE, 1)
-#define SAVE_EXPR_RTL(NODE) (*(rtx *) &EXPR_CHECK (NODE)->exp.operands[2])
-#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (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_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
SAVE_EXPRs are unsaved, meaning that there values are
recalculated.) */
-#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (NODE)
+#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (SAVE_EXPR_CHECK (NODE))
/* In a RTL_EXPR node. */
-#define RTL_EXPR_SEQUENCE(NODE) (*(rtx *) &EXPR_CHECK (NODE)->exp.operands[0])
-#define RTL_EXPR_RTL(NODE) (*(rtx *) &EXPR_CHECK (NODE)->exp.operands[1])
+#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])
/* In a WITH_CLEANUP_EXPR node. */
#define WITH_CLEANUP_EXPR_RTL(NODE) \
- (*(rtx *) &EXPR_CHECK (NODE)->exp.operands[2])
+ (*(rtx *) &WITH_CLEANUP_EXPR_CHECK (NODE)->exp.operands[2])
/* In a CONSTRUCTOR node. */
-#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1)
+#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (CONSTRUCTOR_CHECK (NODE), 1)
/* In ordinary expression nodes. */
#define TREE_OPERAND(NODE, I) (EXPR_CHECK (NODE)->exp.operands[I])
#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)
/* In a LABELED_BLOCK_EXPR node. */
-#define LABELED_BLOCK_LABEL(NODE) TREE_OPERAND (NODE, 0)
-#define LABELED_BLOCK_BODY(NODE) TREE_OPERAND (NODE, 1)
+#define LABELED_BLOCK_LABEL(NODE) \
+ TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 0)
+#define LABELED_BLOCK_BODY(NODE) \
+ TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 1)
-/* In a EXIT_BLOCK_EXPR node. */
-#define EXIT_BLOCK_LABELED_BLOCK(NODE) TREE_OPERAND (NODE, 0)
-#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND (NODE, 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)
/* In a LOOP_EXPR node. */
-#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (NODE, 0)
-
-/* In a EXPR_WITH_FILE_LOCATION node. */
-#define EXPR_WFL_NODE(NODE) TREE_OPERAND((NODE), 0)
+#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (LOOP_EXPR_CHECK (NODE), 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)
+#define EXPR_WFL_FILENAME_NODE(NODE) \
+ TREE_OPERAND (EXPR_WITH_FILE_LOCATION_CHECK (NODE), 1)
#define EXPR_WFL_FILENAME(NODE) \
- (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE ((NODE))))
-#define EXPR_WFL_FILENAME_NODE(NODE) TREE_OPERAND((NODE), 1)
-#define EXPR_WFL_LINENO(NODE) (EXPR_CHECK (NODE)->exp.complexity >> 12)
-#define EXPR_WFL_COLNO(NODE) (EXPR_CHECK (NODE)->exp.complexity & 0xfff)
+ IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (NODE))
+/* ??? Java uses this in all expressions. */
#define EXPR_WFL_LINECOL(NODE) (EXPR_CHECK (NODE)->exp.complexity)
+#define EXPR_WFL_LINENO(NODE) (EXPR_WFL_LINECOL (NODE) >> 12)
+#define EXPR_WFL_COLNO(NODE) (EXPR_WFL_LINECOL (NODE) & 0xfff)
#define EXPR_WFL_SET_LINECOL(NODE, LINE, COL) \
(EXPR_WFL_LINECOL(NODE) = ((LINE) << 12) | ((COL) & 0xfff))
-#define EXPR_WFL_EMIT_LINE_NOTE(NODE) ((NODE)->common.public_flag)
-struct tree_exp
+/* 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)
+
+struct tree_exp GTY(())
{
struct tree_common common;
int complexity;
- tree operands[1];
+ tree GTY ((special ("tree_exp"),
+ length ("TREE_CODE_LENGTH (TREE_CODE ((tree) &%h))")))
+ operands[1];
};
\f
/* In a BLOCK node. */
/* Nonzero means that this block is prepared to handle exceptions
listed in the BLOCK_VARS slot. */
-#define BLOCK_HANDLER_BLOCK(NODE) (BLOCK_CHECK (NODE)->block.handler_block_flag)
+#define BLOCK_HANDLER_BLOCK(NODE) \
+ (BLOCK_CHECK (NODE)->block.handler_block_flag)
/* An index number for this block. These values are not guaranteed to
be unique across functions -- whether or not they are depends on
One of the logical block fragments is arbitrarily chosen to be
the ORIGIN. The other fragments will point to the origin via
BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
- be null. The list of fragments will be chained through
+ be null. The list of fragments will be chained through
BLOCK_FRAGMENT_CHAIN from the origin. */
-#define BLOCK_FRAGMENT_ORIGIN(NODE) \
- (BLOCK_CHECK (NODE)->block.fragment_origin)
-#define BLOCK_FRAGMENT_CHAIN(NODE) \
- (BLOCK_CHECK (NODE)->block.fragment_chain)
+#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
+#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
-struct tree_block
+struct tree_block GTY(())
{
struct tree_common common;
#define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
+#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
/* Nonzero iff the typed-based alias set for this type has been
calculated. */
-#define TYPE_ALIAS_SET_KNOWN_P(NODE) \
- (TYPE_CHECK (NODE)->type.alias_set != -1)
+#define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1)
/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
to this type. */
#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align)
/* The alignment for NODE, in bytes. */
-#define TYPE_ALIGN_UNIT(NODE) \
- (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
+#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
/* If your language allows you to declare types, and you want debug info
for them, then you need to generate corresponding TYPE_DECL nodes.
to point back at the TYPE_DECL node. This allows the debug routines
to know that the two nodes represent the same type, so that we only
get one debug info record for them. */
-#define TYPE_STUB_DECL(NODE) (TREE_CHAIN (NODE))
+#define TYPE_STUB_DECL(NODE) TREE_CHAIN (NODE)
/* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
has BLKmode only because it lacks the alignment requirement for
#define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type.string_flag)
/* If non-NULL, this is an upper bound of the size (in bytes) of an
- object of the given ARRAY_TYPE. This allows temporaries to be allocated. */
-#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) TYPE_MAX_VALUE (ARRAY_TYPE)
+ object of the given ARRAY_TYPE. This allows temporaries to be
+ allocated. */
+#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
+ TYPE_MAX_VALUE (ARRAY_TYPE_CHECK (ARRAY_TYPE))
/* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */
-#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) (GET_MODE_NUNITS (TYPE_CHECK (VECTOR_TYPE)->type.mode))
+#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \
+ GET_MODE_NUNITS (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.mode)
/* Indicates that objects of this type must be initialized by calling a
function when they are created. */
#define MAX_POINTER_DEPTH 2
#define VA_LIST_POINTER_DEPTH 3
-struct tree_type
+struct die_struct;
+
+struct tree_type GTY(())
{
struct tree_common common;
tree values;
unsigned int align;
tree pointer_to;
tree reference_to;
- union {int address; char *pointer; } symtab;
+ union tree_type_symtab {
+ int address;
+ char * GTY ((tag ("1"))) pointer;
+ struct die_struct * GTY ((tag ("2"), skip (""))) die;
+ } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
+ descbits ("2"))) symtab;
tree name;
tree minval;
tree maxval;
from the base of the complete object to the base of the part of the
object that is allocated on behalf of this `type'.
This is always 0 except when there is multiple inheritance. */
-
+
#define BINFO_OFFSET(NODE) TREE_VEC_ELT ((NODE), 1)
#define TYPE_BINFO_OFFSET(NODE) BINFO_OFFSET (TYPE_BINFO (NODE))
#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
/* Accessor macro to get to the Nth basetype of this basetype. */
#define BINFO_BASETYPE(NODE,N) TREE_VEC_ELT (BINFO_BASETYPES (NODE), (N))
-#define TYPE_BINFO_BASETYPE(NODE,N) BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N)))
+#define TYPE_BINFO_BASETYPE(NODE,N) \
+ BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N)))
/* For a BINFO record describing a virtual base class, i.e., one where
TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
base. The actual contents are language-dependent. Under the old
ABI, the C++ front-end uses a FIELD_DECL whose contents are a
pointer to the virtual base; under the new ABI this field is
- instead a INTEGER_CST giving an offset into the vtable where the
+ instead an INTEGER_CST giving an offset into the vtable where the
offset to the virtual base can be found. */
-#define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT ((NODE), 5)
+#define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT (NODE, 5)
/* The size of a base class subobject of this type. Not all frontends
currently allocate the space for these fields. */
-#define BINFO_SIZE(NODE) TREE_VEC_ELT ((NODE), 6)
-#define BINFO_SIZE_UNIT(NODE) TREE_VEC_ELT ((NODE), 7)
+#define BINFO_SIZE(NODE) TREE_VEC_ELT (NODE, 6)
+#define BINFO_SIZE_UNIT(NODE) TREE_VEC_ELT (NODE, 7)
#define TYPE_BINFO_SIZE(NODE) BINFO_SIZE (TYPE_BINFO (NODE))
#define TYPE_BINFO_SIZE_UNIT(NODE) BINFO_SIZE_UNIT (TYPE_BINFO (NODE))
/* Nonzero if DECL represents a decl. */
#define DECL_P(DECL) (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd')
+
/* This is the name of the object as written by the user.
It is an IDENTIFIER_NODE. */
#define DECL_NAME(NODE) (DECL_CHECK (NODE)->decl.name)
+
/* The name of the object as the assembler will see it (but before any
translations made by ASM_OUTPUT_LABELREF). Often this is the same
as DECL_NAME. It is an IDENTIFIER_NODE. */
-#define DECL_ASSEMBLER_NAME(NODE) \
- ((DECL_ASSEMBLER_NAME_SET_P (NODE) \
- ? (void) 0 \
- : (*lang_set_decl_assembler_name) (NODE)), \
- DECL_CHECK (NODE)->decl.assembler_name)
-/* Returns non-zero if the DECL_ASSEMBLER_NAME for NODE has been
- set. If zero, the NODE might still have a DECL_ASSEMBLER_NAME --
- it just hasn't been set yet. */
+#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
+
+/* Returns non-zero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
+ the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
+ yet. */
#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
(DECL_CHECK (NODE)->decl.assembler_name != NULL_TREE)
+
/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
(DECL_CHECK (NODE)->decl.assembler_name = (NAME))
-/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if
- DECL1's DECL_ASSEMBLER_NAME has not yet been set, using this macro
- will not cause the DECL_ASSEMBLER_NAME of either DECL to be set.
- In other words, the semantics of using this macro, are different
- than saying:
-
+
+/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's
+ DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause
+ the DECL_ASSEMBLER_NAME of either DECL to be set. In other words, the
+ semantics of using this macro, are different than saying:
+
SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))
which will try to set the DECL_ASSEMBLER_NAME for DECL1. */
+
#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2) \
(DECL_ASSEMBLER_NAME_SET_P (DECL1) \
- ? (void) SET_DECL_ASSEMBLER_NAME (DECL2, \
- DECL_ASSEMBLER_NAME (DECL1)) \
+ ? (void) SET_DECL_ASSEMBLER_NAME (DECL2, \
+ DECL_ASSEMBLER_NAME (DECL1)) \
: (void) 0)
/* Records the section name in a section attribute. Used to pass
the name from decl_attributes to make_function_rtl and make_decl_rtl. */
#define DECL_SECTION_NAME(NODE) (DECL_CHECK (NODE)->decl.section_name)
+
/* For FIELD_DECLs, this is the
RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field is
a member of. For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL,
if so, the type that was originally specified for it.
TREE_TYPE may have been modified (in finish_struct). */
#define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->decl.result)
-/* In FUNCTION_DECL, a chain of ..._DECL nodes. */
-/* VAR_DECL and PARM_DECL reserve the arguments slot
- for language-specific uses. */
+/* In FUNCTION_DECL, a chain of ..._DECL nodes.
+ VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
+ uses. */
#define DECL_ARGUMENTS(NODE) (DECL_CHECK (NODE)->decl.arguments)
/* This field is used to reference anything in decl.result and is meant only
for use by the garbage collector. */
PROMOTED_MODE is defined, the mode of this expression may not be same
as DECL_MODE. In that case, DECL_MODE contains the mode corresponding
to the variable's data type, while the mode
- of DECL_RTL is the mode actually used to contain the data.
+ of DECL_RTL is the mode actually used to contain the data.
This value can be evaluated lazily for functions, variables with
static storage duration, and labels. */
? (NODE)->decl.rtl \
: (make_decl_rtl (NODE, NULL), (NODE)->decl.rtl))
/* Set the DECL_RTL for NODE to RTL. */
-#define SET_DECL_RTL(NODE, RTL) \
- (DECL_CHECK (NODE)->decl.rtl = (RTL))
+#define SET_DECL_RTL(NODE, RTL) (DECL_CHECK (NODE)->decl.rtl = (RTL))
/* Returns non-zero if the DECL_RTL for NODE has already been set. */
-#define DECL_RTL_SET_P(NODE) \
- (DECL_CHECK (NODE)->decl.rtl != NULL)
+#define DECL_RTL_SET_P(NODE) (DECL_CHECK (NODE)->decl.rtl != NULL)
/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for
NODE1, it will not be set for NODE2; this is a lazy copy. */
#define COPY_DECL_RTL(NODE1, NODE2) \
(DECL_CHECK (NODE2)->decl.rtl = DECL_CHECK (NODE1)->decl.rtl)
/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
-#define DECL_RTL_IF_SET(NODE) \
- (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
+#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
+
/* Holds an INSN_LIST of all of the live ranges in which the variable
has been moved to a possibly different register. */
#define DECL_LIVE_RANGE_RTL(NODE) (DECL_CHECK (NODE)->decl.live_range_rtl)
+
/* For PARM_DECL, holds an RTL for the stack slot or register
where the data was actually passed. */
#define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->decl.u2.r)
+
/* For FUNCTION_DECL, if it is inline, holds the saved insn chain. */
#define DECL_SAVED_INSNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f)
+
/* For FUNCTION_DECL, if it is built-in,
this identifies which built-in operation it is. */
#define DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.f)
to an INTEGER_CST node which is suitable for use as an index
into the virtual function table. */
#define DECL_VINDEX(NODE) (DECL_CHECK (NODE)->decl.vindex)
+
/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
which this FIELD_DECL is defined. This information is needed when
writing debugging information about vfield and vbase decls for C++. */
/* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
origin. This is useful when setting the DECL_ABSTRACT_ORIGIN. */
#define DECL_ORIGIN(NODE) \
- (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : NODE)
+ (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
/* Nonzero for any sort of ..._DECL node means this decl node represents an
inline instance of some original (abstract) decl from an inline function;
suppress any warnings about shadowing some other variable. FUNCTION_DECL
nodes can also have their abstract origin set to themselves. */
-#define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != (tree) 0 \
+#define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
/* Nonzero if a _DECL means that the name of this decl should be ignored
/* Nonzero if a _DECL means that no warnings should be generated just
because this decl is unused. */
-#define DECL_IN_SYSTEM_HEADER(NODE) (DECL_CHECK (NODE)->decl.in_system_header_flag)
+#define DECL_IN_SYSTEM_HEADER(NODE) \
+ (DECL_CHECK (NODE)->decl.in_system_header_flag)
/* Nonzero for a given ..._DECL node means that this node should be
put in .common, if possible. If a DECL_INITIAL is given, and it
/* In a TYPE_DECL
nonzero means the detail info about this type is not dumped into stabs.
- Instead it will generate cross reference ('x') of names.
+ Instead it will generate cross reference ('x') of names.
This uses the same flag as DECL_EXTERNAL. */
#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
-(TYPE_DECL_CHECK (NODE)->decl.external_flag)
+ (TYPE_DECL_CHECK (NODE)->decl.external_flag)
/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
#define DECL_REGISTER(NODE) (DECL_CHECK (NODE)->decl.regdecl_flag)
+
/* In LABEL_DECL nodes, nonzero means that an error message about
jumping into such a binding contour has been printed for this label. */
#define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl.regdecl_flag)
+
/* In a FIELD_DECL, indicates this field should be bit-packed. */
#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl.regdecl_flag)
+
/* In a FUNCTION_DECL with a non-zero DECL_CONTEXT, indicates that a
static chain is not needed. */
#define DECL_NO_STATIC_CHAIN(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
+/* In a VAR_DECL, nonzero if the data should be allocated from
+ thread-local storage. */
+#define DECL_THREAD_LOCAL(NODE) (VAR_DECL_CHECK (NODE)->decl.thread_local_flag)
+
/* In a FUNCTION_DECL, the saved representation of the body of the
entire function. Usually a COMPOUND_STMT, but in C++ this may also
be a RETURN_INIT, CTOR_INITIALIZER, or TRY_BLOCK. */
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)
+ (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
/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
specially. */
#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl.bit_field_flag)
+
/* In a LABEL_DECL, nonzero means label was defined inside a binding
contour that restored a stack level and which is now exited. */
#define DECL_TOO_LATE(NODE) (LABEL_DECL_CHECK (NODE)->decl.bit_field_flag)
/* In a FUNCTION_DECL, nonzero means a built in function. */
#define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
+
/* For a builtin function, identify which part of the compiler defined it. */
#define DECL_BUILT_IN_CLASS(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.built_in_class)
+ (FUNCTION_DECL_CHECK (NODE)->decl.built_in_class)
/* Used in VAR_DECLs to indicate that the variable is a vtable.
Used in FIELD_DECLs for vtable pointers.
argument should be passed in the same way that the first union
alternative would be passed. */
#define DECL_TRANSPARENT_UNION(NODE) \
-(PARM_DECL_CHECK (NODE)->decl.transparent_union)
+ (PARM_DECL_CHECK (NODE)->decl.transparent_union)
/* Used in FUNCTION_DECLs to indicate that they should be run automatically
at the beginning or end of execution. */
#define DECL_STATIC_CONSTRUCTOR(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag)
#define DECL_STATIC_DESTRUCTOR(NODE) \
(FUNCTION_DECL_CHECK (NODE)->decl.static_dtor_flag)
/* Used in FUNCTION_DECLs to indicate that function entry and exit should
be instrumented with calls to support routines. */
#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit)
-
-/* Used in FUNCTION_DECLs to indicate that check-memory-usage should be
- disabled in this function. */
-#define DECL_NO_CHECK_MEMORY_USAGE(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.no_check_memory_usage)
+ (FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit)
/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
disabled in this function. */
#define DECL_NO_LIMIT_STACK(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack)
+ (FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack)
/* Additional flags for language-specific uses. */
#define DECL_LANG_FLAG_0(NODE) (DECL_CHECK (NODE)->decl.lang_flag_0)
struct function;
-struct tree_decl
+struct tree_decl GTY(())
{
struct tree_common common;
const char *filename;
unsigned non_addr_const_p : 1;
unsigned no_instrument_function_entry_exit : 1;
- unsigned no_check_memory_usage : 1;
unsigned comdat_flag : 1;
unsigned malloc_flag : 1;
unsigned no_limit_stack : 1;
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 lang_flag_0 : 1;
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
- union {
+ union tree_decl_u1 {
/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
DECL_FUNCTION_CODE. */
enum built_in_function f;
HOST_WIDE_INT i;
/* DECL_ALIGN and DECL_OFFSET_ALIGN. (These are not used for
FUNCTION_DECLs). */
- struct {unsigned int align : 24; unsigned int off_align : 8;} a;
- } u1;
+ struct tree_decl_u1_a {
+ unsigned int align : 24;
+ unsigned int off_align : 8;
+ } a;
+ } GTY ((skip (""))) u1;
tree size_unit;
tree name;
In PARM_DECL, holds an RTL for the stack slot
of register where the data was actually passed.
Used by Chill and Java in LABEL_DECL and by C++ and Java in VAR_DECL. */
- union {
- struct function *f;
- rtx r;
- tree t;
+ union tree_decl_u2 {
+ struct function * GTY ((tag ("FUNCTION_DECL"))) f;
+ rtx GTY ((tag ("PARM_DECL"))) r;
+ tree GTY ((tag ("FIELD_DECL"))) t;
int i;
- } u2;
+ } GTY ((desc ("TREE_CODE((tree) &(%0))"))) u2;
/* In a FUNCTION_DECL, this is DECL_SAVED_TREE. */
tree saved_tree;
struct lang_decl *lang_specific;
};
\f
+enum tree_node_structure_enum {
+ TS_COMMON,
+ TS_INT_CST,
+ TS_REAL_CST,
+ TS_VECTOR,
+ TS_STRING,
+ TS_COMPLEX,
+ TS_IDENTIFIER,
+ TS_DECL,
+ TS_TYPE,
+ TS_LIST,
+ TS_VEC,
+ TS_EXP,
+ TS_BLOCK,
+ LAST_TS_ENUM
+};
+
/* Define the overall contents of a tree node.
It may be any of the structures declared above
for various types of node. */
-union tree_node
+union tree_node GTY ((ptr_alias (union lang_tree_node),
+ desc ("tree_node_structure (&%h)")))
{
- struct tree_common common;
- struct tree_int_cst int_cst;
- struct tree_real_cst real_cst;
- struct tree_string string;
- struct tree_complex complex;
- struct tree_identifier identifier;
- struct tree_decl decl;
- struct tree_type type;
- struct tree_list list;
- struct tree_vec vec;
- struct tree_exp exp;
- struct tree_block block;
+ struct tree_common GTY ((tag ("TS_COMMON"))) common;
+ struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst;
+ struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst;
+ struct tree_vector GTY ((tag ("TS_VECTOR"))) vector;
+ struct tree_string GTY ((tag ("TS_STRING"))) string;
+ struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
+ struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
+ struct tree_decl GTY ((tag ("TS_DECL"))) decl;
+ struct tree_type GTY ((tag ("TS_TYPE"))) type;
+ struct tree_list GTY ((tag ("TS_LIST"))) list;
+ struct tree_vec GTY ((tag ("TS_VEC"))) vec;
+ struct tree_exp GTY ((tag ("TS_EXP"))) exp;
+ struct tree_block GTY ((tag ("TS_BLOCK"))) block;
};
\f
/* Standard named or nameless data types of the C compiler. */
TI_UINTSI_TYPE,
TI_UINTDI_TYPE,
TI_UINTTI_TYPE,
-
+
TI_INTEGER_ZERO,
TI_INTEGER_ONE,
TI_INTEGER_MINUS_ONE,
TI_VOID_LIST_NODE,
+ TI_UV4SF_TYPE,
+ TI_UV4SI_TYPE,
+ TI_UV8HI_TYPE,
+ TI_UV8QI_TYPE,
+ TI_UV4HI_TYPE,
+ TI_UV2SI_TYPE,
+ TI_UV2SF_TYPE,
+ TI_UV2DI_TYPE,
+ TI_UV16QI_TYPE,
+
TI_V4SF_TYPE,
+ TI_V16SF_TYPE,
TI_V4SI_TYPE,
TI_V8HI_TYPE,
TI_V8QI_TYPE,
TI_V4HI_TYPE,
TI_V2SI_TYPE,
TI_V2SF_TYPE,
+ TI_V2DF_TYPE,
+ TI_V2DI_TYPE,
TI_V16QI_TYPE,
TI_MAIN_IDENTIFIER,
TI_MAX
};
-extern tree global_trees[TI_MAX];
+extern GTY(()) tree global_trees[TI_MAX];
#define error_mark_node global_trees[TI_ERROR_MARK]
-
+
#define intQI_type_node global_trees[TI_INTQI_TYPE]
#define intHI_type_node global_trees[TI_INTHI_TYPE]
#define intSI_type_node global_trees[TI_INTSI_TYPE]
#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
#define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
+#define unsigned_V16QI_type_node global_trees[TI_UV16QI_TYPE]
+#define unsigned_V4SI_type_node global_trees[TI_UV4SI_TYPE]
+#define unsigned_V8QI_type_node global_trees[TI_UV8QI_TYPE]
+#define unsigned_V8HI_type_node global_trees[TI_UV8HI_TYPE]
+#define unsigned_V4HI_type_node global_trees[TI_UV4HI_TYPE]
+#define unsigned_V2SI_type_node global_trees[TI_UV2SI_TYPE]
+#define unsigned_V2DI_type_node global_trees[TI_UV2DI_TYPE]
+
#define V16QI_type_node global_trees[TI_V16QI_TYPE]
#define V4SF_type_node global_trees[TI_V4SF_TYPE]
#define V4SI_type_node global_trees[TI_V4SI_TYPE]
#define V4HI_type_node global_trees[TI_V4HI_TYPE]
#define V2SI_type_node global_trees[TI_V2SI_TYPE]
#define V2SF_type_node global_trees[TI_V2SF_TYPE]
+#define V2DI_type_node global_trees[TI_V2DI_TYPE]
+#define V2DF_type_node global_trees[TI_V2DF_TYPE]
+#define V16SF_type_node global_trees[TI_V16SF_TYPE]
/* An enumeration of the standard C integer types. These must be
- ordered so that shorter types appear before longer ones. */
-enum integer_type_kind
+ ordered so that shorter types appear before longer ones, and so
+ that signed types appear before unsigned ones, for the correct
+ functioning of interpret_integer() in c-lex.c. */
+enum integer_type_kind
{
itk_char,
itk_signed_char,
/* The standard C integer types. Use integer_type_kind to index into
this array. */
-extern tree integer_types[itk_none];
+extern GTY(()) tree integer_types[itk_none];
#define char_type_node integer_types[itk_char]
#define signed_char_type_node integer_types[itk_signed_char]
extern char *permalloc PARAMS ((int));
extern char *expralloc PARAMS ((int));
+extern tree decl_assembler_name PARAMS ((tree));
/* Compute the number of bytes occupied by 'node'. This routine only
looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
to zero except for a few of the common fields. */
extern tree make_node PARAMS ((enum tree_code));
-extern tree make_lang_type PARAMS ((enum tree_code));
-extern tree (*make_lang_type_fn) PARAMS ((enum tree_code));
-/* Make a copy of a node, with all the same contents except
- for TREE_PERMANENT. (The copy is permanent
- iff nodes being made now are permanent.) */
+/* Make a copy of a node, with all the same contents. */
extern tree copy_node PARAMS ((tree));
/* Construct various types of nodes. */
-#define build_int_2(LO,HI) \
+#define build_int_2(LO, HI) \
build_int_2_wide ((unsigned HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))
extern tree build PARAMS ((enum tree_code, tree, ...));
extern tree build_nt PARAMS ((enum tree_code, ...));
extern tree build_int_2_wide PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT));
-extern tree build_real PARAMS ((tree, REAL_VALUE_TYPE));
+extern tree build_vector 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 tree make_unsigned_type PARAMS ((int));
extern void initialize_sizetypes PARAMS ((void));
extern void set_sizetype PARAMS ((tree));
-extern tree signed_or_unsigned_type PARAMS ((int, tree));
extern void fixup_unsigned_type PARAMS ((tree));
extern tree build_pointer_type PARAMS ((tree));
extern tree build_reference_type PARAMS ((tree));
int flags, bool *no_add_attrs));
};
-extern const struct attribute_spec default_target_attribute_table[];
-
/* Flags that may be passed in the third argument of decl_attributes, and
to handler functions for attributes. */
enum attribute_flags
extern void default_set_default_type_attributes PARAMS ((tree));
extern void default_insert_attributes PARAMS ((tree, tree *));
extern bool default_function_attribute_inlinable_p PARAMS ((tree));
+extern bool default_ms_bitfield_layout_p PARAMS ((tree));
+struct cpp_reader;
+extern void default_register_cpp_builtins PARAMS ((struct cpp_reader *));
/* Split a list of declspecs and attributes into two. */
extern tree merge_dllimport_decl_attributes PARAMS ((tree, tree));
#endif
+/* Return true if DECL will be always resolved to a symbol defined in the
+ same module (shared library or program). */
+#define MODULE_LOCAL_P(DECL) \
+ (lookup_attribute ("visibility", DECL_ATTRIBUTES (DECL)) != NULL)
+
/* Return a version of the TYPE, qualified as indicated by the
TYPE_QUALS, if one exists. If no qualified version exists yet,
return NULL_TREE. */
build_qualified_type instead. */
#define build_type_variant(TYPE, CONST_P, VOLATILE_P) \
- build_qualified_type (TYPE, \
+ build_qualified_type ((TYPE), \
((CONST_P) ? TYPE_QUAL_CONST : 0) \
| ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))
/* 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
instance variables) encountered in T. */
tree pending_statics;
UBITSIZETYPE, /* Unsifgned representation of sizes in bits. */
TYPE_KIND_LAST};
-extern tree sizetype_tab[(int) TYPE_KIND_LAST];
+extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST];
#define sizetype sizetype_tab[(int) SIZETYPE]
#define bitsizetype sizetype_tab[(int) BITSIZETYPE]
extern int fields_length PARAMS ((tree));
+/* Given an initializer INIT, return TRUE if INIT is zero or some
+ aggregate of zeros. Otherwise return FALSE. */
+
+extern bool initializer_zerop PARAMS ((tree));
+
/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
extern int integer_zerop PARAMS ((tree));
extern int first_rtl_op PARAMS ((enum tree_code));
+/* Return which tree structure is used by T. */
+
+enum tree_node_structure_enum tree_node_structure PARAMS ((tree));
+
/* unsave_expr (EXP) returns an expression equivalent to EXP but it
can be used multiple times and will evaluate EXP in its entirety
each time. */
extern void unsave_expr_1 PARAMS ((tree));
-/* Like unsave_expr_1, but recurses into all subtrees. */
-
-extern tree unsave_expr_now PARAMS ((tree));
-
-/* If non-null, these are language-specific helper functions for
- unsave_expr_now. If present, LANG_UNSAVE is called before its
- argument (an UNSAVE_EXPR) is to be unsaved, and all other
- processing in unsave_expr_now is aborted. LANG_UNSAVE_EXPR_NOW is
- called from unsave_expr_1 for language-specific tree codes. */
-extern void (*lang_unsave) PARAMS ((tree *));
-extern void (*lang_unsave_expr_now) PARAMS ((tree));
-
/* Return 0 if it is safe to evaluate EXPR multiple times,
return 1 if it is safe if EXPR is unsaved afterward, or
return 2 if it is completely unsafe. */
extern int unsafe_for_reeval PARAMS ((tree));
-/* If non-null, these are language-specific helper functions for
- unsafe_for_reeval. Return negative to not handle some tree. */
-extern int (*lang_unsafe_for_reeval) PARAMS ((tree));
-
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
or offset that depends on a field within a record.
extern tree get_narrower PARAMS ((tree, int *));
-/* Given MODE and UNSIGNEDP, return a suitable type-tree
- with that mode.
- The definition of this resides in language-specific code
- as the repertoire of available types may vary. */
-
-extern tree type_for_mode PARAMS ((enum machine_mode, int));
-
-/* Given PRECISION and UNSIGNEDP, return a suitable type-tree
- for an integer type with at least that precision.
- The definition of this resides in language-specific code
- as the repertoire of available types may vary. */
-
-extern tree type_for_size PARAMS ((unsigned, int));
-
-/* Given an integer type T, return a type like T but unsigned.
- If T is unsigned, the value is T.
- The definition of this resides in language-specific code
- as the repertoire of available types may vary. */
-
-extern tree unsigned_type PARAMS ((tree));
-
-/* Given an integer type T, return a type like T but signed.
- If T is signed, the value is T.
- The definition of this resides in language-specific code
- as the repertoire of available types may vary. */
-
-extern tree signed_type PARAMS ((tree));
-
-/* This function must be defined in the language-specific files.
- expand_expr calls it to build the cleanup-expression for a TARGET_EXPR.
- This is defined in a language-specific file. */
-
-extern tree maybe_build_cleanup PARAMS ((tree));
-
/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
look for nested component-refs or array-refs at constant positions
and find the ultimate containing object, which is returned. */
extern tree get_inner_reference PARAMS ((tree, HOST_WIDE_INT *,
HOST_WIDE_INT *, tree *,
enum machine_mode *, int *,
- int *, unsigned int *));
+ int *));
+
+/* Return 1 if T is an expression that get_inner_reference handles. */
+
+extern int handled_component_p PARAMS ((tree));
/* Given a DECL or TYPE, return the scope in which it was declared, or
NUL_TREE if there is no containing scope. */
/* Points to the FUNCTION_DECL of the function whose body we are reading. */
-extern tree current_function_decl;
+extern GTY(()) tree current_function_decl;
/* Nonzero means a FUNC_BEGIN label was emitted. */
-extern tree current_function_func_begin_label;
+extern GTY(()) tree current_function_func_begin_label;
/* Nonzero means all ..._TYPE nodes should be allocated permanently. */
extern int all_types_permanent;
-/* Pointer to function to compute the name to use to print a declaration.
- DECL is the declaration in question.
- VERBOSITY determines what information will be printed:
- 0: DECL_NAME, demangled as necessary.
- 1: and scope information.
- 2: and any other information that might be interesting, such as function
- parameter types in C++. */
-
-extern const char *(*decl_printable_name) PARAMS ((tree, int));
-
-/* Pointer to function to finish handling an incomplete decl at the
- end of compilation. */
-
-extern void (*incomplete_decl_finalize_hook) PARAMS ((tree));
-
-extern const char *init_parse PARAMS ((const char *));
-extern void finish_parse PARAMS ((void));
-
/* Declare a predefined function. Return the declaration. This function is
provided by each language frontend. */
extern tree builtin_function PARAMS ((const char *, tree, int,
extern tree get_callee_fndecl PARAMS ((tree));
extern void set_decl_assembler_name PARAMS ((tree));
extern int type_num_arguments PARAMS ((tree));
+extern tree lhd_unsave_expr_now PARAMS ((tree));
+
\f
/* In stmt.c */
extern int in_control_zone_p PARAMS ((void));
extern void expand_fixups PARAMS ((rtx));
-extern tree expand_start_stmt_expr PARAMS ((void));
+extern tree expand_start_stmt_expr PARAMS ((int));
extern tree expand_end_stmt_expr PARAMS ((tree));
extern void expand_expr_stmt PARAMS ((tree));
+extern void expand_expr_stmt_value PARAMS ((tree, int, int));
extern int warn_if_unused_value PARAMS ((tree));
extern void expand_decl_init PARAMS ((tree));
extern void clear_last_expr PARAMS ((void));
extern int expand_continue_loop PARAMS ((struct nesting *));
extern int expand_exit_loop PARAMS ((struct nesting *));
extern int expand_exit_loop_if_false PARAMS ((struct nesting *,
- tree));
+ tree));
+extern int expand_exit_loop_top_cond PARAMS ((struct nesting *,
+ tree));
extern int expand_exit_something PARAMS ((void));
extern void expand_return PARAMS ((tree));
extern tree last_cleanup_this_contour PARAMS ((void));
extern void expand_start_case PARAMS ((int, tree, tree,
const char *));
-extern void expand_end_case PARAMS ((tree));
+extern void expand_end_case_type PARAMS ((tree, tree));
+#define expand_end_case(cond) expand_end_case_type (cond, NULL)
extern int add_case_node PARAMS ((tree, tree,
tree, tree *));
extern int pushcase PARAMS ((tree,
extern int operand_equal_p PARAMS ((tree, tree, int));
extern tree invert_truthvalue PARAMS ((tree));
-/* In builtins.c. Given a type, apply default promotions wrt unnamed
- function arguments and return the new type. Return NULL_TREE if no
- change. Required by any language that supports variadic arguments. */
-
-extern tree (*lang_type_promotes_to) PARAMS ((tree));
extern tree fold_builtin PARAMS ((tree));
\f
-/* The language front-end must define these functions. */
-
-/* Function of no arguments for initializing the symbol table. */
-extern void init_decl_processing PARAMS ((void));
-
-/* Function to replace the DECL_LANG_SPECIFIC field of a DECL with a copy. */
-extern void copy_lang_decl PARAMS ((tree));
-
-/* Function called with no arguments to parse and compile the input. */
-extern int yyparse PARAMS ((void));
-/* Functions for processing symbol declarations. */
-/* Function to enter a new lexical scope.
- Takes one argument: always zero when called from outside the front end. */
-extern void pushlevel PARAMS ((int));
-/* Function to exit a lexical scope. It returns a BINDING for that scope.
- Takes three arguments:
- KEEP -- nonzero if there were declarations in this scope.
- REVERSE -- reverse the order of decls before returning them.
- FUNCTIONBODY -- nonzero if this level is the body of a function. */
-extern tree poplevel PARAMS ((int, int, int));
-/* Set the BLOCK node for the current scope level. */
-extern void set_block PARAMS ((tree));
-/* Function to add a decl to the current scope level.
- Takes one argument, a decl to add.
- Returns that decl, or, if the same symbol is already declared, may
- return a different decl for that name. */
-extern tree pushdecl PARAMS ((tree));
-/* Function to return the chain of decls so far in the current scope level. */
-extern tree getdecls PARAMS ((void));
-/* Function to return the chain of structure tags in the current scope level. */
-extern tree gettags PARAMS ((void));
-
extern tree build_range_type PARAMS ((tree, tree, tree));
/* In alias.c */
extern int readonly_fields_p PARAMS ((tree));
extern int objects_must_conflict_p PARAMS ((tree, tree));
-/* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing
- that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
- appropriate IDENTIFIER_NODE. Otherwise, set it to the
- ERROR_MARK_NODE to ensure that the assembler does not talk about
- it. */
-extern void (*lang_set_decl_assembler_name) PARAMS ((tree));
-
struct obstack;
/* In tree.c */
extern int int_fits_type_p PARAMS ((tree, tree));
extern int tree_log2 PARAMS ((tree));
extern int tree_floor_log2 PARAMS ((tree));
-extern void preserve_data PARAMS ((void));
-extern int object_permanent_p PARAMS ((tree));
-extern int type_precision PARAMS ((tree));
extern int simple_cst_equal PARAMS ((tree, tree));
-extern int compare_tree_int PARAMS ((tree, unsigned int));
+extern int compare_tree_int PARAMS ((tree,
+ unsigned HOST_WIDE_INT));
extern int type_list_equal PARAMS ((tree, tree));
extern int chain_member PARAMS ((tree, tree));
extern int chain_member_purpose PARAMS ((tree, 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_obstacks PARAMS ((void));
extern void build_common_tree_nodes PARAMS ((int));
extern void build_common_tree_nodes_2 PARAMS ((int));
-extern void mark_tree_hashtable PARAMS ((void *));
/* In function.c */
extern void setjmp_protect_args PARAMS ((void));
extern void pop_function_context PARAMS ((void));
extern void push_function_context_to PARAMS ((tree));
extern void pop_function_context_from PARAMS ((tree));
-extern void ggc_mark_struct_function PARAMS ((struct function *));
/* In print-rtl.c */
#ifdef BUFSIZ
a decl attribute to the declaration rather than to its type). */
extern tree decl_attributes PARAMS ((tree *, tree, int));
-/* The following function must be provided by front ends
- using attribs.c. */
-
-/* Possibly apply default attributes to a function (represented by
- a FUNCTION_DECL). */
-extern void insert_default_attributes PARAMS ((tree));
-
-/* Table of machine-independent attributes for checking formats, if used. */
-extern const struct attribute_spec *format_attribute_table;
-
-/* Table of machine-independent attributes for a particular language. */
-extern const struct attribute_spec *lang_attribute_table;
-
-/* Flag saying whether common language attributes are to be supported. */
-extern int lang_attribute_common;
-
-/* In front end. */
-
-extern int mark_addressable PARAMS ((tree));
-extern void incomplete_type_error PARAMS ((tree, tree));
-extern void print_lang_statistics PARAMS ((void));
-extern tree truthvalue_conversion PARAMS ((tree));
-#ifdef BUFSIZ
-extern void print_lang_decl PARAMS ((FILE *, tree, int));
-extern void print_lang_type PARAMS ((FILE *, tree, int));
-extern void print_lang_identifier PARAMS ((FILE *, tree, int));
-#endif
-extern int global_bindings_p PARAMS ((void));
-extern void insert_block PARAMS ((tree));
-
/* In integrate.c */
extern void save_for_inline PARAMS ((tree));
extern void set_decl_abstract_flags PARAMS ((tree, int));
extern void output_inline_function PARAMS ((tree));
extern void set_decl_origin_self PARAMS ((tree));
-/* In front end. */
-extern void set_yydebug PARAMS ((int));
-
/* In stor-layout.c */
extern void fixup_signed_type PARAMS ((tree));
extern void internal_reference_types PARAMS ((void));
extern void expand_asm_operands PARAMS ((tree, tree, tree, tree, int,
const char *, int));
extern int any_pending_cleanups PARAMS ((int));
-extern void init_stmt PARAMS ((void));
extern void init_stmt_for_function PARAMS ((void));
extern int drop_through_at_end_p PARAMS ((void));
extern void expand_start_target_temps PARAMS ((void));
extern void save_stack_pointer PARAMS ((void));
extern void expand_decl PARAMS ((tree));
extern int expand_decl_cleanup PARAMS ((tree, tree));
+extern int expand_decl_cleanup_eh PARAMS ((tree, tree, int));
extern void expand_anon_union_decl PARAMS ((tree, tree, tree));
extern void move_cleanups_up PARAMS ((void));
extern void expand_start_case_dummy 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));
-#ifdef BUFSIZ
-extern void lang_print_xnode PARAMS ((FILE *, tree, int));
-#endif
-
/* If KIND=='I', return a suitable global initializer (constructor) name.
If KIND=='D', return a suitable global clean-up (destructor) name. */
typedef tree (*walk_tree_fn) PARAMS ((tree *, int *, void *));
+/* In tree-dump.c */
+
+/* Different tree dump places. When you add new tree dump places,
+ extend the DUMP_FILES array in tree-dump.c */
+enum tree_dump_index
+{
+ TDI_all, /* dump the whole translation unit */
+ TDI_class, /* dump class hierarchy */
+ TDI_original, /* dump each function before optimizing it */
+ TDI_optimized, /* dump each function after optimizing it */
+ TDI_inlined, /* dump each function after inlining
+ within it. */
+ TDI_end
+};
+
+/* Bit masks to control tree dumping. Not all values are applicable to
+ all tree dumps. Add new ones at the end. When you define new
+ values, extend the DUMP_OPTIONS array in tree-dump.c */
+#define TDF_ADDRESS (1 << 0) /* dump node addresses */
+#define TDF_SLIM (1 << 1) /* don't go wild following links */
+
+typedef struct dump_info *dump_info_p;
+
+extern int dump_flag PARAMS ((dump_info_p, int, tree));
+extern int dump_enabled_p PARAMS ((enum tree_dump_index));
+extern FILE *dump_begin PARAMS ((enum tree_dump_index, int *));
+extern void dump_end PARAMS ((enum tree_dump_index, FILE *));
+extern void dump_node PARAMS ((tree, int, FILE *));
+extern int dump_switch_p PARAMS ((const char *));
+extern const char *dump_flag_name PARAMS ((enum tree_dump_index));
+
\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
