X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Ftree.h;h=decc05dc3c31c9cbab3a8237eddc3efd56a52c36;hp=f88c244146f73dab6586b4f731e16a891556514e;hb=5d62553f1596001eaba861c4f8f43386ed7a7233;hpb=8ea8de246d340fe80ffe897e5ca2c083934ecebc diff --git a/gcc/tree.h b/gcc/tree.h index f88c244146f..decc05dc3c3 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -1,12 +1,12 @@ /* Front-end tree definitions for GNU compiler. Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. + 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free -Software Foundation; either version 2, or (at your option) any later +Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY @@ -15,9 +15,8 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #ifndef GCC_TREE_H #define GCC_TREE_H @@ -27,6 +26,8 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #include "input.h" #include "statistics.h" #include "vec.h" +#include "double-int.h" +#include "alias.h" /* Codes of tree nodes */ @@ -41,7 +42,8 @@ enum tree_code { #undef DEFTREECODE -extern unsigned char tree_contains_struct[256][64]; +#define MAX_TREE_CODES 512 +extern unsigned char tree_contains_struct[MAX_TREE_CODES][64]; #define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)]) /* Number of language-independent tree codes. */ @@ -64,6 +66,8 @@ enum tree_code_class { tcc_binary, /* A binary arithmetic expression. */ tcc_statement, /* A statement expression, which have side effects but usually no interesting value. */ + tcc_vl_exp, /* A function call or other expression with a + variable-length operand vector. */ tcc_expression, /* Any other expression. */ tcc_gimple_stmt /* A GIMPLE statement. */ }; @@ -78,7 +82,6 @@ extern const char *const tree_code_class_strings[]; #define TREE_CODE_CLASS_STRING(CLASS)\ tree_code_class_strings[(int) (CLASS)] -#define MAX_TREE_CODES 256 extern const enum tree_code_class tree_code_type[]; #define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)] @@ -149,6 +152,12 @@ extern const enum tree_code_class tree_code_type[]; #define STATEMENT_CLASS_P(CODE)\ (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement) +/* Nonzero if CODE represents a function call-like expression with a + variable-length operand vector. */ + +#define VL_EXP_CLASS_P(CODE)\ + (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_vl_exp) + /* Nonzero if CODE represents any other expression. */ #define EXPRESSION_CLASS_P(CODE)\ @@ -179,12 +188,15 @@ extern const enum tree_code_class tree_code_type[]; (TREE_CODE (NODE) == OMP_PARALLEL \ || TREE_CODE (NODE) == OMP_FOR \ || TREE_CODE (NODE) == OMP_SECTIONS \ + || TREE_CODE (NODE) == OMP_SECTIONS_SWITCH \ || TREE_CODE (NODE) == OMP_SINGLE \ || TREE_CODE (NODE) == OMP_SECTION \ || TREE_CODE (NODE) == OMP_MASTER \ || TREE_CODE (NODE) == OMP_ORDERED \ || TREE_CODE (NODE) == OMP_CRITICAL \ || TREE_CODE (NODE) == OMP_RETURN \ + || TREE_CODE (NODE) == OMP_ATOMIC_LOAD \ + || TREE_CODE (NODE) == OMP_ATOMIC_STORE \ || TREE_CODE (NODE) == OMP_CONTINUE) /* Number of argument-words in each kind of tree-node. */ @@ -264,6 +276,7 @@ extern const char * built_in_names[(int) END_BUILTINS]; #define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN)) #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L +#define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R #define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL /* An array of _DECL trees for the above. */ @@ -355,7 +368,7 @@ union tree_ann_d; struct tree_base GTY(()) { - ENUM_BITFIELD(tree_code) code : 8; + ENUM_BITFIELD(tree_code) code : 16; unsigned side_effects_flag : 1; unsigned constant_flag : 1; @@ -374,6 +387,7 @@ struct tree_base GTY(()) unsigned protected_flag : 1; unsigned deprecated_flag : 1; unsigned invariant_flag : 1; + unsigned saturating_flag : 1; unsigned lang_flag_0 : 1; unsigned lang_flag_1 : 1; @@ -384,6 +398,8 @@ struct tree_base GTY(()) unsigned lang_flag_6 : 1; unsigned visited : 1; + unsigned spare : 23; + /* FIXME tuples: Eventually, we need to move this somewhere external to the trees. */ union tree_ann_d *ann; @@ -426,8 +442,6 @@ struct gimple_stmt GTY(()) VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR BINFO_VIRTUAL_P in TREE_BINFO - TREE_CONSTANT_OVERFLOW in - INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST TREE_SYMBOL_REFERENCED in IDENTIFIER_NODE CLEANUP_EH_ONLY in @@ -437,7 +451,12 @@ struct gimple_stmt GTY(()) EH_FILTER_MUST_NOT_THROW in EH_FILTER_EXPR TYPE_REF_CAN_ALIAS_ALL in POINTER_TYPE, REFERENCE_TYPE - CASE_HIGH_SEEN in CASE_LABEL_EXPR + MOVE_NONTEMPORAL in + GIMPLE_MODIFY_STMT + CASE_HIGH_SEEN in + CASE_LABEL_EXPR + CALL_CANNOT_INLINE_P in + CALL_EXPR public_flag: @@ -447,6 +466,8 @@ struct gimple_stmt GTY(()) VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE ASM_VOLATILE_P in ASM_EXPR + CALL_EXPR_VA_ARG_PACK in + CALL_EXPR TYPE_CACHED_VALUES_P in ..._TYPE SAVE_EXPR_RESOLVED_P in @@ -560,6 +581,11 @@ struct gimple_stmt GTY(()) TREE_INVARIANT in all expressions. + saturating_flag: + + TYPE_SATURATING in + all types + nowarning_flag: TREE_NO_WARNING in @@ -586,21 +612,21 @@ enum tree_node_structure_enum { #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) #define TREE_CHECK(T, CODE) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) != (CODE)) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ (CODE), 0); \ __t; }) #define TREE_NOT_CHECK(T, CODE) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) == (CODE)) \ tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ (CODE), 0); \ __t; }) #define TREE_CHECK2(T, CODE1, CODE2) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) != (CODE1) \ && TREE_CODE (__t) != (CODE2)) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ @@ -608,7 +634,7 @@ enum tree_node_structure_enum { __t; }) #define TREE_NOT_CHECK2(T, CODE1, CODE2) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) == (CODE1) \ || TREE_CODE (__t) == (CODE2)) \ tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ @@ -616,7 +642,7 @@ enum tree_node_structure_enum { __t; }) #define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) != (CODE1) \ && TREE_CODE (__t) != (CODE2) \ && TREE_CODE (__t) != (CODE3)) \ @@ -625,7 +651,7 @@ enum tree_node_structure_enum { __t; }) #define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) == (CODE1) \ || TREE_CODE (__t) == (CODE2) \ || TREE_CODE (__t) == (CODE3)) \ @@ -634,7 +660,7 @@ enum tree_node_structure_enum { __t; }) #define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) != (CODE1) \ && TREE_CODE (__t) != (CODE2) \ && TREE_CODE (__t) != (CODE3) \ @@ -644,7 +670,7 @@ enum tree_node_structure_enum { __t; }) #define NON_TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) == (CODE1) \ || TREE_CODE (__t) == (CODE2) \ || TREE_CODE (__t) == (CODE3) \ @@ -654,7 +680,7 @@ enum tree_node_structure_enum { __t; }) #define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) != (CODE1) \ && TREE_CODE (__t) != (CODE2) \ && TREE_CODE (__t) != (CODE3) \ @@ -665,7 +691,7 @@ enum tree_node_structure_enum { __t; }) #define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) == (CODE1) \ || TREE_CODE (__t) == (CODE2) \ || TREE_CODE (__t) == (CODE3) \ @@ -676,28 +702,28 @@ enum tree_node_structure_enum { __t; }) #define CONTAINS_STRUCT_CHECK(T, STRUCT) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (tree_contains_struct[TREE_CODE(__t)][(STRUCT)] != 1) \ tree_contains_struct_check_failed (__t, (STRUCT), __FILE__, __LINE__, \ __FUNCTION__); \ __t; }) #define TREE_CLASS_CHECK(T, CLASS) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \ tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__, \ __FUNCTION__); \ __t; }) #define TREE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) < (CODE1) || TREE_CODE (__t) > (CODE2)) \ tree_range_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ (CODE1), (CODE2)); \ __t; }) #define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) != OMP_CLAUSE) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ OMP_CLAUSE, 0); \ @@ -707,7 +733,7 @@ enum tree_node_structure_enum { __t; }) #define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TREE_CODE (__t) != OMP_CLAUSE) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ OMP_CLAUSE, 0); \ @@ -719,7 +745,7 @@ enum tree_node_structure_enum { /* These checks have to be special cased. */ #define EXPR_CHECK(T) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \ if (!IS_EXPR_CODE_CLASS (__c)) \ tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__, \ @@ -727,7 +753,7 @@ enum tree_node_structure_enum { __t; }) #define GIMPLE_STMT_CHECK(T) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \ if (!IS_GIMPLE_STMT_CODE_CLASS (__c)) \ tree_class_check_failed (__t, tcc_gimple_stmt, __FILE__, __LINE__,\ @@ -736,14 +762,14 @@ enum tree_node_structure_enum { /* These checks have to be special cased. */ #define NON_TYPE_CHECK(T) __extension__ \ -({ const tree __t = (T); \ +({ __typeof (T) const __t = (T); \ if (TYPE_P (__t)) \ tree_not_class_check_failed (__t, tcc_type, __FILE__, __LINE__, \ __FUNCTION__); \ __t; }) #define TREE_VEC_ELT_CHECK(T, I) __extension__ \ -(*({const tree __t = (T); \ +(*({__typeof (T) const __t = (T); \ const int __i = (I); \ if (TREE_CODE (__t) != TREE_VEC) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ @@ -753,9 +779,9 @@ enum tree_node_structure_enum { __FILE__, __LINE__, __FUNCTION__); \ &__t->vec.a[__i]; })) -#define PHI_NODE_ELT_CHECK(t, i) __extension__ \ -(*({const tree __t = t; \ - const int __i = (i); \ +#define PHI_NODE_ELT_CHECK(T, I) __extension__ \ +(*({__typeof (T) const __t = (T); \ + const int __i = (I); \ if (TREE_CODE (__t) != PHI_NODE) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ PHI_NODE, 0); \ @@ -764,9 +790,9 @@ enum tree_node_structure_enum { __FILE__, __LINE__, __FUNCTION__); \ &__t->phi.a[__i]; })) -#define OMP_CLAUSE_ELT_CHECK(t, i) __extension__ \ -(*({const tree __t = t; \ - const int __i = (i); \ +#define OMP_CLAUSE_ELT_CHECK(T, I) __extension__ \ +(*({__typeof (T) const __t = (T); \ + const int __i = (I); \ if (TREE_CODE (__t) != OMP_CLAUSE) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, \ OMP_CLAUSE, 0); \ @@ -777,42 +803,42 @@ enum tree_node_structure_enum { /* Special checks for TREE_OPERANDs. */ #define TREE_OPERAND_CHECK(T, I) __extension__ \ -(*({const tree __t = EXPR_CHECK (T); \ +(*({__typeof (T) const __t = EXPR_CHECK (T); \ const int __i = (I); \ if (GIMPLE_TUPLE_P (__t)) \ gcc_unreachable (); \ - if (__i < 0 || __i >= TREE_CODE_LENGTH (TREE_CODE (__t))) \ - tree_operand_check_failed (__i, TREE_CODE (__t), \ + if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t)) \ + tree_operand_check_failed (__i, __t, \ __FILE__, __LINE__, __FUNCTION__); \ &__t->exp.operands[__i]; })) #define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__ \ -(*({const tree __t = (T); \ +(*({__typeof (T) const __t = (T); \ const int __i = (I); \ if (TREE_CODE (__t) != CODE) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0);\ - if (__i < 0 || __i >= TREE_CODE_LENGTH (CODE)) \ - tree_operand_check_failed (__i, (CODE), \ + if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t)) \ + tree_operand_check_failed (__i, __t, \ __FILE__, __LINE__, __FUNCTION__); \ &__t->exp.operands[__i]; })) /* Special checks for GIMPLE_STMT_OPERANDs. */ #define GIMPLE_STMT_OPERAND_CHECK(T, I) __extension__ \ -(*({const tree __t = GIMPLE_STMT_CHECK (T); \ +(*({__typeof (T) const __t = GIMPLE_STMT_CHECK (T); \ const int __i = (I); \ - if (__i < 0 || __i >= TREE_CODE_LENGTH (TREE_CODE (__t))) \ - tree_operand_check_failed (__i, TREE_CODE (__t), \ + if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t)) \ + tree_operand_check_failed (__i, __t, \ __FILE__, __LINE__, __FUNCTION__); \ &__t->gstmt.operands[__i]; })) #define TREE_RTL_OPERAND_CHECK(T, CODE, I) __extension__ \ (*(rtx *) \ - ({const tree __t = (T); \ + ({__typeof (T) const __t = (T); \ const int __i = (I); \ if (TREE_CODE (__t) != (CODE)) \ tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0); \ - if (__i < 0 || __i >= TREE_CODE_LENGTH ((CODE))) \ - tree_operand_check_failed (__i, (CODE), \ + if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t)) \ + tree_operand_check_failed (__i, __t, \ __FILE__, __LINE__, __FUNCTION__); \ &__t->exp.operands[__i]; })) @@ -826,7 +852,7 @@ enum tree_node_structure_enum { are chained together. */ #define TREE_CHAIN(NODE) __extension__ \ -(*({const tree __t = (NODE); \ +(*({__typeof (NODE) const __t = (NODE); \ if (GIMPLE_TUPLE_P (__t)) \ gcc_unreachable (); \ &__t->common.chain; })) @@ -836,27 +862,27 @@ enum tree_node_structure_enum { In ARRAY_TYPE nodes, this is the type of the elements. In VECTOR_TYPE nodes, this is the type of the elements. */ #define TREE_TYPE(NODE) __extension__ \ -(*({const tree __t = (NODE); \ +(*({__typeof (NODE) const __t = (NODE); \ if (GIMPLE_TUPLE_P (__t)) \ gcc_unreachable (); \ &__t->common.type; })) -extern void tree_contains_struct_check_failed (const tree, +extern void tree_contains_struct_check_failed (const_tree, const enum tree_node_structure_enum, const char *, int, const char *) ATTRIBUTE_NORETURN; -extern void tree_check_failed (const tree, const char *, int, const char *, +extern void tree_check_failed (const_tree, const char *, int, const char *, ...) ATTRIBUTE_NORETURN; -extern void tree_not_check_failed (const tree, const char *, int, const char *, +extern void tree_not_check_failed (const_tree, const char *, int, const char *, ...) ATTRIBUTE_NORETURN; -extern void tree_class_check_failed (const tree, const enum tree_code_class, +extern void tree_class_check_failed (const_tree, const enum tree_code_class, const char *, int, const char *) ATTRIBUTE_NORETURN; -extern void tree_range_check_failed (const tree, const char *, int, +extern void tree_range_check_failed (const_tree, const char *, int, const char *, enum tree_code, enum tree_code); -extern void tree_not_class_check_failed (const tree, +extern void tree_not_class_check_failed (const_tree, const enum tree_code_class, const char *, int, const char *) ATTRIBUTE_NORETURN; @@ -866,16 +892,16 @@ extern void tree_vec_elt_check_failed (int, int, const char *, extern void phi_node_elt_check_failed (int, int, const char *, int, const char *) ATTRIBUTE_NORETURN; -extern void tree_operand_check_failed (int, enum tree_code, +extern void tree_operand_check_failed (int, const_tree, const char *, int, const char *) ATTRIBUTE_NORETURN; -extern void omp_clause_check_failed (const tree, const char *, int, +extern void omp_clause_check_failed (const_tree, const char *, int, const char *, enum omp_clause_code) ATTRIBUTE_NORETURN; -extern void omp_clause_operand_check_failed (int, tree, const char *, +extern void omp_clause_operand_check_failed (int, const_tree, const char *, int, const char *) ATTRIBUTE_NORETURN; -extern void omp_clause_range_check_failed (const tree, const char *, int, +extern void omp_clause_range_check_failed (const_tree, const char *, int, const char *, enum omp_clause_code, enum omp_clause_code) ATTRIBUTE_NORETURN; @@ -926,6 +952,7 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, #define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON) #define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant) #define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement) +#define VL_EXP_CHECK(T) TREE_CLASS_CHECK (T, tcc_vl_exp) #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) @@ -935,14 +962,15 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) #define NUMERICAL_TYPE_CHECK(T) \ - TREE_CHECK4 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE) + TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \ + FIXED_POINT_TYPE) /* Nonzero if NODE is a GIMPLE statement. */ #define GIMPLE_STMT_P(NODE) \ (TREE_CODE_CLASS (TREE_CODE ((NODE))) == tcc_gimple_stmt) /* Nonzero if NODE is a GIMPLE tuple. */ -#define GIMPLE_TUPLE_P(NODE) (GIMPLE_STMT_P (NODE)) +#define GIMPLE_TUPLE_P(NODE) (GIMPLE_STMT_P (NODE) || TREE_CODE (NODE) == PHI_NODE) /* A GIMPLE tuple that has a ``locus'' field. */ #define GIMPLE_TUPLE_HAS_LOCUS_P(NODE) GIMPLE_STMT_P ((NODE)) @@ -966,6 +994,11 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, used in hash tables which are saved to a PCH. */ #define TREE_HASH(NODE) ((size_t) (NODE) & 0777777) +/* The TREE_CHAIN but it is able to handle tuples. */ +#define GENERIC_NEXT(NODE) \ + (TREE_CODE (NODE) == PHI_NODE ? PHI_CHAIN (NODE) : \ + GIMPLE_STMT_P (NODE) ? NULL_TREE : TREE_CHAIN (NODE)) + /* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs that don't change the machine mode. */ @@ -988,7 +1021,9 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, && (TYPE_MODE (TREE_TYPE (EXP)) \ == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \ && (TYPE_UNSIGNED (TREE_TYPE (EXP)) \ - == TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \ + == TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \ + && (POINTER_TYPE_P (TREE_TYPE (EXP)) \ + == POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \ (EXP) = TREE_OPERAND (EXP, 0) /* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */ @@ -1018,6 +1053,20 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, || TREE_CODE (TYPE) == BOOLEAN_TYPE \ || TREE_CODE (TYPE) == INTEGER_TYPE) +/* Nonzero if TYPE represents a non-saturating fixed-point type. */ + +#define NON_SAT_FIXED_POINT_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE)) + +/* Nonzero if TYPE represents a saturating fixed-point type. */ + +#define SAT_FIXED_POINT_TYPE_P(TYPE) \ + (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE)) + +/* Nonzero if TYPE represents a fixed-point type. */ + +#define FIXED_POINT_TYPE_P(TYPE) (TREE_CODE (TYPE) == FIXED_POINT_TYPE) + /* Nonzero if TYPE represents a scalar floating-point type. */ #define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE) @@ -1126,6 +1175,9 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, #define CASE_HIGH_SEEN(NODE) \ (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag) +/* Used to mark a CALL_EXPR as not suitable for inlining. */ +#define CALL_CANNOT_INLINE_P(NODE) ((NODE)->base.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. In a decl node, warnings concerning the decl should be suppressed. This is used at @@ -1133,12 +1185,6 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, emitted. */ #define TREE_NO_WARNING(NODE) ((NODE)->base.nowarning_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) (CST_CHECK (NODE)->base.static_flag) - /* In an IDENTIFIER_NODE, this means that assemble_name was called with this string as an argument. */ #define TREE_SYMBOL_REFERENCED(NODE) \ @@ -1149,13 +1195,23 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, #define TYPE_REF_CAN_ALIAS_ALL(NODE) \ (PTR_OR_REF_CHECK (NODE)->base.static_flag) +/* In a MODIFY_EXPR, means that the store in the expression is nontemporal. */ +#define MOVE_NONTEMPORAL(NODE) \ + (GIMPLE_MODIFY_STMT_CHECK (NODE)->base.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. */ + there was an overflow in folding. */ #define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag) +/* ??? This is an obsolete synonym for TREE_OVERFLOW. */ +#define TREE_CONSTANT_OVERFLOW(NODE) TREE_OVERFLOW(NODE) + +/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */ + +#define TREE_OVERFLOW_P(EXPR) \ + (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR)) + /* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL, nonzero means name is to be accessible from outside this module. In an IDENTIFIER_NODE, nonzero means an external declaration @@ -1172,6 +1228,11 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, #define SAVE_EXPR_RESOLVED_P(NODE) \ (TREE_CHECK (NODE, SAVE_EXPR)->base.public_flag) +/* Set on a CALL_EXPR if this stdarg call should be passed the argument + pack. */ +#define CALL_EXPR_VA_ARG_PACK(NODE) \ + (CALL_EXPR_CHECK(NODE)->base.public_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 @@ -1239,9 +1300,6 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, /* In integral and pointer types, means an unsigned type. */ #define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.unsigned_flag) -#define TYPE_TRAP_SIGNED(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. This is interesting in an inline function, since it might not need @@ -1311,6 +1369,9 @@ extern void omp_clause_range_check_failed (const tree, const char *, int, any expression node. */ #define TREE_INVARIANT(NODE) ((NODE)->base.invariant_flag) +/* In fixed-point types, means a saturating type. */ +#define TYPE_SATURATING(NODE) ((NODE)->base.saturating_flag) + /* These flags are available for each language front end to use internally. */ #define TREE_LANG_FLAG_0(NODE) ((NODE)->base.lang_flag_0) #define TREE_LANG_FLAG_1(NODE) ((NODE)->base.lang_flag_1) @@ -1362,6 +1423,18 @@ struct tree_real_cst GTY(()) struct real_value * real_cst_ptr; }; +/* In a FIXED_CST node. */ +struct fixed_value; + +#define TREE_FIXED_CST_PTR(NODE) (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr) +#define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE)) + +struct tree_fixed_cst GTY(()) +{ + struct tree_common common; + struct fixed_value * fixed_cst_ptr; +}; + /* In a STRING_CST */ #define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length) #define TREE_STRING_POINTER(NODE) \ @@ -1502,8 +1575,16 @@ struct tree_constructor GTY(()) && integer_zerop (TREE_OPERAND (NODE, 0))) /* In ordinary expression nodes. */ +#define TREE_OPERAND_LENGTH(NODE) tree_operand_length (NODE) #define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I) -#define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity) + +/* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand + length. Its value includes the length operand itself; that is, + the minimum valid length is 1. + Note that we have to bypass the use of TREE_OPERAND to access + that field to avoid infinite recursion in expanding the macros. */ +#define VL_EXP_OPERAND_LENGTH(NODE) \ + ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0])) /* In gimple statements. */ #define GIMPLE_STMT_OPERAND(NODE, I) GIMPLE_STMT_OPERAND_CHECK (NODE, I) @@ -1521,8 +1602,8 @@ struct tree_constructor GTY(()) #define EXPR_HAS_LOCATION(NODE) expr_has_location ((NODE)) #define EXPR_LOCUS(NODE) expr_locus ((NODE)) #define SET_EXPR_LOCUS(NODE, FROM) set_expr_locus ((NODE), (FROM)) -#define EXPR_FILENAME(NODE) *(expr_filename ((NODE))) -#define EXPR_LINENO(NODE) *(expr_lineno ((NODE))) +#define EXPR_FILENAME(NODE) (expr_filename ((NODE))) +#define EXPR_LINENO(NODE) (expr_lineno ((NODE))) /* True if a tree is an expression or statement that can have a location. */ @@ -1610,6 +1691,12 @@ struct tree_constructor GTY(()) #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)) +/* CHANGE_DYNAMIC_TYPE_EXPR accessors. */ +#define CHANGE_DYNAMIC_TYPE_NEW_TYPE(NODE) \ + TREE_OPERAND (CHANGE_DYNAMIC_TYPE_EXPR_CHECK (NODE), 0) +#define CHANGE_DYNAMIC_TYPE_LOCATION(NODE) \ + TREE_OPERAND (CHANGE_DYNAMIC_TYPE_EXPR_CHECK (NODE), 1) + /* OBJ_TYPE_REF accessors. */ #define OBJ_TYPE_REF_EXPR(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0) #define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1) @@ -1619,6 +1706,23 @@ struct tree_constructor GTY(()) #define ASSERT_EXPR_VAR(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0) #define ASSERT_EXPR_COND(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1) +/* CALL_EXPR accessors. + */ +#define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1) +#define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2) +#define CALL_EXPR_ARGS(NODE) call_expr_arglist (NODE) +#define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3) +#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3) + +/* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE. + We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if + the argument count is zero when checking is enabled. Instead, do + the pointer arithmetic to advance past the 3 fixed operands in a + CALL_EXPR. That produces a valid pointer to just past the end of the + operand array, even if it's not valid to dereference it. */ +#define CALL_EXPR_ARGP(NODE) \ + (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3) + /* OpenMP directive and clause accessors. */ #define OMP_BODY(NODE) \ @@ -1640,6 +1744,7 @@ struct tree_constructor GTY(()) #define OMP_SECTIONS_BODY(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0) #define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1) +#define OMP_SECTIONS_CONTROL(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 2) #define OMP_SECTION_BODY(NODE) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0) @@ -1729,7 +1834,6 @@ struct tree_exp GTY(()) { struct tree_common common; source_locus locus; - int complexity; tree block; tree GTY ((special ("tree_exp"), desc ("TREE_CODE ((tree) &%0)"))) @@ -1836,7 +1940,7 @@ struct tree_ssa_name GTY(()) /* PHI_NODEs for each basic block are chained together in a single linked list. The head of the list is linked from the block annotation, and the link to the next PHI is in PHI_CHAIN. */ -#define PHI_CHAIN(NODE) TREE_CHAIN (PHI_NODE_CHECK (NODE)) +#define PHI_CHAIN(NODE) PHI_NODE_CHECK (NODE)->phi.chain #define PHI_NUM_ARGS(NODE) PHI_NODE_CHECK (NODE)->phi.num_args #define PHI_ARG_CAPACITY(NODE) PHI_NODE_CHECK (NODE)->phi.capacity @@ -1855,7 +1959,8 @@ struct phi_arg_d GTY(()) struct tree_phi_node GTY(()) { - struct tree_common common; + struct tree_base common; + tree chain; tree result; int num_args; int capacity; @@ -2005,7 +2110,30 @@ struct tree_block GTY(()) #define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant) #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant) #define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context) + +/* The "canonical" type for this type node, which can be used to + compare the type for equality with another type. If two types are + equal (based on the semantics of the language), then they will have + equivalent TYPE_CANONICAL entries. + + As a special case, if TYPE_CANONICAL is NULL_TREE, then it cannot + be used for comparison against other types. Instead, the type is + said to require structural equality checks, described in + TYPE_STRUCTURAL_EQUALITY_P. */ +#define TYPE_CANONICAL(NODE) (TYPE_CHECK (NODE)->type.canonical) +/* Indicates that the type node requires structural equality + checks. The compiler will need to look at the composition of the + type to determine whether it is equal to another type, rather than + just comparing canonical type pointers. For instance, we would need + to look at the return and parameter types of a FUNCTION_TYPE + node. */ +#define TYPE_STRUCTURAL_EQUALITY_P(NODE) (TYPE_CANONICAL (NODE) == NULL_TREE) +/* Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the + type node requires structural equality. */ +#define SET_TYPE_STRUCTURAL_EQUALITY(NODE) (TYPE_CANONICAL (NODE) = NULL_TREE) #define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific) +#define TYPE_IBIT(NODE) (GET_MODE_IBIT (TYPE_MODE (NODE))) +#define TYPE_FBIT(NODE) (GET_MODE_FBIT (TYPE_MODE (NODE))) /* 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 @@ -2194,7 +2322,7 @@ struct tree_type GTY(()) tree reference_to; union tree_type_symtab { int GTY ((tag ("0"))) address; - char * GTY ((tag ("1"))) pointer; + const char * GTY ((tag ("1"))) pointer; struct die_struct * GTY ((tag ("2"))) die; } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"), descbits ("2"))) symtab; @@ -2205,7 +2333,8 @@ struct tree_type GTY(()) tree main_variant; tree binfo; tree context; - HOST_WIDE_INT alias_set; + tree canonical; + alias_set_type alias_set; /* Points to a structure whose details depend on the language in use. */ struct lang_type *lang_specific; }; @@ -2422,10 +2551,18 @@ struct tree_decl_minimal GTY(()) struct tree_memory_tag GTY(()) { struct tree_decl_minimal common; + + bitmap GTY ((skip)) aliases; + + /* True if this tag has global scope. */ unsigned int is_global:1; + + /* True if this SFT is for a field in a nested structure. */ + unsigned int in_nested_struct : 1; }; #define MTAG_GLOBAL(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.is_global) +#define MTAG_ALIASES(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.aliases) struct tree_struct_field_tag GTY(()) { @@ -2440,10 +2577,18 @@ struct tree_struct_field_tag GTY(()) /* Size of the field. */ unsigned HOST_WIDE_INT size; + /* Alias set for a DECL_NONADDRESSABLE_P field. Otherwise -1. */ + alias_set_type alias_set; }; + #define SFT_PARENT_VAR(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.parent_var) #define SFT_OFFSET(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.offset) #define SFT_SIZE(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.size) +#define SFT_NONADDRESSABLE_P(NODE) \ + (STRUCT_FIELD_TAG_CHECK (NODE)->sft.alias_set != -1) +#define SFT_ALIAS_SET(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.alias_set) +#define SFT_IN_NESTED_STRUCT(NODE) \ + (STRUCT_FIELD_TAG_CHECK (NODE)->sft.common.in_nested_struct) /* Memory Partition Tags (MPTs) group memory symbols under one common name for the purposes of placing memory PHI nodes. */ @@ -2499,13 +2644,11 @@ struct tree_memory_partition_tag GTY(()) /* Likewise for the size in bytes. */ #define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit) /* Holds the alignment required for the datum, in bits. */ -#define DECL_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.u1.a.align) +#define DECL_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align) /* The alignment of NODE, in bytes. */ #define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT) -/* For FIELD_DECLs, off_align holds the number of low-order bits of - DECL_FIELD_OFFSET which are known to be always zero. - DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET - has. */ +/* Set if the alignment of this DECL has been set by the user, for + example with an 'aligned' attribute. */ #define DECL_USER_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.user_align) /* Holds the machine mode corresponding to the declaration of a variable or field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a @@ -2516,7 +2659,8 @@ struct tree_memory_partition_tag GTY(()) operation it is. Note, however, that this field is overloaded, with DECL_BUILT_IN_CLASS as the discriminant, so the latter must always be checked before any access to the former. */ -#define DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_common.u1.f) +#define DECL_FUNCTION_CODE(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code) #define DECL_DEBUG_EXPR_IS_FROM(NODE) \ (DECL_COMMON_CHECK (NODE)->decl_common.debug_expr_is_from) @@ -2544,13 +2688,6 @@ struct tree_memory_partition_tag GTY(()) a C99 "extern inline" function. */ #define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_2) -/* In a VAR_DECL for a RECORD_TYPE, sets number for non-init_priority - initializations. */ -#define DEFAULT_INIT_PRIORITY 65535 -#define MAX_INIT_PRIORITY 65535 -#define MAX_RESERVED_INIT_PRIORITY 100 - - /* Nonzero in a ..._DECL means this variable is ref'd from a nested function. For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes. @@ -2607,11 +2744,10 @@ struct tree_memory_partition_tag GTY(()) #define DECL_GIMPLE_REG_P(DECL) \ DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag -/* This is true if DECL is call clobbered in the current function. - The result of this flag should always be the same as - bitmap_bit_p (call_clobbered_vars, DECL_UID (decl)). */ -#define DECL_CALL_CLOBBERED(DECL) \ - DECL_COMMON_CHECK (DECL)->decl_common.call_clobbered_flag +/* For a DECL with pointer type, this is set if Type Based Alias + Analysis should not be applied to this DECL. */ +#define DECL_NO_TBAA_P(DECL) \ + DECL_COMMON_CHECK (DECL)->decl_common.no_tbaa_flag struct tree_decl_common GTY(()) { @@ -2653,29 +2789,21 @@ struct tree_decl_common GTY(()) /* Logically, these two would go in a theoretical base shared by var and parm decl. */ unsigned gimple_reg_flag : 1; - unsigned call_clobbered_flag : 1; - - union tree_decl_u1 { - /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is - DECL_FUNCTION_CODE. */ - enum built_in_function f; - /* In a FUNCTION_DECL for which DECL_BUILT_IN does not hold, this - is used by language-dependent code. */ - HOST_WIDE_INT i; - /* DECL_ALIGN and DECL_OFFSET_ALIGN. (These are not used for - FUNCTION_DECLs). */ - struct tree_decl_u1_a { - unsigned int align : 24; - unsigned int off_align : 8; - } a; - } GTY ((skip)) u1; + /* In a DECL with pointer type, set if no TBAA should be done. */ + unsigned no_tbaa_flag : 1; + /* Padding so that 'align' can be on a 32-bit boundary. */ + unsigned decl_common_unused : 2; + + unsigned int align : 24; + /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */ + unsigned int off_align : 8; tree size_unit; tree initial; tree attributes; tree abstract_origin; - HOST_WIDE_INT pointer_alias_set; + alias_set_type pointer_alias_set; /* Points to a structure whose details depend on the language in use. */ struct lang_decl *lang_specific; }; @@ -2753,11 +2881,11 @@ struct tree_decl_with_rtl GTY(()) DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET has. */ #define DECL_OFFSET_ALIGN(NODE) \ - (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl_common.u1.a.off_align) + (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl_common.off_align) /* Specify that DECL_ALIGN(NODE) is a multiple of X. */ #define SET_DECL_OFFSET_ALIGN(NODE, X) \ - (FIELD_DECL_CHECK (NODE)->decl_common.u1.a.off_align = exact_log2 ((X) & -(X))) + (FIELD_DECL_CHECK (NODE)->decl_common.off_align = exact_log2 ((X) & -(X))) /* 1 if the alignment for this type was requested by "aligned" attribute, 0 if it is the default for this type. */ @@ -2803,14 +2931,6 @@ struct tree_field_decl GTY(()) struct tree_label_decl GTY(()) { struct tree_decl_with_rtl common; - /* Java's verifier has some need to store information about labels, - and was using fields that no longer exist on labels. - Once the verifier doesn't need these anymore, they should be removed. */ - tree java_field_1; - tree java_field_2; - tree java_field_3; - unsigned int java_field_4; - }; struct tree_result_decl GTY(()) @@ -2889,6 +3009,26 @@ extern void decl_restrict_base_insert (tree, tree); something which is DECL_COMDAT. */ #define DECL_COMDAT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag) +/* A replaceable function is one which may be replaced at link-time + with an entirely different definition, provided that the + replacement has the same type. For example, functions declared + with __attribute__((weak)) on most systems are replaceable. + + COMDAT functions are not replaceable, since all definitions of the + function must be equivalent. It is important that COMDAT functions + not be treated as replaceable so that use of C++ template + instantiations is not penalized. + + For example, DECL_REPLACEABLE is used to determine whether or not a + function (including a template instantiation) which is not + explicitly declared "inline" can be inlined. If the function is + DECL_REPLACEABLE then it is not safe to do the inlining, since the + implementation chosen at link-time may be different. However, a + function that is not DECL_REPLACEABLE can be inlined, since all + versions of the function will be functionally identical. */ +#define DECL_REPLACEABLE_P(NODE) \ + (!DECL_COMDAT (NODE) && !targetm.binds_local_p (NODE)) + /* The name of the object as the assembler will see it (but before any translations made by ASM_OUTPUT_LABELREF). Often this is the same as DECL_NAME. It is an IDENTIFIER_NODE. */ @@ -2997,20 +3137,45 @@ extern void decl_debug_expr_insert (tree, tree); #define SET_DECL_DEBUG_EXPR(NODE, VAL) \ (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL)) +/* An initializationp priority. */ +typedef unsigned short priority_type; -extern unsigned short decl_init_priority_lookup (tree); -extern void decl_init_priority_insert (tree, unsigned short); - -/* In a non-local VAR_DECL with static storage duration, this is the - initialization priority. If this value is zero, the NODE will be - initialized at the DEFAULT_INIT_PRIORITY. Only used by C++ FE*/ +extern priority_type decl_init_priority_lookup (tree); +extern priority_type decl_fini_priority_lookup (tree); +extern void decl_init_priority_insert (tree, priority_type); +extern void decl_fini_priority_insert (tree, priority_type); +/* In a non-local VAR_DECL with static storage duration, true if the + variable has an initialization priority. If false, the variable + will be initialized at the DEFAULT_INIT_PRIORITY. */ #define DECL_HAS_INIT_PRIORITY_P(NODE) \ (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p) + +/* For a VAR_DECL or FUNCTION_DECL the initialization priority of + NODE. */ #define DECL_INIT_PRIORITY(NODE) \ - (decl_init_priority_lookup (VAR_DECL_CHECK (NODE))) + (decl_init_priority_lookup (NODE)) +/* Set the initialization priority for NODE to VAL. */ #define SET_DECL_INIT_PRIORITY(NODE, VAL) \ - (decl_init_priority_insert (VAR_DECL_CHECK (NODE), VAL)) + (decl_init_priority_insert (NODE, VAL)) + +/* For a FUNCTION_DECL the finalization priority of NODE. */ +#define DECL_FINI_PRIORITY(NODE) \ + (decl_fini_priority_lookup (NODE)) +/* Set the finalization priority for NODE to VAL. */ +#define SET_DECL_FINI_PRIORITY(NODE, VAL) \ + (decl_fini_priority_insert (NODE, VAL)) + +/* The initialization priority for entities for which no explicit + initialization priority has been specified. */ +#define DEFAULT_INIT_PRIORITY 65535 + +/* The maximum allowed initialization priority. */ +#define MAX_INIT_PRIORITY 65535 + +/* The largest priority value reserved for use by system runtime + libraries. */ +#define MAX_RESERVED_INIT_PRIORITY 100 /* In a VAR_DECL, the model to use if the data should be allocated from thread-local storage. */ @@ -3124,6 +3289,13 @@ struct tree_decl_non_common GTY(()) #define DECL_DECLARED_INLINE_P(NODE) \ (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag) +/* Nonzero in a FUNCTION_DECL that should be always inlined by the inliner + disregarding size and cost heuristics. This is equivalent to using + the always_inline attribute without the required diagnostics if the + function cannot be inlined. */ +#define DECL_DISREGARD_INLINE_LIMITS(NODE) \ + (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits) + /* 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)->function_decl.f) @@ -3150,23 +3322,33 @@ struct tree_function_decl GTY(()) { struct tree_decl_non_common common; + struct function *f; + + /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is + DECL_FUNCTION_CODE. Otherwise unused. + ??? The bitfield needs to be able to hold all target function + codes as well. */ + ENUM_BITFIELD(built_in_function) function_code : 11; + ENUM_BITFIELD(built_in_class) built_in_class : 2; + unsigned static_ctor_flag : 1; unsigned static_dtor_flag : 1; unsigned uninlinable : 1; + unsigned possibly_inlined : 1; unsigned novops_flag : 1; unsigned returns_twice_flag : 1; unsigned malloc_flag : 1; unsigned pure_flag : 1; - unsigned declared_inline_flag : 1; unsigned regdecl_flag : 1; unsigned inline_flag : 1; + unsigned no_instrument_function_entry_exit : 1; unsigned no_limit_stack : 1; - ENUM_BITFIELD(built_in_class) built_in_class : 2; + unsigned disregard_inline_limits : 1; - struct function *f; + /* 5 bits left */ }; /* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */ @@ -3217,9 +3399,6 @@ struct tree_statement_list #define VALUE_HANDLE_EXPR_SET(NODE) \ (VALUE_HANDLE_CHECK (NODE)->value_handle.expr_set) -#define VALUE_HANDLE_VUSES(NODE) \ - (VALUE_HANDLE_CHECK (NODE)->value_handle.vuses) - /* Defined and used in tree-ssa-pre.c. */ struct tree_value_handle GTY(()) @@ -3233,9 +3412,6 @@ struct tree_value_handle GTY(()) conveniently dense form starting at 0, so that we can make bitmaps of value handles. */ unsigned int id; - - /* Set of virtual uses represented by this handle. */ - VEC (tree, gc) *vuses; }; /* Define the overall contents of a tree node. @@ -3249,6 +3425,7 @@ union tree_node GTY ((ptr_alias (union lang_tree_node), struct tree_common GTY ((tag ("TS_COMMON"))) common; struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst; struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst; + struct tree_fixed_cst GTY ((tag ("TS_FIXED_CST"))) fixed_cst; struct tree_vector GTY ((tag ("TS_VECTOR"))) vector; struct tree_string GTY ((tag ("TS_STRING"))) string; struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex; @@ -3360,6 +3537,75 @@ enum tree_index TI_MAIN_IDENTIFIER, + TI_SAT_SFRACT_TYPE, + TI_SAT_FRACT_TYPE, + TI_SAT_LFRACT_TYPE, + TI_SAT_LLFRACT_TYPE, + TI_SAT_USFRACT_TYPE, + TI_SAT_UFRACT_TYPE, + TI_SAT_ULFRACT_TYPE, + TI_SAT_ULLFRACT_TYPE, + TI_SFRACT_TYPE, + TI_FRACT_TYPE, + TI_LFRACT_TYPE, + TI_LLFRACT_TYPE, + TI_USFRACT_TYPE, + TI_UFRACT_TYPE, + TI_ULFRACT_TYPE, + TI_ULLFRACT_TYPE, + TI_SAT_SACCUM_TYPE, + TI_SAT_ACCUM_TYPE, + TI_SAT_LACCUM_TYPE, + TI_SAT_LLACCUM_TYPE, + TI_SAT_USACCUM_TYPE, + TI_SAT_UACCUM_TYPE, + TI_SAT_ULACCUM_TYPE, + TI_SAT_ULLACCUM_TYPE, + TI_SACCUM_TYPE, + TI_ACCUM_TYPE, + TI_LACCUM_TYPE, + TI_LLACCUM_TYPE, + TI_USACCUM_TYPE, + TI_UACCUM_TYPE, + TI_ULACCUM_TYPE, + TI_ULLACCUM_TYPE, + TI_QQ_TYPE, + TI_HQ_TYPE, + TI_SQ_TYPE, + TI_DQ_TYPE, + TI_TQ_TYPE, + TI_UQQ_TYPE, + TI_UHQ_TYPE, + TI_USQ_TYPE, + TI_UDQ_TYPE, + TI_UTQ_TYPE, + TI_SAT_QQ_TYPE, + TI_SAT_HQ_TYPE, + TI_SAT_SQ_TYPE, + TI_SAT_DQ_TYPE, + TI_SAT_TQ_TYPE, + TI_SAT_UQQ_TYPE, + TI_SAT_UHQ_TYPE, + TI_SAT_USQ_TYPE, + TI_SAT_UDQ_TYPE, + TI_SAT_UTQ_TYPE, + TI_HA_TYPE, + TI_SA_TYPE, + TI_DA_TYPE, + TI_TA_TYPE, + TI_UHA_TYPE, + TI_USA_TYPE, + TI_UDA_TYPE, + TI_UTA_TYPE, + TI_SAT_HA_TYPE, + TI_SAT_SA_TYPE, + TI_SAT_DA_TYPE, + TI_SAT_TA_TYPE, + TI_SAT_UHA_TYPE, + TI_SAT_USA_TYPE, + TI_SAT_UDA_TYPE, + TI_SAT_UTA_TYPE, + TI_MAX }; @@ -3439,6 +3685,84 @@ extern GTY(()) tree global_trees[TI_MAX]; #define dfloat64_ptr_type_node global_trees[TI_DFLOAT64_PTR_TYPE] #define dfloat128_ptr_type_node global_trees[TI_DFLOAT128_PTR_TYPE] +/* The fixed-point types. */ +#define sat_short_fract_type_node global_trees[TI_SAT_SFRACT_TYPE] +#define sat_fract_type_node global_trees[TI_SAT_FRACT_TYPE] +#define sat_long_fract_type_node global_trees[TI_SAT_LFRACT_TYPE] +#define sat_long_long_fract_type_node global_trees[TI_SAT_LLFRACT_TYPE] +#define sat_unsigned_short_fract_type_node \ + global_trees[TI_SAT_USFRACT_TYPE] +#define sat_unsigned_fract_type_node global_trees[TI_SAT_UFRACT_TYPE] +#define sat_unsigned_long_fract_type_node \ + global_trees[TI_SAT_ULFRACT_TYPE] +#define sat_unsigned_long_long_fract_type_node \ + global_trees[TI_SAT_ULLFRACT_TYPE] +#define short_fract_type_node global_trees[TI_SFRACT_TYPE] +#define fract_type_node global_trees[TI_FRACT_TYPE] +#define long_fract_type_node global_trees[TI_LFRACT_TYPE] +#define long_long_fract_type_node global_trees[TI_LLFRACT_TYPE] +#define unsigned_short_fract_type_node global_trees[TI_USFRACT_TYPE] +#define unsigned_fract_type_node global_trees[TI_UFRACT_TYPE] +#define unsigned_long_fract_type_node global_trees[TI_ULFRACT_TYPE] +#define unsigned_long_long_fract_type_node \ + global_trees[TI_ULLFRACT_TYPE] +#define sat_short_accum_type_node global_trees[TI_SAT_SACCUM_TYPE] +#define sat_accum_type_node global_trees[TI_SAT_ACCUM_TYPE] +#define sat_long_accum_type_node global_trees[TI_SAT_LACCUM_TYPE] +#define sat_long_long_accum_type_node global_trees[TI_SAT_LLACCUM_TYPE] +#define sat_unsigned_short_accum_type_node \ + global_trees[TI_SAT_USACCUM_TYPE] +#define sat_unsigned_accum_type_node global_trees[TI_SAT_UACCUM_TYPE] +#define sat_unsigned_long_accum_type_node \ + global_trees[TI_SAT_ULACCUM_TYPE] +#define sat_unsigned_long_long_accum_type_node \ + global_trees[TI_SAT_ULLACCUM_TYPE] +#define short_accum_type_node global_trees[TI_SACCUM_TYPE] +#define accum_type_node global_trees[TI_ACCUM_TYPE] +#define long_accum_type_node global_trees[TI_LACCUM_TYPE] +#define long_long_accum_type_node global_trees[TI_LLACCUM_TYPE] +#define unsigned_short_accum_type_node global_trees[TI_USACCUM_TYPE] +#define unsigned_accum_type_node global_trees[TI_UACCUM_TYPE] +#define unsigned_long_accum_type_node global_trees[TI_ULACCUM_TYPE] +#define unsigned_long_long_accum_type_node \ + global_trees[TI_ULLACCUM_TYPE] +#define qq_type_node global_trees[TI_QQ_TYPE] +#define hq_type_node global_trees[TI_HQ_TYPE] +#define sq_type_node global_trees[TI_SQ_TYPE] +#define dq_type_node global_trees[TI_DQ_TYPE] +#define tq_type_node global_trees[TI_TQ_TYPE] +#define uqq_type_node global_trees[TI_UQQ_TYPE] +#define uhq_type_node global_trees[TI_UHQ_TYPE] +#define usq_type_node global_trees[TI_USQ_TYPE] +#define udq_type_node global_trees[TI_UDQ_TYPE] +#define utq_type_node global_trees[TI_UTQ_TYPE] +#define sat_qq_type_node global_trees[TI_SAT_QQ_TYPE] +#define sat_hq_type_node global_trees[TI_SAT_HQ_TYPE] +#define sat_sq_type_node global_trees[TI_SAT_SQ_TYPE] +#define sat_dq_type_node global_trees[TI_SAT_DQ_TYPE] +#define sat_tq_type_node global_trees[TI_SAT_TQ_TYPE] +#define sat_uqq_type_node global_trees[TI_SAT_UQQ_TYPE] +#define sat_uhq_type_node global_trees[TI_SAT_UHQ_TYPE] +#define sat_usq_type_node global_trees[TI_SAT_USQ_TYPE] +#define sat_udq_type_node global_trees[TI_SAT_UDQ_TYPE] +#define sat_utq_type_node global_trees[TI_SAT_UTQ_TYPE] +#define ha_type_node global_trees[TI_HA_TYPE] +#define sa_type_node global_trees[TI_SA_TYPE] +#define da_type_node global_trees[TI_DA_TYPE] +#define ta_type_node global_trees[TI_TA_TYPE] +#define uha_type_node global_trees[TI_UHA_TYPE] +#define usa_type_node global_trees[TI_USA_TYPE] +#define uda_type_node global_trees[TI_UDA_TYPE] +#define uta_type_node global_trees[TI_UTA_TYPE] +#define sat_ha_type_node global_trees[TI_SAT_HA_TYPE] +#define sat_sa_type_node global_trees[TI_SAT_SA_TYPE] +#define sat_da_type_node global_trees[TI_SAT_DA_TYPE] +#define sat_ta_type_node global_trees[TI_SAT_TA_TYPE] +#define sat_uha_type_node global_trees[TI_SAT_UHA_TYPE] +#define sat_usa_type_node global_trees[TI_SAT_USA_TYPE] +#define sat_uda_type_node global_trees[TI_SAT_UDA_TYPE] +#define sat_uta_type_node global_trees[TI_SAT_UTA_TYPE] + /* The node that should be placed at the end of a parameter list to indicate that the function does not take a variable number of arguments. The TREE_VALUE will be void_type_node and there will be @@ -3527,7 +3851,7 @@ extern bool decl_assembler_name_equal (tree decl, tree asmname); /* Compute the number of bytes occupied by 'node'. This routine only looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */ -extern size_t tree_size (tree); +extern size_t tree_size (const_tree); /* Compute the number of bytes occupied by a tree with code CODE. This function cannot be used for TREE_VEC or PHI_NODE codes, which are of @@ -3608,6 +3932,7 @@ extern tree maybe_get_identifier (const char *); /* Construct various types of nodes. */ extern tree build_nt (enum tree_code, ...); +extern tree build_nt_call_list (tree, tree); extern tree build0_stat (enum tree_code, tree MEM_STAT_DECL); #define build0(c,t) build0_stat (c,t MEM_STAT_INFO) @@ -3615,8 +3940,6 @@ 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 build2_gimple_stat (enum tree_code, tree, tree MEM_STAT_DECL); -#define build2_gimple(c,t1,t2) build2_gimple_stat (c,t1,t2 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, @@ -3630,16 +3953,22 @@ extern tree build7_stat (enum tree_code, tree, tree, tree, tree, tree, #define build7(c,t1,t2,t3,t4,t5,t6,t7,t8) \ build7_stat (c,t1,t2,t3,t4,t5,t6,t7,t8 MEM_STAT_INFO) +extern tree build_gimple_modify_stmt_stat (tree, tree MEM_STAT_DECL); +#define build_gimple_modify_stmt(t1,t2) \ + build_gimple_modify_stmt_stat (t1,t2 MEM_STAT_INFO) + extern tree build_int_cst (tree, HOST_WIDE_INT); extern tree build_int_cst_type (tree, HOST_WIDE_INT); extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT); extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT); +extern tree build_int_cst_wide_type (tree, + unsigned HOST_WIDE_INT, HOST_WIDE_INT); extern tree build_vector (tree, tree); extern tree build_vector_from_ctor (tree, VEC(constructor_elt,gc) *); extern tree build_constructor (tree, VEC(constructor_elt,gc) *); extern tree build_constructor_single (tree, tree, tree); extern tree build_constructor_from_list (tree, tree); -extern tree build_real_from_int_cst (tree, tree); +extern tree build_real_from_int_cst (tree, const_tree); extern tree build_complex (tree, tree, tree); extern tree build_one_cst (tree); extern tree build_string (int, const char *); @@ -3656,10 +3985,19 @@ extern void annotate_with_locus (tree, location_t); extern tree build_empty_stmt (void); extern tree build_omp_clause (enum omp_clause_code); +extern tree build_vl_exp_stat (enum tree_code, int MEM_STAT_DECL); +#define build_vl_exp(c,n) build_vl_exp_stat (c,n MEM_STAT_INFO) + +extern tree build_call_list (tree, tree, tree); +extern tree build_call_nary (tree, tree, int, ...); +extern tree build_call_valist (tree, tree, int, va_list); +extern tree build_call_array (tree, tree, int, tree*); + /* Construct various nodes representing data types. */ extern tree make_signed_type (int); extern tree make_unsigned_type (int); +extern tree signed_or_unsigned_type_for (int, tree); extern tree signed_type_for (tree); extern tree unsigned_type_for (tree); extern void initialize_sizetypes (bool); @@ -3682,26 +4020,58 @@ extern tree build_method_type (tree, tree); extern tree build_offset_type (tree, tree); extern tree build_complex_type (tree); extern tree build_resx (int); -extern tree array_type_nelts (tree); +extern tree array_type_nelts (const_tree); extern bool in_array_bounds_p (tree); extern bool range_in_array_bounds_p (tree); extern tree value_member (tree, tree); -extern tree purpose_member (tree, tree); - -extern int attribute_list_equal (tree, tree); -extern int attribute_list_contained (tree, tree); -extern int tree_int_cst_equal (tree, tree); -extern int tree_int_cst_lt (tree, tree); -extern int tree_int_cst_compare (tree, tree); -extern int host_integerp (tree, int); -extern HOST_WIDE_INT tree_low_cst (tree, int); -extern int tree_int_cst_msb (tree); -extern int tree_int_cst_sgn (tree); -extern int tree_int_cst_sign_bit (tree); +extern tree purpose_member (const_tree, tree); + +extern int attribute_list_equal (const_tree, const_tree); +extern int attribute_list_contained (const_tree, const_tree); +extern int tree_int_cst_equal (const_tree, const_tree); +extern int tree_int_cst_lt (const_tree, const_tree); +extern int tree_int_cst_compare (const_tree, const_tree); +extern int host_integerp (const_tree, int); +extern HOST_WIDE_INT tree_low_cst (const_tree, int); +extern int tree_int_cst_msb (const_tree); +extern int tree_int_cst_sgn (const_tree); +extern int tree_int_cst_sign_bit (const_tree); extern bool tree_expr_nonnegative_p (tree); -extern bool may_negate_without_overflow_p (tree); -extern tree get_inner_array_type (tree); +extern bool tree_expr_nonnegative_warnv_p (tree, bool *); +extern bool may_negate_without_overflow_p (const_tree); +extern tree get_inner_array_type (const_tree); + +/* Construct various nodes representing fract or accum data types. */ + +extern tree make_fract_type (int, int, int); +extern tree make_accum_type (int, int, int); + +#define make_signed_fract_type(P) make_fract_type (P, 0, 0) +#define make_unsigned_fract_type(P) make_fract_type (P, 1, 0) +#define make_sat_signed_fract_type(P) make_fract_type (P, 0, 1) +#define make_sat_unsigned_fract_type(P) make_fract_type (P, 1, 1) +#define make_signed_accum_type(P) make_accum_type (P, 0, 0) +#define make_unsigned_accum_type(P) make_accum_type (P, 1, 0) +#define make_sat_signed_accum_type(P) make_accum_type (P, 0, 1) +#define make_sat_unsigned_accum_type(P) make_accum_type (P, 1, 1) + +#define make_or_reuse_signed_fract_type(P) \ + make_or_reuse_fract_type (P, 0, 0) +#define make_or_reuse_unsigned_fract_type(P) \ + make_or_reuse_fract_type (P, 1, 0) +#define make_or_reuse_sat_signed_fract_type(P) \ + make_or_reuse_fract_type (P, 0, 1) +#define make_or_reuse_sat_unsigned_fract_type(P) \ + make_or_reuse_fract_type (P, 1, 1) +#define make_or_reuse_signed_accum_type(P) \ + make_or_reuse_accum_type (P, 0, 0) +#define make_or_reuse_unsigned_accum_type(P) \ + make_or_reuse_accum_type (P, 1, 0) +#define make_or_reuse_sat_signed_accum_type(P) \ + make_or_reuse_accum_type (P, 0, 1) +#define make_or_reuse_sat_unsigned_accum_type(P) \ + make_or_reuse_accum_type (P, 1, 1) /* From expmed.c. Since rtl.h is included after tree.h, we can't put the prototype here. Rtl.h does declare the prototype if @@ -3796,7 +4166,7 @@ extern tree merge_type_attributes (tree, tree); /* Given a tree node and a string, return nonzero if the tree node is a valid attribute name for the string. */ -extern int is_attribute_p (const char *, tree); +extern int is_attribute_p (const char *, const_tree); /* Given an attribute name and a list of attributes, return the list element of the attribute or NULL_TREE if not found. */ @@ -3824,7 +4194,7 @@ extern tree handle_dll_attribute (tree *, tree, tree, int, bool *); /* Check whether CAND is suitable to be returned from get_qualified_type (BASE, TYPE_QUALS). */ -extern bool check_qualified_type (tree, tree, int); +extern bool check_qualified_type (const_tree, const_tree, int); /* Return a version of the TYPE, qualified as indicated by the TYPE_QUALS, if one exists. If no qualified version exists yet, @@ -3939,24 +4309,24 @@ extern void relayout_decl (tree); The value is BLKmode if no other mode is found. This is like mode_for_size, but is passed a tree. */ -extern enum machine_mode mode_for_size_tree (tree, enum mode_class, int); +extern enum machine_mode mode_for_size_tree (const_tree, enum mode_class, int); /* Return an expr equal to X but certainly not valid as an lvalue. */ extern tree non_lvalue (tree); extern tree convert (tree, tree); -extern unsigned int expr_align (tree); +extern unsigned int expr_align (const_tree); extern tree expr_first (tree); extern tree expr_last (tree); extern tree expr_only (tree); -extern tree size_in_bytes (tree); -extern HOST_WIDE_INT int_size_in_bytes (tree); -extern HOST_WIDE_INT max_int_size_in_bytes (tree); -extern tree bit_position (tree); -extern HOST_WIDE_INT int_bit_position (tree); -extern tree byte_position (tree); -extern HOST_WIDE_INT int_byte_position (tree); +extern tree size_in_bytes (const_tree); +extern HOST_WIDE_INT int_size_in_bytes (const_tree); +extern HOST_WIDE_INT max_int_size_in_bytes (const_tree); +extern tree bit_position (const_tree); +extern HOST_WIDE_INT int_bit_position (const_tree); +extern tree byte_position (const_tree); +extern HOST_WIDE_INT int_byte_position (const_tree); /* Define data structures, macros, and functions for handling sizes and the various types used to represent sizes. */ @@ -4025,16 +4395,16 @@ extern tree nreverse (tree); /* Returns the length of a chain of nodes (number of chain pointers to follow before reaching a null pointer). */ -extern int list_length (tree); +extern int list_length (const_tree); /* Returns the number of FIELD_DECLs in a type. */ -extern int fields_length (tree); +extern int fields_length (const_tree); /* Given an initializer INIT, return TRUE if INIT is zero or some aggregate of zeros. Otherwise return FALSE. */ -extern bool initializer_zerop (tree); +extern bool initializer_zerop (const_tree); /* Examine CTOR to discover: * how many scalar fields are set to nonzero values, @@ -4047,37 +4417,41 @@ extern bool initializer_zerop (tree); Return whether or not CTOR is a valid static constant initializer, the same as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0". */ -extern bool categorize_ctor_elements (tree, HOST_WIDE_INT *, HOST_WIDE_INT *, +extern bool categorize_ctor_elements (const_tree, HOST_WIDE_INT *, HOST_WIDE_INT *, bool *); -extern HOST_WIDE_INT count_type_elements (tree, bool); +extern HOST_WIDE_INT count_type_elements (const_tree, bool); /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0. */ -extern int integer_zerop (tree); +extern int integer_zerop (const_tree); /* integer_onep (tree x) is nonzero if X is an integer constant of value 1. */ -extern int integer_onep (tree); +extern int integer_onep (const_tree); /* integer_all_onesp (tree x) is nonzero if X is an integer constant all of whose significant bits are 1. */ -extern int integer_all_onesp (tree); +extern int integer_all_onesp (const_tree); /* integer_pow2p (tree x) is nonzero is X is an integer constant with exactly one bit 1. */ -extern int integer_pow2p (tree); +extern int integer_pow2p (const_tree); /* integer_nonzerop (tree x) is nonzero if X is an integer constant with a nonzero value. */ -extern int integer_nonzerop (tree); +extern int integer_nonzerop (const_tree); -extern bool zero_p (tree); -extern bool cst_and_fits_in_hwi (tree); -extern tree num_ending_zeros (tree); +extern bool cst_and_fits_in_hwi (const_tree); +extern tree num_ending_zeros (const_tree); + +/* fixed_zerop (tree x) is nonzero if X is a fixed-point constant of + value 0. */ + +extern int fixed_zerop (const_tree); /* staticp (tree x) is nonzero if X is a reference to data allocated at a fixed address in memory. Returns the outermost data. */ @@ -4097,7 +4471,7 @@ extern tree skip_simple_arithmetic (tree); /* Return which tree structure is used by T. */ -enum tree_node_structure_enum tree_node_structure (tree); +enum tree_node_structure_enum tree_node_structure (const_tree); /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size or offset that depends on a field within a record. @@ -4105,7 +4479,7 @@ enum tree_node_structure_enum tree_node_structure (tree); Note that we only allow such expressions within simple arithmetic or a COND_EXPR. */ -extern bool contains_placeholder_p (tree); +extern bool contains_placeholder_p (const_tree); /* This macro calls the above function but short-circuits the common case of a constant to save time. Also check for null. */ @@ -4186,9 +4560,15 @@ extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *, tree *, enum machine_mode *, int *, int *, bool); +/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF, + look for whether EXP or any nested component-refs within EXP is marked + as PACKED. */ + +extern bool contains_packed_reference (const_tree exp); + /* Return 1 if T is an expression that get_inner_reference handles. */ -extern int handled_component_p (tree); +extern int handled_component_p (const_tree); /* Return a tree of sizetype representing the size, in bytes, of the element of EXP, an ARRAY_REF. */ @@ -4213,18 +4593,18 @@ extern tree component_ref_field_offset (tree); /* Given a DECL or TYPE, return the scope in which it was declared, or NUL_TREE if there is no containing scope. */ -extern tree get_containing_scope (tree); +extern tree get_containing_scope (const_tree); /* Return the FUNCTION_DECL which provides this _DECL with its context, or zero if none. */ -extern tree decl_function_context (tree); +extern tree decl_function_context (const_tree); /* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides this _DECL with its context, or zero if none. */ -extern tree decl_type_context (tree); +extern tree decl_type_context (const_tree); /* Return 1 if EXPR is the real constant zero. */ -extern int real_zerop (tree); +extern int real_zerop (const_tree); /* Declare commonly used variables for tree structure. */ @@ -4240,31 +4620,97 @@ extern GTY(()) tree current_function_decl; /* Nonzero means a FUNC_BEGIN label was emitted. */ extern GTY(()) const char * current_function_func_begin_label; +/* Iterator for going through the function arguments. */ +typedef struct { + tree fntype; /* function type declaration */ + tree next; /* TREE_LIST pointing to the next argument */ +} function_args_iterator; + +/* Initialize the iterator I with arguments from function FNDECL */ + +static inline void +function_args_iter_init (function_args_iterator *i, tree fntype) +{ + i->fntype = fntype; + i->next = TYPE_ARG_TYPES (fntype); +} + +/* Return a pointer that holds the next argument if there are more arguments to + handle, otherwise return NULL. */ + +static inline tree * +function_args_iter_cond_ptr (function_args_iterator *i) +{ + return (i->next) ? &TREE_VALUE (i->next) : NULL; +} + +/* Return the next argument if there are more arguments to handle, otherwise + return NULL. */ + +static inline tree +function_args_iter_cond (function_args_iterator *i) +{ + return (i->next) ? TREE_VALUE (i->next) : NULL_TREE; +} + +/* Advance to the next argument. */ +static inline void +function_args_iter_next (function_args_iterator *i) +{ + gcc_assert (i->next != NULL_TREE); + i->next = TREE_CHAIN (i->next); +} + +/* Loop over all function arguments of FNTYPE. In each iteration, PTR is set + to point to the next tree element. ITER is an instance of + function_args_iterator used to iterate the arguments. */ +#define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER) \ + for (function_args_iter_init (&(ITER), (FNTYPE)); \ + (PTR = function_args_iter_cond_ptr (&(ITER))) != NULL; \ + function_args_iter_next (&(ITER))) + +/* Loop over all function arguments of FNTYPE. In each iteration, TREE is set + to the next tree element. ITER is an instance of function_args_iterator + used to iterate the arguments. */ +#define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER) \ + for (function_args_iter_init (&(ITER), (FNTYPE)); \ + (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE; \ + function_args_iter_next (&(ITER))) + + + /* In tree.c */ extern unsigned crc32_string (unsigned, const char *); extern void clean_symbol_name (char *); extern tree get_file_function_name (const char *); -extern tree get_callee_fndecl (tree); +extern tree get_callee_fndecl (const_tree); extern void change_decl_assembler_name (tree, tree); -extern int type_num_arguments (tree); +extern int type_num_arguments (const_tree); extern bool associative_tree_code (enum tree_code); extern bool commutative_tree_code (enum tree_code); extern tree upper_bound_in_type (tree, tree); extern tree lower_bound_in_type (tree, tree); -extern int operand_equal_for_phi_arg_p (tree, tree); +extern int operand_equal_for_phi_arg_p (const_tree, const_tree); extern bool empty_body_p (tree); +extern tree call_expr_arg (tree, int); +extern tree *call_expr_argp (tree, int); +extern tree call_expr_arglist (tree); +extern bool stdarg_p (tree); +extern bool prototype_p (tree); +extern int function_args_count (tree); +extern bool auto_var_in_fn_p (const_tree, const_tree); /* In stmt.c */ extern void expand_expr_stmt (tree); -extern int warn_if_unused_value (tree, location_t); +extern int warn_if_unused_value (const_tree, location_t); extern void expand_label (tree); extern void expand_goto (tree); extern rtx expand_stack_save (void); extern void expand_stack_restore (tree); extern void expand_return (tree); -extern int is_body_block (tree); +extern int is_body_block (const_tree); /* In tree-eh.c */ extern void using_eh_for_cleanups (void); @@ -4275,6 +4721,10 @@ extern void using_eh_for_cleanups (void); otherwise. */ extern int folding_initializer; +/* Convert between trees and native memory representation. */ +extern int native_encode_expr (const_tree, unsigned char *, int); +extern tree native_interpret_expr (tree, const unsigned char *, int); + /* Fold constants as much as possible in an expression. Returns the simplified expression. Acts only on the top level of the expression; @@ -4294,14 +4744,25 @@ extern tree fold_build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DE extern tree fold_build1_initializer (enum tree_code, tree, tree); extern tree fold_build2_initializer (enum tree_code, tree, tree, tree); extern tree fold_build3_initializer (enum tree_code, tree, tree, tree, tree); +extern tree fold_build_call_array (tree, tree, int, tree *); +extern tree fold_build_call_array_initializer (tree, tree, int, tree *); +extern bool fold_convertible_p (const_tree, const_tree); extern tree fold_convert (tree, tree); extern tree fold_single_bit_test (enum tree_code, tree, tree, tree); extern tree fold_ignored_result (tree); extern tree fold_abs_const (tree, tree); extern tree fold_indirect_ref_1 (tree, tree); +extern void fold_defer_overflow_warnings (void); +extern void fold_undefer_overflow_warnings (bool, const_tree, int); +extern void fold_undefer_and_ignore_overflow_warnings (void); +extern bool fold_deferring_overflow_warnings_p (void); +extern tree maybe_fold_offset_to_reference (tree, tree, tree); -extern tree force_fit_type (tree, int, bool, bool); +extern tree force_fit_type_double (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT, + int, bool); +extern int fit_double_type (unsigned HOST_WIDE_INT, HOST_WIDE_INT, + unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, const_tree); extern int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT, unsigned HOST_WIDE_INT, HOST_WIDE_INT, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, @@ -4341,8 +4802,8 @@ enum operand_equal_flag OEP_PURE_SAME = 2 }; -extern int operand_equal_p (tree, tree, unsigned int); - +extern int operand_equal_p (const_tree, const_tree, unsigned int); +extern int multiple_of_p (tree, const_tree, const_tree); extern tree omit_one_operand (tree, tree, tree); extern tree omit_two_operands (tree, tree, tree, tree); extern tree invert_truthvalue (tree); @@ -4350,7 +4811,7 @@ extern tree fold_truth_not_expr (tree); extern tree fold_unary_to_constant (enum tree_code, tree, tree); extern tree 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); +extern tree int_const_binop (enum tree_code, const_tree, const_tree, int); extern tree build_fold_addr_expr (tree); extern tree fold_build_cleanup_point_expr (tree type, tree expr); extern tree fold_strip_sign_ops (tree); @@ -4360,7 +4821,7 @@ extern tree fold_indirect_ref (tree); extern tree constant_boolean_node (int, tree); extern tree build_low_bits_mask (tree, unsigned); -extern bool tree_swap_operands_p (tree, tree, bool); +extern bool tree_swap_operands_p (const_tree, const_tree, bool); extern void swap_tree_operands (tree, tree *, tree *); extern enum tree_code swap_tree_comparison (enum tree_code); @@ -4368,28 +4829,32 @@ extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *); extern enum tree_code invert_tree_comparison (enum tree_code, bool); extern bool tree_expr_nonzero_p (tree); +extern bool tree_expr_nonzero_warnv_p (tree, bool *); /* In builtins.c */ -extern tree fold_builtin (tree, tree, bool); -extern tree fold_builtin_fputs (tree, bool, bool, tree); -extern tree fold_builtin_strcpy (tree, tree, tree); -extern tree fold_builtin_strncpy (tree, tree, tree); -extern tree fold_builtin_memory_chk (tree, tree, tree, bool, +extern tree fold_call_expr (tree, bool); +extern tree fold_builtin_fputs (tree, tree, bool, bool, tree); +extern tree fold_builtin_strcpy (tree, tree, tree, tree); +extern tree fold_builtin_strncpy (tree, tree, tree, tree, tree); +extern tree fold_builtin_memory_chk (tree, tree, tree, tree, tree, tree, bool, enum built_in_function); -extern tree fold_builtin_stxcpy_chk (tree, tree, tree, bool, +extern tree fold_builtin_stxcpy_chk (tree, tree, tree, tree, tree, bool, enum built_in_function); -extern tree fold_builtin_strncpy_chk (tree, tree); +extern tree fold_builtin_strncpy_chk (tree, tree, tree, tree, tree); extern tree fold_builtin_snprintf_chk (tree, tree, enum built_in_function); -extern bool fold_builtin_next_arg (tree); -extern enum built_in_function builtin_mathfn_code (tree); +extern bool fold_builtin_next_arg (tree, bool); +extern enum built_in_function builtin_mathfn_code (const_tree); extern tree build_function_call_expr (tree, tree); +extern tree fold_builtin_call_array (tree, tree, int, tree *); +extern void debug_fold_checksum (const_tree); +extern tree build_call_expr (tree, int, ...); extern tree mathfn_built_in (tree, enum built_in_function fn); extern tree strip_float_extensions (tree); extern tree c_strlen (tree, int); extern tree std_gimplify_va_arg_expr (tree, tree, tree *, tree *); extern tree build_va_arg_indirect_ref (tree); extern tree build_string_literal (int, const char *); -extern int validate_arglist (tree, ...); +extern bool validate_arglist (const_tree, ...); extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode); extern int get_pointer_alignment (tree, unsigned int); @@ -4398,73 +4863,68 @@ extern tree strip_float_extensions (tree); /* In alias.c */ 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 alias_set_type get_alias_set (tree); +extern int alias_sets_conflict_p (alias_set_type, alias_set_type); +extern int alias_sets_must_conflict_p (alias_set_type, alias_set_type); extern int objects_must_conflict_p (tree, tree); /* In tree.c */ -extern int really_constant_p (tree); -extern int int_fits_type_p (tree, tree); +extern int really_constant_p (const_tree); +extern int int_fits_type_p (const_tree, const_tree); +extern void get_type_static_bounds (const_tree, mpz_t, mpz_t); extern bool variably_modified_type_p (tree, tree); -extern int tree_log2 (tree); -extern int tree_floor_log2 (tree); -extern int simple_cst_equal (tree, tree); -extern hashval_t iterative_hash_expr (tree, hashval_t); -extern int compare_tree_int (tree, unsigned HOST_WIDE_INT); -extern int type_list_equal (tree, tree); -extern int chain_member (tree, tree); +extern int tree_log2 (const_tree); +extern int tree_floor_log2 (const_tree); +extern int simple_cst_equal (const_tree, const_tree); +extern hashval_t iterative_hash_expr (const_tree, hashval_t); +extern int compare_tree_int (const_tree, unsigned HOST_WIDE_INT); +extern int type_list_equal (const_tree, const_tree); +extern int chain_member (const_tree, const_tree); extern tree type_hash_lookup (unsigned int, tree); extern void type_hash_add (unsigned int, tree); -extern int simple_cst_list_equal (tree, tree); +extern int simple_cst_list_equal (const_tree, const_tree); extern void dump_tree_statistics (void); extern void expand_function_end (void); extern void expand_function_start (tree); extern void stack_protect_prologue (void); extern void stack_protect_epilogue (void); extern void recompute_tree_invariant_for_addr_expr (tree); -extern bool is_global_var (tree t); -extern bool needs_to_live_in_memory (tree); +extern bool needs_to_live_in_memory (const_tree); extern tree reconstruct_complex_type (tree, tree); -extern int real_onep (tree); -extern int real_twop (tree); -extern int real_minus_onep (tree); +extern int real_onep (const_tree); +extern int real_twop (const_tree); +extern int real_minus_onep (const_tree); extern void init_ttree (void); extern void build_common_tree_nodes (bool, bool); extern void build_common_tree_nodes_2 (int); extern void build_common_builtin_nodes (void); extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int); extern tree build_range_type (tree, tree, tree); -extern HOST_WIDE_INT int_cst_value (tree); -extern tree tree_fold_gcd (tree, tree); +extern HOST_WIDE_INT int_cst_value (const_tree); extern tree build_addr (tree, tree); -extern bool fields_compatible_p (tree, tree); +extern bool fields_compatible_p (const_tree, const_tree); extern tree find_compatible_field (tree, tree); -extern location_t expr_location (tree); +extern location_t expr_location (const_tree); extern void set_expr_location (tree, location_t); -extern bool expr_has_location (tree); -extern -#ifdef USE_MAPPED_LOCATION -source_location * -#else -source_locus -#endif -expr_locus (tree); -extern void set_expr_locus (tree, +extern bool expr_has_location (const_tree); + #ifdef USE_MAPPED_LOCATION - source_location *loc +extern source_locus *expr_locus (const_tree); +extern void set_expr_locus (tree, source_location *); #else - source_locus loc +extern source_locus expr_locus (const_tree); +extern void set_expr_locus (tree, source_locus loc); #endif - ); -extern const char **expr_filename (tree); -extern int *expr_lineno (tree); +extern const char *expr_filename (const_tree); +extern int expr_lineno (const_tree); + extern tree *tree_block (tree); extern tree *generic_tree_operand (tree, int); extern tree *generic_tree_type (tree); +extern location_t *block_nonartificial_location (tree); /* In function.c */ extern void expand_main_function (void); @@ -4472,16 +4932,16 @@ extern void init_dummy_function_start (void); extern void expand_dummy_function_end (void); extern unsigned int init_function_for_compilation (void); extern void allocate_struct_function (tree); +extern void push_struct_function (tree fndecl); extern void init_function_start (tree); -extern bool use_register_for_decl (tree); -extern void setjmp_vars_warning (tree); -extern void setjmp_args_warning (void); +extern bool use_register_for_decl (const_tree); +extern void generate_setjmp_warnings (void); extern void init_temp_slots (void); extern void free_temp_slots (void); extern void pop_temp_slots (void); extern void push_temp_slots (void); extern void preserve_temp_slots (rtx); -extern int aggregate_value_p (tree, tree); +extern int aggregate_value_p (const_tree, const_tree); extern void push_function_context (void); extern void pop_function_context (void); extern void push_function_context_to (tree); @@ -4490,15 +4950,15 @@ extern tree gimplify_parameters (void); /* In print-rtl.c */ #ifdef BUFSIZ -extern void print_rtl (FILE *, rtx); +extern void print_rtl (FILE *, const_rtx); #endif /* In print-tree.c */ extern void debug_tree (tree); #ifdef BUFSIZ -extern void dump_addr (FILE*, const char *, void *); +extern void dump_addr (FILE*, const char *, const void *); extern void print_node (FILE *, const char *, tree, int); -extern void print_node_brief (FILE *, const char *, tree, int); +extern void print_node_brief (FILE *, const char *, const_tree, int); extern void indent_to (FILE *, int); #endif @@ -4509,9 +4969,6 @@ extern bool debug_find_tree (tree, tree); extern tree unsave_expr_now (tree); extern tree build_duplicate_type (tree); -/* In emit-rtl.c */ -extern rtx emit_line_note (location_t); - /* In calls.c */ /* Nonzero if this is a call to a function whose return value depends @@ -4542,16 +4999,18 @@ extern rtx emit_line_note (location_t); it does not necessarily fit ECF_CONST). */ #define ECF_NOVOPS 1024 -extern int flags_from_decl_or_type (tree); -extern int call_expr_flags (tree); +extern int flags_from_decl_or_type (const_tree); +extern int call_expr_flags (const_tree); -extern int setjmp_call_p (tree); -extern bool alloca_call_p (tree); -extern bool must_pass_in_stack_var_size (enum machine_mode, tree); -extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, tree); +extern int setjmp_call_p (const_tree); +extern bool alloca_call_p (const_tree); +extern bool must_pass_in_stack_var_size (enum machine_mode, const_tree); +extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, const_tree); /* In attribs.c. */ +extern const struct attribute_spec *lookup_attribute_spec (tree); + /* Process the attributes listed in ATTRIBUTES and install them in *NODE, which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL, it should be modified in place; if a TYPE, a copy should be created @@ -4584,6 +5043,7 @@ extern void set_user_assembler_name (tree, const char *); extern void process_pending_assemble_externals (void); extern void finish_aliases_1 (void); extern void finish_aliases_2 (void); +extern tree emutls_decl (tree); /* In stmt.c */ extern void expand_computed_goto (tree); @@ -4604,7 +5064,7 @@ extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *); /* In gimplify.c. */ extern tree create_artificial_label (void); extern void gimplify_function_tree (tree); -extern const char *get_name (tree); +extern const char *get_name (const_tree); extern tree unshare_expr (tree); extern void sort_case_labels (tree); @@ -4652,8 +5112,20 @@ struct pointer_set_t; /* The type of a callback function for walking over tree structure. */ typedef tree (*walk_tree_fn) (tree *, int *, void *); -extern tree walk_tree (tree*, walk_tree_fn, void*, struct pointer_set_t*); -extern tree walk_tree_without_duplicates (tree*, walk_tree_fn, void*); + +/* The type of a callback function that represents a custom walk_tree. */ + +typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *), + void *, struct pointer_set_t*); + +extern tree walk_tree_1 (tree*, walk_tree_fn, void*, struct pointer_set_t*, + walk_tree_lh); +extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*, + walk_tree_lh); +#define walk_tree(a,b,c,d) \ + walk_tree_1 (a, b, c, d, NULL) +#define walk_tree_without_duplicates(a,b,c) \ + walk_tree_without_duplicates_1 (a, b, c, NULL) /* Assign the RTX to declaration. */ @@ -4701,24 +5173,62 @@ extern tree get_base_address (tree t); /* In tree-vectorizer.c. */ extern void vect_set_verbosity_level (const char *); +/* In tree.c. */ + +struct tree_map_base GTY(()) +{ + tree from; +}; + +extern int tree_map_base_eq (const void *, const void *); +extern unsigned int tree_map_base_hash (const void *); +extern int tree_map_base_marked_p (const void *); + +/* Map from a tree to another tree. */ + struct tree_map GTY(()) { + struct tree_map_base base; unsigned int hash; - tree from; tree to; }; +#define tree_map_eq tree_map_base_eq extern unsigned int tree_map_hash (const void *); -extern int tree_map_marked_p (const void *); -extern int tree_map_eq (const void *, const void *); +#define tree_map_marked_p tree_map_base_marked_p + +/* Map from a tree to an int. */ + +struct tree_int_map GTY(()) +{ + struct tree_map_base base; + unsigned int to; +}; + +#define tree_int_map_eq tree_map_base_eq +#define tree_int_map_hash tree_map_base_hash +#define tree_int_map_marked_p tree_map_base_marked_p + +/* Map from a tree to initialization/finalization priorities. */ + +struct tree_priority_map GTY(()) +{ + struct tree_map_base base; + priority_type init; + priority_type fini; +}; + +#define tree_priority_map_eq tree_map_base_eq +#define tree_priority_map_hash tree_map_base_hash +#define tree_priority_map_marked_p tree_map_base_marked_p /* In tree-ssa-address.c. */ extern tree tree_mem_ref_addr (tree, tree); extern void copy_mem_ref_info (tree, tree); /* In tree-vrp.c */ -extern bool ssa_name_nonzero_p (tree); -extern bool ssa_name_nonnegative_p (tree); +extern bool ssa_name_nonzero_p (const_tree); +extern bool ssa_name_nonnegative_p (const_tree); /* In tree-object-size.c. */ extern void init_object_sizes (void); @@ -4726,6 +5236,125 @@ extern void fini_object_sizes (void); extern unsigned HOST_WIDE_INT compute_builtin_object_size (tree, int); /* In expr.c. */ -extern unsigned HOST_WIDE_INT highest_pow2_factor (tree); +extern unsigned HOST_WIDE_INT highest_pow2_factor (const_tree); + +/* In tree-inline.c. */ + +void init_inline_once (void); + +/* Compute the number of operands in an expression node NODE. For + tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself, + otherwise it is looked up from the node's code. */ +static inline int +tree_operand_length (const_tree node) +{ + if (VL_EXP_CLASS_P (node)) + return VL_EXP_OPERAND_LENGTH (node); + else + return TREE_CODE_LENGTH (TREE_CODE (node)); +} + +/* Abstract iterators for CALL_EXPRs. These static inline definitions + have to go towards the end of tree.h so that union tree_node is fully + defined by this point. */ + +/* Structure containing iterator state. */ +typedef struct call_expr_arg_iterator_d GTY (()) +{ + tree t; /* the call_expr */ + int n; /* argument count */ + int i; /* next argument index */ +} call_expr_arg_iterator; + +typedef struct const_call_expr_arg_iterator_d GTY (()) +{ + const_tree t; /* the call_expr */ + int n; /* argument count */ + int i; /* next argument index */ +} const_call_expr_arg_iterator; + +/* Initialize the abstract argument list iterator object ITER with the + arguments from CALL_EXPR node EXP. */ +static inline void +init_call_expr_arg_iterator (tree exp, call_expr_arg_iterator *iter) +{ + iter->t = exp; + iter->n = call_expr_nargs (exp); + iter->i = 0; +} + +static inline void +init_const_call_expr_arg_iterator (const_tree exp, const_call_expr_arg_iterator *iter) +{ + iter->t = exp; + iter->n = call_expr_nargs (exp); + iter->i = 0; +} + +/* Return the next argument from abstract argument list iterator object ITER, + and advance its state. Return NULL_TREE if there are no more arguments. */ +static inline tree +next_call_expr_arg (call_expr_arg_iterator *iter) +{ + tree result; + if (iter->i >= iter->n) + return NULL_TREE; + result = CALL_EXPR_ARG (iter->t, iter->i); + iter->i++; + return result; +} + +static inline const_tree +next_const_call_expr_arg (const_call_expr_arg_iterator *iter) +{ + const_tree result; + if (iter->i >= iter->n) + return NULL_TREE; + result = CALL_EXPR_ARG (iter->t, iter->i); + iter->i++; + return result; +} + +/* Initialize the abstract argument list iterator object ITER, then advance + past and return the first argument. Useful in for expressions, e.g. + for (arg = first_call_expr_arg (exp, &iter); arg; + arg = next_call_expr_arg (&iter)) */ +static inline tree +first_call_expr_arg (tree exp, call_expr_arg_iterator *iter) +{ + init_call_expr_arg_iterator (exp, iter); + return next_call_expr_arg (iter); +} + +static inline const_tree +first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter) +{ + init_const_call_expr_arg_iterator (exp, iter); + return next_const_call_expr_arg (iter); +} + +/* Test whether there are more arguments in abstract argument list iterator + ITER, without changing its state. */ +static inline bool +more_call_expr_args_p (const call_expr_arg_iterator *iter) +{ + return (iter->i < iter->n); +} + +static inline bool +more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter) +{ + return (iter->i < iter->n); +} + +/* Iterate through each argument ARG of CALL_EXPR CALL, using variable ITER + (of type call_expr_arg_iterator) to hold the iteration state. */ +#define FOR_EACH_CALL_EXPR_ARG(arg, iter, call) \ + for ((arg) = first_call_expr_arg ((call), &(iter)); (arg); \ + (arg) = next_call_expr_arg (&(iter))) + +#define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call) \ + for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg); \ + (arg) = next_const_call_expr_arg (&(iter))) #endif /* GCC_TREE_H */