X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree.h;h=e0ae9c91036e8b37fdc27a5ae35f74fd02bf3160;hb=8591d03a53e1228efcca64ecd6837093ec22cb4d;hp=5877f6240a1c9c19d31c33f3449340b800d31591;hpb=df5e872e0ce22697473dd596a72bf54f02460a80;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree.h b/gcc/tree.h index 5877f6240a1..e0ae9c91036 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -1,5 +1,5 @@ /* 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. @@ -15,11 +15,16 @@ GNU General Public License for more details. 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, @@ -77,6 +82,8 @@ enum built_in_function BUILT_IN_STRCMP, BUILT_IN_STRLEN, BUILT_IN_FSQRT, + BUILT_IN_SIN, + BUILT_IN_COS, BUILT_IN_GETEXP, BUILT_IN_GETMAN, BUILT_IN_SAVEREGS, @@ -87,12 +94,20 @@ enum built_in_function 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 }; /* The definition of tree nodes fills the next several pages. */ @@ -153,9 +168,110 @@ struct tree_common 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). */ @@ -200,6 +316,33 @@ struct tree_common && (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) /* Define many boolean fields that all tree nodes have. */ @@ -222,18 +365,28 @@ struct tree_common 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 @@ -253,7 +406,7 @@ struct tree_common 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. @@ -301,7 +454,7 @@ struct tree_common 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) @@ -357,6 +510,8 @@ struct tree_common 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; }; @@ -482,6 +637,7 @@ struct tree_exp #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. */ @@ -499,6 +655,7 @@ struct tree_block union tree_node *subblocks; union tree_node *supercontext; union tree_node *abstract_origin; + struct rtx_def *end_note; }; /* Define fields and accessors for nodes representing data types. */ @@ -522,24 +679,30 @@ struct tree_block #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. */ @@ -557,22 +720,47 @@ struct tree_block #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; @@ -580,11 +768,12 @@ struct tree_type 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; @@ -593,6 +782,7 @@ struct tree_type 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; }; @@ -651,6 +841,12 @@ struct tree_type #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))) @@ -673,20 +869,25 @@ struct tree_type /* 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) @@ -700,6 +901,8 @@ struct tree_type #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. @@ -711,6 +914,9 @@ struct tree_type /* 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) @@ -718,24 +924,29 @@ struct tree_type 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) @@ -772,7 +983,7 @@ struct tree_type /* 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) @@ -781,6 +992,11 @@ struct tree_type 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) @@ -789,12 +1005,23 @@ struct tree_type 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. @@ -822,11 +1049,39 @@ struct tree_type #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) @@ -842,8 +1097,8 @@ struct tree_decl 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 @@ -860,7 +1115,14 @@ struct tree_decl 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; @@ -871,26 +1133,32 @@ struct tree_decl 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. */ @@ -916,44 +1184,11 @@ union tree_node 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 - + +#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 - /* 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. */ @@ -967,15 +1202,18 @@ union tree_node /* 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. @@ -1003,29 +1241,25 @@ extern tree make_tree_vec PROTO((int)); 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)); @@ -1050,13 +1284,16 @@ extern tree build_offset_type 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 @@ -1064,6 +1301,33 @@ extern tree build_unary_op PROTO((enum tree_code, tree, int)); extern tree make_tree (); +/* 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) @@ -1101,30 +1365,30 @@ extern tree type_hash_canon PROTO((int, tree)); 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. */ @@ -1186,6 +1450,32 @@ extern int lvalue_or_else PROTO((tree, char *)); 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 @@ -1200,6 +1490,12 @@ extern tree variable_size PROTO((tree)); 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. @@ -1252,14 +1548,16 @@ extern tree maybe_build_cleanup PROTO((tree)); 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, @@ -1268,6 +1566,9 @@ extern tree decl_type_context PROTO((tree)); 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)); /* Declare commonly used variables for tree structure. */ @@ -1312,6 +1613,11 @@ extern int lineno; 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. */ @@ -1333,15 +1639,35 @@ extern int current_function_calls_longjmp; 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) (); + +/* 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)); /* 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)); @@ -1356,22 +1682,65 @@ extern void expand_loop_continue_here PROTO((void)); 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)); /* The language front-end must define these functions. */ @@ -1385,6 +1754,12 @@ extern void init_decl_processing PROTO((void)); 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 @@ -1402,6 +1777,8 @@ extern void pushlevel PROTO((int)); 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)); +/* 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 @@ -1411,3 +1788,37 @@ extern tree pushdecl PROTO((tree)); 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));