/* Codes that identify the various built in functions
so that expand_call can identify them quickly. */
-#define DEF_BUILTIN(x) x,
+#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA) ENUM,
enum built_in_function
{
#include "builtins.def"
/* Names for the above. */
extern const char *const built_in_names[(int) END_BUILTINS];
+
+/* An array of _DECL trees for the above. */
+extern union tree_node *built_in_decls[(int) END_BUILTINS];
\f
/* The definition of tree nodes fills the next several pages. */
ENUM_BITFIELD(tree_code) code : 8;
unsigned side_effects_flag : 1;
unsigned constant_flag : 1;
- unsigned permanent_flag : 1;
unsigned addressable_flag : 1;
unsigned volatile_flag : 1;
unsigned readonly_flag : 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;
};
/* The following table lists the uses of each of the above flags and
TREE_OVERFLOW in
INTEGER_CST, REAL_CST, COMPLEX_CST
TREE_PUBLIC in
- VAR_DECL or FUNCTION_DECL
+ VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
TREE_VIA_PUBLIC in
TREE_LIST or TREE_VEC
EXPR_WFL_EMIT_LINE_NOTE in
TREE_READONLY in
all expressions
- ITERATOR_BOUND_P in
- VAR_DECL if iterator (C)
TYPE_READONLY in
..._TYPE
TREE_CONSTANT in
all expressions
- permanent_flag: TREE_PERMANENT in all nodes
-
unsigned_flag:
TREE_UNSIGNED in
INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL
DECL_BUILT_IN_NONANSI in
FUNCTION_DECL
- TREE_PARMLIST in
- TREE_PARMLIST (C++)
SAVE_EXPR_NOPLACEHOLDER in
SAVE_EXPR
bounded_flag:
TREE_BOUNDED in
- expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL
+ expressions, VAR_DECL, PARM_DECL, FIELD_DECL, FUNCTION_DECL,
+ IDENTIFIER_NODE
TYPE_BOUNDED in
..._TYPE
*/
/* The tree-code says what kind of node it is.
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 = (int) (VALUE))
+#define TREE_SET_CODE(NODE, 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. */
#define TREE_CHECK(t, code) __extension__ \
({ const tree __t = t; \
if (TREE_CODE(__t) != (code)) \
- tree_check_failed (__t, code, __FILE__, \
- __LINE__, __PRETTY_FUNCTION__); \
+ tree_check_failed (__t, code, __FILE__, __LINE__, __FUNCTION__); \
__t; })
#define TREE_CLASS_CHECK(t, class) __extension__ \
({ const tree __t = t; \
if (TREE_CODE_CLASS(TREE_CODE(__t)) != (class)) \
- tree_class_check_failed (__t, class, __FILE__, \
- __LINE__, __PRETTY_FUNCTION__); \
+ tree_class_check_failed (__t, class, __FILE__, __LINE__, __FUNCTION__); \
__t; })
/* These checks have to be special cased. */
({ const tree __t = t; \
enum tree_code __c = TREE_CODE(__t); \
if (__c != CONSTRUCTOR && TREE_CODE_CLASS(__c) != 'c') \
- tree_check_failed (__t, CONSTRUCTOR, __FILE__, \
- __LINE__, __PRETTY_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)); \
if (__c != 'r' && __c != 's' && __c != '<' \
&& __c != '1' && __c != '2' && __c != 'e') \
- tree_class_check_failed(__t, 'e', __FILE__, \
- __LINE__, __PRETTY_FUNCTION__); \
+ tree_class_check_failed(__t, 'e', __FILE__, __LINE__, __FUNCTION__); \
__t; })
extern void tree_check_failed PARAMS ((const tree, enum tree_code,
/* In all nodes that are expressions, this is the data type of the expression.
In POINTER_TYPE nodes, this is the type that the pointer points to.
- In ARRAY_TYPE nodes, this is the type of the elements. */
+ In ARRAY_TYPE nodes, this is the type of the elements.
+ In VECTOR_TYPE nodes, this is the type of the elements. */
#define TREE_TYPE(NODE) ((NODE)->common.type)
/* Nodes are chained together for many purposes.
/* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs
that don't change the machine mode. */
-#define STRIP_NOPS(EXP) \
+#define STRIP_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_MODE (TREE_TYPE (EXP)) \
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
(EXP) = TREE_OPERAND (EXP, 0);
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_MODE (TREE_TYPE (EXP)) \
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
&& (TREE_UNSIGNED (TREE_TYPE (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 \
&& (TREE_TYPE (EXP) \
== TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
(EXP) = TREE_OPERAND (EXP, 0);
/* In a VAR_DECL or FUNCTION_DECL,
nonzero means name is to be accessible from outside this module.
- In an identifier node, nonzero means an external declaration
+ In an IDENTIFIER_NODE, nonzero means an external declaration
accessible from outside this module was previously seen
for this name in an inner scope. */
#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
if the value is constant. */
#define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
-/* Nonzero means permanent node;
- node will continue to exist for the entire compiler run.
- Otherwise it will be recycled at the end of the function.
- This flag is always zero if garbage collection is in use.
- Try not to use this. Only set it with TREE_SET_PERMANENT. */
-#define TREE_PERMANENT(NODE) ((NODE)->common.permanent_flag)
-#define TREE_SET_PERMANENT(NODE) do { \
- if (!ggc_p && current_obstack == &permanent_obstack) \
- TREE_PERMANENT(NODE) = 1; \
-} while (0)
-
/* 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. */
#define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
+#define TYPE_TRAP_SIGNED(NODE) (flag_trapv && ! TREE_UNSIGNED (NODE))
+
/* Nonzero in a VAR_DECL means assembler code has been written.
Nonzero in a FUNCTION_DECL means that the function has been compiled.
This is interesting in an inline function, since it might not need
If the data type is signed, the value is sign-extended to 2 words
even though not all of them may really be in use.
In an unsigned constant shorter than 2 words, the extra bits are 0. */
-#define TREE_INT_CST_LOW(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst_low)
-#define TREE_INT_CST_HIGH(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst_high)
+#define TREE_INT_CST(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst)
+#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) \
struct tree_common common;
struct rtx_def *rtl; /* acts as link to register transfer language
(rtl) info */
- unsigned HOST_WIDE_INT int_cst_low;
- HOST_WIDE_INT int_cst_high;
+ /* 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 {
+ unsigned HOST_WIDE_INT low;
+ HOST_WIDE_INT high;
+ } int_cst;
};
/* In REAL_CST, STRING_CST, COMPLEX_CST nodes, and CONSTRUCTOR nodes,
struct rtx_def *rtl; /* acts as link to register transfer language
(rtl) info */
int length;
- char *pointer;
+ const char *pointer;
};
/* In a COMPLEX_CST node. */
union tree_node *imag;
};
\f
+#include "hashtable.h"
+
/* Define fields and accessors for some special-purpose tree nodes. */
-#define IDENTIFIER_LENGTH(NODE) (IDENTIFIER_NODE_CHECK (NODE)->identifier.length)
-#define IDENTIFIER_POINTER(NODE) (IDENTIFIER_NODE_CHECK (NODE)->identifier.pointer)
+#define IDENTIFIER_LENGTH(NODE) \
+ (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
+#define IDENTIFIER_POINTER(NODE) \
+ ((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)
struct tree_identifier
{
struct tree_common common;
- int length;
- char *pointer;
+ struct ht_identifier id;
};
/* In a TREE_LIST node. */
#define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[0])
#define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[1])
-/* In a CALL_EXPR node. */
-#define CALL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[2])
-
/* In a CONSTRUCTOR node. */
#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1)
#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
/* Note: when changing this, make sure to find the places
that use chainon or nreverse. */
-#define BLOCK_CHAIN(NODE) TREE_CHAIN (NODE)
+#define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE))
#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
#define BLOCK_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag)
#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
#define TYPE_NONCOPIED_PARTS(NODE) (TYPE_CHECK (NODE)->type.noncopied_parts)
#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
-#define TYPE_OBSTACK(NODE) (TYPE_CHECK (NODE)->type.obstack)
#define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific)
+/* For a VECTOR_TYPE node, this describes a different type which is emitted
+ in the debugging output. We use this to describe a vector as a
+ 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
The value is an int, measured in bits. */
#define TYPE_ALIGN(NODE) (TYPE_CHECK (NODE)->type.align)
+/* 1 if the alignment for this type was requested by "aligned" attribute,
+ 0 if it is the default for 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)
+/* If your language allows you to declare types, and you want debug info
+ for them, then you need to generate corresponding TYPE_DECL nodes.
+ These "stub" TYPE_DECL nodes have no name, and simply point at the
+ type node. You then set the TYPE_STUB_DECL field of the type node
+ 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))
/* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
its size. */
#define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
-/* In an INTEGER_TYPE, it means the type represents a size. We use this
- both for validity checking and to permit optimziations that are unsafe
- for other types. */
-#define TYPE_IS_SIZETYPE(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
+/* In an INTEGER_TYPE, it means the type represents a size. We use
+ this both for validity checking and to permit optimizations that
+ are unsafe for other types. Note that the C `size_t' type should
+ *not* have this flag set. The `size_t' type is simply a typedef
+ for an ordinary integer type that happens to be the type of an
+ expression returned by `sizeof'; `size_t' has no special
+ properties. Expressions whose type have TYPE_IS_SIZETYPE set are
+ always actual sizes. */
+#define TYPE_IS_SIZETYPE(NODE) \
+ (INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag)
+
+/* In a FUNCTION_TYPE, indicates that the function returns with the stack
+ pointer depressed. */
+#define TYPE_RETURNS_STACK_DEPRESSED(NODE) \
+ (FUNCTION_TYPE_CHECK (NODE)->type.no_force_blk_flag)
/* Nonzero in a type considered volatile as a whole. */
#define TYPE_VOLATILE(NODE) ((NODE)->common.volatile_flag)
object of the given ARRAY_TYPE. This allows temporaries to be allocated. */
#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) TYPE_MAX_VALUE (ARRAY_TYPE)
-/* Indicates that objects of this type must be initialized by calling a
+/* 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))
+
+ /* Indicates that objects of this type must be initialized by calling a
function when they are created. */
#define TYPE_NEEDS_CONSTRUCTING(NODE) \
(TYPE_CHECK (NODE)->type.needs_constructing_flag)
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
+ unsigned user_align : 1;
unsigned int align;
union tree_node *pointer_to;
union tree_node *binfo;
union tree_node *noncopied_parts;
union tree_node *context;
- struct obstack *obstack;
HOST_WIDE_INT alias_set;
/* Points to a structure whose details depend on the language in use. */
struct lang_type *lang_specific;
/* 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)
-/* This is 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_CHECK (NODE)->decl.assembler_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_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:
+
+ 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) 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)
#define DECL_SIZE(NODE) (DECL_CHECK (NODE)->decl.size)
/* Likewise for the size in bytes. */
#define DECL_SIZE_UNIT(NODE) (DECL_CHECK (NODE)->decl.size_unit)
-/* Holds the alignment required for the datum. */
+/* Holds the alignment required for the datum, in bits. */
#define DECL_ALIGN(NODE) (DECL_CHECK (NODE)->decl.u1.a.align)
-/* For FIELD_DECLs, holds the alignment that DECL_FIELD_OFFSET has. */
-#define DECL_OFFSET_ALIGN(NODE) (FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align)
+/* The alignment of NODE, in bytes. */
+#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
+/* For FIELD_DECLs, off_align holds the number of low-order bits of
+ DECL_FIELD_OFFSET which are known to be always zero.
+ DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
+ has. */
+#define DECL_OFFSET_ALIGN(NODE) \
+ (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align)
+/* Specify that DECL_ALIGN(NODE) is a multiple of X. */
+#define SET_DECL_OFFSET_ALIGN(NODE, X) \
+ (FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align = exact_log2 ((X) & -(X)))
+/* 1 if the alignment for this type was requested by "aligned" attribute,
+ 0 if it is the default for this type. */
+#define DECL_USER_ALIGN(NODE) (DECL_CHECK (NODE)->decl.user_align)
/* Holds the machine mode corresponding to the declaration of a variable or
field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
FIELD_DECL. */
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. */
-#define DECL_RTL(NODE) (DECL_CHECK (NODE)->decl.rtl)
+ 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. */
+#define DECL_RTL(NODE) \
+ (DECL_CHECK (NODE)->decl.rtl \
+ ? (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))
+/* 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)
+/* 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)
/* 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)
#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 inline,
- holds the size of the stack frame, as an integer. */
-#define DECL_FRAME_SIZE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.i)
/* 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)
#define DECL_ORIGIN(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
- (see save_for_inline_copying). */
+/* 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 \
&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
where it is called. */
#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inline_flag)
+/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
+#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
+
/* 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. */
unsigned pure_flag : 1;
unsigned pointer_depth : 2;
unsigned non_addressable : 1;
- /* Four unused bits. */
+ unsigned user_align : 1;
+ unsigned uninlinable : 1;
+ /* Two unused bits. */
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
- /* For a FUNCTION_DECL, if inline, this is the size of frame needed.
- If built-in, this is the code for which built-in function.
- For other kinds of decls, this is DECL_ALIGN and DECL_OFFSET_ALIGN. */
union {
- HOST_WIDE_INT i;
+ /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
+ DECL_FUNCTION_CODE. */
enum built_in_function f;
+ /* In a FUNCITON_DECL for which DECL_BUILT_IN does not hold, this
+ is used by language-dependent code. */
+ 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;
TI_INTEGER_ZERO,
TI_INTEGER_ONE,
+ TI_INTEGER_MINUS_ONE,
TI_NULL_POINTER,
TI_SIZE_ZERO,
TI_PTRDIFF_TYPE,
TI_VA_LIST_TYPE,
+ TI_VOID_LIST_NODE,
+
+ TI_V4SF_TYPE,
+ TI_V4SI_TYPE,
+ TI_V8QI_TYPE,
+ TI_V4HI_TYPE,
+ TI_V2SI_TYPE,
+
+ TI_MAIN_IDENTIFIER,
+
TI_MAX
};
#define integer_zero_node global_trees[TI_INTEGER_ZERO]
#define integer_one_node global_trees[TI_INTEGER_ONE]
+#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]
#define size_zero_node global_trees[TI_SIZE_ZERO]
#define size_one_node global_trees[TI_SIZE_ONE]
#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]
#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
+/* The node that should be placed at the end of a parameter list to
+ indicate that the function does not take a variable number of
+ arguments. The TREE_VALUE will be void_type_node and there will be
+ no TREE_CHAIN. Language-independent code should not assume
+ anything else about this node. */
+#define void_list_node global_trees[TI_VOID_LIST_NODE]
+
+#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
+#define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
+
+#define V4SF_type_node global_trees[TI_V4SF_TYPE]
+#define V4SI_type_node global_trees[TI_V4SI_TYPE]
+#define V8QI_type_node global_trees[TI_V8QI_TYPE]
+#define V4HI_type_node global_trees[TI_V4HI_TYPE]
+#define V2SI_type_node global_trees[TI_V2SI_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
\f
#define NULL_TREE (tree) NULL
-/* The following functions accept a wide integer argument. Rather than
- having to cast on every function call, we use a macro instead, that is
- defined here and in rtl.h. */
+/* Approximate positive square root of a host double. This is for
+ statistical reports, not code generation. */
+extern double approx_sqrt PARAMS ((double));
-#ifndef exact_log2
-#define exact_log2(N) exact_log2_wide ((unsigned HOST_WIDE_INT) (N))
-#define floor_log2(N) floor_log2_wide ((unsigned HOST_WIDE_INT) (N))
-#endif
-extern int exact_log2_wide PARAMS ((unsigned HOST_WIDE_INT));
-extern int floor_log2_wide PARAMS ((unsigned HOST_WIDE_INT));
-
-extern char *oballoc PARAMS ((int));
extern char *permalloc PARAMS ((int));
-extern char *savealloc PARAMS ((int));
extern char *expralloc PARAMS ((int));
+/* 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. */
+
+extern size_t tree_size PARAMS ((tree));
+
/* Lowest level primitive for allocating a node.
The TREE_CODE is the only argument. Contents are initialized
to zero except for a few of the common fields. */
extern tree build PARAMS ((enum tree_code, tree, ...));
extern tree build_nt PARAMS ((enum tree_code, ...));
-extern tree build_parse_node 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_string PARAMS ((int, const char *));
extern tree build1 PARAMS ((enum tree_code, tree, tree));
extern tree build_tree_list PARAMS ((tree, tree));
-extern tree build_decl_list PARAMS ((tree, tree));
-extern tree build_expr_list PARAMS ((tree, tree));
extern tree build_decl PARAMS ((enum tree_code, tree, tree));
extern tree build_block PARAMS ((tree, tree, tree, tree, tree));
extern tree build_expr_wfl PARAMS ((tree, const char *, int, int));
extern void fixup_unsigned_type PARAMS ((tree));
extern tree build_pointer_type PARAMS ((tree));
extern tree build_reference_type PARAMS ((tree));
+extern tree build_type_no_quals PARAMS ((tree));
extern tree build_index_type PARAMS ((tree));
extern tree build_index_2_type PARAMS ((tree, tree));
extern tree build_array_type PARAMS ((tree, tree));
extern int attribute_list_contained PARAMS ((tree, tree));
extern int tree_int_cst_equal PARAMS ((tree, tree));
extern int tree_int_cst_lt PARAMS ((tree, tree));
+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 tree_expr_nonnegative_p PARAMS ((tree));
+extern int rtl_expr_nonnegative_p PARAMS ((struct rtx_def *));
extern int index_type_equal PARAMS ((tree, tree));
extern tree get_inner_array_type PARAMS ((tree));
extern tree merge_attributes PARAMS ((tree, tree));
-/* Given a type node TYPE and a TYPE_QUALIFIER_SET, return a type for
- the same kind of data as TYPE describes. Variants point to the
- "main variant" (which has no qualifiers set) via TYPE_MAIN_VARIANT,
- and it points to a chain of other variants so that duplicate
- variants are never made. Only main variants should ever appear as
- types of expressions. */
+/* 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. */
+
+extern tree get_qualified_type PARAMS ((tree, int));
+
+/* Like get_qualified_type, but creates the type if it does not
+ exist. This function never returns NULL_TREE. */
extern tree build_qualified_type PARAMS ((tree, int));
unsigned int record_align;
/* The alignment of the record so far, not including padding, 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 static variables (i.e., class variables, as opposed to
instance variables) encountered in T. */
tree pending_statics;
int packed_maybe_necessary;
} *record_layout_info;
+extern void set_lang_adjust_rli PARAMS ((void (*) PARAMS
+ ((record_layout_info))));
extern record_layout_info start_record_layout PARAMS ((tree));
extern tree bit_from_pos PARAMS ((tree, tree));
extern tree byte_from_pos PARAMS ((tree, tree));
extern tree round_up PARAMS ((tree, int));
extern tree round_down PARAMS ((tree, int));
extern tree get_pending_sizes PARAMS ((void));
+extern int is_pending_size PARAMS ((tree));
+extern void put_pending_size PARAMS ((tree));
extern void put_pending_sizes PARAMS ((tree));
/* Type for sizes of data-type. */
/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
extern tree tree_cons PARAMS ((tree, tree, tree));
-extern tree perm_tree_cons PARAMS ((tree, tree, tree));
-extern tree temp_tree_cons PARAMS ((tree, tree, tree));
-extern tree saveable_tree_cons PARAMS ((tree, tree, tree));
-extern tree decl_tree_cons PARAMS ((tree, tree, tree));
-extern tree expr_tree_cons PARAMS ((tree, tree, tree));
/* Return the last tree node in a chain. */
/* 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));
+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.
/* Current line number in input file. */
extern int lineno;
-/* Nonzero for -pedantic switch: warn about anything
- that standard C forbids. */
-extern int pedantic;
-
/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
Zero means allow extended lvalues. */
\f
/* In tree.c */
extern char *perm_calloc PARAMS ((int, long));
-extern tree get_file_function_name PARAMS ((int));
+extern void clean_symbol_name PARAMS ((char *));
extern tree get_file_function_name_long PARAMS ((const char *));
extern tree get_set_constructor_bits PARAMS ((tree, char *, int));
extern tree get_set_constructor_bytes PARAMS ((tree,
unsigned char *, int));
extern tree get_callee_fndecl PARAMS ((tree));
+extern void set_decl_assembler_name PARAMS ((tree));
+extern int type_num_arguments PARAMS ((tree));
\f
/* In stmt.c */
extern void expand_start_elseif PARAMS ((tree));
extern struct nesting *expand_start_loop PARAMS ((int));
extern struct nesting *expand_start_loop_continue_elsewhere PARAMS ((int));
+extern struct nesting *expand_start_null_loop PARAMS ((void));
extern void expand_loop_continue_here PARAMS ((void));
extern void expand_end_loop PARAMS ((void));
+extern void expand_end_null_loop 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));
extern int expand_exit_something PARAMS ((void));
-extern void expand_null_return PARAMS ((void));
extern void expand_return PARAMS ((tree));
extern int optimize_tail_recursion PARAMS ((tree, struct rtx_def *));
extern void expand_start_bindings_and_block PARAMS ((int, tree));
extern void end_cleanup_deferral PARAMS ((void));
extern int is_body_block PARAMS ((tree));
-extern void mark_block_as_eh_region PARAMS ((void));
-extern void mark_block_as_not_eh_region PARAMS ((void));
-extern int is_eh_region PARAMS ((void));
extern int conditional_context PARAMS ((void));
extern tree last_cleanup_this_contour PARAMS ((void));
-extern int expand_dhc_cleanup PARAMS ((tree));
-extern int expand_dcc_cleanup PARAMS ((tree));
extern void expand_start_case PARAMS ((int, tree, tree,
const char *));
extern void expand_end_case PARAMS ((tree));
+extern int add_case_node PARAMS ((tree, tree,
+ tree, tree *));
extern int pushcase PARAMS ((tree,
tree (*) (tree, tree),
tree, tree *));
change. Required by any language that supports variadic arguments. */
extern tree (*lang_type_promotes_to) PARAMS ((tree));
-\f
-/* Interface of the DWARF2 unwind info support. */
-
-/* Decide whether we want to emit frame unwind information for the current
- translation unit. */
-
-extern int dwarf2out_do_frame PARAMS ((void));
-
-/* Generate a new label for the CFI info to refer to. */
-
-extern char *dwarf2out_cfi_label PARAMS ((void));
-
-/* Entry point to update the canonical frame address (CFA). */
-
-extern void dwarf2out_def_cfa PARAMS ((const char *, unsigned, long));
-
-/* Add the CFI for saving a register window. */
-
-extern void dwarf2out_window_save PARAMS ((const char *));
-
-/* Add a CFI to update the running total of the size of arguments pushed
- onto the stack. */
-
-extern void dwarf2out_args_size PARAMS ((const char *, long));
-
-/* Entry point for saving a register to the stack. */
-
-extern void dwarf2out_reg_save PARAMS ((const char *, unsigned, long));
-
-/* Entry point for saving the return address in the stack. */
-
-extern void dwarf2out_return_save PARAMS ((const char *, long));
-
-/* Entry point for saving the return address in a register. */
-
-extern void dwarf2out_return_reg PARAMS ((const char *, unsigned));
-
-/* Output a marker (i.e. a label) for the beginning of a function, before
- the prologue. */
-
-extern void dwarf2out_begin_prologue PARAMS ((void));
-
-/* Output a marker (i.e. a label) for the absolute end of the generated
- code for a function definition. */
-
-extern void dwarf2out_end_epilogue PARAMS ((void));
+extern tree fold_builtin PARAMS ((tree));
\f
/* The language front-end must define these functions. */
-/* Function of no arguments for initializing options. */
-extern void lang_init_options PARAMS ((void));
-
/* Function of no arguments for initializing lexical scanning. */
extern void init_lex PARAMS ((void));
/* Function of no arguments for initializing the symbol table. */
extern void init_decl_processing PARAMS ((void));
-/* Functions called with no arguments at the beginning and end or processing
- the input source file. */
-extern void lang_init PARAMS ((void));
-extern void lang_finish PARAMS ((void));
-
/* Function to identify which front-end produced the output file. */
extern const char *lang_identify PARAMS ((void));
/* Function called with no arguments to parse and compile the input. */
extern int yyparse PARAMS ((void));
-/* Function called with option as argument
- to decode options starting with -f or -W or +.
- It should return nonzero if it handles the option. */
-extern int lang_decode_option PARAMS ((int, char **));
-
/* 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 tree build_range_type PARAMS ((tree, tree, tree));
-/* Call when starting to parse a declaration:
- make expressions in the declaration last the length of the function.
- Returns an argument that should be passed to resume_momentary later. */
-extern int suspend_momentary PARAMS ((void));
-
-extern int allocation_temporary_p PARAMS ((void));
-
-/* Call when finished parsing a declaration:
- restore the treatment of node-allocation that was
- in effect before the suspension.
- YES should be the value previously returned by suspend_momentary. */
-extern void resume_momentary PARAMS ((int));
-
-/* Called after finishing a record, union or enumeral type. */
-extern void rest_of_type_compilation PARAMS ((tree, int));
-
-/* Save the current set of obstacks, but don't change them. */
-extern void push_obstacks_nochange PARAMS ((void));
+/* In alias.c */
+extern void record_component_aliases PARAMS ((tree));
+extern HOST_WIDE_INT get_alias_set PARAMS ((tree));
+extern int alias_sets_conflict_p PARAMS ((HOST_WIDE_INT,
+ HOST_WIDE_INT));
+extern int readonly_fields_p PARAMS ((tree));
+extern int objects_must_conflict_p PARAMS ((tree, tree));
-extern void permanent_allocation PARAMS ((int));
-extern void push_momentary PARAMS ((void));
-extern void clear_momentary PARAMS ((void));
-extern void pop_momentary PARAMS ((void));
-extern void end_temporary_allocation PARAMS ((void));
+/* In c-common.c */
+extern HOST_WIDE_INT lang_get_alias_set PARAMS ((tree));
-/* Pop the obstack selection stack. */
-extern void pop_obstacks PARAMS ((void));
+/* 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));
-/* In alias.c */
-void record_component_aliases PARAMS ((tree));
+struct obstack;
/* In tree.c */
extern int really_constant_p PARAMS ((tree));
-extern void push_obstacks PARAMS ((struct obstack *,
- struct obstack *));
-extern void pop_momentary_nofree PARAMS ((void));
-extern void preserve_momentary PARAMS ((void));
-extern void saveable_allocation PARAMS ((void));
-extern void temporary_allocation PARAMS ((void));
-extern void resume_temporary_allocation PARAMS ((void));
-extern tree get_file_function_name PARAMS ((int));
extern void set_identifier_size PARAMS ((int));
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_initializer PARAMS ((void));
extern void preserve_data PARAMS ((void));
extern int object_permanent_p PARAMS ((tree));
extern int type_precision PARAMS ((tree));
extern void type_hash_add PARAMS ((unsigned int, tree));
extern unsigned int type_hash_list PARAMS ((tree));
extern int simple_cst_list_equal PARAMS ((tree, tree));
-extern void debug_obstack PARAMS ((char *));
-extern void rtl_in_current_obstack PARAMS ((void));
-extern void rtl_in_saveable_obstack PARAMS ((void));
-extern void init_tree_codes PARAMS ((void));
extern void dump_tree_statistics PARAMS ((void));
extern void print_obstack_statistics PARAMS ((const char *,
struct obstack *));
#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 void start_identifier_warnings PARAMS ((void));
extern void gcc_obstack_init PARAMS ((struct obstack *));
extern void init_obstacks PARAMS ((void));
-extern void obfree PARAMS ((char *));
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));
#endif
/* In expr.c */
-extern void emit_queue PARAMS ((void));
extern int apply_args_register_offset PARAMS ((int));
extern struct rtx_def *expand_builtin_return_addr
PARAMS ((enum built_in_function, int, struct rtx_def *));
-extern void do_pending_stack_adjust PARAMS ((void));
-extern struct rtx_def *expand_assignment PARAMS ((tree, tree, int,
- int));
-extern struct rtx_def *store_expr PARAMS ((tree,
- struct rtx_def *,
- int));
extern void check_max_integer_computation_mode PARAMS ((tree));
/* In emit-rtl.c */
extern void start_sequence_for_rtl_expr PARAMS ((tree));
-extern struct rtx_def *emit_line_note_after PARAMS ((const char *, int,
- struct rtx_def *));
extern struct rtx_def *emit_line_note PARAMS ((const char *, int));
-extern struct rtx_def *emit_line_note_force PARAMS ((const char *, int));
/* In calls.c */
extern void incomplete_type_error PARAMS ((tree, tree));
extern void print_lang_statistics PARAMS ((void));
extern tree truthvalue_conversion PARAMS ((tree));
-extern void split_specs_attrs PARAMS ((tree, tree *, tree *));
#ifdef BUFSIZ
extern void print_lang_decl PARAMS ((FILE *, tree, int));
extern void print_lang_type PARAMS ((FILE *, tree, int));
extern void insert_block PARAMS ((tree));
/* In integrate.c */
-extern void save_for_inline_nocopy PARAMS ((tree));
-extern void save_for_inline_copying PARAMS ((tree));
+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 stor-layout.c */
extern void fixup_signed_type PARAMS ((tree));
+extern void internal_reference_types PARAMS ((void));
/* varasm.c */
-extern void make_decl_rtl PARAMS ((tree, const char *, int));
+extern void make_decl_rtl PARAMS ((tree, const char *));
extern void make_decl_one_only PARAMS ((tree));
extern int supports_one_only PARAMS ((void));
extern void variable_section PARAMS ((tree, int));
/* In stmt.c */
extern void emit_nop PARAMS ((void));
extern void expand_computed_goto PARAMS ((tree));
-extern struct rtx_def *label_rtx PARAMS ((tree));
extern void expand_asm_operands PARAMS ((tree, tree, tree, tree, int,
const char *, int));
extern int any_pending_cleanups PARAMS ((int));
extern void expand_start_target_temps PARAMS ((void));
extern void expand_end_target_temps PARAMS ((void));
extern void expand_elseif PARAMS ((tree));
+extern void save_stack_pointer PARAMS ((void));
extern void expand_decl PARAMS ((tree));
extern int expand_decl_cleanup PARAMS ((tree, tree));
extern void expand_anon_union_decl PARAMS ((tree, tree, tree));
code for a function definition. */
extern void dwarf2out_end_epilogue PARAMS ((void));
-
+\f
/* Redefine abort to report an internal error w/o coredump, and
reporting the location of the error in the source file. This logic
is duplicated in rtl.h and tree.h because every file that needs the
extern void fancy_abort PARAMS ((const char *, int, const char *))
ATTRIBUTE_NORETURN;
-#if (GCC_VERSION >= 2007)
-#define abort() fancy_abort (__FILE__, __LINE__, __PRETTY_FUNCTION__)
-#else
-#define abort() fancy_abort (__FILE__, __LINE__, 0)
-#endif
+#define abort() fancy_abort (__FILE__, __LINE__, __FUNCTION__)
OSDN Git Service
