Patchwork Factor gimple structures out of gimple.h

login
register
mail settings
Submitter Diego Novillo
Date Sept. 6, 2013, 10:26 p.m.
Message ID <20130906222613.GA22838@google.com>
Download mbox | patch
Permalink /patch/273348/
State New
Headers show

Comments

Diego Novillo - Sept. 6, 2013, 10:26 p.m.
This patch introduces gimple-core.h, which contains just the data
structures needed to define gimple. I left everything else in
gimple.h

The addition of alias.h to tree-ssa-alias.h is so that we can
include tree-ssa-alias.h in isolation. It now includes everything
it needs.

More discussion on rationale at the thread:
http://gcc.gnu.org/ml/gcc-patches/2013-09/msg00300.html

Tested on x86_64.


2013-09-06  Diego Novillo  <dnovillo@google.com>

	* Makefile.in (GIMPLE_CORE_H): New.
        (GIMPLE_H): Depend on GIMPLE_CORE_H.
        (TREE_SSA_ALIAS_H): New. Replace references to tree-ssa-alias.h with
        TREE_SSA_ALIAS_H.
	* gimple-core.h: New. Factor all gimple data structures out of ...
	* gimple.h: ... here.
	* tree-ssa-alias.h: Include alias.h.
Richard Guenther - Sept. 9, 2013, 9 a.m.
On Sat, Sep 7, 2013 at 12:26 AM, Diego Novillo <dnovillo@google.com> wrote:
> This patch introduces gimple-core.h, which contains just the data
> structures needed to define gimple. I left everything else in
> gimple.h
>
> The addition of alias.h to tree-ssa-alias.h is so that we can
> include tree-ssa-alias.h in isolation. It now includes everything
> it needs.

Because of alias_set_type?  That easily could move to coretypes.h.

> More discussion on rationale at the thread:
> http://gcc.gnu.org/ml/gcc-patches/2013-09/msg00300.html
>
> Tested on x86_64.

The split looks ok to me, given the plan.  But as there is still discussion
around it please hold off until that died down with a conclusion.

Thanks,
Richard.

> 2013-09-06  Diego Novillo  <dnovillo@google.com>
>
>         * Makefile.in (GIMPLE_CORE_H): New.
>         (GIMPLE_H): Depend on GIMPLE_CORE_H.
>         (TREE_SSA_ALIAS_H): New. Replace references to tree-ssa-alias.h with
>         TREE_SSA_ALIAS_H.
>         * gimple-core.h: New. Factor all gimple data structures out of ...
>         * gimple.h: ... here.
>         * tree-ssa-alias.h: Include alias.h.
>
> 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
Andrew MacLeod - Sept. 10, 2013, 1:49 p.m.
On 09/09/2013 05:00 AM, Richard Biener wrote:

>> More discussion on rationale at the thread:
>> http://gcc.gnu.org/ml/gcc-patches/2013-09/msg00300.html
>>
>> Tested on x86_64.
> The split looks ok to me, given the plan.  But as there is still discussion
> around it please hold off until that died down with a conclusion.
>
>

Im not sure I need to have this pushed into mainline. Now that I see the 
split, I dont think it's going to buy us much in mainline, and will be 
simple to maintain in a branch (unlike the tree one :-).  So check it 
into the tree-wrapper branch for holding.

Andrew

Patch

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