/* Front-end tree definitions for GNU compiler.
- Copyright (C) 1989 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include "machmode.h"
-/* codes of tree nodes */
+#ifndef RTX_CODE
+struct rtx_def;
+#endif
+
+/* Codes of tree nodes */
#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM,
BUILT_IN_STRCMP,
BUILT_IN_STRLEN,
BUILT_IN_FSQRT,
+ BUILT_IN_SIN,
+ BUILT_IN_COS,
BUILT_IN_GETEXP,
BUILT_IN_GETMAN,
BUILT_IN_SAVEREGS,
BUILT_IN_FRAME_ADDRESS,
BUILT_IN_RETURN_ADDRESS,
BUILT_IN_CALLER_RETURN_ADDRESS,
+ BUILT_IN_APPLY_ARGS,
+ BUILT_IN_APPLY,
+ BUILT_IN_RETURN,
+ BUILT_IN_SETJMP,
+ BUILT_IN_LONGJMP,
/* C++ extensions */
BUILT_IN_NEW,
BUILT_IN_VEC_NEW,
BUILT_IN_DELETE,
- BUILT_IN_VEC_DELETE
+ BUILT_IN_VEC_DELETE,
+
+ /* Upper bound on non-language-specific builtins. */
+ END_BUILTINS
};
\f
/* The definition of tree nodes fills the next several pages. */
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
- /* There is room for two more flags. */
+ /* There is room for three more flags. */
};
+/* The following table lists the uses of each of the above flags and
+ for which types of nodes they are defined. Note that expressions
+ include decls.
+
+ addressable_flag:
+
+ TREE_ADDRESSABLE in
+ VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, LABEL_DECL, ..._TYPE
+ IDENTIFIER_NODE
+
+ static_flag:
+
+ TREE_STATIC in
+ VAR_DECL, FUNCTION_DECL, CONSTRUCTOR
+ TREE_NO_UNUSED_WARNING in
+ CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR
+ TREE_VIA_VIRTUAL in
+ TREE_LIST or TREE_VEC
+ TREE_CONSTANT_OVERFLOW in
+ INTEGER_CST, REAL_CST, COMPLEX_CST
+ TREE_SYMBOL_REFERENCED in
+ IDENTIFIER_NODE
+
+ public_flag:
+
+ TREE_OVERFLOW in
+ INTEGER_CST, REAL_CST, COMPLEX_CST
+ TREE_PUBLIC in
+ VAR_DECL or FUNCTION_DECL
+ TREE_VIA_PUBLIC in
+ TREE_LIST or TREE_VEC
+
+ private_flag:
+
+ TREE_VIA_PRIVATE in
+ TREE_LIST or TREE_VEC
+ TREE_PRIVATE in
+ ??? unspecified nodes
+
+ protected_flag:
+
+ TREE_VIA_PROTECTED in
+ TREE_LIST
+ TREE_PROTECTED in
+ BLOCK
+ ??? unspecified nodes
+
+ side_effects_flag:
+
+ TREE_SIDE_EFFECTS in
+ all expressions
+
+ volatile_flag:
+
+ TREE_THIS_VOLATILE in
+ all expressions
+ TYPE_VOLATILE in
+ ..._TYPE
+
+ readonly_flag:
+
+ TREE_READONLY in
+ VAR_DECL, PARM_DECL, FIELD_DECL, ..._REF
+ ITERATOR_BOUND_P in
+ VAR_DECL if iterator (C)
+ TYPE_READONLY in
+ ..._TYPE
+
+ constant_flag:
+
+ 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++)
+
+ asm_written_flag:
+
+ TREE_ASM_WRITTEN in
+ VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
+ BLOCK
+
+ used_flag:
+
+ TREE_USED in
+ expressions, IDENTIFIER_NODE
+
+ raises_flag:
+
+ TREE_RAISES in
+ expressions
+
+ */
/* Define accessors for the fields that all tree nodes have
(though some fields are not used for all kinds of nodes). */
&& (TREE_TYPE (EXP) \
== TREE_TYPE (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 INTEGRAL_TYPE_P(TYPE) \
+ (TREE_CODE (TYPE) == INTEGER_TYPE || TREE_CODE (TYPE) == ENUMERAL_TYPE \
+ || TREE_CODE (TYPE) == BOOLEAN_TYPE || TREE_CODE (TYPE) == CHAR_TYPE)
+
+/* Nonzero if TYPE represents a floating-point type, including complex
+ floating-point types. */
+
+#define FLOAT_TYPE_P(TYPE) \
+ (TREE_CODE (TYPE) == REAL_TYPE \
+ || (TREE_CODE (TYPE) == COMPLEX_TYPE \
+ && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE))
+
+/* Nonzero if TYPE represents an aggregate (multi-component) type. */
+
+#define AGGREGATE_TYPE_P(TYPE) \
+ (TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \
+ || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
+ || TREE_CODE (TYPE) == SET_TYPE)
+
+/* Nonzero if TYPE represents a pointer type. */
+
+#define POINTER_TYPE_P(TYPE) \
+ (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
\f
/* Define many boolean fields that all tree nodes have. */
In a CONSTRUCTOR, nonzero means allocate static storage. */
#define TREE_STATIC(NODE) ((NODE)->common.static_flag)
-/* In a CONVERT_EXPR or NOP_EXPR, this means the node was made
- implicitly and should not lead to an "unused value" warning. */
+/* 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)
-/* In a NON_LVALUE_EXPR, this means there was overflow in folding.
- The folded constant is inside the NON_LVALUE_EXPR. */
-#define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag)
-
/* Nonzero for a TREE_LIST or TREE_VEC node means that the derivation
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. */
+#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)
+
+/* 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. */
+#define TREE_OVERFLOW(NODE) ((NODE)->common.public_flag)
+
/* 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
base class is via a `protected' declaration, which preserves
protected fields from the base class as protected.
OVERLOADED. */
-#define TREE_VIA_PROTECTED(NODE) ((NODE)->common.static_flag)
+#define TREE_VIA_PROTECTED(NODE) ((NODE)->common.protected_flag)
/* In any expression, nonzero means it has side effects or reevaluation
of the whole expression could produce a different value.
Nonzero in a FUNCTION_DECL means that the function has been compiled.
This is interesting in an inline function, since it might not need
to be compiled separately.
- Nonzero in a RECORD_TYPE, UNION_TYPE or ENUMERAL_TYPE
+ Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
if the sdb debugging info for the type has been written.
In a BLOCK node, nonzero if reorder_blocks has already seen this block. */
#define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag)
struct tree_int_cst
{
char common[sizeof (struct tree_common)];
+ struct rtx_def *rtl; /* acts as link to register transfer language
+ (rtl) info */
HOST_WIDE_INT int_cst_low;
HOST_WIDE_INT int_cst_high;
};
#define BLOCK_CHAIN(NODE) TREE_CHAIN (NODE)
#define BLOCK_ABSTRACT_ORIGIN(NODE) ((NODE)->block.abstract_origin)
#define BLOCK_ABSTRACT(NODE) ((NODE)->block.abstract_flag)
+#define BLOCK_END_NOTE(NODE) ((NODE)->block.end_note)
/* Nonzero means that this block is prepared to handle exceptions
listed in the BLOCK_VARS slot. */
union tree_node *subblocks;
union tree_node *supercontext;
union tree_node *abstract_origin;
+ struct rtx_def *end_note;
};
\f
/* Define fields and accessors for nodes representing data types. */
#define TYPE_MIN_VALUE(NODE) ((NODE)->type.minval)
#define TYPE_MAX_VALUE(NODE) ((NODE)->type.maxval)
#define TYPE_PRECISION(NODE) ((NODE)->type.precision)
-#define TYPE_PARSE_INFO(NODE) ((NODE)->type.parse_info)
-#define TYPE_SYMTAB_ADDRESS(NODE) ((NODE)->type.symtab_address)
+#define TYPE_SYMTAB_ADDRESS(NODE) ((NODE)->type.symtab.address)
+#define TYPE_SYMTAB_POINTER(NODE) ((NODE)->type.symtab.pointer)
#define TYPE_NAME(NODE) ((NODE)->type.name)
#define TYPE_NEXT_VARIANT(NODE) ((NODE)->type.next_variant)
#define TYPE_MAIN_VARIANT(NODE) ((NODE)->type.main_variant)
#define TYPE_BINFO(NODE) ((NODE)->type.binfo)
#define TYPE_NONCOPIED_PARTS(NODE) ((NODE)->type.noncopied_parts)
#define TYPE_CONTEXT(NODE) ((NODE)->type.context)
+#define TYPE_OBSTACK(NODE) ((NODE)->type.obstack)
#define TYPE_LANG_SPECIFIC(NODE) ((NODE)->type.lang_specific)
+/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
+ to this type. */
+#define TYPE_ATTRIBUTES(NODE) ((NODE)->type.attributes)
+
/* The alignment necessary for objects of this type.
The value is an int, measured in bits. */
#define TYPE_ALIGN(NODE) ((NODE)->type.align)
#define TYPE_STUB_DECL(NODE) (TREE_CHAIN (NODE))
-/* In a RECORD_TYPE or UNION_TYPE, it means the type has BLKmode
- only because it lacks the alignment requirement for its size. */
+/* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
+ has BLKmode only because it lacks the alignment requirement for
+ its size. */
#define TYPE_NO_FORCE_BLK(NODE) ((NODE)->type.no_force_blk_flag)
/* Nonzero in a type considered volatile as a whole. */
#define TYPE_LANG_FLAG_5(NODE) ((NODE)->type.lang_flag_5)
#define TYPE_LANG_FLAG_6(NODE) ((NODE)->type.lang_flag_6)
+/* If set in an ARRAY_TYPE, indicates a string type (for languages
+ that distinguish string from array of char).
+ If set in a SET_TYPE, indicates a bitstring type. */
+#define TYPE_STRING_FLAG(NODE) ((NODE)->type.string_flag)
+
+/* If non-NULL, this is a 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)
+
+/* Indicates that objects of this type must be initialized by calling a
+ function when they are created. */
+#define TYPE_NEEDS_CONSTRUCTING(NODE) ((NODE)->type.needs_constructing_flag)
+
+/* Indicates that objects of this type (a UNION_TYPE), should be passed
+ the same way that the first union alternative would be passed. */
+#define TYPE_TRANSPARENT_UNION(NODE) ((NODE)->type.transparent_union_flag)
+
+/* Indicated that objects of this type should be layed out in as
+ compact a way as possible. */
+#define TYPE_PACKED(NODE) ((NODE)->type.packed_flag)
+
struct tree_type
{
char common[sizeof (struct tree_common)];
union tree_node *values;
union tree_node *size;
+ union tree_node *attributes;
unsigned uid;
+ unsigned char precision;
#ifdef ONLY_INT_FIELDS
int mode : 8;
#else
enum machine_mode mode : 8;
#endif
- unsigned char align;
- unsigned char precision;
+ unsigned string_flag : 1;
unsigned no_force_blk_flag : 1;
+ unsigned needs_constructing_flag : 1;
+ unsigned transparent_union_flag : 1;
+ unsigned packed_flag : 1;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_2 : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
+ /* room for 4 more bits */
+ unsigned int align;
union tree_node *pointer_to;
union tree_node *reference_to;
- int parse_info;
- int symtab_address;
+ union {int address; char *pointer; } symtab;
union tree_node *name;
union tree_node *minval;
union tree_node *maxval;
union tree_node *binfo;
union tree_node *noncopied_parts;
union tree_node *context;
+ struct obstack *obstack;
/* Points to a structure whose details depend on the language in use. */
struct lang_type *lang_specific;
};
#define BINFO_BASETYPES(NODE) TREE_VEC_ELT ((NODE), 4)
#define TYPE_BINFO_BASETYPES(NODE) TREE_VEC_ELT (TYPE_BINFO (NODE), 4)
+/* For a BINFO record describing an inheritance, this yields a pointer
+ to the artificial FIELD_DECL node which contains the "virtual base
+ class pointer" for the given inheritance. */
+
+#define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT ((NODE), 5)
+
/* 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)))
/* This is the name of the object as written by the user.
It is an IDENTIFIER_NODE. */
#define DECL_NAME(NODE) ((NODE)->decl.name)
-/* This macro is marked for death. */
-#define DECL_PRINT_NAME(NODE) ((NODE)->decl.print_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) ((NODE)->decl.assembler_name)
+/* 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) ((NODE)->decl.section_name)
/* For FIELD_DECLs, this is the
- RECORD_TYPE or UNION_TYPE node that the field is a member of. For
- VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes,
- this points to the FUNCTION_DECL for the containing function, or else
- yields NULL_TREE if the given decl has "file scope". */
+ 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,
+ and CONST_DECL nodes, this points to either the FUNCTION_DECL for the
+ containing function, the RECORD_TYPE or UNION_TYPE for the containing
+ type, or NULL_TREE if the given decl has "file scope". */
#define DECL_CONTEXT(NODE) ((NODE)->decl.context)
#define DECL_FIELD_CONTEXT(NODE) ((NODE)->decl.context)
+/* In a DECL this is the field where configuration dependent machine
+ attributes are store */
+#define DECL_MACHINE_ATTRIBUTES(NODE) ((NODE)->decl.machine_attributes)
/* In a FIELD_DECL, this is the field position, counting in bits,
of the bit closest to the beginning of the structure. */
#define DECL_FIELD_BITPOS(NODE) ((NODE)->decl.arguments)
#define DECL_ARGUMENTS(NODE) ((NODE)->decl.arguments)
/* In FUNCTION_DECL, holds the decl for the return value. */
#define DECL_RESULT(NODE) ((NODE)->decl.result)
+/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
+#define DECL_ORIGINAL_TYPE(NODE) ((NODE)->decl.result)
/* In PARM_DECL, holds the type as written (perhaps a function or array). */
#define DECL_ARG_TYPE_AS_WRITTEN(NODE) ((NODE)->decl.result)
/* For a FUNCTION_DECL, holds the tree of BINDINGs.
/* For a PARM_DECL, records the data type used to pass the argument,
which may be different from the type seen in the program. */
#define DECL_ARG_TYPE(NODE) ((NODE)->decl.initial) /* In PARM_DECL. */
+/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
+ if nonzero, indicates that the field occupies the type. */
+#define DECL_QUALIFIER(NODE) ((NODE)->decl.initial)
/* These two fields describe where in the source code the declaration was. */
#define DECL_SOURCE_FILE(NODE) ((NODE)->decl.filename)
#define DECL_SOURCE_LINE(NODE) ((NODE)->decl.linenum)
Need not be constant. */
#define DECL_SIZE(NODE) ((NODE)->decl.size)
/* Holds the alignment required for the datum. */
-#define DECL_ALIGN(NODE) ((NODE)->decl.frame_size)
-/* Holds the machine mode of a variable or field. */
+#define DECL_ALIGN(NODE) ((NODE)->decl.frame_size.u)
+/* 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. */
#define DECL_MODE(NODE) ((NODE)->decl.mode)
-/* Holds the RTL expression for the value of a variable or function. */
+/* Holds the RTL expression for the value of a variable or function. If
+ 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) ((NODE)->decl.rtl)
/* For PARM_DECL, holds an RTL for the stack slot or register
where the data was actually passed. */
#define DECL_INCOMING_RTL(NODE) ((NODE)->decl.saved_insns.r)
/* For FUNCTION_DECL, if it is inline, holds the saved insn chain. */
#define DECL_SAVED_INSNS(NODE) ((NODE)->decl.saved_insns.r)
-/* For FUNCTION_DECL for built-in function. */
-#define DECL_FUNCTION_CODE(NODE) \
- ((enum built_in_function) (NODE)->decl.frame_size)
-#define DECL_SET_FUNCTION_CODE(NODE,VAL) \
- ((NODE)->decl.frame_size = (int) (VAL))
/* For FUNCTION_DECL, if it is inline,
holds the size of the stack frame, as an integer. */
-#define DECL_FRAME_SIZE(NODE) ((NODE)->decl.frame_size)
+#define DECL_FRAME_SIZE(NODE) ((NODE)->decl.frame_size.i)
+/* For FUNCTION_DECL, if it is built-in,
+ this identifies which built-in operation it is. */
+#define DECL_FUNCTION_CODE(NODE) ((NODE)->decl.frame_size.f)
+#define DECL_SET_FUNCTION_CODE(NODE,VAL) ((NODE)->decl.frame_size.f = (VAL))
/* For a FIELD_DECL, holds the size of the member as an integer. */
#define DECL_FIELD_SIZE(NODE) ((NODE)->decl.saved_insns.i)
/* Nonzero for a given ..._DECL node means that this node represents an
"abstract instance" of the given declaration (e.g. in the original
declaration of an inline function). When generating symbolic debugging
- information, we musn't try to generate any address information for nodes
+ information, we mustn't try to generate any address information for nodes
marked as "abstract instances" because we don't actually generate
any code or allocate any data space for such instances. */
#define DECL_ABSTRACT(NODE) ((NODE)->decl.abstract_flag)
because this decl is unused. */
#define DECL_IN_SYSTEM_HEADER(NODE) ((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
+ is not error_mark_node, then the decl cannot be put in .common. */
+#define DECL_COMMON(NODE) ((NODE)->decl.common_flag)
+
/* Language-specific decl information. */
#define DECL_LANG_SPECIFIC(NODE) ((NODE)->decl.lang_specific)
do not allocate storage, and refer to a definition elsewhere. */
#define DECL_EXTERNAL(NODE) ((NODE)->decl.external_flag)
-/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.
- In LABEL_DECL nodes, nonzero means that an error message about
- jumping into such a binding contour has been printed for this label. */
+/* 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.
+ This uses the same flag as DECL_EXTERNAL. */
+#define TYPE_DECL_SUPPRESS_DEBUG(NODE) ((NODE)->decl.external_flag)
+
+
+/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
#define DECL_REGISTER(NODE) ((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) ((NODE)->decl.regdecl_flag)
/* In a FIELD_DECL, indicates this field should be bit-packed. */
#define DECL_PACKED(NODE) ((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) ((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.
#define DECL_TOO_LATE(NODE) ((NODE)->decl.bit_field_flag)
/* In a FUNCTION_DECL, nonzero means a built in function. */
#define DECL_BUILT_IN(NODE) ((NODE)->decl.bit_field_flag)
+/* In a VAR_DECL that's static,
+ nonzero if the space is in the text section. */
+#define DECL_IN_TEXT_SECTION(NODE) ((NODE)->decl.bit_field_flag)
/* Used in VAR_DECLs to indicate that the variable is a vtable.
- It is also used in FIELD_DECLs for vtable pointers. */
+ Used in FIELD_DECLs for vtable pointers.
+ Used in FUNCTION_DECLs to indicate that the function is virtual. */
#define DECL_VIRTUAL_P(NODE) ((NODE)->decl.virtual_flag)
+/* Used to indicate that the linkage status of this DECL is not yet known,
+ so it should not be output now. */
+#define DECL_DEFER_OUTPUT(NODE) ((NODE)->decl.defer_output)
+
+/* Used in PARM_DECLs whose type are unions to indicate that the
+ argument should be passed in the same way that the first union
+ alternative would be passed. */
+#define DECL_TRANSPARENT_UNION(NODE) ((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) ((NODE)->decl.static_ctor_flag)
+#define DECL_STATIC_DESTRUCTOR(NODE) ((NODE)->decl.static_dtor_flag)
+
+/* Used to indicate that this DECL represents a compiler-generated entity. */
+#define DECL_ARTIFICIAL(NODE) ((NODE)->decl.artificial_flag)
+
+/* Used to indicate that this DECL has weak linkage. */
+#define DECL_WEAK(NODE) ((NODE)->decl.weak_flag)
+
+/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
+ multiple translation units should be merged. */
+#define DECL_ONE_ONLY(NODE) ((NODE)->decl.transparent_union)
+
/* Additional flags for language-specific uses. */
#define DECL_LANG_FLAG_0(NODE) ((NODE)->decl.lang_flag_0)
#define DECL_LANG_FLAG_1(NODE) ((NODE)->decl.lang_flag_1)
char common[sizeof (struct tree_common)];
char *filename;
int linenum;
- union tree_node *size;
unsigned int uid;
+ union tree_node *size;
#ifdef ONLY_INT_FIELDS
int mode : 8;
#else
unsigned abstract_flag : 1;
unsigned in_system_header_flag : 1;
- /* room for seven more */
+ unsigned common_flag : 1;
+ unsigned defer_output : 1;
+ unsigned transparent_union : 1;
+ unsigned static_ctor_flag : 1;
+ unsigned static_dtor_flag : 1;
+ unsigned artificial_flag : 1;
+ unsigned weak_flag : 1;
+ /* room for no more */
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. */
+ union {
+ int i;
+ unsigned int u;
+ enum built_in_function f;
+ } frame_size;
+
union tree_node *name;
union tree_node *context;
union tree_node *arguments;
union tree_node *result;
union tree_node *initial;
union tree_node *abstract_origin;
- /* The PRINT_NAME field is marked for death. */
- char *print_name;
union tree_node *assembler_name;
+ union tree_node *section_name;
+ union tree_node *machine_attributes;
struct rtx_def *rtl; /* acts as link to register transfer language
(rtl) info */
- /* 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. */
- int frame_size;
/* For FUNCTION_DECLs: points to insn that constitutes its definition
on the permanent obstack. For any other kind of decl, this is the
alignment. */
union {
struct rtx_def *r;
- int i;
+ HOST_WIDE_INT i;
} saved_insns;
union tree_node *vindex;
/* Points to a structure whose details depend on the language in use. */
struct tree_exp exp;
struct tree_block block;
};
-
-/* Add prototype support. */
-#ifndef PROTO
-#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#define PROTO(ARGS) ARGS
-#else
-#define PROTO(ARGS) ()
-#endif
-#endif
-
+\f
+#include "gansidecl.h"
#define NULL_TREE (tree) NULL
-/* Define a generic NULL if one hasn't already been defined. */
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifndef GENERIC_PTR
-#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#define GENERIC_PTR void *
-#else
-#define GENERIC_PTR char *
-#endif
-#endif
-
-#ifndef NULL_PTR
-#define NULL_PTR ((GENERIC_PTR)0)
-#endif
-
-/* Format for global names of constructor and destructor functions. */
-#ifndef NO_DOLLAR_IN_LABEL
-#define CONSTRUCTOR_NAME_FORMAT "_GLOBAL_$I$%s"
-#else
-#define CONSTRUCTOR_NAME_FORMAT "_GLOBAL_.I.%s"
-#endif
-\f
/* 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. */
/* At present, don't prototype xrealloc, since all of the callers don't
cast their pointers to char *, and all of the xrealloc's don't use
void * yet. */
-extern char *xrealloc PROTO((void *, unsigned));
+extern char *xmalloc PROTO((size_t));
+extern char *xrealloc PROTO((void *, size_t));
#else
+extern char *xmalloc ();
extern char *xrealloc ();
#endif
+extern char *xstrdup PROTO((char *));
+
extern char *oballoc PROTO((int));
extern char *permalloc PROTO((int));
extern char *savealloc PROTO((int));
-extern char *xmalloc PROTO((unsigned));
extern void free PROTO((void *));
/* Lowest level primitive for allocating a node.
extern tree get_identifier PROTO((char *));
+/* If an identifier with the name TEXT (a null-terminated string) has
+ previously been referred to, return that node; otherwise return
+ NULL_TREE. */
+
+extern tree maybe_get_identifier PROTO((char *));
+
/* Construct various types of nodes. */
#define build_int_2(LO,HI) \
build_int_2_wide ((HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))
-#if 0
-/* We cannot define prototypes for the variable argument functions,
- since they have not been ANSI-fied, and an ANSI compiler would
- complain when compiling the definition of these functions. */
-
-extern tree build PROTO((enum tree_code, tree, ...));
-extern tree build_nt PROTO((enum tree_code, ...));
-extern tree build_parse_node PROTO((enum tree_code, ...));
-#else
-extern tree build ();
-extern tree build_nt ();
-extern tree build_parse_node ();
-#endif
+extern tree build PVPROTO((enum tree_code, tree, ...));
+extern tree build_nt PVPROTO((enum tree_code, ...));
+extern tree build_parse_node PVPROTO((enum tree_code, ...));
extern tree build_int_2_wide PROTO((HOST_WIDE_INT, HOST_WIDE_INT));
extern tree build_real PROTO((tree, REAL_VALUE_TYPE));
extern tree build_real_from_int_cst PROTO((tree, tree));
-extern tree build_complex PROTO((tree, tree));
+extern tree build_complex PROTO((tree, tree, tree));
extern tree build_string PROTO((int, char *));
extern tree build1 PROTO((enum tree_code, tree, tree));
extern tree build_tree_list PROTO((tree, tree));
extern tree build_complex_type PROTO((tree));
extern tree array_type_nelts PROTO((tree));
-/* Construct expressions, performing type checking.
- GCC and G++ use different calling sequences for build_binary_op,
- and build_indirect_ref, so don't include a prototype here. */
-
-extern tree build_binary_op ();
-extern tree build_indirect_ref ();
-extern tree build_unary_op PROTO((enum tree_code, tree, int));
+extern tree value_member PROTO((tree, tree));
+extern tree purpose_member PROTO((tree, tree));
+extern tree binfo_member PROTO((tree, tree));
+extern int attribute_hash_list PROTO((tree));
+extern int attribute_list_equal PROTO((tree, tree));
+extern int attribute_list_contained PROTO((tree, tree));
+extern int tree_int_cst_equal PROTO((tree, tree));
+extern int tree_int_cst_lt PROTO((tree, tree));
+extern int tree_int_cst_sgn PROTO((tree));
+extern int index_type_equal PROTO((tree, tree));
/* From expmed.c. Since rtl.h is included after tree.h, we can't
put the prototype here. Rtl.h does declare the prototype if
extern tree make_tree ();
\f
+/* Return a type like TTYPE except that its TYPE_ATTRIBUTES
+ is ATTRIBUTE.
+
+ Such modified types already made are recorded so that duplicates
+ are not made. */
+
+extern tree build_type_attribute_variant PROTO((tree, tree));
+extern tree build_decl_attribute_variant PROTO((tree, tree));
+
+/* Return 1 if an attribute and its arguments are valid for a decl or type. */
+
+extern int valid_machine_attribute PROTO((tree, tree, tree, tree));
+
+/* Given a tree node and a string, return non-zero if the tree node is
+ a valid attribute name for the string. */
+
+extern int is_attribute_p PROTO((char *, tree));
+
+/* Given an attribute name and a list of attributes, return the list element
+ of the attribute or NULL_TREE if not found. */
+
+extern tree lookup_attribute PROTO((char *, tree));
+
+/* Given two attributes lists, return a list of their union. */
+
+extern tree merge_attributes PROTO((tree, tree));
+
/* Given a type node TYPE, and CONSTP and VOLATILEP, return a type
for the same kind of data as TYPE describes.
Variants point to the "main variant" (which has neither CONST nor VOLATILE)
extern void layout_decl PROTO((tree, unsigned));
-/* Fold constants as much as possible in an expression.
- Returns the simplified expression.
- Acts only on the top level of the expression;
- if the argument itself cannot be simplified, its
- subexpressions are not changed. */
-
-extern tree fold PROTO((tree));
-
/* Return an expr equal to X but certainly not valid as an lvalue. */
extern tree non_lvalue PROTO((tree));
+extern tree pedantic_non_lvalue PROTO((tree));
extern tree convert PROTO((tree, tree));
extern tree size_in_bytes PROTO((tree));
extern int int_size_in_bytes PROTO((tree));
extern tree size_binop PROTO((enum tree_code, tree, tree));
-extern tree size_int PROTO((unsigned));
+extern tree size_int PROTO((unsigned HOST_WIDE_INT));
extern tree round_up PROTO((tree, int));
extern tree get_pending_sizes PROTO((void));
+extern void put_pending_sizes PROTO((tree));
/* Type for sizes of data-type. */
extern tree sizetype;
+/* If nonzero, an upper limit on alignment of structure fields, in bits. */
+extern int maximum_field_alignment;
+
+/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */
+extern int set_alignment;
+
/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
by making the last node in X point to Y.
Returns X, except if X is 0 returns Y. */
extern tree save_expr PROTO((tree));
+/* unsave_expr (EXP) returns an expression equivalent to EXP but it
+ can be used multiple times and will evaluate EXP, in it's entirety
+ each time. */
+
+extern tree unsave_expr PROTO((tree));
+
+/* unsave_expr_now (EXP) resets EXP in place, so that it can be
+ expanded again. */
+
+extern tree unsave_expr_now PROTO((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.
+
+ Note that we only allow such expressions within simple arithmetic
+ or a COND_EXPR. */
+
+extern int contains_placeholder_p PROTO((tree));
+
+/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
+ return a tree with all occurrences of references to F in a
+ PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
+ contains only arithmetic expressions. */
+
+extern tree substitute_in_expr PROTO((tree, tree, tree));
+
/* variable_size (EXP) is like save_expr (EXP) except that it
is for the special case of something that is part of a
variable size for a data type. It makes special arrangements
extern tree stabilize_reference PROTO((tree));
+/* Subroutine of stabilize_reference; this is called for subtrees of
+ references. Any expression with side-effects must be put in a SAVE_EXPR
+ to ensure that it is only evaluated once. */
+
+extern tree stabilize_reference_1 PROTO((tree));
+
/* Return EXP, stripped of any conversions to wider types
in such a way that the result of converting to type FOR_TYPE
is the same as if EXP were converted to FOR_TYPE.
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 PROTO((tree, int *, int *, tree *, enum machine_mode *, int *, int *));
+extern tree get_inner_reference PROTO((tree, int *, int *, tree *,
+ enum machine_mode *, int *,
+ int *, int *));
/* Return the FUNCTION_DECL which provides this _DECL with its context,
or zero if none. */
extern tree decl_function_context PROTO((tree));
-/* Return the RECORD_TYPE or UNION_TYPE which provides this _DECL
- with its context, or zero if none. */
+/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
+ this _DECL with its context, or zero if none. */
extern tree decl_type_context PROTO((tree));
/* Given the FUNCTION_DECL for the current function,
for the function's name. */
extern char *function_cannot_inline_p PROTO((tree));
+
+/* Return 1 if EXPR is the real constant zero. */
+extern int real_zerop PROTO((tree));
\f
/* Declare commonly used variables for tree structure. */
that standard C forbids. */
extern int pedantic;
+/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
+ Zero means allow extended lvalues. */
+
+extern int pedantic_lvalues;
+
/* Nonzero means can safely call expand_expr now;
otherwise layout_type puts variable sizes onto `pending_sizes' instead. */
extern int all_types_permanent;
-/* Pointer to function to compute the name to use to print a declaration. */
+/* 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 char *(*decl_printable_name) (/* tree decl, int verbosity */);
+
+/* Pointer to function to finish handling an incomplete decl at the
+ end of compilation. */
-extern char *(*decl_printable_name) ();
+extern void (*incomplete_decl_finalize_hook) ();
+\f
+/* In tree.c */
+extern char *perm_calloc PROTO((int, long));
+extern tree get_set_constructor_bits PROTO((tree, char *, int));
+extern tree get_set_constructor_bytes PROTO((tree,
+ unsigned char *, int));
\f
/* In stmt.c */
+extern void expand_fixups PROTO((struct rtx_def *));
extern tree expand_start_stmt_expr PROTO((void));
extern tree expand_end_stmt_expr PROTO((tree));
extern void expand_expr_stmt PROTO((tree));
+extern int warn_if_unused_value PROTO((tree));
+extern void expand_decl_init PROTO((tree));
extern void clear_last_expr PROTO((void));
extern void expand_label PROTO((tree));
extern void expand_goto PROTO((tree));
extern void expand_end_loop PROTO((void));
extern int expand_continue_loop PROTO((struct nesting *));
extern int expand_exit_loop PROTO((struct nesting *));
-extern int expand_exit_loop_if_false PROTO((struct nesting *, tree));
+extern int expand_exit_loop_if_false PROTO((struct nesting *,
+ tree));
extern int expand_exit_something PROTO((void));
extern void expand_null_return PROTO((void));
extern void expand_return PROTO((tree));
extern void expand_start_bindings PROTO((int));
extern void expand_end_bindings PROTO((tree, int, int));
+extern void start_cleanup_deferal PROTO((void));
+extern void end_cleanup_deferal PROTO((void));
+extern void mark_block_as_eh_region PROTO((void));
+extern void mark_block_as_not_eh_region PROTO((void));
+extern int is_eh_region PROTO((void));
+extern int conditional_context PROTO((void));
extern tree last_cleanup_this_contour PROTO((void));
-extern void expand_start_case PROTO((int, tree, tree, char *));
+extern int expand_dhc_cleanup PROTO((void));
+extern void expand_start_case PROTO((int, tree, tree,
+ char *));
extern void expand_end_case PROTO((tree));
-extern int pushcase PROTO((tree, tree, tree *));
-extern int pushcase_range PROTO((tree, tree, tree, tree *));
+extern int pushcase PROTO((tree,
+ tree (*) (tree, tree),
+ tree, tree *));
+extern int pushcase_range PROTO((tree, tree,
+ tree (*) (tree, tree),
+ tree, tree *));
/* In fold-const.c */
-extern tree invert_truthvalue PROTO((tree));
+/* Fold constants as much as possible in an expression.
+ Returns the simplified expression.
+ Acts only on the top level of the expression;
+ if the argument itself cannot be simplified, its
+ subexpressions are not changed. */
+
+extern tree fold PROTO((tree));
+
+extern int force_fit_type PROTO((tree, int));
+extern int add_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT *, HOST_WIDE_INT *));
+extern int neg_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT *, HOST_WIDE_INT *));
+extern int mul_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT *, HOST_WIDE_INT *));
+extern void lshift_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, int, HOST_WIDE_INT *,
+ HOST_WIDE_INT *, int));
+extern void rshift_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, int,
+ HOST_WIDE_INT *, HOST_WIDE_INT *, int));
+extern void lrotate_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, int, HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern void rrotate_double PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, int, HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern int operand_equal_p PROTO((tree, tree, int));
+extern tree invert_truthvalue PROTO((tree));
\f
/* The language front-end must define these functions. */
extern void lang_init PROTO((void));
extern void lang_finish PROTO((void));
+/* Function to identify which front-end produced the output file. */
+extern char *lang_identify PROTO((void));
+
+/* Function to replace the DECL_LANG_SPECIFIC field of a DECL with a copy. */
+extern void copy_lang_decl PROTO((tree));
+
/* Function called with no arguments to parse and compile the input. */
extern int yyparse PROTO((void));
/* Function called with option as argument
REVERSE -- reverse the order of decls before returning them.
FUNCTIONBODY -- nonzero if this level is the body of a function. */
extern tree poplevel PROTO((int, int, int));
-/* Return the BLOCK node for the current scope level. */
-extern tree current_block PROTO((void));
+/* Set the BLOCK node for the current scope level. */
+extern void set_block PROTO((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
extern tree getdecls PROTO((void));
/* Function to return the chain of structure tags in the current scope level. */
extern tree gettags PROTO((void));
+
+extern tree build_range_type PROTO((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 PROTO((void));
+
+extern int allocation_temporary_p PROTO((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 PROTO((int));
+
+/* Called after finishing a record, union or enumeral type. */
+extern void rest_of_type_compilation PROTO((tree, int));
+
+/* Save the current set of obstacks, but don't change them. */
+extern void push_obstacks_nochange PROTO((void));
+
+extern void permanent_allocation PROTO((int));
+
+extern void push_momentary PROTO((void));
+
+extern void clear_momentary PROTO((void));
+
+extern void pop_momentary PROTO((void));
+
+extern void end_temporary_allocation PROTO((void));
+
+/* Pop the obstack selection stack. */
+extern void pop_obstacks PROTO((void));
OSDN Git Service
