X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree.h;h=859a564b360e4fefe3cc20afc94455a42d7be1a0;hb=8d60d2bc69bbdca290a0014c9d03326983f331f5;hp=8f0737649aa559bdd7901309b10cca9f0fd55419;hpb=44acf429b688309e6afa61e4877719f75acadcca;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree.h b/gcc/tree.h index 8f0737649aa..859a564b360 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -1,31 +1,27 @@ /* Front-end tree definitions for GNU compiler. - Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 + Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the 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, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ #include "machmode.h" #include "version.h" -#ifndef RTX_CODE -struct rtx_def; -#endif - /* Codes of tree nodes */ #define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM, @@ -84,12 +80,12 @@ extern const char *const built_in_class_names[4]; /* 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" - /* Upper bound on non-language-specific builtins. */ + /* Upper bound on non-language-specific builtins. */ END_BUILTINS }; #undef DEF_BUILTIN @@ -98,7 +94,7 @@ enum built_in_function 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]; +extern tree built_in_decls[(int) END_BUILTINS]; /* The definition of tree nodes fills the next several pages. */ @@ -116,20 +112,17 @@ extern union tree_node *built_in_decls[(int) END_BUILTINS]; fields as well. The fields of a node are never accessed directly, always through accessor macros. */ -/* This type is used everywhere to refer to a tree node. */ - -typedef union tree_node *tree; - /* Every kind of tree node starts with this structure, so all nodes have these fields. See the accessor macros, defined below, for documentation of the - fields. */ + fields. */ struct tree_common { - union tree_node *chain; - union tree_node *type; + tree chain; + tree type; + void *aux; ENUM_BITFIELD(tree_code) code : 8; unsigned side_effects_flag : 1; unsigned constant_flag : 1; @@ -188,7 +181,7 @@ struct tree_common 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 @@ -205,6 +198,7 @@ struct tree_common TREE_VIA_PROTECTED in TREE_LIST + TREE_VEC TREE_PROTECTED in BLOCK ??? unspecified nodes @@ -239,8 +233,6 @@ struct tree_common 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 @@ -263,7 +255,8 @@ struct tree_common 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 */ @@ -274,7 +267,8 @@ struct tree_common /* 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. */ @@ -334,6 +328,10 @@ extern void tree_class_check_failed PARAMS ((const tree, int, In VECTOR_TYPE nodes, this is the type of the elements. */ #define TREE_TYPE(NODE) ((NODE)->common.type) +/* Here is how primitive or already-canonicalized types' hash codes + are made. */ +#define TYPE_HASH(TYPE) ((size_t) (TYPE) & 0777777) + /* Nodes are chained together for many purposes. Types are chained together to record them for being output to the debugger (see the function `chain_type'). @@ -396,7 +394,7 @@ extern void tree_class_check_failed PARAMS ((const tree, int, || (TREE_CODE (TYPE) == COMPLEX_TYPE \ && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)) -/* Nonzero if TYPE represents an aggregate (multi-component) 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 \ @@ -447,7 +445,8 @@ extern void tree_class_check_failed PARAMS ((const tree, int, #define MAYBE_BOUNDED_POINTER_TYPE_P(TYPE) \ (TREE_CODE (TYPE) == POINTER_TYPE || BOUNDED_POINTER_TYPE_P (TYPE)) -/* Nonzero if TYPE represents a reference type, either bounded or unbounded. */ +/* Nonzero if TYPE represents a reference type, either bounded or + unbounded. */ #define MAYBE_BOUNDED_REFERENCE_TYPE_P(TYPE) \ (TREE_CODE (TYPE) == REFERENCE_TYPE || BOUNDED_REFERENCE_TYPE_P (TYPE)) @@ -460,11 +459,11 @@ extern void tree_class_check_failed PARAMS ((const tree, int, /* Nonzero if this type is complete or is cv void. */ #define COMPLETE_OR_VOID_TYPE_P(NODE) \ - (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE)) + (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE)) /* Nonzero if this type is complete or is an array with unspecified bound. */ #define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \ - (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : NODE)) + (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : NODE)) /* Nonzero if TYPE represents a type. */ @@ -509,7 +508,8 @@ extern void tree_class_check_failed PARAMS ((const tree, int, /* In an IDENTIFIER_NODE, this means that assemble_name was called with this string as an argument. */ -#define TREE_SYMBOL_REFERENCED(NODE) ((NODE)->common.static_flag) +#define TREE_SYMBOL_REFERENCED(NODE) \ + (IDENTIFIER_NODE_CHECK (NODE)->common.static_flag) /* In an INTEGER_CST, REAL_CST, of COMPLEX_CST, this means there was an overflow in folding, and no warning has been issued for this subexpression. @@ -518,7 +518,7 @@ extern void tree_class_check_failed PARAMS ((const tree, int, /* 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) @@ -531,7 +531,7 @@ extern void tree_class_check_failed PARAMS ((const tree, int, /* Ditto, for `private' declarations. */ #define TREE_VIA_PRIVATE(NODE) ((NODE)->common.private_flag) -/* Nonzero for TREE_LIST node means that the path to the +/* Nonzero for TREE_LIST or TREE_VEC node means that the path to the base class is via a `protected' declaration, which preserves protected fields from the base class as protected. OVERLOADED. */ @@ -563,6 +563,9 @@ extern void tree_class_check_failed PARAMS ((const tree, int, when the node is a type). */ #define TREE_READONLY(NODE) ((NODE)->common.readonly_flag) +/* Non-zero if NODE is a _DECL with TREE_READONLY set. */ +#define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE)) + /* Value of expression is constant. Always appears in all ..._CST nodes. May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR @@ -574,7 +577,8 @@ extern void tree_class_check_failed PARAMS ((const tree, int, The same bit is used in functions as DECL_BUILT_IN_NONANSI. */ #define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag) -#define TYPE_TRAP_SIGNED(NODE) (flag_trapv && ! TREE_UNSIGNED (NODE)) +#define TYPE_TRAP_SIGNED(NODE) \ + (flag_trapv && ! TREE_UNSIGNED (TYPE_CHECK (NODE))) /* Nonzero in a VAR_DECL means assembler code has been written. Nonzero in a FUNCTION_DECL means that the function has been compiled. @@ -595,6 +599,14 @@ extern void tree_class_check_failed PARAMS ((const tree, int, an exception. In a CALL_EXPR, nonzero means the call cannot throw. */ #define TREE_NOTHROW(NODE) ((NODE)->common.nothrow_flag) +/* In a type, nonzero means that all objects of the type are guaranteed by the + language or front-end to be properly aligned, so we can indicate that a MEM + of this type is aligned at least to the alignment of the type, even if it + doesn't appear that it is. We see this, for example, in object-oriented + languages where a tag field may show this is an object of a more-aligned + variant of the more generic type. */ +#define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag) + /* Used in classes in C++. */ #define TREE_PRIVATE(NODE) ((NODE)->common.private_flag) /* Used in classes in C++. @@ -655,21 +667,21 @@ extern void tree_class_check_failed PARAMS ((const tree, int, #define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high) #define INT_CST_LT(A, B) \ -(TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \ - || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \ - && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B))) + (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \ + || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \ + && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B))) #define INT_CST_LT_UNSIGNED(A, B) \ -(((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ - < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ - || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ - == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ - && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B))) - + (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ + < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ + || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \ + == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \ + && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B))) + struct tree_int_cst { struct tree_common common; - struct rtx_def *rtl; /* acts as link to register transfer language + rtx rtl; /* acts as link to register transfer language (rtl) info */ /* A sub-struct is necessary here because the function `const_hash' wants to scan both words as a unit and taking the address of the @@ -686,10 +698,10 @@ struct tree_int_cst #define TREE_CST_RTL(NODE) (CST_OR_CONSTRUCTOR_CHECK (NODE)->real_cst.rtl) -/* In a REAL_CST node. */ -/* We can represent a real value as either a `double' or a string. - Strings don't allow for any optimization, but they do allow - for cross-compilation. */ +/* In a REAL_CST node. + + We can represent a real value as either a `double' or an array of + longs. */ #define TREE_REAL_CST(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst) @@ -698,7 +710,7 @@ struct tree_int_cst struct tree_real_cst { struct tree_common common; - struct rtx_def *rtl; /* acts as link to register transfer language + rtx rtl; /* acts as link to register transfer language (rtl) info */ REAL_VALUE_TYPE real_cst; }; @@ -710,7 +722,7 @@ struct tree_real_cst struct tree_string { struct tree_common common; - struct rtx_def *rtl; /* acts as link to register transfer language + rtx rtl; /* acts as link to register transfer language (rtl) info */ int length; const char *pointer; @@ -723,22 +735,32 @@ struct tree_string struct tree_complex { struct tree_common common; - struct rtx_def *rtl; /* acts as link to register transfer language + rtx rtl; /* acts as link to register transfer language (rtl) info */ - union tree_node *real; - union tree_node *imag; + tree real; + tree imag; }; +#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; - const char *pointer; + struct ht_identifier id; }; /* In a TREE_LIST node. */ @@ -748,73 +770,86 @@ struct tree_identifier struct tree_list { struct tree_common common; - union tree_node *purpose; - union tree_node *value; + tree purpose; + tree value; }; /* In a TREE_VEC node. */ #define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length) #define TREE_VEC_ELT(NODE,I) (TREE_VEC_CHECK (NODE)->vec.a[I]) -#define TREE_VEC_END(NODE) ((void) TREE_VEC_CHECK (NODE),&((NODE)->vec.a[(NODE)->vec.length])) +#define TREE_VEC_END(NODE) \ + ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length])) struct tree_vec { struct tree_common common; int length; - union tree_node *a[1]; + tree a[1]; }; /* Define fields and accessors for some nodes that represent expressions. */ /* In a SAVE_EXPR node. */ -#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND(NODE, 1) -#define SAVE_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[2]) -#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (NODE) +#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND(SAVE_EXPR_CHECK (NODE), 1) +#define SAVE_EXPR_RTL(NODE) (*(rtx *) &SAVE_EXPR_CHECK (NODE)->exp.operands[2]) +#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (SAVE_EXPR_CHECK (NODE)) /* Nonzero if the SAVE_EXPRs value should be kept, even if it occurs both in normal code and in a handler. (Normally, in a handler, all SAVE_EXPRs are unsaved, meaning that there values are recalculated.) */ -#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (NODE) +#define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (SAVE_EXPR_CHECK (NODE)) /* In a RTL_EXPR node. */ -#define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[0]) -#define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[1]) +#define RTL_EXPR_SEQUENCE(NODE) \ + (*(rtx *) &RTL_EXPR_CHECK (NODE)->exp.operands[0]) +#define RTL_EXPR_RTL(NODE) (*(rtx *) &RTL_EXPR_CHECK (NODE)->exp.operands[1]) + +/* In a WITH_CLEANUP_EXPR node. */ +#define WITH_CLEANUP_EXPR_RTL(NODE) \ + (*(rtx *) &WITH_CLEANUP_EXPR_CHECK (NODE)->exp.operands[2]) /* In a CONSTRUCTOR node. */ -#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1) +#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (CONSTRUCTOR_CHECK (NODE), 1) /* In ordinary expression nodes. */ #define TREE_OPERAND(NODE, I) (EXPR_CHECK (NODE)->exp.operands[I]) #define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity) /* In a LABELED_BLOCK_EXPR node. */ -#define LABELED_BLOCK_LABEL(NODE) TREE_OPERAND (NODE, 0) -#define LABELED_BLOCK_BODY(NODE) TREE_OPERAND (NODE, 1) +#define LABELED_BLOCK_LABEL(NODE) \ + TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 0) +#define LABELED_BLOCK_BODY(NODE) \ + TREE_OPERAND (LABELED_BLOCK_EXPR_CHECK (NODE), 1) /* In a EXIT_BLOCK_EXPR node. */ -#define EXIT_BLOCK_LABELED_BLOCK(NODE) TREE_OPERAND (NODE, 0) -#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND (NODE, 1) +#define EXIT_BLOCK_LABELED_BLOCK(NODE) \ + TREE_OPERAND (EXIT_BLOCK_EXPR_CHECK (NODE), 0) +#define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND (EXIT_BLOCK_EXPR_CHECK (NODE), 1) /* In a LOOP_EXPR node. */ -#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (NODE, 0) +#define LOOP_EXPR_BODY(NODE) TREE_OPERAND (LOOP_EXPR_CHECK (NODE), 0) /* In a EXPR_WITH_FILE_LOCATION node. */ -#define EXPR_WFL_NODE(NODE) TREE_OPERAND((NODE), 0) +#define EXPR_WFL_EMIT_LINE_NOTE(NODE) \ + (EXPR_WITH_FILE_LOCATION_CHECK (NODE)->common.public_flag) +#define EXPR_WFL_NODE(NODE) \ + TREE_OPERAND (EXPR_WITH_FILE_LOCATION_CHECK (NODE), 0) +#define EXPR_WFL_FILENAME_NODE(NODE) \ + TREE_OPERAND(EXPR_WITH_FILE_LOCATION_CHECK (NODE), 1) #define EXPR_WFL_FILENAME(NODE) \ - (IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE ((NODE)))) -#define EXPR_WFL_FILENAME_NODE(NODE) TREE_OPERAND((NODE), 1) -#define EXPR_WFL_LINENO(NODE) (EXPR_CHECK (NODE)->exp.complexity >> 12) -#define EXPR_WFL_COLNO(NODE) (EXPR_CHECK (NODE)->exp.complexity & 0xfff) + IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE ((NODE))) +/* ??? Java uses this in all expressions. */ #define EXPR_WFL_LINECOL(NODE) (EXPR_CHECK (NODE)->exp.complexity) +#define EXPR_WFL_LINENO(NODE) (EXPR_WFL_LINECOL (NODE) >> 12) +#define EXPR_WFL_COLNO(NODE) (EXPR_WFL_LINECOL (NODE) & 0xfff) #define EXPR_WFL_SET_LINECOL(NODE, LINE, COL) \ (EXPR_WFL_LINECOL(NODE) = ((LINE) << 12) | ((COL) & 0xfff)) -#define EXPR_WFL_EMIT_LINE_NOTE(NODE) ((NODE)->common.public_flag) struct tree_exp { struct tree_common common; int complexity; - union tree_node *operands[1]; + tree operands[1]; }; /* In a BLOCK node. */ @@ -823,19 +858,45 @@ struct tree_exp #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) /* Nonzero means that this block is prepared to handle exceptions listed in the BLOCK_VARS slot. */ -#define BLOCK_HANDLER_BLOCK(NODE) (BLOCK_CHECK (NODE)->block.handler_block_flag) +#define BLOCK_HANDLER_BLOCK(NODE) \ + (BLOCK_CHECK (NODE)->block.handler_block_flag) /* An index number for this block. These values are not guaranteed to be unique across functions -- whether or not they are depends on the debugging output format in use. */ #define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num) +/* If block reordering splits a lexical block into discontiguous + address ranges, we'll make a copy of the original block. + + Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN. + In that case, we have one source block that has been replicated + (through inlining or unrolling) into many logical blocks, and that + these logical blocks have different physical variables in them. + + In this case, we have one logical block split into several + non-contiguous address ranges. Most debug formats can't actually + represent this idea directly, so we fake it by creating multiple + logical blocks with the same variables in them. However, for those + that do support non-contiguous regions, these allow the original + logical block to be reconstructed, along with the set of address + ranges. + + One of the logical block fragments is arbitrarily chosen to be + the ORIGIN. The other fragments will point to the origin via + BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer + be null. The list of fragments will be chained through + BLOCK_FRAGMENT_CHAIN from the origin. */ + +#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin) +#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain) + struct tree_block { struct tree_common common; @@ -844,10 +905,12 @@ struct tree_block unsigned abstract_flag : 1; unsigned block_num : 30; - union tree_node *vars; - union tree_node *subblocks; - union tree_node *supercontext; - union tree_node *abstract_origin; + tree vars; + tree subblocks; + tree supercontext; + tree abstract_origin; + tree fragment_origin; + tree fragment_chain; }; /* Define fields and accessors for nodes representing data types. */ @@ -877,7 +940,6 @@ struct tree_block #define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name) #define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant) #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant) -#define TYPE_NONCOPIED_PARTS(NODE) (TYPE_CHECK (NODE)->type.noncopied_parts) #define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context) #define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific) @@ -920,8 +982,7 @@ struct tree_block /* Nonzero iff the typed-based alias set for this type has been calculated. */ -#define TYPE_ALIAS_SET_KNOWN_P(NODE) \ - (TYPE_CHECK (NODE)->type.alias_set != -1) +#define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1) /* A TREE_LIST of IDENTIFIER nodes of the attributes that apply to this type. */ @@ -936,10 +997,16 @@ struct tree_block #define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align) /* The alignment for NODE, in bytes. */ -#define TYPE_ALIGN_UNIT(NODE) \ - (TYPE_ALIGN (NODE) / BITS_PER_UNIT) +#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT) -#define TYPE_STUB_DECL(NODE) (TREE_CHAIN (NODE)) +/* 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 has BLKmode only because it lacks the alignment requirement for @@ -963,10 +1030,10 @@ struct tree_block (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) +#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->common.volatile_flag) /* Means this type is const-qualified. */ -#define TYPE_READONLY(NODE) ((NODE)->common.readonly_flag) +#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->common.readonly_flag) /* If nonzero, this type is `restrict'-qualified, in the C sense of the term. */ @@ -1016,15 +1083,18 @@ struct tree_block /* 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. */ + If set in a SET_TYPE, indicates a bitstring type. */ #define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (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) +/* If non-NULL, this is an upper bound of the size (in bytes) of an + object of the given ARRAY_TYPE. This allows temporaries to be + allocated. */ +#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \ + TYPE_MAX_VALUE (ARRAY_TYPE_CHECK (ARRAY_TYPE)) /* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */ -#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) (GET_MODE_NUNITS (TYPE_CHECK (VECTOR_TYPE)->type.mode)) +#define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \ + GET_MODE_NUNITS (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.mode) /* Indicates that objects of this type must be initialized by calling a function when they are created. */ @@ -1107,10 +1177,10 @@ struct tree_block struct tree_type { struct tree_common common; - union tree_node *values; - union tree_node *size; - union tree_node *size_unit; - union tree_node *attributes; + tree values; + tree size; + tree size_unit; + tree attributes; unsigned int uid; unsigned int precision : 9; @@ -1134,17 +1204,16 @@ struct tree_type unsigned user_align : 1; unsigned int align; - union tree_node *pointer_to; - union tree_node *reference_to; + tree pointer_to; + tree reference_to; union {int address; char *pointer; } symtab; - union tree_node *name; - union tree_node *minval; - union tree_node *maxval; - union tree_node *next_variant; - union tree_node *main_variant; - union tree_node *binfo; - union tree_node *noncopied_parts; - union tree_node *context; + tree name; + tree minval; + tree maxval; + tree next_variant; + tree main_variant; + tree binfo; + tree context; HOST_WIDE_INT alias_set; /* Points to a structure whose details depend on the language in use. */ struct lang_type *lang_specific; @@ -1211,7 +1280,8 @@ struct tree_type /* Accessor macro to get to the Nth basetype of this basetype. */ #define BINFO_BASETYPE(NODE,N) TREE_VEC_ELT (BINFO_BASETYPES (NODE), (N)) -#define TYPE_BINFO_BASETYPE(NODE,N) BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N))) +#define TYPE_BINFO_BASETYPE(NODE,N) \ + BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N))) /* For a BINFO record describing a virtual base class, i.e., one where TREE_VIA_VIRTUAL is set, this field assists in locating the virtual @@ -1220,12 +1290,12 @@ struct tree_type pointer to the virtual base; under the new ABI this field is instead a INTEGER_CST giving an offset into the vtable where the offset to the virtual base can be found. */ -#define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT ((NODE), 5) +#define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT (NODE, 5) /* The size of a base class subobject of this type. Not all frontends currently allocate the space for these fields. */ -#define BINFO_SIZE(NODE) TREE_VEC_ELT ((NODE), 6) -#define BINFO_SIZE_UNIT(NODE) TREE_VEC_ELT ((NODE), 7) +#define BINFO_SIZE(NODE) TREE_VEC_ELT (NODE, 6) +#define BINFO_SIZE_UNIT(NODE) TREE_VEC_ELT (NODE, 7) #define TYPE_BINFO_SIZE(NODE) BINFO_SIZE (TYPE_BINFO (NODE)) #define TYPE_BINFO_SIZE_UNIT(NODE) BINFO_SIZE_UNIT (TYPE_BINFO (NODE)) @@ -1246,17 +1316,49 @@ struct tree_type /* Nonzero if DECL represents a decl. */ #define DECL_P(DECL) (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd') + /* This is the name of the object as written by the user. It is an IDENTIFIER_NODE. */ #define DECL_NAME(NODE) (DECL_CHECK (NODE)->decl.name) -/* 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) + /* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL, @@ -1265,9 +1367,8 @@ struct tree_type type, or NULL_TREE if the given decl has "file scope". */ #define DECL_CONTEXT(NODE) (DECL_CHECK (NODE)->decl.context) #define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl.context) -/* In a DECL this is the field where configuration dependent machine - attributes are store */ -#define DECL_MACHINE_ATTRIBUTES(NODE) (DECL_CHECK (NODE)->decl.machine_attributes) +/* In a DECL this is the field where attributes are stored. */ +#define DECL_ATTRIBUTES(NODE) (DECL_CHECK (NODE)->decl.attributes) /* In a FIELD_DECL, this is the field position, counting in bytes, of the byte containing the bit closest to the beginning of the structure. */ #define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->decl.arguments) @@ -1278,9 +1379,9 @@ struct tree_type if so, the type that was originally specified for it. TREE_TYPE may have been modified (in finish_struct). */ #define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->decl.result) -/* In FUNCTION_DECL, a chain of ..._DECL nodes. */ -/* VAR_DECL and PARM_DECL reserve the arguments slot - for language-specific uses. */ +/* In FUNCTION_DECL, a chain of ..._DECL nodes. + VAR_DECL and PARM_DECL reserve the arguments slot for language-specific + uses. */ #define DECL_ARGUMENTS(NODE) (DECL_CHECK (NODE)->decl.arguments) /* This field is used to reference anything in decl.result and is meant only for use by the garbage collector. */ @@ -1303,7 +1404,10 @@ struct tree_type /* 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) (FIELD_DECL_CHECK (NODE)->decl.initial) -/* These two fields describe where in the source code the declaration was. */ +/* These two fields describe where in the source code the declaration + was. If the declaration appears in several places (as for a C + function that is declared first and then defined later), this + information should refer to the definition. */ #define DECL_SOURCE_FILE(NODE) (DECL_CHECK (NODE)->decl.filename) #define DECL_SOURCE_LINE(NODE) (DECL_CHECK (NODE)->decl.linenum) /* Holds the size of the datum, in bits, as a tree expression. @@ -1335,19 +1439,36 @@ struct tree_type 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) + /* For PARM_DECL, holds an RTL for the stack slot or register where the data was actually passed. */ #define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->decl.u2.r) + /* For FUNCTION_DECL, if it is inline, holds the saved insn chain. */ #define DECL_SAVED_INSNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f) -/* For FUNCTION_DECL, if it is 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) @@ -1360,6 +1481,7 @@ struct tree_type to an INTEGER_CST node which is suitable for use as an index into the virtual function table. */ #define DECL_VINDEX(NODE) (DECL_CHECK (NODE)->decl.vindex) + /* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in which this FIELD_DECL is defined. This information is needed when writing debugging information about vfield and vbase decls for C++. */ @@ -1383,7 +1505,7 @@ struct tree_type /* 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. */ + 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)) @@ -1401,7 +1523,8 @@ struct tree_type /* Nonzero if a _DECL means that no warnings should be generated just because this decl is unused. */ -#define DECL_IN_SYSTEM_HEADER(NODE) (DECL_CHECK (NODE)->decl.in_system_header_flag) +#define DECL_IN_SYSTEM_HEADER(NODE) \ + (DECL_CHECK (NODE)->decl.in_system_header_flag) /* Nonzero for a given ..._DECL node means that this node should be put in .common, if possible. If a DECL_INITIAL is given, and it @@ -1417,7 +1540,7 @@ struct tree_type #define DECL_EXTERNAL(NODE) (DECL_CHECK (NODE)->decl.external_flag) /* In a VAR_DECL for a RECORD_TYPE, sets number for non-init_priority - initializatons. */ + initializatons. */ #define DEFAULT_INIT_PRIORITY 65535 #define MAX_INIT_PRIORITY 65535 #define MAX_RESERVED_INIT_PRIORITY 100 @@ -1425,21 +1548,24 @@ struct tree_type /* 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. */ + This uses the same flag as DECL_EXTERNAL. */ #define TYPE_DECL_SUPPRESS_DEBUG(NODE) \ -(TYPE_DECL_CHECK (NODE)->decl.external_flag) + (TYPE_DECL_CHECK (NODE)->decl.external_flag) /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */ #define DECL_REGISTER(NODE) (DECL_CHECK (NODE)->decl.regdecl_flag) + /* In LABEL_DECL nodes, nonzero means that an error message about jumping into such a binding contour has been printed for this label. */ #define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl.regdecl_flag) + /* In a FIELD_DECL, indicates this field should be bit-packed. */ #define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl.regdecl_flag) + /* In a FUNCTION_DECL with a non-zero DECL_CONTEXT, indicates that a static chain is not needed. */ #define DECL_NO_STATIC_CHAIN(NODE) \ -(FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag) + (FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag) /* Nonzero in a ..._DECL means this variable is ref'd from a nested function. For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes. @@ -1454,11 +1580,22 @@ struct tree_type 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) + +/* In a FUNCTION_DECL, the saved representation of the body of the + entire function. Usually a COMPOUND_STMT, but in C++ this may also + be a RETURN_INIT, CTOR_INITIALIZER, or TRY_BLOCK. */ +#define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.saved_tree) + +/* List of FUNCTION_DECLs inlined into this function's body. */ +#define DECL_INLINED_FNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inlined_fns) + /* Nonzero in a FUNCTION_DECL means this is a built-in function that is not specified by ansi C and that users are supposed to be allowed to redefine for any purpose whatever. */ #define DECL_BUILT_IN_NONANSI(NODE) \ -(FUNCTION_DECL_CHECK (NODE)->common.unsigned_flag) + (FUNCTION_DECL_CHECK (NODE)->common.unsigned_flag) /* Nonzero in a FUNCTION_DECL means this function should be treated as if it were a malloc, meaning it returns a pointer that is @@ -1472,6 +1609,7 @@ struct tree_type /* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed specially. */ #define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl.bit_field_flag) + /* In a LABEL_DECL, nonzero means label was defined inside a binding contour that restored a stack level and which is now exited. */ #define DECL_TOO_LATE(NODE) (LABEL_DECL_CHECK (NODE)->decl.bit_field_flag) @@ -1484,9 +1622,10 @@ struct tree_type /* In a FUNCTION_DECL, nonzero means a built in function. */ #define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN) + /* For a builtin function, identify which part of the compiler defined it. */ #define DECL_BUILT_IN_CLASS(NODE) \ -(FUNCTION_DECL_CHECK (NODE)->decl.built_in_class) + (FUNCTION_DECL_CHECK (NODE)->decl.built_in_class) /* Used in VAR_DECLs to indicate that the variable is a vtable. Used in FIELD_DECLs for vtable pointers. @@ -1501,12 +1640,12 @@ struct tree_type argument should be passed in the same way that the first union alternative would be passed. */ #define DECL_TRANSPARENT_UNION(NODE) \ -(PARM_DECL_CHECK (NODE)->decl.transparent_union) + (PARM_DECL_CHECK (NODE)->decl.transparent_union) /* Used in FUNCTION_DECLs to indicate that they should be run automatically at the beginning or end of execution. */ #define DECL_STATIC_CONSTRUCTOR(NODE) \ -(FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag) + (FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag) #define DECL_STATIC_DESTRUCTOR(NODE) \ (FUNCTION_DECL_CHECK (NODE)->decl.static_dtor_flag) @@ -1535,17 +1674,17 @@ struct tree_type /* Used in FUNCTION_DECLs to indicate that function entry and exit should be instrumented with calls to support routines. */ #define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \ -(FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit) + (FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit) /* Used in FUNCTION_DECLs to indicate that check-memory-usage should be disabled in this function. */ #define DECL_NO_CHECK_MEMORY_USAGE(NODE) \ -(FUNCTION_DECL_CHECK (NODE)->decl.no_check_memory_usage) + (FUNCTION_DECL_CHECK (NODE)->decl.no_check_memory_usage) /* Used in FUNCTION_DECLs to indicate that limit-stack-* should be disabled in this function. */ #define DECL_NO_LIMIT_STACK(NODE) \ -(FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack) + (FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack) /* Additional flags for language-specific uses. */ #define DECL_LANG_FLAG_0(NODE) (DECL_CHECK (NODE)->decl.lang_flag_0) @@ -1586,13 +1725,15 @@ struct tree_type argument's depth. */ #define DECL_POINTER_DEPTH(DECL) (DECL_CHECK (DECL)->decl.pointer_depth) +struct function; + struct tree_decl { struct tree_common common; const char *filename; int linenum; unsigned int uid; - union tree_node *size; + tree size; ENUM_BITFIELD(machine_mode) mode : 8; unsigned external_flag : 1; @@ -1625,7 +1766,8 @@ struct tree_decl unsigned pointer_depth : 2; unsigned non_addressable : 1; unsigned user_align : 1; - /* Three unused bits. */ + unsigned uninlinable : 1; + /* Two unused bits. */ unsigned lang_flag_0 : 1; unsigned lang_flag_1 : 1; @@ -1636,27 +1778,30 @@ 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 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; - union tree_node *size_unit; - union tree_node *name; - union tree_node *context; - union tree_node *arguments; /* Also used for DECL_FIELD_OFFSET */ - union tree_node *result; /* Also used for DECL_BIT_FIELD_TYPE */ - union tree_node *initial; /* Also used for DECL_QUALIFIER */ - union tree_node *abstract_origin; - union tree_node *assembler_name; - union tree_node *section_name; - union tree_node *machine_attributes; - struct rtx_def *rtl; /* RTL representation for object. */ - struct rtx_def *live_range_rtl; + tree size_unit; + tree name; + tree context; + tree arguments; /* Also used for DECL_FIELD_OFFSET */ + tree result; /* Also used for DECL_BIT_FIELD_TYPE */ + tree initial; /* Also used for DECL_QUALIFIER */ + tree abstract_origin; + tree assembler_name; + tree section_name; + tree attributes; + rtx rtl; /* RTL representation for object. */ + rtx live_range_rtl; /* In FUNCTION_DECL, if it is inline, holds the saved insn chain. In FIELD_DECL, is DECL_FIELD_BIT_OFFSET. @@ -1665,12 +1810,19 @@ struct tree_decl Used by Chill and Java in LABEL_DECL and by C++ and Java in VAR_DECL. */ union { struct function *f; - struct rtx_def *r; - union tree_node *t; + rtx r; + tree t; int i; } u2; - union tree_node *vindex; + /* In a FUNCTION_DECL, this is DECL_SAVED_TREE. */ + tree saved_tree; + + /* In a FUNCTION_DECL, these are function data which is to be kept + as long as FUNCTION_DECL is kept. */ + tree inlined_fns; + + tree vindex; HOST_WIDE_INT pointer_alias_set; /* Points to a structure whose details depend on the language in use. */ struct lang_decl *lang_specific; @@ -1715,6 +1867,7 @@ enum tree_index TI_INTEGER_ZERO, TI_INTEGER_ONE, + TI_INTEGER_MINUS_ONE, TI_NULL_POINTER, TI_SIZE_ZERO, @@ -1739,11 +1892,16 @@ enum tree_index TI_PTRDIFF_TYPE, TI_VA_LIST_TYPE, + TI_VOID_LIST_NODE, + TI_V4SF_TYPE, TI_V4SI_TYPE, + TI_V8HI_TYPE, TI_V8QI_TYPE, TI_V4HI_TYPE, TI_V2SI_TYPE, + TI_V2SF_TYPE, + TI_V16QI_TYPE, TI_MAIN_IDENTIFIER, @@ -1768,6 +1926,7 @@ extern tree global_trees[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] @@ -1793,14 +1952,24 @@ extern tree global_trees[TI_MAX]; #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 V16QI_type_node global_trees[TI_V16QI_TYPE] #define V4SF_type_node global_trees[TI_V4SF_TYPE] #define V4SI_type_node global_trees[TI_V4SI_TYPE] #define V8QI_type_node global_trees[TI_V8QI_TYPE] +#define V8HI_type_node global_trees[TI_V8HI_TYPE] #define V4HI_type_node global_trees[TI_V4HI_TYPE] #define V2SI_type_node global_trees[TI_V2SI_TYPE] +#define V2SF_type_node global_trees[TI_V2SF_TYPE] /* An enumeration of the standard C integer types. These must be ordered so that shorter types appear before longer ones. */ @@ -1841,17 +2010,6 @@ extern tree integer_types[itk_none]; #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. */ - -#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)); - /* Approximate positive square root of a host double. This is for statistical reports, not code generation. */ extern double approx_sqrt PARAMS ((double)); @@ -1891,6 +2049,11 @@ extern tree make_tree_vec PARAMS ((int)); extern tree get_identifier PARAMS ((const char *)); +/* Identical to get_identifier, except that the length is assumed + known. */ + +extern tree get_identifier_with_length PARAMS ((const char *, unsigned int)); + /* If an identifier with the name TEXT (a null-terminated string) has previously been referred to, return that node; otherwise return NULL_TREE. */ @@ -1904,7 +2067,6 @@ extern tree maybe_get_identifier PARAMS ((const char *)); 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)); @@ -1951,7 +2113,7 @@ extern HOST_WIDE_INT tree_low_cst PARAMS ((tree, int)); extern int tree_int_cst_msb PARAMS ((tree)); extern int tree_int_cst_sgn PARAMS ((tree)); extern int tree_expr_nonnegative_p PARAMS ((tree)); -extern int rtl_expr_nonnegative_p PARAMS ((struct rtx_def *)); +extern int rtl_expr_nonnegative_p PARAMS ((rtx)); extern int index_type_equal PARAMS ((tree, tree)); extern tree get_inner_array_type PARAMS ((tree)); @@ -1959,19 +2121,97 @@ extern tree get_inner_array_type PARAMS ((tree)); put the prototype here. Rtl.h does declare the prototype if tree.h had been included. */ -extern tree make_tree PARAMS ((tree, struct rtx_def *)); +extern tree make_tree PARAMS ((tree, rtx)); /* 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. */ + are not made. */ extern tree build_type_attribute_variant PARAMS ((tree, tree)); extern tree build_decl_attribute_variant PARAMS ((tree, tree)); -extern tree merge_machine_decl_attributes PARAMS ((tree, tree)); -extern tree merge_machine_type_attributes PARAMS ((tree, tree)); +/* Structure describing an attribute and a function to handle it. */ +struct attribute_spec +{ + /* The name of the attribute (without any leading or trailing __), + or NULL to mark the end of a table of attributes. */ + const char *const name; + /* The minimum length of the list of arguments of the attribute. */ + const int min_length; + /* The maximum length of the list of arguments of the attribute + (-1 for no maximum). */ + const int max_length; + /* Whether this attribute requires a DECL. If it does, it will be passed + from types of DECLs, function return types and array element types to + the DECLs, function types and array types respectively; but when + applied to a type in any other circumstances, it will be ignored with + a warning. (If greater control is desired for a given attribute, + this should be false, and the flags argument to the handler may be + used to gain greater control in that case.) */ + const bool decl_required; + /* Whether this attribute requires a type. If it does, it will be passed + from a DECL to the type of that DECL. */ + const bool type_required; + /* Whether this attribute requires a function (or method) type. If it does, + it will be passed from a function pointer type to the target type, + and from a function return type (which is not itself a function + pointer type) to the function type. */ + const bool function_type_required; + /* Function to handle this attribute. NODE points to the node to which + the attribute is to be applied. If a DECL, it should be modified in + place; if a TYPE, a copy should be created. NAME is the name of the + attribute (possibly with leading or trailing __). ARGS is the TREE_LIST + of the arguments (which may be NULL). FLAGS gives further information + about the context of the attribute. Afterwards, the attributes will + be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate, + unless *NO_ADD_ATTRS is set to true (which should be done on error, + as well as in any other cases when the attributes should not be added + to the DECL or TYPE). Depending on FLAGS, any attributes to be + applied to another type or DECL later may be returned; + otherwise the return value should be NULL_TREE. This pointer may be + NULL if no special handling is required beyond the checks implied + by the rest of this structure. */ + tree (*const handler) PARAMS ((tree *node, tree name, tree args, + int flags, bool *no_add_attrs)); +}; + +extern const struct attribute_spec default_target_attribute_table[]; + +/* Flags that may be passed in the third argument of decl_attributes, and + to handler functions for attributes. */ +enum attribute_flags +{ + /* The type passed in is the type of a DECL, and any attributes that + should be passed in again to be applied to the DECL rather than the + type should be returned. */ + ATTR_FLAG_DECL_NEXT = 1, + /* The type passed in is a function return type, and any attributes that + should be passed in again to be applied to the function type rather + than the return type should be returned. */ + ATTR_FLAG_FUNCTION_NEXT = 2, + /* The type passed in is an array element type, and any attributes that + should be passed in again to be applied to the array type rather + than the element type should be returned. */ + ATTR_FLAG_ARRAY_NEXT = 4, + /* The type passed in is a structure, union or enumeration type being + created, and should be modified in place. */ + ATTR_FLAG_TYPE_IN_PLACE = 8, + /* The attributes are being applied by default to a library function whose + name indicates known behavior, and should be silently ignored if they + are not in fact compatible with the function type. */ + ATTR_FLAG_BUILT_IN = 16 +}; + +/* Default versions of target-overridable functions. */ + +extern tree merge_decl_attributes PARAMS ((tree, tree)); +extern tree merge_type_attributes PARAMS ((tree, tree)); +extern int default_comp_type_attributes PARAMS ((tree, tree)); +extern void default_set_default_type_attributes PARAMS ((tree)); +extern void default_insert_attributes PARAMS ((tree, tree *)); +extern bool default_function_attribute_inlinable_p PARAMS ((tree)); /* Split a list of declspecs and attributes into two. */ @@ -1999,12 +2239,20 @@ extern tree lookup_attribute PARAMS ((const char *, 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. */ +#ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES +/* Given two Windows decl attributes lists, possibly including + dllimport, return a list of their union . */ +extern tree merge_dllimport_decl_attributes PARAMS ((tree, tree)); +#endif + +/* 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)); @@ -2050,12 +2298,17 @@ typedef struct record_layout_info_s 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)); @@ -2116,8 +2369,8 @@ extern HOST_WIDE_INT int_byte_position PARAMS ((tree)); enum size_type_kind { - SIZETYPE, /* Normal representation of sizes in bytes. */ - SSIZETYPE, /* Signed representation of sizes in bytes. */ + SIZETYPE, /* Normal representation of sizes in bytes. */ + SSIZETYPE, /* Signed representation of sizes in bytes. */ USIZETYPE, /* Unsigned representation of sizes in bytes. */ BITSIZETYPE, /* Normal representation of sizes in bits. */ SBITSIZETYPE, /* Signed representation of sizes in bits. */ @@ -2148,6 +2401,8 @@ extern tree size_int_type_wide PARAMS ((HOST_WIDE_INT, 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. */ @@ -2157,10 +2412,10 @@ extern void put_pending_sizes PARAMS ((tree)); + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \ + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256)) -/* If nonzero, an upper limit on alignment of structure fields, in bits. */ +/* If nonzero, an upper limit on alignment of structure fields, in bits. */ extern unsigned int maximum_field_alignment; -/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */ +/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */ extern unsigned int set_alignment; /* Concatenate two lists (chains of TREE_LIST nodes) X and Y @@ -2255,7 +2510,11 @@ extern void (*lang_unsave_expr_now) PARAMS ((tree)); /* Return 0 if it is safe to evaluate EXPR multiple times, return 1 if it is safe if EXPR is unsaved afterward, or return 2 if it is completely unsafe. */ -extern int unsafe_for_reeval PARAMS ((tree)); +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. @@ -2352,7 +2611,11 @@ extern tree maybe_build_cleanup PARAMS ((tree)); extern tree get_inner_reference PARAMS ((tree, HOST_WIDE_INT *, HOST_WIDE_INT *, tree *, enum machine_mode *, int *, - int *, unsigned int *)); + int *)); + +/* Return 1 if T is an expression that get_inner_reference handles. */ + +extern int handled_component_p PARAMS ((tree)); /* Given a DECL or TYPE, return the scope in which it was declared, or NUL_TREE if there is no containing scope. */ @@ -2386,10 +2649,6 @@ extern const char *input_filename; /* 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. */ @@ -2400,7 +2659,7 @@ extern int pedantic_lvalues; extern int immediate_size_expand; -/* Points to the FUNCTION_DECL of the function whose body we are reading. */ +/* Points to the FUNCTION_DECL of the function whose body we are reading. */ extern tree current_function_decl; @@ -2426,11 +2685,6 @@ extern const char *(*decl_printable_name) PARAMS ((tree, int)); extern void (*incomplete_decl_finalize_hook) PARAMS ((tree)); -extern const char *init_parse PARAMS ((const char *)); -extern void finish_parse PARAMS ((void)); - -extern const char * const language_string; - /* Declare a predefined function. Return the declaration. This function is provided by each language frontend. */ extern tree builtin_function PARAMS ((const char *, tree, int, @@ -2445,11 +2699,13 @@ 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)); /* In stmt.c */ extern int in_control_zone_p PARAMS ((void)); -extern void expand_fixups PARAMS ((struct rtx_def *)); +extern void expand_fixups PARAMS ((rtx)); extern tree expand_start_stmt_expr PARAMS ((void)); extern tree expand_end_stmt_expr PARAMS ((tree)); extern void expand_expr_stmt PARAMS ((tree)); @@ -2475,9 +2731,8 @@ 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 int optimize_tail_recursion PARAMS ((tree, rtx)); extern void expand_start_bindings_and_block PARAMS ((int, tree)); #define expand_start_bindings(flags) \ expand_start_bindings_and_block(flags, NULL_TREE) @@ -2487,13 +2742,9 @@ extern void start_cleanup_deferral PARAMS ((void)); 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 struct nesting * current_nesting_level 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)); @@ -2559,36 +2810,11 @@ extern tree fold_builtin PARAMS ((tree)); /* 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)); - -/* Called by report_error_function to print out function name. - * Default may be overridden by language front-ends. */ -extern void (*print_error_function) PARAMS ((const char *)); - /* Function to replace the DECL_LANG_SPECIFIC field of a DECL with a copy. */ extern void copy_lang_decl PARAMS ((tree)); /* Function called with no arguments to parse and compile the input. */ extern int yyparse PARAMS ((void)); -/* 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. */ @@ -2613,21 +2839,25 @@ extern tree gettags PARAMS ((void)); extern tree build_range_type PARAMS ((tree, tree, tree)); -/* Called after finishing a record, union or enumeral type. */ -extern void rest_of_type_compilation PARAMS ((tree, int)); - /* In alias.c */ extern void record_component_aliases PARAMS ((tree)); extern HOST_WIDE_INT get_alias_set PARAMS ((tree)); - -/* In c-common.c */ -extern HOST_WIDE_INT lang_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)); + +/* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing + that the assembler should talk about, set DECL_ASSEMBLER_NAME to an + appropriate IDENTIFIER_NODE. Otherwise, set it to the + ERROR_MARK_NODE to ensure that the assembler does not talk about + it. */ +extern void (*lang_set_decl_assembler_name) PARAMS ((tree)); struct obstack; /* In tree.c */ extern int really_constant_p PARAMS ((tree)); -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)); @@ -2645,7 +2875,6 @@ extern tree type_hash_lookup PARAMS ((unsigned int, 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 init_tree_codes PARAMS ((void)); extern void dump_tree_statistics PARAMS ((void)); extern void print_obstack_statistics PARAMS ((const char *, struct obstack *)); @@ -2655,14 +2884,15 @@ extern void print_obstack_name PARAMS ((char *, FILE *, #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 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)); @@ -2684,21 +2914,22 @@ extern void combine_temp_slots PARAMS ((void)); extern void free_temp_slots PARAMS ((void)); extern void pop_temp_slots PARAMS ((void)); extern void push_temp_slots PARAMS ((void)); -extern void preserve_temp_slots PARAMS ((struct rtx_def *)); +extern void preserve_temp_slots PARAMS ((rtx)); extern void preserve_rtl_expr_temps PARAMS ((tree)); extern int aggregate_value_p PARAMS ((tree)); extern void free_temps_for_rtl_expr PARAMS ((tree)); -extern void instantiate_virtual_regs PARAMS ((tree, struct rtx_def *)); -extern void unshare_all_rtl PARAMS ((tree, struct rtx_def *)); +extern void instantiate_virtual_regs PARAMS ((tree, rtx)); +extern void unshare_all_rtl PARAMS ((tree, rtx)); extern int max_parm_reg_num PARAMS ((void)); extern void push_function_context PARAMS ((void)); extern void pop_function_context PARAMS ((void)); extern void push_function_context_to PARAMS ((tree)); extern void pop_function_context_from PARAMS ((tree)); +extern void ggc_mark_struct_function PARAMS ((struct function *)); /* In print-rtl.c */ #ifdef BUFSIZ -extern void print_rtl PARAMS ((FILE *, struct rtx_def *)); +extern void print_rtl PARAMS ((FILE *, rtx)); #endif /* In print-tree.c */ @@ -2712,41 +2943,52 @@ extern void indent_to PARAMS ((FILE *, int)); #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 rtx expand_builtin_return_addr + PARAMS ((enum built_in_function, int, rtx)); 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)); +extern rtx emit_line_note PARAMS ((const char *, int)); /* In calls.c */ extern int setjmp_call_p PARAMS ((tree)); +/* In attribs.c. */ + +/* Process the attributes listed in ATTRIBUTES and install them in *NODE, + which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL, + it should be modified in place; if a TYPE, a copy should be created + unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further + information, in the form of a bitwise OR of flags in enum attribute_flags + from tree.h. Depending on these flags, some attributes may be + returned to be applied at a later stage (for example, to apply + a decl attribute to the declaration rather than to its type). */ +extern tree decl_attributes PARAMS ((tree *, tree, int)); + +/* The following function must be provided by front ends + using attribs.c. */ + +/* Possibly apply default attributes to a function (represented by + a FUNCTION_DECL). */ +extern void insert_default_attributes PARAMS ((tree)); + +/* Table of machine-independent attributes for checking formats, if used. */ +extern const struct attribute_spec *format_attribute_table; + +/* Table of machine-independent attributes for a particular language. */ +extern const struct attribute_spec *lang_attribute_table; + +/* Flag saying whether common language attributes are to be supported. */ +extern int lang_attribute_common; + /* In front end. */ extern int mark_addressable PARAMS ((tree)); extern void incomplete_type_error PARAMS ((tree, tree)); -extern void print_lang_statistics PARAMS ((void)); extern tree truthvalue_conversion PARAMS ((tree)); -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 print_lang_identifier PARAMS ((FILE *, tree, int)); -#endif extern int global_bindings_p PARAMS ((void)); extern void insert_block PARAMS ((tree)); @@ -2756,14 +2998,12 @@ extern void set_decl_abstract_flags PARAMS ((tree, int)); extern void output_inline_function PARAMS ((tree)); extern void set_decl_origin_self PARAMS ((tree)); -/* In front end. */ -extern void set_yydebug PARAMS ((int)); - /* In stor-layout.c */ extern void fixup_signed_type PARAMS ((tree)); +extern void internal_reference_types PARAMS ((void)); /* 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)); @@ -2782,7 +3022,9 @@ extern int div_and_round_double PARAMS ((enum tree_code, 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 bool parse_output_constraint PARAMS ((const char **, + int, int, int, + bool *, bool *, bool *)); extern void expand_asm_operands PARAMS ((tree, tree, tree, tree, int, const char *, int)); extern int any_pending_cleanups PARAMS ((int)); @@ -2803,10 +3045,6 @@ extern tree case_index_expr_type PARAMS ((void)); extern HOST_WIDE_INT all_cases_count PARAMS ((tree, int *)); extern void check_for_full_enumeration_handling PARAMS ((tree)); extern void declare_nonlocal_label PARAMS ((tree)); -#ifdef BUFSIZ -extern void lang_print_xnode PARAMS ((FILE *, tree, int)); -#endif - /* If KIND=='I', return a suitable global initializer (constructor) name. If KIND=='D', return a suitable global clean-up (destructor) name. */ @@ -2814,11 +3052,6 @@ extern tree get_file_function_name PARAMS ((int)); /* 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)); @@ -2848,15 +3081,41 @@ extern void dwarf2out_return_save PARAMS ((const char *, long)); 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. */ +/* The type of a function that walks over tree structure. */ + +typedef tree (*walk_tree_fn) PARAMS ((tree *, int *, void *)); + +/* In tree-dump.c */ + +/* Different tree dump places. When you add new tree dump places, + extend the DUMP_FILES array in tree-dump.c */ +enum tree_dump_index +{ + TDI_all, /* dump the whole translation unit */ + TDI_class, /* dump class hierarchy */ + TDI_original, /* dump each function before optimizing it */ + TDI_optimized, /* dump each function after optimizing it */ + TDI_inlined, /* dump each function after inlining + within it. */ + TDI_end +}; + +/* Bit masks to control tree dumping. Not all values are applicable to + all tree dumps. Add new ones at the end. When you define new + values, extend the DUMP_OPTIONS array in tree-dump.c */ +#define TDF_ADDRESS (1 << 0) /* dump node addresses */ +#define TDF_SLIM (1 << 1) /* don't go wild following links */ -extern void dwarf2out_begin_prologue PARAMS ((void)); +typedef struct dump_info *dump_info_p; -/* Output a marker (i.e. a label) for the absolute end of the generated - code for a function definition. */ +extern int dump_flag PARAMS ((dump_info_p, int, tree)); +extern int dump_enabled_p PARAMS ((enum tree_dump_index)); +extern FILE *dump_begin PARAMS ((enum tree_dump_index, int *)); +extern void dump_end PARAMS ((enum tree_dump_index, FILE *)); +extern void dump_node PARAMS ((tree, int, FILE *)); +extern int dump_switch_p PARAMS ((const char *)); +extern const char *dump_flag_name PARAMS ((enum tree_dump_index)); -extern void dwarf2out_end_epilogue PARAMS ((void)); /* Redefine abort to report an internal error w/o coredump, and reporting the location of the error in the source file. This logic