This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Factor gimple structures out of gimple.h
- From: Diego Novillo <dnovillo at google dot com>
- To: amacleod at redhat dot com, gcc-patches at gcc dot gnu dot org
- Date: Fri, 6 Sep 2013 18:26:13 -0400
- Subject: Factor gimple structures out of gimple.h
- Authentication-results: sourceware.org; auth=none
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