* Factor gimple structures out of gimple.h
@ 2013-09-06 22:26 Diego Novillo
2013-09-09 9:06 ` Richard Biener
0 siblings, 1 reply; 3+ messages in thread
From: Diego Novillo @ 2013-09-06 22:26 UTC (permalink / raw)
To: amacleod, gcc-patches
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.
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
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: Factor gimple structures out of gimple.h
2013-09-06 22:26 Factor gimple structures out of gimple.h Diego Novillo
@ 2013-09-09 9:06 ` Richard Biener
2013-09-10 13:55 ` Andrew MacLeod
0 siblings, 1 reply; 3+ messages in thread
From: Richard Biener @ 2013-09-09 9:06 UTC (permalink / raw)
To: Diego Novillo; +Cc: Andrew MacLeod, GCC Patches
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
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: Factor gimple structures out of gimple.h
2013-09-09 9:06 ` Richard Biener
@ 2013-09-10 13:55 ` Andrew MacLeod
0 siblings, 0 replies; 3+ messages in thread
From: Andrew MacLeod @ 2013-09-10 13:55 UTC (permalink / raw)
To: Richard Biener; +Cc: Diego Novillo, GCC Patches
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
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2013-09-10 13:49 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2013-09-06 22:26 Factor gimple structures out of gimple.h Diego Novillo
2013-09-09 9:06 ` Richard Biener
2013-09-10 13:55 ` Andrew MacLeod
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).