CbC/CbC_gcc: gcc/tree.h comparison

comparison gcc/tree.h @ 57:326d9e06c2e3

modify c-parser.c

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 15 Feb 2010 00:54:17 +0900
parents	9de9dad105d4 77e2b8dfacca
children	1b10fe6932e1

comparison

equal deleted inserted replaced

-:f62c169bbc24
+:326d9e06c2e3
 /* Nonzero if CODE represents a declaration.  */
 #define DECL_P(CODE)\
 (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration)
-/* Nonzero if CODE represents a memory tag.  */
-#define MTAG_P(CODE) \
-(TREE_CODE (CODE) == NAME_MEMORY_TAG		\
-|| TREE_CODE (CODE) == SYMBOL_MEMORY_TAG	\
-|| TREE_CODE (CODE) == MEMORY_PARTITION_TAG)
 /* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL.  */
 #define VAR_OR_FUNCTION_DECL_P(DECL)\
 (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)
 /* A vectors of trees.  */
 DEF_VEC_P(tree);
 DEF_VEC_ALLOC_P(tree,gc);
 DEF_VEC_ALLOC_P(tree,heap);
+/* We have to be able to tell cgraph about the needed-ness of the target
+of an alias.  This requires that the decl have been defined.  Aliases
+that precede their definition have to be queued for later processing.  */
+typedef struct GTY(()) alias_pair
+{
+tree decl;
+tree target;
+} alias_pair;
+/* Define gc'd vector type.  */
+DEF_VEC_O(alias_pair);
+DEF_VEC_ALLOC_O(alias_pair,gc);
+extern GTY(()) VEC(alias_pair,gc) * alias_pairs;
 /* Classify which part of the compiler has defined a given builtin function.
 Note that we assume below that this is no more than two bits.  */
 enum built_in_class
 /* Every kind of tree node starts with this structure,
 so all nodes have these fields.
 See the accessor macros, defined below, for documentation of the
 fields.  */
-union tree_ann_d;
+struct GTY(()) tree_base {
-struct tree_base GTY(())
-{
 ENUM_BITFIELD(tree_code) code : 16;
 unsigned side_effects_flag : 1;
 unsigned constant_flag : 1;
 unsigned addressable_flag : 1;
 unsigned public_flag : 1;
 unsigned private_flag : 1;
 unsigned protected_flag : 1;
 unsigned deprecated_flag : 1;
 unsigned saturating_flag : 1;
 unsigned default_def_flag : 1;
 unsigned lang_flag_0 : 1;
 unsigned lang_flag_1 : 1;
 unsigned lang_flag_2 : 1;
 unsigned lang_flag_3 : 1;
 unsigned lang_flag_4 : 1;
 unsigned lang_flag_5 : 1;
 unsigned lang_flag_6 : 1;
 unsigned visited : 1;
+unsigned packed_flag : 1;
-unsigned spare : 23;
+unsigned user_align : 1;
-union tree_ann_d *ann;
+unsigned spare : 13;
-};
+/* This field is only used with type nodes; the only reason it is present
-struct tree_common GTY(())
+in tree_base instead of tree_type is to save space.  The size of the
-{
+field must be large enough to hold addr_space_t values.  */
+unsigned address_space : 8;
+};
+struct GTY(()) tree_common {
 struct tree_base base;
 tree chain;
 tree type;
 };
 TRY_CATCH_EXPR
 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
 MOVE_NONTEMPORAL in
 MODIFY_EXPR
 TREE_PRIVATE in
 all decls
 CALL_EXPR_RETURN_SLOT_OPT in
 CALL_EXPR
-DECL_BY_REFERENCE in
-PARM_DECL, RESULT_DECL
 OMP_SECTION_LAST in
 OMP_SECTION
 OMP_PARALLEL_COMBINED in
 deprecated_flag:
 TREE_DEPRECATED in
 all decls
+	   all types
 IDENTIFIER_TRANSPARENT_ALIAS in
 IDENTIFIER_NODE
 STMT_IN_SSA_EDGE_WORKLIST in
 TREE_NO_WARNING in
 all expressions
 all decls
 default_def_flag:
+TYPE_VECTOR_OPAQUE in
+	   VECTOR_TYPE
 SSA_NAME_IS_DEFAULT_DEF in
 SSA_NAME
 */
 #include "tree-check.h"
 #define TYPE_CHECK(T)		TREE_CLASS_CHECK (T, tcc_type)
 #define DECL_MINIMAL_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
-#define TREE_MEMORY_TAG_CHECK(T)       CONTAINS_STRUCT_CHECK (T, TS_MEMORY_TAG)
 #define DECL_COMMON_CHECK(T)    CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
 #define DECL_WRTL_CHECK(T)      CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
 #define DECL_WITH_VIS_CHECK(T)  CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
 #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 CASE_CONVERT						\
 case NOP_EXPR:						\
 case CONVERT_EXPR
-/* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs
+/* Given an expression as a tree, strip any conversion that generates
-that don't change the machine mode.  */
+no instruction.  Accepts both tree and const_tree arguments since
+we are not modifying the tree itself.  */
-#define STRIP_NOPS(EXP)						\
-while ((CONVERT_EXPR_P (EXP)					\
+#define STRIP_NOPS(EXP) \
-	  || TREE_CODE (EXP) == NON_LVALUE_EXPR)		\
+(EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP))
-	 && TREE_OPERAND (EXP, 0) != error_mark_node		\
-	 && (TYPE_MODE (TREE_TYPE (EXP))			\
-	     == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
-(EXP) = TREE_OPERAND (EXP, 0)
 /* Like STRIP_NOPS, but don't let the signedness change either.  */
 #define STRIP_SIGN_NOPS(EXP) \
-while ((CONVERT_EXPR_P (EXP)					\
+(EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP))
-	  || TREE_CODE (EXP) == NON_LVALUE_EXPR)		\
-	 && TREE_OPERAND (EXP, 0) != error_mark_node		\
-	 && (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)))) \
-	 && (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.  */
 #define STRIP_TYPE_NOPS(EXP) \
 while ((CONVERT_EXPR_P (EXP)					\
 (EXP) = TREE_OPERAND (EXP, 0)
 /* Remove unnecessary type conversions according to
 tree_ssa_useless_type_conversion.  */
-#define STRIP_USELESS_TYPE_CONVERSION(EXP)				\
+#define STRIP_USELESS_TYPE_CONVERSION(EXP) \
-while (tree_ssa_useless_type_conversion (EXP))			\
+(EXP) = tree_ssa_strip_useless_type_conversions (EXP)
-	EXP = TREE_OPERAND (EXP, 0)
 /* Nonzero if TYPE represents an integral type.  Note that we do not
 include COMPLEX types here.  Keep these checks in ascending code
 order.  */
 /* Nonzero if TYPE represents a decimal floating-point type.  */
 #define DECIMAL_FLOAT_TYPE_P(TYPE)		\
 (SCALAR_FLOAT_TYPE_P (TYPE)			\
 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))
+/* Nonzero if TYPE is a record or union type.  */
+#define RECORD_OR_UNION_TYPE_P(TYPE)		\
+(TREE_CODE (TYPE) == RECORD_TYPE		\
+|| TREE_CODE (TYPE) == UNION_TYPE		\
+|| TREE_CODE (TYPE) == QUAL_UNION_TYPE)
 /* Nonzero if TYPE represents an aggregate (multi-component) type.
 Keep these checks in ascending code order.  */
 #define AGGREGATE_TYPE_P(TYPE) \
-(TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \
+(TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE))
-|| TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE)
 /* Nonzero if TYPE represents a pointer or reference type.
 (It should be renamed to INDIRECT_TYPE_P.)  Keep these checks in
 ascending code order.  */
 CASE_LOW operand has been processed.  */
 #define CASE_LOW_SEEN(NODE) \
 (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
 #define PREDICT_EXPR_OUTCOME(NODE) \
-(PREDICT_EXPR_CHECK(NODE)->base.addressable_flag)
+((enum prediction) (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag))
+#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \
+(PREDICT_EXPR_CHECK(NODE)->base.addressable_flag = (int) OUTCOME)
 #define PREDICT_EXPR_PREDICTOR(NODE) \
 ((enum br_predictor)tree_low_cst (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0), 0))
 /* In a VAR_DECL, nonzero means allocate static storage.
 In a FUNCTION_DECL, nonzero if function has been defined.
 /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
 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))
 I.e. that the access will not trap, provided that the access to
 the base to the array will not trap.  */
 #define TREE_THIS_NOTRAP(NODE) ((NODE)->base.nothrow_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.
 Nonzero in a FUNCTION_DECL means this function should be treated
 as "const" function (can only read its arguments).  */
 #define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag)
 /* Value of expression is constant.  Always on in all ..._CST nodes.  May
 /* Nonzero in a VAR_DECL or STRING_CST 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
 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.
+if the debugging info for the type has been written.
 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)->base.asm_written_flag)
 /* In a CALL_EXPR, means that it's safe to use the target of the call
 expansion as the return slot for a call that returns in memory.  */
 #define CALL_EXPR_RETURN_SLOT_OPT(NODE) \
 (CALL_EXPR_CHECK (NODE)->base.private_flag)
-/* In a RESULT_DECL or PARM_DECL, means that it is passed by invisible
+/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
-reference (and the TREE_TYPE is a pointer to the true type).  */
+passed by invisible reference (and the TREE_TYPE is a pointer to the true
-#define DECL_BY_REFERENCE(NODE) (DECL_COMMON_CHECK (NODE)->base.private_flag)
+type).  */
+#define DECL_BY_REFERENCE(NODE) \
+(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \
+		RESULT_DECL)->decl_common.decl_by_reference_flag)
+/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that this decl
+can be used as restricted tag to disambiguate against other restrict
+pointers.  Used by fortran to capture something like non-addressability
+(which it isn't really because the middle-end does take addresses of
+such variables).  */
+#define DECL_RESTRICTED_P(NODE) \
+(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \
+		RESULT_DECL)->decl_common.decl_restricted_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) (CALL_EXPR_CHECK (NODE)->base.protected_flag)
 < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))		\
 || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A)		\
 	== (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))	\
 && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
-struct tree_int_cst GTY(())
+struct GTY(()) tree_int_cst {
-{
 struct tree_common common;
 double_int int_cst;
 };
 /* In a REAL_CST node.  struct real_value is an opaque entity, with
 struct real_value;
 #define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
 #define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
-struct tree_real_cst GTY(())
+struct GTY(()) tree_real_cst {
-{
 struct tree_common common;
 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 GTY(()) tree_fixed_cst {
-{
 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) \
 ((const char *)(STRING_CST_CHECK (NODE)->string.str))
-struct tree_string GTY(())
+struct GTY(()) tree_string {
-{
 struct tree_common common;
 int length;
 char str[1];
 };
 /* In a COMPLEX_CST node.  */
 #define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
 #define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
-struct tree_complex GTY(())
+struct GTY(()) tree_complex {
-{
 struct tree_common common;
 tree real;
 tree imag;
 };
 /* In a VECTOR_CST node.  */
 #define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements)
-struct tree_vector GTY(())
+struct GTY(()) tree_vector {
-{
 struct tree_common common;
 tree elements;
 };
 #include "symtab.h"
 #define HT_IDENT_TO_GCC_IDENT(NODE) \
 ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
 #define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
-struct tree_identifier GTY(())
+struct GTY(()) tree_identifier {
-{
 struct tree_common common;
 struct ht_identifier id;
 };
 /* In a TREE_LIST node.  */
 #define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
 #define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
-struct tree_list GTY(())
+struct GTY(()) tree_list {
-{
 struct tree_common common;
 tree purpose;
 tree value;
 };
 #define TREE_VEC_END(NODE) \
 ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))
 #define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
-struct tree_vec GTY(())
+struct GTY(()) tree_vec {
-{
 struct tree_common common;
 int length;
 tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
 };
 constructor_elt *_ce___ = VEC_safe_push (constructor_elt, gc, V, NULL); \
 _ce___->index = INDEX; \
 _ce___->value = VALUE; \
 } while (0)
+/* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
+constructor output purposes.  */
+#define CONSTRUCTOR_BITFIELD_P(NODE) \
+(DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) && DECL_MODE (NODE) != BLKmode)
 /* A single element of a CONSTRUCTOR. VALUE holds the actual value of the
 element. INDEX can optionally design the position of VALUE: in arrays,
 it is the index where VALUE has to be placed; in structures, it is the
 FIELD_DECL of the member.  */
-typedef struct constructor_elt_d GTY(())
+typedef struct GTY(()) constructor_elt_d {
-{
 tree index;
 tree value;
 } constructor_elt;
 DEF_VEC_O(constructor_elt);
 DEF_VEC_ALLOC_O(constructor_elt,gc);
-struct tree_constructor GTY(())
+struct GTY(()) tree_constructor {
-{
 struct tree_common common;
 VEC(constructor_elt,gc) *elts;
 };
 /* Define fields and accessors for some nodes that represent expressions.  */
 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]))
+/* Nonzero if is_gimple_debug() may possibly hold.  */
+#define MAY_HAVE_DEBUG_STMTS    (flag_var_tracking_assignments)
 /* In a LOOP_EXPR node.  */
 #define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
 /* 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_LOCATION(NODE) (EXPR_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
 #define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS)
 #define EXPR_HAS_LOCATION(NODE) (EXPR_LOCATION (NODE) != UNKNOWN_LOCATION)
-#define EXPR_LOCUS(NODE) (EXPR_P (NODE) \
-			  ? CONST_CAST (source_location *, &(NODE)->exp.locus) \
-			  : (source_location *) NULL)
-#define SET_EXPR_LOCUS(NODE, FROM) set_expr_locus ((NODE), (FROM))
 #define EXPR_FILENAME(NODE) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)
 #define EXPR_LINENO(NODE) LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)
 /* True if a tree is an expression or statement that can have a
 location.  */
-#define CAN_HAVE_LOCATION_P(NODE) (EXPR_P (NODE))
+#define CAN_HAVE_LOCATION_P(NODE) ((NODE) && EXPR_P (NODE))
 extern void protected_set_expr_location (tree, location_t);
 /* In a TARGET_EXPR node.  */
 #define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
 /* DECL_EXPR accessor. This gives access to the DECL associated with
 the given declaration statement.  */
 #define DECL_EXPR_DECL(NODE)    TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)
 #define EXIT_EXPR_COND(NODE)	     TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
+/* COMPOUND_LITERAL_EXPR accessors.  */
+#define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE)		\
+TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)
+#define COMPOUND_LITERAL_EXPR_DECL(NODE)			\
+DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE))
 /* 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 (SWITCH_EXPR_CHECK (NODE), 0)
 #define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
 #define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
 #define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
 #define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
 #define TMR_ORIGINAL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 5))
-#define TMR_TAG(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 6))
 /* 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))
 statement.  */
 #define ASM_STRING(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
 #define ASM_OUTPUTS(NODE)       TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
 #define ASM_INPUTS(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
 #define ASM_CLOBBERS(NODE)      TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
+#define ASM_LABELS(NODE)	TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4)
 /* Nonzero if we want to create an ASM_INPUT instead of an
 ASM_OPERAND with no operands.  */
 #define ASM_INPUT_P(NODE) (ASM_EXPR_CHECK (NODE)->base.static_flag)
 #define ASM_VOLATILE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.public_flag)
 #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) \
-(EH_FILTER_EXPR_CHECK (NODE)->base.static_flag)
-/* 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)
 #define OBJ_TYPE_REF_TOKEN(NODE)  TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)
 #define OMP_CLAUSE_CHAIN(NODE)     TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
 #define OMP_CLAUSE_DECL(NODE)      					\
 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),	\
 					      OMP_CLAUSE_PRIVATE,	\
 	                                      OMP_CLAUSE_COPYPRIVATE), 0)
+#define OMP_CLAUSE_HAS_LOCATION(NODE) \
+((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus != UNKNOWN_LOCATION)
+#define OMP_CLAUSE_LOCATION(NODE)  (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus
 /* True on an OMP_SECTION statement that was the last lexical member.
 This status is meaningful in the implementation of lastprivate.  */
 #define OMP_SECTION_LAST(NODE) \
 (OMP_SECTION_CHECK (NODE)->base.private_flag)
 };
 #define OMP_CLAUSE_DEFAULT_KIND(NODE) \
 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
-struct tree_exp GTY(())
+struct GTY(()) tree_exp {
-{
 struct tree_common common;
 location_t locus;
 tree block;
 tree GTY ((special ("tree_exp"),
 	     desc ("TREE_CODE ((tree) &%0)")))
 /* Attributes for SSA_NAMEs for pointer-type variables.  */
 #define SSA_NAME_PTR_INFO(N) \
 SSA_NAME_CHECK (N)->ssa_name.ptr_info
-/* Get the value of this SSA_NAME, if available.  */
-#define SSA_NAME_VALUE(N) \
-SSA_NAME_CHECK (N)->ssa_name.value_handle
 #ifndef _TREE_FLOW_H
 struct ptr_info_def;
 #endif
 /* Immediate use linking structure.  This structure is used for maintaining
 a doubly linked list of uses of an SSA_NAME.  */
-typedef struct ssa_use_operand_d GTY(())
+typedef struct GTY(()) ssa_use_operand_d {
-{
 struct ssa_use_operand_d* GTY((skip(""))) prev;
 struct ssa_use_operand_d* GTY((skip(""))) next;
 /* Immediate uses for a given SSA name are maintained as a cyclic
 list.  To recognize the root of this list, the location field
 needs to point to the original SSA name.  Since statements and
 } ssa_use_operand_t;
 /* Return the immediate_use information for an SSA_NAME. */
 #define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
-struct tree_ssa_name GTY(())
+struct GTY(()) tree_ssa_name {
-{
 struct tree_common common;
 /* _DECL wrapped by this SSA name.  */
 tree var;
 unsigned int version;
 /* Pointer attributes used for alias analysis.  */
 struct ptr_info_def *ptr_info;
-/* Value for SSA name used by various passes.
-Right now only invariants are allowed to persist beyond a pass in
-this field; in the future we will allow VALUE_HANDLEs to persist
-as well.  */
-tree value_handle;
 /* Immediate uses list for this SSA_NAME.  */
 struct ssa_use_operand_d imm_uses;
 };
-struct phi_arg_d GTY(())
+struct GTY(()) phi_arg_d {
-{
 /* imm_use MUST be the first element in struct because we do some
 pointer arithmetic with it.  See phi_arg_index_from_use.  */
 struct ssa_use_operand_d imm_use;
 tree def;
+location_t locus;
 };
 #define OMP_CLAUSE_CODE(NODE)					\
 	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code
 	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code
 #define OMP_CLAUSE_OPERAND(NODE, I)				\
 	OMP_CLAUSE_ELT_CHECK (NODE, I)
-struct tree_omp_clause GTY(())
+struct GTY(()) tree_omp_clause {
-{
 struct tree_common common;
+location_t locus;
 enum omp_clause_code code;
 union omp_clause_subcode {
 enum omp_clause_default_kind  default_kind;
 enum omp_clause_schedule_kind schedule_kind;
 enum tree_code                reduction_code;
 from.  This is only set in the top level block, which corresponds to the
 inlined function scope.  This is used in the debug output routines.  */
 #define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)
-struct tree_block GTY(())
+struct GTY(()) tree_block {
-{
 struct tree_common common;
 unsigned abstract_flag : 1;
 unsigned block_num : 31;
 #define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
 #define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
 #define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
 #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
 #define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
+#define TYPE_MAXVAL(NODE) (TYPE_CHECK (NODE)->type.maxval)
+#define TYPE_MINVAL(NODE) (TYPE_CHECK (NODE)->type.minval)
 /* Vector types need to check target flags to determine type.  */
 extern enum machine_mode vector_type_mode (const_tree);
 #define TYPE_MODE(NODE) \
 (TREE_CODE (TYPE_CHECK (NODE)) == VECTOR_TYPE \
 (TYPE_CHECK (NODE)->type.mode = (MODE))
 /* 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. */
 The value is an int, measured in bits.  */
 #define TYPE_ALIGN(NODE) (TYPE_CHECK (NODE)->type.align)
 /* 1 if the alignment for this type was requested by "aligned" attribute,
 0 if it is the default for this type.  */
-#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align)
+#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->common.base.user_align)
 /* The alignment for NODE, in bytes.  */
 #define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
 /* If your language allows you to declare types, and you want debug info
 /* If nonzero, this type is `restrict'-qualified, in the C sense of
 the term.  */
 #define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
+/* The address space the type is in.  */
+#define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.address_space)
 /* There is a TYPE_QUAL value for each type qualifier.  They can be
 combined by bitwise-or to form the complete set of qualifiers for a
 type.  */
 #define TYPE_UNQUALIFIED   0x0
 #define TYPE_QUAL_CONST    0x1
 #define TYPE_QUAL_VOLATILE 0x2
 #define TYPE_QUAL_RESTRICT 0x4
+/* Encode/decode the named memory support as part of the qualifier.  If more
+than 8 qualifiers are added, these macros need to be adjusted.  */
+#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
+#define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
+/* Return all qualifiers except for the address space qualifiers.  */
+#define CLEAR_QUAL_ADDR_SPACE(X) ((X) & ~0xFF00)
+/* Only keep the address space out of the qualifiers and discard the other
+qualifiers.  */
+#define KEEP_QUAL_ADDR_SPACE(X) ((X) & 0xFF00)
 /* The set of type qualifiers for this type.  */
 #define TYPE_QUALS(NODE)					\
+((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)			\
+| (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)		\
+| (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)		\
+| (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE))))
+/* The same as TYPE_QUALS without the address space qualifications.  */
+#define TYPE_QUALS_NO_ADDR_SPACE(NODE)				\
 ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)			\
 | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)		\
 | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
 /* These flags are available for each language front end to use internally.  */
 /* Set precision to n when we have 2^n sub-parts of the vector.  */
 #define SET_TYPE_VECTOR_SUBPARTS(VECTOR_TYPE, X) \
 (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision = exact_log2 (X))
+/* Nonzero in a VECTOR_TYPE if the frontends should not emit warnings
+about missing conversions to other vector types of the same size.  */
+#define TYPE_VECTOR_OPAQUE(NODE) \
+(VECTOR_TYPE_CHECK (NODE)->base.default_def_flag)
 /* Indicates that objects of this type must be initialized by calling a
 function when they are created.  */
 #define TYPE_NEEDS_CONSTRUCTING(NODE) \
 (TYPE_CHECK (NODE)->type.needs_constructing_flag)
 #define TYPE_NONALIASED_COMPONENT(NODE) \
 (ARRAY_TYPE_CHECK (NODE)->type.transparent_union_flag)
 /* Indicated that objects of this type should be laid out in as
 compact a way as possible.  */
-#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
+#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->common.base.packed_flag)
 /* Used by type_contains_placeholder_p to avoid recomputation.
 Values are: 0 (unknown), 1 (false), 2 (true).  Never access
 this field directly.  */
 #define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
 (TYPE_CHECK (NODE)->type.contains_placeholder_bits)
 struct die_struct;
-struct tree_type GTY(())
+struct GTY(()) tree_type {
-{
 struct tree_common common;
 tree values;
 tree size;
 tree size_unit;
 tree attributes;
 unsigned int uid;
-unsigned int precision : 9;
+unsigned int precision : 10;
-ENUM_BITFIELD(machine_mode) mode : 7;
-unsigned string_flag : 1;
 unsigned no_force_blk_flag : 1;
 unsigned needs_constructing_flag : 1;
 unsigned transparent_union_flag : 1;
-unsigned packed_flag : 1;
 unsigned restrict_flag : 1;
 unsigned contains_placeholder_bits : 2;
+ENUM_BITFIELD(machine_mode) mode : 8;
+unsigned string_flag : 1;
 unsigned lang_flag_0 : 1;
 unsigned lang_flag_1 : 1;
 unsigned lang_flag_2 : 1;
 unsigned lang_flag_3 : 1;
 unsigned lang_flag_4 : 1;
 unsigned lang_flag_5 : 1;
 unsigned lang_flag_6 : 1;
-unsigned user_align : 1;
 unsigned int align;
 alias_set_type alias_set;
 tree pointer_to;
 tree reference_to;
 points either to the binfo for which this is a primary binfo, or to
 the binfo of the most derived type.  */
 #define BINFO_INHERITANCE_CHAIN(NODE) \
 	(TREE_BINFO_CHECK(NODE)->binfo.inheritance)
-struct tree_binfo GTY (())
+struct GTY (()) tree_binfo {
-{
 struct tree_common common;
 tree offset;
 tree vtable;
 tree virtuals;
 /* 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				\
-	 || MTAG_P (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	\
+		 || TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL)))
-		 || MTAG_P (SSA_NAME_VAR (DECL)))))
 /* Enumerate visibility settings.  */
 #define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
 /* Every ..._DECL node gets a unique number.  */
 #define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)
+/* DEBUG_EXPR_DECLs get negative UID numbers, to catch erroneous
+uses.  */
+#define DEBUG_TEMP_UID(NODE) (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL)))
 /* These two fields describe where in the source code the declaration
 was.  If the declaration appears in several places (as for a C
 function that is declared first and then defined later), this
 information should refer to the definition.  */
 #define DECL_SOURCE_LOCATION(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
 #define DECL_IS_BUILTIN(DECL) \
 (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
 /*  For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
 QUAL_UNION_TYPE node that the field is a member of.  For VAR_DECL,
-PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
+PARM_DECL, FUNCTION_DECL, LABEL_DECL, RESULT_DECL, and CONST_DECL
-points to either the FUNCTION_DECL for the containing function,
+nodes, this points to either the FUNCTION_DECL for the containing
-the RECORD_TYPE or UNION_TYPE for the containing type, or
+function, the RECORD_TYPE or UNION_TYPE for the containing type, or
 NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
 scope".  */
 #define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
 #define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl_minimal.context)
-struct tree_decl_minimal GTY(())
+struct GTY(()) tree_decl_minimal {
-{
 struct tree_common common;
 location_t locus;
 unsigned int uid;
 tree name;
 tree context;
 };
-/* When computing aliasing information, we represent the memory pointed-to
-by pointers with artificial variables called "memory tags" (MT).  There
-are two kinds of tags, namely symbol and name:
-Symbol tags (SMT) are used in flow-insensitive alias analysis, they
-represent all the pointed-to locations and variables pointed-to by
-the same pointer symbol.  Usually, this set is computed using
-type-based analysis (i.e., alias set classes), but this may not
-always be the case.
-Name tags (NMT) are used in flow-sensitive points-to alias
-analysis, they represent the variables and memory locations
-pointed-to by a specific SSA_NAME pointer.
-In general, given a pointer P with a symbol tag SMT, the alias set
-of SMT should be the union of all the alias sets of the NMTs of
-every SSA_NAME for P.  */
-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;
-};
-#define MTAG_GLOBAL(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.is_global)
-#define MTAG_ALIASES(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.aliases)
-/* Memory Partition Tags (MPTs) group memory symbols under one
-common name for the purposes of placing memory PHI nodes.  */
-struct tree_memory_partition_tag GTY(())
-{
-struct tree_memory_tag common;
-/* Set of symbols grouped under this MPT.  */
-bitmap symbols;
-};
-#define MPT_SYMBOLS(NODE)	(MEMORY_PARTITION_TAG_CHECK (NODE)->mpt.symbols)
 /* For any sort of a ..._DECL node, this points to the original (abstract)
-decl node which this decl is an instance of, or else it is NULL indicating
+decl node which this decl is an inlined/cloned instance of, or else it
-that this decl is not an instance of some other decl.  For example,
+is NULL indicating that this decl is not an instance of some other decl.
-in a nested declaration of an inline function, this points back to the
-definition.  */
+The C front-end also uses this in a nested declaration of an inline
+function, to point back to the definition.  */
 #define DECL_ABSTRACT_ORIGIN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)
 /* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
 origin.  This is useful when setting the DECL_ABSTRACT_ORIGIN.  */
 #define DECL_ORIGIN(NODE) \
 #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)
 /* 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)
+#define DECL_USER_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->common.base.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
 FIELD_DECL.  */
 #define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode)
 #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)
+#define DECL_FUNCTION_PERSONALITY(NODE) \
+(FUNCTION_DECL_CHECK (NODE)->function_decl.personality)
 /* Nonzero for a given ..._DECL node means that the name of this node should
-be ignored for symbolic debug purposes.  */
+be ignored for symbolic debug purposes.  Moreover, for a FUNCTION_DECL,
+the body of the function should also be ignored.  */
 #define DECL_IGNORED_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
 /* Nonzero for a given ..._DECL node means that this node represents an
 "abstract instance" of the given declaration (e.g. in the original
 declaration of an inline function).  When generating symbolic debugging
 this does not necessarily imply the entity represented by NODE
 has no program source-level definition in this translation unit.  For
 example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
 DECL_EXTERNAL may be true simultaneously; that can be the case for
 a C99 "extern inline" function.  */
-#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_2)
+#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1)
 /* 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.
 For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
 #define DECL_LANG_FLAG_3(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
 #define DECL_LANG_FLAG_4(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
 #define DECL_LANG_FLAG_5(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
 #define DECL_LANG_FLAG_6(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
 #define DECL_LANG_FLAG_7(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
+#define DECL_LANG_FLAG_8(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8)
-/* Used to indicate an alias set for the memory pointed to by this
-particular FIELD_DECL, PARM_DECL, or VAR_DECL, which must have
-pointer (or reference) type.  */
-#define DECL_POINTER_ALIAS_SET(NODE) \
-(DECL_COMMON_CHECK (NODE)->decl_common.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)
 /* 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)
 be treated as a GIMPLE register, and use real instead of
 virtual ops in SSA form.  */
 #define DECL_GIMPLE_REG_P(DECL) \
 DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag
-/* For a DECL with pointer type, this is set if Type Based Alias
+struct GTY(()) tree_decl_common {
-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(())
-{
 struct tree_decl_minimal common;
 tree size;
 ENUM_BITFIELD(machine_mode) mode : 8;
 unsigned nonlocal_flag : 1;
 unsigned virtual_flag : 1;
 unsigned ignored_flag : 1;
 unsigned abstract_flag : 1;
 unsigned artificial_flag : 1;
-unsigned user_align : 1;
 unsigned preserve_flag: 1;
 unsigned debug_expr_is_from : 1;
 unsigned lang_flag_0 : 1;
 unsigned lang_flag_1 : 1;
 unsigned lang_flag_3 : 1;
 unsigned lang_flag_4 : 1;
 unsigned lang_flag_5 : 1;
 unsigned lang_flag_6 : 1;
 unsigned lang_flag_7 : 1;
+unsigned lang_flag_8 : 1;
 /* In LABEL_DECL, this is DECL_ERROR_ISSUED.
 In VAR_DECL and PARM_DECL, this is DECL_REGISTER.  */
 unsigned decl_flag_0 : 1;
-/* In FIELD_DECL, this is DECL_PACKED.  */
-unsigned decl_flag_1 : 1;
 /* In FIELD_DECL, this is DECL_BIT_FIELD
 In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL.
-In TYPE_DECL, this is TYPE_DECL_SUPRESS_DEBUG.  */
+In TYPE_DECL, this is TYPE_DECL_SUPPRESS_DEBUG.  */
+unsigned decl_flag_1 : 1;
+/* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
+In VAR_DECL and PARM_DECL, this is DECL_HAS_VALUE_EXPR_P.  */
 unsigned decl_flag_2 : 1;
-/* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
-In VAR_DECL and PARM_DECL, this is DECL_HAS_VALUE_EXPR.  */
-unsigned decl_flag_3 : 1;
 /* Logically, these two would go in a theoretical base shared by var and
 parm decl. */
 unsigned gimple_reg_flag : 1;
-/* In a DECL with pointer type, set if no TBAA should be done.  */
+/* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE.  */
-unsigned no_tbaa_flag : 1;
+unsigned decl_by_reference_flag : 1;
-/* Padding so that 'align' can be on a 32-bit boundary.  */
+/* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_RESTRICTED_P.  */
+unsigned decl_restricted_flag : 1;
+/* Padding so that 'off_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;
+/* 24-bits unused.  */
+/* DECL_ALIGN.  It should have the same size as TYPE_ALIGN.  */
+unsigned int align;
 tree size_unit;
 tree initial;
 tree attributes;
 tree abstract_origin;
-alias_set_type pointer_alias_set;
 /* Points to a structure whose details depend on the language in use.  */
 struct lang_decl *lang_specific;
 };
 extern tree decl_value_expr_lookup (tree);
 /* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
 if transformations have made this more complicated than evaluating the
 decl itself.  This should only be used for debugging; once this field has
 been set, the decl itself may not legitimately appear in the function.  */
 #define DECL_HAS_VALUE_EXPR_P(NODE) \
-(TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_flag_3)
+(TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_flag_2)
 #define DECL_VALUE_EXPR(NODE) \
 (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
 #define SET_DECL_VALUE_EXPR(NODE, VAL)			\
 (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
 #define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
 /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.  */
 #define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)
-struct tree_decl_with_rtl GTY(())
+struct GTY(()) tree_decl_with_rtl {
-{
 struct tree_decl_common common;
 rtx rtl;
 };
 /* In a FIELD_DECL, this is the field position, counting in bytes, of the
 which this FIELD_DECL is defined.  This information is needed when
 writing debugging information about vfield and vbase decls for C++.  */
 #define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
 /* In a FIELD_DECL, indicates this field should be bit-packed.  */
-#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
+#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->common.base.packed_flag)
 /* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
 specially.  */
-#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
+#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
 /* Used in a FIELD_DECL to indicate that we cannot form the address of
 this component.  This makes it possible for Type-Based Alias Analysis
 to disambiguate accesses to this field with indirect accesses using
 the field's type:
 field 'i' (int) will not be recorded as a subset of that of the type of
 's' (struct S) in record_component_aliases.  The counterpart is that
 accesses to s.i must not be given the alias set of the type of 'i'
 (int) but instead directly that of the type of 's' (struct S).  */
 #define DECL_NONADDRESSABLE_P(NODE) \
-(FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
+(FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
-struct tree_field_decl GTY(())
+struct GTY(()) tree_field_decl {
-{
 struct tree_decl_common common;
 tree offset;
 tree bit_field_type;
 tree qualifier;
 tree bit_offset;
 tree fcontext;
 };
 /* 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_common.pointer_alias_set)
+(LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid)
+/* In a LABEL_DECL, the EH region number for which the label is the
+post_landing_pad.  */
+#define EH_LANDING_PAD_NR(NODE) \
+(LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr)
 /* In LABEL_DECL nodes, nonzero means that an error message about
 jumping into such a binding contour has been printed for this label.  */
-#define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl_common.decl_flag_0)
+#define DECL_ERROR_ISSUED(NODE) \
+(LABEL_DECL_CHECK (NODE)->decl_common.decl_flag_0)
-struct tree_label_decl GTY(())
-{
+struct GTY(()) tree_label_decl {
 struct tree_decl_with_rtl common;
-};
+int label_decl_uid;
+int eh_landing_pad_nr;
-struct tree_result_decl GTY(())
+};
-{
+struct var_ann_d;
+struct GTY(()) tree_result_decl {
 struct tree_decl_with_rtl common;
-};
+struct var_ann_d *ann;
+};
-struct tree_const_decl GTY(())
-{
+struct GTY(()) tree_const_decl {
 struct tree_decl_with_rtl common;
 };
 /* For a PARM_DECL, records the data type used to pass the argument,
 which may be different from the type seen in the program.  */
 /* For PARM_DECL, holds an RTL for the stack slot or register
 where the data was actually passed.  */
 #define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
-struct tree_parm_decl GTY(())
+struct GTY(()) tree_parm_decl {
-{
 struct tree_decl_with_rtl common;
 rtx incoming_rtl;
+struct var_ann_d *ann;
 };
 /* Nonzero in a decl means that the gimplifier has seen (or placed)
 this variable in a BIND_EXPR.  */
 (in_system_header_at (DECL_SOURCE_LOCATION (NODE)))
 /* Used to indicate that this DECL has weak linkage.  */
 #define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
-/* Internal to the gimplifier.  Indicates that the value is a formal
-temporary controlled by the gimplifier.  */
-#define DECL_GIMPLE_FORMAL_TEMP_P(DECL) \
-DECL_WITH_VIS_CHECK (DECL)->decl_with_vis.gimple_formal_temp
 /* Used to indicate that the DECL is a dllimport.  */
 #define DECL_DLLIMPORT_P(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
-/* DECL_BASED_ON_RESTRICT_P records whether a VAR_DECL is a temporary
-based on a variable with a restrict qualified type.  If it is,
-DECL_RESTRICT_BASE returns the restrict qualified variable on which
-it is based.  */
-#define DECL_BASED_ON_RESTRICT_P(NODE) \
-(VAR_DECL_CHECK (NODE)->decl_with_vis.based_on_restrict_p)
-#define DECL_GET_RESTRICT_BASE(NODE) \
-(decl_restrict_base_lookup (VAR_DECL_CHECK (NODE)))
-#define SET_DECL_RESTRICT_BASE(NODE, VAL) \
-(decl_restrict_base_insert (VAR_DECL_CHECK (NODE), (VAL)))
-extern tree decl_restrict_base_lookup (tree);
-extern void decl_restrict_base_insert (tree, tree);
 /* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
 not be put out unless it is needed in this translation unit.
 Entities like this are shared across translation units (like weak
 entities), but are guaranteed to be generated by any translation
 back-end; it is up to front-ends which set this flag to ensure
 that there will never be any harm, other than bloat, in putting out
 something which is DECL_COMDAT.  */
 #define DECL_COMDAT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)
+#define DECL_COMDAT_GROUP(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_group)
 /* 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
 being inferred.  */
 #define DECL_VISIBILITY_SPECIFIED(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
 /* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
 multiple translation units should be merged.  */
-#define DECL_ONE_ONLY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.one_only)
+#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE)
-struct tree_decl_with_vis GTY(())
+struct GTY(()) tree_decl_with_vis {
-{
 struct tree_decl_with_rtl common;
 tree assembler_name;
 tree section_name;
+tree comdat_group;
 /* Belong to VAR_DECL exclusively.  */
-unsigned defer_output:1;
+unsigned defer_output : 1;
-unsigned hard_register:1;
+unsigned hard_register : 1;
-unsigned thread_local:1;
+unsigned thread_local : 1;
-unsigned common_flag:1;
+unsigned common_flag : 1;
 unsigned in_text_section : 1;
-unsigned gimple_formal_temp : 1;
 unsigned dllimport_flag : 1;
-unsigned based_on_restrict_p : 1;
 /* Used by C++.  Might become a generic decl flag.  */
 unsigned shadowed_for_var_p : 1;
 /* Don't belong to VAR_DECL exclusively.  */
-unsigned weak_flag:1;
+unsigned weak_flag : 1;
 unsigned seen_in_bind_expr : 1;
 unsigned comdat_flag : 1;
 ENUM_BITFIELD(symbol_visibility) visibility : 2;
 unsigned visibility_specified : 1;
-/* Belong to FUNCTION_DECL exclusively.  */
-unsigned one_only : 1;
-unsigned init_priority_p:1;
 /* Belongs to VAR_DECL exclusively.  */
 ENUM_BITFIELD(tls_model) tls_model : 3;
-/* 12 unused bits. */
+/* Belong to FUNCTION_DECL exclusively.  */
+unsigned init_priority_p : 1;
+/* 15 unused bits. */
 };
 /* In a VAR_DECL that's static,
 nonzero if the space is in the text section.  */
 #define DECL_IN_TEXT_SECTION(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)
 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 (NODE))
 /* Set the initialization priority for NODE to VAL.  */
 #define SET_DECL_INIT_PRIORITY(NODE, VAL) \
 (decl_init_priority_insert (NODE, VAL))
 /* In a VAR_DECL, nonzero if the data should be allocated from
 thread-local storage.  */
 #define DECL_THREAD_LOCAL_P(NODE) \
 (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model >= TLS_MODEL_REAL)
-struct tree_var_decl GTY(())
+#define DECL_VAR_ANN_PTR(NODE) \
-{
+(TREE_CODE (NODE) == VAR_DECL ? &(NODE)->var_decl.ann \
+: TREE_CODE (NODE) == PARM_DECL ? &(NODE)->parm_decl.ann \
+: TREE_CODE (NODE) == RESULT_DECL ? &(NODE)->result_decl.ann \
+: NULL)
+struct GTY(()) tree_var_decl {
 struct tree_decl_with_vis common;
+struct var_ann_d *ann;
 };
 /* This field is used to reference anything in decl.result and is meant only
 for use by the garbage collector.  */
 to an INTEGER_CST node which is suitable for use as an index
 into the virtual function table.
 C++ also uses this field in namespaces, hence the DECL_NON_COMMON_CHECK.  */
 #define DECL_VINDEX(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex)
-struct tree_decl_non_common GTY(())
+struct GTY(())
+tree_decl_non_common {
-{
 struct tree_decl_with_vis common;
 /* C++ uses this in namespaces.  */
 tree saved_tree;
 /* C++ uses this in templates.  */
 tree arguments;
 /* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
 disabled in this function.  */
 #define DECL_NO_LIMIT_STACK(NODE) \
 (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)
-/* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
+/* In a FUNCTION_DECL indicates that a static chain is needed.  */
-static chain is not needed.  */
+#define DECL_STATIC_CHAIN(NODE) \
-#define DECL_NO_STATIC_CHAIN(NODE) \
 (FUNCTION_DECL_CHECK (NODE)->function_decl.regdecl_flag)
 /* 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.  */
 /* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the
 arguments/result/saved_tree fields by front ends.   It was either inherit
 FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL,
 which seemed a bit strange.  */
-struct tree_function_decl GTY(())
+struct GTY(()) tree_function_decl {
-{
 struct tree_decl_non_common common;
 struct function *f;
+/* The personality function. Used for stack unwinding. */
+tree personality;
 /* Function specific options that are used by this function.  */
 tree function_specific_target;	/* target options */
 tree function_specific_optimization;	/* optimization options */
 /* In a TYPE_DECL nonzero means the detail info about this type is not dumped
 into stabs.  Instead it will generate cross reference ('x') of names.
 This uses the same flag as DECL_EXTERNAL.  */
 #define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
-(TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_2)
+(TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1)
 /* Getter of the imported declaration associated to the
 IMPORTED_DECL node.  */
 #define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \
 (DECL_INITIAL (IMPORTED_DECL_CHECK (NODE)))
-struct tree_type_decl GTY(())
+struct GTY(()) tree_type_decl {
-{
 struct tree_decl_non_common common;
 };
 /* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
 #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
+struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) 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
+struct GTY(()) tree_statement_list
-GTY(())
+{
-{
 struct tree_common common;
 struct tree_statement_list_node *head;
 struct tree_statement_list_node *tail;
 };
 /* Optimization options used by a function.  */
-struct tree_optimization_option GTY(())
+struct GTY(()) tree_optimization_option {
-{
 struct tree_common common;
 /* The optimization options used by the user.  */
 struct cl_optimization opts;
 };
 /* Return a tree node that encapsulates the current optimization options.  */
 extern tree build_optimization_node (void);
 /* Target options used by a function.  */
-struct tree_target_option GTY(())
+struct GTY(()) tree_target_option {
-{
 struct tree_common common;
 /* The optimization options used by the user.  */
 struct cl_target_option opts;
 };
 /* Define the overall contents of a tree node.
 It may be any of the structures declared above
 for various types of node.  */
-union tree_node GTY ((ptr_alias (union lang_tree_node),
+union GTY ((ptr_alias (union lang_tree_node),
-		      desc ("tree_node_structure (&%h)")))
+		      desc ("tree_node_structure (&%h)"))) tree_node {
-{
 struct tree_base GTY ((tag ("TS_BASE"))) base;
 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_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name;
 struct tree_block GTY ((tag ("TS_BLOCK"))) block;
 struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo;
 struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
 struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
-struct tree_memory_tag GTY ((tag ("TS_MEMORY_TAG"))) mtag;
 struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
-struct tree_memory_partition_tag GTY ((tag ("TS_MEMORY_PARTITION_TAG"))) mpt;
 struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization;
 struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option;
 };
 /* Standard named or nameless data types of the C compiler.  */
 /* Construct various types of nodes.  */
 extern tree build_nt (enum tree_code, ...);
 extern tree build_nt_call_list (tree, tree);
+extern tree build_nt_call_vec (tree, VEC(tree,gc) *);
 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)
 			 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 build5_stat (enum tree_code, tree, tree, tree, tree, tree,
 			 tree MEM_STAT_DECL);
 #define build5(c,t1,t2,t3,t4,t5,t6) build5_stat (c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
-extern tree build7_stat (enum tree_code, tree, tree, tree, tree, tree,
+extern tree build6_stat (enum tree_code, tree, tree, tree, tree, tree,
-			 tree, tree, tree MEM_STAT_DECL);
+			 tree, tree MEM_STAT_DECL);
-#define build7(c,t1,t2,t3,t4,t5,t6,t7,t8) \
+#define build6(c,t1,t2,t3,t4,t5,t6,t7) \
-build7_stat (c,t1,t2,t3,t4,t5,t6,t7,t8 MEM_STAT_INFO)
+build6_stat (c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO)
+extern tree build_var_debug_value_stat (tree, tree MEM_STAT_DECL);
+#define build_var_debug_value(t1,t2) \
+build_var_debug_value_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_complex (tree, tree, tree);
 extern tree build_one_cst (tree);
 extern tree build_string (int, const char *);
 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);
+extern tree build_tree_list_vec_stat (const VEC(tree,gc) * MEM_STAT_DECL);
+#define build_tree_list_vec(v) build_tree_list_vec_stat (v MEM_STAT_INFO)
+extern tree build_decl_stat (location_t, enum tree_code,
+			     tree, tree MEM_STAT_DECL);
 extern tree build_fn_decl (const char *, tree);
-#define build_decl(c,t,q) build_decl_stat (c,t,q MEM_STAT_INFO)
+#define build_decl(l,c,t,q) build_decl_stat (l,c,t,q MEM_STAT_INFO)
 extern tree build_block (tree, tree, tree, tree);
-extern tree build_empty_stmt (void);
+extern tree build_empty_stmt (location_t);
-extern tree build_omp_clause (enum omp_clause_code);
+extern tree build_omp_clause (location_t, 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*);
+#define build_call_array(T1,T2,N,T3)\
+build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3)
+extern tree build_call_array_loc (location_t, tree, tree, int, const tree *);
+extern tree build_call_vec (tree, tree, VEC(tree,gc) *);
 /* Construct various nodes representing data types.  */
 extern tree make_signed_type (int);
 extern tree make_unsigned_type (int);
 extern tree build_pointer_type (tree);
 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_opaque_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_varargs_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);
-extern tree build_resx (int);
 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 (const_tree, tree);
+extern tree chain_index (int, tree);
 #ifndef noCbC
 extern tree build_code_segment_type (tree, tree);
 #endif
 extern int attribute_list_equal (const_tree, const_tree);
 extern unsigned int tree_int_cst_min_precision (tree, bool);
 extern bool tree_expr_nonnegative_p (tree);
 extern bool tree_expr_nonnegative_warnv_p (tree, bool *);
 extern bool may_negate_without_overflow_p (const_tree);
 extern tree strip_array_types (tree);
+extern tree excess_precision_type (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);
 Such modified types already made are recorded so that duplicates
 are not made.  */
 extern tree build_type_attribute_variant (tree, tree);
 extern tree build_decl_attribute_variant (tree, tree);
+extern tree build_type_attribute_qual_variant (tree, tree, int);
 /* Structure describing an attribute and a function to handle it.  */
 struct attribute_spec
 {
 /* The name of the attribute (without any leading or trailing __),
 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);
+#define non_lvalue(T) non_lvalue_loc (UNKNOWN_LOCATION, T)
+extern tree non_lvalue_loc (location_t, tree);
 extern tree convert (tree, 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 (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 tree_expr_size (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 bitsizetype sizetype_tab[(int) BITSIZETYPE]
 #define ssizetype sizetype_tab[(int) SSIZETYPE]
 #define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
 extern tree size_int_kind (HOST_WIDE_INT, enum size_type_kind);
-extern tree size_binop (enum tree_code, tree, tree);
+#define size_binop(CODE,T1,T2)\
-extern tree size_diffop (tree, tree);
+size_binop_loc (UNKNOWN_LOCATION, CODE, T1, T2)
+extern tree size_binop_loc (location_t, enum tree_code, tree, tree);
+#define size_diffop(T1,T2)\
+size_diffop_loc (UNKNOWN_LOCATION, T1, T2)
+extern tree size_diffop_loc (location_t, tree, tree);
 #define size_int(L) size_int_kind (L, SIZETYPE)
 #define ssize_int(L) size_int_kind (L, SSIZETYPE)
 #define bitsize_int(L) size_int_kind (L, BITSIZETYPE)
 #define sbitsize_int(L) size_int_kind (L, SBITSIZETYPE)
-extern tree round_up (tree, int);
+#define round_up(T,N) round_up_loc (UNKNOWN_LOCATION, T, N)
-extern tree round_down (tree, int);
+extern tree round_up_loc (location_t, tree, int);
+#define round_down(T,N) round_down_loc (UNKNOWN_LOCATION, T, N)
+extern tree round_down_loc (location_t, tree, int);
 extern tree get_pending_sizes (void);
 extern void put_pending_size (tree);
 extern void put_pending_sizes (tree);
+extern void finalize_size_functions (void);
 /* Type for sizes of data-type.  */
 #define BITS_PER_UNIT_LOG \
 ((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) \
 extern bool initializer_zerop (const_tree);
 /* Given a CONSTRUCTOR CTOR, return the elements as a TREE_LIST.  */
 extern tree ctor_to_list (tree);
+/* Given a CONSTRUCTOR CTOR, return the element values as a vector.  */
+extern VEC(tree,gc) *ctor_to_vec (tree);
 /* Examine CTOR to discover:
 * how many scalar fields are set to nonzero values,
 and place it in *P_NZ_ELTS;
 * how many scalar fields in total are in CTOR,
 This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
 positions.  */
 extern bool type_contains_placeholder_p (tree);
+/* Given a tree EXP, find all occurences of references to fields
+in a PLACEHOLDER_EXPR and place them in vector REFS without
+duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
+we assume here that EXP contains only arithmetic expressions
+or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
+argument list.  */
+extern void find_placeholder_in_expr (tree, VEC (tree, heap) **);
+/* This macro calls the above function but short-circuits the common
+case of a constant to save time and also checks for NULL.  */
+#define FIND_PLACEHOLDER_IN_EXPR(EXP, V) \
+do {					 \
+if((EXP) && !TREE_CONSTANT (EXP))	 \
+find_placeholder_in_expr (EXP, V);	 \
+} while (0)
 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
 return a tree with all occurrences of references to F in a
-PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
+PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
-contains only arithmetic expressions.  */
+CONST_DECLs.  Note that we assume here that EXP contains only
+arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
+occurring only in their argument list.  */
 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.  */
 extern tree get_narrower (tree, int *);
 /* Return true if T is an expression that get_inner_reference handles.  */
-extern int handled_component_p (const_tree);
+static inline bool
+handled_component_p (const_tree t)
+{
+switch (TREE_CODE (t))
+{
+case BIT_FIELD_REF:
+case COMPONENT_REF:
+case ARRAY_REF:
+case ARRAY_RANGE_REF:
+case VIEW_CONVERT_EXPR:
+case REALPART_EXPR:
+case IMAGPART_EXPR:
+return true;
+default:
+return false;
+}
+}
 /* Given an expression EXP that is a handled_component_p,
 look for the ultimate containing object, which is returned and specify
 the access position and size.  */
 /* 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 (const_tree);
-extern void change_decl_assembler_name (tree, 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 (const_tree, const_tree);
 extern tree call_expr_arg (tree, int);
 extern tree *call_expr_argp (tree, int);
 extern tree call_expr_arglist (tree);
-extern tree create_artificial_label (void);
+extern tree create_artificial_label (location_t);
 extern const char *get_name (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);
+extern tree build_low_bits_mask (tree, unsigned);
+extern tree tree_strip_nop_conversions (tree);
+extern tree tree_strip_sign_nop_conversions (tree);
+extern tree lhd_gcc_personality (void);
+/* In cgraph.c */
+extern void change_decl_assembler_name (tree, tree);
 /* In gimplify.c */
 extern tree unshare_expr (tree);
 /* In stmt.c */
 Acts only on the top level of the expression;
 if the argument itself cannot be simplified, its
 subexpressions are not changed.  */
 extern tree fold (tree);
-extern tree fold_unary (enum tree_code, tree, tree);
+#define fold_unary(CODE,T1,T2)\
-extern tree fold_unary_ignore_overflow (enum tree_code, tree, tree);
+fold_unary_loc (UNKNOWN_LOCATION, CODE, T1, T2)
-extern tree fold_binary (enum tree_code, tree, tree, tree);
+extern tree fold_unary_loc (location_t, enum tree_code, tree, tree);
-extern tree fold_ternary (enum tree_code, tree, tree, tree, tree);
+#define fold_unary_ignore_overflow(CODE,T1,T2)\
-extern tree fold_build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
+fold_unary_ignore_overflow_loc (UNKNOWN_LOCATION, CODE, T1, T2)
-#define fold_build1(c,t1,t2) fold_build1_stat (c, t1, t2 MEM_STAT_INFO)
+extern tree fold_unary_ignore_overflow_loc (location_t, enum tree_code, tree, tree);
-extern tree fold_build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
+#define fold_binary(CODE,T1,T2,T3)\
-#define fold_build2(c,t1,t2,t3) fold_build2_stat (c, t1, t2, t3 MEM_STAT_INFO)
+fold_binary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3)
-extern tree fold_build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
+extern tree fold_binary_loc (location_t, enum tree_code, tree, tree, tree);
-#define fold_build3(c,t1,t2,t3,t4) fold_build3_stat (c, t1, t2, t3, t4 MEM_STAT_INFO)
+#define fold_ternary(CODE,T1,T2,T3,T4)\
-extern tree fold_build1_initializer (enum tree_code, tree, tree);
+fold_ternary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3, T4)
-extern tree fold_build2_initializer (enum tree_code, tree, tree, tree);
+extern tree fold_ternary_loc (location_t, enum tree_code, tree, tree, tree, tree);
-extern tree fold_build3_initializer (enum tree_code, tree, tree, tree, tree);
+#define fold_build1(c,t1,t2)\
-extern tree fold_build_call_array (tree, tree, int, tree *);
+fold_build1_stat_loc (UNKNOWN_LOCATION, c, t1, t2 MEM_STAT_INFO)
-extern tree fold_build_call_array_initializer (tree, tree, int, tree *);
+#define fold_build1_loc(l,c,t1,t2)\
+fold_build1_stat_loc (l, c, t1, t2 MEM_STAT_INFO)
+extern tree fold_build1_stat_loc (location_t, enum tree_code, tree,
+				  tree MEM_STAT_DECL);
+#define fold_build2(c,t1,t2,t3)\
+fold_build2_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3 MEM_STAT_INFO)
+#define fold_build2_loc(l,c,t1,t2,t3)\
+fold_build2_stat_loc (l, c, t1, t2, t3 MEM_STAT_INFO)
+extern tree fold_build2_stat_loc (location_t, enum tree_code, tree, tree,
+				  tree MEM_STAT_DECL);
+#define fold_build3(c,t1,t2,t3,t4)\
+fold_build3_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3, t4 MEM_STAT_INFO)
+#define fold_build3_loc(l,c,t1,t2,t3,t4)\
+fold_build3_stat_loc (l, c, t1, t2, t3, t4 MEM_STAT_INFO)
+extern tree fold_build3_stat_loc (location_t, enum tree_code, tree, tree, tree,
+				  tree MEM_STAT_DECL);
+extern tree fold_build1_initializer_loc (location_t, enum tree_code, tree, tree);
+extern tree fold_build2_initializer_loc (location_t, enum tree_code, tree, tree, tree);
+extern tree fold_build3_initializer_loc (location_t, enum tree_code, tree, tree, tree, tree);
+#define fold_build_call_array(T1,T2,N,T4)\
+fold_build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T4)
+extern tree fold_build_call_array_loc (location_t, tree, tree, int, tree *);
+#define fold_build_call_array_initializer(T1,T2,N,T4)\
+fold_build_call_array_initializer_loc (UNKNOWN_LOCATION, T1, T2, N, T4)
+extern tree fold_build_call_array_initializer_loc (location_t, tree, tree, int, tree *);
 extern bool fold_convertible_p (const_tree, const_tree);
-extern tree fold_convert (tree, tree);
+#define fold_convert(T1,T2)\
-extern tree fold_single_bit_test (enum tree_code, tree, tree, tree);
+fold_convert_loc(UNKNOWN_LOCATION, T1, T2)
+extern tree fold_convert_loc (location_t, tree, tree);
+extern tree fold_single_bit_test (location_t, 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 tree fold_indirect_ref_1 (location_t, tree, tree);
 extern void fold_defer_overflow_warnings (void);
 extern void fold_undefer_overflow_warnings (bool, const_gimple, 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 maybe_fold_offset_to_address (tree, tree, tree);
-extern tree maybe_fold_stmt_addition (tree, tree, tree);
 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,
 OEP_PURE_SAME = 2
 };
 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);
+#define omit_one_operand(T1,T2,T3)\
-extern tree omit_two_operands (tree, tree, tree, tree);
+omit_one_operand_loc (UNKNOWN_LOCATION, T1, T2, T3)
-extern tree invert_truthvalue (tree);
+extern tree omit_one_operand_loc (location_t, tree, tree, tree);
-extern tree fold_truth_not_expr (tree);
+#define omit_two_operands(T1,T2,T3,T4)\
+omit_two_operands_loc (UNKNOWN_LOCATION, T1, T2, T3, T4)
+extern tree omit_two_operands_loc (location_t, tree, tree, tree, tree);
+#define invert_truthvalue(T)\
+invert_truthvalue_loc(UNKNOWN_LOCATION, T)
+extern tree invert_truthvalue_loc (location_t, tree);
+extern tree fold_truth_not_expr (location_t, 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, const_tree, const_tree, int);
-extern tree build_fold_addr_expr (tree);
+#define build_fold_addr_expr(T)\
+build_fold_addr_expr_loc (UNKNOWN_LOCATION, (T))
+extern tree build_fold_addr_expr_loc (location_t, tree);
+#define build_fold_addr_expr_with_type(T,TYPE)\
+build_fold_addr_expr_with_type_loc (UNKNOWN_LOCATION, (T), TYPE)
+extern tree build_fold_addr_expr_with_type_loc (location_t, tree, tree);
 extern tree fold_build_cleanup_point_expr (tree type, tree expr);
 extern tree fold_strip_sign_ops (tree);
-extern tree build_fold_addr_expr_with_type (tree, tree);
+#define build_fold_indirect_ref(T)\
-extern tree build_fold_indirect_ref (tree);
+build_fold_indirect_ref_loc (UNKNOWN_LOCATION, T)
-extern tree fold_indirect_ref (tree);
+extern tree build_fold_indirect_ref_loc (location_t, tree);
+#define fold_indirect_ref(T)\
+fold_indirect_ref_loc (UNKNOWN_LOCATION, T)
+extern tree fold_indirect_ref_loc (location_t, tree);
 extern tree constant_boolean_node (int, tree);
-extern tree build_low_bits_mask (tree, unsigned);
+extern tree div_if_zero_remainder (enum tree_code, const_tree, const_tree);
 extern bool tree_swap_operands_p (const_tree, const_tree, bool);
 extern enum tree_code swap_tree_comparison (enum tree_code);
 extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *);
 extern bool tree_expr_nonzero_p (tree);
 extern bool tree_unary_nonzero_warnv_p (enum tree_code, tree, tree, bool *);
 extern bool tree_binary_nonzero_warnv_p (enum tree_code, tree, tree, tree op1,
 bool *);
 extern bool tree_single_nonzero_warnv_p (tree, bool *);
-extern bool tree_expr_nonzero_warnv_p (tree, bool *);
 extern bool tree_unary_nonnegative_warnv_p (enum tree_code, tree, tree, bool *);
 extern bool tree_binary_nonnegative_warnv_p (enum tree_code, tree, tree, tree,
 bool *);
 extern bool tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p);
 extern bool tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p);
 extern bool tree_call_nonnegative_warnv_p (tree, tree, tree, tree, bool *);
 extern bool tree_expr_nonzero_warnv_p (tree, bool *);
 extern bool fold_real_zero_addition_p (const_tree, const_tree, int);
+extern tree combine_comparisons (location_t, enum tree_code, enum tree_code,
+				 enum tree_code, tree, tree, tree);
+extern void debug_fold_checksum (const_tree);
 /* Return nonzero if CODE is a tree code that represents a truth value.  */
 static inline bool
 truth_value_p (enum tree_code code)
 {
 	  || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
 }
 /* In builtins.c */
-extern tree fold_call_expr (tree, bool);
+extern tree fold_call_expr (location_t, tree, bool);
-extern tree fold_builtin_fputs (tree, tree, bool, bool, tree);
+extern tree fold_builtin_fputs (location_t, tree, tree, bool, bool, tree);
-extern tree fold_builtin_strcpy (tree, tree, tree, tree);
+extern tree fold_builtin_strcpy (location_t, tree, tree, tree, tree);
-extern tree fold_builtin_strncpy (tree, tree, tree, tree, tree);
+extern tree fold_builtin_strncpy (location_t, tree, tree, tree, tree, tree);
-extern tree fold_builtin_memory_chk (tree, tree, tree, tree, tree, tree, bool,
+extern tree fold_builtin_memory_chk (location_t, tree, tree, tree, tree, tree, tree, bool,
 				     enum built_in_function);
-extern tree fold_builtin_stxcpy_chk (tree, tree, tree, tree, tree, bool,
+extern tree fold_builtin_stxcpy_chk (location_t, tree, tree, tree, tree, tree, bool,
 				     enum built_in_function);
-extern tree fold_builtin_strncpy_chk (tree, tree, tree, tree, tree);
+extern tree fold_builtin_strncpy_chk (location_t, tree, tree, tree, tree, tree);
-extern tree fold_builtin_snprintf_chk (tree, tree, enum built_in_function);
+extern tree fold_builtin_snprintf_chk (location_t, tree, tree, enum built_in_function);
 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 build_function_call_expr (location_t, tree, tree);
-extern tree fold_builtin_call_array (tree, tree, int, tree *);
+extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *);
-extern void debug_fold_checksum (const_tree);
+#define build_call_expr(...)\
-extern tree build_call_expr (tree, int, ...);
+build_call_expr_loc (UNKNOWN_LOCATION, __VA_ARGS__)
+extern tree build_call_expr_loc (location_t, 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, gimple_seq *, gimple_seq *);
 extern tree build_va_arg_indirect_ref (tree);
 extern tree build_string_literal (int, const char *);
 extern bool validate_arglist (const_tree, ...);
 extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
+extern bool can_trust_pointer_alignment (void);
 extern int get_pointer_alignment (tree, unsigned int);
+extern bool is_builtin_name (const char *);
+extern bool is_builtin_fn (tree);
 extern int get_object_alignment (tree, unsigned int, unsigned int);
 extern tree fold_call_stmt (gimple, bool);
 extern tree gimple_fold_builtin_snprintf_chk (gimple, tree, enum built_in_function);
+extern tree make_range (tree, int *, tree *, tree *, bool *);
+extern tree build_range_check (location_t, tree, tree, int, tree, tree);
+extern bool merge_ranges (int *, tree *, tree *, int, tree, tree, int,
+			  tree, tree);
+extern void set_builtin_user_assembler_name (tree decl, const char *asmspec);
 /* In convert.c */
 extern tree strip_float_extensions (tree);
 /* In tree.c */
 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 hashval_t iterative_hash_exprs_commutative (const_tree,
 const_tree, hashval_t);
+extern hashval_t iterative_hash_host_wide_int (HOST_WIDE_INT, hashval_t);
 extern hashval_t iterative_hash_hashval_t (hashval_t, hashval_t);
+extern hashval_t iterative_hash_host_wide_int (HOST_WIDE_INT, 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 (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 needs_to_live_in_memory (const_tree);
 extern tree reconstruct_complex_type (tree, tree);
 extern int real_onep (const_tree);
 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 bool subrange_type_for_debug_p (const_tree, tree *, tree *);
 extern HOST_WIDE_INT int_cst_value (const_tree);
-extern tree build_addr (tree, tree);
+extern HOST_WIDEST_INT widest_int_cst_value (const_tree);
 extern bool fields_compatible_p (const_tree, const_tree);
 extern tree find_compatible_field (tree, tree);
-extern void set_expr_locus (tree, source_location *);
 extern tree *tree_block (tree);
 extern location_t *block_nonartificial_location (tree);
 extern location_t tree_nonartificial_location (tree);
+extern tree block_ultimate_origin (const_tree);
+/* In tree-nested.c */
+extern tree build_addr (tree, tree);
 /* In function.c */
 extern void expand_main_function (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 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, bool);
 extern void push_struct_function (tree fndecl);
 extern int setjmp_call_p (const_tree);
 extern bool gimple_alloca_call_p (const_gimple);
 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);
-extern tree block_ultimate_origin (const_tree);
 /* In attribs.c.  */
 extern const struct attribute_spec *lookup_attribute_spec (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);
-extern void make_decl_one_only (tree);
+extern void make_decl_one_only (tree, tree);
 extern int supports_one_only (void);
 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);
 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);
+extern void remove_unreachable_alias_pairs (void);
 /* In stmt.c */
 extern void expand_computed_goto (tree);
 extern bool parse_output_constraint (const char **, int, int, int,
 				     bool *, bool *, bool *);
 extern bool parse_input_constraint (const char **, int, int, int, int,
 				    const char * const *, bool *, bool *);
-extern void expand_asm_expr (tree);
+extern void expand_asm_stmt (gimple);
-extern tree resolve_asm_operand_names (tree, tree, tree);
+extern tree resolve_asm_operand_names (tree, tree, tree, tree);
-extern void expand_case (tree);
+extern void expand_case (gimple);
 extern void expand_decl (tree);
 #ifdef HARD_CONST
 /* Silly ifdef to avoid having all includers depend on hard-reg-set.h.  */
 extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *);
 #endif
+/* In dwarf2out.c */
 /* Interface of the DWARF2 unwind info support.  */
 /* Generate a new label for the CFI info to refer to.  */
 extern char *dwarf2out_cfi_label (bool);
 extern void dwarf2out_def_cfa (const char *, unsigned, HOST_WIDE_INT);
 /* Add the CFI for saving a register window.  */
 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 *, HOST_WIDE_INT);
 /* Entry point for saving a register to the stack.  */
 extern void dwarf2out_reg_save (const char *, unsigned, HOST_WIDE_INT);
 #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)
+/* In emit-rtl.c */
 /* Assign the RTX to declaration.  */
 extern void set_decl_rtl (tree, rtx);
 extern void set_decl_incoming_rtl (tree, rtx, bool);
 /* 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;
-/* In tree-gimple.c.  */
+/* In gimple.c.  */
 extern tree get_base_address (tree t);
+extern void mark_addressable (tree);
 /* In tree-vectorizer.c.  */
 extern void vect_set_verbosity_level (const char *);
 /* In tree.c.  */
-struct tree_map_base GTY(())
+struct GTY(()) tree_map_base {
-{
 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 *);
+extern bool list_equal_p (const_tree, const_tree);
 /* Map from a tree to another tree.  */
-struct tree_map GTY(())
+struct GTY(()) tree_map {
-{
 struct tree_map_base base;
 unsigned int hash;
 tree to;
 };
 extern unsigned int tree_map_hash (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 GTY(()) tree_int_map {
-{
 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 GTY(()) tree_priority_map {
-{
 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.c */
+tree target_for_debug_bind (tree);
+/* In tree-ssa-ccp.c */
+extern tree maybe_fold_offset_to_reference (location_t, tree, tree, tree);
+extern tree maybe_fold_offset_to_address (location_t, tree, tree, tree);
+extern tree maybe_fold_stmt_addition (location_t, tree, tree, tree);
 /* 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 (const_tree);
 extern bool ssa_name_nonnegative_p (const_tree);
 /* In tree-object-size.c.  */
 extern void init_object_sizes (void);
 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 (const_tree);
+extern tree build_personality_function (const char *);
 /* In tree-inline.c.  */
 void init_inline_once (void);
 /* In ipa-reference.c.  Used for parsing attributes of asm code.  */
 extern GTY(()) tree memory_identifier_string;
 /* 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)
 {
 /* 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 (())
+typedef struct GTY (()) call_expr_arg_iterator_d {
-{
 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 (())
+typedef struct GTY (()) const_call_expr_arg_iterator_d {
-{
 const_tree t;	/* the call_expr */
 int n;	/* argument count */
 int i;	/* next argument index */
 } const_call_expr_arg_iterator;
 #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)))
+/* Return true if tree node T is a language-specific node.  */
+static inline bool
+is_lang_specific (tree t)
+{
+return TREE_CODE (t) == LANG_TYPE || TREE_CODE (t) >= NUM_TREE_CODES;
+}
 #endif  /* GCC_TREE_H  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree.h @ 57:326d9e06c2e3