git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

gimplify-be.h: New file. 

* gimplify-be.h:  New file.  Add prototypes.
	* gimplify.h: Don't include gimple.h.
	(struct gimplify_hasher, struct gimplify_ctx, is_gimple_sizepos,
	gimplify_hasher::hash, gimplify_hasher::equal): Relocate from gimple.h.
	* gimple.h (struct gimplify_hasher, gimplify_hasher::hash,
	gimplify_hasher::equal, struct gimplify_ctx, is_gimple_sizepos): Move
	to gimplify.h.
	(enum gsi_iterator_update): Move to gimple-iterator.h.
	* gimple-iterator.h (enum gsi_iterator_update): Relocate from gimple.h.
	* gimplify-be.c: New File.
	(force_gimple_operand_1, force_gimple_operand,
	force_gimple_operand_gsi_1, force_gimple_operand_gsi): Relocate from
	gimplify.c.
	* gimplify.c (force_gimple_operand_1, force_gimple_operand,
	force_gimple_operand_gsi_1, force_gimple_operand_gsi): Move to
	gimplify-be.c.
	* Makefile.in (OBJS): Add gimplify-be.o
	* asan.c: Include only gimplify.h, gimplify-be.h, and/or gimple.h as
	required.
	* cfgloopmanip.c: Likewise.
	* cgraphunit.c: Likewise.
	* cilk-common.c: Likewise.
	* fold-const.c: Likewise.
	* function.c: Likewise.
	* gimple-expr.c: Likewise.
	* gimple-fold.c: Likewise.
	* gimple-ssa-strength-reduction.c: Likewise.
	* gimple.c: Likewise.
	* graphite-clast-to-gimple.c: Likewise.
	* graphite-sese-to-poly.c: Likewise.
	* ipa-prop.c: Likewise.
	* ipa-split.c: Likewise.
	* ipa.c: Likewise.
	* langhooks.c: Likewise.
	* omp-low.c: Likewise.
	* sese.c: Likewise.
	* stor-layout.c: Likewise.
	* targhooks.c: Likewise.
	* trans-mem.c: Likewise.
	* tree-affine.c: Likewise.
	* tree-cfg.c: Likewise.
	* tree-cfgcleanup.c: Likewise.
	* tree-complex.c: Likewise.
	* tree-if-conv.c: Likewise.
	* tree-inline.c: Likewise.
	* tree-loop-distribution.c: Likewise.
	* tree-nested.c: Likewise.
	* tree-parloops.c: Likewise.
	* tree-predcom.c: Likewise.
	* tree-profile.c: Likewise.
	* tree-scalar-evolution.c: Likewise.
	* tree-sra.c: Likewise.
	* tree-ssa-address.c: Likewise.
	* tree-ssa-ccp.c: Likewise.
	* tree-ssa-dce.c: Likewise.
	* tree-ssa-forwprop.c: Likewise.
	* tree-ssa-ifcombine.c: Likewise.
	* tree-ssa-loop-im.c: Likewise.
	* tree-ssa-loop-ivopts.c: Likewise.
	* tree-ssa-loop-manip.c: Likewise.
	* tree-ssa-loop-niter.c: Likewise.
	* tree-ssa-loop-prefetch.c: Likewise.
	* tree-ssa-loop-unswitch.c: Likewise.
	* tree-ssa-math-opts.c: Likewise.
	* tree-ssa-phiopt.c: Likewise.
	* tree-ssa-phiprop.c: Likewise.
	* tree-ssa-pre.c: Likewise.
	* tree-ssa-propagate.c: Likewise.
	* tree-ssa-reassoc.c: Likewise.
	* tree-ssa-sccvn.c: Likewise.
	* tree-ssa-strlen.c: Likewise.
	* tree-ssa.c: Likewise.
	* tree-switch-conversion.c: Likewise.
	* tree-tailcall.c: Likewise.
	* tree-vect-data-refs.c: Likewise.
	* tree-vect-generic.c: Likewise.
	* tree-vect-loop-manip.c: Likewise.
	* tree-vect-loop.c: Likewise.
	* tree-vect-patterns.c: Likewise.
	* tree-vect-stmts.c: Likewise.
	* tree.c: Likewise.
	* tsan.c: Likewise.
	* value-prof.c: Likewise.
	* config/aarch64/aarch64.c: Likewise.
	* config/alpha/alpha.c: Likewise.
	* config/darwin.c: Likewise.
	* config/i386/i386.c: Likewise.
	* config/ia64/ia64.c: Likewise.
	* config/mep/mep.c: Likewise.
	* config/mips/mips.c: Likewise.
	* config/rs6000/rs6000.c: Likewise.
	* config/s390/s390.c: Likewise.
	* config/sh/sh.c: Likewise.
	* config/sparc/sparc.c: Likewise.
	* config/spu/spu.c: Likewise.
	* config/stormy16/stormy16.c: Likewise.
	* config/tilegx/tilegx.c: Likewise.
	* config/tilepro/tilepro.c: Likewise.
	* config/xtensa/xtensa.c: Likewise.

	* c/c-typeck.c: Include only gimplify.h and gimple.h as needed.
	* c-family/c-common.c: Likewise.
	* c-family/c-gimplify.c: Likewise.
	* c-family/cilk.c: Likewise.

	* cp/class.c: Include only gimplify.h and gimple.h as needed.
	* cp/cp-gimplify.c: Likewise.
	* cp/error.c: Likewise.
	* cp/init.c: Likewise.
	* cp/optimize.c: Likewise.
	* cp/pt.c: Likewise.
	* cp/semantics.c: Likewise.
	* cp/tree.c: Likewise.
	* cp/vtable-class-hierarchy.c: Likewise.

	* fortran/trans-expr.c: Include only gimplify.h and gimple.h as needed.
	* fortran/trans-openmp.c: Likewise.

	* go/go-lang.c: Include only gimplify.h and gimple.h as needed.

	* java/java-gimplify.c: Include only gimplify.h and gimple.h as needed.

	* objc/objc-act.c: Include only gimplify.h and gimple.h as needed.

From-SVN: r204812
This commit is contained in:
Andrew MacLeod 2013-11-14 19:39:38 +00:00 committed by Andrew Macleod
parent 6495f8e61f
commit 18f429e29c
114 changed files with 756 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
gcc/ChangeLog
View File

@ -1,3 +1,106 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* gimplify-me.h: New file. Add prototypes.
* gimplify.h: Don't include gimple.h.
(struct gimplify_hasher, struct gimplify_ctx, is_gimple_sizepos):
Relocate from gimple.h.
* gimple.h (struct gimplify_hasher, struct gimplify_ctx,
is_gimple_sizepos): Move to gimplify.h.
(gimplify_hasher::hash, gimplify_hasher::equal): Move to gimplify.c.
(enum gsi_iterator_update): Move to gimple-iterator.h.
* gimple-iterator.h (enum gsi_iterator_update): Relocate from gimple.h.
* gimplify-me.c: New File.
(force_gimple_operand_1, force_gimple_operand,
force_gimple_operand_gsi_1, force_gimple_operand_gsi,
gimple_regimplify_operands): Relocate from gimplify.c.
* gimplify.c (force_gimple_operand_1, force_gimple_operand,
force_gimple_operand_gsi_1, force_gimple_operand_gsi,
gimple_regimplify_operands): Move to gimplify-me.c.
(gimplify_hasher::hash, gimplify_hasher::equal): Relocate from gimple.h.
* Makefile.in (OBJS): Add gimplify-me.o
* asan.c: Include only gimplify.h, gimplify-me.h, and/or gimple.h as
required.
* cfgloopmanip.c: Likewise.
* cgraphunit.c: Likewise.
* cilk-common.c: Likewise.
* fold-const.c: Likewise.
* function.c: Likewise.
* gimple-expr.c: Likewise.
* gimple-fold.c: Likewise.
* gimple-ssa-strength-reduction.c: Likewise.
* gimple.c: Likewise.
* graphite-clast-to-gimple.c: Likewise.
* graphite-sese-to-poly.c: Likewise.
* ipa-prop.c: Likewise.
* ipa-split.c: Likewise.
* ipa.c: Likewise.
* langhooks.c: Likewise.
* omp-low.c: Likewise.
* sese.c: Likewise.
* stor-layout.c: Likewise.
* targhooks.c: Likewise.
* trans-mem.c: Likewise.
* tree-affine.c: Likewise.
* tree-cfg.c: Likewise.
* tree-cfgcleanup.c: Likewise.
* tree-complex.c: Likewise.
* tree-if-conv.c: Likewise.
* tree-inline.c: Likewise.
* tree-loop-distribution.c: Likewise.
* tree-nested.c: Likewise.
* tree-parloops.c: Likewise.
* tree-predcom.c: Likewise.
* tree-profile.c: Likewise.
* tree-scalar-evolution.c: Likewise.
* tree-sra.c: Likewise.
* tree-ssa-address.c: Likewise.
* tree-ssa-ccp.c: Likewise.
* tree-ssa-dce.c: Likewise.
* tree-ssa-forwprop.c: Likewise.
* tree-ssa-ifcombine.c: Likewise.
* tree-ssa-loop-im.c: Likewise.
* tree-ssa-loop-ivopts.c: Likewise.
* tree-ssa-loop-manip.c: Likewise.
* tree-ssa-loop-niter.c: Likewise.
* tree-ssa-loop-prefetch.c: Likewise.
* tree-ssa-loop-unswitch.c: Likewise.
* tree-ssa-math-opts.c: Likewise.
* tree-ssa-phiopt.c: Likewise.
* tree-ssa-phiprop.c: Likewise.
* tree-ssa-pre.c: Likewise.
* tree-ssa-propagate.c: Likewise.
* tree-ssa-reassoc.c: Likewise.
* tree-ssa-sccvn.c: Likewise.
* tree-ssa-strlen.c: Likewise.
* tree-ssa.c: Likewise.
* tree-switch-conversion.c: Likewise.
* tree-tailcall.c: Likewise.
* tree-vect-data-refs.c: Likewise.
* tree-vect-generic.c: Likewise.
* tree-vect-loop-manip.c: Likewise.
* tree-vect-loop.c: Likewise.
* tree-vect-patterns.c: Likewise.
* tree-vect-stmts.c: Likewise.
* tree.c: Likewise.
* tsan.c: Likewise.
* value-prof.c: Likewise.
* config/aarch64/aarch64.c: Likewise.
* config/alpha/alpha.c: Likewise.
* config/darwin.c: Likewise.
* config/i386/i386.c: Likewise.
* config/ia64/ia64.c: Likewise.
* config/mep/mep.c: Likewise.
* config/mips/mips.c: Likewise.
* config/rs6000/rs6000.c: Likewise.
* config/s390/s390.c: Likewise.
* config/sh/sh.c: Likewise.
* config/sparc/sparc.c: Likewise.
* config/spu/spu.c: Likewise.
* config/stormy16/stormy16.c: Likewise.
* config/tilegx/tilegx.c: Likewise.
* config/tilepro/tilepro.c: Likewise.
* config/xtensa/xtensa.c: Likewise.
2013-11-14 Joern Rennecke <joern.rennecke@embecosm.com>
* config/arc/arc.md (doloop_begin_i): Remove extra alignment;

1
gcc/Makefile.in
View File

@ -1242,6 +1242,7 @@ OBJS = \
gimple-streamer-out.o \
gimple-walk.o \
gimplify.o \
gimplify-me.o \
godump.o \
graph.o \
graphds.o \

1
gcc/asan.c
View File

@ -23,6 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "tree-iterator.h"

16
gcc/c-family/ChangeLog
View File

@ -1,3 +1,9 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* c-common.c: Likewise.
* c-gimplify.c: Likewise.
* cilk.c: Likewise.
2013-11-13 Joseph Myers <joseph@codesourcery.com>
* c-common.h (enum rid): Add RID_AUTO_TYPE.
@ -6,11 +12,11 @@
2013-11-12 Andrew MacLeod <amacleod@redhat.com>
* c-family/c-common.c: Include gimplify.h.
* c-family/c-gimplify.c: Likewise.
* c-family/cilk.c: Likewise.
* c-family/c-omp.c: Include gimple-expr.h instead of gimple.h.
* c-family/c-ubsan.c: Don't include gimple.h.
* c-common.c: Include gimplify.h.
* c-gimplify.c: Likewise.
* cilk.c: Likewise.
* c-omp.c: Include gimple-expr.h instead of gimple.h.
* c-ubsan.c: Don't include gimple.h.
2013-11-12 Joseph Myers <joseph@codesourcery.com>

1
gcc/c-family/c-common.c
View File

@ -42,6 +42,7 @@ along with GCC; see the file COPYING3. If not see
#include "opts.h"
#include "cgraph.h"
#include "target-def.h"
#include "gimple.h"
#include "gimplify.h"
cpp_reader *parse_in; /* Declared in c-pragma.h. */

1
gcc/c-family/c-gimplify.c
View File

@ -29,6 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "tm.h"
#include "tree.h"
#include "c-common.h"
#include "gimple.h"
#include "gimplify.h"
#include "tree-inline.h"
#include "diagnostic-core.h"

1
gcc/c-family/cilk.c
View File

@ -25,6 +25,7 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h"
#include "tree.h"
#include "langhooks.h"
#include "gimple.h"
#include "gimplify.h"
#include "tree-iterator.h"
#include "tree-inline.h"

6
gcc/c/ChangeLog
View File

@ -1,3 +1,7 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* c-typeck.c: Include only gimplify.h and gimple.h as needed.
2013-11-13 Joseph Myers <joseph@codesourcery.com>
* c-tree.h (c_typespec_keyword): Add cts_auto_type.
@ -16,7 +20,7 @@
2013-11-12 Andrew MacLeod <amacleod@redhat.com>
* c/c-typeck.c: Include gimplify.h.
* c-typeck.c: Include gimplify.h.
2013-11-12 Joseph Myers <joseph@codesourcery.com>

1
gcc/c/c-typeck.c
View File

@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "tree-iterator.h"
#include "bitmap.h"
#include "gimple.h"
#include "gimplify.h"
#include "tree-inline.h"
#include "omp-low.h"

3
gcc/cfgloopmanip.c
View File

@ -25,8 +25,9 @@ along with GCC; see the file COPYING3. If not see
#include "basic-block.h"
#include "cfgloop.h"
#include "tree.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "tree-ssa-loop-manip.h"
#include "dumpfile.h"

2
gcc/cgraphunit.c
View File

@ -164,8 +164,10 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "output.h"
#include "rtl.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-into-ssa.h"

1
gcc/cilk-common.c
View File

@ -29,6 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "optabs.h"
#include "recog.h"
#include "tree-iterator.h"
#include "gimple.h"
#include "gimplify.h"
#include "cilk.h"

1
gcc/config/aarch64/aarch64.c
View File

@ -42,6 +42,7 @@
#include "recog.h"
#include "langhooks.h"
#include "diagnostic-core.h"
#include "gimple.h"
#include "gimplify.h"
#include "optabs.h"
#include "dwarf2.h"

1
gcc/config/alpha/alpha.c
View File

@ -48,6 +48,7 @@ along with GCC; see the file COPYING3. If not see
#include "debug.h"
#include "langhooks.h"
#include "splay-tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-ssa.h"
#include "tree-ssanames.h"

1
gcc/config/darwin.c
View File

@ -45,6 +45,7 @@ along with GCC; see the file COPYING3. If not see
#include "df.h"
#include "debug.h"
#include "obstack.h"
#include "gimple.h"
#include "gimplify.h"
#include "lto-streamer.h"

1
gcc/config/i386/i386.c
View File

@ -47,6 +47,7 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "reload.h"
#include "cgraph.h"
#include "gimple.h"
#include "gimplify.h"
#include "dwarf2.h"
#include "df.h"

1
gcc/config/ia64/ia64.c
View File

@ -49,6 +49,7 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "hash-table.h"
#include "langhooks.h"
#include "gimple.h"
#include "gimplify.h"
#include "intl.h"
#include "df.h"

1
gcc/config/mep/mep.c
View File

@ -47,6 +47,7 @@ along with GCC; see the file COPYING3. If not see
#include "target-def.h"
#include "langhooks.h"
#include "df.h"
#include "gimple.h"
#include "gimplify.h"
#include "opts.h"
#include "dumpfile.h"

1
gcc/config/mips/mips.c
View File

@ -50,6 +50,7 @@ along with GCC; see the file COPYING3. If not see
#include "common/common-target.h"
#include "langhooks.h"
#include "sched-int.h"
#include "gimple.h"
#include "gimplify.h"
#include "bitmap.h"
#include "diagnostic.h"

1
gcc/config/rs6000/rs6000.c
View File

@ -51,6 +51,7 @@
#include "reload.h"
#include "cfgloop.h"
#include "sched-int.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-walk.h"

1
gcc/config/s390/s390.c
View File

@ -47,6 +47,7 @@ along with GCC; see the file COPYING3. If not see
#include "debug.h"
#include "langhooks.h"
#include "optabs.h"
#include "gimple.h"
#include "gimplify.h"
#include "df.h"
#include "params.h"

1
gcc/config/sh/sh.c
View File

@ -48,6 +48,7 @@ along with GCC; see the file COPYING3. If not see
#include "sched-int.h"
#include "params.h"
#include "ggc.h"
#include "gimple.h"
#include "gimplify.h"
#include "cfgloop.h"
#include "alloc-pool.h"

1
gcc/config/sparc/sparc.c
View File

@ -46,6 +46,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "target-def.h"
#include "common/common-target.h"
#include "gimple.h"
#include "gimplify.h"
#include "langhooks.h"
#include "reload.h"

1
gcc/config/spu/spu.c
View File

@ -45,6 +45,7 @@
#include "sched-int.h"
#include "params.h"
#include "machmode.h"
#include "gimple.h"
#include "gimplify.h"
#include "tm-constrs.h"
#include "ddg.h"

1
gcc/config/stormy16/stormy16.c
View File

@ -43,6 +43,7 @@
#include "target-def.h"
#include "tm_p.h"
#include "langhooks.h"
#include "gimple.h"
#include "gimplify.h"
#include "df.h"
#include "reload.h"

1
gcc/config/tilegx/tilegx.c
View File

@ -40,6 +40,7 @@
#include "dwarf2.h"
#include "timevar.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "cfgloop.h"
#include "tilegx-builtins.h"

1
gcc/config/tilepro/tilepro.c
View File

@ -41,6 +41,7 @@
#include "dwarf2.h"
#include "timevar.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "cfgloop.h"
#include "tilepro-builtins.h"

1
gcc/config/xtensa/xtensa.c
View File

@ -46,6 +46,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "target-def.h"
#include "langhooks.h"
#include "gimple.h"
#include "gimplify.h"
#include "df.h"

36
gcc/cp/ChangeLog
View File

@ -1,17 +1,29 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* class.c: Include only gimplify.h and gimple.h as needed.
* cp-gimplify.c: Likewise.
* error.c: Likewise.
* init.c: Likewise.
* optimize.c: Likewise.
* pt.c: Likewise.
* semantics.c: Likewise.
* tree.c: Likewise.
* vtable-class-hierarchy.c: Likewise.
2013-11-12 Andrew MacLeod <amacleod@redhat.com>
* cp/class.c: Include gimplify.h.
* cp/cp-gimplify.c: Likewise.
* cp/error.c: Likewise.
* cp/init.c: Likewise.
* cp/optimize.c: Likewise.
* cp/pt.c: Likewise.
* cp/semantics.c: Likewise.
* cp/tree.c: Likewise.
* cp/vtable-class-hierarchy.c: Likewise.
* cp/decl2.c: Don't include gimple.h.
* cp/except.c: Likewise.
* cp/method.c: Include pointer-set.h instead of gimple.h.
* class.c: Include gimplify.h.
* cp-gimplify.c: Likewise.
* error.c: Likewise.
* init.c: Likewise.
* optimize.c: Likewise.
* pt.c: Likewise.
* semantics.c: Likewise.
* tree.c: Likewise.
* vtable-class-hierarchy.c: Likewise.
* decl2.c: Don't include gimple.h.
* except.c: Likewise.
* method.c: Include pointer-set.h instead of gimple.h.
2013-11-12 Adam Butcher <adam@jessamine.co.uk>

1
gcc/cp/class.c
View File

@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see
#include "splay-tree.h"
#include "pointer-set.h"
#include "hash-table.h"
#include "gimple.h"
#include "gimplify.h"
/* The number of nested classes being processed. If we are not in the

1
gcc/cp/cp-gimplify.c
View File

@ -27,6 +27,7 @@ along with GCC; see the file COPYING3. If not see
#include "cp-tree.h"
#include "c-family/c-common.h"
#include "tree-iterator.h"
#include "gimple.h"
#include "gimplify.h"
#include "hashtab.h"
#include "pointer-set.h"

1
gcc/cp/error.c
View File

@ -33,7 +33,6 @@ along with GCC; see the file COPYING3. If not see
#include "pointer-set.h"
#include "c-family/c-objc.h"
#include "ubsan.h"
#include "gimplify.h"
#include <new> // For placement-new.

1
gcc/cp/init.c
View File

@ -28,6 +28,7 @@ along with GCC; see the file COPYING3. If not see
#include "cp-tree.h"
#include "flags.h"
#include "target.h"
#include "gimple.h"
#include "gimplify.h"
static bool begin_init_stmts (tree *, tree *);

2
gcc/cp/optimize.c
View File

@ -34,7 +34,7 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "diagnostic-core.h"
#include "dumpfile.h"
#include "gimplify.h"
#include "gimple.h"
#include "tree-iterator.h"
#include "cgraph.h"

1
gcc/cp/pt.c
View File

@ -42,6 +42,7 @@ along with GCC; see the file COPYING3. If not see
#include "timevar.h"
#include "tree-iterator.h"
#include "type-utils.h"
#include "gimple.h"
#include "gimplify.h"
/* The type of functions taking a tree, and some additional data, and

1
gcc/cp/semantics.c
View File

@ -41,6 +41,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-iterator.h"
#include "vec.h"
#include "target.h"
#include "gimple.h"
#include "gimplify.h"
#include "bitmap.h"
#include "hash-table.h"

1
gcc/cp/tree.c
View File

@ -30,6 +30,7 @@ along with GCC; see the file COPYING3. If not see
#include "convert.h"
#include "cgraph.h"
#include "splay-tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "hash-table.h"

1
gcc/cp/vtable-class-hierarchy.c
View File

@ -118,6 +118,7 @@ along with GCC; see the file COPYING3. If not see
#include "cgraph.h"
#include "tree-iterator.h"
#include "vtable-verify.h"
#include "gimple.h"
#include "gimplify.h"
static int num_calls_to_regset = 0;

1
gcc/fold-const.c
View File

@ -57,6 +57,7 @@ along with GCC; see the file COPYING3. If not see
#include "hash-table.h"
#include "langhooks.h"
#include "md5.h"
#include "gimple.h"
#include "gimplify.h"
#include "tree-dfa.h"

17
gcc/fortran/ChangeLog
View File

@ -1,11 +1,16 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* trans-expr.c: Include only gimplify.h and gimple.h as needed.
* trans-openmp.c: Likewise.
2013-11-12 Andrew MacLeod <amacleod@redhat.com>
* fortran/f95-lang.c: Don't include gimple.h.
* fortran/trans-array.c: Include gimple-expr.h instead of gimple.h.
* fortran/trans.c: Likewise.
* fortran/trans-decl.c: Likewise.
* fortran/trans-expr.c: Include gimplify.h.
* fortran/trans-openmp.c: Likewise.
* f95-lang.c: Don't include gimple.h.
* trans-array.c: Include gimple-expr.h instead of gimple.h.
* trans.c: Likewise.
* trans-decl.c: Likewise.
* trans-expr.c: Include gimplify.h.
* trans-openmp.c: Likewise.
2013-11-07 Janus Weil <janus@gcc.gnu.org>

1
gcc/fortran/trans-expr.c
View File

@ -38,6 +38,7 @@ along with GCC; see the file COPYING3. If not see
/* Only for gfc_trans_assign and gfc_trans_pointer_assign. */
#include "trans-stmt.h"
#include "dependency.h"
#include "gimple.h"
#include "gimplify.h"

1
gcc/fortran/trans-openmp.c
View File

@ -23,6 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h" /* For create_tmp_var_raw. */
#include "diagnostic-core.h" /* For internal_error. */
#include "gfortran.h"

1
gcc/function.c
View File

@ -55,6 +55,7 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "target.h"
#include "common/common-target.h"
#include "gimple.h"
#include "gimplify.h"
#include "tree-pass.h"
#include "predict.h"

1
gcc/gimple-expr.c
View File

@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "demangle.h"
#include "gimple-ssa.h"

1
gcc/gimple-fold.c
View File

@ -27,6 +27,7 @@ along with GCC; see the file COPYING3. If not see
#include "function.h"
#include "dumpfile.h"
#include "bitmap.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-ssa.h"

10
gcc/gimple-iterator.h
View File

@ -35,6 +35,16 @@ typedef struct gimple_stmt_iterator_d
basic_block bb;
} gimple_stmt_iterator;
enum gsi_iterator_update
{
GSI_NEW_STMT, /* Only valid when single statement is added, move
iterator to it. */
GSI_SAME_STMT, /* Leave the iterator at the same statement. */
GSI_CONTINUE_LINKING /* Move iterator to whatever position is suitable
for linking other statements in the same
direction. */
};
extern void gsi_insert_seq_before_without_update (gimple_stmt_iterator *,
gimple_seq,
enum gsi_iterator_update);

3
gcc/gimple-ssa-strength-reduction.c
View File

@ -37,8 +37,9 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "basic-block.h"
#include "tree-pass.h"
#include "cfgloop.h"

1
gcc/gimple.c
View File

@ -31,6 +31,7 @@ along with GCC; see the file COPYING3. If not see
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimple-walk.h"
#include "gimple.h"
#include "gimplify.h"
#include "diagnostic.h"
#include "value-prof.h"

90
gcc/gimple.h
View File

@ -847,85 +847,6 @@ typedef struct gimple_temp_hash_elt
tree temp; /* Value */
} elt_t;
/* Gimplify hashtable helper. */
struct gimplify_hasher : typed_free_remove <elt_t>
{
typedef elt_t value_type;
typedef elt_t compare_type;
static inline hashval_t hash (const value_type *);
static inline bool equal (const value_type *, const compare_type *);
};
inline hashval_t
gimplify_hasher::hash (const value_type *p)
{
tree t = p->val;
return iterative_hash_expr (t, 0);
}
inline bool
gimplify_hasher::equal (const value_type *p1, const compare_type *p2)
{
tree t1 = p1->val;
tree t2 = p2->val;
enum tree_code code = TREE_CODE (t1);
if (TREE_CODE (t2) != code
|| TREE_TYPE (t1) != TREE_TYPE (t2))
return false;
if (!operand_equal_p (t1, t2, 0))
return false;
#ifdef ENABLE_CHECKING
/* Only allow them to compare equal if they also hash equal; otherwise
results are nondeterminate, and we fail bootstrap comparison. */
gcc_assert (hash (p1) == hash (p2));
#endif
return true;
}
struct gimplify_ctx
{
struct gimplify_ctx *prev_context;
vec<gimple> bind_expr_stack;
tree temps;
gimple_seq conditional_cleanups;
tree exit_label;
tree return_temp;
vec<tree> case_labels;
/* The formal temporary table. Should this be persistent? */
hash_table <gimplify_hasher> temp_htab;
int conditions;
bool save_stack;
bool into_ssa;
bool allow_rhs_cond_expr;
bool in_cleanup_point_expr;
};
/* Return true if gimplify_one_sizepos doesn't need to gimplify
expr (when in TYPE_SIZE{,_UNIT} and similar type/decl size/bitsize
fields). */
static inline bool
is_gimple_sizepos (tree expr)
{
/* gimplify_one_sizepos doesn't need to do anything if the value isn't there,
is constant, or contains A PLACEHOLDER_EXPR. We also don't want to do
anything if it's already a VAR_DECL. If it's a VAR_DECL from another
function, the gimplifier will want to replace it with a new variable,
but that will cause problems if this type is from outside the function.
It's OK to have that here. */
return (expr == NULL_TREE
|| TREE_CONSTANT (expr)
|| TREE_CODE (expr) == VAR_DECL
|| CONTAINS_PLACEHOLDER_P (expr));
}
/* Get the number of the next statement uid to be allocated. */
static inline unsigned int
gimple_stmt_max_uid (struct function *fn)
@ -948,7 +869,6 @@ inc_gimple_stmt_max_uid (struct function *fn)
}
/* Miscellaneous helpers. */
struct gimplify_omp_ctx;
extern tree canonicalize_cond_expr_cond (tree);
extern void dump_decl_set (FILE *, bitmap);
extern bool nonfreeing_call_p (gimple);
@ -5202,16 +5122,6 @@ gimple_expr_type (const_gimple stmt)
return void_type_node;
}
enum gsi_iterator_update
{
GSI_NEW_STMT, /* Only valid when single statement is added, move
iterator to it. */
GSI_SAME_STMT, /* Leave the iterator at the same statement. */
GSI_CONTINUE_LINKING /* Move iterator to whatever position is suitable
for linking other statements in the same
direction. */
};
gimple gimple_call_copy_skip_args (gimple, bitmap);
/* Enum and arrays used for allocation stats. Keep in sync with

317
gcc/gimplify-me.c Normal file
View File

@ -0,0 +1,317 @@
/* Tree lowering to gimple for middle end use only.
This converts the GENERIC functions-as-trees tree representation into
the GIMPLE form.
Copyright (C) 2013 Free Software Foundation, Inc.
Major work done by Sebastian Pop <s.pop@laposte.net>,
Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.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/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-ssanames.h"
/* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
the predicate that will hold for the result. If VAR is not NULL, make the
base variable of the final destination be VAR if suitable. */
tree
force_gimple_operand_1 (tree expr, gimple_seq *stmts,
gimple_predicate gimple_test_f, tree var)
{
enum gimplify_status ret;
struct gimplify_ctx gctx;
location_t saved_location;
*stmts = NULL;
/* gimple_test_f might be more strict than is_gimple_val, make
sure we pass both. Just checking gimple_test_f doesn't work
because most gimple predicates do not work recursively. */
if (is_gimple_val (expr)
&& (*gimple_test_f) (expr))
return expr;
push_gimplify_context (&gctx);
gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
gimplify_ctxp->allow_rhs_cond_expr = true;
saved_location = input_location;
input_location = UNKNOWN_LOCATION;
if (var)
{
if (gimplify_ctxp->into_ssa
&& is_gimple_reg (var))
var = make_ssa_name (var, NULL);
expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
}
if (TREE_CODE (expr) != MODIFY_EXPR
&& TREE_TYPE (expr) == void_type_node)
{
gimplify_and_add (expr, stmts);
expr = NULL_TREE;
}
else
{
ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
gcc_assert (ret != GS_ERROR);
}
input_location = saved_location;
pop_gimplify_context (NULL);
return expr;
}
/* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
force the result to be either ssa_name or an invariant, otherwise
just force it to be a rhs expression. If VAR is not NULL, make the
base variable of the final destination be VAR if suitable. */
tree
force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
{
return force_gimple_operand_1 (expr, stmts,
simple ? is_gimple_val : is_gimple_reg_rhs,
var);
}
/* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
and VAR. If some statements are produced, emits them at GSI.
If BEFORE is true. the statements are appended before GSI, otherwise
they are appended after it. M specifies the way GSI moves after
insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
tree
force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
gimple_predicate gimple_test_f,
tree var, bool before,
enum gsi_iterator_update m)
{
gimple_seq stmts;
expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);
if (!gimple_seq_empty_p (stmts))
{
if (before)
gsi_insert_seq_before (gsi, stmts, m);
else
gsi_insert_seq_after (gsi, stmts, m);
}
return expr;
}
/* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
If SIMPLE is true, force the result to be either ssa_name or an invariant,
otherwise just force it to be a rhs expression. If some statements are
produced, emits them at GSI. If BEFORE is true, the statements are
appended before GSI, otherwise they are appended after it. M specifies
the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
are the usual values). */
tree
force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
bool simple_p, tree var, bool before,
enum gsi_iterator_update m)
{
return force_gimple_operand_gsi_1 (gsi, expr,
simple_p
? is_gimple_val : is_gimple_reg_rhs,
var, before, m);
}
/* Some transformations like inlining may invalidate the GIMPLE form
for operands. This function traverses all the operands in STMT and
gimplifies anything that is not a valid gimple operand. Any new
GIMPLE statements are inserted before *GSI_P. */
void
gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
{
size_t i, num_ops;
tree lhs;
gimple_seq pre = NULL;
gimple post_stmt = NULL;
struct gimplify_ctx gctx;
push_gimplify_context (&gctx);
gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
switch (gimple_code (stmt))
{
case GIMPLE_COND:
gimplify_expr (gimple_cond_lhs_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
gimplify_expr (gimple_cond_rhs_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
break;
case GIMPLE_SWITCH:
gimplify_expr (gimple_switch_index_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
break;
case GIMPLE_OMP_ATOMIC_LOAD:
gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
break;
case GIMPLE_ASM:
{
size_t i, noutputs = gimple_asm_noutputs (stmt);
const char *constraint, **oconstraints;
bool allows_mem, allows_reg, is_inout;
oconstraints
= (const char **) alloca ((noutputs) * sizeof (const char *));
for (i = 0; i < noutputs; i++)
{
tree op = gimple_asm_output_op (stmt, i);
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
oconstraints[i] = constraint;
parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
&allows_reg, &is_inout);
gimplify_expr (&TREE_VALUE (op), &pre, NULL,
is_inout ? is_gimple_min_lval : is_gimple_lvalue,
fb_lvalue | fb_mayfail);
}
for (i = 0; i < gimple_asm_ninputs (stmt); i++)
{
tree op = gimple_asm_input_op (stmt, i);
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
parse_input_constraint (&constraint, 0, 0, noutputs, 0,
oconstraints, &allows_mem, &allows_reg);
if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
allows_reg = 0;
if (!allows_reg && allows_mem)
gimplify_expr (&TREE_VALUE (op), &pre, NULL,
is_gimple_lvalue, fb_lvalue | fb_mayfail);
else
gimplify_expr (&TREE_VALUE (op), &pre, NULL,
is_gimple_asm_val, fb_rvalue);
}
}
break;
default:
/* NOTE: We start gimplifying operands from last to first to
make sure that side-effects on the RHS of calls, assignments
and ASMs are executed before the LHS. The ordering is not
important for other statements. */
num_ops = gimple_num_ops (stmt);
for (i = num_ops; i > 0; i--)
{
tree op = gimple_op (stmt, i - 1);
if (op == NULL_TREE)
continue;
if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
else if (i == 2
&& is_gimple_assign (stmt)
&& num_ops == 2
&& get_gimple_rhs_class (gimple_expr_code (stmt))
== GIMPLE_SINGLE_RHS)
gimplify_expr (&op, &pre, NULL,
rhs_predicate_for (gimple_assign_lhs (stmt)),
fb_rvalue);
else if (i == 2 && is_gimple_call (stmt))
{
if (TREE_CODE (op) == FUNCTION_DECL)
continue;
gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
}
else
gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
gimple_set_op (stmt, i - 1, op);
}
lhs = gimple_get_lhs (stmt);
/* If the LHS changed it in a way that requires a simple RHS,
create temporary. */
if (lhs && !is_gimple_reg (lhs))
{
bool need_temp = false;
if (is_gimple_assign (stmt)
&& num_ops == 2
&& get_gimple_rhs_class (gimple_expr_code (stmt))
== GIMPLE_SINGLE_RHS)
gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
rhs_predicate_for (gimple_assign_lhs (stmt)),
fb_rvalue);
else if (is_gimple_reg (lhs))
{
if (is_gimple_reg_type (TREE_TYPE (lhs)))
{
if (is_gimple_call (stmt))
{
i = gimple_call_flags (stmt);
if ((i & ECF_LOOPING_CONST_OR_PURE)
|| !(i & (ECF_CONST | ECF_PURE)))
need_temp = true;
}
if (stmt_can_throw_internal (stmt))
need_temp = true;
}
}
else
{
if (is_gimple_reg_type (TREE_TYPE (lhs)))
need_temp = true;
else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
{
if (is_gimple_call (stmt))
{
tree fndecl = gimple_call_fndecl (stmt);
if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
&& !(fndecl && DECL_RESULT (fndecl)
&& DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
need_temp = true;
}
else
need_temp = true;
}
}
if (need_temp)
{
tree temp = create_tmp_reg (TREE_TYPE (lhs), NULL);
if (gimple_in_ssa_p (cfun))
temp = make_ssa_name (temp, NULL);
gimple_set_lhs (stmt, temp);
post_stmt = gimple_build_assign (lhs, temp);
}
}
break;
}
if (!gimple_seq_empty_p (pre))
gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
if (post_stmt)
gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
pop_gimplify_context (NULL);
}

37
gcc/gimplify-me.h Normal file
View File

@ -0,0 +1,37 @@
/* Header file for middle end gimplification.
Copyright (C) 2013 Free Software Foundation, Inc.
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_GIMPLIFY_ME_H
#define GCC_GIMPLIFY_ME_H
/* Validation of GIMPLE expressions. Note that these predicates only check
* the basic form of the expression, they don't recurse to make sure that
* underlying nodes are also of the right form. */
typedef bool (*gimple_predicate)(tree);
extern tree force_gimple_operand_1 (tree, gimple_seq *, gimple_predicate, tree);
extern tree force_gimple_operand (tree, gimple_seq *, bool, tree);
extern tree force_gimple_operand_gsi_1 (gimple_stmt_iterator *, tree,
gimple_predicate, tree,
bool, enum gsi_iterator_update);
extern tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree,
bool, enum gsi_iterator_update);
extern void gimple_regimplify_operands (gimple, gimple_stmt_iterator *);
#endif /* GCC_GIMPLIFY_ME_H */

325
gcc/gimplify.c
View File

@ -23,8 +23,8 @@ along with GCC; see the file COPYING3. If not see
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "tree-iterator.h"
@ -37,24 +37,15 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfg.h"
#include "tree-ssanames.h"
#include "tree-ssa.h"
#include "timevar.h"
#include "hashtab.h"
#include "flags.h"
#include "function.h"
#include "ggc.h"
#include "diagnostic-core.h"
#include "target.h"
#include "pointer-set.h"
#include "splay-tree.h"
#include "vec.h"
#include "omp-low.h"
#include "gimple-low.h"
#include "cilk.h"
#include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
#include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
#include "expr.h"
#include "tm_p.h"
enum gimplify_omp_var_data
{
@ -102,7 +93,7 @@ struct gimplify_omp_ctx
bool combined_loop;
};
static struct gimplify_ctx *gimplify_ctxp;
struct gimplify_ctx *gimplify_ctxp;
static struct gimplify_omp_ctx *gimplify_omp_ctxp;
@ -3393,7 +3384,7 @@ gimplify_init_ctor_eval (tree object, vec<constructor_elt, va_gc> *elts,
/* Return the appropriate RHS predicate for this LHS. */
static gimple_predicate
gimple_predicate
rhs_predicate_for (tree lhs)
{
if (is_gimple_reg (lhs))
@ -8590,287 +8581,6 @@ gimplify_function_tree (tree fndecl)
pop_cfun ();
}
/* Some transformations like inlining may invalidate the GIMPLE form
for operands. This function traverses all the operands in STMT and
gimplifies anything that is not a valid gimple operand. Any new
GIMPLE statements are inserted before *GSI_P. */
void
gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
{
size_t i, num_ops;
tree lhs;
gimple_seq pre = NULL;
gimple post_stmt = NULL;
struct gimplify_ctx gctx;
push_gimplify_context (&gctx);
gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
switch (gimple_code (stmt))
{
case GIMPLE_COND:
gimplify_expr (gimple_cond_lhs_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
gimplify_expr (gimple_cond_rhs_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
break;
case GIMPLE_SWITCH:
gimplify_expr (gimple_switch_index_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
break;
case GIMPLE_OMP_ATOMIC_LOAD:
gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt), &pre, NULL,
is_gimple_val, fb_rvalue);
break;
case GIMPLE_ASM:
{
size_t i, noutputs = gimple_asm_noutputs (stmt);
const char *constraint, **oconstraints;
bool allows_mem, allows_reg, is_inout;
oconstraints
= (const char **) alloca ((noutputs) * sizeof (const char *));
for (i = 0; i < noutputs; i++)
{
tree op = gimple_asm_output_op (stmt, i);
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
oconstraints[i] = constraint;
parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
&allows_reg, &is_inout);
gimplify_expr (&TREE_VALUE (op), &pre, NULL,
is_inout ? is_gimple_min_lval : is_gimple_lvalue,
fb_lvalue | fb_mayfail);
}
for (i = 0; i < gimple_asm_ninputs (stmt); i++)
{
tree op = gimple_asm_input_op (stmt, i);
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
parse_input_constraint (&constraint, 0, 0, noutputs, 0,
oconstraints, &allows_mem, &allows_reg);
if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
allows_reg = 0;
if (!allows_reg && allows_mem)
gimplify_expr (&TREE_VALUE (op), &pre, NULL,
is_gimple_lvalue, fb_lvalue | fb_mayfail);
else
gimplify_expr (&TREE_VALUE (op), &pre, NULL,
is_gimple_asm_val, fb_rvalue);
}
}
break;
default:
/* NOTE: We start gimplifying operands from last to first to
make sure that side-effects on the RHS of calls, assignments
and ASMs are executed before the LHS. The ordering is not
important for other statements. */
num_ops = gimple_num_ops (stmt);
for (i = num_ops; i > 0; i--)
{
tree op = gimple_op (stmt, i - 1);
if (op == NULL_TREE)
continue;
if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
else if (i == 2
&& is_gimple_assign (stmt)
&& num_ops == 2
&& get_gimple_rhs_class (gimple_expr_code (stmt))
== GIMPLE_SINGLE_RHS)
gimplify_expr (&op, &pre, NULL,
rhs_predicate_for (gimple_assign_lhs (stmt)),
fb_rvalue);
else if (i == 2 && is_gimple_call (stmt))
{
if (TREE_CODE (op) == FUNCTION_DECL)
continue;
gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
}
else
gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
gimple_set_op (stmt, i - 1, op);
}
lhs = gimple_get_lhs (stmt);
/* If the LHS changed it in a way that requires a simple RHS,
create temporary. */
if (lhs && !is_gimple_reg (lhs))
{
bool need_temp = false;
if (is_gimple_assign (stmt)
&& num_ops == 2
&& get_gimple_rhs_class (gimple_expr_code (stmt))
== GIMPLE_SINGLE_RHS)
gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
rhs_predicate_for (gimple_assign_lhs (stmt)),
fb_rvalue);
else if (is_gimple_reg (lhs))
{
if (is_gimple_reg_type (TREE_TYPE (lhs)))
{
if (is_gimple_call (stmt))
{
i = gimple_call_flags (stmt);
if ((i & ECF_LOOPING_CONST_OR_PURE)
|| !(i & (ECF_CONST | ECF_PURE)))
need_temp = true;
}
if (stmt_can_throw_internal (stmt))
need_temp = true;
}
}
else
{
if (is_gimple_reg_type (TREE_TYPE (lhs)))
need_temp = true;
else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
{
if (is_gimple_call (stmt))
{
tree fndecl = gimple_call_fndecl (stmt);
if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
&& !(fndecl && DECL_RESULT (fndecl)
&& DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
need_temp = true;
}
else
need_temp = true;
}
}
if (need_temp)
{
tree temp = create_tmp_reg (TREE_TYPE (lhs), NULL);
if (gimple_in_ssa_p (cfun))
temp = make_ssa_name (temp, NULL);
gimple_set_lhs (stmt, temp);
post_stmt = gimple_build_assign (lhs, temp);
}
}
break;
}
if (!gimple_seq_empty_p (pre))
gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
if (post_stmt)
gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
pop_gimplify_context (NULL);
}
/* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
the predicate that will hold for the result. If VAR is not NULL, make the
base variable of the final destination be VAR if suitable. */
tree
force_gimple_operand_1 (tree expr, gimple_seq *stmts,
gimple_predicate gimple_test_f, tree var)
{
enum gimplify_status ret;
struct gimplify_ctx gctx;
location_t saved_location;
*stmts = NULL;
/* gimple_test_f might be more strict than is_gimple_val, make
sure we pass both. Just checking gimple_test_f doesn't work
because most gimple predicates do not work recursively. */
if (is_gimple_val (expr)
&& (*gimple_test_f) (expr))
return expr;
push_gimplify_context (&gctx);
gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
gimplify_ctxp->allow_rhs_cond_expr = true;
saved_location = input_location;
input_location = UNKNOWN_LOCATION;
if (var)
{
if (gimplify_ctxp->into_ssa
&& is_gimple_reg (var))
var = make_ssa_name (var, NULL);
expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
}
if (TREE_CODE (expr) != MODIFY_EXPR
&& TREE_TYPE (expr) == void_type_node)
{
gimplify_and_add (expr, stmts);
expr = NULL_TREE;
}
else
{
ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
gcc_assert (ret != GS_ERROR);
}
input_location = saved_location;
pop_gimplify_context (NULL);
return expr;
}
/* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
force the result to be either ssa_name or an invariant, otherwise
just force it to be a rhs expression. If VAR is not NULL, make the
base variable of the final destination be VAR if suitable. */
tree
force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
{
return force_gimple_operand_1 (expr, stmts,
simple ? is_gimple_val : is_gimple_reg_rhs,
var);
}
/* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
and VAR. If some statements are produced, emits them at GSI.
If BEFORE is true. the statements are appended before GSI, otherwise
they are appended after it. M specifies the way GSI moves after
insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
tree
force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
gimple_predicate gimple_test_f,
tree var, bool before,
enum gsi_iterator_update m)
{
gimple_seq stmts;
expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);
if (!gimple_seq_empty_p (stmts))
{
if (before)
gsi_insert_seq_before (gsi, stmts, m);
else
gsi_insert_seq_after (gsi, stmts, m);
}
return expr;
}
/* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
If SIMPLE is true, force the result to be either ssa_name or an invariant,
otherwise just force it to be a rhs expression. If some statements are
produced, emits them at GSI. If BEFORE is true, the statements are
appended before GSI, otherwise they are appended after it. M specifies
the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
are the usual values). */
tree
force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
bool simple_p, tree var, bool before,
enum gsi_iterator_update m)
{
return force_gimple_operand_gsi_1 (gsi, expr,
simple_p
? is_gimple_val : is_gimple_reg_rhs,
var, before, m);
}
/* Return a dummy expression of type TYPE in order to keep going after an
error. */
@ -8991,3 +8701,32 @@ gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
return gimple_seq_last_stmt (*seq_p);
}
inline hashval_t
gimplify_hasher::hash (const value_type *p)
{
tree t = p->val;
return iterative_hash_expr (t, 0);
}
inline bool
gimplify_hasher::equal (const value_type *p1, const compare_type *p2)
{
tree t1 = p1->val;
tree t2 = p2->val;
enum tree_code code = TREE_CODE (t1);
if (TREE_CODE (t2) != code
|| TREE_TYPE (t1) != TREE_TYPE (t2))
return false;
if (!operand_equal_p (t1, t2, 0))
return false;
#ifdef ENABLE_CHECKING
/* Only allow them to compare equal if they also hash equal; otherwise
results are nondeterminate, and we fail bootstrap comparison. */
gcc_assert (hash (p1) == hash (p2));
#endif
return true;
}

62
gcc/gimplify.h
View File

@ -20,8 +20,6 @@ along with GCC; see the file COPYING3. If not see
#ifndef GCC_GIMPLIFY_H
#define GCC_GIMPLIFY_H
#include "gimple.h"
/* Validation of GIMPLE expressions. Note that these predicates only check
the basic form of the expression, they don't recurse to make sure that
underlying nodes are also of the right form. */
@ -50,7 +48,38 @@ enum gimplify_status {
GS_OK = 0, /* We did something, maybe more to do. */
GS_ALL_DONE = 1 /* The expression is fully gimplified. */
};
/* Gimplify hashtable helper. */
struct gimplify_hasher : typed_free_remove <elt_t>
{
typedef elt_t value_type;
typedef elt_t compare_type;
static inline hashval_t hash (const value_type *);
static inline bool equal (const value_type *, const compare_type *);
};
struct gimplify_ctx
{
struct gimplify_ctx *prev_context;
vec<gimple> bind_expr_stack;
tree temps;
gimple_seq conditional_cleanups;
tree exit_label;
tree return_temp;
vec<tree> case_labels;
/* The formal temporary table. Should this be persistent? */
hash_table <gimplify_hasher> temp_htab;
int conditions;
bool save_stack;
bool into_ssa;
bool allow_rhs_cond_expr;
bool in_cleanup_point_expr;
};
extern struct gimplify_ctx *gimplify_ctxp;
extern void push_gimplify_context (struct gimplify_ctx *);
extern void pop_gimplify_context (gimple);
extern gimple gimple_current_bind_expr (void);
@ -67,6 +96,7 @@ extern tree build_and_jump (tree *);
extern enum gimplify_status gimplify_self_mod_expr (tree *, gimple_seq *,
gimple_seq *, bool, tree);
extern tree gimple_boolify (tree);
extern gimple_predicate rhs_predicate_for (tree);
extern bool gimplify_stmt (tree *, gimple_seq *);
extern void omp_firstprivatize_variable (struct gimplify_omp_ctx *, tree);
extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
@ -76,17 +106,27 @@ extern void gimplify_type_sizes (tree, gimple_seq *);
extern void gimplify_one_sizepos (tree *, gimple_seq *);
extern gimple gimplify_body (tree, bool);
extern void gimplify_function_tree (tree);
extern void gimple_regimplify_operands (gimple, gimple_stmt_iterator *);
extern tree force_gimple_operand_1 (tree, gimple_seq *, gimple_predicate, tree);
extern tree force_gimple_operand (tree, gimple_seq *, bool, tree);
extern tree force_gimple_operand_gsi_1 (gimple_stmt_iterator *, tree,
gimple_predicate, tree,
bool, enum gsi_iterator_update);
extern tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree,
bool, enum gsi_iterator_update);
extern enum gimplify_status gimplify_va_arg_expr (tree *, gimple_seq *,
gimple_seq *);
gimple gimplify_assign (tree, tree, gimple_seq *);
/* Return true if gimplify_one_sizepos doesn't need to gimplify
expr (when in TYPE_SIZE{,_UNIT} and similar type/decl size/bitsize
fields). */
static inline bool
is_gimple_sizepos (tree expr)
{
/* gimplify_one_sizepos doesn't need to do anything if the value isn't there,
is constant, or contains A PLACEHOLDER_EXPR. We also don't want to do
anything if it's already a VAR_DECL. If it's a VAR_DECL from another
function, the gimplifier will want to replace it with a new variable,
but that will cause problems if this type is from outside the function.
It's OK to have that here. */
return (expr == NULL_TREE
|| TREE_CONSTANT (expr)
|| TREE_CODE (expr) == VAR_DECL
|| CONTAINS_PLACEHOLDER_P (expr));
}
#endif /* GCC_GIMPLIFY_H */

6
gcc/go/ChangeLog
View File

@ -1,6 +1,10 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* go-lang.c: Include only gimplify.h and gimple.h as needed.
2013-11-12 Andrew MacLeod <amacleod@redhat.com>
* go/go-lang.c: Include gimplify.h.
* go-lang.c: Include gimplify.h.
2013-11-06 Ian Lance Taylor <iant@google.com>

1
gcc/go/go-lang.c
View File

@ -23,6 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h"
#include "opts.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "ggc.h"
#include "toplev.h"

3
gcc/graphite-clast-to-gimple.c
View File

@ -36,8 +36,9 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tree.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-ssa-loop-manip.h"
#include "tree-ssa-loop.h"

4
gcc/graphite-sese-to-poly.c
View File

@ -34,8 +34,10 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

2
gcc/ipa-prop.c
View File

@ -21,8 +21,10 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "langhooks.h"
#include "ggc.h"

2
gcc/ipa-split.c
View File

@ -78,8 +78,10 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "target.h"
#include "ipa-prop.h"

1
gcc/ipa.c
View File

@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "cgraph.h"
#include "tree-pass.h"
#include "gimple.h"
#include "gimplify.h"
#include "ggc.h"
#include "flags.h"

6
gcc/java/ChangeLog
View File

@ -1,6 +1,10 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* java-gimplify.c: Include only gimplify.h and gimple.h as needed.
2013-11-12 Andrew MacLeod <amacleod@redhat.com>
* java/java-gimplify.c: Include gimplify.h.
* java-gimplify.c: Include gimplify.h.
2013-11-07 Jeff Law <law@redhat.com>

1
gcc/java/java-gimplify.c
View File

@ -27,6 +27,7 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */
#include "tree.h"
#include "java-tree.h"
#include "dumpfile.h"
#include "gimple.h"
#include "gimplify.h"
static tree java_gimplify_block (tree);

1
gcc/langhooks.c
View File

@ -26,6 +26,7 @@ along with GCC; see the file COPYING3. If not see
#include "toplev.h"
#include "tree.h"
#include "tree-inline.h"
#include "gimple.h"
#include "gimplify.h"
#include "rtl.h"
#include "insn-config.h"

6
gcc/objc/ChangeLog
View File

@ -1,6 +1,10 @@
2013-11-14 Andrew MacLeod <amacleod@redhat.com>
* objc-act.c: Include only gimplify.h and gimple.h as needed.
2013-11-12 Andrew MacLeod <amacleod@redhat.com>
* objc/objc-act.c: Include gimplify.h.
* objc-act.c: Include gimplify.h.
2013-11-07 Andrew MacLeod <amacleod@redhat.com>

1
gcc/objc/objc-act.c
View File

@ -60,6 +60,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pretty-print.h"
/* For enum gimplify_status */
#include "gimple.h"
#include "gimplify.h"
/* For encode_method_prototype(). */

2
gcc/omp-low.c
View File

@ -27,8 +27,10 @@ along with GCC; see the file COPYING3. If not see
#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "tree-iterator.h"
#include "tree-inline.h"

2
gcc/sese.c
View File

@ -25,8 +25,10 @@ along with GCC; see the file COPYING3. If not see
#include "hash-table.h"
#include "tree.h"
#include "tree-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

1
gcc/stor-layout.c
View File

@ -37,6 +37,7 @@ along with GCC; see the file COPYING3. If not see
#include "cgraph.h"
#include "tree-inline.h"
#include "tree-dump.h"
#include "gimple.h"
#include "gimplify.h"
/* Data type for the expressions representing sizes of data types.

1
gcc/targhooks.c
View File

@ -68,6 +68,7 @@ along with GCC; see the file COPYING3. If not see
#include "recog.h"
#include "intl.h"
#include "opts.h"
#include "gimple.h"
#include "gimplify.h"
#include "tree-ssanames.h"
#include "tree-ssa-alias.h"

2
gcc/trans-mem.c
View File

@ -22,8 +22,10 @@
#include "coretypes.h"
#include "hash-table.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "gimple-ssa.h"
#include "cgraph.h"

1
gcc/tree-affine.c
View File

@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pretty-print.h"
#include "pointer-set.h"
#include "tree-affine.h"
#include "gimple.h"
#include "gimplify.h"
#include "flags.h"
#include "dumpfile.h"

3
gcc/tree-cfg.c
View File

@ -30,8 +30,9 @@ along with GCC; see the file COPYING3. If not see
#include "function.h"
#include "ggc.h"
#include "gimple-pretty-print.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "gimple-ssa.h"
#include "cgraph.h"

1
gcc/tree-cfgcleanup.c
View File

@ -29,6 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "function.h"
#include "ggc.h"
#include "langhooks.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-ssa.h"

2
gcc/tree-complex.c
View File

@ -23,8 +23,10 @@ along with GCC; see the file COPYING3. If not see
#include "tm.h"
#include "tree.h"
#include "flags.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

2
gcc/tree-if-conv.c
View File

@ -88,8 +88,10 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

2
gcc/tree-inline.c
View File

@ -34,8 +34,10 @@ along with GCC; see the file COPYING3. If not see
#include "basic-block.h"
#include "tree-iterator.h"
#include "intl.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"

3
gcc/tree-loop-distribution.c
View File

@ -45,8 +45,9 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

1
gcc/tree-nested.c
View File

@ -26,6 +26,7 @@
#include "function.h"
#include "tree-dump.h"
#include "tree-inline.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-walk.h"

2
gcc/tree-parloops.c
View File

@ -23,8 +23,10 @@ along with GCC; see the file COPYING3. If not see
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"

2
gcc/tree-predcom.c
View File

@ -191,8 +191,10 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "tm_p.h"
#include "cfgloop.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-phinodes.h"
#include "ssa-iterators.h"

2
gcc/tree-profile.c
View File

@ -34,8 +34,10 @@ along with GCC; see the file COPYING3. If not see
#include "diagnostic-core.h"
#include "coverage.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "cgraph.h"
#include "tree-cfg.h"

2
gcc/tree-scalar-evolution.c
View File

@ -259,8 +259,10 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "hash-table.h"
#include "gimple-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

2
gcc/tree-sra.c
View File

@ -78,8 +78,10 @@ along with GCC; see the file COPYING3. If not see
#include "alloc-pool.h"
#include "tm.h"
#include "tree.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-walk.h"
#include "bitmap.h"
#include "gimple-ssa.h"

4
gcc/tree-ssa-address.c
View File

@ -28,7 +28,9 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "basic-block.h"
#include "tree-pretty-print.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "tree-ssanames.h"
#include "tree-ssa-loop-ivopts.h"
#include "tree-dfa.h"

1
gcc/tree-ssa-ccp.c
View File

@ -119,6 +119,7 @@ along with GCC; see the file COPYING3. If not see
#include "basic-block.h"
#include "function.h"
#include "gimple-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-ssa.h"

1
gcc/tree-ssa-dce.c
View File

@ -50,6 +50,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "gimple-pretty-print.h"
#include "basic-block.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-ssa.h"

2
gcc/tree-ssa-forwprop.c
View File

@ -25,8 +25,10 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

3
gcc/tree-ssa-ifcombine.c
View File

@ -29,8 +29,9 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "basic-block.h"
#include "tree-pretty-print.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

2
gcc/tree-ssa-loop-im.c
View File

@ -25,8 +25,10 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

2
gcc/tree-ssa-loop-ivopts.c
View File

@ -69,8 +69,10 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "cgraph.h"
#include "tree-cfg.h"

2
gcc/tree-ssa-loop-manip.c
View File

@ -24,8 +24,10 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "tm_p.h"
#include "basic-block.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

1
gcc/tree-ssa-loop-niter.c
View File

@ -26,6 +26,7 @@ along with GCC; see the file COPYING3. If not see
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "intl.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-ssa.h"

2
gcc/tree-ssa-loop-prefetch.c
View File

@ -25,8 +25,10 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "basic-block.h"
#include "tree-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-ssa-loop-ivopts.h"
#include "tree-ssa-loop-manip.h"

1
gcc/tree-ssa-loop-unswitch.c
View File

@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "tm_p.h"
#include "basic-block.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"

3
gcc/tree-ssa-math-opts.c
View File

@ -90,8 +90,9 @@ along with GCC; see the file COPYING3. If not see
#include "tm.h"
#include "flags.h"
#include "tree.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

2
gcc/tree-ssa-phiopt.c
View File

@ -27,8 +27,10 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "tm_p.h"
#include "basic-block.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

1
gcc/tree-ssa-phiprop.c
View File

@ -26,6 +26,7 @@ along with GCC; see the file COPYING3. If not see
#include "tm_p.h"
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-ssa.h"

2
gcc/tree-ssa-pre.c
View File

@ -27,8 +27,10 @@ along with GCC; see the file COPYING3. If not see
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "tree-inline.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

1
gcc/tree-ssa-propagate.c
View File

@ -30,6 +30,7 @@
#include "gimple-pretty-print.h"
#include "dumpfile.h"
#include "sbitmap.h"
#include "gimple.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "gimple-ssa.h"

3
gcc/tree-ssa-reassoc.c
View File

@ -29,8 +29,9 @@ along with GCC; see the file COPYING3. If not see
#include "basic-block.h"
#include "gimple-pretty-print.h"
#include "tree-inline.h"
#include "gimplify.h"
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimplify-me.h"
#include "gimple-ssa.h"
#include "tree-cfg.h"
#include "tree-phinodes.h"

Some files were not shown because too many files have changed in this diff Show More