Split all the structures, enums, typedefs and some fundamental declarations from tree.h into tree-core.h.

Split all the structures, enums, typedefs and some fundamental
declarations from tree.h into tree-core.h.  Everything else stays in
tree.h for now.

As we convert gimple files, we'll move declarations out of tree.h into
other headers and rewrite missing functions in the new gimple API.

	* Makefile.in (TREE_CORE_H): Define.
	(TREE_H): Use.
	(GTFILES): Add tree-core.h.
	* builtins.c (built_in_class_names): Use BUILT_IN_LAST to
	size the array.
	* tree-core.h: New file.
	Move all data structures, enum, typedefs, global
	declarations and constants from ...
	* tree.h: ... here.

From-SVN: r202172

5 files changed, 1710 insertions, 1705 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 498f68e..94e9992 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -67,6 +67,18 @@
 	* config/darwin.h (LINK_COMMAND_SPEC_A): Revise sanitizer specs to
 	include sanitize(undefined).
 
+2013-08-31  Diego Novillo  <dnovillo@google.com>
+
+	* Makefile.in (TREE_CORE_H): Define.
+	(TREE_H): Use.
+	(GTFILES): Add tree-core.h.
+	* builtins.c (built_in_class_names): Use BUILT_IN_LAST to
+	size the array.
+	* tree-core.h: New file.
+	Move all data structures, enum, typedefs, global
+	declarations and constants from ...
+	* tree.h: ... here.
+
 2013-08-31  Jan Hubicka  <jh@suse.cz>
 
 	* bulitins.c (expand_builtin): Do not early exit for gcov
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 2512410..77166d6 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -872,11 +872,13 @@ BUILTINS_DEF = builtins.def sync-builtins.def omp-builtins.def \
 	gtm-builtins.def sanitizer.def cilkplus.def
 INTERNAL_FN_DEF = internal-fn.def
 INTERNAL_FN_H = internal-fn.h $(INTERNAL_FN_DEF)
-TREE_H = coretypes.h tree.h all-tree.def tree.def c-family/c-common.def \
-	$(lang_tree_files) $(MACHMODE_H) tree-check.h $(BUILTINS_DEF) \
-	$(INPUT_H) statistics.h $(VEC_H) treestruct.def $(HASHTAB_H) \
+TREE_CORE_H = tree-core.h coretypes.h all-tree.def tree.def \
+	c-family/c-common.def $(lang_tree_files) $(MACHMODE_H) \
+	$(BUILTINS_DEF) $(INPUT_H) statistics.h \
+	$(VEC_H) treestruct.def $(HASHTAB_H) \
 	double-int.h alias.h $(SYMTAB_H) $(FLAGS_H) \
 	$(REAL_H) $(FIXED_VALUE_H)
+TREE_H = tree.h $(TREE_CORE_H)  tree-check.h
 REGSET_H = regset.h $(BITMAP_H) hard-reg-set.h
 BASIC_BLOCK_H = basic-block.h $(PREDICT_H) $(VEC_H) $(FUNCTION_H) \
 	cfg-flags.def cfghooks.h
@@ -3795,7 +3797,8 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \
   $(host_xm_file_list) \
   $(tm_file_list) $(HASHTAB_H) $(SPLAY_TREE_H) $(srcdir)/bitmap.h \
   $(srcdir)/alias.h $(srcdir)/coverage.c $(srcdir)/rtl.h \
-  $(srcdir)/optabs.h $(srcdir)/tree.h $(srcdir)/libfuncs.h $(SYMTAB_H) \
+  $(srcdir)/optabs.h $(srcdir)/tree.h $(srcdir)/tree-core.h \
+  $(srcdir)/libfuncs.h $(SYMTAB_H) \
   $(srcdir)/real.h $(srcdir)/function.h $(srcdir)/insn-addr.h $(srcdir)/hwint.h \
   $(srcdir)/fixed-value.h \
   $(srcdir)/output.h $(srcdir)/cfgloop.h \
diff --git a/gcc/builtins.c b/gcc/builtins.c
index 581a050..bb44a7f 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -62,7 +62,7 @@ struct target_builtins *this_target_builtins = &default_target_builtins;
 #endif
 
 /* Define the names of the builtin function types and codes.  */
-const char *const built_in_class_names[4]
+const char *const built_in_class_names[BUILT_IN_LAST]
   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
 
 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
new file mode 100644
index 0000000..57d5e9c
--- /dev/null
+++ b/gcc/tree-core.h
@@ -0,0 +1,1688 @@
+/* Core data structures for the 'tree' type.
+   Copyright (C) 1989-2013 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef GCC_TREE_CORE_H
+#define GCC_TREE_CORE_H
+
+#include "hashtab.h"
+#include "machmode.h"
+#include "input.h"
+#include "statistics.h"
+#include "vec.h"
+#include "double-int.h"
+#include "real.h"
+#include "fixed-value.h"
+#include "alias.h"
+#include "flags.h"
+#include "symtab.h"
+
+/* This file contains all the data structures that define the 'tree' type.
+   There are no accessor macros nor functions in this file. Only the
+   basic data structures, extern declarations and type definitions.  */
+
+/*---------------------------------------------------------------------------
+   Forward type declarations.  Mostly to avoid including unnecessary headers
+---------------------------------------------------------------------------*/
+struct function;
+struct real_value;
+struct fixed_value;
+struct ptr_info_def;
+struct die_struct;
+struct pointer_set_t;
+
+
+/*---------------------------------------------------------------------------
+                              #defined constants
+---------------------------------------------------------------------------*/
+/* Nonzero if this is a call to a function whose return value depends
+   solely on its arguments, has no side effects, and does not read
+   global memory.  This corresponds to TREE_READONLY for function
+   decls.  */
+#define ECF_CONST		  (1 << 0)
+
+/* Nonzero if this is a call to "pure" function (like const function,
+   but may read memory.  This corresponds to DECL_PURE_P for function
+   decls.  */
+#define ECF_PURE		  (1 << 1)
+
+/* Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no
+   infinite loop.  This corresponds to DECL_LOOPING_CONST_OR_PURE_P
+   for function decls.*/
+#define ECF_LOOPING_CONST_OR_PURE (1 << 2)
+
+/* Nonzero if this call will never return.  */
+#define ECF_NORETURN		  (1 << 3)
+
+/* Nonzero if this is a call to malloc or a related function.  */
+#define ECF_MALLOC		  (1 << 4)
+
+/* Nonzero if it is plausible that this is a call to alloca.  */
+#define ECF_MAY_BE_ALLOCA	  (1 << 5)
+
+/* Nonzero if this is a call to a function that won't throw an exception.  */
+#define ECF_NOTHROW		  (1 << 6)
+
+/* Nonzero if this is a call to setjmp or a related function.  */
+#define ECF_RETURNS_TWICE	  (1 << 7)
+
+/* 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)
+
+/* Nonzero if this call does not affect transactions.  */
+#define ECF_TM_PURE		  (1 << 11)
+
+/* Nonzero if this call is into the transaction runtime library.  */
+#define ECF_TM_BUILTIN		  (1 << 12)
+
+/* 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)
+
+
+/*---------------------------------------------------------------------------
+                                  Enumerations
+---------------------------------------------------------------------------*/
+/* Codes of tree nodes.  */
+#define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
+#define END_OF_BASE_TREE_CODES LAST_AND_UNUSED_TREE_CODE,
+
+enum tree_code {
+#include "all-tree.def"
+MAX_TREE_CODES
+};
+
+#undef DEFTREECODE
+#undef END_OF_BASE_TREE_CODES
+
+/* Number of language-independent tree codes.  */
+#define NUM_TREE_CODES \
+  ((int) LAST_AND_UNUSED_TREE_CODE)
+
+#define CODE_CONTAINS_STRUCT(CODE, STRUCT) \
+  (tree_contains_struct[(CODE)][(STRUCT)])
+
+
+/* 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
+};
+
+/* Last marker used for LTO stremaing of built_in_class.  We can not add it
+   to the enum since we need the enumb to fit in 2 bits.  */
+#define BUILT_IN_LAST (BUILT_IN_NORMAL + 1)
+
+/* 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
+
+/* 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.  */
+};
+
+/* OMP_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 {
+  /* Clause zero is special-cased inside the parser
+     (c_parser_omp_variable_list).  */
+  OMP_CLAUSE_ERROR = 0,
+
+  /* OpenMP clause: private (variable_list).  */
+  OMP_CLAUSE_PRIVATE,
+
+  /* OpenMP clause: shared (variable_list).  */
+  OMP_CLAUSE_SHARED,
+
+  /* OpenMP clause: firstprivate (variable_list).  */
+  OMP_CLAUSE_FIRSTPRIVATE,
+
+  /* OpenMP clause: lastprivate (variable_list).  */
+  OMP_CLAUSE_LASTPRIVATE,
+
+  /* OpenMP clause: reduction (operator:variable_list).
+     OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator.
+     Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var.
+     Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var
+                into the shared one.
+     Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL
+                placeholder used in OMP_CLAUSE_REDUCTION_{INIT,MERGE}.  */
+  OMP_CLAUSE_REDUCTION,
+
+  /* OpenMP clause: copyin (variable_list).  */
+  OMP_CLAUSE_COPYIN,
+
+  /* OpenMP clause: copyprivate (variable_list).  */
+  OMP_CLAUSE_COPYPRIVATE,
+
+  /* OpenMP clause: linear (variable-list[:linear-step]).  */
+  OMP_CLAUSE_LINEAR,
+
+  /* OpenMP clause: uniform (argument-list).  */
+  OMP_CLAUSE_UNIFORM,
+
+  /* OpenMP clause: if (scalar-expression).  */
+  OMP_CLAUSE_IF,
+
+  /* OpenMP clause: num_threads (integer-expression).  */
+  OMP_CLAUSE_NUM_THREADS,
+
+  /* OpenMP clause: schedule.  */
+  OMP_CLAUSE_SCHEDULE,
+
+  /* OpenMP clause: nowait.  */
+  OMP_CLAUSE_NOWAIT,
+
+  /* OpenMP clause: ordered.  */
+  OMP_CLAUSE_ORDERED,
+
+  /* OpenMP clause: default.  */
+  OMP_CLAUSE_DEFAULT,
+
+  /* OpenMP clause: collapse (constant-integer-expression).  */
+  OMP_CLAUSE_COLLAPSE,
+
+  /* OpenMP clause: untied.  */
+  OMP_CLAUSE_UNTIED,
+
+  /* OpenMP clause: final (scalar-expression).  */
+  OMP_CLAUSE_FINAL,
+
+  /* OpenMP clause: mergeable.  */
+  OMP_CLAUSE_MERGEABLE,
+
+  /* OpenMP clause: safelen (constant-integer-expression).  */
+  OMP_CLAUSE_SAFELEN,
+
+  /* Internally used only clause, holding SIMD uid.  */
+  OMP_CLAUSE__SIMDUID_
+};
+
+#undef DEFTREESTRUCT
+#define DEFTREESTRUCT(ENUM, NAME) ENUM,
+enum tree_node_structure_enum {
+#include "treestruct.def"
+  LAST_TS_ENUM
+};
+#undef DEFTREESTRUCT
+
+enum omp_clause_schedule_kind {
+  OMP_CLAUSE_SCHEDULE_STATIC,
+  OMP_CLAUSE_SCHEDULE_DYNAMIC,
+  OMP_CLAUSE_SCHEDULE_GUIDED,
+  OMP_CLAUSE_SCHEDULE_AUTO,
+  OMP_CLAUSE_SCHEDULE_RUNTIME
+};
+
+enum omp_clause_default_kind {
+  OMP_CLAUSE_DEFAULT_UNSPECIFIED,
+  OMP_CLAUSE_DEFAULT_SHARED,
+  OMP_CLAUSE_DEFAULT_NONE,
+  OMP_CLAUSE_DEFAULT_PRIVATE,
+  OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
+};
+
+/* There is a TYPE_QUAL value for each type qualifier.  They can be
+   combined by bitwise-or to form the complete set of qualifiers for a
+   type.  */
+enum cv_qualifier {
+  TYPE_UNQUALIFIED   = 0x0,
+  TYPE_QUAL_CONST    = 0x1,
+  TYPE_QUAL_VOLATILE = 0x2,
+  TYPE_QUAL_RESTRICT = 0x4
+};
+
+/* Enumerate visibility settings.  */
+#ifndef SYMBOL_VISIBILITY_DEFINED
+#define SYMBOL_VISIBILITY_DEFINED
+enum symbol_visibility {
+  VISIBILITY_DEFAULT,
+  VISIBILITY_PROTECTED,
+  VISIBILITY_HIDDEN,
+  VISIBILITY_INTERNAL
+};
+#endif  // SYMBOL_VISIBILITY_DEFINED
+
+/* Standard named or nameless data types of the C compiler.  */
+enum tree_index {
+  TI_ERROR_MARK,
+  TI_INTQI_TYPE,
+  TI_INTHI_TYPE,
+  TI_INTSI_TYPE,
+  TI_INTDI_TYPE,
+  TI_INTTI_TYPE,
+
+  TI_UINTQI_TYPE,
+  TI_UINTHI_TYPE,
+  TI_UINTSI_TYPE,
+  TI_UINTDI_TYPE,
+  TI_UINTTI_TYPE,
+
+  TI_UINT16_TYPE,
+  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,
+
+  TI_BITSIZE_ZERO,
+  TI_BITSIZE_ONE,
+  TI_BITSIZE_UNIT,
+
+  TI_PUBLIC,
+  TI_PROTECTED,
+  TI_PRIVATE,
+
+  TI_BOOLEAN_FALSE,
+  TI_BOOLEAN_TRUE,
+
+  TI_COMPLEX_INTEGER_TYPE,
+  TI_COMPLEX_FLOAT_TYPE,
+  TI_COMPLEX_DOUBLE_TYPE,
+  TI_COMPLEX_LONG_DOUBLE_TYPE,
+
+  TI_FLOAT_TYPE,
+  TI_DOUBLE_TYPE,
+  TI_LONG_DOUBLE_TYPE,
+
+  TI_FLOAT_PTR_TYPE,
+  TI_DOUBLE_PTR_TYPE,
+  TI_LONG_DOUBLE_PTR_TYPE,
+  TI_INTEGER_PTR_TYPE,
+
+  TI_VOID_TYPE,
+  TI_PTR_TYPE,
+  TI_CONST_PTR_TYPE,
+  TI_SIZE_TYPE,
+  TI_PID_TYPE,
+  TI_PTRDIFF_TYPE,
+  TI_VA_LIST_TYPE,
+  TI_VA_LIST_GPR_COUNTER_FIELD,
+  TI_VA_LIST_FPR_COUNTER_FIELD,
+  TI_BOOLEAN_TYPE,
+  TI_FILEPTR_TYPE,
+  TI_POINTER_SIZED_TYPE,
+
+  TI_DFLOAT32_TYPE,
+  TI_DFLOAT64_TYPE,
+  TI_DFLOAT128_TYPE,
+  TI_DFLOAT32_PTR_TYPE,
+  TI_DFLOAT64_PTR_TYPE,
+  TI_DFLOAT128_PTR_TYPE,
+
+  TI_VOID_LIST_NODE,
+
+  TI_MAIN_IDENTIFIER,
+
+  TI_SAT_SFRACT_TYPE,
+  TI_SAT_FRACT_TYPE,
+  TI_SAT_LFRACT_TYPE,
+  TI_SAT_LLFRACT_TYPE,
+  TI_SAT_USFRACT_TYPE,
+  TI_SAT_UFRACT_TYPE,
+  TI_SAT_ULFRACT_TYPE,
+  TI_SAT_ULLFRACT_TYPE,
+  TI_SFRACT_TYPE,
+  TI_FRACT_TYPE,
+  TI_LFRACT_TYPE,
+  TI_LLFRACT_TYPE,
+  TI_USFRACT_TYPE,
+  TI_UFRACT_TYPE,
+  TI_ULFRACT_TYPE,
+  TI_ULLFRACT_TYPE,
+  TI_SAT_SACCUM_TYPE,
+  TI_SAT_ACCUM_TYPE,
+  TI_SAT_LACCUM_TYPE,
+  TI_SAT_LLACCUM_TYPE,
+  TI_SAT_USACCUM_TYPE,
+  TI_SAT_UACCUM_TYPE,
+  TI_SAT_ULACCUM_TYPE,
+  TI_SAT_ULLACCUM_TYPE,
+  TI_SACCUM_TYPE,
+  TI_ACCUM_TYPE,
+  TI_LACCUM_TYPE,
+  TI_LLACCUM_TYPE,
+  TI_USACCUM_TYPE,
+  TI_UACCUM_TYPE,
+  TI_ULACCUM_TYPE,
+  TI_ULLACCUM_TYPE,
+  TI_QQ_TYPE,
+  TI_HQ_TYPE,
+  TI_SQ_TYPE,
+  TI_DQ_TYPE,
+  TI_TQ_TYPE,
+  TI_UQQ_TYPE,
+  TI_UHQ_TYPE,
+  TI_USQ_TYPE,
+  TI_UDQ_TYPE,
+  TI_UTQ_TYPE,
+  TI_SAT_QQ_TYPE,
+  TI_SAT_HQ_TYPE,
+  TI_SAT_SQ_TYPE,
+  TI_SAT_DQ_TYPE,
+  TI_SAT_TQ_TYPE,
+  TI_SAT_UQQ_TYPE,
+  TI_SAT_UHQ_TYPE,
+  TI_SAT_USQ_TYPE,
+  TI_SAT_UDQ_TYPE,
+  TI_SAT_UTQ_TYPE,
+  TI_HA_TYPE,
+  TI_SA_TYPE,
+  TI_DA_TYPE,
+  TI_TA_TYPE,
+  TI_UHA_TYPE,
+  TI_USA_TYPE,
+  TI_UDA_TYPE,
+  TI_UTA_TYPE,
+  TI_SAT_HA_TYPE,
+  TI_SAT_SA_TYPE,
+  TI_SAT_DA_TYPE,
+  TI_SAT_TA_TYPE,
+  TI_SAT_UHA_TYPE,
+  TI_SAT_USA_TYPE,
+  TI_SAT_UDA_TYPE,
+  TI_SAT_UTA_TYPE,
+
+  TI_OPTIMIZATION_DEFAULT,
+  TI_OPTIMIZATION_CURRENT,
+  TI_TARGET_OPTION_DEFAULT,
+  TI_TARGET_OPTION_CURRENT,
+  TI_CURRENT_TARGET_PRAGMA,
+  TI_CURRENT_OPTIMIZE_PRAGMA,
+
+  TI_MAX
+};
+
+/* An enumeration of the standard C integer types.  These must be
+   ordered so that shorter types appear before longer ones, and so
+   that signed types appear before unsigned ones, for the correct
+   functioning of interpret_integer() in c-lex.c.  */
+enum integer_type_kind {
+  itk_char,
+  itk_signed_char,
+  itk_unsigned_char,
+  itk_short,
+  itk_unsigned_short,
+  itk_int,
+  itk_unsigned_int,
+  itk_long,
+  itk_unsigned_long,
+  itk_long_long,
+  itk_unsigned_long_long,
+  itk_int128,
+  itk_unsigned_int128,
+  itk_none
+};
+
+/* A pointer-to-function member type looks like:
+
+     struct {
+       __P __pfn;
+       ptrdiff_t __delta;
+     };
+
+   If __pfn is NULL, it is a NULL pointer-to-member-function.
+
+   (Because the vtable is always the first thing in the object, we
+   don't need its offset.)  If the function is virtual, then PFN is
+   one plus twice the index into the vtable; otherwise, it is just a
+   pointer to the function.
+
+   Unfortunately, using the lowest bit of PFN doesn't work in
+   architectures that don't impose alignment requirements on function
+   addresses, or that use the lowest bit to tell one ISA from another,
+   for example.  For such architectures, we use the lowest bit of
+   DELTA instead of the lowest bit of the PFN, and DELTA will be
+   multiplied by 2.  */
+enum ptrmemfunc_vbit_where_t {
+  ptrmemfunc_vbit_in_pfn,
+  ptrmemfunc_vbit_in_delta
+};
+
+/* Flags that may be passed in the third argument of decl_attributes, and
+   to handler functions for attributes.  */
+enum attribute_flags {
+  /* The type passed in is the type of a DECL, and any attributes that
+     should be passed in again to be applied to the DECL rather than the
+     type should be returned.  */
+  ATTR_FLAG_DECL_NEXT = 1,
+  /* The type passed in is a function return type, and any attributes that
+     should be passed in again to be applied to the function type rather
+     than the return type should be returned.  */
+  ATTR_FLAG_FUNCTION_NEXT = 2,
+  /* The type passed in is an array element type, and any attributes that
+     should be passed in again to be applied to the array type rather
+     than the element type should be returned.  */
+  ATTR_FLAG_ARRAY_NEXT = 4,
+  /* The type passed in is a structure, union or enumeration type being
+     created, and should be modified in place.  */
+  ATTR_FLAG_TYPE_IN_PLACE = 8,
+  /* The attributes are being applied by default to a library function whose
+     name indicates known behavior, and should be silently ignored if they
+     are not in fact compatible with the function type.  */
+  ATTR_FLAG_BUILT_IN = 16,
+  /* A given attribute has been parsed as a C++-11 attribute.  */
+  ATTR_FLAG_CXX11 = 32
+};
+
+/* Types used to represent sizes.  */
+enum size_type_kind {
+  stk_sizetype,		/* Normal representation of sizes in bytes.  */
+  stk_ssizetype,	/* Signed representation of sizes in bytes.  */
+  stk_bitsizetype,	/* Normal representation of sizes in bits.  */
+  stk_sbitsizetype,	/* Signed representation of sizes in bits.  */
+  stk_type_kind_last
+};
+
+enum operand_equal_flag {
+  OEP_ONLY_CONST = 1,
+  OEP_PURE_SAME = 2,
+  OEP_CONSTANT_ADDRESS_OF = 4
+};
+
+/* Enum and arrays used for tree allocation stats.
+   Keep in sync with tree.c:tree_node_kind_names.  */
+enum tree_node_kind {
+  d_kind,
+  t_kind,
+  b_kind,
+  s_kind,
+  r_kind,
+  e_kind,
+  c_kind,
+  id_kind,
+  vec_kind,
+  binfo_kind,
+  ssa_name_kind,
+  constr_kind,
+  x_kind,
+  lang_decl,
+  lang_type,
+  omp_clause_kind,
+  all_kinds
+};
+
+
+/*---------------------------------------------------------------------------
+                                Type definitions
+---------------------------------------------------------------------------*/
+/* When processing aliases at the symbol table level, we need the
+   declaration of target. For this reason we need to queue aliases and
+   process them after all declarations has been produced.  */
+typedef struct GTY(()) alias_pair {
+  tree decl;
+  tree target;
+} alias_pair;
+
+/* An initialization priority.  */
+typedef unsigned short priority_type;
+
+/* The type of a callback function for walking over tree structure.  */
+typedef tree (*walk_tree_fn) (tree *, int *, void *);
+
+/* The type of a callback function that represents a custom walk_tree.  */
+typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *),
+			      void *, struct pointer_set_t*);
+
+
+/*---------------------------------------------------------------------------
+                              Main data structures
+---------------------------------------------------------------------------*/
+/* 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, and the table below which connects the fields and the
+   accessor macros.  */
+
+struct GTY(()) tree_base {
+  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 asm_written_flag: 1;
+  unsigned nowarning_flag : 1;
+  unsigned visited : 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 default_def_flag : 1;
+
+  union {
+    /* The bits in the following structure should only be used with
+       accessor macros that constrain inputs with tree checking.  */
+    struct {
+      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 saturating_flag : 1;
+
+      unsigned unsigned_flag : 1;
+      unsigned packed_flag : 1;
+      unsigned user_align : 1;
+      unsigned nameless_flag : 1;
+      unsigned spare0 : 4;
+
+      unsigned spare1 : 8;
+
+      /* This field is only used with TREE_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;
+    } bits;
+    /* The following fields are present in tree_base to save space.  The
+       nodes using them do not require any of the flags above and so can
+       make better use of the 4-byte sized word.  */
+    /* VEC length.  This field is only used with TREE_VEC.  */
+    int length;
+    /* SSA version number.  This field is only used with SSA_NAME.  */
+    unsigned int version;
+  } GTY((skip(""))) u;
+};
+
+/* The following table lists the uses of each of the above flags and
+   for which types of nodes they are defined.
+
+   addressable_flag:
+
+       TREE_ADDRESSABLE in
+           VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL
+           SSA_NAME
+           all types
+           CONSTRUCTOR, IDENTIFIER_NODE
+           STMT_EXPR
+
+       CALL_EXPR_TAILCALL in
+           CALL_EXPR
+
+       CASE_LOW_SEEN in
+           CASE_LABEL_EXPR
+
+       PREDICT_EXPR_OUTCOME in
+	   PREDICT_EXPR
+
+   static_flag:
+
+       TREE_STATIC in
+           VAR_DECL, FUNCTION_DECL
+           CONSTRUCTOR
+
+       TREE_NO_TRAMPOLINE in
+           ADDR_EXPR
+
+       BINFO_VIRTUAL_P in
+           TREE_BINFO
+
+       TREE_SYMBOL_REFERENCED in
+           IDENTIFIER_NODE
+
+       CLEANUP_EH_ONLY in
+           TARGET_EXPR, WITH_CLEANUP_EXPR
+
+       TRY_CATCH_IS_CLEANUP in
+           TRY_CATCH_EXPR
+
+       ASM_INPUT_P in
+           ASM_EXPR
+
+       TYPE_REF_CAN_ALIAS_ALL in
+           POINTER_TYPE, REFERENCE_TYPE
+
+       CASE_HIGH_SEEN in
+           CASE_LABEL_EXPR
+
+       ENUM_IS_SCOPED in
+	   ENUMERAL_TYPE
+
+       TRANSACTION_EXPR_OUTER in
+	   TRANSACTION_EXPR
+
+   public_flag:
+
+       TREE_OVERFLOW in
+           INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
+
+       TREE_PUBLIC in
+           VAR_DECL, FUNCTION_DECL
+           IDENTIFIER_NODE
+
+       ASM_VOLATILE_P in
+           ASM_EXPR
+
+       CALL_EXPR_VA_ARG_PACK in
+           CALL_EXPR
+
+       TYPE_CACHED_VALUES_P in
+           all types
+
+       SAVE_EXPR_RESOLVED_P in
+           SAVE_EXPR
+
+       OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
+           OMP_CLAUSE_LASTPRIVATE
+
+       OMP_CLAUSE_PRIVATE_DEBUG in
+           OMP_CLAUSE_PRIVATE
+
+       TRANSACTION_EXPR_RELAXED in
+	   TRANSACTION_EXPR
+
+   private_flag:
+
+       TREE_PRIVATE in
+           all decls
+
+       CALL_EXPR_RETURN_SLOT_OPT in
+           CALL_EXPR
+
+       OMP_SECTION_LAST in
+           OMP_SECTION
+
+       OMP_PARALLEL_COMBINED in
+           OMP_PARALLEL
+
+       OMP_CLAUSE_PRIVATE_OUTER_REF in
+	   OMP_CLAUSE_PRIVATE
+
+       TYPE_REF_IS_RVALUE in
+	   REFERENCE_TYPE
+
+       ENUM_IS_OPAQUE in
+	   ENUMERAL_TYPE
+
+   protected_flag:
+
+       TREE_PROTECTED in
+           BLOCK
+           all decls
+
+       CALL_FROM_THUNK_P and
+       CALL_ALLOCA_FOR_VAR_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
+           all decls
+
+       TYPE_VOLATILE in
+           all types
+
+   readonly_flag:
+
+       TREE_READONLY in
+           all expressions
+           all decls
+
+       TYPE_READONLY in
+           all types
+
+   constant_flag:
+
+       TREE_CONSTANT in
+           all expressions
+           all decls
+           all constants
+
+       TYPE_SIZES_GIMPLIFIED in
+           all types
+
+   unsigned_flag:
+
+       TYPE_UNSIGNED in
+           all types
+
+       DECL_UNSIGNED in
+           all decls
+
+   asm_written_flag:
+
+       TREE_ASM_WRITTEN in
+           VAR_DECL, FUNCTION_DECL, TYPE_DECL
+           RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
+           BLOCK, STRING_CST
+
+       SSA_NAME_OCCURS_IN_ABNORMAL_PHI in
+           SSA_NAME
+
+   used_flag:
+
+       TREE_USED in
+           all expressions
+           all decls
+           IDENTIFIER_NODE
+
+   nothrow_flag:
+
+       TREE_NOTHROW in
+           CALL_EXPR
+           FUNCTION_DECL
+
+       TYPE_ALIGN_OK in
+           all types
+
+       TREE_THIS_NOTRAP in
+          INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF
+
+       SSA_NAME_IN_FREELIST in
+          SSA_NAME
+
+   deprecated_flag:
+
+       TREE_DEPRECATED in
+           all decls
+	   all types
+
+       IDENTIFIER_TRANSPARENT_ALIAS in
+           IDENTIFIER_NODE
+
+   visited:
+
+       TREE_VISITED in
+           all trees (used liberally by many passes)
+
+   saturating_flag:
+
+       TYPE_SATURATING in
+           all types
+
+       VAR_DECL_IS_VIRTUAL_OPERAND in
+	   VAR_DECL
+
+   nowarning_flag:
+
+       TREE_NO_WARNING in
+           all expressions
+           all decls
+
+       TYPE_ARTIFICIAL in
+           all types
+
+   default_def_flag:
+
+       TYPE_VECTOR_OPAQUE in
+	   VECTOR_TYPE
+
+       SSA_NAME_IS_DEFAULT_DEF in
+           SSA_NAME
+
+       DECL_NONLOCAL_FRAME in
+	   VAR_DECL
+*/
+
+struct GTY(()) tree_typed {
+  struct tree_base base;
+  tree type;
+};
+
+struct GTY(()) tree_common {
+  struct tree_typed typed;
+  tree chain;
+};
+
+struct GTY(()) tree_int_cst {
+  struct tree_typed typed;
+  double_int int_cst;
+};
+
+
+struct GTY(()) tree_real_cst {
+  struct tree_typed typed;
+  struct real_value * real_cst_ptr;
+};
+
+struct GTY(()) tree_fixed_cst {
+  struct tree_typed typed;
+  struct fixed_value * fixed_cst_ptr;
+};
+
+struct GTY(()) tree_string {
+  struct tree_typed typed;
+  int length;
+  char str[1];
+};
+
+struct GTY(()) tree_complex {
+  struct tree_typed typed;
+  tree real;
+  tree imag;
+};
+
+struct GTY(()) tree_vector {
+  struct tree_typed typed;
+  tree GTY ((length ("TYPE_VECTOR_SUBPARTS (TREE_TYPE ((tree)&%h))"))) elts[1];
+};
+
+struct GTY(()) tree_identifier {
+  struct tree_common common;
+  struct ht_identifier id;
+};
+
+struct GTY(()) tree_list {
+  struct tree_common common;
+  tree purpose;
+  tree value;
+};
+
+struct GTY(()) tree_vec {
+  struct tree_common common;
+  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 GTY(()) constructor_elt_d {
+  tree index;
+  tree value;
+} constructor_elt;
+
+struct GTY(()) tree_constructor {
+  struct tree_typed typed;
+  vec<constructor_elt, va_gc> *elts;
+};
+
+struct GTY(()) tree_exp {
+  struct tree_typed typed;
+  location_t locus;
+  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 GTY(()) ssa_use_operand_d {
+  struct ssa_use_operand_d* GTY((skip(""))) prev;
+  struct ssa_use_operand_d* GTY((skip(""))) next;
+  /* Immediate uses for a given SSA name are maintained as a cyclic
+     list.  To recognize the root of this list, the location field
+     needs to point to the original SSA name.  Since statements and
+     SSA names are of different data types, we need this union.  See
+     the explanation in struct immediate_use_iterator_d.  */
+  union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc;
+  tree *GTY((skip(""))) use;
+} ssa_use_operand_t;
+
+struct GTY(()) tree_ssa_name {
+  struct tree_typed typed;
+
+  /* _DECL wrapped by this SSA name.  */
+  tree var;
+
+  /* Statement that defines this SSA name.  */
+  gimple def_stmt;
+
+  /* Pointer attributes used for alias analysis.  */
+  struct ptr_info_def *ptr_info;
+
+  /* Immediate uses list for this SSA_NAME.  */
+  struct ssa_use_operand_d imm_uses;
+};
+
+struct GTY(()) phi_arg_d {
+  /* imm_use MUST be the first element in struct because we do some
+     pointer arithmetic with it.  See phi_arg_index_from_use.  */
+  struct ssa_use_operand_d imm_use;
+  tree def;
+  location_t locus;
+};
+
+struct GTY(()) tree_omp_clause {
+  struct tree_common common;
+  location_t locus;
+  enum omp_clause_code code;
+  union omp_clause_subcode {
+    enum omp_clause_default_kind  default_kind;
+    enum omp_clause_schedule_kind schedule_kind;
+    enum tree_code                reduction_code;
+  } GTY ((skip)) subcode;
+
+  /* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's
+     usage.  */
+  gimple_seq gimple_reduction_init;
+  gimple_seq gimple_reduction_merge;
+
+  tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]")))
+    ops[1];
+};
+
+struct GTY(()) tree_block {
+  struct tree_base base;
+  tree chain;
+
+  unsigned abstract_flag : 1;
+  unsigned block_num : 31;
+
+  location_t locus;
+
+  tree vars;
+  vec<tree, va_gc> *nonlocalized_vars;
+
+  tree subblocks;
+  tree supercontext;
+  tree abstract_origin;
+  tree fragment_origin;
+  tree fragment_chain;
+};
+
+struct GTY(()) tree_type_common {
+  struct tree_common common;
+  tree size;
+  tree size_unit;
+  tree attributes;
+  unsigned int uid;
+
+  unsigned int precision : 10;
+  unsigned no_force_blk_flag : 1;
+  unsigned needs_constructing_flag : 1;
+  unsigned transparent_aggr_flag : 1;
+  unsigned restrict_flag : 1;
+  unsigned contains_placeholder_bits : 2;
+
+  ENUM_BITFIELD(machine_mode) mode : 8;
+
+  unsigned string_flag : 1;
+  unsigned lang_flag_0 : 1;
+  unsigned lang_flag_1 : 1;
+  unsigned lang_flag_2 : 1;
+  unsigned lang_flag_3 : 1;
+  unsigned lang_flag_4 : 1;
+  unsigned lang_flag_5 : 1;
+  unsigned lang_flag_6 : 1;
+
+  unsigned int align;
+  alias_set_type alias_set;
+  tree pointer_to;
+  tree reference_to;
+  union tree_type_symtab {
+    int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address;
+    const char * GTY ((tag ("TYPE_SYMTAB_IS_POINTER"))) pointer;
+    struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die;
+  } GTY ((desc ("debug_hooks->tree_type_symtab_field"))) symtab;
+  tree name;
+  tree next_variant;
+  tree main_variant;
+  tree context;
+  tree canonical;
+};
+
+struct GTY(()) tree_type_with_lang_specific {
+  struct tree_type_common common;
+  /* Points to a structure whose details depend on the language in use.  */
+  struct lang_type *lang_specific;
+};
+
+struct GTY(()) tree_type_non_common {
+  struct tree_type_with_lang_specific with_lang_specific;
+  tree values;
+  tree minval;
+  tree maxval;
+  tree binfo;
+};
+
+struct GTY (()) tree_binfo {
+  struct tree_common common;
+
+  tree offset;
+  tree vtable;
+  tree virtuals;
+  tree vptr_field;
+  vec<tree, va_gc> *base_accesses;
+  tree inheritance;
+
+  tree vtt_subvtt;
+  tree vtt_vptr;
+
+  vec<tree, va_gc> base_binfos;
+};
+
+struct GTY(()) tree_decl_minimal {
+  struct tree_common common;
+  location_t locus;
+  unsigned int uid;
+  tree name;
+  tree context;
+};
+
+struct GTY(()) tree_decl_common {
+  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 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;
+  unsigned lang_flag_8 : 1;
+
+  /* In LABEL_DECL, this is DECL_ERROR_ISSUED.
+     In VAR_DECL and PARM_DECL, this is DECL_REGISTER.  */
+  unsigned decl_flag_0 : 1;
+  /* In FIELD_DECL, this is DECL_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, PARM_DECL and RESULT_DECL, this is
+     DECL_HAS_VALUE_EXPR_P.  */
+  unsigned decl_flag_2 : 1;
+  /* 1 bit unused.  */
+  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 VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE.  */
+  unsigned decl_by_reference_flag : 1;
+  /* In a VAR_DECL and PARM_DECL, this is DECL_READ_P.  */
+  unsigned decl_read_flag : 1;
+  /* In a VAR_DECL or RESULT_DECL, this is DECL_NONSHAREABLE.  */
+  unsigned decl_nonshareable_flag : 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;
+
+  /* Points to a structure whose details depend on the language in use.  */
+  struct lang_decl *lang_specific;
+};
+
+struct GTY(()) tree_decl_with_rtl {
+  struct tree_decl_common common;
+  rtx rtl;
+};
+
+struct GTY(()) tree_field_decl {
+  struct tree_decl_common common;
+
+  tree offset;
+  tree bit_field_type;
+  tree qualifier;
+  tree bit_offset;
+  tree fcontext;
+};
+
+struct GTY(()) tree_label_decl {
+  struct tree_decl_with_rtl common;
+  int label_decl_uid;
+  int eh_landing_pad_nr;
+};
+
+struct GTY(()) tree_result_decl {
+  struct tree_decl_with_rtl common;
+};
+
+struct GTY(()) tree_const_decl {
+  struct tree_decl_common common;
+};
+
+struct GTY(()) tree_parm_decl {
+  struct tree_decl_with_rtl common;
+  rtx incoming_rtl;
+};
+
+struct GTY(()) tree_decl_with_vis {
+ struct tree_decl_with_rtl common;
+ tree assembler_name;
+ tree section_name;
+ tree comdat_group;
+
+ /* Belong to VAR_DECL exclusively.  */
+ unsigned defer_output : 1;
+ unsigned hard_register : 1;
+ unsigned common_flag : 1;
+ unsigned in_text_section : 1;
+ unsigned in_constant_pool : 1;
+ unsigned dllimport_flag : 1;
+ /* Don't belong to VAR_DECL exclusively.  */
+ unsigned weak_flag : 1;
+ /* When SECTION_NAME is implied by -ffunction-section.  */
+ unsigned implicit_section_name_p : 1;
+
+ unsigned seen_in_bind_expr : 1;
+ unsigned comdat_flag : 1;
+ ENUM_BITFIELD(symbol_visibility) visibility : 2;
+ unsigned visibility_specified : 1;
+ /* Belongs to VAR_DECL exclusively.  */
+ ENUM_BITFIELD(tls_model) tls_model : 3;
+
+ /* Belong to FUNCTION_DECL exclusively.  */
+ unsigned init_priority_p : 1;
+ /* Used by C++ only.  Might become a generic decl flag.  */
+ unsigned shadowed_for_var_p : 1;
+ /* Belong to FUNCTION_DECL exclusively.  */
+ unsigned cxx_constructor : 1;
+ /* Belong to FUNCTION_DECL exclusively.  */
+ unsigned cxx_destructor : 1;
+ /* Belong to FUNCTION_DECL exclusively.  */
+ unsigned final : 1;
+ /* 11 unused bits. */
+};
+
+struct GTY(()) tree_var_decl {
+  struct tree_decl_with_vis common;
+};
+
+struct GTY(()) tree_decl_non_common {
+  struct tree_decl_with_vis common;
+  /* C++ uses this in namespaces.  */
+  tree saved_tree;
+  /* C++ uses this in templates.  */
+  tree arguments;
+  /* Almost all FE's use this.  */
+  tree result;
+  /* C++ uses this in namespaces and function_decls.  */
+  tree vindex;
+};
+
+struct GTY(()) tree_function_decl {
+  struct tree_decl_non_common common;
+
+  struct function *f;
+
+  /* The personality function. Used for stack unwinding. */
+  tree personality;
+
+  /* Function specific options that are used by this function.  */
+  tree function_specific_target;	/* target options */
+  tree function_specific_optimization;	/* optimization options */
+
+  /* In a 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 operator_new_flag : 1;
+  unsigned declared_inline_flag : 1;
+  unsigned regdecl_flag : 1;
+  unsigned no_inline_warning_flag : 1;
+
+  unsigned no_instrument_function_entry_exit : 1;
+  unsigned no_limit_stack : 1;
+  unsigned disregard_inline_limits : 1;
+  unsigned pure_flag : 1;
+  unsigned looping_const_or_pure_flag : 1;
+  unsigned has_debug_args_flag : 1;
+  unsigned tm_clone_flag : 1;
+  unsigned versioned_function : 1;
+  /* No bits left.  */
+};
+
+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.  */
+};
+
+struct GTY(()) tree_type_decl {
+  struct tree_decl_non_common common;
+
+};
+
+struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) tree_statement_list_node
+ {
+  struct tree_statement_list_node *prev;
+  struct tree_statement_list_node *next;
+  tree stmt;
+};
+
+struct GTY(()) tree_statement_list
+ {
+  struct tree_typed typed;
+  struct tree_statement_list_node *head;
+  struct tree_statement_list_node *tail;
+};
+
+struct GTY(()) tree_optimization_option {
+  struct tree_common common;
+
+  /* The optimization options used by the user.  */
+  struct cl_optimization opts;
+
+  /* Target optabs for this set of optimization options.  This is of
+     type `struct target_optabs *'.  */
+  unsigned char *GTY ((atomic)) optabs;
+
+  /* The value of this_target_optabs against which the optabs above were
+     generated.  */
+  struct target_optabs *GTY ((skip)) base_optabs;
+};
+
+struct GTY(()) tree_target_option {
+  struct tree_common common;
+
+  /* The optimization options used by the user.  */
+  struct cl_target_option opts;
+};
+
+/* Define the overall contents of a tree node.
+   It may be any of the structures declared above
+   for various types of node.  */
+union GTY ((ptr_alias (union lang_tree_node),
+	    desc ("tree_node_structure (&%h)"), variable_size)) tree_node {
+  struct tree_base GTY ((tag ("TS_BASE"))) base;
+  struct tree_typed GTY ((tag ("TS_TYPED"))) typed;
+  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_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL")))
+    translation_unit_decl;
+  struct tree_type_common GTY ((tag ("TS_TYPE_COMMON"))) type_common;
+  struct tree_type_with_lang_specific GTY ((tag ("TS_TYPE_WITH_LANG_SPECIFIC")))
+    type_with_lang_specific;
+  struct tree_type_non_common GTY ((tag ("TS_TYPE_NON_COMMON")))
+    type_non_common;
+  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_block GTY ((tag ("TS_BLOCK"))) block;
+  struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo;
+  struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
+  struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
+  struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
+  struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization;
+  struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option;
+};
+
+/* Structure describing an attribute and a function to handle it.  */
+struct attribute_spec {
+  /* The name of the attribute (without any leading or trailing __),
+     or NULL to mark the end of a table of attributes.  */
+  const char *name;
+  /* The minimum length of the list of arguments of the attribute.  */
+  int min_length;
+  /* The maximum length of the list of arguments of the attribute
+     (-1 for no maximum).  */
+  int max_length;
+  /* Whether this attribute requires a DECL.  If it does, it will be passed
+     from types of DECLs, function return types and array element types to
+     the DECLs, function types and array types respectively; but when
+     applied to a type in any other circumstances, it will be ignored with
+     a warning.  (If greater control is desired for a given attribute,
+     this should be false, and the flags argument to the handler may be
+     used to gain greater control in that case.)  */
+  bool decl_required;
+  /* Whether this attribute requires a type.  If it does, it will be passed
+     from a DECL to the type of that DECL.  */
+  bool type_required;
+  /* Whether this attribute requires a function (or method) type.  If it does,
+     it will be passed from a function pointer type to the target type,
+     and from a function return type (which is not itself a function
+     pointer type) to the function type.  */
+  bool function_type_required;
+  /* Function to handle this attribute.  NODE points to the node to which
+     the attribute is to be applied.  If a DECL, it should be modified in
+     place; if a TYPE, a copy should be created.  NAME is the name of the
+     attribute (possibly with leading or trailing __).  ARGS is the TREE_LIST
+     of the arguments (which may be NULL).  FLAGS gives further information
+     about the context of the attribute.  Afterwards, the attributes will
+     be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
+     unless *NO_ADD_ATTRS is set to true (which should be done on error,
+     as well as in any other cases when the attributes should not be added
+     to the DECL or TYPE).  Depending on FLAGS, any attributes to be
+     applied to another type or DECL later may be returned;
+     otherwise the return value should be NULL_TREE.  This pointer may be
+     NULL if no special handling is required beyond the checks implied
+     by the rest of this structure.  */
+  tree (*handler) (tree *node, tree name, tree args,
+		   int flags, bool *no_add_attrs);
+  /* Specifies if attribute affects type's identity.  */
+  bool affects_type_identity;
+};
+
+/* These functions allow a front-end to perform a manual layout of a
+   RECORD_TYPE.  (For instance, if the placement of subsequent fields
+   depends on the placement of fields so far.)  Begin by calling
+   start_record_layout.  Then, call place_field for each of the
+   fields.  Then, call finish_record_layout.  See layout_type for the
+   default way in which these functions are used.  */
+typedef struct record_layout_info_s {
+  /* The RECORD_TYPE that we are laying out.  */
+  tree t;
+  /* The offset into the record so far, in bytes, not including bits in
+     BITPOS.  */
+  tree offset;
+  /* The last known alignment of SIZE.  */
+  unsigned int offset_align;
+  /* The bit position within the last OFFSET_ALIGN bits, in bits.  */
+  tree bitpos;
+  /* The alignment of the record so far, in bits.  */
+  unsigned int record_align;
+  /* The alignment of the record so far, ignoring #pragma pack and
+     __attribute__ ((packed)), in bits.  */
+  unsigned int unpacked_align;
+  /* The previous field laid out.  */
+  tree prev_field;
+  /* The static variables (i.e., class variables, as opposed to
+     instance variables) encountered in T.  */
+  vec<tree, va_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;
+} *record_layout_info;
+
+/* Iterator for going through the function arguments.  */
+struct function_args_iterator {
+  tree next;			/* TREE_LIST pointing to the next argument */
+};
+
+/* Structures to map from a tree to another tree.  */
+struct GTY(()) tree_map_base {
+  tree from;
+};
+
+struct GTY(()) tree_map {
+  struct tree_map_base base;
+  unsigned int hash;
+  tree to;
+};
+
+/* Map from a decl tree to another tree.  */
+struct GTY(()) tree_decl_map {
+  struct tree_map_base base;
+  tree to;
+};
+
+/* Map from a tree to an int.  */
+struct GTY(()) tree_int_map {
+  struct tree_map_base base;
+  unsigned int to;
+};
+
+/* Map from a tree to initialization/finalization priorities.  */
+struct GTY(()) tree_priority_map {
+  struct tree_map_base base;
+  priority_type init;
+  priority_type fini;
+};
+
+/* Map from a decl tree to a tree vector.  */
+struct GTY(()) tree_vec_map {
+  struct tree_map_base base;
+  vec<tree, va_gc> *to;
+};
+
+/* 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.  */
+struct call_expr_arg_iterator {
+  tree t;	/* the call_expr */
+  int n;	/* argument count */
+  int i;	/* next argument index */
+};
+
+struct const_call_expr_arg_iterator {
+  const_tree t;	/* the call_expr */
+  int n;	/* argument count */
+  int i;	/* next argument index */
+};
+
+/* The builtin_info structure holds the FUNCTION_DECL of the standard builtin
+   function, and a flag that says if the function is available implicitly, or
+   whether the user has to code explicit calls to __builtin_<xxx>.  */
+struct GTY(()) builtin_info_type {
+  tree decl[(int)END_BUILTINS];
+  bool implicit_p[(int)END_BUILTINS];
+};
+
+
+/*---------------------------------------------------------------------------
+                                Global variables
+---------------------------------------------------------------------------*/
+/* Matrix describing the structures contained in a given tree code.  */
+extern unsigned char tree_contains_struct[MAX_TREE_CODES][64];
+
+/* Class of tree given its code.  */
+extern const enum tree_code_class tree_code_type[];
+
+/* 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[];
+
+/* Number of argument-words in each kind of tree-node.  */
+extern const unsigned char tree_code_length[];
+
+/* Names of tree components.  */
+extern const char *const tree_code_name[];
+
+/* Vector of all alias pairs for global symbols.  */
+extern GTY(()) vec<alias_pair, va_gc> *alias_pairs;
+
+/* Names of all the built_in classes.  */
+extern const char *const built_in_class_names[BUILT_IN_LAST];
+
+/* Names of all the built_in functions.  */
+extern const char * built_in_names[(int) END_BUILTINS];
+
+/* Number of operands and names for each OMP_CLAUSE node.  */
+extern unsigned const char omp_clause_num_ops[];
+extern const char * const omp_clause_code_name[];
+
+/* A vector of all translation-units.  */
+extern GTY (()) vec<tree, va_gc> *all_translation_units;
+
+/* Vector of standard trees used by the C compiler.  */
+extern GTY(()) tree global_trees[TI_MAX];
+
+/* The standard C integer types.  Use integer_type_kind to index into
+   this array.  */
+extern GTY(()) tree integer_types[itk_none];
+
+/* Types used to represent sizes.  */
+extern GTY(()) tree sizetype_tab[(int) stk_type_kind_last];
+
+/* Arrays for keeping track of tree node statistics.  */
+extern int tree_node_counts[];
+extern int tree_node_sizes[];
+
+/* True if we are in gimple form and the actions of the folders need to
+   be restricted.  False if we are not in gimple form and folding is not
+   restricted to creating gimple expressions.  */
+extern bool in_gimple_form;
+
+/* Functional interface to the builtin functions.  */
+extern GTY(()) builtin_info_type builtin_info;
+
+/* If nonzero, an upper limit on alignment of structure fields, in bits,  */
+extern unsigned int maximum_field_alignment;
+
+/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
+   Zero means allow extended lvalues.  */
+extern int pedantic_lvalues;
+
+/* Points to the FUNCTION_DECL of the function whose body we are reading.  */
+extern GTY(()) tree current_function_decl;
+
+/* Nonzero means a FUNC_BEGIN label was emitted.  */
+extern GTY(()) const char * current_function_func_begin_label;
+
+#endif  // GCC_TREE_CORE_H
diff --git a/gcc/tree.h b/gcc/tree.h
index 83edaba..718d8f4 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -20,32 +20,7 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_TREE_H
 #define GCC_TREE_H
 
-#include "hashtab.h"
-#include "machmode.h"
-#include "input.h"
-#include "statistics.h"
-#include "vec.h"
-#include "double-int.h"
-#include "real.h"
-#include "fixed-value.h"
-#include "alias.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,
-
-enum tree_code {
-#include "all-tree.def"
-MAX_TREE_CODES
-};
-
-#undef DEFTREECODE
-#undef END_OF_BASE_TREE_CODES
-
-extern unsigned char tree_contains_struct[MAX_TREE_CODES][64];
-#define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)])
+#include "tree-core.h"
 
 /* Macros for initializing `tree_contains_struct'.  */
 #define MARK_TS_BASE(C)					\
@@ -107,42 +82,12 @@ extern unsigned char tree_contains_struct[MAX_TREE_CODES][64];
     tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;	\
   } while (0)
 
-/* 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.  */
-};
-
-/* 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.  */
@@ -231,76 +176,8 @@ extern const enum tree_code_class tree_code_type[];
 
 #define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
 
-/* 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[];
-
-/* When procesing aliases on symtab level, we need the declaration of target.
-   For this reason we need to queue aliases and process them after all declarations
-   has been produced.  */
-
-typedef struct GTY(()) alias_pair
-{
-  tree decl;
-  tree target;  
-} alias_pair;
-
-/* Define gc'd vector type.  */
-
-extern GTY(()) vec<alias_pair, va_gc> *alias_pairs;
-
-
-/* Classify which part of the compiler has defined a given builtin function.
-   Note that we assume below that this is no more than two bits.  */
-enum built_in_class
-{
-  NOT_BUILT_IN = 0,
-  BUILT_IN_FRONTEND,
-  BUILT_IN_MD,
-  BUILT_IN_NORMAL
-};
-
-/* Last marker used for LTO stremaing of built_in_class.  We can not add it
-   to the enum since we need the enumb to fit in 2 bits.  */
-#define BUILT_IN_LAST (BUILT_IN_NORMAL + 1)
-
-/* 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.  */
 
@@ -323,438 +200,6 @@ extern const char * built_in_names[(int) END_BUILTINS];
 #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: case FN##IMAX
-
-/* 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.  */
-enum omp_clause_code
-{
-  /* Clause zero is special-cased inside the parser
-     (c_parser_omp_variable_list).  */
-  OMP_CLAUSE_ERROR = 0,
-
-  /* OpenMP clause: private (variable_list).  */
-  OMP_CLAUSE_PRIVATE,
-
-  /* OpenMP clause: shared (variable_list).  */
-  OMP_CLAUSE_SHARED,
-
-  /* OpenMP clause: firstprivate (variable_list).  */
-  OMP_CLAUSE_FIRSTPRIVATE,
-
-  /* OpenMP clause: lastprivate (variable_list).  */
-  OMP_CLAUSE_LASTPRIVATE,
-
-  /* OpenMP clause: reduction (operator:variable_list).
-     OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator.
-     Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var.
-     Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var
-                into the shared one.
-     Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL
-                placeholder used in OMP_CLAUSE_REDUCTION_{INIT,MERGE}.  */
-  OMP_CLAUSE_REDUCTION,
-
-  /* OpenMP clause: copyin (variable_list).  */
-  OMP_CLAUSE_COPYIN,
-
-  /* OpenMP clause: copyprivate (variable_list).  */
-  OMP_CLAUSE_COPYPRIVATE,
-
-  /* OpenMP clause: linear (variable-list[:linear-step]).  */
-  OMP_CLAUSE_LINEAR,
-
-  /* OpenMP clause: uniform (argument-list).  */
-  OMP_CLAUSE_UNIFORM,
-
-  /* OpenMP clause: if (scalar-expression).  */
-  OMP_CLAUSE_IF,
-
-  /* OpenMP clause: num_threads (integer-expression).  */
-  OMP_CLAUSE_NUM_THREADS,
-
-  /* OpenMP clause: schedule.  */
-  OMP_CLAUSE_SCHEDULE,
-
-  /* OpenMP clause: nowait.  */
-  OMP_CLAUSE_NOWAIT,
-
-  /* OpenMP clause: ordered.  */
-  OMP_CLAUSE_ORDERED,
-
-  /* OpenMP clause: default.  */
-  OMP_CLAUSE_DEFAULT,
-
-  /* OpenMP clause: collapse (constant-integer-expression).  */
-  OMP_CLAUSE_COLLAPSE,
-
-  /* OpenMP clause: untied.  */
-  OMP_CLAUSE_UNTIED,
-
-  /* OpenMP clause: final (scalar-expression).  */
-  OMP_CLAUSE_FINAL,
-
-  /* OpenMP clause: mergeable.  */
-  OMP_CLAUSE_MERGEABLE,
-
-  /* OpenMP clause: safelen (constant-integer-expression).  */
-  OMP_CLAUSE_SAFELEN,
-
-  /* Internally used only clause, holding SIMD uid.  */
-  OMP_CLAUSE__SIMDUID_
-};
-
-/* 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, and the table below which connects the fields and the
-   accessor macros.  */
-
-struct GTY(()) tree_base {
-  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 asm_written_flag: 1;
-  unsigned nowarning_flag : 1;
-  unsigned visited : 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 default_def_flag : 1;
-
-  union {
-    /* The bits in the following structure should only be used with
-       accessor macros that constrain inputs with tree checking.  */
-    struct {
-      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 saturating_flag : 1;
-
-      unsigned unsigned_flag : 1;
-      unsigned packed_flag : 1;
-      unsigned user_align : 1;
-      unsigned nameless_flag : 1;
-      unsigned spare0 : 4;
-
-      unsigned spare1 : 8;
-
-      /* This field is only used with TREE_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;
-    } bits;
-    /* The following fields are present in tree_base to save space.  The
-       nodes using them do not require any of the flags above and so can
-       make better use of the 4-byte sized word.  */
-    /* VEC length.  This field is only used with TREE_VEC.  */
-    int length;
-    /* SSA version number.  This field is only used with SSA_NAME.  */
-    unsigned int version;
-  } GTY((skip(""))) u;
-};
-
-/* The following table lists the uses of each of the above flags and
-   for which types of nodes they are defined.
-
-   addressable_flag:
-
-       TREE_ADDRESSABLE in
-           VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL
-           SSA_NAME
-           all types
-           CONSTRUCTOR, IDENTIFIER_NODE
-           STMT_EXPR
-
-       CALL_EXPR_TAILCALL in
-           CALL_EXPR
-
-       CASE_LOW_SEEN in
-           CASE_LABEL_EXPR
-
-       PREDICT_EXPR_OUTCOME in
-	   PREDICT_EXPR
-
-   static_flag:
-
-       TREE_STATIC in
-           VAR_DECL, FUNCTION_DECL
-           CONSTRUCTOR
-
-       TREE_NO_TRAMPOLINE in
-           ADDR_EXPR
-
-       BINFO_VIRTUAL_P in
-           TREE_BINFO
-
-       TREE_SYMBOL_REFERENCED in
-           IDENTIFIER_NODE
-
-       CLEANUP_EH_ONLY in
-           TARGET_EXPR, WITH_CLEANUP_EXPR
-
-       TRY_CATCH_IS_CLEANUP in
-           TRY_CATCH_EXPR
-
-       ASM_INPUT_P in
-           ASM_EXPR
-
-       TYPE_REF_CAN_ALIAS_ALL in
-           POINTER_TYPE, REFERENCE_TYPE
-
-       CASE_HIGH_SEEN in
-           CASE_LABEL_EXPR
-
-       ENUM_IS_SCOPED in
-	   ENUMERAL_TYPE
-
-       TRANSACTION_EXPR_OUTER in
-	   TRANSACTION_EXPR
-
-   public_flag:
-
-       TREE_OVERFLOW in
-           INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
-
-       TREE_PUBLIC in
-           VAR_DECL, FUNCTION_DECL
-           IDENTIFIER_NODE
-
-       ASM_VOLATILE_P in
-           ASM_EXPR
-
-       CALL_EXPR_VA_ARG_PACK in
-           CALL_EXPR
-
-       TYPE_CACHED_VALUES_P in
-           all types
-
-       SAVE_EXPR_RESOLVED_P in
-           SAVE_EXPR
-
-       OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
-           OMP_CLAUSE_LASTPRIVATE
-
-       OMP_CLAUSE_PRIVATE_DEBUG in
-           OMP_CLAUSE_PRIVATE
-
-       OMP_CLAUSE_LINEAR_NO_COPYIN in
-	   OMP_CLAUSE_LINEAR
-
-       TRANSACTION_EXPR_RELAXED in
-	   TRANSACTION_EXPR
-
-   private_flag:
-
-       TREE_PRIVATE in
-           all decls
-
-       CALL_EXPR_RETURN_SLOT_OPT in
-           CALL_EXPR
-
-       OMP_SECTION_LAST in
-           OMP_SECTION
-
-       OMP_PARALLEL_COMBINED in
-           OMP_PARALLEL
-
-       OMP_CLAUSE_PRIVATE_OUTER_REF in
-	   OMP_CLAUSE_PRIVATE
-
-       OMP_CLAUSE_LINEAR_NO_COPYOUT in
-	   OMP_CLAUSE_LINEAR
-
-       TYPE_REF_IS_RVALUE in
-	   REFERENCE_TYPE
-
-       ENUM_IS_OPAQUE in
-	   ENUMERAL_TYPE
-
-   protected_flag:
-
-       TREE_PROTECTED in
-           BLOCK
-           all decls
-
-       CALL_FROM_THUNK_P and
-       CALL_ALLOCA_FOR_VAR_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
-           all decls
-
-       TYPE_VOLATILE in
-           all types
-
-   readonly_flag:
-
-       TREE_READONLY in
-           all expressions
-           all decls
-
-       TYPE_READONLY in
-           all types
-
-   constant_flag:
-
-       TREE_CONSTANT in
-           all expressions
-           all decls
-           all constants
-
-       TYPE_SIZES_GIMPLIFIED in
-           all types
-
-   unsigned_flag:
-
-       TYPE_UNSIGNED in
-           all types
-
-       DECL_UNSIGNED in
-           all decls
-
-   asm_written_flag:
-
-       TREE_ASM_WRITTEN in
-           VAR_DECL, FUNCTION_DECL, TYPE_DECL
-           RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
-           BLOCK, STRING_CST
-
-       SSA_NAME_OCCURS_IN_ABNORMAL_PHI in
-           SSA_NAME
-
-   used_flag:
-
-       TREE_USED in
-           all expressions
-           all decls
-           IDENTIFIER_NODE
-
-   nothrow_flag:
-
-       TREE_NOTHROW in
-           CALL_EXPR
-           FUNCTION_DECL
-
-       TYPE_ALIGN_OK in
-           all types
-
-       TREE_THIS_NOTRAP in
-          INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF
-
-       SSA_NAME_IN_FREELIST in
-          SSA_NAME
-
-   deprecated_flag:
-
-       TREE_DEPRECATED in
-           all decls
-	   all types
-
-       IDENTIFIER_TRANSPARENT_ALIAS in
-           IDENTIFIER_NODE
-
-   visited:
-
-       TREE_VISITED in
-           all trees (used liberally by many passes)
-
-   saturating_flag:
-
-       TYPE_SATURATING in
-           all types
-
-       VAR_DECL_IS_VIRTUAL_OPERAND in
-	   VAR_DECL
-
-   nowarning_flag:
-
-       TREE_NO_WARNING in
-           all expressions
-           all decls
-
-       TYPE_ARTIFICIAL in
-           all types
-
-   default_def_flag:
-
-       TYPE_VECTOR_OPAQUE in
-	   VECTOR_TYPE
-
-       SSA_NAME_IS_DEFAULT_DEF in
-           SSA_NAME
-
-       DECL_NONLOCAL_FRAME in
-	   VAR_DECL
-
-       TYPE_FINAL_P in
-	   RECORD_TYPE, UNION_TYPE and QUAL_UNION_TYPE
-*/
-
-struct GTY(()) tree_typed {
-  struct tree_base base;
-  tree type;
-};
-
-struct GTY(()) tree_common {
-  struct tree_typed typed;
-  tree chain;
-};
-
-#undef DEFTREESTRUCT
-#define DEFTREESTRUCT(ENUM, NAME) ENUM,
-enum tree_node_structure_enum {
-#include "treestruct.def"
-  LAST_TS_ENUM
-};
-#undef DEFTREESTRUCT
 
 /* Define accessors for the fields that all tree nodes have
    (though some fields are not used for all kinds of nodes).  */
@@ -1439,70 +884,28 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
 	== (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))	\
        && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
 
-struct GTY(()) tree_int_cst {
-  struct tree_typed typed;
-  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.  */
-struct real_value;
-
 #define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
 #define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
 
-struct GTY(()) tree_real_cst {
-  struct tree_typed typed;
-  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 GTY(()) tree_fixed_cst {
-  struct tree_typed typed;
-  struct fixed_value * fixed_cst_ptr;
-};
-
 /* In a STRING_CST */
 /* In C terms, this is sizeof, not strlen.  */
 #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 GTY(()) tree_string {
-  struct tree_typed typed;
-  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 GTY(()) tree_complex {
-  struct tree_typed typed;
-  tree real;
-  tree imag;
-};
-
 /* In a VECTOR_CST node.  */
 #define VECTOR_CST_NELTS(NODE) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)))
 #define VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elts)
 #define VECTOR_CST_ELT(NODE,IDX) (VECTOR_CST_CHECK (NODE)->vector.elts[IDX])
 
-struct GTY(()) tree_vector {
-  struct tree_typed typed;
-  tree GTY ((length ("TYPE_VECTOR_SUBPARTS (TREE_TYPE ((tree)&%h))"))) elts[1];
-};
-
-#include "symtab.h"
-
 /* Define fields and accessors for some special-purpose tree nodes.  */
 
 #define IDENTIFIER_LENGTH(NODE) \
@@ -1519,21 +922,10 @@ struct GTY(()) tree_vector {
   ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
 #define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
 
-struct GTY(()) tree_identifier {
-  struct tree_common common;
-  struct ht_identifier id;
-};
-
 /* In a TREE_LIST node.  */
 #define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
 #define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
 
-struct GTY(()) tree_list {
-  struct tree_common common;
-  tree purpose;
-  tree value;
-};
-
 /* In a TREE_VEC node.  */
 #define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->base.u.length)
 #define TREE_VEC_END(NODE) \
@@ -1541,11 +933,6 @@ struct GTY(()) tree_list {
 
 #define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
 
-struct GTY(()) tree_vec {
-  struct tree_common common;
-  tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
-};
-
 /* In a CONSTRUCTOR node.  */
 #define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
 #define CONSTRUCTOR_ELT(NODE,IDX) \
@@ -1594,21 +981,6 @@ struct GTY(()) tree_vec {
 #define TREE_CLOBBER_P(NODE) \
   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE))
 
-/* 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 GTY(()) constructor_elt_d {
-  tree index;
-  tree value;
-} constructor_elt;
-
-
-struct GTY(()) tree_constructor {
-  struct tree_typed typed;
-  vec<constructor_elt, va_gc> *elts;
-};
-
 /* Define fields and accessors for some nodes that represent expressions.  */
 
 /* Nonzero if NODE is an empty statement (NOP_EXPR <0>).  */
@@ -1907,38 +1279,12 @@ extern void protected_set_expr_location (tree, location_t);
 #define OMP_CLAUSE__SIMDUID__DECL(NODE) \
   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0)
 
-enum omp_clause_schedule_kind
-{
-  OMP_CLAUSE_SCHEDULE_STATIC,
-  OMP_CLAUSE_SCHEDULE_DYNAMIC,
-  OMP_CLAUSE_SCHEDULE_GUIDED,
-  OMP_CLAUSE_SCHEDULE_AUTO,
-  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,
-  OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
-};
-
 #define OMP_CLAUSE_DEFAULT_KIND(NODE) \
   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
 
-struct GTY(()) tree_exp {
-  struct tree_typed typed;
-  location_t locus;
-  tree GTY ((special ("tree_exp"),
-	     desc ("TREE_CODE ((tree) &%0)")))
-    operands[1];
-};
-
 /* SSA_NAME accessors.  */
 
 /* Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE
@@ -1992,51 +1338,9 @@ struct GTY(()) tree_exp {
 #define SSA_NAME_PTR_INFO(N) \
     SSA_NAME_CHECK (N)->ssa_name.ptr_info
 
-/* Defined in tree-flow.h.  */
-struct ptr_info_def;
-
-/* 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;
-  struct ssa_use_operand_d* GTY((skip(""))) next;
-  /* Immediate uses for a given SSA name are maintained as a cyclic
-     list.  To recognize the root of this list, the location field
-     needs to point to the original SSA name.  Since statements and
-     SSA names are of different data types, we need this union.  See
-     the explanation in struct immediate_use_iterator_d.  */
-  union { gimple stmt; tree ssa_name; } GTY((skip(""))) loc;
-  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 GTY(()) tree_ssa_name {
-  struct tree_typed typed;
-
-  /* _DECL wrapped by this SSA name.  */
-  tree var;
-
-  /* Statement that defines this SSA name.  */
-  gimple def_stmt;
-
-  /* Pointer attributes used for alias analysis.  */
-  struct ptr_info_def *ptr_info;
-
-  /* Immediate uses list for this SSA_NAME.  */
-  struct ssa_use_operand_d imm_uses;
-};
-
-struct GTY(()) phi_arg_d {
-  /* imm_use MUST be the first element in struct because we do some
-     pointer arithmetic with it.  See phi_arg_index_from_use.  */
-  struct ssa_use_operand_d imm_use;
-  tree def;
-  location_t locus;
-};
-
-
 #define OMP_CLAUSE_CODE(NODE)					\
 	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code
 
@@ -2049,25 +1353,6 @@ struct GTY(()) phi_arg_d {
 #define OMP_CLAUSE_OPERAND(NODE, I)				\
 	OMP_CLAUSE_ELT_CHECK (NODE, I)
 
-struct GTY(()) tree_omp_clause {
-  struct tree_common common;
-  location_t locus;
-  enum omp_clause_code code;
-  union omp_clause_subcode {
-    enum omp_clause_default_kind  default_kind;
-    enum omp_clause_schedule_kind schedule_kind;
-    enum tree_code                reduction_code;
-  } GTY ((skip)) subcode;
-
-  /* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's
-     usage.  */
-  gimple_seq gimple_reduction_init;
-  gimple_seq gimple_reduction_merge;
-
-  tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
-};
-
-
 /* In a BLOCK node.  */
 #define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
 #define BLOCK_NONLOCALIZED_VARS(NODE) \
@@ -2120,25 +1405,6 @@ struct GTY(()) tree_omp_clause {
 
 #define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)
 
-struct GTY(()) tree_block {
-  struct tree_base base;
-  tree chain;
-
-  unsigned abstract_flag : 1;
-  unsigned block_num : 31;
-
-  location_t locus;
-
-  tree vars;
-  vec<tree, va_gc> *nonlocalized_vars;
-
-  tree subblocks;
-  tree supercontext;
-  tree abstract_origin;
-  tree fragment_origin;
-  tree fragment_chain;
-};
-
 /* Define fields and accessors for nodes representing data types.  */
 
 /* See tree.def for documentation of the use of these fields.
@@ -2258,17 +1524,6 @@ extern enum machine_mode vector_type_mode (const_tree);
 /* The address space the type is in.  */
 #define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.u.bits.address_space)
 
-/* There is a TYPE_QUAL value for each type qualifier.  They can be
-   combined by bitwise-or to form the complete set of qualifiers for a
-   type.  */
-enum cv_qualifier
-  {
-    TYPE_UNQUALIFIED   = 0x0,
-    TYPE_QUAL_CONST    = 0x1,
-    TYPE_QUAL_VOLATILE = 0x2,
-    TYPE_QUAL_RESTRICT = 0x4
-  };
-
 /* Encode/decode the named memory support as part of the qualifier.  If more
    than 8 qualifiers are added, these macros need to be adjusted.  */
 #define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
@@ -2388,58 +1643,9 @@ enum cv_qualifier
 #define TYPE_SYMTAB_IS_POINTER (1)
 #define TYPE_SYMTAB_IS_DIE (2)
 
-struct die_struct;
-
-struct GTY(()) tree_type_common {
-  struct tree_common common;
-  tree size;
-  tree size_unit;
-  tree attributes;
-  unsigned int uid;
-
-  unsigned int precision : 10;
-  unsigned no_force_blk_flag : 1;
-  unsigned needs_constructing_flag : 1;
-  unsigned transparent_aggr_flag : 1;
-  unsigned restrict_flag : 1;
-  unsigned contains_placeholder_bits : 2;
-
-  ENUM_BITFIELD(machine_mode) mode : 8;
-
-  unsigned string_flag : 1;
-  unsigned lang_flag_0 : 1;
-  unsigned lang_flag_1 : 1;
-  unsigned lang_flag_2 : 1;
-  unsigned lang_flag_3 : 1;
-  unsigned lang_flag_4 : 1;
-  unsigned lang_flag_5 : 1;
-  unsigned lang_flag_6 : 1;
-
-  unsigned int align;
-  alias_set_type alias_set;
-  tree pointer_to;
-  tree reference_to;
-  union tree_type_symtab {
-    int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address;
-    const char * GTY ((tag ("TYPE_SYMTAB_IS_POINTER"))) pointer;
-    struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die;
-  } GTY ((desc ("debug_hooks->tree_type_symtab_field"))) symtab;
-  tree name;
-  tree next_variant;
-  tree main_variant;
-  tree context;
-  tree canonical;
-};
-
 #define TYPE_LANG_SPECIFIC(NODE) \
   (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific)
 
-struct GTY(()) tree_type_with_lang_specific {
-  struct tree_type_common common;
-  /* Points to a structure whose details depend on the language in use.  */
-  struct lang_type *lang_specific;
-};
-
 #define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)
 #define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)
 #define TYPE_FIELDS(NODE) \
@@ -2482,14 +1688,6 @@ struct GTY(()) tree_type_with_lang_specific {
 #define TYPE_LANG_SLOT_1(NODE) \
   (NOT_RECORD_OR_UNION_CHECK(NODE)->type_non_common.binfo)
 
-struct GTY(()) tree_type_non_common {
-  struct tree_type_with_lang_specific with_lang_specific;
-  tree values;
-  tree minval;
-  tree maxval;
-  tree binfo;
-};
-
 /* Define accessor macros for information about type inheritance
    and basetypes.
 
@@ -2593,23 +1791,7 @@ struct GTY(()) tree_type_non_common {
 #define BINFO_INHERITANCE_CHAIN(NODE) \
 	(TREE_BINFO_CHECK(NODE)->binfo.inheritance)
 
-struct GTY (()) tree_binfo {
-  struct tree_common common;
 
-  tree offset;
-  tree vtable;
-  tree virtuals;
-  tree vptr_field;
-  vec<tree, va_gc> *base_accesses;
-  tree inheritance;
-
-  tree vtt_subvtt;
-  tree vtt_vptr;
-
-  vec<tree, va_gc> base_binfos;
-};
-
-
 /* Define fields and accessors for nodes representing declared names.  */
 
 /* Nonzero if DECL represents an SSA name or a variable that can possibly
@@ -2621,21 +1803,6 @@ struct GTY (()) tree_binfo {
 	 || TREE_CODE (DECL) == SSA_NAME)
 
 
-
-/* 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;
-
 #define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE)))
 
 /* This is the name of the object as written by the user.
@@ -2690,15 +1857,6 @@ struct function;
 /* If nonzero, decl's name shouldn't be emitted into debug info.  */
 #define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag)
 
-struct GTY(()) tree_decl_minimal {
-  struct tree_common common;
-  location_t locus;
-  unsigned int uid;
-  tree name;
-  tree context;
-};
-
-
 /* For any sort of a ..._DECL node, this points to the original (abstract)
    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.
@@ -2856,72 +2014,6 @@ struct GTY(()) tree_decl_minimal {
 #define DECL_GIMPLE_REG_P(DECL) \
   DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag
 
-struct GTY(()) tree_decl_common {
-  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 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;
-  unsigned lang_flag_8 : 1;
-
-  /* In VAR_DECL and PARM_DECL, this is DECL_REGISTER.  */
-  unsigned decl_flag_0 : 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_SUPPRESS_DEBUG.  */
-  unsigned decl_flag_1 : 1;
-  /* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
-     In VAR_DECL, PARM_DECL and RESULT_DECL, this is
-     DECL_HAS_VALUE_EXPR_P.  */
-  unsigned decl_flag_2 : 1;
-  /* 1 bit unused.  */
-  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 VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE.  */
-  unsigned decl_by_reference_flag : 1;
-  /* In a VAR_DECL and PARM_DECL, this is DECL_READ_P.  */
-  unsigned decl_read_flag : 1;
-  /* In a VAR_DECL or RESULT_DECL, this is DECL_NONSHAREABLE.  */
-  unsigned decl_nonshareable_flag : 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;
-
-  /* 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);
 
@@ -2978,11 +2070,6 @@ extern void decl_value_expr_insert (tree, tree);
 /* 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 GTY(()) tree_decl_with_rtl {
-  struct tree_decl_common common;
-  rtx rtl;
-};
-
 /* In a FIELD_DECL, this is the field position, counting in bytes, of the
    DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
    of the structure.  */
@@ -3051,16 +2138,6 @@ struct GTY(()) tree_decl_with_rtl {
 #define DECL_NONADDRESSABLE_P(NODE) \
   (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
 
-struct GTY(()) tree_field_decl {
-  struct tree_decl_common common;
-
-  tree offset;
-  tree bit_field_type;
-  tree qualifier;
-  tree bit_offset;
-  tree fcontext;
-};
-
 /* A numeric unique identifier for a LABEL_DECL.  The UID allocation is
    dense, unique within any one function, and may be used to index arrays.
    If the value is -1, then no UID has been assigned.  */
@@ -3072,20 +2149,6 @@ struct GTY(()) tree_field_decl {
 #define EH_LANDING_PAD_NR(NODE) \
   (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr)
 
-struct GTY(()) tree_label_decl {
-  struct tree_decl_with_rtl common;
-  int label_decl_uid;
-  int eh_landing_pad_nr;
-};
-
-struct GTY(()) tree_result_decl {
-  struct tree_decl_with_rtl common;
-};
-
-struct GTY(()) tree_const_decl {
-  struct tree_decl_common 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)
@@ -3095,12 +2158,6 @@ struct GTY(()) tree_const_decl {
 #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;
-};
-
-
 /* 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) \
@@ -3233,46 +2290,9 @@ struct GTY(()) tree_parm_decl {
 #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;
- tree comdat_group;
-
- /* Belong to VAR_DECL exclusively.  */
- unsigned defer_output : 1;
- unsigned hard_register : 1;
- unsigned common_flag : 1;
- unsigned in_text_section : 1;
- unsigned in_constant_pool : 1;
- unsigned dllimport_flag : 1;
- /* Don't belong to VAR_DECL exclusively.  */
- unsigned weak_flag : 1;
- /* When SECTION_NAME is implied by -ffunction-section.  */
- unsigned implicit_section_name_p : 1;
-
- unsigned seen_in_bind_expr : 1;
- unsigned comdat_flag : 1;
- ENUM_BITFIELD(symbol_visibility) visibility : 2;
- unsigned visibility_specified : 1;
- /* Belongs to VAR_DECL exclusively.  */
- ENUM_BITFIELD(tls_model) tls_model : 3;
-
- /* Belong to FUNCTION_DECL exclusively.  */
- unsigned init_priority_p : 1;
- /* Used by C++ only.  Might become a generic decl flag.  */
- unsigned shadowed_for_var_p : 1;
- /* Belong to FUNCTION_DECL exclusively.  */
- unsigned cxx_constructor : 1;
- /* Belong to FUNCTION_DECL exclusively.  */
- unsigned cxx_destructor : 1;
- /* Belong to FUNCTION_DECL exclusively.  */
- unsigned final : 1;
- /* 11 unused bits. */
-};
-
 extern tree decl_debug_expr_lookup (tree);
 extern void decl_debug_expr_insert (tree, tree);
+
 /* For VAR_DECL, this is set to an expression that it was split from.  */
 #define DECL_HAS_DEBUG_EXPR_P(NODE) \
   (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from)
@@ -3282,9 +2302,6 @@ extern void decl_debug_expr_insert (tree, tree);
 #define SET_DECL_DEBUG_EXPR(NODE, VAL) \
   (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))
 
-/* An initialization priority.  */
-typedef unsigned short priority_type;
-
 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);
@@ -3324,11 +2341,6 @@ extern void decl_fini_priority_insert (tree, priority_type);
 #define DECL_NONLOCAL_FRAME(NODE)  \
   (VAR_DECL_CHECK (NODE)->base.default_def_flag)
 
-struct GTY(()) tree_var_decl {
-  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.  */
 #define DECL_RESULT_FLD(NODE) \
@@ -3345,19 +2357,6 @@ struct GTY(()) tree_var_decl {
 #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.  */
-  tree saved_tree;
-  /* C++ uses this in templates.  */
-  tree arguments;
-  /* Almost all FE's use this.  */
-  tree result;
-  /* C++ uses this in namespaces and function_decls.  */
-  tree vindex;
-};
-
 /* In FUNCTION_DECL, holds the decl for the return value.  */
 #define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
 
@@ -3540,66 +2539,12 @@ extern vec<tree, va_gc> **decl_debug_args_insert (tree);
    FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL,
    which seemed a bit strange.  */
 
-struct GTY(()) tree_function_decl {
-  struct tree_decl_non_common common;
-
-  struct function *f;
-
-  /* The personality function. Used for stack unwinding. */
-  tree personality;
-
-  /* Function specific options that are used by this function.  */
-  tree function_specific_target;	/* target options */
-  tree function_specific_optimization;	/* optimization options */
-
-  /* In a 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 operator_new_flag : 1;
-  unsigned declared_inline_flag : 1;
-  unsigned regdecl_flag : 1;
-  unsigned no_inline_warning_flag : 1;
-
-  unsigned no_instrument_function_entry_exit : 1;
-  unsigned no_limit_stack : 1;
-  unsigned disregard_inline_limits : 1;
-  unsigned pure_flag : 1;
-  unsigned looping_const_or_pure_flag : 1;
-  unsigned has_debug_args_flag : 1;
-  unsigned tm_clone_flag : 1;
-  unsigned versioned_function : 1;
-  /* No 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, va_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)
@@ -3615,11 +2560,6 @@ extern GTY (()) vec<tree, va_gc> *all_translation_units;
 #define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \
 (DECL_INITIAL (IMPORTED_DECL_CHECK (NODE)))
 
-struct GTY(()) tree_type_decl {
-  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.
    This avoids the overhead of tree_common on all linked list elements.
@@ -3631,38 +2571,6 @@ struct GTY(()) tree_type_decl {
 #define STATEMENT_LIST_TAIL(NODE) \
   (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
 
-struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) tree_statement_list_node
- {
-  struct tree_statement_list_node *prev;
-  struct tree_statement_list_node *next;
-  tree stmt;
-};
-
-struct GTY(()) tree_statement_list
- {
-  struct tree_typed typed;
-  struct tree_statement_list_node *head;
-  struct tree_statement_list_node *tail;
-};
-
-
-/* Optimization options used by a function.  */
-
-struct GTY(()) tree_optimization_option {
-  struct tree_common common;
-
-  /* The optimization options used by the user.  */
-  struct cl_optimization opts;
-
-  /* Target optabs for this set of optimization options.  This is of
-     type `struct target_optabs *'.  */
-  unsigned char *GTY ((atomic)) optabs;
-
-  /* The value of this_target_optabs against which the optabs above were
-     generated.  */
-  struct target_optabs *GTY ((skip)) base_optabs;
-};
-
 #define TREE_OPTIMIZATION(NODE) \
   (&OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)
 
@@ -3677,71 +2585,12 @@ extern tree build_optimization_node (void);
 
 extern void init_tree_optimization_optabs (tree);
 
-/* Target options used by a function.  */
-
-struct GTY(()) tree_target_option {
-  struct tree_common common;
-
-  /* The optimization options used by the user.  */
-  struct cl_target_option opts;
-};
-
 #define TREE_TARGET_OPTION(NODE) \
   (&TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts)
 
 /* Return a tree node that encapsulates the current target options.  */
 extern tree build_target_option_node (void);
 
-
-/* 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)"), variable_size)) tree_node {
-  struct tree_base GTY ((tag ("TS_BASE"))) base;
-  struct tree_typed GTY ((tag ("TS_TYPED"))) typed;
-  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_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL")))
-    translation_unit_decl;
-  struct tree_type_common GTY ((tag ("TS_TYPE_COMMON"))) type_common;
-  struct tree_type_with_lang_specific GTY ((tag ("TS_TYPE_WITH_LANG_SPECIFIC")))
-    type_with_lang_specific;
-  struct tree_type_non_common GTY ((tag ("TS_TYPE_NON_COMMON")))
-    type_non_common;
-  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_block GTY ((tag ("TS_BLOCK"))) block;
-  struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo;
-  struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
-  struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
-  struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
-  struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization;
-  struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option;
-};
-
 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
 
 inline tree
@@ -4221,167 +3070,6 @@ tree_operand_check_code (const_tree __t, enum tree_code __code, int __i,
 
 #endif
 
-
-/* Standard named or nameless data types of the C compiler.  */
-
-enum tree_index
-{
-  TI_ERROR_MARK,
-  TI_INTQI_TYPE,
-  TI_INTHI_TYPE,
-  TI_INTSI_TYPE,
-  TI_INTDI_TYPE,
-  TI_INTTI_TYPE,
-
-  TI_UINTQI_TYPE,
-  TI_UINTHI_TYPE,
-  TI_UINTSI_TYPE,
-  TI_UINTDI_TYPE,
-  TI_UINTTI_TYPE,
-
-  TI_UINT16_TYPE,
-  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,
-
-  TI_BITSIZE_ZERO,
-  TI_BITSIZE_ONE,
-  TI_BITSIZE_UNIT,
-
-  TI_PUBLIC,
-  TI_PROTECTED,
-  TI_PRIVATE,
-
-  TI_BOOLEAN_FALSE,
-  TI_BOOLEAN_TRUE,
-
-  TI_COMPLEX_INTEGER_TYPE,
-  TI_COMPLEX_FLOAT_TYPE,
-  TI_COMPLEX_DOUBLE_TYPE,
-  TI_COMPLEX_LONG_DOUBLE_TYPE,
-
-  TI_FLOAT_TYPE,
-  TI_DOUBLE_TYPE,
-  TI_LONG_DOUBLE_TYPE,
-
-  TI_FLOAT_PTR_TYPE,
-  TI_DOUBLE_PTR_TYPE,
-  TI_LONG_DOUBLE_PTR_TYPE,
-  TI_INTEGER_PTR_TYPE,
-
-  TI_VOID_TYPE,
-  TI_PTR_TYPE,
-  TI_CONST_PTR_TYPE,
-  TI_SIZE_TYPE,
-  TI_PID_TYPE,
-  TI_PTRDIFF_TYPE,
-  TI_VA_LIST_TYPE,
-  TI_VA_LIST_GPR_COUNTER_FIELD,
-  TI_VA_LIST_FPR_COUNTER_FIELD,
-  TI_BOOLEAN_TYPE,
-  TI_FILEPTR_TYPE,
-  TI_POINTER_SIZED_TYPE,
-
-  TI_DFLOAT32_TYPE,
-  TI_DFLOAT64_TYPE,
-  TI_DFLOAT128_TYPE,
-  TI_DFLOAT32_PTR_TYPE,
-  TI_DFLOAT64_PTR_TYPE,
-  TI_DFLOAT128_PTR_TYPE,
-
-  TI_VOID_LIST_NODE,
-
-  TI_MAIN_IDENTIFIER,
-
-  TI_SAT_SFRACT_TYPE,
-  TI_SAT_FRACT_TYPE,
-  TI_SAT_LFRACT_TYPE,
-  TI_SAT_LLFRACT_TYPE,
-  TI_SAT_USFRACT_TYPE,
-  TI_SAT_UFRACT_TYPE,
-  TI_SAT_ULFRACT_TYPE,
-  TI_SAT_ULLFRACT_TYPE,
-  TI_SFRACT_TYPE,
-  TI_FRACT_TYPE,
-  TI_LFRACT_TYPE,
-  TI_LLFRACT_TYPE,
-  TI_USFRACT_TYPE,
-  TI_UFRACT_TYPE,
-  TI_ULFRACT_TYPE,
-  TI_ULLFRACT_TYPE,
-  TI_SAT_SACCUM_TYPE,
-  TI_SAT_ACCUM_TYPE,
-  TI_SAT_LACCUM_TYPE,
-  TI_SAT_LLACCUM_TYPE,
-  TI_SAT_USACCUM_TYPE,
-  TI_SAT_UACCUM_TYPE,
-  TI_SAT_ULACCUM_TYPE,
-  TI_SAT_ULLACCUM_TYPE,
-  TI_SACCUM_TYPE,
-  TI_ACCUM_TYPE,
-  TI_LACCUM_TYPE,
-  TI_LLACCUM_TYPE,
-  TI_USACCUM_TYPE,
-  TI_UACCUM_TYPE,
-  TI_ULACCUM_TYPE,
-  TI_ULLACCUM_TYPE,
-  TI_QQ_TYPE,
-  TI_HQ_TYPE,
-  TI_SQ_TYPE,
-  TI_DQ_TYPE,
-  TI_TQ_TYPE,
-  TI_UQQ_TYPE,
-  TI_UHQ_TYPE,
-  TI_USQ_TYPE,
-  TI_UDQ_TYPE,
-  TI_UTQ_TYPE,
-  TI_SAT_QQ_TYPE,
-  TI_SAT_HQ_TYPE,
-  TI_SAT_SQ_TYPE,
-  TI_SAT_DQ_TYPE,
-  TI_SAT_TQ_TYPE,
-  TI_SAT_UQQ_TYPE,
-  TI_SAT_UHQ_TYPE,
-  TI_SAT_USQ_TYPE,
-  TI_SAT_UDQ_TYPE,
-  TI_SAT_UTQ_TYPE,
-  TI_HA_TYPE,
-  TI_SA_TYPE,
-  TI_DA_TYPE,
-  TI_TA_TYPE,
-  TI_UHA_TYPE,
-  TI_USA_TYPE,
-  TI_UDA_TYPE,
-  TI_UTA_TYPE,
-  TI_SAT_HA_TYPE,
-  TI_SAT_SA_TYPE,
-  TI_SAT_DA_TYPE,
-  TI_SAT_TA_TYPE,
-  TI_SAT_UHA_TYPE,
-  TI_SAT_USA_TYPE,
-  TI_SAT_UDA_TYPE,
-  TI_SAT_UTA_TYPE,
-
-  TI_OPTIMIZATION_DEFAULT,
-  TI_OPTIMIZATION_CURRENT,
-  TI_TARGET_OPTION_DEFAULT,
-  TI_TARGET_OPTION_CURRENT,
-  TI_CURRENT_TARGET_PRAGMA,
-  TI_CURRENT_OPTIMIZE_PRAGMA,
-
-  TI_MAX
-};
-
-extern GTY(()) tree global_trees[TI_MAX];
-
 #define error_mark_node			global_trees[TI_ERROR_MARK]
 
 #define intQI_type_node			global_trees[TI_INTQI_TYPE]
@@ -4562,34 +3250,6 @@ extern GTY(()) tree global_trees[TI_MAX];
 #define current_target_pragma		global_trees[TI_CURRENT_TARGET_PRAGMA]
 #define current_optimize_pragma		global_trees[TI_CURRENT_OPTIMIZE_PRAGMA]
 
-/* An enumeration of the standard C integer types.  These must be
-   ordered so that shorter types appear before longer ones, and so
-   that signed types appear before unsigned ones, for the correct
-   functioning of interpret_integer() in c-lex.c.  */
-enum integer_type_kind
-{
-  itk_char,
-  itk_signed_char,
-  itk_unsigned_char,
-  itk_short,
-  itk_unsigned_short,
-  itk_int,
-  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;
-
-/* The standard C integer types.  Use integer_type_kind to index into
-   this array.  */
-extern GTY(()) tree integer_types[itk_none];
-
 #define char_type_node			integer_types[itk_char]
 #define signed_char_type_node		integer_types[itk_signed_char]
 #define unsigned_char_type_node		integer_types[itk_unsigned_char]
@@ -4603,34 +3263,7 @@ extern GTY(()) tree integer_types[itk_none];
 #define long_long_unsigned_type_node	integer_types[itk_unsigned_long_long]
 #define int128_integer_type_node	integer_types[itk_int128]
 #define int128_unsigned_type_node	integer_types[itk_unsigned_int128]
-
-/* A pointer-to-function member type looks like:
-
-     struct {
-       __P __pfn;
-       ptrdiff_t __delta;
-     };
 
-   If __pfn is NULL, it is a NULL pointer-to-member-function.
-
-   (Because the vtable is always the first thing in the object, we
-   don't need its offset.)  If the function is virtual, then PFN is
-   one plus twice the index into the vtable; otherwise, it is just a
-   pointer to the function.
-
-   Unfortunately, using the lowest bit of PFN doesn't work in
-   architectures that don't impose alignment requirements on function
-   addresses, or that use the lowest bit to tell one ISA from another,
-   for example.  For such architectures, we use the lowest bit of
-   DELTA instead of the lowest bit of the PFN, and DELTA will be
-   multiplied by 2.  */
-
-enum ptrmemfunc_vbit_where_t
-{
-  ptrmemfunc_vbit_in_pfn,
-  ptrmemfunc_vbit_in_delta
-};
-
 #define NULL_TREE (tree) NULL
 
 /* True if NODE is an erroneous expression.  */
@@ -4987,82 +3620,7 @@ extern tree build_type_attribute_qual_variant (tree, tree, int);
    warning to be generated).  */
 extern int comp_type_attributes (const_tree, const_tree);
 
-/* Structure describing an attribute and a function to handle it.  */
-struct attribute_spec
-{
-  /* The name of the attribute (without any leading or trailing __),
-     or NULL to mark the end of a table of attributes.  */
-  const char *name;
-  /* The minimum length of the list of arguments of the attribute.  */
-  int min_length;
-  /* The maximum length of the list of arguments of the attribute
-     (-1 for no maximum).  */
-  int max_length;
-  /* Whether this attribute requires a DECL.  If it does, it will be passed
-     from types of DECLs, function return types and array element types to
-     the DECLs, function types and array types respectively; but when
-     applied to a type in any other circumstances, it will be ignored with
-     a warning.  (If greater control is desired for a given attribute,
-     this should be false, and the flags argument to the handler may be
-     used to gain greater control in that case.)  */
-  bool decl_required;
-  /* Whether this attribute requires a type.  If it does, it will be passed
-     from a DECL to the type of that DECL.  */
-  bool type_required;
-  /* Whether this attribute requires a function (or method) type.  If it does,
-     it will be passed from a function pointer type to the target type,
-     and from a function return type (which is not itself a function
-     pointer type) to the function type.  */
-  bool function_type_required;
-  /* Function to handle this attribute.  NODE points to the node to which
-     the attribute is to be applied.  If a DECL, it should be modified in
-     place; if a TYPE, a copy should be created.  NAME is the name of the
-     attribute (possibly with leading or trailing __).  ARGS is the TREE_LIST
-     of the arguments (which may be NULL).  FLAGS gives further information
-     about the context of the attribute.  Afterwards, the attributes will
-     be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
-     unless *NO_ADD_ATTRS is set to true (which should be done on error,
-     as well as in any other cases when the attributes should not be added
-     to the DECL or TYPE).  Depending on FLAGS, any attributes to be
-     applied to another type or DECL later may be returned;
-     otherwise the return value should be NULL_TREE.  This pointer may be
-     NULL if no special handling is required beyond the checks implied
-     by the rest of this structure.  */
-  tree (*handler) (tree *node, tree name, tree args,
-		   int flags, bool *no_add_attrs);
-  /* Specifies if attribute affects type's identity.  */
-  bool affects_type_identity;
-};
-
-/* Flags that may be passed in the third argument of decl_attributes, and
-   to handler functions for attributes.  */
-enum attribute_flags
-{
-  /* The type passed in is the type of a DECL, and any attributes that
-     should be passed in again to be applied to the DECL rather than the
-     type should be returned.  */
-  ATTR_FLAG_DECL_NEXT = 1,
-  /* The type passed in is a function return type, and any attributes that
-     should be passed in again to be applied to the function type rather
-     than the return type should be returned.  */
-  ATTR_FLAG_FUNCTION_NEXT = 2,
-  /* The type passed in is an array element type, and any attributes that
-     should be passed in again to be applied to the array type rather
-     than the element type should be returned.  */
-  ATTR_FLAG_ARRAY_NEXT = 4,
-  /* The type passed in is a structure, union or enumeration type being
-     created, and should be modified in place.  */
-  ATTR_FLAG_TYPE_IN_PLACE = 8,
-  /* The attributes are being applied by default to a library function whose
-     name indicates known behavior, and should be silently ignored if they
-     are not in fact compatible with the function type.  */
-  ATTR_FLAG_BUILT_IN = 16,
-  /* A given attribute has been parsed as a C++-11 attribute.  */
-  ATTR_FLAG_CXX11 = 32
-};
-
 /* Default versions of target-overridable functions.  */
-
 extern tree merge_decl_attributes (tree, tree);
 extern tree merge_type_attributes (tree, tree);
 
@@ -5177,41 +3735,6 @@ extern void finish_builtin_struct (tree, const char *,
 
 extern void layout_type (tree);
 
-/* These functions allow a front-end to perform a manual layout of a
-   RECORD_TYPE.  (For instance, if the placement of subsequent fields
-   depends on the placement of fields so far.)  Begin by calling
-   start_record_layout.  Then, call place_field for each of the
-   fields.  Then, call finish_record_layout.  See layout_type for the
-   default way in which these functions are used.  */
-
-typedef struct record_layout_info_s
-{
-  /* The RECORD_TYPE that we are laying out.  */
-  tree t;
-  /* The offset into the record so far, in bytes, not including bits in
-     BITPOS.  */
-  tree offset;
-  /* The last known alignment of SIZE.  */
-  unsigned int offset_align;
-  /* The bit position within the last OFFSET_ALIGN bits, in bits.  */
-  tree bitpos;
-  /* The alignment of the record so far, in bits.  */
-  unsigned int record_align;
-  /* The alignment of the record so far, ignoring #pragma pack and
-     __attribute__ ((packed)), in bits.  */
-  unsigned int unpacked_align;
-  /* The previous field laid out.  */
-  tree prev_field;
-  /* The static variables (i.e., class variables, as opposed to
-     instance variables) encountered in T.  */
-  vec<tree, va_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;
-} *record_layout_info;
-
 extern record_layout_info start_record_layout (tree);
 extern tree bit_from_pos (tree, tree);
 extern tree byte_from_pos (tree, tree);
@@ -5271,20 +3794,6 @@ extern HOST_WIDE_INT int_bit_position (const_tree);
 extern tree byte_position (const_tree);
 extern HOST_WIDE_INT int_byte_position (const_tree);
 
-/* Define data structures, macros, and functions for handling sizes
-   and the various types used to represent sizes.  */
-
-enum size_type_kind
-{
-  stk_sizetype,		/* Normal representation of sizes in bytes.  */
-  stk_ssizetype,	/* Signed representation of sizes in bytes.  */
-  stk_bitsizetype,	/* Normal representation of sizes in bits.  */
-  stk_sbitsizetype,	/* Signed representation of sizes in bits.  */
-  stk_type_kind_last
-};
-
-extern GTY(()) tree sizetype_tab[(int) stk_type_kind_last];
-
 #define sizetype sizetype_tab[(int) stk_sizetype]
 #define bitsizetype sizetype_tab[(int) stk_bitsizetype]
 #define ssizetype sizetype_tab[(int) stk_ssizetype]
@@ -5316,9 +3825,6 @@ extern void finalize_size_functions (void);
    + (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;
-
 /* 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.  */
@@ -5593,25 +4099,6 @@ extern tree decl_type_context (const_tree);
 
 /* Return 1 if EXPR is the real constant zero.  */
 extern int real_zerop (const_tree);
-
-/* Declare commonly used variables for tree structure.  */
-
-/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
-   Zero means allow extended lvalues.  */
-
-extern int pedantic_lvalues;
-
-/* Points to the FUNCTION_DECL of the function whose body we are reading.  */
-
-extern GTY(()) tree current_function_decl;
-
-/* Nonzero means a FUNC_BEGIN label was emitted.  */
-extern GTY(()) const char * current_function_func_begin_label;
-
-/* Iterator for going through the function arguments.  */
-typedef struct {
-  tree next;			/* TREE_LIST pointing to the next argument */
-} function_args_iterator;
 
 /* Initialize the iterator I with arguments from function FNDECL  */
 
@@ -5817,14 +4304,6 @@ 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);
-
-enum operand_equal_flag
-{
-  OEP_ONLY_CONST = 1,
-  OEP_PURE_SAME = 2,
-  OEP_CONSTANT_ADDRESS_OF = 4
-};
-
 extern int operand_equal_p (const_tree, const_tree, unsigned int);
 extern int multiple_of_p (tree, const_tree, const_tree);
 #define omit_one_operand(T1,T2,T3)\
@@ -6109,70 +4588,10 @@ extern bool debug_find_tree (tree, tree);
 extern tree build_duplicate_type (tree);
 
 /* In calls.c */
-
-/* Nonzero if this is a call to a function whose return value depends
-   solely on its arguments, has no side effects, and does not read
-   global memory.  This corresponds to TREE_READONLY for function
-   decls.  */
-#define ECF_CONST		  (1 << 0)
-/* Nonzero if this is a call to "pure" function (like const function,
-   but may read memory.  This corresponds to DECL_PURE_P for function
-   decls.  */
-#define ECF_PURE		  (1 << 1)
-/* Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no
-   infinite loop.  This corresponds to DECL_LOOPING_CONST_OR_PURE_P
-   for function decls.*/
-#define ECF_LOOPING_CONST_OR_PURE (1 << 2)
-/* Nonzero if this call will never return.  */
-#define ECF_NORETURN		  (1 << 3)
-/* Nonzero if this is a call to malloc or a related function.  */
-#define ECF_MALLOC		  (1 << 4)
-/* Nonzero if it is plausible that this is a call to alloca.  */
-#define ECF_MAY_BE_ALLOCA	  (1 << 5)
-/* Nonzero if this is a call to a function that won't throw an exception.  */
-#define ECF_NOTHROW		  (1 << 6)
-/* Nonzero if this is a call to setjmp or a related function.  */
-#define ECF_RETURNS_TWICE	  (1 << 7)
-/* 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)
-/* Nonzero if this call does not affect transactions.  */
-#define ECF_TM_PURE		  (1 << 11)
-/* Nonzero if this call is into the transaction runtime library.  */
-#define ECF_TM_BUILTIN		  (1 << 12)
-
 extern int flags_from_decl_or_type (const_tree);
 extern int call_expr_flags (const_tree);
 extern void set_call_expr_flags (tree, int);
 
-/* 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);
@@ -6273,19 +4692,6 @@ extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *);
 
 /* In tree-inline.c  */
 
-/* The type of a set of already-visited pointers.  Functions for creating
-   and manipulating it are declared in pointer-set.h */
-struct pointer_set_t;
-
-/* The type of a callback function for walking over tree structure.  */
-
-typedef tree (*walk_tree_fn) (tree *, int *, void *);
-
-/* The type of a callback function that represents a custom walk_tree.  */
-
-typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *),
-			      void *, struct pointer_set_t*);
-
 extern tree walk_tree_1 (tree*, walk_tree_fn, void*, struct pointer_set_t*,
 			 walk_tree_lh);
 extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*,
@@ -6300,106 +4706,33 @@ extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*,
 
 extern void set_decl_rtl (tree, rtx);
 extern void set_decl_incoming_rtl (tree, rtx, bool);
-
-/* Enum and arrays used for tree allocation stats.
-   Keep in sync with tree.c:tree_node_kind_names.  */
-typedef enum
-{
-  d_kind,
-  t_kind,
-  b_kind,
-  s_kind,
-  r_kind,
-  e_kind,
-  c_kind,
-  id_kind,
-  vec_kind,
-  binfo_kind,
-  ssa_name_kind,
-  constr_kind,
-  x_kind,
-  lang_decl,
-  lang_type,
-  omp_clause_kind,
-  all_kinds
-} tree_node_kind;
-
-extern int tree_node_counts[];
-extern int tree_node_sizes[];
-
-/* True if we are in gimple form and the actions of the folders need to
-   be restricted.  False if we are not in gimple form and folding is not
-   restricted to creating gimple expressions.  */
-extern bool in_gimple_form;
 
 /* In gimple.c.  */
 extern tree get_base_address (tree t);
 extern void mark_addressable (tree);
 
 /* In tree.c.  */
-
-struct GTY(()) tree_map_base {
-  tree from;
-};
-
 extern int tree_map_base_eq (const void *, const void *);
 extern unsigned int tree_map_base_hash (const void *);
 extern int tree_map_base_marked_p (const void *);
 extern bool list_equal_p (const_tree, const_tree);
 
-/* Map from a tree to another tree.  */
-
-struct GTY(()) tree_map {
-  struct tree_map_base base;
-  unsigned int hash;
-  tree to;
-};
-
 #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;
-};
-
 #define tree_int_map_eq tree_map_base_eq
 #define tree_int_map_hash tree_map_base_hash
 #define tree_int_map_marked_p tree_map_base_marked_p
 
-/* Map from a tree to initialization/finalization priorities.  */
-
-struct GTY(()) tree_priority_map {
-  struct tree_map_base base;
-  priority_type init;
-  priority_type fini;
-};
-
 #define tree_priority_map_eq tree_map_base_eq
 #define tree_priority_map_hash tree_map_base_hash
 #define tree_priority_map_marked_p tree_map_base_marked_p
 
-/* Map from a decl tree to a tree vector.  */
-
-struct GTY(()) tree_vec_map {
-  struct tree_map_base base;
-  vec<tree, va_gc> *to;
-};
-
 #define tree_vec_map_eq tree_map_base_eq
 #define tree_vec_map_hash tree_decl_map_hash
 #define tree_vec_map_marked_p tree_map_base_marked_p
@@ -6452,23 +4785,6 @@ is_tm_safe_or_pure (const_tree x)
 
 void init_inline_once (void);
 
-/* Abstract iterators for CALL_EXPRs.  These static inline definitions
-   have to go towards the end of tree.h so that union tree_node is fully
-   defined by this point.  */
-
-/* Structure containing iterator state.  */
-typedef struct call_expr_arg_iterator_d {
-  tree t;	/* the call_expr */
-  int n;	/* argument count */
-  int i;	/* next argument index */
-} call_expr_arg_iterator;
-
-typedef struct const_call_expr_arg_iterator_d {
-  const_tree t;	/* the call_expr */
-  int n;	/* argument count */
-  int i;	/* next argument index */
-} const_call_expr_arg_iterator;
-
 /* Initialize the abstract argument list iterator object ITER with the
    arguments from CALL_EXPR node EXP.  */
 static inline void
@@ -6566,20 +4882,6 @@ extern bool block_may_fallthru (const_tree);
 /* In vtable-verify.c.  */
 extern void save_vtable_map_decl (tree);
 
-
-/* Functional interface to the builtin functions.  */
-
-/* The builtin_info structure holds the FUNCTION_DECL of the standard builtin
-   function, and a flag that says if the function is available implicitly, or
-   whether the user has to code explicit calls to __builtin_<xxx>.  */
-
-typedef struct GTY(()) builtin_info_type_d {
-  tree decl[(int)END_BUILTINS];
-  bool implicit_p[(int)END_BUILTINS];
-} builtin_info_type;
-
-extern GTY(()) builtin_info_type builtin_info;
-
 /* Valid builtin number.  */
 #define BUILTIN_VALID_P(FNCODE) \
   (IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1))