X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree.h;h=c6a9f078eca979ef1b1a1957caf25778f2a5f990;hb=32d8eb784a9aa7cf83866f9199749eb10704d60c;hp=0563f08554a9df3615cef0d200db1a1386b0ec45;hpb=4754934763ee7476140c80579bf20f46dc87ce5d;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree.h b/gcc/tree.h index 0563f08554a..c6a9f078eca 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. @@ -23,8 +23,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define GCC_TREE_H #include "machmode.h" -#include "version.h" #include "input.h" +#include "statistics.h" /* Codes of tree nodes */ @@ -34,7 +34,7 @@ enum tree_code { #include "tree.def" LAST_AND_UNUSED_TREE_CODE /* A convenient way to get a value for - NUM_TREE_CODE. */ + NUM_TREE_CODES. */ }; #undef DEFTREECODE @@ -53,12 +53,18 @@ 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. */ -#define IS_EXPR_CODE_CLASS(CLASS) \ - ((CLASS) == '<' || (CLASS) == '1' || (CLASS) == '2' || (CLASS) == 'e' \ - || (CLASS) == 'r' || (CLASS) == 's') +#define IS_EXPR_CODE_CLASS(CLASS) (strchr ("<12ers", (CLASS)) != 0) + +/* Returns nonzero iff NODE is an expression of some kind. */ + +#define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) /* Number of argument-words in each kind of tree-node. */ @@ -98,6 +104,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]; @@ -123,11 +147,13 @@ extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS]; See the accessor macros, defined below, for documentation of the fields. */ +union tree_ann_d; struct tree_common GTY(()) { tree chain; tree type; + union tree_ann_d *ann; ENUM_BITFIELD(tree_code) code : 8; @@ -138,7 +164,7 @@ struct tree_common GTY(()) unsigned readonly_flag : 1; unsigned unsigned_flag : 1; unsigned asm_written_flag: 1; - unsigned unused_0 : 1; + unsigned nowarning_flag : 1; unsigned used_flag : 1; unsigned nothrow_flag : 1; @@ -147,7 +173,7 @@ struct tree_common GTY(()) unsigned private_flag : 1; unsigned protected_flag : 1; unsigned deprecated_flag : 1; - unsigned unused_1 : 1; + unsigned invariant_flag : 1; unsigned lang_flag_0 : 1; unsigned lang_flag_1 : 1; @@ -156,7 +182,7 @@ struct tree_common GTY(()) unsigned lang_flag_4 : 1; unsigned lang_flag_5 : 1; unsigned lang_flag_6 : 1; - unsigned unused_2 : 1; + unsigned visited : 1; }; /* The following table lists the uses of each of the above flags and @@ -170,13 +196,12 @@ struct tree_common GTY(()) ..._TYPE, IDENTIFIER_NODE. In a STMT_EXPR, it means we want the result of the enclosed expression. + CALL_EXPR_TAILCALL in CALL_EXPR static_flag: TREE_STATIC in VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR - TREE_NO_UNUSED_WARNING in - CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR TREE_VIA_VIRTUAL in TREE_LIST or TREE_VEC TREE_CONSTANT_OVERFLOW in @@ -186,15 +211,23 @@ struct tree_common GTY(()) CLEANUP_EH_ONLY in TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT, TREE_LIST elements of a block's cleanup list. + ASM_INPUT_P in + ASM_EXPR + EH_FILTER_MUST_NOT_THROW in EH_FILTER_EXPR + 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 - EXPR_WITH_FILE_LOCATION + TREE_VIA_PUBLIC in + TREE_LIST or TREE_VEC + ASM_VOLATILE_P in + ASM_EXPR private_flag: @@ -208,11 +241,18 @@ 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 + + FORCED_LABEL in + LABEL_DECL volatile_flag: @@ -232,11 +272,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 @@ -244,7 +290,7 @@ struct tree_common GTY(()) TREE_ASM_WRITTEN in VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE - BLOCK + BLOCK, SSA_NAME used_flag: @@ -256,10 +302,27 @@ struct tree_common GTY(()) TREE_NOTHROW in CALL_EXPR, FUNCTION_DECL + TYPE_ALIGN_OK in + ..._TYPE + deprecated_flag: TREE_DEPRECATED in ..._DECL + + visited: + + Used in tree traversals to mark visited nodes. + + invariant_flag: + + TREE_INVARIANT in + all expressions. + + nowarning_flag: + + TREE_NO_WARNING in + ... any expr node */ /* Define accessors for the fields that all tree nodes have @@ -268,8 +331,7 @@ struct tree_common GTY(()) /* 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 = (ENUM_BITFIELD (tree_code)) (VALUE)) +#define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (VALUE)) /* When checking is enabled, errors will be generated if a tree node is accessed incorrectly. The macros abort with a fatal error. */ @@ -281,6 +343,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)) \ @@ -293,10 +393,29 @@ 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; }) +#define EREF_NODE_CHECK(t) __extension__ \ +({ const tree __t = t; \ + if (TREE_CODE (__t) != EPHI_NODE \ + && TREE_CODE (__t) != EKILL_NODE \ + && TREE_CODE (__t) != EUSE_NODE \ + && TREE_CODE (__t) != EEXIT_NODE) \ + tree_check_failed (__t, TREE_CODE (t), \ + __FILE__, __LINE__, __FUNCTION__); \ + __t; }) + #define TREE_VEC_ELT_CHECK(T, I) __extension__ \ (*({const tree __t = (T); \ const int __i = (I); \ @@ -308,6 +427,28 @@ struct tree_common GTY(()) __FILE__, __LINE__, __FUNCTION__); \ &__t->vec.a[__i]; })) +#define EPHI_NODE_ELT_CHECK(t, i) __extension__ \ +(*({const tree __t = t; \ + const int __i = (i); \ + if (TREE_CODE (__t) != EPHI_NODE) \ + tree_check_failed (__t, EPHI_NODE, \ + __FILE__, __LINE__, __FUNCTION__); \ + if (__i < 0 || __i >= __t->ephi.capacity) \ + ephi_node_elt_check_failed (__i, __t->ephi.num_args, \ + __FILE__, __LINE__, __FUNCTION__); \ + &__t->ephi.a[__i]; })) + +#define PHI_NODE_ELT_CHECK(t, i) __extension__ \ +(*({const tree __t = t; \ + const int __i = (i); \ + if (TREE_CODE (__t) != PHI_NODE) \ + tree_check_failed (__t, PHI_NODE, \ + __FILE__, __LINE__, __FUNCTION__); \ + if (__i < 0 || __i >= __t->phi.capacity) \ + phi_node_elt_check_failed (__i, __t->phi.num_args, \ + __FILE__, __LINE__, __FUNCTION__); \ + &__t->phi.a[__i]; })) + /* Special checks for TREE_OPERANDs. */ #define TREE_OPERAND_CHECK(T, I) __extension__ \ (*({const tree __t = EXPR_CHECK (T); \ @@ -341,12 +482,33 @@ 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; extern void tree_vec_elt_check_failed (int, int, const char *, int, const char *) ATTRIBUTE_NORETURN; +extern void phi_node_elt_check_failed (int, int, const char *, + int, const char *) + ATTRIBUTE_NORETURN; +extern void ephi_node_elt_check_failed (int, int, const char *, + int, const char *) + ATTRIBUTE_NORETURN; extern void tree_operand_check_failed (int, enum tree_code, const char *, int, const char *) @@ -354,22 +516,44 @@ 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])) +#define EREF_NODE_CHECK(T) (T) +#define PHI_NODE_ELT_CHECK(T, i) ((T)->phi.a[i]) +#define EPHI_NODE_ELT_CHECK(T, i) ((T)->ephi.a[i]) #endif +#define TREE_BLOCK(NODE) ((NODE)->exp.block) + #include "tree-check.h" #define TYPE_CHECK(T) TREE_CLASS_CHECK (T, 't') #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_OR_ARRAY_CHECK(T) \ + TREE_CHECK2 (T, ARRAY_TYPE, SET_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. @@ -379,7 +563,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 @@ -413,8 +601,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. */ @@ -439,6 +627,13 @@ extern void tree_operand_check_failed (int, enum tree_code, == TREE_TYPE (TREE_OPERAND (EXP, 0)))) \ (EXP) = TREE_OPERAND (EXP, 0) +/* Remove unnecessary type conversions according to + tree_ssa_useless_type_conversion. */ + +#define STRIP_USELESS_TYPE_CONVERSION(EXP) \ + while (tree_ssa_useless_type_conversion (EXP)) \ + EXP = TREE_OPERAND (EXP, 0) + /* Nonzero if TYPE represents an integral type. Note that we do not include COMPLEX types here. */ @@ -446,13 +641,21 @@ extern void tree_operand_check_failed (int, enum tree_code, (TREE_CODE (TYPE) == INTEGER_TYPE || TREE_CODE (TYPE) == ENUMERAL_TYPE \ || TREE_CODE (TYPE) == BOOLEAN_TYPE || TREE_CODE (TYPE) == CHAR_TYPE) +/* Nonzero if TYPE represents a scalar floating-point type. */ + +#define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE) + +/* Nonzero if TYPE represents a complex floating-point type. */ + +#define COMPLEX_FLOAT_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == COMPLEX_TYPE \ + && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE) + /* Nonzero if TYPE represents a floating-point type, including complex floating-point types. */ #define FLOAT_TYPE_P(TYPE) \ - (TREE_CODE (TYPE) == REAL_TYPE \ - || (TREE_CODE (TYPE) == COMPLEX_TYPE \ - && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)) + (SCALAR_FLOAT_TYPE_P (TYPE) || COMPLEX_FLOAT_TYPE_P (TYPE)) /* Nonzero if TYPE represents an aggregate (multi-component) type. */ @@ -504,9 +707,14 @@ extern void tree_operand_check_failed (int, enum tree_code, had its address taken. That matters for inline functions. */ #define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag) +#define CALL_EXPR_TAILCALL(NODE) (CALL_EXPR_CHECK(NODE)->common.addressable_flag) + /* 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 @@ -514,29 +722,38 @@ 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 an expr node (usually a conversion) this means the node was made + implicitly and should not lead to any sort of warning. */ +#define TREE_NO_WARNING(NODE) ((NODE)->common.nowarning_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, @@ -546,12 +763,18 @@ 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) + +/* In a LABEL_DECL, nonzero means this label had its address taken + and therefore can never be deleted and is a jump target for + computed gotos. */ +#define FORCED_LABEL(NODE) ((NODE)->common.side_effects_flag) /* Nonzero means this expression is volatile in the C sense: its address should be of type `volatile WHATEVER *'. @@ -566,27 +789,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. @@ -594,7 +818,9 @@ extern void tree_operand_check_failed (int, enum tree_code, to be compiled separately. Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE if the sdb debugging info for the type has been written. - In a BLOCK node, nonzero if reorder_blocks has already seen this block. */ + In a BLOCK node, nonzero if reorder_blocks has already seen this block. + In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal + PHI node. */ #define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag) /* Nonzero in a _DECL if the name is used in its scope. @@ -611,12 +837,19 @@ 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 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. */ + variant of the more generic type. + + In an SSA_NAME node, nonzero if the SSA_NAME node is on the SSA_NAME + freelist. */ #define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag) /* Used in classes in C++. */ @@ -629,6 +862,12 @@ extern void tree_operand_check_failed (int, enum tree_code, deprecated feature by __attribute__((deprecated)). */ #define TREE_DEPRECATED(NODE) ((NODE)->common.deprecated_flag) +/* Value of expression is function invariant. A strict subset of + TREE_CONSTANT, such an expression is constant over any one function + invocation, though not across different invocations. May appear in + any expression node. */ +#define TREE_INVARIANT(NODE) ((NODE)->common.invariant_flag) + /* These flags are available for each language front end to use internally. */ #define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0) #define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1) @@ -717,7 +956,7 @@ struct tree_vector GTY(()) tree elements; }; -#include "hashtable.h" +#include "symtab.h" /* Define fields and accessors for some special-purpose tree nodes. */ @@ -768,11 +1007,18 @@ struct tree_vec GTY(()) /* Define fields and accessors for some nodes that represent expressions. */ +/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */ +#define IS_EMPTY_STMT(NODE) (TREE_CODE (NODE) == NOP_EXPR \ + && VOID_TYPE_P (TREE_TYPE (NODE)) \ + && integer_zerop (TREE_OPERAND (NODE, 0))) + /* In a SAVE_EXPR node. */ #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 @@ -782,6 +1028,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) \ @@ -808,36 +1055,333 @@ struct tree_vec GTY(()) /* In a LOOP_EXPR node. */ #define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0) -/* In an EXPR_WITH_FILE_LOCATION node. */ -#define EXPR_WFL_EMIT_LINE_NOTE(NODE) \ - (EXPR_WITH_FILE_LOCATION_CHECK (NODE)->common.public_flag) -#define EXPR_WFL_NODE(NODE) \ - TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 0) -#define EXPR_WFL_FILENAME_NODE(NODE) \ - TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 1) -#define EXPR_WFL_FILENAME(NODE) \ - 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)) +/* The source location of this expression. Non-tree_exp nodes such as + decls and constants can be shared among multiple locations, so + return nothing. */ +#define EXPR_LOCUS(NODE) \ + (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \ + ? (NODE)->exp.locus \ + : (location_t *)NULL) +#define SET_EXPR_LOCUS(NODE, FROM) \ + (EXPR_CHECK (NODE)->exp.locus = (FROM)) +#define EXPR_FILENAME(NODE) \ + (EXPR_CHECK (NODE)->exp.locus->file) +#define EXPR_LINENO(NODE) \ + (EXPR_CHECK (NODE)->exp.locus->line) +#ifdef USE_MAPPED_LOCATION +#define EXPR_LOCATION(NODE) \ + (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) \ + ? (NODE)->exp.locus \ + : UNKNOWN_LOCATION) +#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION) +#else +#define EXPR_LOCATION(NODE) (*EXPR_LOCUS (NODE)) +#define EXPR_HAS_LOCATION(NODE) (EXPR_LOCUS (NODE) != NULL) +#endif /* In a TARGET_EXPR node. */ #define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0) #define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1) #define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2) +#define EXIT_EXPR_COND(NODE) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0) + +/* SWITCH_EXPR accessors. These give access to the condition, body and + original condition type (before any compiler conversions) + of the switch statement, respectively. */ +#define SWITCH_COND(NODE) TREE_OPERAND ((NODE), 0) +#define SWITCH_BODY(NODE) TREE_OPERAND ((NODE), 1) +#define SWITCH_LABELS(NODE) TREE_OPERAND ((NODE), 2) + +/* CASE_LABEL accessors. These give access to the high and low values + of a case label, respectively. */ +#define CASE_LOW(NODE) TREE_OPERAND ((NODE), 0) +#define CASE_HIGH(NODE) TREE_OPERAND ((NODE), 1) +#define CASE_LABEL(NODE) TREE_OPERAND ((NODE), 2) + +/* The operands of a BIND_EXPR. */ +#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0)) +#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1)) +#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2)) + +/* GOTO_EXPR accessor. This gives access to the label associated with + a goto statement. */ +#define GOTO_DESTINATION(NODE) TREE_OPERAND ((NODE), 0) + +/* ASM_STMT accessors. ASM_STRING returns a STRING_CST for the + instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and + ASM_CLOBBERS represent the outputs, inputs, and clobbers for the + statement. */ +#define ASM_STRING(NODE) TREE_OPERAND ((NODE), 0) +#define ASM_OUTPUTS(NODE) TREE_OPERAND ((NODE), 1) +#define ASM_INPUTS(NODE) TREE_OPERAND ((NODE), 2) +#define ASM_CLOBBERS(NODE) TREE_OPERAND ((NODE), 3) +/* Nonzero if we want to create an ASM_INPUT instead of an + ASM_OPERAND with no operands. */ +#define ASM_INPUT_P(NODE) (TREE_STATIC (NODE)) +#define ASM_VOLATILE_P(NODE) (TREE_PUBLIC (NODE)) + +/* COND_EXPR accessors. */ +#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0)) +#define COND_EXPR_THEN(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1)) +#define COND_EXPR_ELSE(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2)) + +/* LABEL_EXPR accessor. This gives access to the label associated with + the given label expression. */ +#define LABEL_EXPR_LABEL(NODE) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0) + +/* VDEF_EXPR accessors are specified in tree-flow.h, along with the other + accessors for SSA operands. */ + +/* CATCH_EXPR accessors. */ +#define CATCH_TYPES(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0) +#define CATCH_BODY(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1) + +/* EH_FILTER_EXPR accessors. */ +#define EH_FILTER_TYPES(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0) +#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1) +#define EH_FILTER_MUST_NOT_THROW(NODE) TREE_STATIC (EH_FILTER_EXPR_CHECK (NODE)) + struct tree_exp GTY(()) { struct tree_common common; + location_t *locus; int complexity; + tree block; tree GTY ((special ("tree_exp"), desc ("TREE_CODE ((tree) &%0)"))) operands[1]; }; +/* SSA_NAME accessors. */ + +/* Returns the variable being referenced. Once released, this is the + only field that can be relied upon. */ +#define SSA_NAME_VAR(NODE) SSA_NAME_CHECK (NODE)->ssa_name.var + +/* Returns the statement which defines this reference. Note that + we use the same field when chaining SSA_NAME nodes together on + the SSA_NAME freelist. */ +#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->common.chain + +/* Returns the SSA version number of this SSA name. Note that in + tree SSA, version numbers are not per variable and may be recycled. */ +#define SSA_NAME_VERSION(NODE) SSA_NAME_CHECK (NODE)->ssa_name.version + +/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are + never output, so we can safely use the ASM_WRITTEN_FLAG for this + status bit. */ +#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \ + SSA_NAME_CHECK (NODE)->common.asm_written_flag + +/* Nonzero if this SSA_NAME expression is currently on the freelist of + SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing + has no meaning for an SSA_NAME. */ +#define SSA_NAME_IN_FREE_LIST(NODE) \ + SSA_NAME_CHECK (NODE)->common.nothrow_flag + +struct tree_ssa_name GTY(()) +{ + struct tree_common common; + + /* _DECL wrapped by this SSA name. */ + tree var; + + /* SSA version number. */ + unsigned int version; +}; + +/* In a PHI_NODE node. */ +#define PHI_RESULT(NODE) PHI_NODE_CHECK (NODE)->phi.result + +/* Nonzero if the PHI node was rewritten by a previous pass through the + SSA renamer. */ +#define PHI_REWRITTEN(NODE) PHI_NODE_CHECK (NODE)->phi.rewritten +#define PHI_NUM_ARGS(NODE) PHI_NODE_CHECK (NODE)->phi.num_args +#define PHI_ARG_CAPACITY(NODE) PHI_NODE_CHECK (NODE)->phi.capacity +#define PHI_ARG_ELT(NODE, I) PHI_NODE_ELT_CHECK (NODE, I) +#define PHI_ARG_EDGE(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).e +#define PHI_ARG_DEF(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).def +#define PHI_ARG_NONZERO(NODE, I) PHI_NODE_ELT_CHECK (NODE, I).nonzero + +struct edge_def; + +struct phi_arg_d GTY(()) +{ + tree def; + struct edge_def * GTY((skip (""))) e; + bool nonzero; +}; + +struct tree_phi_node GTY(()) +{ + struct tree_common common; + tree result; + int num_args; + int capacity; + + /* Nonzero if the PHI node was rewritten by a previous pass through the + SSA renamer. */ + int rewritten; + + struct phi_arg_d GTY ((length ("((tree)&%h)->phi.capacity"))) a[1]; +}; + + +struct varray_head_tag; + +struct tree_eref_common GTY(()) +{ + struct tree_common common; + + /* SSAPRE: ID for the EREF. Used only for sorting erefs inside a + block. */ + int id; + + /* SSAPRE: Name for the EREF. Used only for printing.*/ + tree name; + + /* SSAPRE: The statement associated with this expression reference. */ + tree stmt; + + /* SSAPRE: True if expression needs to be saved to a temporary. */ + unsigned int save:1; + + /* SSAPRE: True if expression needs to be reloaded from a temporary. */ + unsigned int reload:1; + + /* SSAPRE: Redundancy class of expression. */ + unsigned int class; + + /* SSAPRE: Processed flag 1. */ + unsigned int processed:1; + + /* SSAPRE: True if expression is injured. */ + unsigned int injured:1; + + /* SSAPRE: Temporary assigned to this reference. */ + tree temp; + +}; + +struct tree_euse_node GTY(()) +{ + struct tree_eref_common common; + + /* SSAPRE: Definition for this use. */ + tree def; + + /* SSAPRE: True if this is an EPHI operand occurrence. */ + unsigned int op_occurrence:1; + + /* SSAPRE: True if expression was inserted as a PHI operand occurrence. */ + unsigned int inserted:1; + + /* SSAPRE: True if expression occurs as a lvalue. */ + unsigned int lval:1; +}; +struct ephi_arg_d GTY(()) +{ + + /* SSAPRE: True if this phi argument is injured. */ + unsigned int injured:1; + + /* SSAPRE: True if there is a real occurrence for this phi argument. */ + unsigned int has_real_use:1; + + /* SSAPRE: True if delayed renaming is required on this phi argument. */ + unsigned int delayed_rename:1; + + /* SSAPRE: Processed 2 flag for this phi argument. */ + unsigned int processed2:1; + + /* SSAPRE: True if this operand stops forward movement. */ + unsigned int stops:1; + + /* SSAPRE: Definition of this phi operand. */ + tree def; + + /* SSAPRE: Phi predecessor for this phi operand. */ + tree pred; + + struct edge_def * GTY((skip (""))) e; +}; +struct tree_ephi_node GTY(()) +{ + struct tree_eref_common common; + + /* SSAPRE: True if PHI is downsafe. */ + unsigned int downsafe:1; + + /* SSAPRE: True if PHI is cant_be_avail. */ + unsigned int cant_be_avail:1; + + /* SSAPRE: True if PHI is dead. */ + unsigned int dead:1; + + /* SSAPRE: True if PHI is pointless or identical to some value. */ + unsigned int identity:1; + + /* SSAPRE: True if replacing occurrence known for ESSA minimization. */ + unsigned int rep_occur_known:1; + + /* SSAPRE: True if PHI is pointless, but is also injured. */ + unsigned int ident_injured:1; + + /* SSAPRE: True if this PHI stops forward movement. */ + unsigned int stops:1; + + /* SSAPRE: If PHI's replacing occurrence is known, this is it. */ + tree identical_to; + + /* SSAPRE: Uses of this ephi. */ + struct varray_head_tag *uses; + + int num_args; + int capacity; + struct ephi_arg_d GTY ((length ("((tree)&%h)->ephi.capacity"))) a[1]; + +}; +/* In both EPHI's and EUSES */ +#define EREF_PROCESSED(NODE) EREF_NODE_CHECK (NODE)->eref.processed +#define EREF_ID(NODE) EREF_NODE_CHECK (NODE)->eref.id +#define EREF_NAME(NODE) EREF_NODE_CHECK (NODE)->eref.name +#define EREF_STMT(NODE) EREF_NODE_CHECK (NODE)->eref.stmt +#define EREF_RELOAD(NODE) EREF_NODE_CHECK (NODE)->eref.reload +#define EREF_SAVE(NODE) EREF_NODE_CHECK (NODE)->eref.save +#define EREF_CLASS(NODE) EREF_NODE_CHECK (NODE)->eref.class +#define EREF_INJURED(NODE) EREF_NODE_CHECK (NODE)->eref.injured +#define EREF_TEMP(NODE) EREF_NODE_CHECK (NODE)->eref.temp + +/* In a EUSE_NODE node. */ +#define EUSE_DEF(NODE) EUSE_NODE_CHECK (NODE)->euse.def +#define EUSE_PHIOP(NODE) EUSE_NODE_CHECK (NODE)->euse.op_occurrence +#define EUSE_INSERTED(NODE) EUSE_NODE_CHECK (NODE)->euse.inserted +#define EUSE_LVAL(NODE) EUSE_NODE_CHECK (NODE)->euse.lval + +/* In a EPHI_NODE node. */ +#define EPHI_NUM_ARGS(NODE) EPHI_NODE_CHECK (NODE)->ephi.num_args +#define EPHI_ARG_CAPACITY(NODE) EPHI_NODE_CHECK (NODE)->ephi.capacity +#define EPHI_ARG_ELT(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I) +#define EPHI_ARG_EDGE(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).e +#define EPHI_ARG_PRED(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).pred +#define EPHI_ARG_DEF(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).def +#define EPHI_ARG_INJURED(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).injured +#define EPHI_ARG_DELAYED_RENAME(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).delayed_rename +#define EPHI_ARG_HAS_REAL_USE(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).has_real_use +#define EPHI_ARG_STOPS(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).stops +#define EPHI_ARG_PROCESSED2(NODE, I) EPHI_NODE_ELT_CHECK (NODE, I).processed2 +#define EPHI_IDENTITY(NODE) EPHI_NODE_CHECK (NODE)->ephi.identity +#define EPHI_IDENT_INJURED(NODE) EPHI_NODE_CHECK (NODE)->ephi.ident_injured + +#define EPHI_REP_OCCUR_KNOWN(NODE) EPHI_NODE_CHECK (NODE)->ephi.rep_occur_known +#define EPHI_IDENTICAL_TO(NODE) EPHI_NODE_CHECK (NODE)->ephi.identical_to +#define EPHI_DOWNSAFE(NODE) EPHI_NODE_CHECK (NODE)->ephi.downsafe +#define EPHI_CANT_BE_AVAIL(NODE) EPHI_NODE_CHECK (NODE)->ephi.cant_be_avail +#define EPHI_DEAD(NODE) EPHI_NODE_CHECK (NODE)->ephi.dead +#define EPHI_USES(NODE) EPHI_NODE_CHECK (NODE)->ephi.uses +#define EPHI_STOPS(NODE) EPHI_NODE_CHECK (NODE)->ephi.stops + /* In a BLOCK node. */ #define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars) #define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks) @@ -902,24 +1446,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_OR_ARRAY_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) @@ -933,7 +1486,7 @@ struct tree_block GTY(()) /* For a VECTOR_TYPE node, this describes a different type which is emitted in the debugging output. We use this to describe a vector as a structure containing an array. */ -#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (TYPE_CHECK (NODE)->type.values) +#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values) /* For aggregate types, information about this type, as a base type for itself. Used in a language-dependent way for types that are @@ -1030,6 +1583,10 @@ struct tree_block GTY(()) #define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type.lang_flag_5) #define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type.lang_flag_6) +/* Used to keep track of visited nodes in tree traversals. This is set to + 0 by copy_node and make_node. */ +#define TREE_VISITED(NODE) ((NODE)->common.visited) + /* 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. */ @@ -1039,7 +1596,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) \ @@ -1216,6 +1773,16 @@ struct tree_type GTY(()) /* Nonzero if DECL represents a decl. */ #define DECL_P(DECL) (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd') +/* Nonzero if DECL represents a variable for the SSA passes. */ +#define SSA_VAR_P(DECL) \ + (TREE_CODE (DECL) == VAR_DECL \ + || TREE_CODE (DECL) == PARM_DECL \ + || TREE_CODE (DECL) == RESULT_DECL \ + || (TREE_CODE (DECL) == SSA_NAME \ + && (TREE_CODE (SSA_NAME_VAR (DECL)) == VAR_DECL \ + || TREE_CODE (SSA_NAME_VAR (DECL)) == PARM_DECL \ + || TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL))) + /* 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) @@ -1293,7 +1860,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. */ @@ -1333,12 +1902,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) \ @@ -1360,13 +1924,20 @@ 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. */ #define DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.f) +/* 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_NUM_STMTS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.i) + /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways. Before the struct containing the FUNCTION_DECL is laid out, DECL_VINDEX may point to a FUNCTION_DECL in a base class which @@ -1481,6 +2052,13 @@ struct tree_type GTY(()) #define DECL_DECLARED_INLINE_P(NODE) \ (FUNCTION_DECL_CHECK (NODE)->decl.declared_inline_flag) +/* In a VAR_DECL, nonzero if the decl is a register variable with + an explicit asm specification. */ +#define DECL_HARD_REGISTER(NODE) (DECL_CHECK (NODE)->decl.inline_flag) + +/* Value of the decls's visibility attribute */ +#define DECL_VISIBILITY(NODE) (DECL_CHECK (NODE)->decl.visibility) + /* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */ #define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable) @@ -1605,19 +2183,52 @@ struct tree_type GTY(()) #define DECL_POINTER_ALIAS_SET(NODE) \ (DECL_CHECK (NODE)->decl.pointer_alias_set) +/* Used to store the alias_var for a DECL node. */ +#define DECL_PTA_ALIASVAR(NODE) \ + (DECL_CHECK (NODE)->decl.alias_var) + +/* A numeric unique identifier for a LABEL_DECL. The UID allocation is + dense, unique within any one function, and may be used to index arrays. + If the value is -1, then no UID has been assigned. */ +#define LABEL_DECL_UID(NODE) \ + (LABEL_DECL_CHECK (NODE)->decl.pointer_alias_set) + /* Nonzero if an alias set has been assigned to this declaration. */ #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) \ + || TREE_CODE (DECL_CONTEXT (EXP)) == TRANSLATION_UNIT_DECL) + +/* Nonzero for a decl that has been marked as needing a memory slot. + NOTE: Never use this macro directly. It will give you incomplete + information. Most of the time this bit will only be set after alias + analysis in the tree optimizers. It's always better to call + needs_to_live_in_memory instead. To mark memory variables use + mark_call_clobbered. */ +#define DECL_NEEDS_TO_LIVE_IN_MEMORY_INTERNAL(DECL) \ + DECL_CHECK (DECL)->decl.needs_to_live_in_memory + +/* Nonzero for a decl that cgraph has decided should be inlined into + at least one call site. It is not meaningful to look at this + directly; always use cgraph_function_possibly_inlined_p. */ +#define DECL_POSSIBLY_INLINED(DECL) \ + FUNCTION_DECL_CHECK (DECL)->decl.possibly_inlined -struct function; +/* Enumerate visibility settings. */ +enum symbol_visibility +{ + VISIBILITY_DEFAULT, + VISIBILITY_INTERNAL, + VISIBILITY_HIDDEN, + VISIBILITY_PROTECTED +}; + +struct function; +union alias_var_def; struct tree_decl GTY(()) { struct tree_common common; @@ -1657,8 +2268,8 @@ struct tree_decl GTY(()) unsigned uninlinable : 1; unsigned thread_local_flag : 1; unsigned declared_inline_flag : 1; - unsigned unused : 3; - /* three unused bits. */ + unsigned seen_in_bind_expr : 1; + ENUM_BITFIELD(symbol_visibility) visibility : 2; unsigned lang_flag_0 : 1; unsigned lang_flag_1 : 1; @@ -1669,6 +2280,10 @@ struct tree_decl GTY(()) unsigned lang_flag_6 : 1; unsigned lang_flag_7 : 1; + unsigned needs_to_live_in_memory : 1; + unsigned possibly_inlined : 1; + /* 14 unused bits. */ + union tree_decl_u1 { /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is DECL_FUNCTION_CODE. */ @@ -1682,7 +2297,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; @@ -1717,9 +2332,38 @@ struct tree_decl GTY(()) tree vindex; HOST_WIDE_INT pointer_alias_set; + union alias_var_def *GTY ((skip(""))) alias_var; /* Points to a structure whose details depend on the language in use. */ struct lang_decl *lang_specific; }; + + +/* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE. + To reduce overhead, the nodes containing the statements are not trees. + This avoids the overhead of tree_common on all linked list elements. + + Use the interface in tree-iterator.h to access this node. */ + +#define STATEMENT_LIST_HEAD(NODE) \ + (STATEMENT_LIST_CHECK (NODE)->stmt_list.head) +#define STATEMENT_LIST_TAIL(NODE) \ + (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail) + +struct tree_statement_list_node + GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) +{ + struct tree_statement_list_node *prev; + struct tree_statement_list_node *next; + tree stmt; +}; + +struct tree_statement_list + GTY(()) +{ + struct tree_common common; + struct tree_statement_list_node *head; + struct tree_statement_list_node *tail; +}; enum tree_node_structure_enum { TS_COMMON, @@ -1734,7 +2378,13 @@ enum tree_node_structure_enum { TS_LIST, TS_VEC, TS_EXP, + TS_SSA_NAME, + TS_PHI_NODE, + TS_EPHI_NODE, + TS_EUSE_NODE, + TS_EREF_NODE, TS_BLOCK, + TS_STATEMENT_LIST, LAST_TS_ENUM }; @@ -1757,8 +2407,14 @@ union tree_node GTY ((ptr_alias (union lang_tree_node), struct tree_list GTY ((tag ("TS_LIST"))) list; struct tree_vec GTY ((tag ("TS_VEC"))) vec; struct tree_exp GTY ((tag ("TS_EXP"))) exp; + struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name; + struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi; + struct tree_eref_common GTY ((tag ("TS_EREF_NODE"))) eref; + struct tree_ephi_node GTY ((tag ("TS_EPHI_NODE"))) ephi; + struct tree_euse_node GTY ((tag ("TS_EUSE_NODE"))) euse; struct tree_block GTY ((tag ("TS_BLOCK"))) block; - }; + struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list; +}; /* Standard named or nameless data types of the C compiler. */ @@ -1789,6 +2445,10 @@ enum tree_index TI_BITSIZE_ONE, TI_BITSIZE_UNIT, + TI_PUBLIC, + TI_PROTECTED, + TI_PRIVATE, + TI_BOOLEAN_FALSE, TI_BOOLEAN_TRUE, @@ -1801,43 +2461,22 @@ enum tree_index TI_DOUBLE_TYPE, TI_LONG_DOUBLE_TYPE, + TI_FLOAT_PTR_TYPE, + TI_DOUBLE_PTR_TYPE, + TI_LONG_DOUBLE_PTR_TYPE, + TI_INTEGER_PTR_TYPE, + TI_VOID_TYPE, TI_PTR_TYPE, TI_CONST_PTR_TYPE, TI_SIZE_TYPE, + TI_PID_TYPE, TI_PTRDIFF_TYPE, TI_VA_LIST_TYPE, TI_BOOLEAN_TYPE, 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 @@ -1869,9 +2508,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] @@ -1879,6 +2518,11 @@ extern GTY(()) tree global_trees[TI_MAX]; #define double_type_node global_trees[TI_DOUBLE_TYPE] #define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE] +#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE] +#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE] +#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE] +#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE] + #define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE] #define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE] #define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE] @@ -1891,6 +2535,7 @@ extern GTY(()) tree global_trees[TI_MAX]; #define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE] /* The C type `size_t'. */ #define size_type_node global_trees[TI_SIZE_TYPE] +#define pid_type_node global_trees[TI_PID_TYPE] #define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE] #define va_list_type_node global_trees[TI_VA_LIST_TYPE] @@ -1908,31 +2553,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 @@ -1982,15 +2602,6 @@ enum tls_model { extern enum tls_model flag_tls_default; -/* Enumerate visibility settings. */ - -enum symbol_visibility -{ - VISIBILITY_DEFAULT, - VISIBILITY_INTERNAL, - VISIBILITY_HIDDEN, - VISIBILITY_PROTECTED -}; /* A pointer-to-function member type looks like: @@ -2021,6 +2632,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 @@ -2032,11 +2644,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. */ @@ -2044,7 +2658,26 @@ 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) + +/* Tree nodes for SSA analysis. */ + +extern tree make_phi_node (tree, int); +extern void init_phinodes (void); +extern void fini_phinodes (void); +extern void release_phi_node (tree); +#ifdef GATHER_STATISTICS +extern void phinodes_print_statistics (void); +#endif + +extern void init_ssanames (void); +extern void fini_ssanames (void); +extern tree make_ssa_name (tree, tree); +extern void release_ssa_name (tree); +#ifdef GATHER_STATISTICS +extern void ssanames_print_statistics (void); +#endif /* Return the (unique) IDENTIFIER_NODE node for a given name. The name is supplied as a char *. */ @@ -2078,17 +2711,44 @@ 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); +extern void annotate_with_file_line (tree, const char *, int); +extern void annotate_with_locus (tree, location_t); +extern tree build_empty_stmt (void); /* Construct various nodes representing data types. */ @@ -2097,16 +2757,19 @@ 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); extern tree build_array_type (tree, tree); extern tree build_function_type (tree, tree); extern tree build_function_type_list (tree, ...); +extern tree build_method_type_directly (tree, tree, tree); extern tree build_method_type (tree, tree); extern tree build_offset_type (tree, tree); extern tree build_complex_type (tree); @@ -2115,7 +2778,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); @@ -2252,6 +2915,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. */ @@ -2370,7 +3038,7 @@ extern tree convert (tree, tree); extern unsigned int expr_align (tree); extern tree expr_first (tree); extern tree expr_last (tree); -extern int expr_length (tree); +extern tree expr_only (tree); extern tree size_in_bytes (tree); extern HOST_WIDE_INT int_size_in_bytes (tree); extern tree bit_position (tree); @@ -2414,7 +3082,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); @@ -2439,7 +3106,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. */ @@ -2463,11 +3131,14 @@ extern int fields_length (tree); extern bool initializer_zerop (tree); -/* Given an initializer INIT, return TRUE if INIT is at least 3/4 zeros. - Otherwise return FALSE. */ - +extern void categorize_ctor_elements (tree, HOST_WIDE_INT *, HOST_WIDE_INT *); +extern HOST_WIDE_INT count_type_elements (tree); extern int mostly_zeros_p (tree); +/* add_var_to_bind_expr (bind_expr, var) binds var to bind_expr. */ + +extern void add_var_to_bind_expr (tree, tree); + /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */ extern int integer_zerop (tree); @@ -2496,11 +3167,6 @@ extern int integer_nonzerop (tree); extern int staticp (tree); -/* Gets an error if argument X is not an lvalue. - Also returns 1 if X is an lvalue, 0 if not. */ - -extern int lvalue_or_else (tree, const char *); - /* save_expr (EXP) returns an expression equivalent to EXP but it can be used multiple times within context CTX and only evaluate EXP once. */ @@ -2512,11 +3178,6 @@ extern tree save_expr (tree); extern tree skip_simple_arithmetic (tree); -/* Return TRUE if EXPR is a SAVE_EXPR or wraps simple arithmetic around a - SAVE_EXPR. Return FALSE otherwise. */ - -extern bool saved_expr_p (tree); - /* Returns the index of the first non-tree operand for CODE, or the number of operands if all are trees. */ @@ -2574,6 +3235,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 @@ -2582,7 +3261,12 @@ extern tree substitute_in_expr (tree, tree, tree); extern tree variable_size (tree); -/* stabilize_reference (EXP) returns an reference equivalent to EXP +/* Given a type T, force elaboration of any SAVE_EXPRs used in the definition + of that type. */ + +extern void force_type_save_exprs (tree); + +/* stabilize_reference (EXP) returns a reference equivalent to EXP but it can be used multiple times and only evaluate the subexpressions once. */ @@ -2632,13 +3316,6 @@ extern tree decl_function_context (tree); this _DECL with its context, or zero if none. */ extern tree decl_type_context (tree); -/* Given the FUNCTION_DECL for the current function, - return zero if it is ok for this function to be inline. - Otherwise return a warning message with a single %s - for the function's name. */ - -extern const char *function_cannot_inline_p (tree); - /* Return 1 if EXPR is the real constant zero. */ extern int real_zerop (tree); @@ -2661,6 +3338,11 @@ extern GTY(()) tree current_function_decl; /* Nonzero means a FUNC_BEGIN label was emitted. */ extern GTY(()) tree current_function_func_begin_label; +/* A DECL for the current file-scope context. When using IMA, this heads a + chain of FILE_DECLs; currently only C uses it. */ + +extern GTY(()) tree current_file_decl; + /* Nonzero means all ..._TYPE nodes should be allocated permanently. */ extern int all_types_permanent; @@ -2681,9 +3363,12 @@ extern tree get_file_function_name_long (const char *); extern tree get_set_constructor_bits (tree, char *, int); extern tree get_set_constructor_bytes (tree, unsigned char *, int); extern tree get_callee_fndecl (tree); -extern void set_decl_assembler_name (tree); +extern void change_decl_assembler_name (tree, tree); extern int type_num_arguments (tree); extern tree lhd_unsave_expr_now (tree); +extern bool is_essa_node (tree); +extern bool associative_tree_code (enum tree_code); +extern bool commutative_tree_code (enum tree_code); /* In stmt.c */ @@ -2703,20 +3388,11 @@ extern void expand_start_cond (tree, int); extern void expand_end_cond (void); extern void expand_start_else (void); extern void expand_start_elseif (tree); -extern struct nesting *expand_start_loop (int); -extern struct nesting *expand_start_loop_continue_elsewhere (int); -extern struct nesting *expand_start_null_loop (void); -extern void expand_loop_continue_here (void); -extern void expand_end_loop (void); -extern void expand_end_null_loop (void); -extern int expand_continue_loop (struct nesting *); -extern int expand_exit_loop (struct nesting *); -extern int expand_exit_loop_if_false (struct nesting *,tree); -extern int expand_exit_loop_top_cond (struct nesting *, tree); -extern int expand_exit_something (void); +extern void expand_stack_alloc (tree, tree); +extern rtx expand_stack_save (void); +extern void expand_stack_restore (tree); extern void expand_return (tree); -extern int optimize_tail_recursion (tree, rtx); extern void expand_start_bindings_and_block (int, tree); #define expand_start_bindings(flags) \ expand_start_bindings_and_block(flags, NULL_TREE) @@ -2732,7 +3408,7 @@ extern tree last_cleanup_this_contour (void); extern void expand_start_case (int, tree, tree, const char *); extern void expand_end_case_type (tree, tree); #define expand_end_case(cond) expand_end_case_type (cond, NULL) -extern int add_case_node (tree, tree, tree, tree *); +extern int add_case_node (tree, tree, tree, tree *, bool); extern int pushcase (tree, tree (*) (tree, tree), tree, tree *); extern int pushcase_range (tree, tree, tree (*) (tree, tree), tree, tree *); extern void using_eh_for_cleanups (void); @@ -2747,6 +3423,7 @@ extern void using_eh_for_cleanups (void); extern tree fold (tree); extern tree fold_initializer (tree); +extern tree fold_convert (tree, tree); extern tree fold_single_bit_test (enum tree_code, tree, tree, tree); extern int force_fit_type (tree, int); @@ -2777,15 +3454,29 @@ extern int div_and_round_double (enum tree_code, int, unsigned HOST_WIDE_INT, HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *); -extern int operand_equal_p (tree, tree, int); +enum operand_equal_flag +{ + OEP_ONLY_CONST = 1, + OEP_PURE_SAME = 2 +}; + +extern int operand_equal_p (tree, tree, unsigned int); + extern tree omit_one_operand (tree, tree, tree); extern tree invert_truthvalue (tree); +extern tree nondestructive_fold_unary_to_constant (enum tree_code, tree, tree); +extern tree nondestructive_fold_binary_to_constant (enum tree_code, tree, tree, tree); +extern tree fold_read_from_constant_string (tree); +extern tree int_const_binop (enum tree_code, tree, tree, int); /* In builtins.c */ extern tree fold_builtin (tree); extern enum built_in_function builtin_mathfn_code (tree); extern tree build_function_call_expr (tree, tree); extern tree mathfn_built_in (tree, enum built_in_function fn); +extern tree strip_float_extensions (tree); +extern tree simplify_builtin (tree, int); +extern tree c_strlen (tree, int); /* In convert.c */ extern tree strip_float_extensions (tree); @@ -2794,6 +3485,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); @@ -2810,12 +3502,15 @@ 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 void recompute_tree_invarant_for_addr_expr (tree); +extern bool needs_to_live_in_memory (tree); +extern tree make_vector (enum machine_mode, tree, int); +extern tree reconstruct_complex_type (tree, tree); extern int real_onep (tree); extern int real_twop (tree); @@ -2832,13 +3527,13 @@ extern void expand_main_function (void); extern void init_dummy_function_start (void); extern void expand_dummy_function_end (void); extern void init_function_for_compilation (void); +extern void allocate_struct_function (tree); extern void init_function_start (tree); extern void assign_parms (tree); extern void put_var_into_stack (tree, int); extern void flush_addressof (tree); -extern void uninitialized_vars_warning (tree); +extern void setjmp_vars_warning (tree); extern void setjmp_args_warning (void); -extern void mark_all_temps_used (void); extern void init_temp_slots (void); extern void combine_temp_slots (void); extern void free_temp_slots (void); @@ -2846,7 +3541,7 @@ extern void pop_temp_slots (void); extern void push_temp_slots (void); extern void preserve_temp_slots (rtx); extern void preserve_rtl_expr_temps (tree); -extern int aggregate_value_p (tree); +extern int aggregate_value_p (tree, tree); extern void free_temps_for_rtl_expr (tree); extern void instantiate_virtual_regs (tree, rtx); extern void unshare_all_rtl (tree, rtx); @@ -2869,7 +3564,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); @@ -2895,20 +3589,20 @@ extern rtx emit_line_note (location_t); #define ECF_LONGJMP 64 /* Nonzero if this is a syscall that makes a new process in the image of the current one. */ -#define ECF_FORK_OR_EXEC 128 -#define ECF_SIBCALL 256 +#define ECF_SIBCALL 128 /* Nonzero if this is a call to "pure" function (like const function, but may read memory. */ -#define ECF_PURE 512 +#define ECF_PURE 256 /* Nonzero if this is a call to a function that returns with the stack pointer depressed. */ -#define ECF_SP_DEPRESSED 1024 +#define ECF_SP_DEPRESSED 512 /* Nonzero if this call is known to always return. */ -#define ECF_ALWAYS_RETURN 2048 +#define ECF_ALWAYS_RETURN 1024 /* Create libcall block around the call. */ -#define ECF_LIBCALL_BLOCK 4096 +#define ECF_LIBCALL_BLOCK 2048 extern int flags_from_decl_or_type (tree); +extern int call_expr_flags (tree); extern int setjmp_call_p (tree); extern bool alloca_call_p (tree); @@ -2926,25 +3620,24 @@ extern bool alloca_call_p (tree); extern tree decl_attributes (tree *, tree, int); /* In integrate.c */ -extern void save_for_inline (tree); extern void set_decl_abstract_flags (tree, int); -extern void output_inline_function (tree); extern void set_decl_origin_self (tree); /* In stor-layout.c */ extern void set_min_and_max_values_for_integral_type (tree, int, bool); extern void fixup_signed_type (tree); extern void internal_reference_types (void); - +extern unsigned int update_alignment_for_field (record_layout_info, tree, + unsigned int); /* varasm.c */ extern void make_decl_rtl (tree, const char *); extern void make_decl_one_only (tree); extern int supports_one_only (void); extern void variable_section (tree, int); enum tls_model decl_tls_model (tree); -enum symbol_visibility decl_visibility (tree); extern void resolve_unique_section (tree, int, int); extern void mark_referenced (tree); +extern void mark_decl_referenced (tree); extern void notice_global_symbol (tree); /* In stmt.c */ @@ -2952,8 +3645,11 @@ extern void emit_nop (void); extern void expand_computed_goto (tree); extern bool parse_output_constraint (const char **, int, int, int, bool *, bool *, bool *); -extern void expand_asm_operands (tree, tree, tree, tree, int, - const char *, int); +extern bool parse_input_constraint (const char **, int, int, int, int, + const char * const *, bool *, bool *); +extern void expand_asm_operands (tree, tree, tree, tree, int, location_t); +extern void expand_asm_expr (tree); +extern bool asm_op_is_mem_input (tree, tree); extern tree resolve_asm_operand_names (tree, tree, tree); extern int any_pending_cleanups (void); extern void init_stmt_for_function (void); @@ -2965,10 +3661,14 @@ 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); +extern int containing_blocks_have_cleanups_or_stack_level (void); + +/* In gimplify.c. */ +extern tree create_artificial_label (void); +extern void gimplify_function_tree (tree); +extern const char *get_name (tree); +extern tree unshare_expr (tree); +extern void sort_case_labels (tree); /* If KIND=='I', return a suitable global initializer (constructor) name. If KIND=='D', return a suitable global clean-up (destructor) name. */ @@ -2982,7 +3682,7 @@ extern char *dwarf2out_cfi_label (void); /* Entry point to update the canonical frame address (CFA). */ -extern void dwarf2out_def_cfa (const char *, unsigned, long); +extern void dwarf2out_def_cfa (const char *, unsigned, HOST_WIDE_INT); /* Add the CFI for saving a register window. */ @@ -2991,36 +3691,44 @@ extern void dwarf2out_window_save (const char *); /* Add a CFI to update the running total of the size of arguments pushed onto the stack. */ -extern void dwarf2out_args_size (const char *, long); +extern void dwarf2out_args_size (const char *, HOST_WIDE_INT); /* Entry point for saving a register to the stack. */ -extern void dwarf2out_reg_save (const char *, unsigned, long); +extern void dwarf2out_reg_save (const char *, unsigned, HOST_WIDE_INT); /* Entry point for saving the return address in the stack. */ -extern void dwarf2out_return_save (const char *, long); +extern void dwarf2out_return_save (const char *, HOST_WIDE_INT); /* Entry point for saving the return address in a register. */ extern void dwarf2out_return_reg (const char *, unsigned); -/* The type of a function that walks over tree structure. */ +/* The type of a callback function for walking over tree structure. */ typedef tree (*walk_tree_fn) (tree *, int *, void *); +tree walk_tree (tree*, walk_tree_fn, void*, void*); +tree walk_tree_without_duplicates (tree*, walk_tree_fn, 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 */ + 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_none, /* No dump */ + TDI_tu, /* 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_generic, /* dump each function after genericizing it */ + TDI_nested, /* dump each function after unnesting it */ TDI_inlined, /* dump each function after inlining within it. */ + TDI_vcg, /* create a VCG graph file for each + function's flowgraph. */ + TDI_xml, /* dump function call graph. */ + TDI_all, /* enable all the dumps. */ TDI_end }; @@ -3029,6 +3737,16 @@ enum tree_dump_index 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 */ +#define TDF_RAW (1 << 2) /* don't unparse the function */ +#define TDF_DETAILS (1 << 3) /* show more detailed info about + each pass */ +#define TDF_STATS (1 << 4) /* dump various statistics about + each pass */ +#define TDF_BLOCKS (1 << 5) /* display basic block boundaries */ +#define TDF_VOPS (1 << 6) /* display virtual operands */ +#define TDF_LINENO (1 << 7) /* display statement line numbers */ +#define TDF_UID (1 << 8) /* display decl UIDs */ + typedef struct dump_info *dump_info_p; @@ -3042,6 +3760,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 @@ -3068,6 +3787,8 @@ typedef enum perm_list_kind, temp_list_kind, vec_kind, + phi_kind, + ssa_name_kind, x_kind, lang_decl, lang_type, @@ -3076,5 +3797,10 @@ typedef enum extern int tree_node_counts[]; extern int tree_node_sizes[]; + +/* True if we are in gimple form and the actions of the folders need to + be restricted. False if we are not in gimple form and folding is not + restricted to creating gimple expressions. */ +extern bool in_gimple_form; #endif /* GCC_TREE_H */