X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree.h;h=34e6f45f4f2c77ff3b47d4191f4e0cb8a95f4d85;hb=ac8a72dec9e57bd3380048ab0cef058c396cf550;hp=a2fdb1eef825bb11cf9217d674bf20f2eebbb62e;hpb=2aea9e36612b77fa729862a644deb9b7673bd8d8;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree.h b/gcc/tree.h index a2fdb1eef82..34e6f45f4f2 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -1,6 +1,6 @@ /* Front-end tree definitions for GNU compiler. Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003 Free Software Foundation, Inc. + 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -25,6 +25,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "machmode.h" #include "version.h" #include "input.h" +#include "statistics.h" /* Codes of tree nodes */ @@ -53,6 +54,10 @@ enum tree_code { extern const char tree_code_type[]; #define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)] +/* Returns nonzero iff CLASS is not the tree code of a type. */ + +#define IS_NON_TYPE_CODE_CLASS(CLASS) (strchr ("xbcdr<12se", (CLASS)) != 0) + /* Returns nonzero iff CLASS is the tree-code class of an expression. */ @@ -100,6 +105,24 @@ enum built_in_function /* Names for the above. */ extern const char *const built_in_names[(int) END_BUILTINS]; +/* Helper macros for math builtins. */ + +#define BUILTIN_EXP10_P(FN) \ + ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \ + || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L) + +#define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \ + || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \ + || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L) + +#define BUILTIN_SQRT_P(FN) \ + ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL) + +#define BUILTIN_CBRT_P(FN) \ + ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL) + +#define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN)) + /* An array of _DECL trees for the above. */ extern GTY(()) tree built_in_decls[(int) END_BUILTINS]; extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS]; @@ -140,15 +163,16 @@ struct tree_common GTY(()) unsigned readonly_flag : 1; unsigned unsigned_flag : 1; unsigned asm_written_flag: 1; - unsigned unused_0 : 1; - unsigned used_flag : 1; + unsigned nothrow_flag : 1; unsigned static_flag : 1; unsigned public_flag : 1; unsigned private_flag : 1; unsigned protected_flag : 1; unsigned deprecated_flag : 1; + + unsigned unused_0 : 1; unsigned unused_1 : 1; unsigned lang_flag_0 : 1; @@ -178,7 +202,8 @@ struct tree_common GTY(()) TREE_STATIC in VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR TREE_NO_UNUSED_WARNING in - CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR + CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR, NON_LVALUE_EXPR + ??? plus other expressions, apparently (e.g. MODIFY_EXPR). TREE_VIA_VIRTUAL in TREE_LIST or TREE_VEC TREE_CONSTANT_OVERFLOW in @@ -188,11 +213,14 @@ struct tree_common GTY(()) CLEANUP_EH_ONLY in TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT, TREE_LIST elements of a block's cleanup list. + TYPE_REF_CAN_ALIAS_ALL in + POINTER_TYPE, REFERENCE_TYPE public_flag: TREE_OVERFLOW in INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST + ??? and other expressions? TREE_PUBLIC in VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE EXPR_WFL_EMIT_LINE_NOTE in @@ -210,11 +238,15 @@ struct tree_common GTY(()) TREE_PROTECTED in BLOCK ..._DECL + CALL_FROM_THUNK_P in + CALL_EXPR side_effects_flag: TREE_SIDE_EFFECTS in all expressions + all decls + all constants volatile_flag: @@ -234,11 +266,17 @@ struct tree_common GTY(()) TREE_CONSTANT in all expressions + all decls + all constants unsigned_flag: - TREE_UNSIGNED in - INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL + TYPE_UNSIGNED in + all types + DECL_UNSIGNED in + all decls + BIT_FIELD_REF_UNSIGNED in + BIT_FIELD_REF SAVE_EXPR_NOPLACEHOLDER in SAVE_EXPR @@ -258,10 +296,14 @@ struct tree_common GTY(()) TREE_NOTHROW in CALL_EXPR, FUNCTION_DECL + TYPE_ALIGN_OK in + ..._TYPE + deprecated_flag: TREE_DEPRECATED in ..._DECL + */ /* Define accessors for the fields that all tree nodes have @@ -282,6 +324,44 @@ struct tree_common GTY(()) tree_check_failed (__t, (CODE), __FILE__, __LINE__, __FUNCTION__); \ __t; }) +#define TREE_CHECK2(T, CODE1, CODE2) __extension__ \ +({ const tree __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2)) \ + tree_check2_failed (__t, (CODE1), (CODE2), __FILE__, __LINE__, \ + __FUNCTION__); \ + __t; }) + +#define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \ +({ const tree __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2) \ + && TREE_CODE (__t) != (CODE3)) \ + tree_check3_failed (__t, (CODE1), (CODE2), (CODE3), __FILE__, \ + __LINE__, __FUNCTION__); \ + __t; }) + +#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \ +({ const tree __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2) \ + && TREE_CODE (__t) != (CODE3) \ + && TREE_CODE (__t) != (CODE4)) \ + tree_check4_failed (__t, (CODE1), (CODE2), (CODE3), (CODE4), \ + __FILE__, __LINE__, __FUNCTION__); \ + __t; }) + +#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \ +({ const tree __t = (T); \ + if (TREE_CODE (__t) != (CODE1) \ + && TREE_CODE (__t) != (CODE2) \ + && TREE_CODE (__t) != (CODE3) \ + && TREE_CODE (__t) != (CODE4) \ + && TREE_CODE (__t) != (CODE5)) \ + tree_check5_failed (__t, (CODE1), (CODE2), (CODE3), (CODE4), \ + (CODE5), __FILE__, __LINE__, __FUNCTION__); \ + __t; }) + #define TREE_CLASS_CHECK(T, CLASS) __extension__ \ ({ const tree __t = (T); \ if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \ @@ -294,7 +374,16 @@ struct tree_common GTY(()) ({ const tree __t = (T); \ char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \ if (!IS_EXPR_CODE_CLASS (__c)) \ - tree_class_check_failed (__t, 'e', __FILE__, __LINE__, \ + tree_class_check_failed (__t, 'E', __FILE__, __LINE__, \ + __FUNCTION__); \ + __t; }) + +/* These checks have to be special cased. */ +#define NON_TYPE_CHECK(T) __extension__ \ +({ const tree __t = (T); \ + char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \ + if (!IS_NON_TYPE_CODE_CLASS (__c)) \ + tree_class_check_failed (__t, 'T', __FILE__, __LINE__, \ __FUNCTION__); \ __t; }) @@ -342,6 +431,21 @@ struct tree_common GTY(()) extern void tree_check_failed (const tree, enum tree_code, const char *, int, const char *) ATTRIBUTE_NORETURN; +extern void tree_check2_failed (const tree, enum tree_code, enum tree_code, + const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void tree_check3_failed (const tree, enum tree_code, enum tree_code, + enum tree_code, const char *, int, + const char *) + ATTRIBUTE_NORETURN; +extern void tree_check4_failed (const tree, enum tree_code, enum tree_code, + enum tree_code, enum tree_code, + const char *, int, const char *) + ATTRIBUTE_NORETURN; +extern void tree_check5_failed (const tree, enum tree_code, enum tree_code, + enum tree_code, enum tree_code, enum tree_code, + const char *, int, const char *) + ATTRIBUTE_NORETURN; extern void tree_class_check_failed (const tree, int, const char *, int, const char *) ATTRIBUTE_NORETURN; @@ -355,12 +459,17 @@ extern void tree_operand_check_failed (int, enum tree_code, #else /* not ENABLE_TREE_CHECKING, or not gcc */ -#define TREE_CHECK(T, CODE) (T) -#define TREE_CLASS_CHECK(T, CODE) (T) -#define EXPR_CHECK(T) (T) -#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I]) -#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I]) -#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I]) +#define TREE_CHECK(T, CODE) (T) +#define TREE_CHECK2(T, CODE1, CODE2) (T) +#define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T) +#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T) +#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T) +#define TREE_CLASS_CHECK(T, CODE) (T) +#define EXPR_CHECK(T) (T) +#define NON_TYPE_CHECK(T) (T) +#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I]) +#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I]) +#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I]) #define TREE_RTL_OPERAND_CHECK(T, CODE, I) (*(rtx *) &((T)->exp.operands[I])) #endif @@ -371,6 +480,18 @@ extern void tree_operand_check_failed (int, enum tree_code, #define DECL_CHECK(T) TREE_CLASS_CHECK (T, 'd') #define CST_CHECK(T) TREE_CLASS_CHECK (T, 'c') #define STMT_CHECK(T) TREE_CLASS_CHECK (T, 's') +#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE) +#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE) + +#define SET_ARRAY_OR_VECTOR_CHECK(T) \ + TREE_CHECK3 (T, ARRAY_TYPE, SET_TYPE, VECTOR_TYPE) + +#define REC_OR_UNION_CHECK(T) \ + TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) + +#define NUMERICAL_TYPE_CHECK(T) \ + TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, \ + CHAR_TYPE, REAL_TYPE) /* In all nodes that are expressions, this is the data type of the expression. In POINTER_TYPE nodes, this is the type that the pointer points to. @@ -380,7 +501,11 @@ extern void tree_operand_check_failed (int, enum tree_code, /* Here is how primitive or already-canonicalized types' hash codes are made. */ -#define TYPE_HASH(TYPE) ((size_t) (TYPE) & 0777777) +#define TYPE_HASH(TYPE) (TYPE_UID (TYPE)) + +/* A simple hash function for an arbitrary tree node. This must not be + used in hash tables which are saved to a PCH. */ +#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777) /* Nodes are chained together for many purposes. Types are chained together to record them for being output to the debugger @@ -414,8 +539,8 @@ extern void tree_operand_check_failed (int, enum tree_code, && TREE_OPERAND (EXP, 0) != error_mark_node \ && (TYPE_MODE (TREE_TYPE (EXP)) \ == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \ - && (TREE_UNSIGNED (TREE_TYPE (EXP)) \ - == TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \ + && (TYPE_UNSIGNED (TREE_TYPE (EXP)) \ + == TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \ (EXP) = TREE_OPERAND (EXP, 0) /* Like STRIP_NOPS, but don't alter the TREE_TYPE main variant either. */ @@ -515,7 +640,10 @@ extern void tree_operand_check_failed (int, enum tree_code, /* In a VAR_DECL, nonzero means allocate static storage. In a FUNCTION_DECL, nonzero if function has been defined. - In a CONSTRUCTOR, nonzero means allocate static storage. */ + In a CONSTRUCTOR, nonzero means allocate static storage. + + ??? This is also used in lots of other nodes in unclear ways which + should be cleaned up some day. */ #define TREE_STATIC(NODE) ((NODE)->common.static_flag) /* In a TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT, or element of a @@ -523,29 +651,42 @@ extern void tree_operand_check_failed (int, enum tree_code, executed if an exception is thrown, not on normal exit of its scope. */ #define CLEANUP_EH_ONLY(NODE) ((NODE)->common.static_flag) -/* In a CONVERT_EXPR, NOP_EXPR or COMPOUND_EXPR, this means the node was - made implicitly and should not lead to an "unused value" warning. */ -#define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag) +/* In a CONVERT_EXPR, NOP_EXPR, NON_LVALUE_EXPR or COMPOUND_EXPR, this means + the node was made implicitly and should not lead to an "unused value" + warning. + + ??? Apparently this is also used on other expression types (such as + MODIFY_EXPR. This needs to be cleaned up sometime. */ +#define TREE_NO_UNUSED_WARNING(NODE) (EXPR_CHECK (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) +#define TREE_VIA_VIRTUAL(NODE) \ + (TREE_CHECK2 (NODE, TREE_LIST, TREE_VEC)->common.static_flag) /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means there was an overflow in folding. This is distinct from TREE_OVERFLOW because ANSI C requires a diagnostic when overflows occur in constant expressions. */ -#define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag) +#define TREE_CONSTANT_OVERFLOW(NODE) (CST_CHECK (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) \ (IDENTIFIER_NODE_CHECK (NODE)->common.static_flag) +/* Nonzero in a pointer or reference type means the data pointed to + by this type can alias anything. */ +#define TYPE_REF_CAN_ALIAS_ALL(NODE) \ + (PTR_OR_REF_CHECK (NODE)->common.static_flag) + /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means there was an overflow in folding, and no warning has been issued - for this subexpression. TREE_OVERFLOW implies - TREE_CONSTANT_OVERFLOW, but not vice versa. */ + for this subexpression. TREE_OVERFLOW implies TREE_CONSTANT_OVERFLOW, + but not vice versa. + + ??? Apparently, lots of code assumes this is defined in all + expressions. */ #define TREE_OVERFLOW(NODE) ((NODE)->common.public_flag) /* In a VAR_DECL or FUNCTION_DECL, @@ -555,12 +696,13 @@ extern void tree_operand_check_failed (int, enum tree_code, for this name in an inner scope. */ #define TREE_PUBLIC(NODE) ((NODE)->common.public_flag) -/* In any expression, nonzero means it has side effects or reevaluation - of the whole expression could produce a different value. - This is set if any subexpression is a function call, a side effect - or a reference to a volatile variable. - In a ..._DECL, this is set only if the declaration said `volatile'. */ -#define TREE_SIDE_EFFECTS(NODE) ((NODE)->common.side_effects_flag) +/* In any expression, decl, or constant, nonzero means it has side effects or + reevaluation of the whole expression could produce a different value. + This is set if any subexpression is a function call, a side effect or a + reference to a volatile variable. In a ..._DECL, this is set only if the + declaration said `volatile'. This will never be set for a constant. */ +#define TREE_SIDE_EFFECTS(NODE) \ + (NON_TYPE_CHECK (NODE)->common.side_effects_flag) /* Nonzero means this expression is volatile in the C sense: its address should be of type `volatile WHATEVER *'. @@ -575,27 +717,28 @@ extern void tree_operand_check_failed (int, enum tree_code, #define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag) /* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node, - nonzero means it may not be the lhs of an assignment. - In a ..._TYPE node, means this type is const-qualified - (but the macro TYPE_READONLY should be used instead of this macro - when the node is a type). */ -#define TREE_READONLY(NODE) ((NODE)->common.readonly_flag) + nonzero means it may not be the lhs of an assignment. */ +#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->common.readonly_flag) /* Nonzero if NODE is a _DECL with TREE_READONLY set. */ -#define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE)) +#define TREE_READONLY_DECL_P(NODE) (DECL_P (NODE) && TREE_READONLY (NODE)) + +/* Value of expression is constant. Always on in all ..._CST nodes. May + also appear in an expression or decl where the value is constant. */ +#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->common.constant_flag) + +/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */ +#define DECL_UNSIGNED(NODE) (DECL_CHECK (NODE)->common.unsigned_flag) -/* Value of expression is constant. - Always appears in all ..._CST nodes. - May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR - if the value is constant. */ -#define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag) +/* In a BIT_FIELD_REF, means the bitfield is to be interpreted as unsigned. */ +#define BIT_FIELD_REF_UNSIGNED(NODE) \ + (BIT_FIELD_REF_CHECK (NODE)->common.unsigned_flag) -/* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type. - In FIELD_DECL nodes, means an unsigned bit field. */ -#define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag) +/* In integral and pointer types, means an unsigned type. */ +#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->common.unsigned_flag) #define TYPE_TRAP_SIGNED(NODE) \ - (flag_trapv && ! TREE_UNSIGNED (TYPE_CHECK (NODE))) + (flag_trapv && ! TYPE_UNSIGNED (NODE)) /* Nonzero in a VAR_DECL means assembler code has been written. Nonzero in a FUNCTION_DECL means that the function has been compiled. @@ -620,6 +763,10 @@ extern void tree_operand_check_failed (int, enum tree_code, argument list. */ #define CALL_EXPR_HAS_RETURN_SLOT_ADDR(NODE) ((NODE)->common.private_flag) +/* In a CALL_EXPR, means that the call is the jump from a thunk to the + thunked-to function. */ +#define CALL_FROM_THUNK_P(NODE) ((NODE)->common.protected_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 @@ -781,7 +928,9 @@ struct tree_vec GTY(()) #define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND_CHECK_CODE (NODE, SAVE_EXPR, 1) #define SAVE_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, SAVE_EXPR, 2) -#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (SAVE_EXPR_CHECK (NODE)) +#define SAVE_EXPR_NOPLACEHOLDER(NODE) \ + (SAVE_EXPR_CHECK (NODE)->common.unsigned_flag) + /* 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 their values are @@ -791,6 +940,7 @@ struct tree_vec GTY(()) /* In a RTL_EXPR node. */ #define RTL_EXPR_SEQUENCE(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 0) #define RTL_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 1) +#define RTL_EXPR_ALT_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 2) /* In a WITH_CLEANUP_EXPR node. */ #define WITH_CLEANUP_EXPR_RTL(NODE) \ @@ -911,24 +1061,33 @@ struct tree_block GTY(()) /* Define fields and accessors for nodes representing data types. */ /* See tree.def for documentation of the use of these fields. - Look at the documentation of the various ..._TYPE tree codes. */ + Look at the documentation of the various ..._TYPE tree codes. + + Note that the type.values, type.minval, and type.maxval fields are + overloaded and used for different macros in different kinds of types. + Each macro must check to ensure the tree node is of the proper kind of + type. Note also that some of the front-ends also overload these fields, + so they must be checked as well. */ #define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid) #define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size) #define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit) #define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode) -#define TYPE_VALUES(NODE) (TYPE_CHECK (NODE)->type.values) -#define TYPE_DOMAIN(NODE) (TYPE_CHECK (NODE)->type.values) -#define TYPE_FIELDS(NODE) (TYPE_CHECK (NODE)->type.values) -#define TYPE_METHODS(NODE) (TYPE_CHECK (NODE)->type.maxval) -#define TYPE_VFIELD(NODE) (TYPE_CHECK (NODE)->type.minval) -#define TYPE_ARG_TYPES(NODE) (TYPE_CHECK (NODE)->type.values) -#define TYPE_METHOD_BASETYPE(NODE) (TYPE_CHECK (NODE)->type.maxval) -#define TYPE_OFFSET_BASETYPE(NODE) (TYPE_CHECK (NODE)->type.maxval) +#define TYPE_ORIG_SIZE_TYPE(NODE) (INTEGER_TYPE_CHECK (NODE)->type.values) +#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values) +#define TYPE_DOMAIN(NODE) (SET_ARRAY_OR_VECTOR_CHECK (NODE)->type.values) +#define TYPE_FIELDS(NODE) (REC_OR_UNION_CHECK (NODE)->type.values) +#define TYPE_METHODS(NODE) (REC_OR_UNION_CHECK (NODE)->type.maxval) +#define TYPE_VFIELD(NODE) (REC_OR_UNION_CHECK (NODE)->type.minval) +#define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values) +#define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval) +#define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval) #define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type.pointer_to) #define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type.reference_to) -#define TYPE_MIN_VALUE(NODE) (TYPE_CHECK (NODE)->type.minval) -#define TYPE_MAX_VALUE(NODE) (TYPE_CHECK (NODE)->type.maxval) +#define TYPE_NEXT_PTR_TO(NODE) (POINTER_TYPE_CHECK (NODE)->type.minval) +#define TYPE_NEXT_REF_TO(NODE) (REFERENCE_TYPE_CHECK (NODE)->type.minval) +#define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval) +#define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval) #define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision) #define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address) #define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer) @@ -1048,7 +1207,7 @@ struct tree_block GTY(()) 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)) + (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type.maxval) /* For a VECTOR_TYPE, this is the number of sub-parts of the vector. */ #define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \ @@ -1302,7 +1461,9 @@ struct tree_type GTY(()) For a VAR_DECL, holds the initial value. For a PARM_DECL, not used--default values for parameters are encoded in the type of the function, - not in the PARM_DECL slot. */ + not in the PARM_DECL slot. + + ??? Need to figure out some way to check this isn't a PARM_DECL. */ #define DECL_INITIAL(NODE) (DECL_CHECK (NODE)->decl.initial) /* For a PARM_DECL, records the data type used to pass the argument, which may be different from the type seen in the program. */ @@ -1342,12 +1503,7 @@ struct tree_type GTY(()) field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a FIELD_DECL. */ #define DECL_MODE(NODE) (DECL_CHECK (NODE)->decl.mode) -/* 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. - +/* Holds the RTL expression for the value of a variable or function. This value can be evaluated lazily for functions, variables with static storage duration, and labels. */ #define DECL_RTL(NODE) \ @@ -1369,8 +1525,9 @@ struct tree_type GTY(()) 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, this holds a pointer to a structure ("struct function") + that describes the status of this function. */ +#define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f) /* For FUNCTION_DECL, if it is built-in, this identifies which built-in operation it is. */ @@ -1621,13 +1778,6 @@ struct tree_type GTY(()) #define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \ (DECL_POINTER_ALIAS_SET (NODE) != - 1) -/* In a FUNCTION_DECL for which DECL_BUILT_IN does not hold, this is - the approximate number of statements in this function. There is - no need for this number to be exact; it is only used in various - heuristics regarding optimization. */ -#define DECL_ESTIMATED_INSNS(NODE) \ - (FUNCTION_DECL_CHECK (NODE)->decl.u1.i) - /* Nonzero for a decl which is at file scope. */ #define DECL_FILE_SCOPE_P(EXP) \ (! DECL_CONTEXT (EXP) \ @@ -1710,7 +1860,7 @@ struct tree_decl GTY(()) unsigned int align : 24; unsigned int off_align : 8; } a; - } GTY ((skip (""))) u1; + } GTY ((skip)) u1; tree size_unit; tree name; @@ -1817,6 +1967,10 @@ enum tree_index TI_BITSIZE_ONE, TI_BITSIZE_UNIT, + TI_PUBLIC, + TI_PROTECTED, + TI_PRIVATE, + TI_BOOLEAN_FALSE, TI_BOOLEAN_TRUE, @@ -1844,33 +1998,6 @@ enum tree_index TI_VOID_LIST_NODE, - TI_UV4SF_TYPE, - TI_UV4SI_TYPE, - TI_UV8HI_TYPE, - TI_UV8QI_TYPE, - TI_UV4HI_TYPE, - TI_UV2HI_TYPE, - TI_UV2SI_TYPE, - TI_UV2SF_TYPE, - TI_UV2DI_TYPE, - TI_UV1DI_TYPE, - TI_UV16QI_TYPE, - - TI_V4SF_TYPE, - TI_V16SF_TYPE, - TI_V4SI_TYPE, - TI_V8HI_TYPE, - TI_V8QI_TYPE, - TI_V4HI_TYPE, - TI_V2HI_TYPE, - TI_V2SI_TYPE, - TI_V2SF_TYPE, - TI_V2DF_TYPE, - TI_V2DI_TYPE, - TI_V1DI_TYPE, - TI_V16QI_TYPE, - TI_V4DF_TYPE, - TI_MAIN_IDENTIFIER, TI_MAX @@ -1902,9 +2029,9 @@ extern GTY(()) tree global_trees[TI_MAX]; #define bitsize_unit_node global_trees[TI_BITSIZE_UNIT] /* Base access nodes. */ -#define access_public_node NULL_TREE -#define access_protected_node size_zero_node -#define access_private_node size_one_node +#define access_public_node global_trees[TI_PUBLIC] +#define access_protected_node global_trees[TI_PROTECTED] +#define access_private_node global_trees[TI_PRIVATE] #define null_pointer_node global_trees[TI_NULL_POINTER] @@ -1946,31 +2073,6 @@ extern GTY(()) tree global_trees[TI_MAX]; #define main_identifier_node global_trees[TI_MAIN_IDENTIFIER] #define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node) -#define unsigned_V16QI_type_node global_trees[TI_UV16QI_TYPE] -#define unsigned_V4SI_type_node global_trees[TI_UV4SI_TYPE] -#define unsigned_V8QI_type_node global_trees[TI_UV8QI_TYPE] -#define unsigned_V8HI_type_node global_trees[TI_UV8HI_TYPE] -#define unsigned_V4HI_type_node global_trees[TI_UV4HI_TYPE] -#define unsigned_V2HI_type_node global_trees[TI_UV2HI_TYPE] -#define unsigned_V2SI_type_node global_trees[TI_UV2SI_TYPE] -#define unsigned_V2DI_type_node global_trees[TI_UV2DI_TYPE] -#define unsigned_V1DI_type_node global_trees[TI_UV1DI_TYPE] - -#define V16QI_type_node global_trees[TI_V16QI_TYPE] -#define V4SF_type_node global_trees[TI_V4SF_TYPE] -#define V4SI_type_node global_trees[TI_V4SI_TYPE] -#define 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 V2HI_type_node global_trees[TI_V2HI_TYPE] -#define V2SI_type_node global_trees[TI_V2SI_TYPE] -#define V2SF_type_node global_trees[TI_V2SF_TYPE] -#define V2DI_type_node global_trees[TI_V2DI_TYPE] -#define V2DF_type_node global_trees[TI_V2DF_TYPE] -#define V16SF_type_node global_trees[TI_V16SF_TYPE] -#define V1DI_type_node global_trees[TI_V1DI_TYPE] -#define V4DF_type_node global_trees[TI_V4DF_TYPE] - /* An enumeration of the standard C integer types. These must be ordered so that shorter types appear before longer ones, and so that signed types appear before unsigned ones, for the correct @@ -2050,6 +2152,7 @@ enum ptrmemfunc_vbit_where_t #define NULL_TREE (tree) NULL +extern GTY(()) tree frame_base_decl; extern tree decl_assembler_name (tree); /* Compute the number of bytes occupied by 'node'. This routine only @@ -2061,11 +2164,13 @@ extern size_t tree_size (tree); The TREE_CODE is the only argument. Contents are initialized to zero except for a few of the common fields. */ -extern tree make_node (enum tree_code); +extern tree make_node_stat (enum tree_code MEM_STAT_DECL); +#define make_node(t) make_node_stat (t MEM_STAT_INFO) /* Make a copy of a node, with all the same contents. */ -extern tree copy_node (tree); +extern tree copy_node_stat (tree MEM_STAT_DECL); +#define copy_node(t) copy_node_stat (t MEM_STAT_INFO) /* Make a copy of a chain of TREE_LIST nodes. */ @@ -2073,7 +2178,8 @@ extern tree copy_list (tree); /* Make a TREE_VEC. */ -extern tree make_tree_vec (int); +extern tree make_tree_vec_stat (int MEM_STAT_DECL); +#define make_tree_vec(t) make_tree_vec_stat (t MEM_STAT_INFO) /* Return the (unique) IDENTIFIER_NODE node for a given name. The name is supplied as a char *. */ @@ -2107,15 +2213,40 @@ extern tree maybe_get_identifier (const char *); extern tree build (enum tree_code, tree, ...); extern tree build_nt (enum tree_code, ...); +#if GCC_VERSION >= 3000 || __STDC_VERSION__ >= 199901L +/* Use preprocessor trickery to map "build" to "buildN" where N is the + expected number of arguments. This is used for both efficiency (no + varargs), and checking (verifying number of passed arguments). */ +#define build(code, ...) \ + _buildN1(build, _buildC1(__VA_ARGS__))(code, __VA_ARGS__) +#define _buildN1(BASE, X) _buildN2(BASE, X) +#define _buildN2(BASE, X) BASE##X +#define _buildC1(...) _buildC2(__VA_ARGS__,9,8,7,6,5,4,3,2,1,0,0) +#define _buildC2(x,a1,a2,a3,a4,a5,a6,a7,a8,a9,c,...) c +#endif + +extern tree build0_stat (enum tree_code, tree MEM_STAT_DECL); +#define build0(c,t) build0_stat (c,t MEM_STAT_INFO) +extern tree build1_stat (enum tree_code, tree, tree MEM_STAT_DECL); +#define build1(c,t1,t2) build1_stat (c,t1,t2 MEM_STAT_INFO) +extern tree build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL); +#define build2(c,t1,t2,t3) build2_stat (c,t1,t2,t3 MEM_STAT_INFO) +extern tree build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL); +#define build3(c,t1,t2,t3,t4) build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO) +extern tree build4_stat (enum tree_code, tree, tree, tree, tree, + tree MEM_STAT_DECL); +#define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO) + extern tree build_int_2_wide (unsigned HOST_WIDE_INT, HOST_WIDE_INT); extern tree build_vector (tree, tree); extern tree build_constructor (tree, tree); extern tree build_real_from_int_cst (tree, tree); extern tree build_complex (tree, tree, tree); extern tree build_string (int, const char *); -extern tree build1 (enum tree_code, tree, tree); -extern tree build_tree_list (tree, tree); -extern tree build_decl (enum tree_code, tree, tree); +extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL); +#define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO) +extern tree build_decl_stat (enum tree_code, tree, tree MEM_STAT_DECL); +#define build_decl(c,t,q) build_decl_stat (c,t,q MEM_STAT_INFO) extern tree build_block (tree, tree, tree, tree, tree); extern tree build_expr_wfl (tree, const char *, int, int); @@ -2126,10 +2257,12 @@ extern tree make_unsigned_type (int); extern void initialize_sizetypes (void); extern void set_sizetype (tree); extern void fixup_unsigned_type (tree); -extern tree build_pointer_type_for_mode (tree, enum machine_mode); +extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool); extern tree build_pointer_type (tree); -extern tree build_reference_type_for_mode (tree, enum machine_mode); +extern tree build_reference_type_for_mode (tree, enum machine_mode, bool); extern tree build_reference_type (tree); +extern tree build_vector_type_for_mode (tree, enum machine_mode); +extern tree build_vector_type (tree innertype, int nunits); extern tree build_type_no_quals (tree); extern tree build_index_type (tree); extern tree build_index_2_type (tree, tree); @@ -2145,7 +2278,7 @@ extern tree array_type_nelts (tree); extern tree value_member (tree, tree); extern tree purpose_member (tree, tree); extern tree binfo_member (tree, tree); -extern unsigned int attribute_hash_list (tree); + extern int attribute_list_equal (tree, tree); extern int attribute_list_contained (tree, tree); extern int tree_int_cst_equal (tree, tree); @@ -2282,6 +2415,11 @@ extern tree merge_attributes (tree, tree); extern tree merge_dllimport_decl_attributes (tree, tree); #endif +/* Check whether CAND is suitable to be returned from get_qualified_type + (BASE, TYPE_QUALS). */ + +extern bool check_qualified_type (tree, tree, int); + /* 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. */ @@ -2444,7 +2582,6 @@ extern tree size_int_type_wide (HOST_WIDE_INT, tree); extern tree round_up (tree, int); extern tree round_down (tree, int); extern tree get_pending_sizes (void); -extern int is_pending_size (tree); extern void put_pending_size (tree); extern void put_pending_sizes (tree); @@ -2469,7 +2606,8 @@ extern tree chainon (tree, tree); /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */ -extern tree tree_cons (tree, tree, tree); +extern tree tree_cons_stat (tree, tree, tree MEM_STAT_DECL); +#define tree_cons(t,q,w) tree_cons_stat (t,q,w MEM_STAT_INFO) /* Return the last tree node in a chain. */ @@ -2604,6 +2742,24 @@ extern int has_cleanups (tree); extern tree substitute_in_expr (tree, tree, tree); +/* This macro calls the above function but short-circuits the common + case of a constant to save time and also checks for NULL. */ + +#define SUBSTITUTE_IN_EXPR(EXP, F, R) \ + ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R)) + +/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement + for it within OBJ, a tree that is an object or a chain of references. */ + +extern tree substitute_placeholder_in_expr (tree, tree); + +/* This macro calls the above function but short-circuits the common + case of a constant to save time and also checks for NULL. */ + +#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \ + ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \ + : substitute_placeholder_in_expr (EXP, OBJ)) + /* 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 @@ -2714,6 +2870,8 @@ extern tree get_callee_fndecl (tree); extern void change_decl_assembler_name (tree, tree); extern int type_num_arguments (tree); extern tree lhd_unsave_expr_now (tree); +extern bool associative_tree_code (enum tree_code); +extern bool commutative_tree_code (enum tree_code); /* In stmt.c */ @@ -2824,6 +2982,7 @@ extern tree strip_float_extensions (tree); extern void record_component_aliases (tree); extern HOST_WIDE_INT get_alias_set (tree); extern int alias_sets_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT); +extern int alias_sets_might_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT); extern int readonly_fields_p (tree); extern int objects_must_conflict_p (tree, tree); @@ -2840,12 +2999,12 @@ extern int type_list_equal (tree, tree); extern int chain_member (tree, tree); extern tree type_hash_lookup (unsigned int, tree); extern void type_hash_add (unsigned int, tree); -extern unsigned int type_hash_list (tree); extern int simple_cst_list_equal (tree, tree); extern void dump_tree_statistics (void); extern void expand_function_end (void); extern void expand_function_start (tree, int); extern void expand_pending_sizes (tree); +extern tree reconstruct_complex_type (tree, tree); extern int real_onep (tree); extern int real_twop (tree); @@ -2900,7 +3059,6 @@ extern void indent_to (FILE *, int); #endif /* In expr.c */ -extern int apply_args_register_offset (int); extern rtx expand_builtin_return_addr (enum built_in_function, int, rtx); extern void check_max_integer_computation_mode (tree); @@ -2997,7 +3155,6 @@ extern void expand_decl (tree); extern int expand_decl_cleanup (tree, tree); extern int expand_decl_cleanup_eh (tree, tree, int); extern void expand_anon_union_decl (tree, tree, tree); -extern void expand_start_case_dummy (void); extern HOST_WIDE_INT all_cases_count (tree, int *); extern void check_for_full_enumeration_handling (tree); extern void declare_nonlocal_label (tree); @@ -3074,6 +3231,7 @@ extern const char *dump_flag_name (enum tree_dump_index); /* Assign the RTX to declaration. */ extern void set_decl_rtl (tree, rtx); +extern void set_decl_incoming_rtl (tree, rtx); /* Redefine abort to report an internal error w/o coredump, and reporting the location of the error in the source file. This logic