Factor gimple structures out of gimple.h

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.

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

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