This is the mail archive of the
gcc@gcc.gnu.org
mailing list for the GCC project.
[PATCH] Add gimple-compat.h (was Re: [gimple-classes, committed 4/6] tree-ssa-tail-merge.c: Use gassign)
- From: David Malcolm <dmalcolm at redhat dot com>
- To: Richard Biener <richard dot guenther at gmail dot com>
- Cc: Jakub Jelinek <jakub at redhat dot com>, GCC Patches <gcc-patches at gcc dot gnu dot org>, GCC Development <gcc at gcc dot gnu dot org>, Jeff Law <law at redhat dot com>
- Date: Fri, 14 Nov 2014 10:27:52 -0500
- Subject: [PATCH] Add gimple-compat.h (was Re: [gimple-classes, committed 4/6] tree-ssa-tail-merge.c: Use gassign)
- Authentication-results: sourceware.org; auth=none
- References: <1415373690-26193-1-git-send-email-dmalcolm at redhat dot com> <1415373690-26193-5-git-send-email-dmalcolm at redhat dot com> <CAFiYyc2rg+T5d7rkTBPLeWKGnWMgv07j_N8KaFfr0NK1CjsfVQ at mail dot gmail dot com> <CAFiYyc2Y4uWt3Ec-D=c+LmKyBb1s0UPkP=8sSr1+5_nb7NruyA at mail dot gmail dot com> <20141108135646 dot GU5026 at tucnak dot redhat dot com> <1415658470 dot 2209 dot 20 dot camel at surprise> <20141111072614 dot GW5026 at tucnak dot redhat dot com> <CAFiYyc1jfx05qxvsCGqbdDL=ouH0hMp2A1ufandUbb-EfUAukg at mail dot gmail dot com> <1415842862 dot 2209 dot 101 dot camel at surprise> <CAFiYyc0H958TKBOb7F20hg8++YnOQYeMcQEZ2Ba+Q0F6hobeKw at mail dot gmail dot com>
On Thu, 2014-11-13 at 11:45 +0100, Richard Biener wrote:
> On Thu, Nov 13, 2014 at 2:41 AM, David Malcolm <dmalcolm@redhat.com> wrote:
> > On Tue, 2014-11-11 at 11:43 +0100, Richard Biener wrote:
> >> On Tue, Nov 11, 2014 at 8:26 AM, Jakub Jelinek <jakub@redhat.com> wrote:
> >> > On Mon, Nov 10, 2014 at 05:27:50PM -0500, David Malcolm wrote:
> >> >> On Sat, 2014-11-08 at 14:56 +0100, Jakub Jelinek wrote:
> >> >> > On Sat, Nov 08, 2014 at 01:07:28PM +0100, Richard Biener wrote:
> >> >> > > To be constructive here - the above case is from within a
> >> >> > > GIMPLE_ASSIGN case label
> >> >> > > and thus I'd have expected
> >> >> > >
> >> >> > > case GIMPLE_ASSIGN:
> >> >> > > {
> >> >> > > gassign *a1 = as_a <gassign *> (s1);
> >> >> > > gassign *a2 = as_a <gassign *> (s2);
> >> >> > > lhs1 = gimple_assign_lhs (a1);
> >> >> > > lhs2 = gimple_assign_lhs (a2);
> >> >> > > if (TREE_CODE (lhs1) != SSA_NAME
> >> >> > > && TREE_CODE (lhs2) != SSA_NAME)
> >> >> > > return (operand_equal_p (lhs1, lhs2, 0)
> >> >> > > && gimple_operand_equal_value_p (gimple_assign_rhs1 (a1),
> >> >> > > gimple_assign_rhs1 (a2)));
> >> >> > > else if (TREE_CODE (lhs1) == SSA_NAME
> >> >> > > && TREE_CODE (lhs2) == SSA_NAME)
> >> >> > > return vn_valueize (lhs1) == vn_valueize (lhs2);
> >> >> > > return false;
> >> >> > > }
> >> >> > >
> >> >> > > instead. That's the kind of changes I have expected and have approved of.
> >> >> >
> >> >> > But even that looks like just adding extra work for all developers, with no
> >> >> > gain. You only have to add extra code and extra temporaries, in switches
> >> >> > typically also have to add {} because of the temporaries and thus extra
> >> >> > indentation level, and it doesn't simplify anything in the code.
> >> >>
> >> >> The branch attempts to use the C++ typesystem to capture information
> >> >> about the kinds of gimple statement we expect, both:
> >> >> (A) so that the compiler can detect type errors, and
> >> >> (B) as a comprehension aid to the human reader of the code
> >> >>
> >> >> The ideal here is when function params and struct field can be
> >> >> strengthened from "gimple" to a subclass ptr. This captures the
> >> >> knowledge that every use of a function or within a struct has a given
> >> >> gimple code.
> >> >
> >> > I just don't like all the as_a/is_a stuff enforced everywhere,
> >> > it means more typing, more temporaries, more indentation.
> >> > So, as I view it, instead of the checks being done cheaply (yes, I think
> >> > the gimple checking as we have right now is very cheap) under the
> >> > hood by the accessors (gimple_assign_{lhs,rhs1} etc.), those changes
> >> > put the burden on the developers, who has to check that manually through
> >> > the as_a/is_a stuff everywhere, more typing and uglier syntax.
> >> > I just don't see that as a step forward, instead a huge step backwards.
> >> > But perhaps I'm alone with this.
> >> > Can you e.g. compare the size of - lines in your patchset combined, and
> >> > size of + lines in your patchset? As in, if your changes lead to less
> >> > typing or more.
> >>
> >> I see two ways out here. One is to add overloads to all the functions
> >> taking the special types like
> >>
> >> tree
> >> gimple_assign_rhs1 (gimple *);
> >>
> >> or simply add
> >>
> >> gassign *operator ()(gimple *g) { return as_a <gassign *> (g); }
> >>
> >> into a gimple-compat.h header which you include in places that
> >> are not converted "nicely".
> >
> > Thanks for the suggestions.
> >
> > Am I missing something, or is the gimple-compat.h idea above not valid C
> > ++?
> >
> > Note that "gimple" is still a typedef to
> > gimple_statement_base *
> > (as noted before, the gimple -> gimple * change would break everyone
> > else's patches, so we talked about that as a followup patch for early
> > stage3).
> >
> > Given that, if I try to create an "operator ()" outside of a class, I
> > get this error:
> >
> > âgassign* operator()(gimple)â must be a nonstatic member function
> >
> > which is emitted from cp/decl.c's grok_op_properties:
> > /* An operator function must either be a non-static member function
> > or have at least one parameter of a class, a reference to a class,
> > an enumeration, or a reference to an enumeration. 13.4.0.6 */
> >
> > I tried making it a member function of gimple_statement_base, but that
> > doesn't work either: we want a conversion
> > from a gimple_statement_base * to a gassign *, not
> > from a gimple_statement_base to a gassign *.
> >
> > Is there some syntactic trick here that I'm missing? Sorry if I'm being
> > dumb (I can imagine there's a way of doing it by making "gimple" become
> > some kind of wrapped ptr class, but that way lies madness, surely).
>
> Hmm.
>
> struct assign;
> struct base {
> operator assign *() const { return (assign *)this; }
> };
> struct assign : base {
> };
>
> void foo (assign *);
> void bar (base *b)
> {
> foo (b);
> }
>
> doesn't work, but
>
> void bar (base &b)
> {
> foo (b);
> }
>
> does. Indeed C++ doesn't seem to provide what is necessary
> for the compat trick :(
>
> So the gimple-compat.h header would need to provide
> additional overloads for the affected functions like
>
> inline tree
> gimple_assign_rhs1 (gimple *g)
> {
> return gimple_assign_rhs1 (as_a <gassign *> (g));
> }
>
> that would work for me as well.
>
> >> Both avoid manually making the compiler happy (which the
> >> explicit as_a<> stuff is! It doesn't add any "checking" - it's
> >> just placing the as_a<> at the callers and thus make the
> >> runtine ICE fire there).
> >>
> >> As much as I don't like "global" conversion operators I don't
> >> like adding overloads to all of the accessor functions even more.
> >
> > (nods)
> >
> > Some other options:
> >
> > Option 3: only convert the "easy" accessors: the ones I already did in
> > the /89 patch kit, as reviewed by Jeff, and rebased by me recently,
> > which is this 92-patch kit:
> > "[gimple-classes, committed 00/92] Initial slew of commits":
> > https://gcc.gnu.org/ml/gcc-patches/2014-10/msg02791.html
> > Doing so converts about half of the gimple_foo_ accessors to taking a
> > gfoo *, giving a mixture of GIMPLE_CHECK vs subclass use. I believe
> > the quality of those patches was higher than the later ones on the
> > branch: I was doing the places that didn't require the invasive/verbose
> > changes seen in the later patches. Shelve the remaining ~80
> > increasingly ugly patches, starting a new branch to contain just the
> > good ones.
> >
> >
> > Option 4: don't convert any accessors, but instead focus on fields of
> > structs (e.g. "call_stmt" within a cgraph_edge), and on params of other
> > functions (e.g. phi-manipulation code). That way we'd avoid the
> > inconsistency of some accessors using GIMPLE_CHECK and some using
> > subclasses - all would continue to consistently use GIMPLE_CHECK, but
> > there would be some extra type-checking and self-documentation of the
> > expected statement kinds in the code.
> >
> >
> >
> > FWIW, option 3 is my preferred approach (I've already done the bulk of
> > the work and it's already been reviewed; it would need an update merger
> > from trunk, and there's the big gimple to gimple * fixup you wanted).
>
> Works for me as well. The compat solution looks somewhat appealing
> as we can then incrementally fix up things rather than requiring to
> mass-convert everything.
>
> Thanks,
> Richard.
I still prefer option 3 above (i.e. go with the patches Jeff reviewed,
with the fixups discussed earlier, with a merger from trunk), but I had
a go at implementing your gimple-compat.h idea.
Attached is a patch against e74b2ecd78d21fc7bcc2f50dacc92819e0e69e6b on
the gimple-classes branch (the last commit before I went overboard with
the as_a changes), which converts the remaining gimple_assign_ accessors
to take a gassign *, adding a gimple-compat.h to provide overloaded
accessors taking just a gimple for those source files that needed them.
It also strengthens some places I spotted where converting params,
locals or fields from gimple to gassign * was simple and obvious.
Successfully bootstrapped®rtested on x86_64-unknown-linux-gnu,
comparing the branch+patch against master r216746 (2014-10-27).
This only covers gimple_assign_; it would still be a hybrid of is-a and
GIMPLE_CHECK unless I extended the patch to cover all the other
accessors.
Do you want me to continue converting things for gimple-compat.h to see
what a set of patches for that approach looks like?
If so, would it be better to split things out and have a
gimple-compat-assign.h, gimple-compat-call.h etc rather than one big
gimple-compat.h?
That said, I still prefer option 3.
> >> Whether you enable them generally or just for selected files
> >> via a gimple-compat.h will be up to you (but I'd rather get
> >> rid of them at some point).
> >>
> >> Note this allows seamless transform of "random" functions
> >> taking a gimple now but really only expecting a single kind.
> >>
> >> Note that we don't absolutely have to rush this all in for GCC 5.
> >> Being the very first for GCC 6 stage1 is another possibility.
> >> We just should get it right.
> >
> > Thanks
> > Dave
> >
>From 225ca0e9a4c37f4b0d259de2325a474c905bffd9 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Thu, 13 Nov 2014 15:46:41 -0500
Subject: [PATCH] Add gimple-compat.h and port remaining gimple_assign
accessors
gcc/ChangeLog.gimple-classes:
* gimple-compat.h: New file.
* gimple.h (is_a_helper <const gassign *>::test): New.
(gimple_assign_rhs_could_trap_p): Strengthen param "s" from gimple
to gassign *s.
(gimple_assign_set_lhs): Likewise for param "gs".
(gimple_assign_set_rhs1): Likewise.
(gimple_assign_set_rhs2): Likewise.
(gimple_assign_set_rhs3): Likewise.
(gimple_assign_set_nontemporal_move): Likewise.
(gimple_assign_set_rhs_code): Likewise for param "s".
(gimple_assign_lhs): Strengthen param "gs" from const_gimple to
const gassign *.
(gimple_assign_lhs_ptr): Likewise.
(gimple_assign_rhs1): Likewise.
(gimple_assign_rhs1_ptr): Likewise.
(gimple_assign_rhs2): Likewise.
(gimple_assign_rhs2_ptr): Likewise.
(gimple_assign_rhs3): Likewise.
(gimple_assign_rhs3_ptr): Likewise.
(gimple_assign_rhs_code): Likewise.
(gimple_assign_rhs_class): Likewise.
(gimple_assign_single_p): Make typesafe.
(gimple_assign_load_p): Likewise.
(gimple_assign_cast_p): Likewise.
(gimple_clobber_p): Likewise.
(gimple_expr_type): Likewise, by introducing a const gassign *
"assign" within the GIMPLE_ASSIGN "else" clause. Replace a
gimple_get_lhs call with a gimple_assign_lhs.
* asan.c: Include gimple-compat.h.
(build_shadow_mem_access): Strengthen local "g" from gimple to
gassign *.
(maybe_create_ssa_name): Likewise.
(maybe_cast_to_ptrmode): Likewise.
(instrument_strlen_call): Likewise.
(maybe_instrument_assignment): Likewise for local "s".
* auto-profile.c: Include gimple-compat.h.
* cfgexpand.c: Likewise.
* expr.c: Likewise.
* gimple-builder.c: Likewise.
* gimple-fold.c: Likewise.
* gimple-match-head.c: Likewise.
* gimple-ssa-isolate-paths.c: Likewise.
* gimple-ssa-strength-reduction.c: Likewise.
* gimple-walk.c: Likewise. Remove redundant second include of
gimple-walk.h.
* gimple.c: Include gimple-compat.h.
(gimple_assign_rhs_could_trap_p): Strengthen param "s" from gimple
to gassign *s.
* gimplify-me.c: Include gimple-compat.h.
* graphite-sese-to-poly.c: Likewise.
* ipa-icf-gimple.c: Likewise.
* ipa-inline-analysis.c: Likewise.
* ipa-polymorphic-call.c: Likewise.
* ipa-prop.c: Likewise.
* ipa-split.c: Likewise.
* omp-low.c: Likewise.
* predict.c: Likewise.
* sese.c: Likewise.
* trans-mem.c: Likewise.
(tm_log_emit_saves): Strengthen local "stmt" from gimple to
gassign *.
* tree-affine.c: Include gimple-compat.h.
* tree-call-cdce.c: Likewise.
* tree-complex.c: Likewise.
* tree-data-ref.c: Likewise.
* tree-eh.c: Likewise.
* tree-emutls.c (lower_emutls_1): Strengthen local "x" from gimple
to gassign *.
* tree-if-conv.c: Include gimple-compat.h.
* tree-inline.c: Likewise.
* tree-into-ssa.c: Likewise.
* tree-loop-distribution.c: Likewise.
* tree-nested.c: Likewise.
* tree-nrv.c: Likewise.
* tree-object-size.c: Likewise.
* tree-outof-ssa.c: Likewise.
* tree-parloops.c: Likewise.
* tree-predcom.c: Likewise.
* tree-scalar-evolution.c: Likewise.
(follow_ssa_edge_in_rhs): Strengthen param "stmt" from gimple to
gassign *.
(follow_ssa_edge): Add a checked cast to gassign * within
case GIMPLE_ASSIGN.
* tree-sra.c: Include gimple-compat.h.
* tree-ssa-alias.c: Likewise.
* tree-ssa-ccp.c: Likewise.
* tree-ssa-coalesce.c: Likewise.
* tree-ssa-copy.c: Likewise.
* tree-ssa-copyrename.c: Likewise.
* tree-ssa-dce.c: Likewise.
* tree-ssa-dom.c: Likewise.
* tree-ssa-dse.c: Likewise.
* tree-ssa-forwprop.c: Likewise.
* tree-ssa-ifcombine.c: Likewise.
* tree-ssa-live.c: Likewise.
* tree-ssa-loop-ch.c: Likewise.
* tree-ssa-loop-im.c: Likewise.
* tree-ssa-loop-ivcanon.c: Likewise.
* tree-ssa-loop-ivopts.c: Likewise.
* tree-ssa-loop-niter.c: Likewise.
* tree-ssa-loop-prefetch.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-sink.c: Likewise.
* tree-ssa-strlen.c: Likewise.
* tree-ssa-structalias.c: Likewise.
* tree-ssa-tail-merge.c: Likewise.
* tree-ssa-ter.c: Likewise.
* tree-ssa-threadedge.c: Likewise.
* tree-ssa-uninit.c: Likewise.
* tree-ssa.c: Likewise.
* tree-stdarg.c: Likewise.
* tree-switch-conversion.c (struct switch_conv_info): Strengthen
fields "arr_ref_first" and "arr_ref_last" from gimple to
gassign *.
(build_one_array): Likewise for local "load".
(build_arrays): Likewise for local "stmt".
* tree-vect-data-refs.c: Include gimple-compat.h.
* tree-vect-generic.c: Likewise.
* tree-vect-loop.c: Likewise.
* tree-vect-patterns.c: Likewise.
* tree-vect-slp.c: Likewise.
* tree-vect-stmts.c: Likewise.
(vect_init_vector): Strengthen local "init_stmt" from gimple to
gassign *.
* tree-vrp.c: Include gimple-compat.h.
* tsan.c: Likewise.
* ubsan.c: Likewise.
* value-prof.c: Likewise.
* vtable-verify.c: Likewise.
---
gcc/ChangeLog.gimple-classes | 139 ++++++++++++++++++++++++++++++++++++
gcc/asan.c | 11 +--
gcc/auto-profile.c | 1 +
gcc/cfgexpand.c | 1 +
gcc/expr.c | 1 +
gcc/gimple-builder.c | 1 +
gcc/gimple-compat.h | 123 +++++++++++++++++++++++++++++++
gcc/gimple-fold.c | 1 +
gcc/gimple-match-head.c | 1 +
gcc/gimple-ssa-isolate-paths.c | 1 +
gcc/gimple-ssa-strength-reduction.c | 1 +
gcc/gimple-walk.c | 2 +-
gcc/gimple.c | 4 +-
gcc/gimple.h | 98 ++++++++++++-------------
gcc/gimplify-me.c | 1 +
gcc/graphite-sese-to-poly.c | 1 +
gcc/ipa-icf-gimple.c | 1 +
gcc/ipa-inline-analysis.c | 1 +
gcc/ipa-polymorphic-call.c | 1 +
gcc/ipa-prop.c | 1 +
gcc/ipa-split.c | 1 +
gcc/omp-low.c | 1 +
gcc/predict.c | 1 +
gcc/sese.c | 1 +
gcc/trans-mem.c | 3 +-
gcc/tree-affine.c | 1 +
gcc/tree-call-cdce.c | 2 +
gcc/tree-complex.c | 1 +
gcc/tree-data-ref.c | 1 +
gcc/tree-eh.c | 1 +
gcc/tree-emutls.c | 2 +-
gcc/tree-if-conv.c | 1 +
gcc/tree-inline.c | 1 +
gcc/tree-into-ssa.c | 1 +
gcc/tree-loop-distribution.c | 1 +
gcc/tree-nested.c | 1 +
gcc/tree-nrv.c | 1 +
gcc/tree-object-size.c | 1 +
gcc/tree-outof-ssa.c | 1 +
gcc/tree-parloops.c | 1 +
gcc/tree-predcom.c | 1 +
gcc/tree-scalar-evolution.c | 5 +-
gcc/tree-sra.c | 1 +
gcc/tree-ssa-alias.c | 1 +
gcc/tree-ssa-ccp.c | 1 +
gcc/tree-ssa-coalesce.c | 1 +
gcc/tree-ssa-copy.c | 1 +
gcc/tree-ssa-copyrename.c | 1 +
gcc/tree-ssa-dce.c | 1 +
gcc/tree-ssa-dom.c | 1 +
gcc/tree-ssa-dse.c | 1 +
gcc/tree-ssa-forwprop.c | 1 +
gcc/tree-ssa-ifcombine.c | 1 +
gcc/tree-ssa-live.c | 1 +
gcc/tree-ssa-loop-ch.c | 1 +
gcc/tree-ssa-loop-im.c | 1 +
gcc/tree-ssa-loop-ivcanon.c | 1 +
gcc/tree-ssa-loop-ivopts.c | 1 +
gcc/tree-ssa-loop-niter.c | 1 +
gcc/tree-ssa-loop-prefetch.c | 1 +
gcc/tree-ssa-math-opts.c | 1 +
gcc/tree-ssa-phiopt.c | 1 +
gcc/tree-ssa-phiprop.c | 1 +
gcc/tree-ssa-pre.c | 1 +
gcc/tree-ssa-propagate.c | 1 +
gcc/tree-ssa-reassoc.c | 1 +
gcc/tree-ssa-sccvn.c | 1 +
gcc/tree-ssa-sink.c | 1 +
gcc/tree-ssa-strlen.c | 1 +
gcc/tree-ssa-structalias.c | 1 +
gcc/tree-ssa-tail-merge.c | 1 +
gcc/tree-ssa-ter.c | 1 +
gcc/tree-ssa-threadedge.c | 1 +
gcc/tree-ssa-uninit.c | 1 +
gcc/tree-ssa.c | 1 +
gcc/tree-stdarg.c | 1 +
gcc/tree-switch-conversion.c | 8 +--
gcc/tree-vect-data-refs.c | 1 +
gcc/tree-vect-generic.c | 1 +
gcc/tree-vect-loop.c | 1 +
gcc/tree-vect-patterns.c | 1 +
gcc/tree-vect-slp.c | 1 +
gcc/tree-vect-stmts.c | 3 +-
gcc/tree-vrp.c | 1 +
gcc/tsan.c | 1 +
gcc/ubsan.c | 1 +
gcc/value-prof.c | 1 +
gcc/vtable-verify.c | 1 +
88 files changed, 406 insertions(+), 70 deletions(-)
create mode 100644 gcc/gimple-compat.h
diff --git a/gcc/ChangeLog.gimple-classes b/gcc/ChangeLog.gimple-classes
index 133965c..e78b4b0 100644
--- a/gcc/ChangeLog.gimple-classes
+++ b/gcc/ChangeLog.gimple-classes
@@ -1,3 +1,142 @@
+2014-11-13 David Malcolm <dmalcolm@redhat.com>
+
+ * gimple-compat.h: New file.
+ * gimple.h (is_a_helper <const gassign *>::test): New.
+ (gimple_assign_rhs_could_trap_p): Strengthen param "s" from gimple
+ to gassign *s.
+ (gimple_assign_set_lhs): Likewise for param "gs".
+ (gimple_assign_set_rhs1): Likewise.
+ (gimple_assign_set_rhs2): Likewise.
+ (gimple_assign_set_rhs3): Likewise.
+ (gimple_assign_set_nontemporal_move): Likewise.
+ (gimple_assign_set_rhs_code): Likewise for param "s".
+ (gimple_assign_lhs): Strengthen param "gs" from const_gimple to
+ const gassign *.
+ (gimple_assign_lhs_ptr): Likewise.
+ (gimple_assign_rhs1): Likewise.
+ (gimple_assign_rhs1_ptr): Likewise.
+ (gimple_assign_rhs2): Likewise.
+ (gimple_assign_rhs2_ptr): Likewise.
+ (gimple_assign_rhs3): Likewise.
+ (gimple_assign_rhs3_ptr): Likewise.
+ (gimple_assign_rhs_code): Likewise.
+ (gimple_assign_rhs_class): Likewise.
+ (gimple_assign_single_p): Make typesafe.
+ (gimple_assign_load_p): Likewise.
+ (gimple_assign_cast_p): Likewise.
+ (gimple_clobber_p): Likewise.
+ (gimple_expr_type): Likewise, by introducing a const gassign *
+ "assign" within the GIMPLE_ASSIGN "else" clause. Replace a
+ gimple_get_lhs call with a gimple_assign_lhs.
+
+ * asan.c: Include gimple-compat.h.
+ (build_shadow_mem_access): Strengthen local "g" from gimple to
+ gassign *.
+ (maybe_create_ssa_name): Likewise.
+ (maybe_cast_to_ptrmode): Likewise.
+ (instrument_strlen_call): Likewise.
+ (maybe_instrument_assignment): Likewise for local "s".
+ * auto-profile.c: Include gimple-compat.h.
+ * cfgexpand.c: Likewise.
+ * expr.c: Likewise.
+ * gimple-builder.c: Likewise.
+ * gimple-fold.c: Likewise.
+ * gimple-match-head.c: Likewise.
+ * gimple-ssa-isolate-paths.c: Likewise.
+ * gimple-ssa-strength-reduction.c: Likewise.
+ * gimple-walk.c: Likewise. Remove redundant second include of
+ gimple-walk.h.
+ * gimple.c: Include gimple-compat.h.
+ (gimple_assign_rhs_could_trap_p): Strengthen param "s" from gimple
+ to gassign *s.
+ * gimplify-me.c: Include gimple-compat.h.
+ * graphite-sese-to-poly.c: Likewise.
+ * ipa-icf-gimple.c: Likewise.
+ * ipa-inline-analysis.c: Likewise.
+ * ipa-polymorphic-call.c: Likewise.
+ * ipa-prop.c: Likewise.
+ * ipa-split.c: Likewise.
+ * omp-low.c: Likewise.
+ * predict.c: Likewise.
+ * sese.c: Likewise.
+ * trans-mem.c: Likewise.
+ (tm_log_emit_saves): Strengthen local "stmt" from gimple to
+ gassign *.
+ * tree-affine.c: Include gimple-compat.h.
+ * tree-call-cdce.c: Likewise.
+ * tree-complex.c: Likewise.
+ * tree-data-ref.c: Likewise.
+ * tree-eh.c: Likewise.
+ * tree-emutls.c (lower_emutls_1): Strengthen local "x" from gimple
+ to gassign *.
+ * tree-if-conv.c: Include gimple-compat.h.
+ * tree-inline.c: Likewise.
+ * tree-into-ssa.c: Likewise.
+ * tree-loop-distribution.c: Likewise.
+ * tree-nested.c: Likewise.
+ * tree-nrv.c: Likewise.
+ * tree-object-size.c: Likewise.
+ * tree-outof-ssa.c: Likewise.
+ * tree-parloops.c: Likewise.
+ * tree-predcom.c: Likewise.
+ * tree-scalar-evolution.c: Likewise.
+ (follow_ssa_edge_in_rhs): Strengthen param "stmt" from gimple to
+ gassign *.
+ (follow_ssa_edge): Add a checked cast to gassign * within
+ case GIMPLE_ASSIGN.
+ * tree-sra.c: Include gimple-compat.h.
+ * tree-ssa-alias.c: Likewise.
+ * tree-ssa-ccp.c: Likewise.
+ * tree-ssa-coalesce.c: Likewise.
+ * tree-ssa-copy.c: Likewise.
+ * tree-ssa-copyrename.c: Likewise.
+ * tree-ssa-dce.c: Likewise.
+ * tree-ssa-dom.c: Likewise.
+ * tree-ssa-dse.c: Likewise.
+ * tree-ssa-forwprop.c: Likewise.
+ * tree-ssa-ifcombine.c: Likewise.
+ * tree-ssa-live.c: Likewise.
+ * tree-ssa-loop-ch.c: Likewise.
+ * tree-ssa-loop-im.c: Likewise.
+ * tree-ssa-loop-ivcanon.c: Likewise.
+ * tree-ssa-loop-ivopts.c: Likewise.
+ * tree-ssa-loop-niter.c: Likewise.
+ * tree-ssa-loop-prefetch.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-sink.c: Likewise.
+ * tree-ssa-strlen.c: Likewise.
+ * tree-ssa-structalias.c: Likewise.
+ * tree-ssa-tail-merge.c: Likewise.
+ * tree-ssa-ter.c: Likewise.
+ * tree-ssa-threadedge.c: Likewise.
+ * tree-ssa-uninit.c: Likewise.
+ * tree-ssa.c: Likewise.
+ * tree-stdarg.c: Likewise.
+ * tree-switch-conversion.c (struct switch_conv_info): Strengthen
+ fields "arr_ref_first" and "arr_ref_last" from gimple to
+ gassign *.
+ (build_one_array): Likewise for local "load".
+ (build_arrays): Likewise for local "stmt".
+ * tree-vect-data-refs.c: Include gimple-compat.h.
+ * tree-vect-generic.c: Likewise.
+ * tree-vect-loop.c: Likewise.
+ * tree-vect-patterns.c: Likewise.
+ * tree-vect-slp.c: Likewise.
+ * tree-vect-stmts.c: Likewise.
+ (vect_init_vector): Strengthen local "init_stmt" from gimple to
+ gassign *.
+ * tree-vrp.c: Include gimple-compat.h.
+ * tsan.c: Likewise.
+ * ubsan.c: Likewise.
+ * value-prof.c: Likewise.
+ * vtable-verify.c: Likewise.
+
2014-10-28 David Malcolm <dmalcolm@redhat.com>
* auto-profile.c (autofdo::function_instance::find_icall_target_map):
diff --git a/gcc/asan.c b/gcc/asan.c
index 9a310b4..cb8d5d0 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -67,6 +67,7 @@ along with GCC; see the file COPYING3. If not see
#include "ubsan.h"
#include "params.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* AddressSanitizer finds out-of-bounds and use-after-free bugs
with <2x slowdown on average.
@@ -1523,7 +1524,7 @@ build_shadow_mem_access (gimple_stmt_iterator *gsi, location_t location,
{
tree t, uintptr_type = TREE_TYPE (base_addr);
tree shadow_type = TREE_TYPE (shadow_ptr_type);
- gimple g;
+ gassign *g;
t = build_int_cst (uintptr_type, ASAN_SHADOW_SHIFT);
g = gimple_build_assign_with_ops (RSHIFT_EXPR,
@@ -1564,7 +1565,7 @@ maybe_create_ssa_name (location_t loc, tree base, gimple_stmt_iterator *iter,
{
if (TREE_CODE (base) == SSA_NAME)
return base;
- gimple g
+ gassign *g
= gimple_build_assign_with_ops (TREE_CODE (base),
make_ssa_name (TREE_TYPE (base), NULL),
base, NULL_TREE);
@@ -1585,7 +1586,7 @@ maybe_cast_to_ptrmode (location_t loc, tree len, gimple_stmt_iterator *iter,
{
if (ptrofftype_p (len))
return len;
- gimple g
+ gassign *g
= gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (pointer_sized_int_node, NULL),
len, NULL);
@@ -1854,7 +1855,7 @@ instrument_mem_region_access (tree base, tree len,
static bool
instrument_strlen_call (gimple_stmt_iterator *iter)
{
- gimple g;
+ gassign *g;
gcall *call = as_a <gcall *> (gsi_stmt (*iter));
gcc_assert (is_gimple_call (call));
@@ -1980,7 +1981,7 @@ instrument_builtin_call (gimple_stmt_iterator *iter)
static bool
maybe_instrument_assignment (gimple_stmt_iterator *iter)
{
- gimple s = gsi_stmt (*iter);
+ gassign *s = as_a <gassign *> (gsi_stmt (*iter));
gcc_assert (gimple_assign_single_p (s));
diff --git a/gcc/auto-profile.c b/gcc/auto-profile.c
index ba4e567..3dfe831 100644
--- a/gcc/auto-profile.c
+++ b/gcc/auto-profile.c
@@ -67,6 +67,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-inline.h"
#include "stringpool.h"
#include "auto-profile.h"
+#include "gimple-compat.h"
/* The following routines implements AutoFDO optimization.
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index a2cb483..eed4354 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -85,6 +85,7 @@ along with GCC; see the file COPYING3. If not see
#include "recog.h"
#include "output.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* Some systems use __main in a way incompatible with its use in gcc, in these
cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
diff --git a/gcc/expr.c b/gcc/expr.c
index a5bf13a..7929725 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -75,6 +75,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-address.h"
#include "cfgexpand.h"
#include "builtins.h"
+#include "gimple-compat.h"
#ifndef STACK_PUSH_CODE
#ifdef STACK_GROWS_DOWNWARD
diff --git a/gcc/gimple-builder.c b/gcc/gimple-builder.c
index a7c6c4e..aad2ce9 100644
--- a/gcc/gimple-builder.c
+++ b/gcc/gimple-builder.c
@@ -38,6 +38,7 @@ along with GCC; see the file COPYING3. If not see
#include "is-a.h"
#include "gimple.h"
#include "tree-ssanames.h"
+#include "gimple-compat.h"
/* Return the expression type to use based on the CODE and type of
diff --git a/gcc/gimple-compat.h b/gcc/gimple-compat.h
new file mode 100644
index 0000000..cbc37a0
--- /dev/null
+++ b/gcc/gimple-compat.h
@@ -0,0 +1,123 @@
+/* Compatibility for source files using gimple accessors with base class.
+
+ Copyright (C) 2014 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_GIMPLE_COMPAT_H
+#define GCC_GIMPLE_COMPAT_H
+
+/* Compatibility implementations of various gimple_assign_ accessors,
+ taking a gimple/const_gimple rather than a gassign *. */
+
+static inline tree
+gimple_assign_lhs (const_gimple gs)
+{
+ return gimple_assign_lhs (as_a <const gassign *> (gs));
+}
+
+static inline tree *
+gimple_assign_lhs_ptr (const_gimple gs)
+{
+ return gimple_assign_lhs_ptr (as_a <const gassign *> (gs));
+}
+
+static inline void
+gimple_assign_set_lhs (gimple gs, tree lhs)
+{
+ gimple_assign_set_lhs (as_a <gassign *> (gs), lhs);
+}
+
+static inline enum gimple_rhs_class
+gimple_assign_rhs_class (const_gimple gs)
+{
+ return gimple_assign_rhs_class (as_a <const gassign *> (gs));
+}
+
+static inline tree
+gimple_assign_rhs1 (const_gimple gs)
+{
+ return gimple_assign_rhs1 (as_a <const gassign *> (gs));
+}
+
+static inline tree *
+gimple_assign_rhs1_ptr (const_gimple gs)
+{
+ return gimple_assign_rhs1_ptr (as_a <const gassign *> (gs));
+}
+
+static inline void
+gimple_assign_set_rhs1 (gimple gs, tree rhs)
+{
+ gimple_assign_set_rhs1 (as_a <gassign *> (gs), rhs);
+}
+
+static inline tree
+gimple_assign_rhs2 (const_gimple gs)
+{
+ return gimple_assign_rhs2 (as_a <const gassign *> (gs));
+}
+
+static inline tree *
+gimple_assign_rhs2_ptr (const_gimple gs)
+{
+ return gimple_assign_rhs2_ptr (as_a <const gassign *> (gs));
+}
+
+static inline void
+gimple_assign_set_rhs2 (gimple gs, tree rhs)
+{
+ gimple_assign_set_rhs2 (as_a <gassign *> (gs), rhs);
+}
+
+static inline tree
+gimple_assign_rhs3 (const_gimple gs)
+{
+ return gimple_assign_rhs3 (as_a <const gassign *> (gs));
+}
+
+static inline void
+gimple_assign_set_rhs3 (gimple gs, tree rhs)
+{
+ gimple_assign_set_rhs3 (as_a <gassign *> (gs), rhs);
+}
+
+static inline void
+gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
+{
+ gimple_assign_set_nontemporal_move (as_a <gassign *> (gs), nontemporal);
+}
+
+static inline enum tree_code
+gimple_assign_rhs_code (const_gimple gs)
+{
+ return gimple_assign_rhs_code (as_a <const gassign *> (gs));
+}
+
+static inline void
+gimple_assign_set_rhs_code (gimple s, enum tree_code code)
+{
+ gimple_assign_set_rhs_code (as_a <gassign *> (s), code);
+}
+
+static inline bool
+gimple_assign_rhs_could_trap_p (gimple gs)
+{
+ return gimple_assign_rhs_could_trap_p (as_a <gassign *> (gs));
+}
+
+#endif /* GCC_GIMPLE_COMPAT_H */
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 4b45648..9fe6b3a 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -65,6 +65,7 @@ along with GCC; see the file COPYING3. If not see
#include "output.h"
#include "tree-eh.h"
#include "gimple-match.h"
+#include "gimple-compat.h"
/* Return true when DECL can be referenced from current unit.
FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c
index 9c6da59..12caa7e 100644
--- a/gcc/gimple-match-head.c
+++ b/gcc/gimple-match-head.c
@@ -50,6 +50,7 @@ along with GCC; see the file COPYING3. If not see
#include "ssa-iterators.h"
#include "dumpfile.h"
#include "gimple-match.h"
+#include "gimple-compat.h"
/* Forward declarations of the private auto-generated matchers.
diff --git a/gcc/gimple-ssa-isolate-paths.c b/gcc/gimple-ssa-isolate-paths.c
index ea8ead0..04d7eca 100644
--- a/gcc/gimple-ssa-isolate-paths.c
+++ b/gcc/gimple-ssa-isolate-paths.c
@@ -55,6 +55,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfg.h"
#include "diagnostic-core.h"
#include "intl.h"
+#include "gimple-compat.h"
static bool cfg_altered;
diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
index 0831f92..bb6e7eb 100644
--- a/gcc/gimple-ssa-strength-reduction.c
+++ b/gcc/gimple-ssa-strength-reduction.c
@@ -76,6 +76,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-affine.h"
#include "wide-int-print.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* Information about a strength reduction candidate. Each statement
in the candidate table represents an expression of one of the
diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c
index a6ea1ec..5f6abff 100644
--- a/gcc/gimple-walk.c
+++ b/gcc/gimple-walk.c
@@ -41,8 +41,8 @@ along with GCC; see the file COPYING3. If not see
#include "gimple.h"
#include "gimple-iterator.h"
#include "gimple-walk.h"
-#include "gimple-walk.h"
#include "demangle.h"
+#include "gimple-compat.h"
/* Walk all the statements in the sequence *PSEQ calling walk_gimple_stmt
on each one. WI is as in walk_gimple_stmt.
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 061a7a1..eb7f474 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -58,6 +58,7 @@ along with GCC; see the file COPYING3. If not see
#include "bitmap.h"
#include "stringpool.h"
#include "tree-ssanames.h"
+#include "gimple-compat.h"
/* All the tuples have their operand vector (if present) at the very bottom
@@ -1947,9 +1948,8 @@ gimple_could_trap_p (gimple s)
/* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
bool
-gimple_assign_rhs_could_trap_p (gimple s)
+gimple_assign_rhs_could_trap_p (gassign *s)
{
- gcc_assert (is_gimple_assign (s));
return gimple_could_trap_p_1 (s, true, false);
}
diff --git a/gcc/gimple.h b/gcc/gimple.h
index ccafde5..d87709f 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -1110,6 +1110,14 @@ is_a_helper <const gasm *>::test (const_gimple gs)
template <>
template <>
inline bool
+is_a_helper <const gassign *>::test (const_gimple gs)
+{
+ return gs->code == GIMPLE_ASSIGN;
+}
+
+template <>
+template <>
+inline bool
is_a_helper <const gbind *>::test (const_gimple gs)
{
return gs->code == GIMPLE_BIND;
@@ -1376,7 +1384,7 @@ gimple gimple_copy (gimple);
bool gimple_has_side_effects (const_gimple);
bool gimple_could_trap_p_1 (gimple, bool, bool);
bool gimple_could_trap_p (gimple);
-bool gimple_assign_rhs_could_trap_p (gimple);
+bool gimple_assign_rhs_could_trap_p (gassign *);
extern void dump_gimple_statistics (void);
unsigned get_gimple_rhs_num_ops (enum tree_code);
extern tree canonicalize_cond_expr_cond (tree);
@@ -2270,9 +2278,8 @@ get_gimple_rhs_class (enum tree_code code)
/* Return the LHS of assignment statement GS. */
static inline tree
-gimple_assign_lhs (const_gimple gs)
+gimple_assign_lhs (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
return gimple_op (gs, 0);
}
@@ -2280,9 +2287,8 @@ gimple_assign_lhs (const_gimple gs)
/* Return a pointer to the LHS of assignment statement GS. */
static inline tree *
-gimple_assign_lhs_ptr (const_gimple gs)
+gimple_assign_lhs_ptr (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
return gimple_op_ptr (gs, 0);
}
@@ -2290,9 +2296,8 @@ gimple_assign_lhs_ptr (const_gimple gs)
/* Set LHS to be the LHS operand of assignment statement GS. */
static inline void
-gimple_assign_set_lhs (gimple gs, tree lhs)
+gimple_assign_set_lhs (gassign *gs, tree lhs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
gimple_set_op (gs, 0, lhs);
if (lhs && TREE_CODE (lhs) == SSA_NAME)
@@ -2303,9 +2308,8 @@ gimple_assign_set_lhs (gimple gs, tree lhs)
/* Return the first operand on the RHS of assignment statement GS. */
static inline tree
-gimple_assign_rhs1 (const_gimple gs)
+gimple_assign_rhs1 (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
return gimple_op (gs, 1);
}
@@ -2314,19 +2318,16 @@ gimple_assign_rhs1 (const_gimple gs)
statement GS. */
static inline tree *
-gimple_assign_rhs1_ptr (const_gimple gs)
+gimple_assign_rhs1_ptr (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
return gimple_op_ptr (gs, 1);
}
/* Set RHS to be the first operand on the RHS of assignment statement GS. */
static inline void
-gimple_assign_set_rhs1 (gimple gs, tree rhs)
+gimple_assign_set_rhs1 (gassign *gs, tree rhs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-
gimple_set_op (gs, 1, rhs);
}
@@ -2335,10 +2336,8 @@ gimple_assign_set_rhs1 (gimple gs, tree rhs)
If GS does not have two operands, NULL is returned instead. */
static inline tree
-gimple_assign_rhs2 (const_gimple gs)
+gimple_assign_rhs2 (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-
if (gimple_num_ops (gs) >= 3)
return gimple_op (gs, 2);
else
@@ -2350,9 +2349,8 @@ gimple_assign_rhs2 (const_gimple gs)
statement GS. */
static inline tree *
-gimple_assign_rhs2_ptr (const_gimple gs)
+gimple_assign_rhs2_ptr (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
return gimple_op_ptr (gs, 2);
}
@@ -2360,10 +2358,8 @@ gimple_assign_rhs2_ptr (const_gimple gs)
/* Set RHS to be the second operand on the RHS of assignment statement GS. */
static inline void
-gimple_assign_set_rhs2 (gimple gs, tree rhs)
+gimple_assign_set_rhs2 (gassign *gs, tree rhs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-
gimple_set_op (gs, 2, rhs);
}
@@ -2371,10 +2367,8 @@ gimple_assign_set_rhs2 (gimple gs, tree rhs)
If GS does not have two operands, NULL is returned instead. */
static inline tree
-gimple_assign_rhs3 (const_gimple gs)
+gimple_assign_rhs3 (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-
if (gimple_num_ops (gs) >= 4)
return gimple_op (gs, 3);
else
@@ -2385,9 +2379,8 @@ gimple_assign_rhs3 (const_gimple gs)
statement GS. */
static inline tree *
-gimple_assign_rhs3_ptr (const_gimple gs)
+gimple_assign_rhs3_ptr (const gassign *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
return gimple_op_ptr (gs, 3);
}
@@ -2395,10 +2388,8 @@ gimple_assign_rhs3_ptr (const_gimple gs)
/* Set RHS to be the third operand on the RHS of assignment statement GS. */
static inline void
-gimple_assign_set_rhs3 (gimple gs, tree rhs)
+gimple_assign_set_rhs3 (gassign *gs, tree rhs)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-
gimple_set_op (gs, 3, rhs);
}
@@ -2423,9 +2414,8 @@ gimple_assign_nontemporal_move_p (const gassign *gs)
/* Sets nontemporal move flag of GS to NONTEMPORAL. */
static inline void
-gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
+gimple_assign_set_nontemporal_move (gassign *gs, bool nontemporal)
{
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
gs->nontemporal_move = nontemporal;
}
@@ -2435,10 +2425,9 @@ gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
tree code of the object. */
static inline enum tree_code
-gimple_assign_rhs_code (const_gimple gs)
+gimple_assign_rhs_code (const gassign *gs)
{
enum tree_code code;
- GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
code = (enum tree_code) gs->subcode;
/* While we initially set subcode to the TREE_CODE of the rhs for
@@ -2455,9 +2444,8 @@ gimple_assign_rhs_code (const_gimple gs)
assignment S. */
static inline void
-gimple_assign_set_rhs_code (gimple s, enum tree_code code)
+gimple_assign_set_rhs_code (gassign *s, enum tree_code code)
{
- GIMPLE_CHECK (s, GIMPLE_ASSIGN);
s->subcode = code;
}
@@ -2467,7 +2455,7 @@ gimple_assign_set_rhs_code (gimple s, enum tree_code code)
This will never return GIMPLE_INVALID_RHS. */
static inline enum gimple_rhs_class
-gimple_assign_rhs_class (const_gimple gs)
+gimple_assign_rhs_class (const gassign *gs)
{
return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
}
@@ -2481,8 +2469,9 @@ gimple_assign_rhs_class (const_gimple gs)
static inline bool
gimple_assign_single_p (const_gimple gs)
{
- return (is_gimple_assign (gs)
- && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
+ if (const gassign *assign = dyn_cast <const gassign *> (gs))
+ return gimple_assign_rhs_class (assign) == GIMPLE_SINGLE_RHS;
+ return false;
}
/* Return true if GS performs a store to its lhs. */
@@ -2502,7 +2491,7 @@ gimple_assign_load_p (const_gimple gs)
tree rhs;
if (!gimple_assign_single_p (gs))
return false;
- rhs = gimple_assign_rhs1 (gs);
+ rhs = gimple_assign_rhs1 (as_a <const gassign *> (gs));
if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
return true;
rhs = get_base_address (rhs);
@@ -2518,7 +2507,7 @@ gimple_assign_cast_p (const_gimple s)
{
if (is_gimple_assign (s))
{
- enum tree_code sc = gimple_assign_rhs_code (s);
+ enum tree_code sc = gimple_assign_rhs_code (as_a <const gassign *> (s));
return CONVERT_EXPR_CODE_P (sc)
|| sc == VIEW_CONVERT_EXPR
|| sc == FIX_TRUNC_EXPR;
@@ -2533,7 +2522,7 @@ static inline bool
gimple_clobber_p (const_gimple s)
{
return gimple_assign_single_p (s)
- && TREE_CLOBBER_P (gimple_assign_rhs1 (s));
+ && TREE_CLOBBER_P (gimple_assign_rhs1 (as_a <const gassign *> (s)));
}
/* Return true if GS is a GIMPLE_CALL. */
@@ -5626,17 +5615,20 @@ gimple_expr_type (const_gimple stmt)
type = gimple_call_return_type (call_stmt);
}
else
- switch (gimple_assign_rhs_code (stmt))
- {
- case POINTER_PLUS_EXPR:
- type = TREE_TYPE (gimple_assign_rhs1 (stmt));
- break;
-
- default:
- /* As fallback use the type of the LHS. */
- type = TREE_TYPE (gimple_get_lhs (stmt));
- break;
- }
+ {
+ const gassign *assign = as_a <const gassign *> (stmt);
+ switch (gimple_assign_rhs_code (assign))
+ {
+ case POINTER_PLUS_EXPR:
+ type = TREE_TYPE (gimple_assign_rhs1 (assign));
+ break;
+
+ default:
+ /* As fallback use the type of the LHS. */
+ type = TREE_TYPE (gimple_assign_lhs (assign));
+ break;
+ }
+ }
return type;
}
else if (code == GIMPLE_COND)
diff --git a/gcc/gimplify-me.c b/gcc/gimplify-me.c
index 9d969de..1009b2f 100644
--- a/gcc/gimplify-me.c
+++ b/gcc/gimplify-me.c
@@ -49,6 +49,7 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-ssa.h"
#include "stringpool.h"
#include "tree-ssanames.h"
+#include "gimple-compat.h"
/* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c
index 16d1bb6..1c08c3c 100644
--- a/gcc/graphite-sese-to-poly.c
+++ b/gcc/graphite-sese-to-poly.c
@@ -86,6 +86,7 @@ extern "C" {
#include "domwalk.h"
#include "sese.h"
#include "tree-ssa-propagate.h"
+#include "gimple-compat.h"
#ifdef HAVE_isl
#include "expr.h"
diff --git a/gcc/ipa-icf-gimple.c b/gcc/ipa-icf-gimple.c
index 9ebef25..ddf253a 100644
--- a/gcc/ipa-icf-gimple.c
+++ b/gcc/ipa-icf-gimple.c
@@ -56,6 +56,7 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-icf-gimple.h"
#include "ipa-icf.h"
+#include "gimple-compat.h"
namespace ipa_icf_gimple {
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index aa8a596..642e1b5 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -116,6 +116,7 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-utils.h"
#include "cilk.h"
#include "cfgexpand.h"
+#include "gimple-compat.h"
/* Estimate runtime of function can easilly run into huge numbers with many
nested loops. Be sure we can compute time * INLINE_SIZE_SCALE * 2 in an
diff --git a/gcc/ipa-polymorphic-call.c b/gcc/ipa-polymorphic-call.c
index 3f2d303..9a69f7e 100644
--- a/gcc/ipa-polymorphic-call.c
+++ b/gcc/ipa-polymorphic-call.c
@@ -51,6 +51,7 @@ along with GCC; see the file COPYING3. If not see
#include "data-streamer.h"
#include "lto-streamer.h"
#include "streamer-hooks.h"
+#include "gimple-compat.h"
/* Return true when TYPE contains an polymorphic type and thus is interesting
for devirtualization machinery. */
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index 47a8f03..41534a6 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -74,6 +74,7 @@ along with GCC; see the file COPYING3. If not see
#include "domwalk.h"
#include "builtins.h"
#include "calls.h"
+#include "gimple-compat.h"
/* Intermediate information that we get from alias analysis about a particular
parameter in a particular basic_block. When a parameter or the memory it
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index 145aceb..1f6c9dc 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -122,6 +122,7 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-pretty-print.h"
#include "ipa-inline.h"
#include "cfgloop.h"
+#include "gimple-compat.h"
/* Per basic block info. */
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index e53f4ff..da6fec3 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -81,6 +81,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-nested.h"
#include "tree-eh.h"
#include "cilk.h"
+#include "gimple-compat.h"
/* Lowering of OpenMP parallel and workshare constructs proceeds in two
diff --git a/gcc/predict.c b/gcc/predict.c
index 352417a..6674300 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -77,6 +77,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pass.h"
#include "tree-scalar-evolution.h"
#include "cfgloop.h"
+#include "gimple-compat.h"
/* real constants: 0, 1, 1-1/REG_BR_PROB_BASE, REG_BR_PROB_BASE,
1/REG_BR_PROB_BASE, 0.5, BB_FREQ_MAX. */
diff --git a/gcc/sese.c b/gcc/sese.c
index e0869e0..660d6d9 100644
--- a/gcc/sese.c
+++ b/gcc/sese.c
@@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see
#include "value-prof.h"
#include "sese.h"
#include "tree-ssa-propagate.h"
+#include "gimple-compat.h"
/* Helper function for debug_rename_map. */
diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c
index eb1f5be..d584ed4 100644
--- a/gcc/trans-mem.c
+++ b/gcc/trans-mem.c
@@ -65,6 +65,7 @@
#include "gimple-pretty-print.h"
#include "cfgloop.h"
#include "tree-ssa-address.h"
+#include "gimple-compat.h"
#define A_RUNINSTRUMENTEDCODE 0x0001
@@ -1281,7 +1282,7 @@ tm_log_emit_saves (basic_block entry_block, basic_block bb)
{
size_t i;
gimple_stmt_iterator gsi = gsi_last_bb (bb);
- gimple stmt;
+ gassign *stmt;
struct tm_log_entry l, *lp;
for (i = 0; i < tm_log_save_addresses.length (); ++i)
diff --git a/gcc/tree-affine.c b/gcc/tree-affine.c
index 4c61cd0..fda862d 100644
--- a/gcc/tree-affine.c
+++ b/gcc/tree-affine.c
@@ -44,6 +44,7 @@ along with GCC; see the file COPYING3. If not see
#include "dumpfile.h"
#include "cfgexpand.h"
#include "wide-int-print.h"
+#include "gimple-compat.h"
/* Extends CST as appropriate for the affine combinations COMB. */
diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c
index 23c2df5..2b98ccd 100644
--- a/gcc/tree-call-cdce.c
+++ b/gcc/tree-call-cdce.c
@@ -49,6 +49,8 @@ along with GCC; see the file COPYING3. If not see
#include "tree-into-ssa.h"
#include "tree-pass.h"
#include "flags.h"
+#include "gimple-compat.h"
+
/* Conditional dead call elimination
diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c
index dbc01f4..eb4c85a 100644
--- a/gcc/tree-complex.c
+++ b/gcc/tree-complex.c
@@ -58,6 +58,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-propagate.h"
#include "tree-hasher.h"
#include "cfgloop.h"
+#include "gimple-compat.h"
/* For each complex ssa name, a lattice value. We're interested in finding
diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index 4a16c3a..c94b2ec 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -107,6 +107,7 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "tree-affine.h"
#include "params.h"
+#include "gimple-compat.h"
static struct datadep_stats
{
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index a27ed35..34da690 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "cfgloop.h"
#include "gimple-low.h"
+#include "gimple-compat.h"
/* In some instances a tree and a gimple need to be stored in a same table,
i.e. in hash tables. This is a structure to do this. */
diff --git a/gcc/tree-emutls.c b/gcc/tree-emutls.c
index f456b4b..ec3ea61 100644
--- a/gcc/tree-emutls.c
+++ b/gcc/tree-emutls.c
@@ -489,7 +489,7 @@ lower_emutls_1 (tree *ptr, int *walk_subtrees, void *cb_data)
new assignment statement, and substitute yet another SSA_NAME. */
if (wi->changed)
{
- gimple x;
+ gassign *x;
addr = create_tmp_var (TREE_TYPE (t), NULL);
x = gimple_build_assign (addr, t);
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index f0beb31..0cd73c4 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -126,6 +126,7 @@ along with GCC; see the file COPYING3. If not see
#include "dbgcnt.h"
#include "expr.h"
#include "optabs.h"
+#include "gimple-compat.h"
/* List of basic blocks in if-conversion-suitable order. */
static basic_block *ifc_bbs;
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index e005da1..dd46529 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -75,6 +75,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "cfgloop.h"
#include "builtins.h"
+#include "gimple-compat.h"
#include "rtl.h" /* FIXME: For asm_str_count. */
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index 70b523c..a370f45 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -63,6 +63,7 @@ along with GCC; see the file COPYING3. If not see
#include "params.h"
#include "diagnostic-core.h"
#include "tree-into-ssa.h"
+#include "gimple-compat.h"
#define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y))
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index 31ea04c..94b9d85 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -83,6 +83,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pass.h"
#include "gimple-pretty-print.h"
#include "tree-vectorizer.h"
+#include "gimple-compat.h"
/* A Reduced Dependence Graph (RDG) vertex representing a statement. */
diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c
index a254a1c..3fc9271 100644
--- a/gcc/tree-nested.c
+++ b/gcc/tree-nested.c
@@ -51,6 +51,7 @@
#include "expr.h" /* FIXME: For STACK_SAVEAREA_MODE and SAVE_NONLOCAL. */
#include "langhooks.h"
#include "gimple-low.h"
+#include "gimple-compat.h"
/* The object of this pass is to lower the representation of a set of nested
diff --git a/gcc/tree-nrv.c b/gcc/tree-nrv.c
index 182039e..b50619f 100644
--- a/gcc/tree-nrv.c
+++ b/gcc/tree-nrv.c
@@ -49,6 +49,7 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h" /* For "optimize" in gate_pass_return_slot.
FIXME: That should be up to the pass manager,
but pass_nrv is not in pass_all_optimizations. */
+#include "gimple-compat.h"
/* This file implements return value optimizations for functions which
return aggregate types.
diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c
index 20b9956..7dfa176 100644
--- a/gcc/tree-object-size.c
+++ b/gcc/tree-object-size.c
@@ -53,6 +53,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-phinodes.h"
#include "ssa-iterators.h"
#include "builtins.h"
+#include "gimple-compat.h"
struct object_size_info
{
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index bb57053..798b440 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -59,6 +59,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-ter.h"
#include "tree-ssa-coalesce.h"
#include "tree-outof-ssa.h"
+#include "gimple-compat.h"
/* FIXME: A lot of code here deals with expanding to RTL. All that code
should be in cfgexpand.c. */
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index a1e0778..702a6fe 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -68,6 +68,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-parloops.h"
#include "omp-low.h"
#include "tree-nested.h"
+#include "gimple-compat.h"
/* This pass tries to distribute iterations of loops into several threads.
The implementation is straightforward -- for each loop we test whether its
diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
index 93a523c..297805b 100644
--- a/gcc/tree-predcom.c
+++ b/gcc/tree-predcom.c
@@ -233,6 +233,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-affine.h"
#include "tree-inline.h"
#include "wide-int-print.h"
+#include "gimple-compat.h"
/* The maximum number of iterations between the considered memory
references. */
diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c
index 38b0767..746cb14 100644
--- a/gcc/tree-scalar-evolution.c
+++ b/gcc/tree-scalar-evolution.c
@@ -298,6 +298,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-propagate.h"
#include "gimple-fold.h"
#include "gimplify-me.h"
+#include "gimple-compat.h"
static tree analyze_scalar_evolution_1 (struct loop *, tree, tree);
static tree analyze_scalar_evolution_for_address_of (struct loop *loop,
@@ -1150,7 +1151,7 @@ follow_ssa_edge_expr (struct loop *loop, gimple at_stmt, tree expr,
Return true if the strongly connected component has been found. */
static t_bool
-follow_ssa_edge_in_rhs (struct loop *loop, gimple stmt,
+follow_ssa_edge_in_rhs (struct loop *loop, gassign *stmt,
gphi *halting_phi, tree *evolution_of_loop,
int limit)
{
@@ -1388,7 +1389,7 @@ follow_ssa_edge (struct loop *loop, gimple def, gphi *halting_phi,
return t_false;
case GIMPLE_ASSIGN:
- return follow_ssa_edge_in_rhs (loop, def, halting_phi,
+ return follow_ssa_edge_in_rhs (loop, as_a <gassign *> (def), halting_phi,
evolution_of_loop, limit);
default:
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 85a9a87..3092125 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -123,6 +123,7 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-inline.h"
#include "ipa-utils.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* Enumeration of all aggregate reductions we can do. */
enum sra_mode { SRA_MODE_EARLY_IPA, /* early call regularization */
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 9b55e0d..eb53fad 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -56,6 +56,7 @@ along with GCC; see the file COPYING3. If not see
#include "alloc-pool.h"
#include "tree-ssa-alias.h"
#include "ipa-reference.h"
+#include "gimple-compat.h"
/* Broad overview of how alias analysis on gimple works:
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index bf7577a..8bb2c53 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -164,6 +164,7 @@ along with GCC; see the file COPYING3. If not see
#include "params.h"
#include "wide-int-print.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* Possible lattice values. */
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index 7d1825d..b8b0726 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -53,6 +53,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-live.h"
#include "tree-ssa-coalesce.h"
#include "diagnostic-core.h"
+#include "gimple-compat.h"
/* This set of routines implements a coalesce_list. This is an object which
diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index 3833dff..818a100 100644
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -55,6 +55,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-scalar-evolution.h"
#include "tree-ssa-dom.h"
#include "tree-ssa-loop-niter.h"
+#include "gimple-compat.h"
/* This file implements the copy propagation pass and provides a
diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c
index cd7bac5..231ff3f 100644
--- a/gcc/tree-ssa-copyrename.c
+++ b/gcc/tree-ssa-copyrename.c
@@ -52,6 +52,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-live.h"
#include "tree-pass.h"
#include "langhooks.h"
+#include "gimple-compat.h"
static struct
{
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index 06ffb24..e5e5475 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -84,6 +84,7 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "cfgloop.h"
#include "tree-scalar-evolution.h"
+#include "gimple-compat.h"
static struct stmt_stats
{
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 747354b..9278629 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -66,6 +66,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-threadedge.h"
#include "tree-ssa-dom.h"
#include "inchash.h"
+#include "gimple-compat.h"
/* This file implements optimizations on the dominator tree. */
diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c
index 91017ff..3093904 100644
--- a/gcc/tree-ssa-dse.c
+++ b/gcc/tree-ssa-dse.c
@@ -55,6 +55,7 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "langhooks.h"
#include "tree-cfgcleanup.h"
+#include "gimple-compat.h"
/* This file implements dead store elimination.
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index 55de465..b16c77a 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -67,6 +67,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfgcleanup.h"
#include "tree-into-ssa.h"
#include "cfganal.h"
+#include "gimple-compat.h"
/* This pass propagates the RHS of assignment statements into use
sites of the LHS of the assignment. It's basically a specialized
diff --git a/gcc/tree-ssa-ifcombine.c b/gcc/tree-ssa-ifcombine.c
index 9fd7113..764b9d1 100644
--- a/gcc/tree-ssa-ifcombine.c
+++ b/gcc/tree-ssa-ifcombine.c
@@ -54,6 +54,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-phinodes.h"
#include "ssa-iterators.h"
#include "tree-pass.h"
+#include "gimple-compat.h"
#ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
#define LOGICAL_OP_NON_SHORT_CIRCUIT \
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index db11e3e..33ab5a6 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -57,6 +57,7 @@ along with GCC; see the file COPYING3. If not see
#include "diagnostic-core.h"
#include "debug.h"
#include "flags.h"
+#include "gimple-compat.h"
#ifdef ENABLE_CHECKING
static void verify_live_on_entry (tree_live_info_p);
diff --git a/gcc/tree-ssa-loop-ch.c b/gcc/tree-ssa-loop-ch.c
index 300b2fa..5b5edf0 100644
--- a/gcc/tree-ssa-loop-ch.c
+++ b/gcc/tree-ssa-loop-ch.c
@@ -48,6 +48,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-inline.h"
#include "flags.h"
#include "tree-ssa-threadedge.h"
+#include "gimple-compat.h"
/* Duplicates headers of loops if they are small enough, so that the statements
in the loop body are always executed when the loop is entered. This
diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index 6f64f4a..edfc8f3 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -64,6 +64,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-propagate.h"
#include "trans-mem.h"
#include "gimple-fold.h"
+#include "gimple-compat.h"
/* TODO: Support for predicated code motion. I.e.
diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index e205216..8aff3a9 100644
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -83,6 +83,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "tree-cfgcleanup.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* Specifies types of loops that may be unrolled. */
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index f0237e0..ac71e40 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -120,6 +120,7 @@ along with GCC; see the file COPYING3. If not see
#include "expmed.h"
#include "tree-ssa-address.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* FIXME: Expressions are expanded to RTL in this pass to determine the
cost of different addressing modes. This should be moved to a TBD
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index fd4d5bf..a6f6238 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -65,6 +65,7 @@ along with GCC; see the file COPYING3. If not see
#include "stringpool.h"
#include "tree-ssanames.h"
#include "wide-int-print.h"
+#include "gimple-compat.h"
#define SWAP(X, Y) do { affine_iv *tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c
index c06c755..41935f3 100644
--- a/gcc/tree-ssa-loop-prefetch.c
+++ b/gcc/tree-ssa-loop-prefetch.c
@@ -60,6 +60,7 @@ along with GCC; see the file COPYING3. If not see
#include "langhooks.h"
#include "tree-inline.h"
#include "tree-data-ref.h"
+#include "gimple-compat.h"
/* FIXME: Needed for optabs, but this should all be moved to a TBD interface
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index 5211b89..d3e8d3f 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -125,6 +125,7 @@ along with GCC; see the file COPYING3. If not see
#include "target.h"
#include "gimple-pretty-print.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* FIXME: RTL headers have to be included here for optabs. */
#include "rtl.h" /* Because optabs.h wants enum rtx_code. */
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c
index ccb6c6b..c4ac573 100644
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -65,6 +65,7 @@ along with GCC; see the file COPYING3. If not see
#include "optabs.h"
#include "tree-scalar-evolution.h"
#include "tree-inline.h"
+#include "gimple-compat.h"
#ifndef HAVE_conditional_move
#define HAVE_conditional_move (0)
diff --git a/gcc/tree-ssa-phiprop.c b/gcc/tree-ssa-phiprop.c
index 8caab38..8f97b39 100644
--- a/gcc/tree-ssa-phiprop.c
+++ b/gcc/tree-ssa-phiprop.c
@@ -52,6 +52,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pass.h"
#include "langhooks.h"
#include "flags.h"
+#include "gimple-compat.h"
/* This pass propagates indirect loads through the PHI node for its
address to make the load source possibly non-addressable and to
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index 886e6fc2..4d098a7 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -76,6 +76,7 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-prop.h"
#include "tree-ssa-propagate.h"
#include "ipa-utils.h"
+#include "gimple-compat.h"
/* TODO:
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index c246ed6..7140f61 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -60,6 +60,7 @@
#include "langhooks.h"
#include "value-prof.h"
#include "domwalk.h"
+#include "gimple-compat.h"
/* This file implements a generic value propagation engine based on
the same propagation used by the SSA-CCP algorithm [1].
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index dec357a..4840f26 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -74,6 +74,7 @@ along with GCC; see the file COPYING3. If not see
#include "builtins.h"
#include "gimplify.h"
#include "optabs.h"
+#include "gimple-compat.h"
/* This is a simple global reassociation pass. It is, in part, based
on the LLVM pass of the same name (They do some things more/less
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 683e50e..4c5e7c6 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -65,6 +65,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-sccvn.h"
#include "tree-cfg.h"
#include "domwalk.h"
+#include "gimple-compat.h"
/* This algorithm is based on the SCC algorithm presented by Keith
Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index c6d8712..6d8c511 100644
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -54,6 +54,7 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "cfgloop.h"
#include "params.h"
+#include "gimple-compat.h"
/* TODO:
1. Sinking store only using scalar promotion (IE without moving the RHS):
diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c
index 4d35bc9..114bbff 100644
--- a/gcc/tree-ssa-strlen.c
+++ b/gcc/tree-ssa-strlen.c
@@ -62,6 +62,7 @@ along with GCC; see the file COPYING3. If not see
#include "gimple-pretty-print.h"
#include "params.h"
#include "expr.h"
+#include "gimple-compat.h"
/* A vector indexed by SSA_NAME_VERSION. 0 means unknown, positive value
is an index into strinfo vector, negative value stands for
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index e1f0e66..66d1dbf 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -61,6 +61,7 @@
#include "splay-tree.h"
#include "params.h"
#include "alias.h"
+#include "gimple-compat.h"
/* The idea behind this analyzer is to generate set constraints from the
program, then solve the resulting constraints in order to generate the
diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
index 5678657..1bff1e6 100644
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -228,6 +228,7 @@ along with GCC; see the file COPYING3. If not see
#include "cfgloop.h"
#include "tree-pass.h"
#include "trans-mem.h"
+#include "gimple-compat.h"
/* Describes a group of bbs with the same successors. The successor bbs are
cached in succs, and the successor edge flags are cached in succ_flags.
diff --git a/gcc/tree-ssa-ter.c b/gcc/tree-ssa-ter.c
index 96b3959..afddc00 100644
--- a/gcc/tree-ssa-ter.c
+++ b/gcc/tree-ssa-ter.c
@@ -54,6 +54,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-outof-ssa.h"
#include "flags.h"
#include "gimple-walk.h"
+#include "gimple-compat.h"
/* Temporary Expression Replacement (TER)
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index 1f3825d..972f1a9 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -56,6 +56,7 @@ along with GCC; see the file COPYING3. If not see
#include "params.h"
#include "tree-ssa-threadedge.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* To avoid code explosion due to jump threading, we limit the
number of statements we are going to copy. This variable
diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index 9fa3acf..f4039b6 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -52,6 +52,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-pass.h"
#include "diagnostic-core.h"
#include "params.h"
+#include "gimple-compat.h"
/* This implements the pass that does predicate aware warning on uses of
possibly uninitialized variables. The pass first collects the set of
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index b893df9..a433b7c 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -62,6 +62,7 @@ along with GCC; see the file COPYING3. If not see
#include "diagnostic-core.h"
#include "cfgloop.h"
#include "cfgexpand.h"
+#include "gimple-compat.h"
/* Pointer map of variable mappings, keyed by edge. */
static hash_map<edge, auto_vec<edge_var_map> > *edge_var_maps;
diff --git a/gcc/tree-stdarg.c b/gcc/tree-stdarg.c
index 7bf3335..f71c4f6 100644
--- a/gcc/tree-stdarg.c
+++ b/gcc/tree-stdarg.c
@@ -53,6 +53,7 @@ along with GCC; see the file COPYING3. If not see
#include "sbitmap.h"
#include "tree-pass.h"
#include "tree-stdarg.h"
+#include "gimple-compat.h"
/* A simple pass that attempts to optimize stdarg functions on architectures
that need to save register arguments to stack on entry to stdarg functions.
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index 334d775..f5172e9 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -599,10 +599,10 @@ struct switch_conv_info
/* The first load statement that loads a temporary from a new static array.
*/
- gimple arr_ref_first;
+ gassign *arr_ref_first;
/* The last load statement that loads a temporary from a new static array. */
- gimple arr_ref_last;
+ gassign *arr_ref_last;
/* String reason why the case wasn't a good candidate that is written to the
dump file, if there is one. */
@@ -1037,7 +1037,7 @@ build_one_array (gswitch *swtch, int num, tree arr_index_type,
gphi *phi, tree tidx, struct switch_conv_info *info)
{
tree name, cst;
- gimple load;
+ gassign *load;
gimple_stmt_iterator gsi = gsi_for_stmt (swtch);
location_t loc = gimple_location (swtch);
@@ -1103,7 +1103,7 @@ build_arrays (gswitch *swtch, struct switch_conv_info *info)
{
tree arr_index_type;
tree tidx, sub, utype;
- gimple stmt;
+ gassign *stmt;
gimple_stmt_iterator gsi;
gphi_iterator gpi;
int i;
diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
index de6a531..2f42894 100644
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -69,6 +69,7 @@ along with GCC; see the file COPYING3. If not see
#include "optabs.h"
#include "builtins.h"
#include "varasm.h"
+#include "gimple-compat.h"
/* Return true if load- or store-lanes optab OPTAB is implemented for
COUNT vectors of type VECTYPE. NAME is the name of OPTAB. */
diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c
index 55ab637..c3a2437 100644
--- a/gcc/tree-vect-generic.c
+++ b/gcc/tree-vect-generic.c
@@ -52,6 +52,7 @@ along with GCC; see the file COPYING3. If not see
#include "flags.h"
#include "diagnostic.h"
#include "target.h"
+#include "gimple-compat.h"
/* Need to include rtl.h, expr.h, etc. for optabs. */
#include "expr.h"
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 5149db7..e63c21d 100644
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -66,6 +66,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-scalar-evolution.h"
#include "tree-vectorizer.h"
#include "target.h"
+#include "gimple-compat.h"
/* Loop Vectorization Pass.
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index b84248e..f16dcbf 100644
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -59,6 +59,7 @@ along with GCC; see the file COPYING3. If not see
#include "diagnostic-core.h"
#include "dumpfile.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* Pattern recognition functions */
static gimple vect_recog_widen_sum_pattern (vec<gimple> *, tree *,
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 0e9abdb..85e01ed 100644
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -55,6 +55,7 @@ along with GCC; see the file COPYING3. If not see
#include "optabs.h"
#include "tree-vectorizer.h"
#include "langhooks.h"
+#include "gimple-compat.h"
/* Extract the location of the basic block in the source code.
Return the basic block location if succeed and NULL if not. */
diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c
index 02ac7d0..f42adae 100644
--- a/gcc/tree-vect-stmts.c
+++ b/gcc/tree-vect-stmts.c
@@ -66,6 +66,7 @@ along with GCC; see the file COPYING3. If not see
#include "dumpfile.h"
#include "cgraph.h"
#include "builtins.h"
+#include "gimple-compat.h"
/* For lang_hooks.types.type_for_mode. */
#include "langhooks.h"
@@ -1314,7 +1315,7 @@ tree
vect_init_vector (gimple stmt, tree val, tree type, gimple_stmt_iterator *gsi)
{
tree new_var;
- gimple init_stmt;
+ gassign *init_stmt;
tree vec_oprnd;
tree new_temp;
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 43ffcfe..4614fba 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -72,6 +72,7 @@ along with GCC; see the file COPYING3. If not see
#include "optabs.h"
#include "tree-ssa-threadedge.h"
#include "wide-int.h"
+#include "gimple-compat.h"
diff --git a/gcc/tsan.c b/gcc/tsan.c
index 0577104..83a5931 100644
--- a/gcc/tsan.c
+++ b/gcc/tsan.c
@@ -59,6 +59,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-propagate.h"
#include "tsan.h"
#include "asan.h"
+#include "gimple-compat.h"
/* Number of instrumented memory accesses in the current function. */
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index 7a69000..e8dc598 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -56,6 +56,7 @@ along with GCC; see the file COPYING3. If not see
#include "dfp.h"
#include "builtins.h"
#include "tree-object-size.h"
+#include "gimple-compat.h"
/* Map from a tree to a VAR_DECL tree. */
diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index b35c437..5a4033e 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -69,6 +69,7 @@ along with GCC; see the file COPYING3. If not see
#include "builtins.h"
#include "tree-nested.h"
#include "params.h"
+#include "gimple-compat.h"
/* In this file value profile based optimizations are placed. Currently the
following optimizations are implemented (for more detailed descriptions
diff --git a/gcc/vtable-verify.c b/gcc/vtable-verify.c
index c7105d5..0815802 100644
--- a/gcc/vtable-verify.c
+++ b/gcc/vtable-verify.c
@@ -161,6 +161,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssanames.h"
#include "tree-pass.h"
#include "cfgloop.h"
+#include "gimple-compat.h"
#include "vtable-verify.h"
--
1.8.5.3