CbC/CbC_gcc: gcc/tree.h comparison

comparison gcc/tree.h @ 69:1b10fe6932e1

merge 69

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 07:53:12 +0900
parents	326d9e06c2e3 f6334be47118
children	f26ecf70364b

comparison

equal deleted inserted replaced

-:b362627d71ba
+:1b10fe6932e1
 /* Front-end tree definitions for GNU compiler.
 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "hashtab.h"
 #include "machmode.h"
 #include "input.h"
 #include "statistics.h"
 #include "vec.h"
+#include "vecir.h"
 #include "double-int.h"
+#include "real.h"
+#include "fixed-value.h"
 #include "alias.h"
-#include "options.h"
+#include "flags.h"
 /* Codes of tree nodes */
 #define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
 #define END_OF_BASE_TREE_CODES LAST_AND_UNUSED_TREE_CODE,
 /* Nonzero if CODE represents a INDIRECT_REF.  Keep these checks in
 ascending code order.  */
 #define INDIRECT_REF_P(CODE)\
-(TREE_CODE (CODE) == INDIRECT_REF \
+(TREE_CODE (CODE) == INDIRECT_REF)
-|| TREE_CODE (CODE) == ALIGN_INDIRECT_REF \
-|| TREE_CODE (CODE) == MISALIGNED_INDIRECT_REF)
 /* Nonzero if CODE represents a reference.  */
 #define REFERENCE_CLASS_P(CODE)\
 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_reference)
 #define TREE_CODE_LENGTH(CODE)	tree_code_length[(int) (CODE)]
 /* Names of tree components.  */
 extern const char *const tree_code_name[];
-/* 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.  */
+/* The deferred processing proceeds in several passes.  We memorize the
+diagnostics emitted for a pair to prevent repeating messages when the
+queue gets re-scanned after possible updates.  */
+typedef enum {
+ALIAS_DIAG_NONE      = 0x0,
+ALIAS_DIAG_TO_UNDEF  = 0x1,
+ALIAS_DIAG_TO_EXTERN = 0x2
+} alias_diag_flags;
 typedef struct GTY(()) alias_pair
 {
 tree decl;
 tree target;
+int  emitted_diags;  /* alias_diags already emitted for this pair.  */
 } alias_pair;
 /* Define gc'd vector type.  */
 DEF_VEC_O(alias_pair);
 DEF_VEC_ALLOC_O(alias_pair,gc);
 unsigned lang_flag_6 : 1;
 unsigned visited : 1;
 unsigned packed_flag : 1;
 unsigned user_align : 1;
+unsigned nameless_flag : 1;
-unsigned spare : 13;
+unsigned spare : 12;
 /* This field is only used with type nodes; the only reason it is present
 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;
 for which types of nodes they are defined.
 addressable_flag:
 TREE_ADDRESSABLE in
-VAR_DECL, FUNCTION_DECL, FIELD_DECL, LABEL_DECL
+VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL
 all types
 CONSTRUCTOR, IDENTIFIER_NODE
 STMT_EXPR, it means we want the result of the enclosed expression
 CALL_EXPR_TAILCALL in
 CASE_HIGH_SEEN in
 CASE_LABEL_EXPR
 CALL_CANNOT_INLINE_P in
 CALL_EXPR
+ENUM_IS_SCOPED in
+	   ENUMERAL_TYPE
 public_flag:
 TREE_OVERFLOW in
 INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
 OMP_PARALLEL_COMBINED in
 OMP_PARALLEL
 OMP_CLAUSE_PRIVATE_OUTER_REF in
 	   OMP_CLAUSE_PRIVATE
+TYPE_REF_IS_RVALUE in
+	   REFERENCE_TYPE
 protected_flag:
 TREE_PROTECTED in
 BLOCK
 all decls
-CALL_FROM_THUNK_P in
+CALL_FROM_THUNK_P and
+ALLOCA_FOR_VAR_P in
 CALL_EXPR
 side_effects_flag:
 TREE_SIDE_EFFECTS in
 TYPE_ALIGN_OK in
 all types
 TREE_THIS_NOTRAP in
-(ALIGN/MISALIGNED_)INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF
+INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF
 deprecated_flag:
 TREE_DEPRECATED in
 all decls
 if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))			\
 tree_operand_check_failed (__i, __t,				\
 				 __FILE__, __LINE__, __FUNCTION__);	\
 &__t->exp.operands[__i]; }))
-#define TREE_RTL_OPERAND_CHECK(T, CODE, I) __extension__		\
-(*(rtx *)								\
-({__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_OPERAND_LENGTH (__t))			\
-tree_operand_check_failed (__i, __t,				\
-				 __FILE__, __LINE__, __FUNCTION__);	\
-&__t->exp.operands[__i]; }))
 /* Nodes are chained together for many purposes.
 Types are chained together to record them for being output to the debugger
 (see the function `chain_type').
 Decls in the same scope are chained together to record the contents
 of the scope.
 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,
 				     const char *, enum tree_code,
-				     enum tree_code);
+				     enum tree_code)
+ATTRIBUTE_NORETURN;
 extern void tree_not_class_check_failed (const_tree,
 					 const enum tree_code_class,
 					 const char *, int, const char *)
 ATTRIBUTE_NORETURN;
 extern void tree_vec_elt_check_failed (int, int, const char *,
 #define EXPR_CHECK(T)				(T)
 #define NON_TYPE_CHECK(T)			(T)
 #define TREE_VEC_ELT_CHECK(T, I)		((T)->vec.a[I])
 #define TREE_OPERAND_CHECK(T, I)		((T)->exp.operands[I])
 #define TREE_OPERAND_CHECK_CODE(T, CODE, I)	((T)->exp.operands[I])
-#define TREE_RTL_OPERAND_CHECK(T, CODE, I)  (*(rtx *) &((T)->exp.operands[I]))
 #define OMP_CLAUSE_ELT_CHECK(T, i)	        ((T)->omp_clause.ops[i])
 #define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2)	(T)
 #define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)	(T)
 #define TREE_CHAIN(NODE) ((NODE)->common.chain)
 (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
 /* Define many boolean fields that all tree nodes have.  */
-/* In VAR_DECL nodes, nonzero means address of this is needed.
+/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
-So it cannot be in a register.
+of this is needed.  So it cannot be in a register.
-In a FUNCTION_DECL, nonzero means its address is needed.
+In a FUNCTION_DECL it has no meaning.
-So it must be compiled even if it is an inline function.
-In a FIELD_DECL node, it means that the programmer is permitted to
-construct the address of this field.  This is used for aliasing
-purposes: see record_component_aliases.
 In CONSTRUCTOR nodes, it means object constructed must be in memory.
 In LABEL_DECL nodes, it means a goto for this label has been seen
 from a place outside all binding contours that restore stack levels.
-In ..._TYPE nodes, it means that objects of this type must
+In ..._TYPE nodes, it means that objects of this type must be fully
-be fully addressable.  This means that pieces of this
+addressable.  This means that pieces of this object cannot go into
-object cannot go into register parameters, for example.
+register parameters, for example.  If this a function type, this
+means that the value must be returned in memory.
 In IDENTIFIER_NODEs, this means that some extern decl for this name
 had its address taken.  That matters for inline functions.  */
 #define TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag)
 /* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
 #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) (CALL_EXPR_CHECK (NODE)->base.static_flag)
+/* Used to mark scoped enums.  */
+#define ENUM_IS_SCOPED(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag)
+/* Determines whether an ENUMERAL_TYPE has defined the list of constants. */
+#define ENUM_IS_OPAQUE(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.private_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
 least for used-before-set warnings, and it set after one warning is
 #define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag)
 /* Nonzero means this node will not trap.  In an INDIRECT_REF, means
 accessing the memory pointed to won't generate a trap.  However,
 this only applies to an object when used appropriately: it doesn't
-mean that writing a READONLY mem won't trap. Similarly for
+mean that writing a READONLY mem won't trap.
-ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF.
 In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
 (or slice of the array) always belongs to the range of the array.
 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)
+#define TREE_THIS_NOTRAP(NODE) \
+(TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF,	\
+		ARRAY_RANGE_REF)->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).  */
 In IDENTIFIER_NODEs, this means that some extern decl for this name
 was used.
 In a BLOCK, this means that the block contains variables that are used.  */
 #define TREE_USED(NODE) ((NODE)->base.used_flag)
-/* In a FUNCTION_DECL, nonzero means a call to the function cannot throw
+/* In a FUNCTION_DECL, nonzero means a call to the function cannot
-an exception.  In a CALL_EXPR, nonzero means the call cannot throw.  */
+throw an exception.  In a CALL_EXPR, nonzero means the call cannot
+throw.  We can't easily check the node type here as the C++
+frontend also uses this flag (for AGGR_INIT_EXPR).  */
 #define TREE_NOTHROW(NODE) ((NODE)->base.nothrow_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) \
 such variables).  */
 #define DECL_RESTRICTED_P(NODE) \
 (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \
 		RESULT_DECL)->decl_common.decl_restricted_flag)
+#define DECL_READ_P(NODE) \
+(TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_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)
+/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
+it has been built for the declaration of a variable-sized object.  */
+#define ALLOCA_FOR_VAR_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag)
 /* In a type, nonzero means that all objects of the type are guaranteed by the
 language or front-end to be properly aligned, so we can indicate that a MEM
 of this type is aligned at least to the alignment of the type, even if it
 doesn't appear that it is.  We see this, for example, in object-oriented
 /* Used in classes in C++.  */
 #define TREE_PRIVATE(NODE) ((NODE)->base.private_flag)
 /* Used in classes in C++. */
 #define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag)
+/* True if reference type NODE is a C++ rvalue reference.  */
+#define TYPE_REF_IS_RVALUE(NODE) \
+(REFERENCE_TYPE_CHECK (NODE)->base.private_flag)
 /* Nonzero in a _DECL if the use of the name is defined as a
 deprecated feature by __attribute__((deprecated)).  */
 #define TREE_DEPRECATED(NODE) \
 ((NODE)->base.deprecated_flag)
 };
 /* 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_PTR(NODE) \
+(FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)
 #define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE))
 struct GTY(()) tree_fixed_cst {
 struct tree_common common;
 struct fixed_value * fixed_cst_ptr;
 /* In a CONSTRUCTOR node.  */
 #define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
 #define CONSTRUCTOR_ELT(NODE,IDX) \
 (VEC_index (constructor_elt, CONSTRUCTOR_ELTS (NODE), IDX))
-#define CONSTRUCTOR_NELTS(NODE) (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (NODE)))
+#define CONSTRUCTOR_NELTS(NODE) \
+(VEC_length (constructor_elt, CONSTRUCTOR_ELTS (NODE)))
 /* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
 value of each element (stored within VAL). IX must be a scratch variable
 of unsigned integer type.  */
 #define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \
 the value of each element (stored within VAL) and its index (stored
 within INDEX). IX must be a scratch variable of unsigned integer type.  */
 #define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \
 for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \
 	       ? false \
-	       : ((VAL = VEC_index (constructor_elt, V, IX)->value), \
+	       : (((void) (VAL = VEC_index (constructor_elt, V, IX)->value)), \
 		  (INDEX = VEC_index (constructor_elt, V, IX)->index), \
-	       true); \
+		  true); \
 (IX)++)
 /* Append a new constructor element to V, with the specified INDEX and VAL.  */
 #define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
 do { \
 #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 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_LOC_OR_HERE(NODE) (EXPR_HAS_LOCATION (NODE) ? (NODE)->exp.locus : input_location)
 #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.  */
 of a case label, respectively.  */
 #define CASE_LOW(NODE)          	TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
 #define CASE_HIGH(NODE)         	TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
 #define CASE_LABEL(NODE)		TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
-/* The operands of a TARGET_MEM_REF.  */
+/* The operands of a TARGET_MEM_REF.  Operands 0 and 1 have to match
-#define TMR_SYMBOL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
+corresponding MEM_REF operands.  */
-#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
+#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
+#define TMR_OFFSET(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_INDEX2(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
-#define TMR_ORIGINAL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 5))
 /* 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))
 /* 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
 /* Nonzero if this SSA_NAME is the default definition for the
 underlying symbol.  A default SSA name is created for symbol S if
 the very first reference to S in the function is a read operation.
 Default definitions are always created by an empty statement and
 belong to no basic block.  */
-#define SSA_NAME_IS_DEFAULT_DEF(NODE)	\
+#define SSA_NAME_IS_DEFAULT_DEF(NODE) \
 SSA_NAME_CHECK (NODE)->base.default_def_flag
 /* Attributes for SSA_NAMEs for pointer-type variables.  */
 #define SSA_NAME_PTR_INFO(N) \
 SSA_NAME_CHECK (N)->ssa_name.ptr_info
-#ifndef _TREE_FLOW_H
+/* Defined in 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 GTY(()) ssa_use_operand_d {
 struct ssa_use_operand_d* GTY((skip(""))) prev;
 tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
 };
-struct varray_head_tag;
 /* In a BLOCK node.  */
 #define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
-#define BLOCK_NONLOCALIZED_VARS(NODE) (BLOCK_CHECK (NODE)->block.nonlocalized_vars)
+#define BLOCK_NONLOCALIZED_VARS(NODE) \
-#define BLOCK_NUM_NONLOCALIZED_VARS(NODE) VEC_length (tree, BLOCK_NONLOCALIZED_VARS (NODE))
+(BLOCK_CHECK (NODE)->block.nonlocalized_vars)
-#define BLOCK_NONLOCALIZED_VAR(NODE,N) VEC_index (tree, BLOCK_NONLOCALIZED_VARS (NODE), N)
+#define BLOCK_NUM_NONLOCALIZED_VARS(NODE) \
+VEC_length (tree, BLOCK_NONLOCALIZED_VARS (NODE))
+#define BLOCK_NONLOCALIZED_VAR(NODE,N) \
+VEC_index (tree, BLOCK_NONLOCALIZED_VARS (NODE), N)
 #define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
 #define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
 /* Note: when changing this, make sure to find the places
 that use chainon or nreverse.  */
 #define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE))
 #define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
 #define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
 #define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type.values)
 #define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values)
 #define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type.values)
-#define TYPE_ORIG_SIZE_TYPE(NODE)			\
-(INTEGER_TYPE_CHECK (NODE)->type.values		\
-? TREE_TYPE ((NODE)->type.values) : NULL_TREE)
 #define TYPE_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.maxval)
 #define TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.minval)
 #define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values)
 #define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval)
 #define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval)
 #define TYPE_NEXT_PTR_TO(NODE) (POINTER_TYPE_CHECK (NODE)->type.minval)
 #define TYPE_NEXT_REF_TO(NODE) (REFERENCE_TYPE_CHECK (NODE)->type.minval)
 #define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
 #define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
 #define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
-#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
-#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
-#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)
 (TREE_CODE (TYPE_CHECK (NODE)) == VECTOR_TYPE \
 ? vector_type_mode (NODE) : (NODE)->type.mode)
 #define SET_TYPE_MODE(NODE, MODE) \
 (TYPE_CHECK (NODE)->type.mode = (MODE))
-/* The "canonical" type for this type node, which can be used to
+/* The "canonical" type for this type node, which is used by frontends to
-compare the type for equality with another type. If two types are
+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
+As a special case, if TYPE_CANONICAL is NULL_TREE, and thus
-be used for comparison against other types. Instead, the type is
+TYPE_STRUCTURAL_EQUALITY_P is true, 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. */
+TYPE_STRUCTURAL_EQUALITY_P.
+For unqualified aggregate and function types the middle-end relies on
+TYPE_CANONICAL to tell whether two variables can be assigned
+to each other without a conversion.  The middle-end also makes sure
+to assign the same alias-sets to the type partition with equal
+TYPE_CANONICAL of their unqualified variants.  */
 #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
+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
+just comparing canonical type pointers.  For instance, we would need
 to look at the return and parameter types of a FUNCTION_TYPE
-node. */
+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. */
+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
-structure containing an array.  */
-#define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values)
 /* For record and union types, information about this type, as a base type
 for itself.  */
 #define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type.binfo)
 /* If nonzero, this type is `restrict'-qualified, in the C sense of
 the term.  */
 #define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
+/* If nonzero, type's name shouldn't be emitted into debug info.  */
+#define TYPE_NAMELESS(NODE) (TYPE_CHECK (NODE)->base.nameless_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
 /* 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)
-/* Indicates that objects of this type (a UNION_TYPE), should be passed
+/* Indicates that a UNION_TYPE object should be passed the same way that
-the same way that the first union alternative would be passed.  */
+the first union alternative would be passed, or that a RECORD_TYPE
-#define TYPE_TRANSPARENT_UNION(NODE)  \
+object should be passed the same way that the first (and only) member
-(UNION_TYPE_CHECK (NODE)->type.transparent_union_flag)
+would be passed.  */
+#define TYPE_TRANSPARENT_AGGR(NODE) \
+(RECORD_OR_UNION_CHECK (NODE)->type.transparent_aggr_flag)
 /* For an ARRAY_TYPE, indicates that it is not permitted to take the
 address of a component of the type.  This is the counterpart of
 DECL_NONADDRESSABLE_P for arrays, see the definition of this flag.  */
 #define TYPE_NONALIASED_COMPONENT(NODE) \
-(ARRAY_TYPE_CHECK (NODE)->type.transparent_union_flag)
+(ARRAY_TYPE_CHECK (NODE)->type.transparent_aggr_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)->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)
+/* The debug output functions use the symtab union field to store
+information specific to the debugging format.  The different debug
+output hooks store different types in the union field.  These three
+macros are used to access different fields in the union.  The debug
+hooks are responsible for consistently using only a specific
+macro.  */
+/* Symtab field as an integer.  Used by stabs generator in dbxout.c to
+hold the type's number in the generated stabs.  */
+#define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
+/* Symtab field as a string.  Used by COFF generator in sdbout.c to
+hold struct/union type tag names.  */
+#define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
+/* Symtab field as a pointer to a DWARF DIE.  Used by DWARF generator
+in dwarf2out.c to point to the DIE generated for the type.  */
+#define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
+/* The garbage collector needs to know the interpretation of the
+symtab field.  These constants represent the different types in the
+union.  */
+#define TYPE_SYMTAB_IS_ADDRESS (0)
+#define TYPE_SYMTAB_IS_POINTER (1)
+#define TYPE_SYMTAB_IS_DIE (2)
 struct die_struct;
 struct GTY(()) tree_type {
 struct tree_common common;
 unsigned int uid;
 unsigned int precision : 10;
 unsigned no_force_blk_flag : 1;
 unsigned needs_constructing_flag : 1;
-unsigned transparent_union_flag : 1;
+unsigned transparent_aggr_flag : 1;
 unsigned restrict_flag : 1;
 unsigned contains_placeholder_bits : 2;
 ENUM_BITFIELD(machine_mode) mode : 8;
 unsigned int align;
 alias_set_type alias_set;
 tree pointer_to;
 tree reference_to;
 union tree_type_symtab {
-int GTY ((tag ("0"))) address;
+int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address;
-const char * GTY ((tag ("1"))) pointer;
+const char * GTY ((tag ("TYPE_SYMTAB_IS_POINTER"))) pointer;
-struct die_struct * GTY ((tag ("2"))) die;
+struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die;
-} GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
+} GTY ((desc ("debug_hooks->tree_type_symtab_field"))) symtab;
-	  descbits ("2"))) symtab;
 tree name;
 tree minval;
 tree maxval;
 tree next_variant;
 tree main_variant;
 };
 #endif
 struct function;
+#define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE)))
 /* This is the name of the object as written by the user.
 It is an IDENTIFIER_NODE.  */
 #define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
 #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)))
+/* Every ..._DECL node gets a unique number that stays the same even
+when the decl is copied by the inliner once it is set.  */
+#define DECL_PT_UID(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.pt_uid == -1u \
+? (NODE)->decl_minimal.uid : (NODE)->decl_common.pt_uid)
+/* Initialize the ..._DECL node pt-uid to the decls uid.  */
+#define SET_DECL_PT_UID(NODE, UID) \
+(DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID))
+/* Whether the ..._DECL node pt-uid has been initialized and thus needs to
+be preserved when copyin the decl.  */
+#define DECL_PT_UID_SET_P(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u)
 /* 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_SOURCE_LOCATION(NODE) \
+(DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
 #define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
 #define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
 #define DECL_IS_BUILTIN(DECL) \
 (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
 nodes, this points to either the FUNCTION_DECL for the containing
 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)
+#define DECL_FIELD_CONTEXT(NODE) \
+(FIELD_DECL_CHECK (NODE)->decl_minimal.context)
+/* If nonzero, decl's name shouldn't be emitted into debug info.  */
+#define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.nameless_flag)
 struct GTY(()) tree_decl_minimal {
 struct tree_common common;
 location_t locus;
 unsigned int uid;
 tree name;
 decl node which this decl is an inlined/cloned instance of, or else it
 is NULL indicating that this decl is not an instance of some other decl.
 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)
+#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) \
 (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
 /* Nonzero for any sort of ..._DECL node means this decl node represents an
 inline instance of some original (abstract) decl from an inline function;
 suppress any warnings about shadowing some other variable.  FUNCTION_DECL
 nodes can also have their abstract origin set to themselves.  */
-#define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
+#define DECL_FROM_INLINE(NODE) \
-				&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
+(DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
+&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
 /* In a DECL this is the field where attributes are stored.  */
-#define DECL_ATTRIBUTES(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.attributes)
+#define DECL_ATTRIBUTES(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.attributes)
 /* For a FUNCTION_DECL, holds the tree of BINDINGs.
 For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
 For a VAR_DECL, holds the initial value.
 For a PARM_DECL, used for DECL_ARG_TYPE--default
 #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)->common.base.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_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.  Moreover, for a FUNCTION_DECL,
+be ignored for symbolic debug purposes.  For a TYPE_DECL, this means that
-the body of the function should also be ignored.  */
+the associated type should be ignored.  For a FUNCTION_DECL, the body of
-#define DECL_IGNORED_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
+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
 information, we mustn't try to generate any address information for nodes
 marked as "abstract instances" because we don't actually generate
 any code or allocate any data space for such instances.  */
-#define DECL_ABSTRACT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
+#define DECL_ABSTRACT(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
 /* Language-specific decl information.  */
-#define DECL_LANG_SPECIFIC(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
+#define DECL_LANG_SPECIFIC(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
 /* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
 do not allocate storage, and refer to a definition elsewhere.  Note that
 this does not necessarily imply the entity represented by NODE
 has no program source-level definition in this translation unit.  For
 For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
 Also set in some languages for variables, etc., outside the normal
 lexical scope, such as class instance variables.  */
-#define DECL_NONLOCAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
+#define DECL_NONLOCAL(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
 /* Used in VAR_DECLs to indicate that the variable is a vtable.
 Used in FIELD_DECLs for vtable pointers.
 Used in FUNCTION_DECLs to indicate that the function is virtual.  */
-#define DECL_VIRTUAL_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
+#define DECL_VIRTUAL_P(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
 /* Used to indicate that this DECL represents a compiler-generated entity.  */
-#define DECL_ARTIFICIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
+#define DECL_ARTIFICIAL(NODE) \
+(DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
 /* Additional flags for language-specific uses.  */
-#define DECL_LANG_FLAG_0(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
+#define DECL_LANG_FLAG_0(NODE) \
-#define DECL_LANG_FLAG_1(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
+(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
-#define DECL_LANG_FLAG_2(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
+#define DECL_LANG_FLAG_1(NODE) \
-#define DECL_LANG_FLAG_3(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
+(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
-#define DECL_LANG_FLAG_4(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
+#define DECL_LANG_FLAG_2(NODE) \
-#define DECL_LANG_FLAG_5(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
+(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
-#define DECL_LANG_FLAG_6(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
+#define DECL_LANG_FLAG_3(NODE) \
-#define DECL_LANG_FLAG_7(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
+(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
-#define DECL_LANG_FLAG_8(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8)
+#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)
+/* Nonzero for a scope which is equal to file scope.  */
+#define SCOPE_FILE_SCOPE_P(EXP)	\
+(! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL)
 /* Nonzero for a decl which is at file scope.  */
-#define DECL_FILE_SCOPE_P(EXP) 					\
+#define DECL_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP))
-(! DECL_CONTEXT (EXP)						\
+/* Nonzero for a type which is at file scope.  */
-|| TREE_CODE (DECL_CONTEXT (EXP)) == TRANSLATION_UNIT_DECL)
+#define TYPE_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP))
 /* Nonzero for a decl that is decorated using attribute used.
-This indicates compiler tools that this decl needs to be preserved.  */
+This indicates to compiler tools that this decl needs to be preserved.  */
 #define DECL_PRESERVE_P(DECL) \
 DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag
 /* For function local variables of COMPLEX and VECTOR types,
 indicates that the variable is not aliased, and that all
 /* 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_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.  */
+In VAR_DECL, PARM_DECL and RESULT_DECL, this is
+DECL_HAS_VALUE_EXPR_P.  */
 unsigned decl_flag_2 : 1;
 /* Logically, these two would go in a theoretical base shared by var and
 parm decl. */
 unsigned gimple_reg_flag : 1;
 /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE.  */
 unsigned decl_by_reference_flag : 1;
 /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_RESTRICTED_P.  */
 unsigned decl_restricted_flag : 1;
+/* In VAR_DECL and PARM_DECL set when the decl has been used except for
+being set.  */
+unsigned decl_read_flag : 1;
 /* Padding so that 'off_align' can be on a 32-bit boundary.  */
-unsigned decl_common_unused : 2;
+unsigned decl_common_unused : 1;
 /* 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;
+/* UID for points-to sets, stable over copying from inlining.  */
+unsigned int pt_uid;
 tree size_unit;
 tree initial;
 tree attributes;
 tree abstract_origin;
 /* 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_2)
+(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_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)			\
+#define SET_DECL_VALUE_EXPR(NODE, VAL) \
 (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
 /* Holds the RTL expression for the value of a variable or function.
 This value can be evaluated lazily for functions, variables with
 static storage duration, and labels.  */
 /* Returns nonzero if NODE is a tree node that can contain RTL.  */
 #define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))
 /* Returns nonzero if the DECL_RTL for NODE has already been set.  */
-#define DECL_RTL_SET_P(NODE)  (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
+#define DECL_RTL_SET_P(NODE) \
+(HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
 /* Copy the RTL from NODE1 to NODE2.  If the RTL was not set for
 NODE1, it will not be set for NODE2; this is a lazy copy.  */
 #define COPY_DECL_RTL(NODE1, NODE2) \
-(DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl = DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl)
+(DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl \
+= DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl)
 /* The DECL_RTL for NODE, if it is set, or NULL, if it is not set.  */
 #define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
 /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.  */
 /* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
 field from DECL_FIELD_OFFSET.  This field may be nonzero even for fields
 that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the
 natural alignment of the field's type).  */
-#define DECL_FIELD_BIT_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
+#define DECL_FIELD_BIT_OFFSET(NODE) \
+(FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
 /* In a FIELD_DECL, this indicates whether the field was a bit-field and
 if so, the type that was originally specified for it.
 TREE_TYPE may have been modified (in finish_struct).  */
-#define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
+#define DECL_BIT_FIELD_TYPE(NODE) \
+(FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
 /* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
 if nonzero, indicates that the field occupies the type.  */
 #define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
 #define DECL_OFFSET_ALIGN(NODE) \
 (((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.off_align = exact_log2 ((X) & -(X)))
+(FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1)
-/* 1 if the alignment for this type was requested by "aligned" attribute,
-0 if it is the default for this type.  */
 /* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
 which this FIELD_DECL is defined.  This information is needed when
 writing debugging information about vfield and vbase decls for C++.  */
 #define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
 which may be different from the type seen in the program.  */
 #define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)
 /* 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)
+#define DECL_INCOMING_RTL(NODE) \
+(PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
 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.  */
-#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
-(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
-/* Used to indicate that the linkage status of this DECL is not yet known,
-so it should not be output now.  */
-#define DECL_DEFER_OUTPUT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
 /* Nonzero for a given ..._DECL node means that no warnings should be
 generated just because this node is unused.  */
 #define DECL_IN_SYSTEM_HEADER(NODE) \
 (in_system_header_at (DECL_SOURCE_LOCATION (NODE)))
+/* Used to indicate that the linkage status of this DECL is not yet known,
+so it should not be output now.  */
+#define DECL_DEFER_OUTPUT(NODE) \
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
+/* 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)
+/* In a VAR_DECL that's static,
+nonzero if it belongs to the global constant pool.  */
+#define DECL_IN_CONSTANT_POOL(NODE) \
+(VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool)
+/* Nonzero for a given ..._DECL node means that this node should be
+put in .common, if possible.  If a DECL_INITIAL is given, and it
+is not error_mark_node, then the decl cannot be put in .common.  */
+#define DECL_COMMON(NODE) \
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
+/* In a VAR_DECL, nonzero if the decl is a register variable with
+an explicit asm specification.  */
+#define DECL_HARD_REGISTER(NODE)  \
+(VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
 /* Used to indicate that this DECL has weak linkage.  */
 #define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
 /* Used to indicate that the DECL is a dllimport.  */
-#define DECL_DLLIMPORT_P(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
+#define DECL_DLLIMPORT_P(NODE) \
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
 /* 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
 unit that needs them, and therefore need not be put out anywhere
 where they are not needed.  DECL_COMDAT is just a hint to the
 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(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)
+#define DECL_COMDAT_GROUP(NODE) \
-/* A replaceable function is one which may be replaced at link-time
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_group)
-with an entirely different definition, provided that the
-replacement has the same type.  For example, functions declared
+/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
-with __attribute__((weak)) on most systems are replaceable.
+multiple translation units should be merged.  */
+#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE)
-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.  */
 #define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
 /* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set.  If zero,
 the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
 yet.  */
 #define DECL_ASSEMBLER_NAME_SET_P(NODE) \
-(HAS_DECL_ASSEMBLER_NAME_P (NODE) &&  DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name != NULL_TREE)
+(HAS_DECL_ASSEMBLER_NAME_P (NODE) \
+&& DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name != NULL_TREE)
 /* Set the DECL_ASSEMBLER_NAME for NODE to NAME.  */
 #define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
 (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name = (NAME))
 				     DECL_ASSEMBLER_NAME (DECL1))	\
 : (void) 0)
 /* Records the section name in a section attribute.  Used to pass
 the name from decl_attributes to make_function_rtl and make_decl_rtl.  */
-#define DECL_SECTION_NAME(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name)
+#define DECL_SECTION_NAME(NODE) \
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name)
+/* Nonzero in a decl means that the gimplifier has seen (or placed)
+this variable in a BIND_EXPR.  */
+#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
 /* Value of the decls's visibility attribute */
-#define DECL_VISIBILITY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
+#define DECL_VISIBILITY(NODE) \
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
 /* Nonzero means that the decl had its visibility specified rather than
 being inferred.  */
-#define DECL_VISIBILITY_SPECIFIED(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
+#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.  */
+/* In a VAR_DECL, the model to use if the data should be allocated from
-#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE)
+thread-local storage.  */
+#define DECL_TLS_MODEL(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model)
+/* 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)
+/* 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)
+/* Specify whether the section name was set by user or by
+compiler via -ffunction-sections.  */
+#define DECL_HAS_IMPLICIT_SECTION_NAME_P(NODE) \
+(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.implicit_section_name_p)
 struct GTY(()) tree_decl_with_vis {
 struct tree_decl_with_rtl common;
 tree assembler_name;
 tree section_name;
 unsigned defer_output : 1;
 unsigned hard_register : 1;
 unsigned thread_local : 1;
 unsigned common_flag : 1;
 unsigned in_text_section : 1;
+unsigned in_constant_pool : 1;
 unsigned dllimport_flag : 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 seen_in_bind_expr : 1;
 unsigned comdat_flag : 1;
 /* Belongs to VAR_DECL exclusively.  */
 ENUM_BITFIELD(tls_model) tls_model : 3;
 /* Belong to FUNCTION_DECL exclusively.  */
 unsigned init_priority_p : 1;
-/* 15 unused bits. */
+/* Used by C++ only.  Might become a generic decl flag.  */
+unsigned shadowed_for_var_p : 1;
+/* When SECTION_NAME is implied by -ffunsection-section.  */
+unsigned implicit_section_name_p : 1;
+/* 13 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)
-/* Nonzero for a given ..._DECL node means that this node should be
-put in .common, if possible.  If a DECL_INITIAL is given, and it
-is not error_mark_node, then the decl cannot be put in .common.  */
-#define DECL_COMMON(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
-/* In a VAR_DECL, nonzero if the decl is a register variable with
-an explicit asm specification.  */
-#define DECL_HARD_REGISTER(NODE)  (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
 extern tree decl_debug_expr_lookup (tree);
 extern void decl_debug_expr_insert (tree, tree);
 /* For VAR_DECL, this is set to either an expression that it was split
 from (if DECL_DEBUG_EXPR_IS_FROM is true), otherwise a tree_list of
 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 (NODE))
 /* Set the initialization priority for NODE to VAL.  */
 /* 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.  */
-#define DECL_TLS_MODEL(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model)
-/* 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)
 #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)
 };
 /* This field is used to reference anything in decl.result and is meant only
 for use by the garbage collector.  */
-#define DECL_RESULT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
+#define DECL_RESULT_FLD(NODE) \
+(DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
 /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
 Before the struct containing the FUNCTION_DECL is laid out,
 DECL_VINDEX may point to a FUNCTION_DECL in a base class which
 is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
 function.  When the class is laid out, this pointer is changed
 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)
+#define DECL_VINDEX(NODE) \
+(DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex)
 struct GTY(())
 tree_decl_non_common {
 struct tree_decl_with_vis common;
 /* C++ uses this in namespaces.  */
 /* In FUNCTION_DECL, holds the decl for the return value.  */
 #define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
 /* In a FUNCTION_DECL, nonzero if the function cannot be inlined.  */
-#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
+#define DECL_UNINLINABLE(NODE) \
+(FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
 /* In a FUNCTION_DECL, the saved representation of the body of the
 entire function.  */
-#define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.saved_tree)
+#define DECL_SAVED_TREE(NODE) \
+(FUNCTION_DECL_CHECK (NODE)->decl_non_common.saved_tree)
 /* Nonzero in a FUNCTION_DECL means this function should be treated
 as if it were a malloc, meaning it returns a pointer that is
 not an alias.  */
-#define DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
+#define DECL_IS_MALLOC(NODE) \
+(FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
 /* Nonzero in a FUNCTION_DECL means this function should be treated as
 C++ operator new, meaning that it returns a pointer for which we
 should not use type based aliasing.  */
 #define DECL_IS_OPERATOR_NEW(NODE) \
 (FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag)
 /* Nonzero in a FUNCTION_DECL means this function should be treated
 as "novops" function (function that does not read global memory,
 but may have arbitrary side effects).  */
-#define DECL_IS_NOVOPS(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
+#define DECL_IS_NOVOPS(NODE) \
+(FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
 /* Used in FUNCTION_DECLs to indicate that they should be run automatically
 at the beginning or end of execution.  */
 #define DECL_STATIC_CONSTRUCTOR(NODE) \
 (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)
 #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)
+#define DECL_STRUCT_FUNCTION(NODE) \
+(FUNCTION_DECL_CHECK (NODE)->function_decl.f)
 /* In a FUNCTION_DECL, nonzero means a built in function.  */
 #define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
 /* For a builtin function, identify which part of the compiler defined it.  */
 (FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
 /* In FUNCTION_DECL, a chain of ..._DECL nodes.
 VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
 uses.  */
-#define DECL_ARGUMENTS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.arguments)
+#define DECL_ARGUMENTS(NODE) \
-#define DECL_ARGUMENT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments)
+(FUNCTION_DECL_CHECK (NODE)->decl_non_common.arguments)
+#define DECL_ARGUMENT_FLD(NODE) \
+(DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments)
 /* In FUNCTION_DECL, the function specific target options to use when compiling
 this function.  */
 #define DECL_FUNCTION_SPECIFIC_TARGET(NODE) \
 (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target)
 /* 3 bits left */
 };
+/* The source language of the translation-unit.  */
+#define TRANSLATION_UNIT_LANGUAGE(NODE) \
+(TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language)
+/* TRANSLATION_UNIT_DECL inherits from DECL_MINIMAL.  */
+struct GTY(()) tree_translation_unit_decl {
+struct tree_decl_common common;
+/* Source language of this translation unit.  Used for DWARF output.  */
+const char * GTY((skip(""))) language;
+/* TODO: Non-optimization used to build this translation unit.  */
+/* TODO: Root of a partial DWARF tree for global types and decls.  */
+};
+/* A vector of all translation-units.  */
+extern GTY (()) VEC(tree,gc) *all_translation_units;
 /* For a TYPE_DECL, holds the "original" type.  (TREE_TYPE has the copy.) */
-#define DECL_ORIGINAL_TYPE(NODE) (TYPE_DECL_CHECK (NODE)->decl_non_common.result)
+#define DECL_ORIGINAL_TYPE(NODE) \
+(TYPE_DECL_CHECK (NODE)->decl_non_common.result)
 /* 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) \
 /* Define the overall contents of a tree node.
 It may be any of the structures declared above
 for various types of node.  */
 union GTY ((ptr_alias (union lang_tree_node),
-		      desc ("tree_node_structure (&%h)"))) tree_node {
+	    desc ("tree_node_structure (&%h)"), variable_size)) 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_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl;
 struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl;
 struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl;
 struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl;
 struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl;
+struct tree_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL")))
+translation_unit_decl;
 struct tree_type GTY ((tag ("TS_TYPE"))) type;
 struct tree_list GTY ((tag ("TS_LIST"))) list;
 struct tree_vec GTY ((tag ("TS_VEC"))) vec;
 struct tree_exp GTY ((tag ("TS_EXP"))) exp;
 struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name;
 TI_UINT32_TYPE,
 TI_UINT64_TYPE,
 TI_INTEGER_ZERO,
 TI_INTEGER_ONE,
+TI_INTEGER_THREE,
 TI_INTEGER_MINUS_ONE,
 TI_NULL_POINTER,
 TI_SIZE_ZERO,
 TI_SIZE_ONE,
 #define uint32_type_node		global_trees[TI_UINT32_TYPE]
 #define uint64_type_node		global_trees[TI_UINT64_TYPE]
 #define integer_zero_node		global_trees[TI_INTEGER_ZERO]
 #define integer_one_node		global_trees[TI_INTEGER_ONE]
+#define integer_three_node              global_trees[TI_INTEGER_THREE]
 #define integer_minus_one_node		global_trees[TI_INTEGER_MINUS_ONE]
 #define size_zero_node			global_trees[TI_SIZE_ZERO]
 #define size_one_node			global_trees[TI_SIZE_ONE]
 #define bitsize_zero_node		global_trees[TI_BITSIZE_ZERO]
 #define bitsize_one_node		global_trees[TI_BITSIZE_ONE]
 no TREE_CHAIN.  Language-independent code should not assume
 anything else about this node.  */
 #define void_list_node                  global_trees[TI_VOID_LIST_NODE]
 #define main_identifier_node		global_trees[TI_MAIN_IDENTIFIER]
-#define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
+#define MAIN_NAME_P(NODE) \
+(IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
 /* Optimization options (OPTIMIZATION_NODE) to use for default and current
 functions.  */
 #define optimization_default_node	global_trees[TI_OPTIMIZATION_DEFAULT]
 #define optimization_current_node	global_trees[TI_OPTIMIZATION_CURRENT]
 itk_unsigned_int,
 itk_long,
 itk_unsigned_long,
 itk_long_long,
 itk_unsigned_long_long,
+itk_int128,
+itk_unsigned_int128,
 itk_none
 };
 typedef enum integer_type_kind integer_type_kind;
 #define unsigned_type_node		integer_types[itk_unsigned_int]
 #define long_integer_type_node		integer_types[itk_long]
 #define long_unsigned_type_node		integer_types[itk_unsigned_long]
 #define long_long_integer_type_node	integer_types[itk_long_long]
 #define long_long_unsigned_type_node	integer_types[itk_unsigned_long_long]
+#define int128_integer_type_node	integer_types[itk_int128]
-/* Set to the default thread-local storage (tls) model to use.  */
+#define int128_unsigned_type_node	integer_types[itk_unsigned_int128]
-extern enum tls_model flag_tls_default;
 /* A pointer-to-function member type looks like:
 struct {
 __P __pfn;
 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 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);
 extern tree build6_stat (enum tree_code, tree, tree, tree, tree, tree,
 			 tree, tree MEM_STAT_DECL);
 #define build6(c,t1,t2,t3,t4,t5,t6,t7) \
 build6_stat (c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO)
+/* _loc versions of build[1-6].  */
+static inline tree
+build1_stat_loc (location_t loc, enum tree_code code, tree type,
+		 tree arg1 MEM_STAT_DECL)
+{
+tree t = build1_stat (code, type, arg1 PASS_MEM_STAT);
+if (CAN_HAVE_LOCATION_P (t))
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
+#define build1_loc(l,c,t1,t2) build1_stat_loc (l,c,t1,t2 MEM_STAT_INFO)
+static inline tree
+build2_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+		 tree arg1 MEM_STAT_DECL)
+{
+tree t = build2_stat (code, type, arg0, arg1 PASS_MEM_STAT);
+if (CAN_HAVE_LOCATION_P (t))
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
+#define build2_loc(l,c,t1,t2,t3) build2_stat_loc (l,c,t1,t2,t3 MEM_STAT_INFO)
+static inline tree
+build3_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+		 tree arg1, tree arg2 MEM_STAT_DECL)
+{
+tree t = build3_stat (code, type, arg0, arg1, arg2 PASS_MEM_STAT);
+if (CAN_HAVE_LOCATION_P (t))
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
+#define build3_loc(l,c,t1,t2,t3,t4) \
+build3_stat_loc (l,c,t1,t2,t3,t4 MEM_STAT_INFO)
+static inline tree
+build4_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+		 tree arg1, tree arg2, tree arg3 MEM_STAT_DECL)
+{
+tree t = build4_stat (code, type, arg0, arg1, arg2, arg3 PASS_MEM_STAT);
+if (CAN_HAVE_LOCATION_P (t))
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
+#define build4_loc(l,c,t1,t2,t3,t4,t5) \
+build4_stat_loc (l,c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
+static inline tree
+build5_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+		 tree arg1, tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
+{
+tree t = build5_stat (code, type, arg0, arg1, arg2, arg3,
+			arg4 PASS_MEM_STAT);
+if (CAN_HAVE_LOCATION_P (t))
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
+#define build5_loc(l,c,t1,t2,t3,t4,t5,t6) \
+build5_stat_loc (l,c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
+static inline tree
+build6_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+		 tree arg1, tree arg2, tree arg3, tree arg4,
+		 tree arg5 MEM_STAT_DECL)
+{
+tree t = build6_stat (code, type, arg0, arg1, arg2, arg3, arg4,
+			arg5 PASS_MEM_STAT);
+if (CAN_HAVE_LOCATION_P (t))
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
+#define build6_loc(l,c,t1,t2,t3,t4,t5,t6,t7) \
+build6_stat_loc (l,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)
+/* Constructs double_int from tree CST.  */
+static inline double_int
+tree_to_double_int (const_tree cst)
+{
+return TREE_INT_CST (cst);
+}
+extern tree double_int_to_tree (tree, double_int);
+extern bool double_int_fits_to_tree_p (const_tree, double_int);
+extern tree force_fit_type_double (tree, double_int, int, bool);
+/* Create an INT_CST node with a CST value zero extended.  */
+static inline tree
+build_int_cstu (tree type, unsigned HOST_WIDE_INT cst)
+{
+return double_int_to_tree (type, uhwi_to_double_int (cst));
+}
 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_vector_from_val (tree, tree);
 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, const_tree);
 extern tree build_complex (tree, tree, tree);
 extern tree build_one_cst (tree);
+extern tree build_zero_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_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(l,c,t,q) build_decl_stat (l,c,t,q MEM_STAT_INFO)
+extern tree build_translation_unit_decl (tree);
 extern tree build_block (tree, tree, tree, tree);
 extern tree build_empty_stmt (location_t);
 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);
 #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 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);
+extern void initialize_sizetypes (void);
 extern void set_sizetype (tree);
 extern void fixup_unsigned_type (tree);
 extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool);
 extern tree build_pointer_type (tree);
 extern tree build_reference_type_for_mode (tree, enum machine_mode, bool);
 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_nonshared_array_type (tree, tree);
 extern tree build_function_type (tree, tree);
 extern tree build_function_type_list (tree, ...);
 extern tree build_function_type_skip_args (tree, bitmap);
 extern tree build_function_decl_skip_args (tree, bitmap);
 extern tree build_varargs_function_type_list (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 bool vec_member (const_tree, VEC(tree,gc) *);
 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 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 int host_integerp (const_tree, int)
+#ifndef ENABLE_TREE_CHECKING
+ATTRIBUTE_PURE /* host_integerp is pure only when checking is disabled.  */
+#endif
+;
 extern HOST_WIDE_INT tree_low_cst (const_tree, int);
+#if !defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 4003)
+extern inline __attribute__ ((__gnu_inline__)) HOST_WIDE_INT
+tree_low_cst (const_tree t, int pos)
+{
+gcc_assert (host_integerp (t, pos));
+return TREE_INT_CST_LOW (t);
+}
+#endif
 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 unsigned int tree_int_cst_min_precision (tree, bool);
 extern bool tree_expr_nonnegative_p (tree);
 /* Like get_qualified_type, but creates the type if it does not
 exist.  This function never returns NULL_TREE.  */
 extern tree build_qualified_type (tree, int);
+/* Create a variant of type T with alignment ALIGN.  */
+extern tree build_aligned_type (tree, unsigned int);
 /* Like build_qualified_type, but only deals with the `const' and
 `volatile' qualifiers.  This interface is retained for backwards
 compatibility with the various front-ends; new code should use
 build_qualified_type instead.  */
 unsigned int unpacked_align;
 /* The previous field layed out.  */
 tree prev_field;
 /* The static variables (i.e., class variables, as opposed to
 instance variables) encountered in T.  */
-tree pending_statics;
+VEC(tree,gc) *pending_statics;
 /* Bits remaining in the current alignment group */
 int remaining_in_alignment;
 /* True if we've seen a packed field that didn't have normal
 alignment anyway.  */
 int packed_maybe_necessary;
 #define round_up(T,N) round_up_loc (UNKNOWN_LOCATION, T, N)
 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 VEC(tree,gc) *get_pending_sizes (void);
 extern void put_pending_size (tree);
-extern void put_pending_sizes (tree);
+extern void put_pending_sizes (VEC(tree,gc) *);
 extern void finalize_size_functions (void);
 /* Type for sizes of data-type.  */
 #define BITS_PER_UNIT_LOG \
 + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
 + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))
 /* If nonzero, an upper limit on alignment of structure fields, in bits,  */
 extern unsigned int maximum_field_alignment;
-/* and its original value in bytes, specified via -fpack-struct=<value>.  */
-extern unsigned int initial_max_fld_align;
 /* Concatenate two lists (chains of TREE_LIST nodes) X and Y
 by making the last node in X point to Y.
 Returns X, except if X is 0 returns Y.  */
 /* Returns the number of FIELD_DECLs in a type.  */
 extern int fields_length (const_tree);
+/* Returns the first FIELD_DECL in a type.  */
+extern tree first_field (const_tree);
 /* Given an initializer INIT, return TRUE if INIT is zero or some
 aggregate of zeros.  Otherwise return FALSE.  */
 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);
 /* Return which tree structure is used by T.  */
 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
+/* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
-or offset that depends on a field within a record.
+size or offset that depends on a field within a record.  */
-Note that we only allow such expressions within simple arithmetic
-or a COND_EXPR.  */
 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.  */
 #define CONTAINS_PLACEHOLDER_P(EXP) \
 ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
-/* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
+/* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
-This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
+directly.  This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
-positions.  */
+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
 /* 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)
+function_args_iter_init (function_args_iterator *i, const_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.  */
 extern tree get_file_function_name (const char *);
 extern tree get_callee_fndecl (const_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 bool commutative_ternary_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 (location_t);
 extern const char *get_name (tree);
-extern bool stdarg_p (tree);
+extern bool stdarg_p (const_tree);
 extern bool prototype_p (tree);
+extern bool is_typedef_decl (tree x);
+extern bool typedef_variant_p (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);
+extern void assign_assembler_name_if_neeeded (tree);
+extern void warn_deprecated_use (tree, tree);
 /* In cgraph.c */
 extern void change_decl_assembler_name (tree, tree);
 /* In gimplify.c */
 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 fold_fma (location_t, tree, 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,
-			    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 *,
-				 bool);
-#define add_double(l1,h1,l2,h2,lv,hv) \
-add_double_with_sign (l1, h1, l2, h2, lv, hv, false)
-extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-		       unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
-extern int mul_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-				 unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-				 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
-				 bool);
-#define mul_double(l1,h1,l2,h2,lv,hv) \
-mul_double_with_sign (l1, h1, l2, h2, lv, hv, false)
-extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-			   HOST_WIDE_INT, unsigned int,
-			   unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
-extern void rshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-			   HOST_WIDE_INT, unsigned int,
-			   unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
-extern void lrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-			    HOST_WIDE_INT, unsigned int,
-			    unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
-extern void rrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-			    HOST_WIDE_INT, unsigned int,
-			    unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
-extern int div_and_round_double (enum tree_code, int, unsigned HOST_WIDE_INT,
-				 HOST_WIDE_INT, unsigned HOST_WIDE_INT,
-				 HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
-				 HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
-				 HOST_WIDE_INT *);
 enum operand_equal_flag
 {
 OEP_ONLY_CONST = 1,
 OEP_PURE_SAME = 2
 build_fold_indirect_ref_loc (UNKNOWN_LOCATION, T)
 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 build_simple_mem_ref_loc (location_t, tree);
+#define build_simple_mem_ref(T)\
+	build_simple_mem_ref_loc (UNKNOWN_LOCATION, T)
+extern double_int mem_ref_offset (const_tree);
+extern tree reference_alias_ptr_type (const_tree);
 extern tree constant_boolean_node (int, tree);
 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);
 				     enum built_in_function);
 extern tree fold_builtin_strncpy_chk (location_t, tree, tree, tree, tree, tree);
 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 (location_t, tree, tree);
 extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *);
-#define build_call_expr(...)\
+extern tree build_call_expr_loc_array (location_t, tree, int, tree *);
-build_call_expr_loc (UNKNOWN_LOCATION, __VA_ARGS__)
+extern tree build_call_expr_loc_vec (location_t, tree, VEC(tree,gc) *);
 extern tree build_call_expr_loc (location_t, tree, int, ...);
+extern tree build_call_expr (tree, int, ...);
 extern tree mathfn_built_in (tree, enum built_in_function fn);
 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 unsigned 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 unsigned int get_object_alignment (tree, 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);
+extern bool is_simple_builtin (tree);
+extern bool is_inexpensive_builtin (tree);
 /* In convert.c */
 extern tree strip_float_extensions (tree);
 /* In tree.c */
 extern int really_constant_p (const_tree);
 extern bool decl_address_invariant_p (const_tree);
 extern bool decl_address_ip_invariant_p (const_tree);
-extern int int_fits_type_p (const_tree, const_tree);
+extern bool int_fits_type_p (const_tree, const_tree);
 #ifndef GENERATOR_FILE
 extern void get_type_static_bounds (const_tree, mpz_t, mpz_t);
 #endif
 extern bool variably_modified_type_p (tree, tree);
 extern int tree_log2 (const_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 (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 tree build_nonshared_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 HOST_WIDEST_INT widest_int_cst_value (const_tree);
 extern bool fields_compatible_p (const_tree, const_tree);
 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);
+extern tree get_binfo_at_offset (tree, HOST_WIDE_INT, tree);
 /* In tree-nested.c */
 extern tree build_addr (tree, tree);
 /* In function.c */
 extern void print_rtl (FILE *, const_rtx);
 #endif
 /* In print-tree.c */
 extern void debug_tree (tree);
+extern void debug_vec_tree (VEC(tree,gc) *);
 #ifdef BUFSIZ
 extern void dump_addr (FILE*, const char *, const void *);
 extern void print_node (FILE *, const char *, tree, int);
+extern void print_vec_tree (FILE *, const char *, VEC(tree,gc) *, int);
 extern void print_node_brief (FILE *, const char *, const_tree, int);
 extern void indent_to (FILE *, int);
 #endif
 /* In tree-inline.c:  */
 /* Nonzero if this call replaces the current stack frame.  */
 #define ECF_SIBCALL		  (1 << 8)
 /* Function does not read or write memory (but may have side effects, so
 it does not necessarily fit ECF_CONST).  */
 #define ECF_NOVOPS		  (1 << 9)
+/* The function does not lead to calls within current function unit.  */
+#define ECF_LEAF		  (1 << 10)
 extern int flags_from_decl_or_type (const_tree);
 extern int call_expr_flags (const_tree);
+/* Call argument flags.  */
+/* Nonzero if the argument is not dereferenced recursively, thus only
+directly reachable memory is read or written.  */
+#define EAF_DIRECT		(1 << 0)
+/* Nonzero if memory reached by the argument is not clobbered.  */
+#define EAF_NOCLOBBER		(1 << 1)
+/* Nonzero if the argument does not escape.  */
+#define EAF_NOESCAPE		(1 << 2)
+/* Nonzero if the argument is not used by the function.  */
+#define EAF_UNUSED		(1 << 3)
+/* Call return flags.  */
+/* Mask for the argument number that is returned.  Lower two bits of
+the return flags, encodes argument slots zero to three.  */
+#define ERF_RETURN_ARG_MASK	(3)
+/* Nonzero if the return value is equal to the argument number
+flags & ERF_RETURN_ARG_MASK.  */
+#define ERF_RETURNS_ARG		(1 << 2)
+/* Nonzero if the return value does not alias with anything.  Functions
+with the malloc attribute have this set on their return value.  */
+#define ERF_NOALIAS		(1 << 3)
 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);
 /* In attribs.c.  */
-extern const struct attribute_spec *lookup_attribute_spec (tree);
+extern const struct attribute_spec *lookup_attribute_spec (const_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
 unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
 extern void fixup_signed_type (tree);
 extern void internal_reference_types (void);
 extern unsigned int update_alignment_for_field (record_layout_info, tree,
 unsigned int);
 /* varasm.c */
+extern tree tree_output_constant_def (tree);
 extern void make_decl_rtl (tree);
+extern rtx make_decl_rtl_for_debug (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);
+extern bool decl_replaceable_p (tree);
+extern bool decl_binds_to_current_def_p (tree);
+/* Derived type for use by compute_visible_aliases and callers.  A symbol
+alias set is a pointer set into which we enter IDENTIFIER_NODES bearing
+the canonicalised assembler-level symbol names corresponding to decls
+and their aliases.  */
+typedef struct pointer_set_t symbol_alias_set_t;
+extern void symbol_alias_set_destroy (symbol_alias_set_t *);
+extern int symbol_alias_set_contains (const symbol_alias_set_t *, tree);
+extern symbol_alias_set_t * propagate_aliases_backward (bool (*)
+							 (tree, tree, void *),
+							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_stmt (gimple);
 extern tree resolve_asm_operand_names (tree, tree, tree, tree);
+extern bool expand_switch_using_bit_tests_p (tree, tree, unsigned int,
+					     unsigned int);
 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 *);
 s_kind,
 r_kind,
 e_kind,
 c_kind,
 id_kind,
-perm_list_kind,
-temp_list_kind,
 vec_kind,
 binfo_kind,
 ssa_name_kind,
 constr_kind,
 x_kind,
 /* 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 GTY(()) tree_map_base {
 tree from;
 };
 #define tree_map_eq tree_map_base_eq
 extern unsigned int tree_map_hash (const void *);
 #define tree_map_marked_p tree_map_base_marked_p
+/* Map from a decl tree to another tree.  */
+struct GTY(()) tree_decl_map {
+struct tree_map_base base;
+tree to;
+};
+#define tree_decl_map_eq tree_map_base_eq
+extern unsigned int tree_decl_map_hash (const void *);
+#define tree_decl_map_marked_p tree_map_base_marked_p
 /* Map from a tree to an int.  */
 struct GTY(()) tree_int_map {
 struct tree_map_base base;
 unsigned int to;
 /* 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 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
 /* 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 GTY (()) call_expr_arg_iterator_d {
+typedef struct 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 GTY (()) const_call_expr_arg_iterator_d {
+typedef struct 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;
 is_lang_specific (tree t)
 {
 return TREE_CODE (t) == LANG_TYPE || TREE_CODE (t) >= NUM_TREE_CODES;
 }
+/* In gimple-low.c.  */
+extern bool block_may_fallthru (const_tree);
 #endif  /* GCC_TREE_H  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree.h @ 69:1b10fe6932e1