[RFC][4.4] Convenience reorganization of parts of tree.h

[simonb at google dot com (Simon Baldwin)]

Hoist tree.h data structures to the top of the file, so that they're ahead
of their accessor macros.  This change is in preparation for the daunting
task of trying to turn some of these accessor macros into inline functions.

At present, structure field accessor macros are generally located ahead of
the data structure that they access, and many accessors also rely on union
tree_node being available to make them syntactically correct when expanded
into code.  By moving the structure and union definitions to the top of the
header file, it becomes possible to turn accessor macros into static inline
functions largely in-situ, using semi-mechanical methods; something not
possible with the current organization of tree.h.

Also, replace a couple of constant integral macro definitions with equivalent
enums, the CODE_CONTAINS_STRUCT macro with a static inline function, add a
tree cast to the &%h GTY entry for struct gimple_stmt, and add parentheses
around a switch target in tree-ssa-pre.c create_component_ref_by_pieces().

This is a readability patch, with no runtime effects.  It's almost all internal
reorganization only of tree.h.  Targetted for gcc 4.4, rather than 4.3.

Tested with bootstrap of C and C++ on linux i386.  Okay?


gcc/Changelog
2007-11-27  Simon Baldwin  <simonb@google.com>

	* tree.h (MAX_TREE_CODES): Converted from macro to enum.
	(NUM_TREE_CODES): Ditto.
	(CODE_CONTAINS_STRUCT): Converted from macro to static inline function.
	(enum tree_code, enum omp_clause_code, struct tree_base,
	struct real_value, struct tree_vector, struct tree_list,
	struct tree_vec, struct tree_constructor, struct tree_exp,
	struct tree_ssa_name, struct tree_phi_node, struct varray_head_tag,
	struct tree_block, struct tree_type, struct tree_binfo,
	struct function, struct tree_decl_minimal,
	struct tree_struct_field_tag, struct tree_memory_partition_tag,
	struct tree_decl_with_rtl, struct tree_field_decl,
	struct tree_const_decl, struct tree_var_decl,
	struct tree_decl_non_common, struct tree_function_decl,
	struct tree_type_decl, union tree_node): Hoisted structure and union
	definitions and declarations to the head of the file.
	* tree-ssa-pre.c (create_component_ref_by_pieces): Added parentheses
	around switch statement target expression.


Index: gcc/tree.h
===================================================================
*** gcc/tree.h	(revision 130472)
--- gcc/tree.h	(working copy)
*************** along with GCC; see the file COPYING3.  
*** 29,34 ****
--- 29,36 ----
  #include "double-int.h"
  #include "alias.h"
  
+ #include "symtab.h"
+ 
  /* Codes of tree nodes */
  
  #define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
*************** enum tree_code {
*** 42,293 ****
  
  #undef DEFTREECODE
  
! #define MAX_TREE_CODES 512
! extern unsigned char tree_contains_struct[MAX_TREE_CODES][64];
! #define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)])
! 
! /* Number of language-independent tree codes.  */
! #define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)
  
! /* Tree code classes.  */
  
! /* Each tree_code has an associated code class represented by a
!    TREE_CODE_CLASS.  */
  
! enum tree_code_class {
!   tcc_exceptional, /* An exceptional code (fits no category).  */
!   tcc_constant,    /* A constant.  */
!   /* Order of tcc_type and tcc_declaration is important.  */
!   tcc_type,        /* A type object code.  */
!   tcc_declaration, /* A declaration (also serving as variable refs).  */
!   tcc_reference,   /* A reference to storage.  */
!   tcc_comparison,  /* A comparison expression.  */
!   tcc_unary,       /* A unary arithmetic expression.  */
!   tcc_binary,      /* A binary arithmetic expression.  */
!   tcc_statement,   /* A statement expression, which have side effects
! 		      but usually no interesting value.  */
!   tcc_vl_exp,      /* A function call or other expression with a
! 		      variable-length operand vector.  */
!   tcc_expression,  /* Any other expression.  */
!   tcc_gimple_stmt  /* A GIMPLE statement.  */
! };
  
! /* Each tree code class has an associated string representation.
!    These must correspond to the tree_code_class entries.  */
  
! extern const char *const tree_code_class_strings[];
  
! /* Returns the string representing CLASS.  */
  
! #define TREE_CODE_CLASS_STRING(CLASS)\
!         tree_code_class_strings[(int) (CLASS)]
  
! extern const enum tree_code_class tree_code_type[];
! #define TREE_CODE_CLASS(CODE)	tree_code_type[(int) (CODE)]
  
! /* Nonzero if CODE represents an exceptional code.  */
  
! #define EXCEPTIONAL_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional)
  
! /* Nonzero if CODE represents a constant.  */
  
! #define CONSTANT_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant)
  
! /* Nonzero if CODE represents a type.  */
  
! #define TYPE_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type)
  
! /* 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) == STRUCT_FIELD_TAG		\
!    || 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)
  
! /* 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) == 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)
  
! /* Nonzero if CODE represents a comparison.  */
  
! #define COMPARISON_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison)
  
! /* Nonzero if CODE represents a unary arithmetic expression.  */
  
! #define UNARY_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary)
  
! /* Nonzero if CODE represents a binary arithmetic expression.  */
  
! #define BINARY_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary)
  
! /* Nonzero if CODE represents a statement expression.  */
  
! #define STATEMENT_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement)
  
! /* Nonzero if CODE represents a function call-like expression with a
!    variable-length operand vector.  */
  
! #define VL_EXP_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_vl_exp)
  
! /* Nonzero if CODE represents any other expression.  */
  
! #define EXPRESSION_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression)
  
! /* Returns nonzero iff CODE represents a type or declaration.  */
  
! #define IS_TYPE_OR_DECL_P(CODE)\
! 	(TYPE_P (CODE) || DECL_P (CODE))
  
! /* Returns nonzero iff CLASS is the tree-code class of an
!    expression.  */
  
! #define IS_EXPR_CODE_CLASS(CLASS)\
! 	((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
  
! /* Returns nonzer iff CLASS is a GIMPLE statement.  */
  
! #define IS_GIMPLE_STMT_CODE_CLASS(CLASS) ((CLASS) == tcc_gimple_stmt)
  
! /* Returns nonzero iff NODE is an expression of some kind.  */
  
! #define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
  
! /* Returns nonzero iff NODE is an OpenMP directive.  */
  
! #define OMP_DIRECTIVE_P(NODE)				\
!     (TREE_CODE (NODE) == OMP_PARALLEL			\
!      || TREE_CODE (NODE) == OMP_FOR			\
!      || TREE_CODE (NODE) == OMP_SECTIONS		\
!      || TREE_CODE (NODE) == OMP_SECTIONS_SWITCH		\
!      || TREE_CODE (NODE) == OMP_SINGLE			\
!      || TREE_CODE (NODE) == OMP_SECTION			\
!      || TREE_CODE (NODE) == OMP_MASTER			\
!      || TREE_CODE (NODE) == OMP_ORDERED			\
!      || TREE_CODE (NODE) == OMP_CRITICAL		\
!      || TREE_CODE (NODE) == OMP_RETURN			\
!      || TREE_CODE (NODE) == OMP_ATOMIC_LOAD                            \
!      || TREE_CODE (NODE) == OMP_ATOMIC_STORE                           \
!      || TREE_CODE (NODE) == OMP_CONTINUE)
  
! /* Number of argument-words in each kind of tree-node.  */
  
! extern const unsigned char tree_code_length[];
! #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);
  
! 
! /* 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
  {
!   NOT_BUILT_IN = 0,
!   BUILT_IN_FRONTEND,
!   BUILT_IN_MD,
!   BUILT_IN_NORMAL
  };
  
! /* Names for the above.  */
! extern const char *const built_in_class_names[4];
  
! /* Codes that identify the various built in functions
!    so that expand_call can identify them quickly.  */
  
! #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM,
! enum built_in_function
  {
! #include "builtins.def"
  
!   /* Complex division routines in libgcc.  These are done via builtins
!      because emit_library_call_value can't handle complex values.  */
!   BUILT_IN_COMPLEX_MUL_MIN,
!   BUILT_IN_COMPLEX_MUL_MAX
!     = BUILT_IN_COMPLEX_MUL_MIN
!       + MAX_MODE_COMPLEX_FLOAT
!       - MIN_MODE_COMPLEX_FLOAT,
  
!   BUILT_IN_COMPLEX_DIV_MIN,
!   BUILT_IN_COMPLEX_DIV_MAX
!     = BUILT_IN_COMPLEX_DIV_MIN
!       + MAX_MODE_COMPLEX_FLOAT
!       - MIN_MODE_COMPLEX_FLOAT,
  
!   /* Upper bound on non-language-specific builtins.  */
!   END_BUILTINS
  };
- #undef DEF_BUILTIN
  
! /* Names for the above.  */
! extern const char * built_in_names[(int) END_BUILTINS];
  
! /* Helper macros for math builtins.  */
  
! #define BUILTIN_EXP10_P(FN) \
!  ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \
!   || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L)
  
! #define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \
!   || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \
!   || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L)
  
! #define BUILTIN_SQRT_P(FN) \
!  ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL)
  
! #define BUILTIN_CBRT_P(FN) \
!  ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL)
  
! #define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN))
  
! #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
! #define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R
! #define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL
  
! /* An array of _DECL trees for the above.  */
! extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
! extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];
! 
! /* In an OMP_CLAUSE node.  */
  
! /* Number of operands and names for each clause.  */
! extern unsigned const char omp_clause_num_ops[];
! extern const char * const omp_clause_code_name[];
  
  /* Clause codes.  Do not reorder, as this is used to index into the tables
     omp_clause_num_ops and omp_clause_code_name.  */
--- 44,441 ----
  
  #undef DEFTREECODE
  
! /* The definition of tree nodes fills the next several pages.  */
  
! /* A tree node can represent a data type, a variable, an expression
!    or a statement.  Each node has a TREE_CODE which says what kind of
!    thing it represents.  Some common codes are:
!    INTEGER_TYPE -- represents a type of integers.
!    ARRAY_TYPE -- represents a type of pointer.
!    VAR_DECL -- represents a declared variable.
!    INTEGER_CST -- represents a constant integer value.
!    PLUS_EXPR -- represents a sum (an expression).
  
!    As for the contents of a tree node: there are some fields
!    that all nodes share.  Each TREE_CODE has various special-purpose
!    fields as well.  The fields of a node are never accessed directly,
!    always through accessor macros.  */
  
! /* 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 tree_base GTY(())
! {
!   ENUM_BITFIELD(tree_code) code : 16;
  
!   unsigned side_effects_flag : 1;
!   unsigned constant_flag : 1;
!   unsigned addressable_flag : 1;
!   unsigned volatile_flag : 1;
!   unsigned readonly_flag : 1;
!   unsigned unsigned_flag : 1;
!   unsigned asm_written_flag: 1;
!   unsigned nowarning_flag : 1;
  
!   unsigned used_flag : 1;
!   unsigned nothrow_flag : 1;
!   unsigned static_flag : 1;
!   unsigned public_flag : 1;
!   unsigned private_flag : 1;
!   unsigned protected_flag : 1;
!   unsigned deprecated_flag : 1;
!   unsigned invariant_flag : 1;
!   unsigned saturating_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 spare : 23;
  
!   /* FIXME tuples: Eventually, we need to move this somewhere external to
!      the trees.  */
!   union tree_ann_d *ann;
! };
  
! struct tree_common GTY(())
! {
!   struct tree_base base;
!   tree chain;
!   tree type;
! };
  
! /* GIMPLE_MODIFY_STMT */
! struct gimple_stmt GTY(())
! {
!   struct tree_base base;
!   source_locus locus;
!   tree block;
!   /* FIXME tuples: Eventually this should be of type ``struct gimple_expr''.  */
!   tree GTY ((length ("TREE_CODE_LENGTH (TREE_CODE ((tree)&%h))"))) operands[1];
! };
  
! /* The following table lists the uses of each of the above flags and
!    for which types of nodes they are defined.  Note that expressions
!    include decls.
  
!    addressable_flag:
  
!        TREE_ADDRESSABLE in
! 	   VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
! 	   ..._TYPE, IDENTIFIER_NODE.
! 	   In a STMT_EXPR, it means we want the result of the enclosed
! 	   expression.
!        CALL_EXPR_TAILCALL in CALL_EXPR
!        CASE_LOW_SEEN in CASE_LABEL_EXPR
  
!    static_flag:
  
!        TREE_STATIC in
!            VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR
!        BINFO_VIRTUAL_P in
!            TREE_BINFO
!        TREE_SYMBOL_REFERENCED in
!            IDENTIFIER_NODE
!        CLEANUP_EH_ONLY in
!            TARGET_EXPR, WITH_CLEANUP_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
! 	   GIMPLE_MODIFY_STMT
!        CASE_HIGH_SEEN in
! 	   CASE_LABEL_EXPR
!        CALL_CANNOT_INLINE_P in
! 	   CALL_EXPR
  
!    public_flag:
  
+        TREE_OVERFLOW in
+            INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
+        TREE_PUBLIC in
+            VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
+        ASM_VOLATILE_P in
+            ASM_EXPR
+        CALL_EXPR_VA_ARG_PACK in
+ 	  CALL_EXPR
+        TYPE_CACHED_VALUES_P in
+           ..._TYPE
+        SAVE_EXPR_RESOLVED_P in
+ 	  SAVE_EXPR
+        OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
+ 	  OMP_CLAUSE_LASTPRIVATE
+        OMP_CLAUSE_PRIVATE_DEBUG in
+ 	  OMP_CLAUSE_PRIVATE
  
!    private_flag:
  
!        TREE_PRIVATE in
!            ..._DECL
!        CALL_EXPR_RETURN_SLOT_OPT in
!            CALL_EXPR
!        DECL_BY_REFERENCE in
!            PARM_DECL, RESULT_DECL
!        OMP_RETURN_NOWAIT in
! 	   OMP_RETURN
!        OMP_SECTION_LAST in
! 	   OMP_SECTION
!        OMP_PARALLEL_COMBINED in
! 	   OMP_PARALLEL
  
!    protected_flag:
  
!        TREE_PROTECTED in
!            BLOCK
! 	   ..._DECL
!        CALL_FROM_THUNK_P in
!            CALL_EXPR
  
!    side_effects_flag:
  
!        TREE_SIDE_EFFECTS in
!            all expressions
! 	   all decls
! 	   all constants
  
!        FORCED_LABEL in
! 	   LABEL_DECL
  
!    volatile_flag:
  
!        TREE_THIS_VOLATILE in
!            all expressions
!        TYPE_VOLATILE in
!            ..._TYPE
  
!    readonly_flag:
  
!        TREE_READONLY in
!            all expressions
!        TYPE_READONLY in
!            ..._TYPE
  
!    constant_flag:
  
!        TREE_CONSTANT in
!            all expressions
! 	   all decls
! 	   all constants
!        TYPE_SIZES_GIMPLIFIED
!            ..._TYPE
  
!    unsigned_flag:
  
!        TYPE_UNSIGNED in
!            all types
!        DECL_UNSIGNED in
!            all decls
!        BIT_FIELD_REF_UNSIGNED in
!            BIT_FIELD_REF
  
!    asm_written_flag:
  
!        TREE_ASM_WRITTEN in
!            VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
! 	   BLOCK, SSA_NAME
  
!    used_flag:
  
!        TREE_USED in
!            expressions, IDENTIFIER_NODE
  
!    nothrow_flag:
  
!        TREE_NOTHROW in
!            CALL_EXPR, FUNCTION_DECL
  
!        TYPE_ALIGN_OK in
! 	   ..._TYPE
  
!        TREE_THIS_NOTRAP in
!           (ALIGN/MISALIGNED_)INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF
  
!    deprecated_flag:
  
! 	TREE_DEPRECATED in
! 	   ..._DECL
  
! 	IDENTIFIER_TRANSPARENT_ALIAS in
! 	   IDENTIFIER_NODE
  
!    visited:
  
!    	Used in tree traversals to mark visited nodes.
  
!    invariant_flag:
  
! 	TREE_INVARIANT in
! 	    all expressions.
  
!    saturating_flag:
  
!        TYPE_SATURATING in
!            all types
  
!    nowarning_flag:
  
!        TREE_NO_WARNING in
!            ... any expr or decl node
! */
! 
! struct tree_int_cst GTY(())
  {
!   struct tree_common common;
!   double_int int_cst;
  };
  
! struct tree_real_cst GTY(())
! {
!   struct tree_common common;
!   struct real_value * real_cst_ptr;
! };
  
! struct tree_fixed_cst GTY(())
! {
!   struct tree_common common;
!   struct fixed_value * fixed_cst_ptr;
! };
  
! struct tree_string GTY(())
  {
!   struct tree_common common;
!   int length;
!   char str[1];
! };
  
! struct tree_complex GTY(())
! {
!   struct tree_common common;
!   tree real;
!   tree imag;
! };
  
! struct tree_vector GTY(())
! {
!   struct tree_common common;
!   tree elements;
! };
  
! struct tree_identifier GTY(())
! {
!   struct tree_common common;
!   struct ht_identifier id;
  };
  
! struct tree_list GTY(())
! {
!   struct tree_common common;
!   tree purpose;
!   tree value;
! };
  
! struct tree_vec GTY(())
! {
!   struct tree_common common;
!   int length;
!   tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
! };
  
! /* 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(())
! {
!   tree index;
!   tree value;
! } constructor_elt;
  
! DEF_VEC_O(constructor_elt);
! DEF_VEC_ALLOC_O(constructor_elt,gc);
  
! struct tree_constructor GTY(())
! {
!   struct tree_common common;
!   VEC(constructor_elt,gc) *elts;
! };
  
! struct tree_exp GTY(())
! {
!   struct tree_common common;
!   source_locus locus;
!   tree block;
!   tree GTY ((special ("tree_exp"), desc ("TREE_CODE ((tree) &%0)")))
!     operands[1];
! };
  
! /* 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(())
! {
!   struct ssa_use_operand_d* GTY((skip(""))) prev;
!   struct ssa_use_operand_d* GTY((skip(""))) next;
!   tree GTY((skip(""))) stmt;
!   tree *GTY((skip(""))) use;
! } ssa_use_operand_t;
  
! struct tree_ssa_name GTY(())
! {
!   struct tree_common common;
  
!   /* _DECL wrapped by this SSA name.  */
!   tree var;
  
!   /* SSA version number.  */
!   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(())
! {
!   /* 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;
! };
! 
! struct tree_phi_node GTY(())
! {
!   struct tree_base common;
!   tree chain;
!   tree result;
!   int num_args;
!   int capacity;
! 
!   /* Basic block holding this PHI node.  */
!   struct basic_block_def *bb;
! 
!   /* Arguments of the PHI node.  These are maintained in the same
!      order as predecessor edge vector BB->PREDS.  */
!   struct phi_arg_d GTY ((length ("((tree)&%h)->phi.num_args"))) a[1];
! };
  
  /* Clause codes.  Do not reorder, as this is used to index into the tables
     omp_clause_num_ops and omp_clause_code_name.  */
*************** enum omp_clause_code
*** 342,393 ****
    /* OpenMP clause: default.  */
    OMP_CLAUSE_DEFAULT
  };
- 
- /* The definition of tree nodes fills the next several pages.  */
- 
- /* A tree node can represent a data type, a variable, an expression
-    or a statement.  Each node has a TREE_CODE which says what kind of
-    thing it represents.  Some common codes are:
-    INTEGER_TYPE -- represents a type of integers.
-    ARRAY_TYPE -- represents a type of pointer.
-    VAR_DECL -- represents a declared variable.
-    INTEGER_CST -- represents a constant integer value.
-    PLUS_EXPR -- represents a sum (an expression).
  
!    As for the contents of a tree node: there are some fields
!    that all nodes share.  Each TREE_CODE has various special-purpose
!    fields as well.  The fields of a node are never accessed directly,
!    always through accessor macros.  */
  
! /* 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 tree_base GTY(())
  {
!   ENUM_BITFIELD(tree_code) code : 16;
  
!   unsigned side_effects_flag : 1;
!   unsigned constant_flag : 1;
!   unsigned addressable_flag : 1;
!   unsigned volatile_flag : 1;
!   unsigned readonly_flag : 1;
!   unsigned unsigned_flag : 1;
!   unsigned asm_written_flag: 1;
!   unsigned nowarning_flag : 1;
  
!   unsigned used_flag : 1;
!   unsigned nothrow_flag : 1;
!   unsigned static_flag : 1;
!   unsigned public_flag : 1;
!   unsigned private_flag : 1;
!   unsigned protected_flag : 1;
!   unsigned deprecated_flag : 1;
!   unsigned invariant_flag : 1;
!   unsigned saturating_flag : 1;
  
    unsigned lang_flag_0 : 1;
    unsigned lang_flag_1 : 1;
--- 490,563 ----
    /* OpenMP clause: default.  */
    OMP_CLAUSE_DEFAULT
  };
  
! enum omp_clause_default_kind
! {
!   OMP_CLAUSE_DEFAULT_UNSPECIFIED,
!   OMP_CLAUSE_DEFAULT_SHARED,
!   OMP_CLAUSE_DEFAULT_NONE,
!   OMP_CLAUSE_DEFAULT_PRIVATE
! };
  
! enum omp_clause_schedule_kind
! {
!   OMP_CLAUSE_SCHEDULE_STATIC,
!   OMP_CLAUSE_SCHEDULE_DYNAMIC,
!   OMP_CLAUSE_SCHEDULE_GUIDED,
!   OMP_CLAUSE_SCHEDULE_RUNTIME
! };
  
! struct tree_omp_clause GTY(())
! {
!   struct tree_common common;
!   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;
!   } GTY ((skip)) subcode;
!   tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
! };
  
! struct tree_block GTY(())
  {
!   struct tree_common common;
  
!   unsigned handler_block_flag : 1;
!   unsigned abstract_flag : 1;
!   unsigned block_num : 30;
  
!   location_t locus;
! 
!   tree vars;
!   tree subblocks;
!   tree supercontext;
!   tree abstract_origin;
!   tree fragment_origin;
!   tree fragment_chain;
! };
! 
! struct die_struct;
! 
! struct tree_type GTY(())
! {
!   struct tree_common common;
!   tree values;
!   tree size;
!   tree size_unit;
!   tree attributes;
!   unsigned int uid;
! 
!   unsigned int precision : 9;
!   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;
  
    unsigned lang_flag_0 : 1;
    unsigned lang_flag_1 : 1;
*************** struct tree_base GTY(())
*** 396,596 ****
    unsigned lang_flag_4 : 1;
    unsigned lang_flag_5 : 1;
    unsigned lang_flag_6 : 1;
!   unsigned visited : 1;
! 
!   unsigned spare : 23;
  
!   /* FIXME tuples: Eventually, we need to move this somewhere external to
!      the trees.  */
!   union tree_ann_d *ann;
  };
  
! struct tree_common GTY(())
! {
!   struct tree_base base;
!   tree chain;
!   tree type;
! };
  
! /* GIMPLE_MODIFY_STMT */
! struct gimple_stmt GTY(())
  {
!   struct tree_base base;
!   source_locus locus;
!   tree block;
!   /* FIXME tuples: Eventually this should be of type ``struct gimple_expr''.  */
!   tree GTY ((length ("TREE_CODE_LENGTH (TREE_CODE (&%h))"))) operands[1];
! };
  
! /* The following table lists the uses of each of the above flags and
!    for which types of nodes they are defined.  Note that expressions
!    include decls.
  
!    addressable_flag:
  
!        TREE_ADDRESSABLE in
! 	   VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
! 	   ..._TYPE, IDENTIFIER_NODE.
! 	   In a STMT_EXPR, it means we want the result of the enclosed
! 	   expression.
!        CALL_EXPR_TAILCALL in CALL_EXPR
!        CASE_LOW_SEEN in CASE_LABEL_EXPR
  
!    static_flag:
  
!        TREE_STATIC in
!            VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR
!        BINFO_VIRTUAL_P in
!            TREE_BINFO
!        TREE_SYMBOL_REFERENCED in
!            IDENTIFIER_NODE
!        CLEANUP_EH_ONLY in
!            TARGET_EXPR, WITH_CLEANUP_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
! 	   GIMPLE_MODIFY_STMT
!        CASE_HIGH_SEEN in
! 	   CASE_LABEL_EXPR
!        CALL_CANNOT_INLINE_P in
! 	   CALL_EXPR
  
!    public_flag:
  
!        TREE_OVERFLOW in
!            INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
!        TREE_PUBLIC in
!            VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
!        ASM_VOLATILE_P in
!            ASM_EXPR
!        CALL_EXPR_VA_ARG_PACK in
! 	  CALL_EXPR
!        TYPE_CACHED_VALUES_P in
!           ..._TYPE
!        SAVE_EXPR_RESOLVED_P in
! 	  SAVE_EXPR
!        OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
! 	  OMP_CLAUSE_LASTPRIVATE
!        OMP_CLAUSE_PRIVATE_DEBUG in
! 	  OMP_CLAUSE_PRIVATE
  
!    private_flag:
  
!        TREE_PRIVATE in
!            ..._DECL
!        CALL_EXPR_RETURN_SLOT_OPT in
!            CALL_EXPR
!        DECL_BY_REFERENCE in
!            PARM_DECL, RESULT_DECL
!        OMP_RETURN_NOWAIT in
! 	   OMP_RETURN
!        OMP_SECTION_LAST in
! 	   OMP_SECTION
!        OMP_PARALLEL_COMBINED in
! 	   OMP_PARALLEL
  
!    protected_flag:
  
!        TREE_PROTECTED in
!            BLOCK
! 	   ..._DECL
!        CALL_FROM_THUNK_P in
!            CALL_EXPR
  
!    side_effects_flag:
  
!        TREE_SIDE_EFFECTS in
!            all expressions
! 	   all decls
! 	   all constants
  
!        FORCED_LABEL in
! 	   LABEL_DECL
  
!    volatile_flag:
  
!        TREE_THIS_VOLATILE in
!            all expressions
!        TYPE_VOLATILE in
!            ..._TYPE
  
!    readonly_flag:
  
!        TREE_READONLY in
!            all expressions
!        TYPE_READONLY in
!            ..._TYPE
  
!    constant_flag:
  
!        TREE_CONSTANT in
!            all expressions
! 	   all decls
! 	   all constants
!        TYPE_SIZES_GIMPLIFIED
!            ..._TYPE
  
!    unsigned_flag:
  
!        TYPE_UNSIGNED in
!            all types
!        DECL_UNSIGNED in
!            all decls
!        BIT_FIELD_REF_UNSIGNED in
!            BIT_FIELD_REF
  
!    asm_written_flag:
  
!        TREE_ASM_WRITTEN in
!            VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
! 	   BLOCK, SSA_NAME
  
!    used_flag:
  
!        TREE_USED in
!            expressions, IDENTIFIER_NODE
  
!    nothrow_flag:
  
!        TREE_NOTHROW in
!            CALL_EXPR, FUNCTION_DECL
  
!        TYPE_ALIGN_OK in
! 	   ..._TYPE
  
!        TREE_THIS_NOTRAP in
!           (ALIGN/MISALIGNED_)INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF
  
!    deprecated_flag:
  
! 	TREE_DEPRECATED in
! 	   ..._DECL
  
! 	IDENTIFIER_TRANSPARENT_ALIAS in
! 	   IDENTIFIER_NODE
  
!    visited:
  
!    	Used in tree traversals to mark visited nodes.
  
!    invariant_flag:
  
! 	TREE_INVARIANT in
! 	    all expressions.
  
!    saturating_flag:
  
!        TYPE_SATURATING in
!            all types
  
!    nowarning_flag:
  
!        TREE_NO_WARNING in
!            ... any expr or decl node
! */
  #undef DEFTREESTRUCT
  #define DEFTREESTRUCT(ENUM, NAME) ENUM,
  enum tree_node_structure_enum {
--- 566,1193 ----
    unsigned lang_flag_4 : 1;
    unsigned lang_flag_5 : 1;
    unsigned lang_flag_6 : 1;
!   unsigned user_align : 1;
  
!   unsigned int align;
!   tree pointer_to;
!   tree reference_to;
!   union tree_type_symtab {
!     int GTY ((tag ("0"))) address;
!     const char * GTY ((tag ("1"))) pointer;
!     struct die_struct * GTY ((tag ("2"))) die;
!   } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
! 	  descbits ("2"))) symtab;
!   tree name;
!   tree minval;
!   tree maxval;
!   tree next_variant;
!   tree main_variant;
!   tree binfo;
!   tree context;
!   tree canonical;
!   alias_set_type alias_set;
!   /* Points to a structure whose details depend on the language in use.  */
!   struct lang_type *lang_specific;
  };
  
! /* A vectors of trees.  */
! DEF_VEC_P(tree);
! DEF_VEC_ALLOC_P(tree,gc);
! DEF_VEC_ALLOC_P(tree,heap);
  
! struct tree_binfo GTY (())
  {
!   struct tree_common common;
  
!   tree offset;
!   tree vtable;
!   tree virtuals;
!   tree vptr_field;
!   VEC(tree,gc) *base_accesses;
!   tree inheritance;
  
!   tree vtt_subvtt;
!   tree vtt_vptr;
  
!   VEC(tree,none) base_binfos;
! };
  
! struct tree_decl_minimal GTY(())
! {
!   struct tree_common common;
!   location_t locus;
!   unsigned int uid;
!   tree name;
!   tree context;
! };
  
! struct tree_memory_tag GTY(())
! {
!   struct tree_decl_minimal common;
  
!   bitmap GTY ((skip)) aliases;
  
!   /* True if this tag has global scope.  */
!   unsigned int is_global : 1;
  
!   /* True if this tag is the first field of an aggregate type that
!      can be used to find adjacent SFTs belonging to the same aggregate.  */
!   unsigned int base_for_components : 1;
  
!   /* True if this tag should not be grouped into a memory partition.  */
!   unsigned int unpartitionable : 1;
! };
  
! struct tree_struct_field_tag GTY(())
! {
!   struct tree_memory_tag common;
  
!   /* Parent variable.  */
!   tree parent_var;
  
!   /* Offset inside structure.  */
!   unsigned HOST_WIDE_INT offset;
  
!   /* Size of the field.  */
!   unsigned HOST_WIDE_INT size;
  
!   /* Alias set for a DECL_NONADDRESSABLE_P field.  Otherwise -1.  */
!   alias_set_type alias_set;
! };
  
! struct tree_memory_partition_tag GTY(())
! {
!   struct tree_memory_tag common;
!   
!   /* Set of symbols grouped under this MPT.  */
!   bitmap symbols;
! };
  
! 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_2 : 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;
  
!   /* 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.  */
!   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.  */
!   unsigned no_tbaa_flag : 1;
!   /* Padding so that 'align' can be on a 32-bit boundary.  */
!   unsigned decl_common_unused : 2;
  
!   unsigned int align : 24;
!   /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs.  */
!   unsigned int off_align : 8;
  
!   tree size_unit;
!   tree initial;
!   tree attributes;
!   tree abstract_origin;
! 
!   alias_set_type pointer_alias_set;
!   /* Points to a structure whose details depend on the language in use.  */
!   struct lang_decl *lang_specific;
! };
! 
! struct tree_decl_with_rtl GTY(())
! {
!   struct tree_decl_common common;
!   rtx rtl;
! };
! 
! struct tree_field_decl GTY(())
! {
!   struct tree_decl_common common;
! 
!   tree offset;
!   tree bit_field_type;
!   tree qualifier;
!   tree bit_offset;
!   tree fcontext;
! 
! };
! 
! struct tree_label_decl GTY(())
! {
!   struct tree_decl_with_rtl common;
! };
! 
! struct tree_result_decl GTY(())
! {
!   struct tree_decl_with_rtl common;
! };
! 
! struct tree_const_decl GTY(())
! {
!   struct tree_decl_with_rtl common;
! };
! 
! struct tree_parm_decl GTY(())
! {
!   struct tree_decl_with_rtl common;
!   rtx incoming_rtl;
! };
! 
! /* Enumerate visibility settings.  */
! #ifndef SYMBOL_VISIBILITY_DEFINED
! #define SYMBOL_VISIBILITY_DEFINED
! enum symbol_visibility
! {
!   VISIBILITY_DEFAULT,
!   VISIBILITY_PROTECTED,
!   VISIBILITY_HIDDEN,
!   VISIBILITY_INTERNAL
! };
! #endif
! 
! struct tree_decl_with_vis GTY(())
! {
!  struct tree_decl_with_rtl common;
!  tree assembler_name;
!  tree section_name;
! 
!  /* Belong to VAR_DECL exclusively.  */
!  unsigned defer_output:1;
!  unsigned hard_register:1;
!  unsigned thread_local: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 in_system_header_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;
!  /* 11 unused bits. */
! };
! 
! struct tree_var_decl GTY(())
! {
!   struct tree_decl_with_vis common;
! };
! 
! struct tree_decl_non_common GTY(())
! {
!   struct tree_decl_with_vis common;
!   /* C++ uses this in namespaces.  */
!   tree saved_tree;
!   /* C++ uses this in templates.  */
!   tree arguments;
!   /* Almost all FE's use this.  */
!   tree result;
!   /* C++ uses this in namespaces.  */
!   tree vindex;
! };
! 
! /* Codes that identify the various built in functions
!    so that expand_call can identify them quickly.  */
! 
! #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM,
! enum built_in_function
! {
! #include "builtins.def"
! 
!   /* Complex division routines in libgcc.  These are done via builtins
!      because emit_library_call_value can't handle complex values.  */
!   BUILT_IN_COMPLEX_MUL_MIN,
!   BUILT_IN_COMPLEX_MUL_MAX
!     = BUILT_IN_COMPLEX_MUL_MIN
!       + MAX_MODE_COMPLEX_FLOAT
!       - MIN_MODE_COMPLEX_FLOAT,
! 
!   BUILT_IN_COMPLEX_DIV_MIN,
!   BUILT_IN_COMPLEX_DIV_MAX
!     = BUILT_IN_COMPLEX_DIV_MIN
!       + MAX_MODE_COMPLEX_FLOAT
!       - MIN_MODE_COMPLEX_FLOAT,
! 
!   /* Upper bound on non-language-specific builtins.  */
!   END_BUILTINS
! };
! #undef DEF_BUILTIN
! 
! /* Names for the above.  */
! extern const char * built_in_names[(int) END_BUILTINS];
! 
! /* 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
! {
!   NOT_BUILT_IN = 0,
!   BUILT_IN_FRONTEND,
!   BUILT_IN_MD,
!   BUILT_IN_NORMAL
! };
! 
! /* Names for the above.  */
! extern const char *const built_in_class_names[4];
! 
! struct tree_function_decl GTY(())
! {
!   struct tree_decl_non_common common;
! 
!   struct function *f;
! 
!   /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
!      DECL_FUNCTION_CODE.  Otherwise unused.
!      ???  The bitfield needs to be able to hold all target function
! 	  codes as well.  */
!   ENUM_BITFIELD(built_in_function) function_code : 11;
!   ENUM_BITFIELD(built_in_class) built_in_class : 2;
! 
!   unsigned static_ctor_flag : 1;
!   unsigned static_dtor_flag : 1;
!   unsigned uninlinable : 1;
! 
!   unsigned possibly_inlined : 1;
!   unsigned novops_flag : 1;
!   unsigned returns_twice_flag : 1;
!   unsigned malloc_flag : 1;
!   unsigned pure_flag : 1;
!   unsigned declared_inline_flag : 1;
!   unsigned regdecl_flag : 1;
!   unsigned inline_flag : 1;
! 
!   unsigned no_instrument_function_entry_exit : 1;
!   unsigned no_limit_stack : 1;
!   unsigned disregard_inline_limits : 1;
! 
!   /* 5 bits left */
! };
! 
! struct tree_type_decl GTY(())
! {
!   struct tree_decl_non_common common;
! };
! 
! struct tree_statement_list_node
!   GTY ((chain_next ("%h.next"), chain_prev ("%h.prev")))
! {
!   struct tree_statement_list_node *prev;
!   struct tree_statement_list_node *next;
!   tree stmt;
! };
! 
! struct tree_statement_list
!   GTY(())
! {
!   struct tree_common common;
!   struct tree_statement_list_node *head;
!   struct tree_statement_list_node *tail;
! };
! 
! /* Defined and used in tree-ssa-pre.c.  */
! 
! struct tree_value_handle GTY(())
! {
!   struct tree_common common;
! 
!   /* The set of expressions represented by this handle.  */
!   struct bitmap_set * GTY ((skip)) expr_set;
! 
!   /* Unique ID for this value handle.  IDs are handed out in a
!      conveniently dense form starting at 0, so that we can make
!      bitmaps of value handles.  */
!   unsigned int id;
! };
! 
! /* 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),
! 		      desc ("tree_node_structure (&%h)")))
! {
!   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_vector GTY ((tag ("TS_VECTOR"))) vector;
!   struct tree_string GTY ((tag ("TS_STRING"))) string;
!   struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
!   struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
!   struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal;
!   struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common;
!   struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl;
!   struct tree_decl_non_common  GTY ((tag ("TS_DECL_NON_COMMON"))) decl_non_common;
!   struct tree_parm_decl  GTY  ((tag ("TS_PARM_DECL"))) parm_decl;
!   struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis;
!   struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl;
!   struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl;
!   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_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;
!   struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi;
!   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 gimple_stmt GTY ((tag ("TS_GIMPLE_STATEMENT"))) gstmt;
!   struct tree_value_handle GTY ((tag ("TS_VALUE_HANDLE"))) value_handle;
!   struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
!   struct tree_memory_tag GTY ((tag ("TS_MEMORY_TAG"))) mtag;
!   struct tree_struct_field_tag GTY ((tag ("TS_STRUCT_FIELD_TAG"))) sft;
!   struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
!   struct tree_memory_partition_tag GTY ((tag ("TS_MEMORY_PARTITION_TAG"))) mpt;
! };
! 
! enum { MAX_TREE_CODES = 512 };
! extern unsigned char tree_contains_struct[MAX_TREE_CODES][64];
! 
! static inline bool
! CODE_CONTAINS_STRUCT (enum tree_code code, int index)
! {
!   return tree_contains_struct[(int) code][index];
! }
! 
! /* Number of language-independent tree codes.  */
! enum { NUM_TREE_CODES = (int) LAST_AND_UNUSED_TREE_CODE };
! 
! /* Tree code classes.  */
! 
! /* Each tree_code has an associated code class represented by a
!    TREE_CODE_CLASS.  */
! 
! enum tree_code_class {
!   tcc_exceptional, /* An exceptional code (fits no category).  */
!   tcc_constant,    /* A constant.  */
!   /* Order of tcc_type and tcc_declaration is important.  */
!   tcc_type,        /* A type object code.  */
!   tcc_declaration, /* A declaration (also serving as variable refs).  */
!   tcc_reference,   /* A reference to storage.  */
!   tcc_comparison,  /* A comparison expression.  */
!   tcc_unary,       /* A unary arithmetic expression.  */
!   tcc_binary,      /* A binary arithmetic expression.  */
!   tcc_statement,   /* A statement expression, which have side effects
! 		      but usually no interesting value.  */
!   tcc_vl_exp,      /* A function call or other expression with a
! 		      variable-length operand vector.  */
!   tcc_expression,  /* Any other expression.  */
!   tcc_gimple_stmt  /* A GIMPLE statement.  */
! };
! 
! /* Each tree code class has an associated string representation.
!    These must correspond to the tree_code_class entries.  */
! 
! extern const char *const tree_code_class_strings[];
! 
! /* Returns the string representing CLASS.  */
! 
! #define TREE_CODE_CLASS_STRING(CLASS)\
!         tree_code_class_strings[(int) (CLASS)]
! 
! extern const enum tree_code_class tree_code_type[];
! #define TREE_CODE_CLASS(CODE)	tree_code_type[(int) (CODE)]
! 
! /* Nonzero if CODE represents an exceptional code.  */
! 
! #define EXCEPTIONAL_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional)
! 
! /* Nonzero if CODE represents a constant.  */
! 
! #define CONSTANT_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant)
! 
! /* Nonzero if CODE represents a type.  */
! 
! #define TYPE_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type)
! 
! /* 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) == STRUCT_FIELD_TAG		\
!    || 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)
! 
! /* 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) == 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)
! 
! /* Nonzero if CODE represents a comparison.  */
! 
! #define COMPARISON_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison)
! 
! /* Nonzero if CODE represents a unary arithmetic expression.  */
! 
! #define UNARY_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary)
! 
! /* Nonzero if CODE represents a binary arithmetic expression.  */
! 
! #define BINARY_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary)
! 
! /* Nonzero if CODE represents a statement expression.  */
! 
! #define STATEMENT_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement)
! 
! /* Nonzero if CODE represents a function call-like expression with a
!    variable-length operand vector.  */
! 
! #define VL_EXP_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_vl_exp)
! 
! /* Nonzero if CODE represents any other expression.  */
! 
! #define EXPRESSION_CLASS_P(CODE)\
! 	(TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression)
! 
! /* Returns nonzero iff CODE represents a type or declaration.  */
! 
! #define IS_TYPE_OR_DECL_P(CODE)\
! 	(TYPE_P (CODE) || DECL_P (CODE))
  
! /* Returns nonzero iff CLASS is the tree-code class of an
!    expression.  */
  
! #define IS_EXPR_CODE_CLASS(CLASS)\
! 	((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
  
! /* Returns nonzer iff CLASS is a GIMPLE statement.  */
  
! #define IS_GIMPLE_STMT_CODE_CLASS(CLASS) ((CLASS) == tcc_gimple_stmt)
  
! /* Returns nonzero iff NODE is an expression of some kind.  */
  
! #define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
  
! /* Returns nonzero iff NODE is an OpenMP directive.  */
  
! #define OMP_DIRECTIVE_P(NODE)				\
!     (TREE_CODE (NODE) == OMP_PARALLEL			\
!      || TREE_CODE (NODE) == OMP_FOR			\
!      || TREE_CODE (NODE) == OMP_SECTIONS		\
!      || TREE_CODE (NODE) == OMP_SECTIONS_SWITCH		\
!      || TREE_CODE (NODE) == OMP_SINGLE			\
!      || TREE_CODE (NODE) == OMP_SECTION			\
!      || TREE_CODE (NODE) == OMP_MASTER			\
!      || TREE_CODE (NODE) == OMP_ORDERED			\
!      || TREE_CODE (NODE) == OMP_CRITICAL		\
!      || TREE_CODE (NODE) == OMP_RETURN			\
!      || TREE_CODE (NODE) == OMP_ATOMIC_LOAD                            \
!      || TREE_CODE (NODE) == OMP_ATOMIC_STORE                           \
!      || TREE_CODE (NODE) == OMP_CONTINUE)
  
! /* Number of argument-words in each kind of tree-node.  */
  
! extern const unsigned char tree_code_length[];
! #define TREE_CODE_LENGTH(CODE)	tree_code_length[(int) (CODE)]
  
! /* Names of tree components.  */
  
! extern const char *const tree_code_name[];
  
! 
! /* Helper macros for math builtins.  */
  
! #define BUILTIN_EXP10_P(FN) \
!  ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \
!   || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L)
  
! #define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \
!   || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \
!   || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L)
  
! #define BUILTIN_SQRT_P(FN) \
!  ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL)
  
! #define BUILTIN_CBRT_P(FN) \
!  ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL)
  
! #define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN))
  
! #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
! #define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R
! #define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL
! 
! /* An array of _DECL trees for the above.  */
! extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
! extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];
! 
! /* In an OMP_CLAUSE node.  */
! 
! /* Number of operands and names for each clause.  */
! extern unsigned const char omp_clause_num_ops[];
! extern const char * const omp_clause_code_name[];
! 
  #undef DEFTREESTRUCT
  #define DEFTREESTRUCT(ENUM, NAME) ENUM,
  enum tree_node_structure_enum {
*************** extern void omp_clause_range_check_faile
*** 1403,1414 ****
  	== (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 tree_common common;
-   double_int int_cst;
- };
- 
  /* In a REAL_CST node.  struct real_value is an opaque entity, with
     manipulators defined in real.h.  We don't want tree.h depending on
     real.h and transitively on tm.h.  */
--- 2000,2005 ----
*************** struct real_value;
*** 1417,1474 ****
  #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 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 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 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 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 tree_common common;
-   tree elements;
- };
  
- #include "symtab.h"
- 
  /* Define fields and accessors for some special-purpose tree nodes.  */
  
  #define IDENTIFIER_LENGTH(NODE) \
--- 2008,2031 ----
*************** struct tree_vector GTY(())
*** 1485,1507 ****
    ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
  #define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
  
- struct tree_identifier GTY(())
- {
-   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 tree_common common;
-   tree purpose;
-   tree value;
- };
- 
  /* In a TREE_VEC node.  */
  #define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length)
  #define TREE_VEC_END(NODE) \
--- 2042,2051 ----
*************** struct tree_list GTY(())
*** 1509,1521 ****
  
  #define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
  
- struct tree_vec GTY(())
- {
-   struct tree_common common;
-   int length;
-   tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
- };
- 
  /* In a CONSTRUCTOR node.  */
  #define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
  
--- 2053,2058 ----
*************** struct tree_vec GTY(())
*** 1548,1572 ****
      _ce___->value = VALUE; \
    } while (0)
  
- /* 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(())
- {
-   tree index;
-   tree value;
- } constructor_elt;
- 
- DEF_VEC_O(constructor_elt);
- DEF_VEC_ALLOC_O(constructor_elt,gc);
- 
- struct tree_constructor GTY(())
- {
-   struct tree_common common;
-   VEC(constructor_elt,gc) *elts;
- };
- 
  /* Define fields and accessors for some nodes that represent expressions.  */
  
  /* Nonzero if NODE is an empty statement (NOP_EXPR <0>).  */
--- 2085,2090 ----
*************** struct tree_constructor GTY(())
*** 1808,1844 ****
  #define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 3)
  
- enum omp_clause_schedule_kind
- {
-   OMP_CLAUSE_SCHEDULE_STATIC,
-   OMP_CLAUSE_SCHEDULE_DYNAMIC,
-   OMP_CLAUSE_SCHEDULE_GUIDED,
-   OMP_CLAUSE_SCHEDULE_RUNTIME
- };
- 
  #define OMP_CLAUSE_SCHEDULE_KIND(NODE) \
    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)
  
- enum omp_clause_default_kind
- {
-   OMP_CLAUSE_DEFAULT_UNSPECIFIED,
-   OMP_CLAUSE_DEFAULT_SHARED,
-   OMP_CLAUSE_DEFAULT_NONE,
-   OMP_CLAUSE_DEFAULT_PRIVATE
- };
- 
  #define OMP_CLAUSE_DEFAULT_KIND(NODE) \
    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
- 
- struct tree_exp GTY(())
- {
-   struct tree_common common;
-   source_locus locus;
-   tree block;
-   tree GTY ((special ("tree_exp"),
- 	     desc ("TREE_CODE ((tree) &%0)")))
-     operands[1];
- };
  
  /* SSA_NAME accessors.  */
  
--- 2326,2336 ----
*************** struct tree_exp GTY(())
*** 1887,1930 ****
  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(())
- {
-   struct ssa_use_operand_d* GTY((skip(""))) prev;
-   struct ssa_use_operand_d* GTY((skip(""))) next;
-   tree GTY((skip(""))) stmt;
-   tree *GTY((skip(""))) use;
- } 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 tree_common common;
- 
-   /* _DECL wrapped by this SSA name.  */
-   tree var;
- 
-   /* SSA version number.  */
-   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;
- };
  
  /* In a PHI_NODE node.  */
  
--- 2379,2386 ----
*************** struct tree_ssa_name GTY(())
*** 1942,1978 ****
     the link to the next PHI is in PHI_CHAIN.  */
  #define PHI_CHAIN(NODE)			PHI_NODE_CHECK (NODE)->phi.chain
  
! #define PHI_NUM_ARGS(NODE)		PHI_NODE_CHECK (NODE)->phi.num_args
! #define PHI_ARG_CAPACITY(NODE)		PHI_NODE_CHECK (NODE)->phi.capacity
! #define PHI_ARG_ELT(NODE, I)		PHI_NODE_ELT_CHECK (NODE, I)
! #define PHI_ARG_EDGE(NODE, I) 		(EDGE_PRED (PHI_BB ((NODE)), (I)))
! #define PHI_BB(NODE)			PHI_NODE_CHECK (NODE)->phi.bb
! #define PHI_ARG_IMM_USE_NODE(NODE, I)	PHI_NODE_ELT_CHECK (NODE, I).imm_use
! 
! struct phi_arg_d GTY(())
! {
!   /* 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;
! };
! 
! struct tree_phi_node GTY(())
! {
!   struct tree_base common;
!   tree chain;
!   tree result;
!   int num_args;
!   int capacity;
! 
!   /* Basic block holding this PHI node.  */
!   struct basic_block_def *bb;
! 
!   /* Arguments of the PHI node.  These are maintained in the same
!      order as predecessor edge vector BB->PREDS.  */
!   struct phi_arg_d GTY ((length ("((tree)&%h)->phi.num_args"))) a[1];
! };
! 
  
  #define OMP_CLAUSE_CODE(NODE)					\
  	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code
--- 2398,2409 ----
     the link to the next PHI is in PHI_CHAIN.  */
  #define PHI_CHAIN(NODE)			PHI_NODE_CHECK (NODE)->phi.chain
  
! #define PHI_NUM_ARGS(NODE)		PHI_NODE_CHECK (NODE)->phi.num_args
! #define PHI_ARG_CAPACITY(NODE)		PHI_NODE_CHECK (NODE)->phi.capacity
! #define PHI_ARG_ELT(NODE, I)		PHI_NODE_ELT_CHECK (NODE, I)
! #define PHI_ARG_EDGE(NODE, I) 		(EDGE_PRED (PHI_BB ((NODE)), (I)))
! #define PHI_BB(NODE)			PHI_NODE_CHECK (NODE)->phi.bb
! #define PHI_ARG_IMM_USE_NODE(NODE, I)	PHI_NODE_ELT_CHECK (NODE, I).imm_use
  
  #define OMP_CLAUSE_CODE(NODE)					\
  	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code
*************** struct tree_phi_node GTY(())
*** 1985,2002 ****
  
  #define OMP_CLAUSE_OPERAND(NODE, I)				\
  	OMP_CLAUSE_ELT_CHECK (NODE, I)
- 
- struct tree_omp_clause GTY(())
- {
-   struct tree_common common;
-   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;
-   } GTY ((skip)) subcode;
-   tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
- };
  
  
  struct varray_head_tag;
--- 2416,2421 ----
*************** struct varray_head_tag;
*** 2051,2074 ****
     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 tree_common common;
- 
-   unsigned handler_block_flag : 1;
-   unsigned abstract_flag : 1;
-   unsigned block_num : 30;
- 
-   location_t locus;
- 
-   tree vars;
-   tree subblocks;
-   tree supercontext;
-   tree abstract_origin;
-   tree fragment_origin;
-   tree fragment_chain;
- };
  
  /* Define fields and accessors for nodes representing data types.  */
  
--- 2470,2475 ----
*************** struct tree_block GTY(())
*** 2286,2344 ****
     this field directly.  */
  #define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
    (TYPE_CHECK (NODE)->type.contains_placeholder_bits)
- 
- struct die_struct;
- 
- struct tree_type GTY(())
- {
-   struct tree_common common;
-   tree values;
-   tree size;
-   tree size_unit;
-   tree attributes;
-   unsigned int uid;
- 
-   unsigned int precision : 9;
-   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;
- 
-   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;
-   tree pointer_to;
-   tree reference_to;
-   union tree_type_symtab {
-     int GTY ((tag ("0"))) address;
-     const char * GTY ((tag ("1"))) pointer;
-     struct die_struct * GTY ((tag ("2"))) die;
-   } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
- 	  descbits ("2"))) symtab;
-   tree name;
-   tree minval;
-   tree maxval;
-   tree next_variant;
-   tree main_variant;
-   tree binfo;
-   tree context;
-   tree canonical;
-   alias_set_type alias_set;
-   /* Points to a structure whose details depend on the language in use.  */
-   struct lang_type *lang_specific;
- };
  
  /* Define accessor macros for information about type inheritance
     and basetypes.
--- 2687,2692 ----
*************** struct tree_type GTY(())
*** 2442,2465 ****
     the binfo of the most derived type.  */
  #define BINFO_INHERITANCE_CHAIN(NODE) \
  	(TREE_BINFO_CHECK(NODE)->binfo.inheritance)
- 
- struct tree_binfo GTY (())
- {
-   struct tree_common common;
- 
-   tree offset;
-   tree vtable;
-   tree virtuals;
-   tree vptr_field;
-   VEC(tree,gc) *base_accesses;
-   tree inheritance;
- 
-   tree vtt_subvtt;
-   tree vtt_vptr;
- 
-   VEC(tree,none) base_binfos;
- };
- 
  
  /* Define fields and accessors for nodes representing declared names.  */
  
--- 2790,2795 ----
*************** struct tree_binfo GTY (())
*** 2475,2495 ****
  		 || TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL	\
  		 || MTAG_P (SSA_NAME_VAR (DECL)))))
  
- 
- 
- 
- /* Enumerate visibility settings.  */
- #ifndef SYMBOL_VISIBILITY_DEFINED
- #define SYMBOL_VISIBILITY_DEFINED
- enum symbol_visibility
- {
-   VISIBILITY_DEFAULT,
-   VISIBILITY_PROTECTED,
-   VISIBILITY_HIDDEN,
-   VISIBILITY_INTERNAL
- };
- #endif
- 
  struct function;
  
  
--- 2805,2810 ----
*************** struct function;
*** 2523,2536 ****
      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 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
--- 2838,2843 ----
*************** struct tree_decl_minimal GTY(())
*** 2549,2590 ****
     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;
- 
-   /* True if this tag is the first field of an aggregate type that
-      can be used to find adjacent SFTs belonging to the same aggregate.  */
-   unsigned int base_for_components : 1;
- 
-   /* True if this tag should not be grouped into a memory partition.  */
-   unsigned int unpartitionable : 1;
- };
- 
  #define MTAG_GLOBAL(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.is_global)
  #define MTAG_ALIASES(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.aliases)
  
- struct tree_struct_field_tag GTY(())
- {
-   struct tree_memory_tag common;
- 
-   /* Parent variable.  */
-   tree parent_var;
- 
-   /* Offset inside structure.  */
-   unsigned HOST_WIDE_INT offset;
- 
-   /* Size of the field.  */
-   unsigned HOST_WIDE_INT size;
- 
-   /* Alias set for a DECL_NONADDRESSABLE_P field.  Otherwise -1.  */
-   alias_set_type alias_set;
- };
  #define SFT_PARENT_VAR(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.parent_var)
  #define SFT_OFFSET(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.offset)
  #define SFT_SIZE(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.size)
--- 2856,2864 ----
*************** struct tree_struct_field_tag GTY(())
*** 2598,2612 ****
  
  /* 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)
  
  
--- 2872,2877 ----
*************** struct tree_memory_partition_tag GTY(())
*** 2715,2818 ****
  #define DECL_LANG_FLAG_0(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
  #define DECL_LANG_FLAG_1(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
  #define DECL_LANG_FLAG_2(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
! #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)
! 
! /* 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)
! 
! /* Nonzero for a decl that is decorated using attribute used.
!    This indicates 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
!    modifications to the variable have been adjusted so that
!    they are killing assignments.  Thus the variable may now
!    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
!    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_2 : 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;
! 
!   /* 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.  */
!   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.  */
!   unsigned no_tbaa_flag : 1;
!   /* Padding so that 'align' can be on a 32-bit boundary.  */
!   unsigned decl_common_unused : 2;
  
!   unsigned int align : 24;
!   /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs.  */
!   unsigned int off_align : 8;
  
!   tree size_unit;
!   tree initial;
!   tree attributes;
!   tree abstract_origin;
  
!   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);
  extern void decl_value_expr_insert (tree, tree);
--- 2980,3024 ----
  #define DECL_LANG_FLAG_0(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
  #define DECL_LANG_FLAG_1(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
  #define DECL_LANG_FLAG_2(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
! #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)
  
! /* 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)
! 
! /* Nonzero for a decl that is decorated using attribute used.
!    This indicates 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
!    modifications to the variable have been adjusted so that
!    they are killing assignments.  Thus the variable may now
!    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
!    Analysis should not be applied to this DECL.  */
! #define DECL_NO_TBAA_P(DECL) \
!   DECL_COMMON_CHECK (DECL)->decl_common.no_tbaa_flag
  
  extern tree decl_value_expr_lookup (tree);
  extern void decl_value_expr_insert (tree, tree);
*************** extern void decl_value_expr_insert (tree
*** 2856,2867 ****
  /* 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 tree_decl_common common;
-   rtx rtl;
- };
- 
  /* In a FIELD_DECL, this is the field position, counting in bytes, of the
     DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
     of the structure.  */
--- 3062,3067 ----
*************** struct tree_decl_with_rtl GTY(())
*** 2912,2929 ****
  #define DECL_NONADDRESSABLE_P(NODE) \
    (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
  
- struct tree_field_decl GTY(())
- {
-   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.  */
--- 3112,3117 ----
*************** struct tree_field_decl GTY(())
*** 2934,2954 ****
     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)
  
- struct tree_label_decl GTY(())
- {
-   struct tree_decl_with_rtl common;
- };
- 
- struct tree_result_decl GTY(())
- {
-   struct tree_decl_with_rtl common;
- };
- 
- struct tree_const_decl GTY(())
- {
-   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.  */
  #define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)
--- 3122,3127 ----
*************** struct tree_const_decl GTY(())
*** 2957,2968 ****
     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 tree_decl_with_rtl common;
-   rtx incoming_rtl;
- };
- 
  
  /* Nonzero in a decl means that the gimplifier has seen (or placed)
     this variable in a BIND_EXPR.  */
--- 3130,3135 ----
*************** extern void decl_restrict_base_insert (t
*** 3085,3124 ****
     multiple translation units should be merged.  */
  #define DECL_ONE_ONLY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.one_only)
  
- struct tree_decl_with_vis GTY(())
- {
-  struct tree_decl_with_rtl common;
-  tree assembler_name;
-  tree section_name;
- 
-  /* Belong to VAR_DECL exclusively.  */
-  unsigned defer_output:1;
-  unsigned hard_register:1;
-  unsigned thread_local: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 in_system_header_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;
-  /* 11 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)
--- 3252,3257 ----
*************** extern void decl_fini_priority_insert (t
*** 3192,3202 ****
  #define DECL_THREAD_LOCAL_P(NODE) \
    (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model != TLS_MODEL_NONE)
  
- struct tree_var_decl GTY(())
- {
-   struct tree_decl_with_vis common;
- };
- 
  
  /* This field is used to reference anything in decl.result and is meant only
     for use by the garbage collector.  */
--- 3325,3330 ----
*************** struct tree_var_decl GTY(())
*** 3212,3231 ****
     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 tree_decl_with_vis common;
-   /* C++ uses this in namespaces.  */
-   tree saved_tree;
-   /* C++ uses this in templates.  */
-   tree arguments;
-   /* Almost all FE's use this.  */
-   tree result;
-   /* C++ uses this in namespaces.  */
-   tree vindex;
- };
- 
  /* In FUNCTION_DECL, holds the decl for the return value.  */
  #define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
  
--- 3340,3345 ----
*************** struct tree_decl_non_common GTY(())
*** 3324,3362 ****
     FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL,
     which seemed a bit strange.  */
  
- struct tree_function_decl GTY(())
- {
-   struct tree_decl_non_common common;
- 
-   struct function *f;
- 
-   /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
-      DECL_FUNCTION_CODE.  Otherwise unused.
-      ???  The bitfield needs to be able to hold all target function
- 	  codes as well.  */
-   ENUM_BITFIELD(built_in_function) function_code : 11;
-   ENUM_BITFIELD(built_in_class) built_in_class : 2;
- 
-   unsigned static_ctor_flag : 1;
-   unsigned static_dtor_flag : 1;
-   unsigned uninlinable : 1;
- 
-   unsigned possibly_inlined : 1;
-   unsigned novops_flag : 1;
-   unsigned returns_twice_flag : 1;
-   unsigned malloc_flag : 1;
-   unsigned pure_flag : 1;
-   unsigned declared_inline_flag : 1;
-   unsigned regdecl_flag : 1;
-   unsigned inline_flag : 1;
- 
-   unsigned no_instrument_function_entry_exit : 1;
-   unsigned no_limit_stack : 1;
-   unsigned disregard_inline_limits : 1;
- 
-   /* 5 bits left */
- };
- 
  /* 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)
  
--- 3438,3443 ----
*************** struct tree_function_decl GTY(())
*** 3365,3376 ****
     This uses the same flag as DECL_EXTERNAL.  */
  #define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
    (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_2)
- 
- struct tree_type_decl GTY(())
- {
-   struct tree_decl_non_common common;
- 
- };
  
  /* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
     To reduce overhead, the nodes containing the statements are not trees.
--- 3446,3451 ----
*************** struct tree_type_decl GTY(())
*** 3383,3471 ****
  #define STATEMENT_LIST_TAIL(NODE) \
    (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
  
- struct tree_statement_list_node
-   GTY ((chain_next ("%h.next"), chain_prev ("%h.prev")))
- {
-   struct tree_statement_list_node *prev;
-   struct tree_statement_list_node *next;
-   tree stmt;
- };
- 
- struct tree_statement_list
-   GTY(())
- {
-   struct tree_common common;
-   struct tree_statement_list_node *head;
-   struct tree_statement_list_node *tail;
- };
- 
  #define VALUE_HANDLE_ID(NODE)		\
    (VALUE_HANDLE_CHECK (NODE)->value_handle.id)
  
  #define VALUE_HANDLE_EXPR_SET(NODE)	\
    (VALUE_HANDLE_CHECK (NODE)->value_handle.expr_set)
- 
- /* Defined and used in tree-ssa-pre.c.  */
- 
- struct tree_value_handle GTY(())
- {
-   struct tree_common common;
- 
-   /* The set of expressions represented by this handle.  */
-   struct bitmap_set * GTY ((skip)) expr_set;
- 
-   /* Unique ID for this value handle.  IDs are handed out in a
-      conveniently dense form starting at 0, so that we can make
-      bitmaps of value handles.  */
-   unsigned int id;
- };
- 
- /* 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),
- 		      desc ("tree_node_structure (&%h)")))
- {
-   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_vector GTY ((tag ("TS_VECTOR"))) vector;
-   struct tree_string GTY ((tag ("TS_STRING"))) string;
-   struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
-   struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
-   struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal;
-   struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common;
-   struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl;
-   struct tree_decl_non_common  GTY ((tag ("TS_DECL_NON_COMMON"))) decl_non_common;
-   struct tree_parm_decl  GTY  ((tag ("TS_PARM_DECL"))) parm_decl;
-   struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis;
-   struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl;
-   struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl;
-   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_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;
-   struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi;
-   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 gimple_stmt GTY ((tag ("TS_GIMPLE_STATEMENT"))) gstmt;
-   struct tree_value_handle GTY ((tag ("TS_VALUE_HANDLE"))) value_handle;
-   struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
-   struct tree_memory_tag GTY ((tag ("TS_MEMORY_TAG"))) mtag;
-   struct tree_struct_field_tag GTY ((tag ("TS_STRUCT_FIELD_TAG"))) sft;
-   struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
-   struct tree_memory_partition_tag GTY ((tag ("TS_MEMORY_PARTITION_TAG"))) mpt;
- };
  
  /* Standard named or nameless data types of the C compiler.  */
  
--- 3458,3468 ----
Index: gcc/tree-ssa-pre.c
===================================================================
*** gcc/tree-ssa-pre.c	(revision 130472)
--- gcc/tree-ssa-pre.c	(working copy)
*************** create_component_ref_by_pieces (basic_bl
*** 2157,2163 ****
        genop = expression_for_id (firstbit);
      }
  
!   switch TREE_CODE (genop)
      {
      case ARRAY_REF:
        {
--- 2157,2163 ----
        genop = expression_for_id (firstbit);
      }
  
!   switch (TREE_CODE (genop))
      {
      case ARRAY_REF:
        {