diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index a72b753..2be8846 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -882,15 +882,19 @@ 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
-GIMPLE_H = gimple.h gimple.def gsstruct.def pointer-set.h $(VEC_H) \
+GIMPLE_CORE_H = gimple-core.h $(CONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \
+		$(INPUT_H) gimple.def gsstruct.def $(TREE_SSA_ALIAS_H) \
+		$(INTERNAL_FN_H) $(TREE_CORE_H)
+GIMPLE_H = gimple.h $(GIMPLE_CORE_H) pointer-set.h $(VEC_H) \
 	$(GGC_H) $(BASIC_BLOCK_H) $(TREE_H) tree-ssa-operands.h \
-	tree-ssa-alias.h $(INTERNAL_FN_H) $(HASH_TABLE_H)
+	$(HASH_TABLE_H)
 TRANS_MEM_H = trans-mem.h
 GCOV_IO_H = gcov-io.h gcov-iov.h auto-host.h
 COVERAGE_H = coverage.h $(GCOV_IO_H)
 DEMANGLE_H = $(srcdir)/../include/demangle.h
 RECOG_H = recog.h
 ALIAS_H = alias.h
+TREE_SSA_ALIAS_H = tree-ssa-alias.h $(ALIAS_H)
 EMIT_RTL_H = emit-rtl.h
 FLAGS_H = flags.h flag-types.h $(OPTIONS_H)
 OPTIONS_H = options.h flag-types.h $(OPTIONS_H_EXTRA)
@@ -946,7 +950,7 @@ TREE_PASS_H = tree-pass.h $(TIMEVAR_H) $(DUMPFILE_H)
 TREE_FLOW_H = tree-flow.h tree-flow-inline.h tree-ssa-operands.h \
 		$(BITMAP_H) sbitmap.h $(BASIC_BLOCK_H) $(GIMPLE_H) \
 		$(HASHTAB_H) $(CGRAPH_H) $(IPA_REFERENCE_H) \
-		tree-ssa-alias.h
+		$(TREE_SSA_ALIAS_H)
 TREE_HASHER_H = tree-hasher.h $(HASH_TABLE_H) $(TREE_FLOW_H)
 TREE_SSA_LIVE_H = tree-ssa-live.h $(PARTITION_H)
 SSAEXPAND_H = ssaexpand.h $(TREE_SSA_LIVE_H)
@@ -2234,7 +2238,7 @@ test-dump.o : test-dump.c $(CONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \
    $(BITMAP_H) sbitmap.h sreal.h $(TREE_H) $(CXX_PARSER_H) $(DWARF2OUT_H) \
    $(GIMPLE_PRETTY_PRINT_H) $(BASIC_BLOCK_H) insn-config.h $(LRA_INT.H) \
    $(SEL_SCHED_DUMP_H) $(IRA_INT_H) $(TREE_DATA_REF_H) $(TREE_FLOW_H) \
-   $(TREE_SSA_LIVE_H) tree-ssa-alias.h $(OMEGA_H) $(RTL_H)
+   $(TREE_SSA_LIVE_H) $(TREE_SSA_ALIAS_H) $(OMEGA_H) $(RTL_H)
 tree.o: tree.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
    all-tree.def $(FLAGS_H) $(FUNCTION_H) $(PARAMS_H) \
    toplev.h $(DIAGNOSTIC_CORE_H) $(GGC_H) $(HASHTAB_H) $(TARGET_H) output.h $(TM_P_H) \
@@ -2722,7 +2726,7 @@ targhooks.o : targhooks.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \
    $(EXPR_H) $(TM_H) $(RTL_H) $(TM_P_H) $(FUNCTION_H) output.h $(DIAGNOSTIC_CORE_H) \
    $(MACHMODE_H) $(TARGET_DEF_H) $(TARGET_H) $(GGC_H) gt-targhooks.h \
    $(OPTABS_H) $(RECOG_H) $(REGS_H) reload.h hard-reg-set.h intl.h $(OPTS_H) \
-   tree-ssa-alias.h $(TREE_FLOW_H)
+   $(TREE_SSA_ALIAS_H) $(TREE_FLOW_H)
 common/common-targhooks.o : common/common-targhooks.c $(CONFIG_H) $(SYSTEM_H) \
    coretypes.h $(INPUT_H) $(TM_H) $(COMMON_TARGET_H) common/common-targhooks.h
 
@@ -2746,7 +2750,7 @@ toplev.o : toplev.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
    langhooks.h insn-flags.h $(CFGLOOP_H) hosthooks.h \
    $(CGRAPH_H) $(COVERAGE_H) alloc-pool.h $(GGC_H) \
    $(OPTS_H) params.def tree-mudflap.h $(TREE_PASS_H) $(GIMPLE_H) \
-   tree-ssa-alias.h $(PLUGIN_H) realmpfr.h tree-diagnostic.h \
+   $(TREE_SSA_ALIAS_H) $(PLUGIN_H) realmpfr.h tree-diagnostic.h \
    $(TREE_PRETTY_PRINT_H) opts-diagnostic.h $(COMMON_TARGET_H) \
    tsan.h diagnostic-color.h $(CONTEXT_H) $(PASS_MANAGER_H)
 
@@ -3303,7 +3307,7 @@ alias.o : alias.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(DUMPFILE_H) \
    $(ALIAS_H) $(EMIT_RTL_H) $(GGC_H) $(FUNCTION_H) cselib.h $(TREE_H) $(TM_P_H) \
    langhooks.h $(TARGET_H) gt-alias.h $(TIMEVAR_H) $(CGRAPH_H) \
    $(SPLAY_TREE_H) $(DF_H) \
-   tree-ssa-alias.h pointer-set.h $(TREE_FLOW_H)
+   $(TREE_SSA_ALIAS_H) pointer-set.h $(TREE_FLOW_H)
 stack-ptr-mod.o : stack-ptr-mod.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    $(TM_H) $(TREE_H) $(RTL_H) $(REGS_H) $(EXPR_H) $(TREE_PASS_H) \
    $(BASIC_BLOCK_H) $(FLAGS_H) output.h $(DF_H)
@@ -3819,7 +3823,7 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \
   $(srcdir)/reg-stack.c $(srcdir)/cfgrtl.c \
   $(srcdir)/sdbout.c $(srcdir)/stor-layout.c \
   $(srcdir)/stringpool.c $(srcdir)/tree.c $(srcdir)/varasm.c \
-  $(srcdir)/gimple.h $(srcdir)/gimple.c \
+  $(srcdir)/gimple-core.h $(srcdir)/gimple.h $(srcdir)/gimple.c \
   $(srcdir)/tree-mudflap.c $(srcdir)/tree-flow.h \
   $(srcdir)/tree-ssanames.c $(srcdir)/tree-eh.c $(srcdir)/tree-ssa-address.c \
   $(srcdir)/tree-cfg.c \
diff --git a/gcc/gimple-core.h b/gcc/gimple-core.h
new file mode 100644
index 0000000..c489750
--- /dev/null
+++ b/gcc/gimple-core.h
@@ -0,0 +1,574 @@
+/* Data structure definitions for the gimple type.
+
+   Copyright (C) 2007-2013 Free Software Foundation, Inc.
+   Contributed by Diego Novillo <dnovillo@google.com>
+
+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_GIMPLE_CORE_H
+#define GCC_GIMPLE_CORE_H
+
+#include "input.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "tree-core.h"
+
+/* This file contains all the data structures that define the 'gimple' type.
+   There are no accessor macros nor functions in this file. Only the
+   basic data structures, extern declarations and type definitions.  */
+
+enum gimple_code {
+#define DEFGSCODE(SYM, STRING, STRUCT)	SYM,
+#include "gimple.def"
+#undef DEFGSCODE
+    LAST_AND_UNUSED_GIMPLE_CODE
+};
+
+/* Data structure definitions for GIMPLE tuples.  NOTE: word markers
+   are for 64 bit hosts.  */
+
+struct GTY((chain_next ("%h.next"))) gimple_statement_base {
+  /* [ WORD 1 ]
+     Main identifying code for a tuple.  */
+  ENUM_BITFIELD(gimple_code) code : 8;
+
+  /* Nonzero if a warning should not be emitted on this tuple.  */
+  unsigned int no_warning	: 1;
+
+  /* Nonzero if this tuple has been visited.  Passes are responsible
+     for clearing this bit before using it.  */
+  unsigned int visited		: 1;
+
+  /* Nonzero if this tuple represents a non-temporal move.  */
+  unsigned int nontemporal_move	: 1;
+
+  /* Pass local flags.  These flags are free for any pass to use as
+     they see fit.  Passes should not assume that these flags contain
+     any useful value when the pass starts.  Any initial state that
+     the pass requires should be set on entry to the pass.  See
+     gimple_set_plf and gimple_plf for usage.  */
+  unsigned int plf		: 2;
+
+  /* Nonzero if this statement has been modified and needs to have its
+     operands rescanned.  */
+  unsigned modified 		: 1;
+
+  /* Nonzero if this statement contains volatile operands.  */
+  unsigned has_volatile_ops 	: 1;
+
+  /* The SUBCODE field can be used for tuple-specific flags for tuples
+     that do not require subcodes.  Note that SUBCODE should be at
+     least as wide as tree codes, as several tuples store tree codes
+     in there.  */
+  unsigned int subcode		: 16;
+
+  /* UID of this statement.  This is used by passes that want to
+     assign IDs to statements.  It must be assigned and used by each
+     pass.  By default it should be assumed to contain garbage.  */
+  unsigned uid;
+
+  /* [ WORD 2 ]
+     Locus information for debug info.  */
+  location_t location;
+
+  /* Number of operands in this tuple.  */
+  unsigned num_ops;
+
+  /* [ WORD 3 ]
+     Basic block holding this statement.  */
+  basic_block bb;
+
+  /* [ WORD 4-5 ]
+     Linked lists of gimple statements.  The next pointers form
+     a NULL terminated list, the prev pointers are a cyclic list.
+     A gimple statement is hence also a double-ended list of
+     statements, with the pointer itself being the first element,
+     and the prev pointer being the last.  */
+  gimple 	next;
+  gimple GTY((skip)) prev;
+};
+
+
+/* Base structure for tuples with operands.  */
+
+struct GTY(()) gimple_statement_with_ops_base {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]
+     SSA operand vectors.  NOTE: It should be possible to
+     amalgamate these vectors with the operand vector OP.  However,
+     the SSA operand vectors are organized differently and contain
+     more information (like immediate use chaining).  */
+  struct use_optype_d GTY((skip (""))) *use_ops;
+};
+
+
+/* Statements that take register operands.  */
+
+struct GTY(()) gimple_statement_with_ops {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_with_ops_base opbase;
+
+  /* [ WORD 8 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1];
+};
+
+
+/* Base for statements that take both memory and register operands.  */
+
+struct GTY(()) gimple_statement_with_memory_ops_base {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_with_ops_base opbase;
+
+  /* [ WORD 8-9 ]
+     Virtual operands for this statement.  The GC will pick them
+     up via the ssa_names array.  */
+  tree GTY((skip (""))) vdef;
+  tree GTY((skip (""))) vuse;
+};
+
+
+/* Statements that take both memory and register operands.  */
+
+struct GTY(()) gimple_statement_with_memory_ops {
+  /* [ WORD 1-9 ]  */
+  struct gimple_statement_with_memory_ops_base membase;
+
+  /* [ WORD 10 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
+};
+
+
+/* Call statements that take both memory and register operands.  */
+
+struct GTY(()) gimple_statement_call {
+  /* [ WORD 1-9 ]  */
+  struct gimple_statement_with_memory_ops_base membase;
+
+  /* [ WORD 10-13 ]  */
+  struct pt_solution call_used;
+  struct pt_solution call_clobbered;
+
+  /* [ WORD 14 ]  */
+  union GTY ((desc ("%1.membase.opbase.gsbase.subcode & GF_CALL_INTERNAL"))) {
+    tree GTY ((tag ("0"))) fntype;
+    enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn;
+  } u;
+
+  /* [ WORD 15 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
+};
+
+
+/* OpenMP statements (#pragma omp).  */
+
+struct GTY(()) gimple_statement_omp {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]  */
+  gimple_seq body;
+};
+
+
+/* GIMPLE_BIND */
+
+struct GTY(()) gimple_statement_bind {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]
+     Variables declared in this scope.  */
+  tree vars;
+
+  /* [ WORD 8 ]
+     This is different than the BLOCK field in gimple_statement_base,
+     which is analogous to TREE_BLOCK (i.e., the lexical block holding
+     this statement).  This field is the equivalent of BIND_EXPR_BLOCK
+     in tree land (i.e., the lexical scope defined by this bind).  See
+     gimple-low.c.  */
+  tree block;
+
+  /* [ WORD 9 ]  */
+  gimple_seq body;
+};
+
+
+/* GIMPLE_CATCH */
+
+struct GTY(()) gimple_statement_catch {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]  */
+  tree types;
+
+  /* [ WORD 8 ]  */
+  gimple_seq handler;
+};
+
+
+/* GIMPLE_EH_FILTER */
+
+struct GTY(()) gimple_statement_eh_filter {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]
+     Filter types.  */
+  tree types;
+
+  /* [ WORD 8 ]
+     Failure actions.  */
+  gimple_seq failure;
+};
+
+/* GIMPLE_EH_ELSE */
+
+struct GTY(()) gimple_statement_eh_else {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7,8 ] */
+  gimple_seq n_body, e_body;
+};
+
+/* GIMPLE_EH_MUST_NOT_THROW */
+
+struct GTY(()) gimple_statement_eh_mnt {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ] Abort function decl.  */
+  tree fndecl;
+};
+
+/* GIMPLE_PHI */
+
+struct GTY(()) gimple_statement_phi {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]  */
+  unsigned capacity;
+  unsigned nargs;
+
+  /* [ WORD 8 ]  */
+  tree result;
+
+  /* [ WORD 9 ]  */
+  struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
+};
+
+
+/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
+
+struct GTY(()) gimple_statement_eh_ctrl
+{
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]
+     Exception region number.  */
+  int region;
+};
+
+
+/* GIMPLE_TRY */
+
+struct GTY(()) gimple_statement_try {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]
+     Expression to evaluate.  */
+  gimple_seq eval;
+
+  /* [ WORD 8 ]
+     Cleanup expression.  */
+  gimple_seq cleanup;
+};
+
+
+/* GIMPLE_WITH_CLEANUP_EXPR */
+
+struct GTY(()) gimple_statement_wce {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* Subcode: CLEANUP_EH_ONLY.  True if the cleanup should only be
+	      executed if an exception is thrown, not on normal exit of its
+	      scope.  This flag is analogous to the CLEANUP_EH_ONLY flag
+	      in TARGET_EXPRs.  */
+
+  /* [ WORD 7 ]
+     Cleanup expression.  */
+  gimple_seq cleanup;
+};
+
+
+/* GIMPLE_ASM  */
+
+struct GTY(()) gimple_statement_asm {
+  /* [ WORD 1-9 ]  */
+  struct gimple_statement_with_memory_ops_base membase;
+
+  /* [ WORD 10 ]
+     __asm__ statement.  */
+  const char *string;
+
+  /* [ WORD 11 ]
+       Number of inputs, outputs, clobbers, labels.  */
+  unsigned char ni;
+  unsigned char no;
+  unsigned char nc;
+  unsigned char nl;
+
+  /* [ WORD 12 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
+};
+
+
+/* GIMPLE_OMP_CRITICAL */
+
+struct GTY(()) gimple_statement_omp_critical {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_omp omp;
+
+  /* [ WORD 8 ]
+     Critical section name.  */
+  tree name;
+};
+
+
+struct GTY(()) gimple_omp_for_iter {
+  /* Condition code.  */
+  enum tree_code cond;
+
+  /* Index variable.  */
+  tree index;
+
+  /* Initial value.  */
+  tree initial;
+
+  /* Final value.  */
+  tree final;
+
+  /* Increment.  */
+  tree incr;
+};
+
+
+/* GIMPLE_OMP_FOR */
+
+struct GTY(()) gimple_statement_omp_for {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_omp omp;
+
+  /* [ WORD 8 ]  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Number of elements in iter array.  */
+  size_t collapse;
+
+  /* [ WORD 10 ]  */
+  struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
+
+  /* [ WORD 11 ]
+     Pre-body evaluated before the loop body begins.  */
+  gimple_seq pre_body;
+};
+
+
+/* GIMPLE_OMP_PARALLEL */
+
+struct GTY(()) gimple_statement_omp_parallel {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_omp omp;
+
+  /* [ WORD 8 ]
+     Clauses.  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Child function holding the body of the parallel region.  */
+  tree child_fn;
+
+  /* [ WORD 10 ]
+     Shared data argument.  */
+  tree data_arg;
+};
+
+
+/* GIMPLE_OMP_TASK */
+
+struct GTY(()) gimple_statement_omp_task {
+  /* [ WORD 1-10 ]  */
+  struct gimple_statement_omp_parallel par;
+
+  /* [ WORD 11 ]
+     Child function holding firstprivate initialization if needed.  */
+  tree copy_fn;
+
+  /* [ WORD 12-13 ]
+     Size and alignment in bytes of the argument data block.  */
+  tree arg_size;
+  tree arg_align;
+};
+
+
+/* GIMPLE_OMP_SECTION */
+/* Uses struct gimple_statement_omp.  */
+
+
+/* GIMPLE_OMP_SECTIONS */
+
+struct GTY(()) gimple_statement_omp_sections {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_omp omp;
+
+  /* [ WORD 8 ]  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     The control variable used for deciding which of the sections to
+     execute.  */
+  tree control;
+};
+
+
+/* GIMPLE_OMP_CONTINUE.
+
+   Note: This does not inherit from gimple_statement_omp, because we
+         do not need the body field.  */
+
+struct GTY(()) gimple_statement_omp_continue {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]  */
+  tree control_def;
+
+  /* [ WORD 8 ]  */
+  tree control_use;
+};
+
+
+/* GIMPLE_OMP_SINGLE */
+
+struct GTY(()) gimple_statement_omp_single {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_omp omp;
+
+  /* [ WORD 7 ]  */
+  tree clauses;
+};
+
+
+/* GIMPLE_OMP_ATOMIC_LOAD.
+   Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
+   contains a sequence, which we don't need here.  */
+
+struct GTY(()) gimple_statement_omp_atomic_load {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7-8 ]  */
+  tree rhs, lhs;
+};
+
+
+/* GIMPLE_OMP_ATOMIC_STORE.
+   See note on GIMPLE_OMP_ATOMIC_LOAD.  */
+
+struct GTY(()) gimple_statement_omp_atomic_store {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]  */
+  tree val;
+};
+
+/* GIMPLE_TRANSACTION.  */
+
+struct GTY(()) gimple_statement_transaction {
+  /* [ WORD 1-9 ]  */
+  struct gimple_statement_with_memory_ops_base gsbase;
+
+  /* [ WORD 10 ] */
+  gimple_seq body;
+
+  /* [ WORD 11 ] */
+  tree label;
+};
+
+#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)	SYM,
+enum gimple_statement_structure_enum {
+#include "gsstruct.def"
+    LAST_GSS_ENUM
+};
+#undef DEFGSSTRUCT
+
+
+/* Define the overall contents of a gimple tuple.  It may be any of the
+   structures declared above for various types of tuples.  */
+
+union GTY ((desc ("gimple_statement_structure (&%h)"),
+	    chain_next ("%h.gsbase.next"), variable_size)) gimple_statement_d {
+  struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase;
+  struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops;
+  struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase;
+  struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem;
+  struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gimple_call;
+  struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp;
+  struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind;
+  struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch;
+  struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter;
+  struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt;
+  struct gimple_statement_eh_else GTY ((tag ("GSS_EH_ELSE"))) gimple_eh_else;
+  struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi;
+  struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl;
+  struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try;
+  struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce;
+  struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm;
+  struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical;
+  struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for;
+  struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gimple_omp_parallel;
+  struct gimple_statement_omp_task GTY ((tag ("GSS_OMP_TASK"))) gimple_omp_task;
+  struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gimple_omp_sections;
+  struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gimple_omp_single;
+  struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue;
+  struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load;
+  struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store;
+  struct gimple_statement_transaction GTY((tag ("GSS_TRANSACTION"))) gimple_transaction;
+};
+
+#endif  /* GCC_GIMPLE_CORE_H */
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 9f29561..3d2120f 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -22,6 +22,8 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_GIMPLE_H
 #define GCC_GIMPLE_H
 
+#include "gimple-core.h"
+
 #include "pointer-set.h"
 #include "hash-table.h"
 #include "vec.h"
@@ -47,13 +49,6 @@ enum ssa_mode {
    these vectors.  */
 typedef vec<gimple> gimple_vec;
 
-enum gimple_code {
-#define DEFGSCODE(SYM, STRING, STRUCT)	SYM,
-#include "gimple.def"
-#undef DEFGSCODE
-    LAST_AND_UNUSED_GIMPLE_CODE
-};
-
 extern const char *const gimple_code_name[];
 extern const unsigned char gimple_rhs_class_table[];
 
@@ -156,286 +151,6 @@ struct gimple_stmt_iterator_d
   basic_block bb;
 };
 
-/* Data structure definitions for GIMPLE tuples.  NOTE: word markers
-   are for 64 bit hosts.  */
-
-struct GTY((chain_next ("%h.next"))) gimple_statement_base {
-  /* [ WORD 1 ]
-     Main identifying code for a tuple.  */
-  ENUM_BITFIELD(gimple_code) code : 8;
-
-  /* Nonzero if a warning should not be emitted on this tuple.  */
-  unsigned int no_warning	: 1;
-
-  /* Nonzero if this tuple has been visited.  Passes are responsible
-     for clearing this bit before using it.  */
-  unsigned int visited		: 1;
-
-  /* Nonzero if this tuple represents a non-temporal move.  */
-  unsigned int nontemporal_move	: 1;
-
-  /* Pass local flags.  These flags are free for any pass to use as
-     they see fit.  Passes should not assume that these flags contain
-     any useful value when the pass starts.  Any initial state that
-     the pass requires should be set on entry to the pass.  See
-     gimple_set_plf and gimple_plf for usage.  */
-  unsigned int plf		: 2;
-
-  /* Nonzero if this statement has been modified and needs to have its
-     operands rescanned.  */
-  unsigned modified 		: 1;
-
-  /* Nonzero if this statement contains volatile operands.  */
-  unsigned has_volatile_ops 	: 1;
-
-  /* The SUBCODE field can be used for tuple-specific flags for tuples
-     that do not require subcodes.  Note that SUBCODE should be at
-     least as wide as tree codes, as several tuples store tree codes
-     in there.  */
-  unsigned int subcode		: 16;
-
-  /* UID of this statement.  This is used by passes that want to
-     assign IDs to statements.  It must be assigned and used by each
-     pass.  By default it should be assumed to contain garbage.  */
-  unsigned uid;
-
-  /* [ WORD 2 ]
-     Locus information for debug info.  */
-  location_t location;
-
-  /* Number of operands in this tuple.  */
-  unsigned num_ops;
-
-  /* [ WORD 3 ]
-     Basic block holding this statement.  */
-  basic_block bb;
-
-  /* [ WORD 4-5 ]
-     Linked lists of gimple statements.  The next pointers form
-     a NULL terminated list, the prev pointers are a cyclic list.
-     A gimple statement is hence also a double-ended list of
-     statements, with the pointer itself being the first element,
-     and the prev pointer being the last.  */
-  gimple next;
-  gimple GTY((skip)) prev;
-};
-
-
-/* Base structure for tuples with operands.  */
-
-struct GTY(()) gimple_statement_with_ops_base
-{
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]
-     SSA operand vectors.  NOTE: It should be possible to
-     amalgamate these vectors with the operand vector OP.  However,
-     the SSA operand vectors are organized differently and contain
-     more information (like immediate use chaining).  */
-  struct use_optype_d GTY((skip (""))) *use_ops;
-};
-
-
-/* Statements that take register operands.  */
-
-struct GTY(()) gimple_statement_with_ops
-{
-  /* [ WORD 1-7 ]  */
-  struct gimple_statement_with_ops_base opbase;
-
-  /* [ WORD 8 ]
-     Operand vector.  NOTE!  This must always be the last field
-     of this structure.  In particular, this means that this
-     structure cannot be embedded inside another one.  */
-  tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1];
-};
-
-
-/* Base for statements that take both memory and register operands.  */
-
-struct GTY(()) gimple_statement_with_memory_ops_base
-{
-  /* [ WORD 1-7 ]  */
-  struct gimple_statement_with_ops_base opbase;
-
-  /* [ WORD 8-9 ]
-     Virtual operands for this statement.  The GC will pick them
-     up via the ssa_names array.  */
-  tree GTY((skip (""))) vdef;
-  tree GTY((skip (""))) vuse;
-};
-
-
-/* Statements that take both memory and register operands.  */
-
-struct GTY(()) gimple_statement_with_memory_ops
-{
-  /* [ WORD 1-9 ]  */
-  struct gimple_statement_with_memory_ops_base membase;
-
-  /* [ WORD 10 ]
-     Operand vector.  NOTE!  This must always be the last field
-     of this structure.  In particular, this means that this
-     structure cannot be embedded inside another one.  */
-  tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
-};
-
-
-/* Call statements that take both memory and register operands.  */
-
-struct GTY(()) gimple_statement_call
-{
-  /* [ WORD 1-9 ]  */
-  struct gimple_statement_with_memory_ops_base membase;
-
-  /* [ WORD 10-13 ]  */
-  struct pt_solution call_used;
-  struct pt_solution call_clobbered;
-
-  /* [ WORD 14 ]  */
-  union GTY ((desc ("%1.membase.opbase.gsbase.subcode & GF_CALL_INTERNAL"))) {
-    tree GTY ((tag ("0"))) fntype;
-    enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn;
-  } u;
-
-  /* [ WORD 15 ]
-     Operand vector.  NOTE!  This must always be the last field
-     of this structure.  In particular, this means that this
-     structure cannot be embedded inside another one.  */
-  tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
-};
-
-
-/* OpenMP statements (#pragma omp).  */
-
-struct GTY(()) gimple_statement_omp {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]  */
-  gimple_seq body;
-};
-
-
-/* GIMPLE_BIND */
-
-struct GTY(()) gimple_statement_bind {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]
-     Variables declared in this scope.  */
-  tree vars;
-
-  /* [ WORD 8 ]
-     This is different than the BLOCK field in gimple_statement_base,
-     which is analogous to TREE_BLOCK (i.e., the lexical block holding
-     this statement).  This field is the equivalent of BIND_EXPR_BLOCK
-     in tree land (i.e., the lexical scope defined by this bind).  See
-     gimple-low.c.  */
-  tree block;
-
-  /* [ WORD 9 ]  */
-  gimple_seq body;
-};
-
-
-/* GIMPLE_CATCH */
-
-struct GTY(()) gimple_statement_catch {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]  */
-  tree types;
-
-  /* [ WORD 8 ]  */
-  gimple_seq handler;
-};
-
-
-/* GIMPLE_EH_FILTER */
-
-struct GTY(()) gimple_statement_eh_filter {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]
-     Filter types.  */
-  tree types;
-
-  /* [ WORD 8 ]
-     Failure actions.  */
-  gimple_seq failure;
-};
-
-/* GIMPLE_EH_ELSE */
-
-struct GTY(()) gimple_statement_eh_else {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7,8 ] */
-  gimple_seq n_body, e_body;
-};
-
-/* GIMPLE_EH_MUST_NOT_THROW */
-
-struct GTY(()) gimple_statement_eh_mnt {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ] Abort function decl.  */
-  tree fndecl;
-};
-
-/* GIMPLE_PHI */
-
-struct GTY(()) gimple_statement_phi {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]  */
-  unsigned capacity;
-  unsigned nargs;
-
-  /* [ WORD 8 ]  */
-  tree result;
-
-  /* [ WORD 9 ]  */
-  struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
-};
-
-
-/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
-
-struct GTY(()) gimple_statement_eh_ctrl
-{
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]
-     Exception region number.  */
-  int region;
-};
-
-
-/* GIMPLE_TRY */
-
-struct GTY(()) gimple_statement_try {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]
-     Expression to evaluate.  */
-  gimple_seq eval;
-
-  /* [ WORD 8 ]
-     Cleanup expression.  */
-  gimple_seq cleanup;
-};
-
 /* Kind of GIMPLE_TRY statements.  */
 enum gimple_try_flags
 {
@@ -450,206 +165,6 @@ enum gimple_try_flags
   GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
 };
 
-/* GIMPLE_WITH_CLEANUP_EXPR */
-
-struct GTY(()) gimple_statement_wce {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* Subcode: CLEANUP_EH_ONLY.  True if the cleanup should only be
-	      executed if an exception is thrown, not on normal exit of its
-	      scope.  This flag is analogous to the CLEANUP_EH_ONLY flag
-	      in TARGET_EXPRs.  */
-
-  /* [ WORD 7 ]
-     Cleanup expression.  */
-  gimple_seq cleanup;
-};
-
-
-/* GIMPLE_ASM  */
-
-struct GTY(()) gimple_statement_asm
-{
-  /* [ WORD 1-9 ]  */
-  struct gimple_statement_with_memory_ops_base membase;
-
-  /* [ WORD 10 ]
-     __asm__ statement.  */
-  const char *string;
-
-  /* [ WORD 11 ]
-       Number of inputs, outputs, clobbers, labels.  */
-  unsigned char ni;
-  unsigned char no;
-  unsigned char nc;
-  unsigned char nl;
-
-  /* [ WORD 12 ]
-     Operand vector.  NOTE!  This must always be the last field
-     of this structure.  In particular, this means that this
-     structure cannot be embedded inside another one.  */
-  tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
-};
-
-/* GIMPLE_OMP_CRITICAL */
-
-struct GTY(()) gimple_statement_omp_critical {
-  /* [ WORD 1-7 ]  */
-  struct gimple_statement_omp omp;
-
-  /* [ WORD 8 ]
-     Critical section name.  */
-  tree name;
-};
-
-
-struct GTY(()) gimple_omp_for_iter {
-  /* Condition code.  */
-  enum tree_code cond;
-
-  /* Index variable.  */
-  tree index;
-
-  /* Initial value.  */
-  tree initial;
-
-  /* Final value.  */
-  tree final;
-
-  /* Increment.  */
-  tree incr;
-};
-
-/* GIMPLE_OMP_FOR */
-
-struct GTY(()) gimple_statement_omp_for {
-  /* [ WORD 1-7 ]  */
-  struct gimple_statement_omp omp;
-
-  /* [ WORD 8 ]  */
-  tree clauses;
-
-  /* [ WORD 9 ]
-     Number of elements in iter array.  */
-  size_t collapse;
-
-  /* [ WORD 10 ]  */
-  struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
-
-  /* [ WORD 11 ]
-     Pre-body evaluated before the loop body begins.  */
-  gimple_seq pre_body;
-};
-
-
-/* GIMPLE_OMP_PARALLEL */
-
-struct GTY(()) gimple_statement_omp_parallel {
-  /* [ WORD 1-7 ]  */
-  struct gimple_statement_omp omp;
-
-  /* [ WORD 8 ]
-     Clauses.  */
-  tree clauses;
-
-  /* [ WORD 9 ]
-     Child function holding the body of the parallel region.  */
-  tree child_fn;
-
-  /* [ WORD 10 ]
-     Shared data argument.  */
-  tree data_arg;
-};
-
-
-/* GIMPLE_OMP_TASK */
-
-struct GTY(()) gimple_statement_omp_task {
-  /* [ WORD 1-10 ]  */
-  struct gimple_statement_omp_parallel par;
-
-  /* [ WORD 11 ]
-     Child function holding firstprivate initialization if needed.  */
-  tree copy_fn;
-
-  /* [ WORD 12-13 ]
-     Size and alignment in bytes of the argument data block.  */
-  tree arg_size;
-  tree arg_align;
-};
-
-
-/* GIMPLE_OMP_SECTION */
-/* Uses struct gimple_statement_omp.  */
-
-
-/* GIMPLE_OMP_SECTIONS */
-
-struct GTY(()) gimple_statement_omp_sections {
-  /* [ WORD 1-7 ]  */
-  struct gimple_statement_omp omp;
-
-  /* [ WORD 8 ]  */
-  tree clauses;
-
-  /* [ WORD 9 ]
-     The control variable used for deciding which of the sections to
-     execute.  */
-  tree control;
-};
-
-/* GIMPLE_OMP_CONTINUE.
-
-   Note: This does not inherit from gimple_statement_omp, because we
-         do not need the body field.  */
-
-struct GTY(()) gimple_statement_omp_continue {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]  */
-  tree control_def;
-
-  /* [ WORD 8 ]  */
-  tree control_use;
-};
-
-/* GIMPLE_OMP_SINGLE */
-
-struct GTY(()) gimple_statement_omp_single {
-  /* [ WORD 1-7 ]  */
-  struct gimple_statement_omp omp;
-
-  /* [ WORD 7 ]  */
-  tree clauses;
-};
-
-
-/* GIMPLE_OMP_ATOMIC_LOAD.
-   Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
-   contains a sequence, which we don't need here.  */
-
-struct GTY(()) gimple_statement_omp_atomic_load {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7-8 ]  */
-  tree rhs, lhs;
-};
-
-/* GIMPLE_OMP_ATOMIC_STORE.
-   See note on GIMPLE_OMP_ATOMIC_LOAD.  */
-
-struct GTY(()) gimple_statement_omp_atomic_store {
-  /* [ WORD 1-6 ]  */
-  struct gimple_statement_base gsbase;
-
-  /* [ WORD 7 ]  */
-  tree val;
-};
-
-/* GIMPLE_TRANSACTION.  */
 
 /* Bits to be stored in the GIMPLE_TRANSACTION subcode.  */
 
@@ -677,58 +192,6 @@ struct GTY(()) gimple_statement_omp_atomic_store {
    likely because it is guaranteed to go irrevocable upon entry.  */
 #define GTMA_HAS_NO_INSTRUMENTATION	(1u << 7)
 
-struct GTY(()) gimple_statement_transaction
-{
-  /* [ WORD 1-9 ]  */
-  struct gimple_statement_with_memory_ops_base gsbase;
-
-  /* [ WORD 10 ] */
-  gimple_seq body;
-
-  /* [ WORD 11 ] */
-  tree label;
-};
-
-#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)	SYM,
-enum gimple_statement_structure_enum {
-#include "gsstruct.def"
-    LAST_GSS_ENUM
-};
-#undef DEFGSSTRUCT
-
-
-/* Define the overall contents of a gimple tuple.  It may be any of the
-   structures declared above for various types of tuples.  */
-
-union GTY ((desc ("gimple_statement_structure (&%h)"),
-	    chain_next ("%h.gsbase.next"), variable_size)) gimple_statement_d {
-  struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase;
-  struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops;
-  struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase;
-  struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem;
-  struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gimple_call;
-  struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp;
-  struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind;
-  struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch;
-  struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter;
-  struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt;
-  struct gimple_statement_eh_else GTY ((tag ("GSS_EH_ELSE"))) gimple_eh_else;
-  struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi;
-  struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl;
-  struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try;
-  struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce;
-  struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm;
-  struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical;
-  struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for;
-  struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gimple_omp_parallel;
-  struct gimple_statement_omp_task GTY ((tag ("GSS_OMP_TASK"))) gimple_omp_task;
-  struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gimple_omp_sections;
-  struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gimple_omp_single;
-  struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue;
-  struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load;
-  struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store;
-  struct gimple_statement_transaction GTY((tag ("GSS_TRANSACTION"))) gimple_transaction;
-};
 
 /* In gimple.c.  */
 
diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h
index 96d0192..39bd835 100644
--- a/gcc/tree-ssa-alias.h
+++ b/gcc/tree-ssa-alias.h
@@ -21,6 +21,8 @@
 #ifndef TREE_SSA_ALIAS_H
 #define TREE_SSA_ALIAS_H
 
+#include "alias.h"
+
 /* The points-to solution.
 
    The points-to solution is a union of pt_vars and the abstract
