Discussion:
[PATCH 0/3] Compile-time gimple checking v4
(too old to reply)
David Malcolm
2014-05-12 21:35:59 UTC
Permalink
This is v4 of the patch series.

Revision history of the patch series:

v1: http://gcc.gnu.org/ml/gcc-patches/2014-04/msg01148.html
(this was the full 89-patch patch series I originally posted)

v2: http://gcc.gnu.org/ml/gcc-patches/2014-04/msg01549.html
* eliminated the as_a_gimple_foo methods in favor of
as_a <gimple_foo>, using is-a.h changes here:
http://gcc.gnu.org/ml/gcc-patches/2014-04/msg01439.html
(this merely does it for the GIMPLE_SWITCH initial patch,
as a proof-of-concept of how the rest of the series would
be reworked).

v3: http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00128.html
* eliminated "gimple" and "const_gimple" typedefs in favor
of "gimple_stmt *" and "const gimple_stmt *".
(likewise, just for the GIMPLE_SWITCH initial patch)

v4 (this one):
* eliminate "gimple" and "const_gimple" typedefs in favor
of "gimple *" and "const gimple *".
* rename "gimple_statement_with_foo" to "gimple_with_foo"
* rename "gimple_statement_bar" to "gbar"
as per:
http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00349.html
(see http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00346.html
for a diagram of the resulting class hierarchy).

As per v2 onwards, this patch series only covers the initial
GIMPLE_SWITCH part of the original patch series.

As before, this has a prerequisite on a gengtype fix:

"[PATCH] gengtype: Support explicit pointers in template arguments":
http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00003.html
(which I've reworking to merge in the changes from the wide-int
branch, and have bootstrapped that underneath the following
patches; solo bootstrap is in progress)

The "gfoo" type names are pleasantly terse, though I'm a little unhappy
about how they no longer match the prefix of the accessor functions e.g.
gimple_switch_num_labels (const gswitch *gs)
vs
gimple_switch_num_labels (const gimple_switch *gs)
But it works.

The patches are similar to those in v3:

Patch 1:
This is the handwritten conversion of "gimple" to "gimple *"
Jeff approved an envisaged update to the v3 version of this:
http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00563.html
That's going to mean a ton of trivial fixups to this patch.
With those fixes, this patch is approved.
and this patch does indeed have a ton of such trivial fixups.

Patch 2:
This is the autogenerated part of the above.
As per patch 1, Jeff approved an earlier version of this:
http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00564.html
(It's likely to bit-rot before 4.9.1 of course)

Patch 3: is the example of porting "Patch 02/89" from the original
series: introducing a class for GIMPLE_SWITCH, now called
"gswitch".
Jeff approved an earlier version of this:
http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00565.html
OK after the "gimple_stmt" to "gimple" change referenced in
prior messages related to this patchkit.
The additional change here relative to that patch is the renaming
of the new class from "gimple_switch" to "gswitch".

Successfully bootstrapped&regrtested on x86_64-unknown-linux-gnu
(Fedora 20) (on top of the reworked dependent patch mentioned above; equal
results compared to a control build of r210222 (in particular, this is
after the wide-int merge).

I believe that the approvals from the earlier reviews cover this
iteration of the patches; I'm posting them here for reference (and in
case of hard drive failure...).

My plan is, assuming no-one complains loudly,
(A) to update the rest of the patch series to this new approach (and to
post the results for reference; Jeff has reviewed them).
(B) to commit the patches to trunk after 4.9.1 is released (re-testing
each patch appropriately, of course).

Dave


David Malcolm (3):
Handwritten part of conversion of "gimple" to "gimple *"
Autogenerated part of conversion of "gimple" to "gimple *"
Introduce gswitch and use it in various places

gcc/asan.c | 36 +-
gcc/builtins.c | 10 +-
gcc/builtins.h | 2 +-
gcc/c-family/c-gimplify.c | 4 +-
gcc/calls.c | 2 +-
gcc/calls.h | 2 +-
gcc/cfgexpand.c | 48 +-
gcc/cfgexpand.h | 2 +-
gcc/cfgloop.c | 2 +-
gcc/cfgloop.h | 2 +-
gcc/cfgloopmanip.c | 4 +-
gcc/cgraph.c | 32 +-
gcc/cgraph.h | 24 +-
gcc/cgraphbuild.c | 12 +-
gcc/cgraphclones.c | 8 +-
gcc/cgraphunit.c | 12 +-
gcc/config/aarch64/aarch64-builtins.c | 4 +-
gcc/config/alpha/alpha.c | 14 +-
gcc/config/i386/i386.c | 14 +-
gcc/config/rs6000/rs6000.c | 4 +-
gcc/coretypes.h | 10 +-
gcc/cp/cp-gimplify.c | 2 +-
gcc/doc/gimple.texi | 824 +++++++++------
gcc/dumpfile.c | 4 +-
gcc/dumpfile.h | 4 +-
gcc/except.h | 2 +-
gcc/expr.c | 28 +-
gcc/expr.h | 2 +-
gcc/fold-const.c | 2 +-
gcc/fold-const.h | 2 +-
gcc/gdbhooks.py | 4 +-
gcc/ggc.h | 6 +-
gcc/gimple-builder.c | 26 +-
gcc/gimple-builder.h | 16 +-
gcc/gimple-fold.c | 58 +-
gcc/gimple-fold.h | 8 +-
gcc/gimple-iterator.c | 36 +-
gcc/gimple-iterator.h | 22 +-
gcc/gimple-low.c | 30 +-
gcc/gimple-low.h | 2 +-
gcc/gimple-pretty-print.c | 110 +-
gcc/gimple-pretty-print.h | 12 +-
gcc/gimple-ssa-isolate-paths.c | 14 +-
gcc/gimple-ssa-strength-reduction.c | 92 +-
gcc/gimple-ssa.h | 22 +-
gcc/gimple-streamer-in.c | 12 +-
gcc/gimple-streamer-out.c | 8 +-
gcc/gimple-walk.c | 18 +-
gcc/gimple-walk.h | 12 +-
gcc/gimple.c | 313 +++---
gcc/gimple.h | 1655 ++++++++++++++----------------
gcc/gimplify-me.c | 4 +-
gcc/gimplify-me.h | 2 +-
gcc/gimplify.c | 102 +-
gcc/gimplify.h | 12 +-
gcc/graphite-poly.c | 8 +-
gcc/graphite-scop-detection.c | 20 +-
gcc/graphite-sese-to-poly.c | 168 +--
gcc/gsstruct.def | 52 +-
gcc/internal-fn.c | 40 +-
gcc/internal-fn.h | 2 +-
gcc/ipa-inline-analysis.c | 45 +-
gcc/ipa-inline.c | 4 +-
gcc/ipa-profile.c | 2 +-
gcc/ipa-prop.c | 80 +-
gcc/ipa-prop.h | 6 +-
gcc/ipa-pure-const.c | 12 +-
gcc/ipa-ref.c | 10 +-
gcc/ipa-ref.h | 12 +-
gcc/ipa-split.c | 40 +-
gcc/java/java-gimplify.c | 2 +-
gcc/lto-streamer-in.c | 16 +-
gcc/lto-streamer-out.c | 6 +-
gcc/omp-low.c | 253 ++---
gcc/passes.c | 4 +-
gcc/predict.c | 32 +-
gcc/profile.c | 8 +-
gcc/sese.c | 18 +-
gcc/sese.h | 8 +-
gcc/ssa-iterators.h | 42 +-
gcc/stmt.c | 4 +-
gcc/system.h | 2 +-
gcc/target.def | 2 +-
gcc/testsuite/g++.dg/plugin/selfassign.c | 8 +-
gcc/testsuite/gcc.dg/plugin/selfassign.c | 8 +-
gcc/tracer.c | 4 +-
gcc/trans-mem.c | 114 +-
gcc/trans-mem.h | 2 +-
gcc/tree-affine.c | 2 +-
gcc/tree-call-cdce.c | 50 +-
gcc/tree-cfg.c | 277 ++---
gcc/tree-cfg.h | 22 +-
gcc/tree-cfgcleanup.c | 28 +-
gcc/tree-cfgcleanup.h | 2 +-
gcc/tree-chrec.c | 10 +-
gcc/tree-chrec.h | 6 +-
gcc/tree-complex.c | 34 +-
gcc/tree-core.h | 4 +-
gcc/tree-data-ref.c | 14 +-
gcc/tree-data-ref.h | 8 +-
gcc/tree-dfa.c | 16 +-
gcc/tree-dfa.h | 2 +-
gcc/tree-eh.c | 198 ++--
gcc/tree-eh.h | 38 +-
gcc/tree-emutls.c | 8 +-
gcc/tree-if-conv.c | 46 +-
gcc/tree-inline.c | 105 +-
gcc/tree-inline.h | 6 +-
gcc/tree-into-ssa.c | 62 +-
gcc/tree-into-ssa.h | 4 +-
gcc/tree-loop-distribution.c | 66 +-
gcc/tree-nested.c | 32 +-
gcc/tree-nrv.c | 8 +-
gcc/tree-object-size.c | 28 +-
gcc/tree-outof-ssa.c | 26 +-
gcc/tree-outof-ssa.h | 4 +-
gcc/tree-parloops.c | 52 +-
gcc/tree-pass.h | 6 +-
gcc/tree-phinodes.c | 53 +-
gcc/tree-phinodes.h | 14 +-
gcc/tree-predcom.c | 62 +-
gcc/tree-profile.c | 32 +-
gcc/tree-scalar-evolution.c | 72 +-
gcc/tree-scalar-evolution.h | 2 +-
gcc/tree-sra.c | 62 +-
gcc/tree-ssa-alias.c | 38 +-
gcc/tree-ssa-alias.h | 16 +-
gcc/tree-ssa-ccp.c | 48 +-
gcc/tree-ssa-coalesce.c | 10 +-
gcc/tree-ssa-copy.c | 14 +-
gcc/tree-ssa-copyrename.c | 2 +-
gcc/tree-ssa-dce.c | 40 +-
gcc/tree-ssa-dom.c | 90 +-
gcc/tree-ssa-dom.h | 2 +-
gcc/tree-ssa-dse.c | 10 +-
gcc/tree-ssa-forwprop.c | 154 +--
gcc/tree-ssa-ifcombine.c | 20 +-
gcc/tree-ssa-live.c | 18 +-
gcc/tree-ssa-loop-ch.c | 6 +-
gcc/tree-ssa-loop-im.c | 70 +-
gcc/tree-ssa-loop-ivcanon.c | 20 +-
gcc/tree-ssa-loop-ivopts.c | 68 +-
gcc/tree-ssa-loop-manip.c | 32 +-
gcc/tree-ssa-loop-niter.c | 56 +-
gcc/tree-ssa-loop-niter.h | 4 +-
gcc/tree-ssa-loop-prefetch.c | 16 +-
gcc/tree-ssa-loop-unswitch.c | 8 +-
gcc/tree-ssa-loop.h | 2 +-
gcc/tree-ssa-math-opts.c | 90 +-
gcc/tree-ssa-operands.c | 42 +-
gcc/tree-ssa-operands.h | 10 +-
gcc/tree-ssa-phiopt.c | 88 +-
gcc/tree-ssa-phiprop.c | 18 +-
gcc/tree-ssa-pre.c | 52 +-
gcc/tree-ssa-propagate.c | 46 +-
gcc/tree-ssa-propagate.h | 14 +-
gcc/tree-ssa-reassoc.c | 176 ++--
gcc/tree-ssa-sccvn.c | 58 +-
gcc/tree-ssa-sccvn.h | 8 +-
gcc/tree-ssa-sink.c | 22 +-
gcc/tree-ssa-strlen.c | 42 +-
gcc/tree-ssa-structalias.c | 44 +-
gcc/tree-ssa-tail-merge.c | 40 +-
gcc/tree-ssa-ter.c | 12 +-
gcc/tree-ssa-threadedge.c | 46 +-
gcc/tree-ssa-threadedge.h | 4 +-
gcc/tree-ssa-threadupdate.c | 12 +-
gcc/tree-ssa-uncprop.c | 12 +-
gcc/tree-ssa-uninit.c | 78 +-
gcc/tree-ssa.c | 42 +-
gcc/tree-ssa.h | 4 +-
gcc/tree-ssanames.c | 8 +-
gcc/tree-ssanames.h | 16 +-
gcc/tree-stdarg.c | 12 +-
gcc/tree-switch-conversion.c | 50 +-
gcc/tree-tailcall.c | 30 +-
gcc/tree-vect-data-refs.c | 100 +-
gcc/tree-vect-generic.c | 22 +-
gcc/tree-vect-loop-manip.c | 62 +-
gcc/tree-vect-loop.c | 174 ++--
gcc/tree-vect-patterns.c | 194 ++--
gcc/tree-vect-slp.c | 124 +--
gcc/tree-vect-stmts.c | 244 ++---
gcc/tree-vectorizer.c | 22 +-
gcc/tree-vectorizer.h | 116 +--
gcc/tree-vrp.c | 152 +--
gcc/tree.c | 4 +-
gcc/tree.h | 4 +-
gcc/tsan.c | 12 +-
gcc/ubsan.c | 20 +-
gcc/value-prof.c | 96 +-
gcc/value-prof.h | 26 +-
gcc/vtable-verify.c | 10 +-
193 files changed, 4729 insertions(+), 4682 deletions(-)
--
1.8.5.3
David Malcolm
2014-05-12 21:36:02 UTC
Permalink
gcc/
* gimple.h (gswitch): New subclass of gimple_stmt_with_ops,
adding the invariant that stmt->code == GIMPLE_SWITCH.
(is_a_helper <gswitch *>::test): New.
(is_a_helper <const gswitch *>::test): New.
(gimple_try): Likewise.

* coretypes.h (gswitch): Add forward declaration here.

* gdbhooks.py (build_pretty_printer): Add gswitch,
using the gimple printer.

* gimple.c (gimple_build_switch_nlabels): Return a gswitch
rather than just a gimple.
(gimple_build_switch): Likewise.
* gimple.h (gimple_build_switch_nlabels): Likewise.
(gimple_build_switch): Likewise.

* gimple.h (gimple_switch_num_labels): Update type-signature to
require a gswitch rather than just a gimple.
(gimple_switch_set_num_labels): Likewise.
(gimple_switch_set_index): Likewise.
(gimple_switch_label): Likewise.
(gimple_switch_set_label): Likewise.
(gimple_switch_default_label): Likewise.
(gimple_switch_set_default_label): Likewise.
* expr.h (expand_case): Likewise.
* gimple-pretty-print.c (dump_gimple_call): Likewise.
* stmt.c (compute_cases_per_edge): Likewise.
(expand_case): Likewise.
* tree-cfg.h (group_case_labels_stmt): Likewise.
* tree-cfg.c (make_gimple_switch_edges): Likewise.
(find_taken_edge_switch_expr) Likewise.
(find_case_label_for_value) Likewise.
(get_cases_for_edge): Likewise.
(group_case_labels_stmt): Likewise.
(verify_gimple_switch): Likewise.
* tree-eh.c (verify_norecord_switch_expr): Likewise.
* tree-eh.c (lower_eh_constructs_2): Likewise.
* tree-loop-distribution.c (generate_loops_for_partition): Likewise.
* tree-ssa-dom.c (record_edge_info): Likewise.
* tree-ssa-forwprop.c (simplify_gimple_switch_label_vec): Likewise.
(simplify_gimple_switch): Likewise.
* tree-switch-conversion.c (emit_case_bit_tests): Likewise.
(collect_switch_conv_info): Likewise.
(build_constructors): Likewise.
(array_value_type): Likewise.
(build_one_array): Likewise.
(build_arrays): Likewise.
(gen_inbound_check): Likewise.
* tree-vrp.c (find_switch_asserts): Likewise.
(find_case_label_range): Likewise.
(find_case_label_ranges): Likewise.
(vrp_visit_switch_stmt): Likewise.
(simplify_switch_using_ranges): Likewise.

* tree-vrp.c (switch_update): Strengthen field "stmt" from being
merely a gimple * to being a gswitch *.

* cfgexpand.c (expand_gimple_stmt_1): Add checked cast to
gswitch in regions where the stmt code has been tested as
GIMPLE_SWITCH.
* gimple-pretty-print.c (pp_gimple_stmt_1): Likewise.
* tree-cfg.c (make_edges): Likewise.
(end_recording_case_labels): Likewise.
(cleanup_dead_labels): Likewise.
(cleanup_dead_labels): Likewise.
(group_case_labels): Likewise.
(find_taken_edge): Likewise.
(find_case_label_for_value): Likewise.
(verify_gimple_stmt): Likewise.
(gimple_verify_flow_info): Likewise.
(gimple_redirect_edge_and_branch): Likewise.
* tree-inline.c (estimate_num_insns): Likewise.
* tree-ssa-forwprop.c (ssa_forward_propagate_and_combine): Likewise.
* tree-ssa-uncprop.c (associate_equivalences_with_edges): Likewise.
* tree-switch-conversion.c (do_switchconv): Likewise.
* tree-vrp.c (find_assert_locations_1): Likewise.
(vrp_visit_stmt): Likewise.
(simplify_stmt_using_ranges): Likewise.

* ipa-inline-analysis.c (set_switch_stmt_execution_predicate):
Introduce local "lastg" as a generic gimple, so that local "last"
can be of type gswitch once lastg's code has been verified.

* omp-low.c (diagnose_sb_2): Introduce switch_stmt local to handle
the GIMPLE_SWITCH case.

* tree-cfg.c (find_taken_edge_switch_expr): Add gswitch
argument, since the caller (find_taken_edge) has checked that
last_stmt is a switch.

* doc/gimple.texi (Class hierarchy of GIMPLE statements): Add
gswitch class.
(GIMPLE_SWITCH): Update signatures of accessor functions to reflect
above gimple to gswitch changes.
---
gcc/cfgexpand.c | 2 +-
gcc/coretypes.h | 5 ++++
gcc/doc/gimple.texi | 34 ++++++++++++++-----------
gcc/expr.h | 2 +-
gcc/gdbhooks.py | 4 ++-
gcc/gimple-pretty-print.c | 4 +--
gcc/gimple.c | 11 +++++----
gcc/gimple.h | 44 ++++++++++++++++++++++++++-------
gcc/ipa-inline-analysis.c | 7 +++---
gcc/omp-low.c | 5 ++--
gcc/stmt.c | 4 +--
gcc/tree-cfg.c | 59 ++++++++++++++++++++++----------------------
gcc/tree-cfg.h | 2 +-
gcc/tree-eh.c | 4 +--
gcc/tree-inline.c | 21 +++++++++-------
gcc/tree-loop-distribution.c | 4 +--
gcc/tree-ssa-dom.c | 8 +++---
gcc/tree-ssa-forwprop.c | 6 ++---
gcc/tree-ssa-uncprop.c | 8 +++---
gcc/tree-switch-conversion.c | 18 +++++++-------
gcc/tree-vrp.c | 24 +++++++++---------
21 files changed, 160 insertions(+), 116 deletions(-)

diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 05d0f51..6daa929 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -3161,7 +3161,7 @@ expand_gimple_stmt_1 (gimple *stmt)
case GIMPLE_PREDICT:
break;
case GIMPLE_SWITCH:
- expand_case (stmt);
+ expand_case (as_a <gswitch *> (stmt));
break;
case GIMPLE_ASM:
expand_asm_stmt (stmt);
diff --git a/gcc/coretypes.h b/gcc/coretypes.h
index 9a1f172..5783b04 100644
--- a/gcc/coretypes.h
+++ b/gcc/coretypes.h
@@ -67,6 +67,11 @@ typedef const union tree_node *const_tree;
class gimple;
typedef gimple *gimple_seq;
struct gimple_stmt_iterator;
+
+/* Forward declarations of gimple subclasses.
+ Keep this in the same order as the corresponding codes in gimple.def. */
+class gswitch;
+
union section;
typedef union section section;
struct gcc_options;
diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi
index 54bad5d..088a498 100644
--- a/gcc/doc/gimple.texi
+++ b/gcc/doc/gimple.texi
@@ -311,12 +311,14 @@ kinds, along with their relationships to @code{GSS_} values (layouts) and
| | (no GSS layout)
| |
| + gimple_with_ops
- | | layout: GSS_WITH_OPS
- | | Used for 5 codes: GIMPLE_COND
- | | GIMPLE_DEBUG
- | | GIMPLE_GOTO
- | | GIMPLE_LABEL
- | | GIMPLE_SWITCH
+ | | | layout: GSS_WITH_OPS
+ | | | Used for 4 codes: GIMPLE_COND
+ | | | GIMPLE_DEBUG
+ | | | GIMPLE_GOTO
+ | | | GIMPLE_LABEL
+ | | |
+ | | + gswitch
+ | | code: GIMPLE_SWITCH
| |
| + gimple_with_memory_ops_base
| | layout: GSS_WITH_MEM_OPS_BASE
@@ -2252,7 +2254,7 @@ Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@subsection @code{GIMPLE_SWITCH}
@cindex @code{GIMPLE_SWITCH}

-@deftypefn {GIMPLE function} gimple *gimple_build_switch (tree index, @
+@deftypefn {GIMPLE function} gswitch *gimple_build_switch (tree index, @
tree default_label, @code{VEC}(tree,heap) *args)
Build a @code{GIMPLE_SWITCH} statement. @code{INDEX} is the index variable
to switch on, and @code{DEFAULT_LABEL} represents the default label.
@@ -2260,44 +2262,46 @@ to switch on, and @code{DEFAULT_LABEL} represents the default label.
non-default case labels. Each label is a tree of code @code{CASE_LABEL_EXPR}.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple *g)
+@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (@
+const gswitch *g)
Return the number of labels associated with the switch statement
@code{G}.
@end deftypefn

@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (@
-gimple *g, unsigned nlabels)
+gswitch *g, unsigned nlabels)
Set @code{NLABELS} to be the number of labels for the switch statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_switch_index (gimple *g)
+@deftypefn {GIMPLE function} tree gimple_switch_index (const gswitch *g)
Return the index variable used by the switch statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple *g, @
+@deftypefn {GIMPLE function} void gimple_switch_set_index (gswitch *g, @
tree index)
Set @code{INDEX} to be the index variable for switch statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_switch_label (gimple *g, @
+@deftypefn {GIMPLE function} tree gimple_switch_label (const gswitch *g, @
unsigned index)
Return the label numbered @code{INDEX}. The default label is 0, followed
by any labels in a switch statement.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple *g, @
+@deftypefn {GIMPLE function} void gimple_switch_set_label (gswitch *g, @
unsigned index, tree label)
Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
label.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple *g)
+@deftypefn {GIMPLE function} tree gimple_switch_default_label (@
+const gswitch *g)
Return the default label for a switch statement.
@end deftypefn

@deftypefn {GIMPLE function} void gimple_switch_set_default_label (@
-gimple *g, tree label)
+gswitch *g, tree label)
Set the default label for a switch statement.
@end deftypefn

diff --git a/gcc/expr.h b/gcc/expr.h
index 43cd3c9..e3634c3 100644
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -777,7 +777,7 @@ rtx get_personality_function (tree);
/* In stmt.c */

/* Expand a GIMPLE_SWITCH statement. */
-extern void expand_case (gimple *);
+extern void expand_case (gswitch *);

/* Like expand_case but special-case for SJLJ exception dispatching. */
extern void expand_sjlj_dispatch_table (rtx, vec<tree> );
diff --git a/gcc/gdbhooks.py b/gcc/gdbhooks.py
index a0d94bb..7838668 100644
--- a/gcc/gdbhooks.py
+++ b/gcc/gdbhooks.py
@@ -454,7 +454,9 @@ def build_pretty_printer():
'tree', TreePrinter)
pp.add_printer_for_types(['cgraph_node *'],
'cgraph_node', CGraphNodePrinter)
- pp.add_printer_for_types(['gimple *'],
+ pp.add_printer_for_types(['gimple *',
+ # Keep this in the same order as gimple.def:
+ 'gswitch *'],
'gimple',
GimplePrinter)
pp.add_printer_for_types(['basic_block', 'basic_block_def *'],
diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 205cccb..307b7d3 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -775,7 +775,7 @@ dump_gimple_call (pretty_printer *buffer, gimple *gs, int spc, int flags)
pp_gimple_stmt_1. */

static void
-dump_gimple_switch (pretty_printer *buffer, gimple *gs, int spc, int flags)
+dump_gimple_switch (pretty_printer *buffer, gswitch *gs, int spc, int flags)
{
unsigned int i;

@@ -2120,7 +2120,7 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple *gs, int spc, int flags)
break;

case GIMPLE_SWITCH:
- dump_gimple_switch (buffer, gs, spc, flags);
+ dump_gimple_switch (buffer, as_a <gswitch *> (gs), spc, flags);
break;

case GIMPLE_TRY:
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 281815c..25e0fb9 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -714,13 +714,14 @@ gimple_build_resx (int region)
NLABELS is the number of labels in the switch excluding the default.
DEFAULT_LABEL is the default label for the switch statement. */

-gimple *
+gswitch *
gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
{
/* nlabels + 1 default label + 1 index. */
gcc_checking_assert (default_label);
- gimple *p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
- 1 + 1 + nlabels);
+ gswitch *p =
+ as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
+ 1 + 1 + nlabels));
gimple_switch_set_index (p, index);
gimple_switch_set_default_label (p, default_label);
return p;
@@ -732,12 +733,12 @@ gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
DEFAULT_LABEL is the default label
ARGS is a vector of labels excluding the default. */

-gimple *
+gswitch *
gimple_build_switch (tree index, tree default_label, vec<tree> args)
{
unsigned i, nlabels = args.length ();

- gimple *p = gimple_build_switch_nlabels (nlabels, index, default_label);
+ gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);

/* Copy the labels from the vector to the switch statement. */
for (i = 0; i < nlabels; i++)
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 173f1b4..e1df705 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -764,6 +764,16 @@ enum gimple_statement_structure_enum {
};
#undef DEFGSSTRUCT

+/* A statement with the invariant that
+ stmt->code == GIMPLE_SWITCH
+ i.e. a switch statement. */
+
+struct GTY((tag("GSS_WITH_OPS")))
+ gswitch : public gimple_with_ops
+{
+ /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+};
+
template <>
template <>
inline bool
@@ -951,6 +961,14 @@ is_a_helper <gphi *>::test (gimple *gs)
template <>
template <>
inline bool
+is_a_helper <gswitch *>::test (gimple *gs)
+{
+ return gs->code == GIMPLE_SWITCH;
+}
+
+template <>
+template <>
+inline bool
is_a_helper <gtransaction *>::test (gimple *gs)
{
return gs->code == GIMPLE_TRANSACTION;
@@ -1143,6 +1161,14 @@ is_a_helper <const gphi *>::test (const gimple *gs)
template <>
template <>
inline bool
+is_a_helper <const gswitch *>::test (const gimple *gs)
+{
+ return gs->code == GIMPLE_SWITCH;
+}
+
+template <>
+template <>
+inline bool
is_a_helper <const gtransaction *>::test (const gimple *gs)
{
return gs->code == GIMPLE_TRANSACTION;
@@ -1193,8 +1219,8 @@ gtry *gimple_build_try (gimple_seq, gimple_seq,
enum gimple_try_flags);
gimple *gimple_build_wce (gimple_seq);
gimple *gimple_build_resx (int);
-gimple *gimple_build_switch_nlabels (unsigned, tree, tree);
-gimple *gimple_build_switch (tree, tree, vec<tree> );
+gswitch *gimple_build_switch_nlabels (unsigned, tree, tree);
+gswitch *gimple_build_switch (tree, tree, vec<tree> );
gimple *gimple_build_eh_dispatch (int);
gimple *gimple_build_debug_bind_stat (tree, tree, gimple *MEM_STAT_DECL);
#define gimple_build_debug_bind(var,val,stmt) \
@@ -3908,7 +3934,7 @@ gimple_eh_dispatch_set_region (gimple *gs, int region)
/* Return the number of labels associated with the switch statement GS. */

static inline unsigned
-gimple_switch_num_labels (const gimple *gs)
+gimple_switch_num_labels (const gswitch *gs)
{
unsigned num_ops;
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
@@ -3921,7 +3947,7 @@ gimple_switch_num_labels (const gimple *gs)
/* Set NLABELS to be the number of labels for the switch statement GS. */

static inline void
-gimple_switch_set_num_labels (gimple *g, unsigned nlabels)
+gimple_switch_set_num_labels (gswitch *g, unsigned nlabels)
{
GIMPLE_CHECK (g, GIMPLE_SWITCH);
gimple_set_num_ops (g, nlabels + 1);
@@ -3951,7 +3977,7 @@ gimple_switch_index_ptr (const gimple *gs)
/* Set INDEX to be the index variable for switch statement GS. */

static inline void
-gimple_switch_set_index (gimple *gs, tree index)
+gimple_switch_set_index (gswitch *gs, tree index)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
@@ -3963,7 +3989,7 @@ gimple_switch_set_index (gimple *gs, tree index)
labels in a switch statement. */

static inline tree
-gimple_switch_label (const gimple *gs, unsigned index)
+gimple_switch_label (const gswitch *gs, unsigned index)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
@@ -3973,7 +3999,7 @@ gimple_switch_label (const gimple *gs, unsigned index)
/* Set the label number INDEX to LABEL. 0 is always the default label. */

static inline void
-gimple_switch_set_label (gimple *gs, unsigned index, tree label)
+gimple_switch_set_label (gswitch *gs, unsigned index, tree label)
{
GIMPLE_CHECK (gs, GIMPLE_SWITCH);
gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1
@@ -3985,7 +4011,7 @@ gimple_switch_set_label (gimple *gs, unsigned index, tree label)
/* Return the default label for a switch statement. */

static inline tree
-gimple_switch_default_label (const gimple *gs)
+gimple_switch_default_label (const gswitch *gs)
{
tree label = gimple_switch_label (gs, 0);
gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
@@ -3995,7 +4021,7 @@ gimple_switch_default_label (const gimple *gs)
/* Set the default label for a switch statement. */

static inline void
-gimple_switch_set_default_label (gimple *gs, tree label)
+gimple_switch_set_default_label (gswitch *gs, tree label)
{
gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
gimple_switch_set_label (gs, 0, label);
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index db9fbf7..f54514a 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -1801,7 +1801,7 @@ set_switch_stmt_execution_predicate (struct ipa_node_params *info,
struct inline_summary *summary,
basic_block bb)
{
- gimple *last;
+ gimple *lastg;
tree op;
int index;
struct agg_position_info aggpos;
@@ -1810,9 +1810,10 @@ set_switch_stmt_execution_predicate (struct ipa_node_params *info,
size_t n;
size_t case_idx;

- last = last_stmt (bb);
- if (!last || gimple_code (last) != GIMPLE_SWITCH)
+ lastg = last_stmt (bb);
+ if (!lastg || gimple_code (lastg) != GIMPLE_SWITCH)
return;
+ gswitch *last = as_a <gswitch *> (lastg);
op = gimple_switch_index (last);
if (!unmodified_parm_or_parm_agg_item (info, last, op, &index, &aggpos))
return;
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index 004aa6d..4ae911a 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -10478,10 +10478,11 @@ diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,

case GIMPLE_SWITCH:
{
+ gswitch *switch_stmt = as_a <gswitch *> (stmt);
unsigned int i;
- for (i = 0; i < gimple_switch_num_labels (stmt); ++i)
+ for (i = 0; i < gimple_switch_num_labels (switch_stmt); ++i)
{
- tree lab = CASE_LABEL (gimple_switch_label (stmt, i));
+ tree lab = CASE_LABEL (gimple_switch_label (switch_stmt, i));
n = splay_tree_lookup (all_labels, (splay_tree_key) lab);
if (n && diagnose_sb_0 (gsi_p, context, (gimple *) n->value))
break;
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 23da44a..fd1db8a 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -1130,7 +1130,7 @@ reset_out_edges_aux (basic_block bb)
STMT. Record this information in the aux field of the edge. */

static inline void
-compute_cases_per_edge (gimple *stmt)
+compute_cases_per_edge (gswitch *stmt)
{
basic_block bb = gimple_bb (stmt);
reset_out_edges_aux (bb);
@@ -1152,7 +1152,7 @@ compute_cases_per_edge (gimple *stmt)
Generate the code to test it and jump to the right place. */

void
-expand_case (gimple *stmt)
+expand_case (gswitch *stmt)
{
tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE;
rtx default_label = NULL_RTX;
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 1e219d6..95c96ef 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -152,7 +152,7 @@ static void make_blocks (gimple_seq);
static void make_edges (void);
static void assign_discriminators (void);
static void make_cond_expr_edges (basic_block);
-static void make_gimple_switch_edges (basic_block);
+static void make_gimple_switch_edges (gswitch *, basic_block);
static bool make_goto_expr_edges (basic_block);
static void make_gimple_asm_edges (basic_block);
static edge gimple_redirect_edge_and_branch (edge, basic_block);
@@ -171,8 +171,8 @@ static bool gimple_can_merge_blocks_p (basic_block, basic_block);
static void remove_bb (basic_block);
static edge find_taken_edge_computed_goto (basic_block, tree);
static edge find_taken_edge_cond_expr (basic_block, tree);
-static edge find_taken_edge_switch_expr (basic_block, tree);
-static tree find_case_label_for_value (gimple *, tree);
+static edge find_taken_edge_switch_expr (gswitch *, basic_block, tree);
+static tree find_case_label_for_value (gswitch *, tree);

void
init_empty_tree_cfg_for_function (struct function *fn)
@@ -771,7 +771,7 @@ make_edges (void)
fallthru = false;
break;
case GIMPLE_SWITCH:
- make_gimple_switch_edges (bb);
+ make_gimple_switch_edges (as_a <gswitch *> (last), bb);
fallthru = false;
break;
case GIMPLE_RESX:
@@ -1096,7 +1096,7 @@ end_recording_case_labels (void)
{
gimple *stmt = last_stmt (bb);
if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
- group_case_labels_stmt (stmt);
+ group_case_labels_stmt (as_a <gswitch *> (stmt));
}
}
BITMAP_FREE (touched_switch_bbs);
@@ -1108,7 +1108,7 @@ end_recording_case_labels (void)
Otherwise return NULL. */

static tree
-get_cases_for_edge (edge e, gimple *t)
+get_cases_for_edge (edge e, gswitch *t)
{
void **slot;
size_t i, n;
@@ -1147,9 +1147,8 @@ get_cases_for_edge (edge e, gimple *t)
/* Create the edges for a GIMPLE_SWITCH starting at block BB. */

static void
-make_gimple_switch_edges (basic_block bb)
+make_gimple_switch_edges (gswitch *entry, basic_block bb)
{
- gimple *entry = last_stmt (bb);
size_t i, n;

n = gimple_switch_num_labels (entry);
@@ -1400,12 +1399,13 @@ cleanup_dead_labels (void)

case GIMPLE_SWITCH:
{
- size_t i, n = gimple_switch_num_labels (stmt);
+ gswitch *switch_stmt = as_a <gswitch *> (stmt);
+ size_t i, n = gimple_switch_num_labels (switch_stmt);

/* Replace all destination labels. */
for (i = 0; i < n; ++i)
{
- tree case_label = gimple_switch_label (stmt, i);
+ tree case_label = gimple_switch_label (switch_stmt, i);
label = CASE_LABEL (case_label);
new_label = main_block_label (label);
if (new_label != label)
@@ -1502,7 +1502,7 @@ cleanup_dead_labels (void)
Eg. three separate entries 1: 2: 3: become one entry 1..3: */

void
-group_case_labels_stmt (gimple *stmt)
+group_case_labels_stmt (gswitch *stmt)
{
int old_size = gimple_switch_num_labels (stmt);
int i, j, new_size = old_size;
@@ -1590,7 +1590,7 @@ group_case_labels (void)
{
gimple *stmt = last_stmt (bb);
if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
- group_case_labels_stmt (stmt);
+ group_case_labels_stmt (as_a <gswitch *> (stmt));
}
}

@@ -2055,8 +2055,8 @@ find_taken_edge (basic_block bb, tree val)
if (gimple_code (stmt) == GIMPLE_COND)
return find_taken_edge_cond_expr (bb, val);

- if (gimple_code (stmt) == GIMPLE_SWITCH)
- return find_taken_edge_switch_expr (bb, val);
+ if (gswitch *switch_stmt = dyn_cast <gswitch *> (stmt))
+ return find_taken_edge_switch_expr (switch_stmt, bb, val);

if (computed_goto_p (stmt))
{
@@ -2115,14 +2115,13 @@ find_taken_edge_cond_expr (basic_block bb, tree val)
NULL if any edge may be taken. */

static edge
-find_taken_edge_switch_expr (basic_block bb, tree val)
+find_taken_edge_switch_expr (gswitch *switch_stmt, basic_block bb,
+ tree val)
{
basic_block dest_bb;
edge e;
- gimple *switch_stmt;
tree taken_case;

- switch_stmt = last_stmt (bb);
taken_case = find_case_label_for_value (switch_stmt, val);
dest_bb = label_to_block (CASE_LABEL (taken_case));

@@ -2137,7 +2136,7 @@ find_taken_edge_switch_expr (basic_block bb, tree val)
sorted: We can do a binary search for a case matching VAL. */

static tree
-find_case_label_for_value (gimple *switch_stmt, tree val)
+find_case_label_for_value (gswitch *switch_stmt, tree val)
{
size_t low, high, n = gimple_switch_num_labels (switch_stmt);
tree default_case = gimple_switch_default_label (switch_stmt);
@@ -4264,7 +4263,7 @@ verify_gimple_goto (gimple *stmt)
is a problem, otherwise false. */

static bool
-verify_gimple_switch (gimple *stmt)
+verify_gimple_switch (gswitch *stmt)
{
unsigned int i, n;
tree elt, prev_upper_bound = NULL_TREE;
@@ -4446,7 +4445,7 @@ verify_gimple_stmt (gimple *stmt)
return verify_gimple_goto (stmt);

case GIMPLE_SWITCH:
- return verify_gimple_switch (stmt);
+ return verify_gimple_switch (as_a <gswitch *> (stmt));

case GIMPLE_RETURN:
return verify_gimple_return (stmt);
@@ -5179,26 +5178,27 @@ gimple_verify_flow_info (void)

case GIMPLE_SWITCH:
{
+ gswitch *switch_stmt = as_a <gswitch *> (stmt);
tree prev;
edge e;
size_t i, n;

- n = gimple_switch_num_labels (stmt);
+ n = gimple_switch_num_labels (switch_stmt);

/* Mark all the destination basic blocks. */
for (i = 0; i < n; ++i)
{
- tree lab = CASE_LABEL (gimple_switch_label (stmt, i));
+ tree lab = CASE_LABEL (gimple_switch_label (switch_stmt, i));
basic_block label_bb = label_to_block (lab);
gcc_assert (!label_bb->aux || label_bb->aux == (void *)1);
label_bb->aux = (void *)1;
}

/* Verify that the case labels are sorted. */
- prev = gimple_switch_label (stmt, 0);
+ prev = gimple_switch_label (switch_stmt, 0);
for (i = 1; i < n; ++i)
{
- tree c = gimple_switch_label (stmt, i);
+ tree c = gimple_switch_label (switch_stmt, i);
if (!CASE_LOW (c))
{
error ("found default case not at the start of "
@@ -5244,7 +5244,7 @@ gimple_verify_flow_info (void)
/* Check that we have all of them. */
for (i = 0; i < n; ++i)
{
- tree lab = CASE_LABEL (gimple_switch_label (stmt, i));
+ tree lab = CASE_LABEL (gimple_switch_label (switch_stmt, i));
basic_block label_bb = label_to_block (lab);

if (label_bb->aux != (void *)2)
@@ -5432,8 +5432,9 @@ gimple_redirect_edge_and_branch (edge e, basic_block dest)

case GIMPLE_SWITCH:
{
+ gswitch *switch_stmt = as_a <gswitch *> (stmt);
tree label = gimple_block_label (dest);
- tree cases = get_cases_for_edge (e, stmt);
+ tree cases = get_cases_for_edge (e, switch_stmt);

/* If we have a list of cases associated with E, then use it
as it's a lot faster than walking the entire case vector. */
@@ -5454,7 +5455,7 @@ gimple_redirect_edge_and_branch (edge e, basic_block dest)
to move all the cases associated with E to E2. */
if (e2)
{
- tree cases2 = get_cases_for_edge (e2, stmt);
+ tree cases2 = get_cases_for_edge (e2, switch_stmt);

CASE_CHAIN (last) = CASE_CHAIN (cases2);
CASE_CHAIN (cases2) = first;
@@ -5463,11 +5464,11 @@ gimple_redirect_edge_and_branch (edge e, basic_block dest)
}
else
{
- size_t i, n = gimple_switch_num_labels (stmt);
+ size_t i, n = gimple_switch_num_labels (switch_stmt);

for (i = 0; i < n; i++)
{
- tree elt = gimple_switch_label (stmt, i);
+ tree elt = gimple_switch_label (switch_stmt, i);
if (label_to_block (CASE_LABEL (elt)) == e->dest)
CASE_LABEL (elt) = label;
}
diff --git a/gcc/tree-cfg.h b/gcc/tree-cfg.h
index 2bcfedf..30f6fbf 100644
--- a/gcc/tree-cfg.h
+++ b/gcc/tree-cfg.h
@@ -32,7 +32,7 @@ extern void end_recording_case_labels (void);
extern basic_block label_to_block_fn (struct function *, tree);
#define label_to_block(t) (label_to_block_fn (cfun, t))
extern void cleanup_dead_labels (void);
-extern void group_case_labels_stmt (gimple *);
+extern void group_case_labels_stmt (gswitch *);
extern void group_case_labels (void);
extern void replace_uses_by (tree, tree);
extern basic_block single_noncomplex_succ (basic_block bb);
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index fd3057d..e6c9030 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -713,7 +713,7 @@ maybe_record_in_goto_queue (struct leh_state *state, gimple *stmt)
of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */

static void
-verify_norecord_switch_expr (struct leh_state *state, gimple *switch_expr)
+verify_norecord_switch_expr (struct leh_state *state, gswitch *switch_expr)
{
struct leh_tf_state *tf = state->tf;
size_t i, n;
@@ -2057,7 +2057,7 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
break;

case GIMPLE_SWITCH:
- verify_norecord_switch_expr (state, stmt);
+ verify_norecord_switch_expr (state, as_a <gswitch *> (stmt));
break;

case GIMPLE_TRY:
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 6f72d21..c6cf093 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -3811,15 +3811,18 @@ estimate_num_insns (gimple *stmt, eni_weights *weights)
break;

case GIMPLE_SWITCH:
- /* Take into account cost of the switch + guess 2 conditional jumps for
- each case label.
-
- TODO: once the switch expansion logic is sufficiently separated, we can
- do better job on estimating cost of the switch. */
- if (weights->time_based)
- cost = floor_log2 (gimple_switch_num_labels (stmt)) * 2;
- else
- cost = gimple_switch_num_labels (stmt) * 2;
+ {
+ gswitch *switch_stmt = as_a <gswitch *> (stmt);
+ /* Take into account cost of the switch + guess 2 conditional jumps for
+ each case label.
+
+ TODO: once the switch expansion logic is sufficiently separated, we can
+ do better job on estimating cost of the switch. */
+ if (weights->time_based)
+ cost = floor_log2 (gimple_switch_num_labels (switch_stmt)) * 2;
+ else
+ cost = gimple_switch_num_labels (switch_stmt) * 2;
+ }
break;

case GIMPLE_CALL:
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index 282d5db..8f08a34 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -685,10 +685,10 @@ generate_loops_for_partition (struct loop *loop, partition_t partition,
gimple_cond_make_false (stmt);
update_stmt (stmt);
}
- else if (gimple_code (stmt) == GIMPLE_SWITCH)
+ else if (gswitch *switch_stmt = dyn_cast <gswitch *> (stmt))
{
gimple_switch_set_index
- (stmt, CASE_LOW (gimple_switch_label (stmt, 1)));
+ (switch_stmt, CASE_LOW (gimple_switch_label (switch_stmt, 1)));
update_stmt (stmt);
}
else
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 7683fb6..8abee2f 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -1782,21 +1782,21 @@ record_edge_info (basic_block bb)
gimple *stmt = gsi_stmt (gsi);
location_t loc = gimple_location (stmt);

- if (gimple_code (stmt) == GIMPLE_SWITCH)
+ if (gswitch *switch_stmt = dyn_cast <gswitch *> (stmt))
{
- tree index = gimple_switch_index (stmt);
+ tree index = gimple_switch_index (switch_stmt);

if (TREE_CODE (index) == SSA_NAME)
{
int i;
- int n_labels = gimple_switch_num_labels (stmt);
+ int n_labels = gimple_switch_num_labels (switch_stmt);
tree *info = XCNEWVEC (tree, last_basic_block_for_fn (cfun));
edge e;
edge_iterator ei;

for (i = 0; i < n_labels; i++)
{
- tree label = gimple_switch_label (stmt, i);
+ tree label = gimple_switch_label (switch_stmt, i);
basic_block target_bb = label_to_block (CASE_LABEL (label));
if (CASE_HIGH (label)
|| !CASE_LOW (label)
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index d990100..0b68e07 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -1284,7 +1284,7 @@ simplify_not_neg_expr (gimple_stmt_iterator *gsi_p)
have values outside the range of the new type. */

static void
-simplify_gimple_switch_label_vec (gimple *stmt, tree index_type)
+simplify_gimple_switch_label_vec (gswitch *stmt, tree index_type)
{
unsigned int branch_num = gimple_switch_num_labels (stmt);
auto_vec<tree> labels (branch_num);
@@ -1354,7 +1354,7 @@ simplify_gimple_switch_label_vec (gimple *stmt, tree index_type)
the condition which we may be able to optimize better. */

static bool
-simplify_gimple_switch (gimple *stmt)
+simplify_gimple_switch (gswitch *stmt)
{
/* The optimization that we really care about is removing unnecessary
casts. That will let us do much better in propagating the inferred
@@ -3811,7 +3811,7 @@ pass_forwprop::execute (function *fun)
}

case GIMPLE_SWITCH:
- changed = simplify_gimple_switch (stmt);
+ changed = simplify_gimple_switch (as_a <gswitch *> (stmt));
break;

case GIMPLE_COND:
diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
index 4c196e1..9b0f9d3 100644
--- a/gcc/tree-ssa-uncprop.c
+++ b/gcc/tree-ssa-uncprop.c
@@ -171,14 +171,14 @@ associate_equivalences_with_edges (void)
/* For a SWITCH_EXPR, a case label which represents a single
value and which is the only case label which reaches the
target block creates an equivalence. */
- else if (gimple_code (stmt) == GIMPLE_SWITCH)
+ else if (gswitch *switch_stmt = dyn_cast <gswitch *> (stmt))
{
- tree cond = gimple_switch_index (stmt);
+ tree cond = gimple_switch_index (switch_stmt);

if (TREE_CODE (cond) == SSA_NAME
&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (cond))
{
- int i, n_labels = gimple_switch_num_labels (stmt);
+ int i, n_labels = gimple_switch_num_labels (switch_stmt);
tree *info = XCNEWVEC (tree, last_basic_block_for_fn (cfun));

/* Walk over the case label vector. Record blocks
@@ -186,7 +186,7 @@ associate_equivalences_with_edges (void)
a single value. */
for (i = 0; i < n_labels; i++)
{
- tree label = gimple_switch_label (stmt, i);
+ tree label = gimple_switch_label (switch_stmt, i);
basic_block bb = label_to_block (CASE_LABEL (label));

if (CASE_HIGH (label)
diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c
index f5de6d9..ece86e5 100644
--- a/gcc/tree-switch-conversion.c
+++ b/gcc/tree-switch-conversion.c
@@ -299,7 +299,7 @@ case_bit_test_cmp (const void *p1, const void *p2)
node targets. */

static void
-emit_case_bit_tests (gimple *swtch, tree index_expr,
+emit_case_bit_tests (gswitch *swtch, tree index_expr,
tree minval, tree range)
{
struct case_bit_test test[MAX_CASE_BIT_TESTS];
@@ -615,7 +615,7 @@ struct switch_conv_info
/* Collect information about GIMPLE_SWITCH statement SWTCH into INFO. */

static void
-collect_switch_conv_info (gimple *swtch, struct switch_conv_info *info)
+collect_switch_conv_info (gswitch *swtch, struct switch_conv_info *info)
{
unsigned int branch_num = gimple_switch_num_labels (swtch);
tree min_case, max_case;
@@ -859,7 +859,7 @@ gather_default_values (tree default_case, struct switch_conv_info *info)
order of phi nodes. SWTCH is the switch statement being converted. */

static void
-build_constructors (gimple *swtch, struct switch_conv_info *info)
+build_constructors (gswitch *swtch, struct switch_conv_info *info)
{
unsigned i, branch_num = gimple_switch_num_labels (swtch);
tree pos = info->range_min;
@@ -953,7 +953,7 @@ constructor_contains_same_values_p (vec<constructor_elt, va_gc> *vec)
all the constants. */

static tree
-array_value_type (gimple *swtch, tree type, int num,
+array_value_type (gswitch *swtch, tree type, int num,
struct switch_conv_info *info)
{
unsigned int i, len = vec_safe_length (info->constructors[num]);
@@ -1030,7 +1030,7 @@ array_value_type (gimple *swtch, tree type, int num,
new array. */

static void
-build_one_array (gimple *swtch, int num, tree arr_index_type, gimple *phi,
+build_one_array (gswitch *swtch, int num, tree arr_index_type, gimple *phi,
tree tidx, struct switch_conv_info *info)
{
tree name, cst;
@@ -1096,7 +1096,7 @@ build_one_array (gimple *swtch, int num, tree arr_index_type, gimple *phi,
them. */

static void
-build_arrays (gimple *swtch, struct switch_conv_info *info)
+build_arrays (gswitch *swtch, struct switch_conv_info *info)
{
tree arr_index_type;
tree tidx, sub, utype;
@@ -1217,7 +1217,7 @@ fix_phi_nodes (edge e1f, edge e2f, basic_block bbf,
*/

static void
-gen_inbound_check (gimple *swtch, struct switch_conv_info *info)
+gen_inbound_check (gswitch *swtch, struct switch_conv_info *info)
{
tree label_decl1 = create_artificial_label (UNKNOWN_LOCATION);
tree label_decl2 = create_artificial_label (UNKNOWN_LOCATION);
@@ -1337,7 +1337,7 @@ gen_inbound_check (gimple *swtch, struct switch_conv_info *info)
conversion failed. */

static const char *
-process_switch (gimple *swtch)
+process_switch (gswitch *swtch)
{
struct switch_conv_info info;

@@ -1473,7 +1473,7 @@ pass_convert_switch::execute (function *fun)
putc ('\n', dump_file);
}

- failure_reason = process_switch (stmt);
+ failure_reason = process_switch (as_a <gswitch *> (stmt));
if (! failure_reason)
{
if (dump_file)
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 55576f9..0978d3d 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -169,7 +169,7 @@ static bool values_propagated;
static int *vr_phi_edge_counts;

typedef struct {
- gimple *stmt;
+ gswitch *stmt;
tree vec;
} switch_update;

@@ -5535,7 +5535,7 @@ compare_case_labels (const void *p1, const void *p2)
list of assertions for the corresponding operands. */

static bool
-find_switch_asserts (basic_block bb, gimple *last)
+find_switch_asserts (basic_block bb, gswitch *last)
{
bool need_assert;
gimple_stmt_iterator bsi;
@@ -5706,7 +5706,7 @@ find_assert_locations_1 (basic_block bb, sbitmap live)
if (last
&& gimple_code (last) == GIMPLE_SWITCH
&& !ZERO_SSA_OPERANDS (last, SSA_OP_USE))
- need_assert |= find_switch_asserts (bb, last);
+ need_assert |= find_switch_asserts (bb, as_a <gswitch *> (last));

/* Traverse all the statements in BB marking used names and looking
for statements that may infer assertions for their used operands. */
@@ -7187,7 +7187,7 @@ vrp_visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
returned. */

static bool
-find_case_label_index (gimple *stmt, size_t start_idx, tree val, size_t *idx)
+find_case_label_index (gswitch *stmt, size_t start_idx, tree val, size_t *idx)
{
size_t n = gimple_switch_num_labels (stmt);
size_t low, high;
@@ -7237,7 +7237,7 @@ find_case_label_index (gimple *stmt, size_t start_idx, tree val, size_t *idx)
Returns true if the default label is not needed. */

static bool
-find_case_label_range (gimple *stmt, tree min, tree max, size_t *min_idx,
+find_case_label_range (gswitch *stmt, tree min, tree max, size_t *min_idx,
size_t *max_idx)
{
size_t i, j;
@@ -7293,7 +7293,7 @@ find_case_label_range (gimple *stmt, tree min, tree max, size_t *min_idx,
Returns true if the default label is not needed. */

static bool
-find_case_label_ranges (gimple *stmt, value_range_t *vr, size_t *min_idx1,
+find_case_label_ranges (gswitch *stmt, value_range_t *vr, size_t *min_idx1,
size_t *max_idx1, size_t *min_idx2,
size_t *max_idx2)
{
@@ -7371,7 +7371,7 @@ find_case_label_ranges (gimple *stmt, value_range_t *vr, size_t *min_idx1,
SSA_PROP_VARYING. */

static enum ssa_prop_result
-vrp_visit_switch_stmt (gimple *stmt, edge *taken_edge_p)
+vrp_visit_switch_stmt (gswitch *stmt, edge *taken_edge_p)
{
tree op, val;
value_range_t *vr;
@@ -7486,8 +7486,8 @@ vrp_visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
return vrp_visit_assignment_or_call (stmt, output_p);
else if (gimple_code (stmt) == GIMPLE_COND)
return vrp_visit_cond_stmt (stmt, taken_edge_p);
- else if (gimple_code (stmt) == GIMPLE_SWITCH)
- return vrp_visit_switch_stmt (stmt, taken_edge_p);
+ else if (gswitch *switch_stmt = dyn_cast <gswitch *> (stmt))
+ return vrp_visit_switch_stmt (switch_stmt, taken_edge_p);

/* All other statements produce nothing of interest for VRP, so mark
their outputs varying and prevent further simulation. */
@@ -8955,7 +8955,7 @@ simplify_cond_using_ranges (gimple *stmt)
argument. */

static bool
-simplify_switch_using_ranges (gimple *stmt)
+simplify_switch_using_ranges (gswitch *stmt)
{
tree op = gimple_switch_index (stmt);
value_range_t *vr;
@@ -9349,8 +9349,8 @@ simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
}
else if (gimple_code (stmt) == GIMPLE_COND)
return simplify_cond_using_ranges (stmt);
- else if (gimple_code (stmt) == GIMPLE_SWITCH)
- return simplify_switch_using_ranges (stmt);
+ else if (gswitch *switch_stmt = dyn_cast <gswitch *> (stmt))
+ return simplify_switch_using_ranges (switch_stmt);
else if (is_gimple_call (stmt)
&& gimple_call_internal_p (stmt))
return simplify_internal_call_using_ranges (gsi, stmt);
--
1.8.5.3
David Malcolm
2014-05-12 21:36:01 UTC
Permalink
This patch is 1.1MB in size, so I've uploaded it to:

http://dmalcolm.fedorapeople.org/gcc/large-patches/79f640b7d6d8f569d7c377a1373986323b3cbd9f-0002-Autogenerated-part-of-conversion-of-gimple-to-gimple.patch

ChangeLog follows:

gcc/

Patch autogenerated by rename_gimple.py from
https://github.com/davidmalcolm/gcc-refactoring-scripts
revision d0dcc1bc64a800765492e0c76ba714090414f555

* asan.c (has_mem_ref_been_instrumented): Replace "gimple" typedef
with "gimple *".
(get_mem_ref_of_assignment): Likewise.
(get_mem_refs_of_builtin_call): Likewise.
(create_cond_insert_point): Likewise.
(build_check_stmt): Likewise.
(instrument_mem_region_access): Likewise.
(instrument_strlen_call): Likewise.
(instrument_builtin_call): Likewise.
(maybe_instrument_assignment): Likewise.
(maybe_instrument_call): Likewise.
(transform_statements): Likewise.
(make_pass_asan_O0): Likewise.
* builtins.c (validate_arg): Likewise.
(do_mpc_arg2): Likewise.
(gimple_fold_builtin_sprintf_chk): Likewise.
(gimple_fold_builtin_snprintf_chk): Likewise.
(gimple_fold_builtin_varargs): Likewise.
* builtins.h (validate_gimple_arglist): Likewise.
* calls.c (setjmp_call_p): Likewise.
* calls.h (gimple_alloca_call_p): Likewise.
* cfgexpand.c (Copyright): Likewise.
(gimple_assign_rhs_to_tree): Likewise.
(stack_var_conflict_p): Likewise.
(visit_op): Likewise.
(add_scope_conflicts_1): Likewise.
(expand_used_vars): Likewise.
(label_rtx_for_bb): Likewise.
(maybe_cleanup_end_of_block): Likewise.
(expand_gimple_cond): Likewise.
(mark_transaction_restart_calls): Likewise.
(expand_call_stmt): Likewise.
(expand_asm_operands): Likewise.
(expand_return): Likewise.
(expand_gimple_stmt_1): Likewise.
(expand_gimple_stmt): Likewise.
(expand_debug_expr): Likewise.
(expand_gimple_basic_block): Likewise.
(discover_nonconstant_array_refs): Likewise.
* cfgexpand.h (gimple_assign_rhs_to_tree): Likewise.
* cfgloop.c (find_subloop_latch_edge_by_ivs): Likewise.
* cfgloop.h (GTY): Likewise.
* cfgloopmanip.c (create_empty_if_region_on_edge): Likewise.
(create_empty_loop_on_edge): Likewise.
* cgraph.c (cgraph_add_edge_to_call_site_hash): Likewise.
(cgraph_edge): Likewise.
(cgraph_set_call_stmt): Likewise.
(cgraph_create_edge_1): Likewise.
(cgraph_allocate_init_indirect_info): Likewise.
(cgraph_make_edge_direct): Likewise.
(cgraph_redirect_edge_call_stmt_to_callee): Likewise.
(cgraph_update_edges_for_call_stmt_node): Likewise.
(verify_edge_count_and_frequency): Likewise.
(verify_cgraph_node): Likewise.
(cgraph_get_body): Likewise.
(gimple_check_call_args): Likewise.
* cgraph.h (delete_function_version): Likewise.
(cgraph_create_edge): Likewise.
(cgraph_create_indirect_edge): Likewise.
(cgraph_edge): Likewise.
(cgraph_set_call_stmt): Likewise.
(cgraph_update_edges_for_call_stmt): Likewise.
(cgraph_remove_node_duplication_hook): Likewise.
(cgraph_turn_edge_to_speculative): Likewise.
* cgraphbuild.c (compute_call_stmt_bb_frequency): Likewise.
(mark_address): Likewise.
(mark_load): Likewise.
(mark_store): Likewise.
(ipa_record_stmt_references): Likewise.
(rebuild_cgraph_edges): Likewise.
* cgraphclones.c (function): Likewise.
(cgraph_find_replacement_node): Likewise.
(cgraph_set_call_stmt_including_clones): Likewise.
* cgraphunit.c (thunk_adjust): Likewise.
(expand_thunk): Likewise.
* config/aarch64/aarch64-builtins.c (aarch64_gimple_fold_builtin):
Likewise.
* config/alpha/alpha.c (alpha_build_builtin_va_list): Likewise.
(va_list_skip_additions): Likewise.
(alpha_stdarg_optimize_hook): Likewise.
* config/i386/i386.c (add_condition_to_bb): Likewise.
(dispatch_function_versions): Likewise.
(ix86_expand_builtin): Likewise.
* config/rs6000/rs6000.c (rs6000_density_test): Likewise.
(rs6000_gimplify_va_arg): Likewise.
* dumpfile.c (dump_loc): Likewise.
(dump_gimple_stmt): Likewise.
* dumpfile.h (dump_gimple_stmt_loc): Likewise.
(dump_gimple_stmt): Likewise.
* except.h (finish_eh_generation): Likewise.
* expr.c (use_group_regs): Likewise.
(get_def_for_expr): Likewise.
(get_def_for_expr_class): Likewise.
(optimize_bitfield_assignment_op): Likewise.
(store_field): Likewise.
(expand_cond_expr_using_cmove): Likewise.
(expand_expr_real_2): Likewise.
(expand_expr_real_1): Likewise.
(do_store_flag): Likewise.
* expr.h (expand_normal): Likewise.
* fold-const.c (fold_defer_overflow_warnings): Likewise.
* fold-const.h (fold_undefer_overflow_warnings): Likewise.
* ggc.h (ggc_alloc_cleared_tree_node_stat): Likewise.
(ggc_alloc_cleared_gimple_stat): Likewise.
* gimple-builder.c (get_expr_type): Likewise.
(build_assign): Likewise.
(build_type_cast): Likewise.
* gimple-builder.h (Copyright): Likewise.
(build_assign): Likewise.
(build_type_cast): Likewise.
* gimple-fold.c (fold_gimple_assign): Likewise.
(gimplify_and_update_call_from_tree): Likewise.
(get_maxval_strlen): Likewise.
(gimple_fold_call): Likewise.
(fold_stmt_1): Likewise.
(fold_stmt_inplace): Likewise.
(same_bool_comparison_p): Likewise.
(and_var_with_comparison): Likewise.
(and_var_with_comparison_1): Likewise.
(and_comparisons_1): Likewise.
(or_var_with_comparison): Likewise.
(or_var_with_comparison_1): Likewise.
(or_comparisons_1): Likewise.
(maybe_fold_or_comparisons): Likewise.
(gimple_fold_stmt_to_constant_1): Likewise.
(gimple_val_nonnegative_real_p): Likewise.
(arith_code_with_undefined_signed_overflow): Likewise.
(rewrite_to_defined_overflow): Likewise.
* gimple-fold.h (gimple_fold_builtin): Likewise.
(gimple_fold_stmt_to_constant_1): Likewise.
(gimple_fold_stmt_to_constant): Likewise.
(rewrite_to_defined_overflow): Likewise.
* gimple-iterator.c (update_modified_stmt): Likewise.
(gsi_split_seq_after): Likewise.
(gsi_set_stmt): Likewise.
(gsi_split_seq_before): Likewise.
(gsi_replace): Likewise.
(gsi_replace_with_seq): Likewise.
(gsi_insert_before_without_update): Likewise.
(gsi_insert_before): Likewise.
(gsi_insert_after_without_update): Likewise.
(gsi_remove): Likewise.
(gsi_move_after): Likewise.
(gsi_move_before): Likewise.
(gsi_move_to_bb_end): Likewise.
(gimple_find_edge_insert_loc): Likewise.
* gimple-iterator.h (gsi_set_stmt): Likewise.
(gsi_replace): Likewise.
(gsi_insert_before_without_update): Likewise.
(gsi_insert_before): Likewise.
(gsi_insert_after_without_update): Likewise.
(gsi_insert_after): Likewise.
(gsi_for_stmt): Likewise.
(gsi_insert_on_edge): Likewise.
(gsi_insert_on_edge_immediate): Likewise.
(gsi_prev): Likewise.
* gimple-low.c (hierarchy): Likewise.
(lower_function_body): Likewise.
(lower_omp_directive): Likewise.
(lower_stmt): Likewise.
(lower_gimple_bind): Likewise.
(lower_try_catch): Likewise.
(gimple_try_catch_may_fallthru): Likewise.
(lower_gimple_return): Likewise.
(lower_builtin_setjmp): Likewise.
(lower_builtin_posix_memalign): Likewise.
* gimple-low.h (gimple_stmt_may_fallthru): Likewise.
* gimple-pretty-print.c (do_niy): Likewise.
(newline_and_indent): Likewise.
(debug_gimple_stmt): Likewise.
(debug): Likewise.
(dump_gimple_seq): Likewise.
(dump_gimple_fmt): Likewise.
(dump_unary_rhs): Likewise.
(dump_binary_rhs): Likewise.
(dump_ternary_rhs): Likewise.
(dump_gimple_assign): Likewise.
(dump_gimple_return): Likewise.
(pp_points_to_solution): Likewise.
(dump_gimple_call): Likewise.
(dump_gimple_switch): Likewise.
(dump_gimple_cond): Likewise.
(dump_gimple_label): Likewise.
(dump_gimple_goto): Likewise.
(dump_gimple_bind): Likewise.
(dump_gimple_try): Likewise.
(dump_gimple_catch): Likewise.
(dump_gimple_eh_filter): Likewise.
(dump_gimple_eh_must_not_throw): Likewise.
(dump_gimple_eh_else): Likewise.
(dump_gimple_resx): Likewise.
(dump_gimple_eh_dispatch): Likewise.
(dump_gimple_debug): Likewise.
(dump_gimple_omp_for): Likewise.
(dump_gimple_omp_continue): Likewise.
(dump_gimple_omp_single): Likewise.
(dump_gimple_omp_target): Likewise.
(dump_gimple_omp_teams): Likewise.
(dump_gimple_omp_sections): Likewise.
(dump_gimple_omp_block): Likewise.
(dump_gimple_omp_critical): Likewise.
(dump_gimple_omp_return): Likewise.
(dump_gimple_transaction): Likewise.
(dump_ssaname_info): Likewise.
(dump_gimple_phi): Likewise.
(dump_gimple_omp_parallel): Likewise.
(dump_gimple_omp_task): Likewise.
(dump_gimple_omp_atomic_load): Likewise.
(dump_gimple_omp_atomic_store): Likewise.
(dump_gimple_mem_ops): Likewise.
(dump_gimple_bb_header): Likewise.
(dump_phi_nodes): Likewise.
(pp_cfg_jump): Likewise.
(dump_implicit_edges): Likewise.
(gimple_dump_bb_buff): Likewise.
(gimple_dump_bb_for_graph): Likewise.
* gimple-pretty-print.h (debug_gimple_stmt): Likewise.
(print_gimple_stmt): Likewise.
(print_gimple_expr): Likewise.
(pp_gimple_stmt_1): Likewise.
* gimple-ssa-isolate-paths.c (check_loadstore): Likewise.
(insert_trap_and_remove_trailing_statements): Likewise.
(find_implicit_erroneous_behaviour): Likewise.
(find_explicit_erroneous_behaviour): Likewise.
* gimple-ssa-strength-reduction.c (of): Likewise.
(record_potential_basis): Likewise.
(alloc_cand_and_find_basis): Likewise.
(base_cand_from_table): Likewise.
(add_cand_for_stmt): Likewise.
(slsr_process_phi): Likewise.
(restructure_reference): Likewise.
(slsr_process_ref): Likewise.
(create_mul_ssa_cand): Likewise.
(create_mul_imm_cand): Likewise.
(slsr_process_mul): Likewise.
(create_add_ssa_cand): Likewise.
(create_add_imm_cand): Likewise.
(slsr_process_add): Likewise.
(legal_cast_p_1): Likewise.
(legal_cast_p): Likewise.
(slsr_process_cast): Likewise.
(slsr_process_copy): Likewise.
(replace_mult_candidate): Likewise.
(create_add_on_incoming_edge): Likewise.
(create_phi_basis): Likewise.
(replace_conditional_candidate): Likewise.
(phi_add_costs): Likewise.
(replace_uncond_cands_and_profitable_phis): Likewise.
(record_increment): Likewise.
(record_phi_increments): Likewise.
(record_increments): Likewise.
(phi_incr_cost): Likewise.
(lowest_cost_path): Likewise.
(total_savings): Likewise.
(ncd_for_two_cands): Likewise.
(ncd_with_phi): Likewise.
(insert_initializers): Likewise.
(all_phi_incrs_profitable): Likewise.
(introduce_cast_before_cand): Likewise.
(replace_one_candidate): Likewise.
(replace_profitable_candidates): Likewise.
* gimple-ssa.h (gimple_vop): Likewise.
(Copyright): Likewise.
(gimple_vuse_op): Likewise.
(gimple_vdef_op): Likewise.
(update_stmt): Likewise.
(update_stmt_if_modified): Likewise.
* gimple-streamer-in.c (Copyright): Likewise.
(input_phi): Likewise.
(input_gimple_stmt): Likewise.
(input_bb): Likewise.
* gimple-streamer-out.c (output_phi): Likewise.
(output_bb): Likewise.
* gimple-walk.c (callback): Likewise.
(walk_gimple_seq_mod): Likewise.
(walk_gimple_seq): Likewise.
(walk_gimple_asm): Likewise.
(walk_gimple_stmt): Likewise.
(get_base_loadstore): Likewise.
(walk_stmt_load_store_addr_ops): Likewise.
* gimple-walk.h (tree): Likewise.
(walk_gimple_seq_mod): Likewise.
(walk_gimple_op): Likewise.
(bool): Likewise.
(walk_stmt_load_store_addr_ops): Likewise.
(walk_stmt_load_store_ops): Likewise.
* gimple.c (gimple_call_same_target_p): Likewise.
(gimple_call_flags): Likewise.
(gimple_call_fnspec): Likewise.
(gimple_call_arg_flags): Likewise.
(validate_type): Likewise.
(gimple_builtin_call_types_compatible_p): Likewise.
(gimple_call_builtin_p): Likewise.
(gimple_set_code): Likewise.
(gimple_size): Likewise.
(gimple_alloc_stat): Likewise.
(gimple_set_subcode): Likewise.
(gimple_build_with_ops_stat): Likewise.
(gimple_build_return): Likewise.
(gimple_call_reset_alias_info): Likewise.
(gimple_build_call_1): Likewise.
(gimple_build_call_vec): Likewise.
(gimple_build_call): Likewise.
(gimple_build_call_valist): Likewise.
(gimple_build_call_internal_1): Likewise.
(gimple_build_call_internal): Likewise.
(gimple_build_call_internal_vec): Likewise.
(gimple_build_call_from_tree): Likewise.
(gimple_build_assign_stat): Likewise.
(gimple_build_assign_with_ops): Likewise.
(gimple_build_cond): Likewise.
(gimple_build_cond_from_tree): Likewise.
(gimple_cond_set_condition_from_tree): Likewise.
(gimple_build_label): Likewise.
(gimple_build_goto): Likewise.
(gimple_build_nop): Likewise.
(gimple_build_bind): Likewise.
(gimple_build_asm_1): Likewise.
(gimple_build_asm_vec): Likewise.
(gimple_build_catch): Likewise.
(gimple_build_eh_filter): Likewise.
(gimple_build_eh_must_not_throw): Likewise.
(gimple_build_eh_else): Likewise.
(gimple_build_try): Likewise.
(gimple_build_wce): Likewise.
(gimple_build_resx): Likewise.
(gimple_build_switch_nlabels): Likewise.
(gimple_build_switch): Likewise.
(gimple_build_eh_dispatch): Likewise.
(gimple_build_debug_bind_stat): Likewise.
(gimple_build_debug_source_bind_stat): Likewise.
(gimple_build_omp_critical): Likewise.
(gimple_build_omp_for): Likewise.
(gimple_build_omp_parallel): Likewise.
(gimple_build_omp_task): Likewise.
(gimple_build_omp_section): Likewise.
(gimple_build_omp_master): Likewise.
(gimple_build_omp_taskgroup): Likewise.
(gimple_build_omp_continue): Likewise.
(gimple_build_omp_ordered): Likewise.
(gimple_build_omp_return): Likewise.
(gimple_build_omp_sections): Likewise.
(gimple_build_omp_sections_switch): Likewise.
(gimple_build_omp_single): Likewise.
(gimple_build_omp_target): Likewise.
(gimple_build_omp_teams): Likewise.
(gimple_build_omp_atomic_load): Likewise.
(gimple_build_omp_atomic_store): Likewise.
(gimple_build_transaction): Likewise.
(gimple_build_predict): Likewise.
(gimple_check_failed): Likewise.
(gimple_seq_add_stmt): Likewise.
(gimple_seq_add_seq): Likewise.
(should_carry_location_p): Likewise.
(annotate_all_with_location): Likewise.
(gimple_seq_copy): Likewise.
(gimple_call_return_flags): Likewise.
(gimple_assign_copy_p): Likewise.
(gimple_assign_ssa_name_copy_p): Likewise.
(gimple_assign_unary_nop_p): Likewise.
(gimple_assign_set_rhs_with_ops_1): Likewise.
(gimple_get_lhs): Likewise.
(gimple_set_lhs): Likewise.
(gimple_copy): Likewise.
(gimple_has_side_effects): Likewise.
(gimple_could_trap_p_1): Likewise.
(gimple_could_trap_p): Likewise.
(canonicalize_cond_expr_cond): Likewise.
(gimple_call_copy_skip_args): Likewise.
(gimple_get_alias_set): Likewise.
(gimple_ior_addresses_taken_1): Likewise.
(dump_decl_set): Likewise.
(nonfreeing_call_p): Likewise.
(check_loadstore): Likewise.
* gimple.h (gimple_call_same_target_p): Likewise.
(gimple_call_flags): Likewise.
(gimple_call_arg_flags): Likewise.
(gimple_call_return_flags): Likewise.
(gimple_get_lhs): Likewise.
(gimple_has_side_effects): Likewise.
(gimple_builtin_call_types_compatible_p): Likewise.
(gimple_call_builtin_p): Likewise.
(gimple_asm_clobbers_memory_p): Likewise.
(set_bb_seq): Likewise.
(gimple_has_substatements): Likewise.
(gimple_bb): Likewise.
(gimple_set_block): Likewise.
(gimple_location): Likewise.
(gimple_set_location): Likewise.
(gimple_has_location): Likewise.
(gimple_filename): Likewise.
(gimple_seq_singleton_p): Likewise.
(gimple_set_uid): Likewise.
(gimple_init_singleton): Likewise.
(gimple_set_use_ops): Likewise.
(gimple_vuse): Likewise.
(gimple_set_vdef): Likewise.
(gimple_set_modified): Likewise.
(gimple_expr_code): Likewise.
(gimple_references_memory_p): Likewise.
(gimple_omp_return_set_nowait): Likewise.
(gimple_omp_return_set_lhs): Likewise.
(gimple_omp_return_lhs_ptr): Likewise.
(gimple_omp_section_set_last): Likewise.
(gimple_omp_parallel_set_combined_p): Likewise.
(gimple_omp_atomic_set_need_value): Likewise.
(gimple_omp_atomic_set_seq_cst): Likewise.
(gimple_ops): Likewise.
(gimple_op): Likewise.
(gimple_set_op): Likewise.
(get_gimple_rhs_class): Likewise.
(gimple_assign_lhs): Likewise.
(gimple_assign_set_lhs): Likewise.
(gimple_assign_rhs1): Likewise.
(gimple_assign_set_rhs1): Likewise.
(gimple_assign_rhs2): Likewise.
(gimple_assign_set_rhs2): Likewise.
(gimple_assign_rhs3): Likewise.
(gimple_assign_set_rhs_with_ops): Likewise.
(gimple_assign_set_nontemporal_move): Likewise.
(gimple_assign_set_rhs_code): Likewise.
(gimple_assign_rhs_class): Likewise.
(gimple_assign_single_p): Likewise.
(gimple_store_p): Likewise.
(gimple_assign_load_p): Likewise.
(gimple_assign_cast_p): Likewise.
(gimple_clobber_p): Likewise.
(is_gimple_call): Likewise.
(gimple_call_lhs): Likewise.
(gimple_call_set_lhs): Likewise.
(gimple_call_internal_p): Likewise.
(gimple_call_internal_fn): Likewise.
(gimple_call_set_fntype): Likewise.
(gimple_call_fn): Likewise.
(gimple_call_set_internal_fn): Likewise.
(gimple_call_fndecl): Likewise.
(gimple_call_return_type): Likewise.
(gimple_call_chain): Likewise.
(gimple_call_set_chain): Likewise.
(gimple_call_num_args): Likewise.
(gimple_call_arg): Likewise.
(gimple_has_lhs): Likewise.
(gimple_cond_set_code): Likewise.
(gimple_cond_lhs): Likewise.
(gimple_cond_set_lhs): Likewise.
(gimple_cond_rhs): Likewise.
(gimple_cond_set_rhs): Likewise.
(gimple_cond_set_false_label): Likewise.
(gimple_cond_make_true): Likewise.
(gimple_cond_true_p): Likewise.
(gimple_cond_set_condition): Likewise.
(gimple_label_set_label): Likewise.
(gimple_goto_set_dest): Likewise.
(gimple_bind_add_seq): Likewise.
(gimple_bind_set_block): Likewise.
(gimple_asm_ninputs): Likewise.
(gimple_asm_noutputs): Likewise.
(gimple_asm_nclobbers): Likewise.
(gimple_asm_nlabels): Likewise.
(gimple_asm_input_op): Likewise.
(gimple_asm_set_input_op): Likewise.
(gimple_asm_output_op): Likewise.
(gimple_asm_set_output_op): Likewise.
(gimple_asm_set_clobber_op): Likewise.
(gimple_asm_set_label_op): Likewise.
(gimple_asm_string): Likewise.
(gimple_asm_set_input): Likewise.
(gimple_asm_input_p): Likewise.
(gimple_catch_set_handler): Likewise.
(gimple_eh_else_set_e_body): Likewise.
(gimple_try_set_kind): Likewise.
(gimple_wce_set_cleanup): Likewise.
(gimple_wce_set_cleanup_eh_only): Likewise.
(gimple_phi_capacity): Likewise.
(gimple_phi_num_args): Likewise.
(gimple_phi_arg_has_location): Likewise.
(gimple_resx_set_region): Likewise.
(gimple_eh_dispatch_set_region): Likewise.
(gimple_switch_set_num_labels): Likewise.
(gimple_switch_index): Likewise.
(gimple_switch_set_index): Likewise.
(gimple_switch_set_label): Likewise.
(gimple_switch_set_default_label): Likewise.
(is_gimple_debug): Likewise.
(gimple_debug_bind_has_value_p): Likewise.
(gimple_debug_source_bind_set_value): Likewise.
(gimple_omp_set_body): Likewise.
(gimple_omp_critical_set_name): Likewise.
(gimple_omp_for_set_kind): Likewise.
(gimple_omp_for_set_combined_p): Likewise.
(gimple_omp_for_set_combined_into_p): Likewise.
(gimple_omp_for_collapse): Likewise.
(gimple_omp_for_set_index): Likewise.
(gimple_omp_for_set_initial): Likewise.
(gimple_omp_for_set_final): Likewise.
(gimple_omp_for_set_pre_body): Likewise.
(gimple_omp_parallel_set_clauses): Likewise.
(gimple_omp_parallel_set_child_fn): Likewise.
(gimple_omp_parallel_set_data_arg): Likewise.
(gimple_omp_task_set_clauses): Likewise.
(gimple_omp_task_set_child_fn): Likewise.
(gimple_omp_task_set_data_arg): Likewise.
(gimple_omp_taskreg_set_clauses): Likewise.
(gimple_omp_taskreg_set_child_fn): Likewise.
(gimple_omp_taskreg_set_data_arg): Likewise.
(gimple_omp_task_set_copy_fn): Likewise.
(gimple_omp_task_set_arg_size): Likewise.
(gimple_omp_task_set_arg_align): Likewise.
(gimple_omp_single_set_clauses): Likewise.
(gimple_omp_target_set_clauses): Likewise.
(gimple_omp_target_set_kind): Likewise.
(gimple_omp_target_set_child_fn): Likewise.
(gimple_omp_target_set_data_arg): Likewise.
(gimple_omp_teams_set_clauses): Likewise.
(gimple_omp_sections_set_clauses): Likewise.
(gimple_omp_for_set_cond): Likewise.
(gimple_omp_atomic_store_set_val): Likewise.
(gimple_omp_atomic_load_set_lhs): Likewise.
(gimple_omp_atomic_load_set_rhs): Likewise.
(gimple_omp_atomic_load_rhs_ptr): Likewise.
(gimple_omp_continue_set_control_def): Likewise.
(gimple_transaction_body): Likewise.
(gimple_transaction_label_ptr): Likewise.
(gimple_transaction_set_subcode): Likewise.
(gimple_return_retval_ptr): Likewise.
(gimple_return_set_retval): Likewise.
(is_gimple_omp): Likewise.
(gimple_nop_p): Likewise.
(gimple_predict_set_outcome): Likewise.
(Copyright): Likewise.
(gimple_check_failed): Likewise.
(GTY): Likewise.
(gimple_alloc_stat): Likewise.
(gimple_call_reset_alias_info): Likewise.
(gimple_build_call_vec): Likewise.
(gimple_build_call): Likewise.
(gimple_build_call_valist): Likewise.
(gimple_build_call_internal): Likewise.
(gimple_build_call_internal_vec): Likewise.
(gimple_build_call_from_tree): Likewise.
(gimple_build_assign_stat): Likewise.
(gimple_build_assign_with_ops): Likewise.
(gimple_build_cond): Likewise.
(gimple_cond_set_condition_from_tree): Likewise.
(gimple_build_label): Likewise.
(gimple_build_goto): Likewise.
(gimple_build_nop): Likewise.
(gimple_build_bind): Likewise.
(gimple_build_asm_vec): Likewise.
(gimple_build_catch): Likewise.
(gimple_build_eh_filter): Likewise.
(gimple_build_eh_must_not_throw): Likewise.
(gimple_build_try): Likewise.
(gimple_build_wce): Likewise.
(gimple_build_resx): Likewise.
(gimple_build_switch_nlabels): Likewise.
(gimple_build_switch): Likewise.
(gimple_build_eh_dispatch): Likewise.
(gimple_build_debug_bind_stat): Likewise.
(gimple_build_debug_source_bind_stat): Likewise.
(gimple_build_omp_critical): Likewise.
(gimple_build_omp_for): Likewise.
(gimple_build_omp_parallel): Likewise.
(gimple_build_omp_task): Likewise.
(gimple_build_omp_section): Likewise.
(gimple_build_omp_master): Likewise.
(gimple_build_omp_taskgroup): Likewise.
(gimple_build_omp_continue): Likewise.
(gimple_build_omp_ordered): Likewise.
(gimple_build_omp_return): Likewise.
(gimple_build_omp_sections): Likewise.
(gimple_build_omp_sections_switch): Likewise.
(gimple_build_omp_single): Likewise.
(gimple_build_omp_target): Likewise.
(gimple_build_omp_teams): Likewise.
(gimple_build_omp_atomic_load): Likewise.
(gimple_build_omp_atomic_store): Likewise.
(gimple_build_transaction): Likewise.
(gimple_seq_add_stmt): Likewise.
(gimple_seq_add_stmt_without_update): Likewise.
(gimple_assign_copy_p): Likewise.
(gimple_assign_ssa_name_copy_p): Likewise.
(gimple_assign_unary_nop_p): Likewise.
(gimple_set_bb): Likewise.
(gimple_set_lhs): Likewise.
(gimple_copy): Likewise.
(gimple_could_trap_p_1): Likewise.
(gimple_could_trap_p): Likewise.
(gimple_assign_rhs_could_trap_p): Likewise.
(canonicalize_cond_expr_cond): Likewise.
(gimple_call_copy_skip_args): Likewise.
(gimple_ior_addresses_taken): Likewise.
(nonfreeing_call_p): Likewise.
(infer_nonnull_range): Likewise.
(gimple_seq_first): Likewise.
(gimple_seq_last): Likewise.
(gimple_seq_empty_p): Likewise.
(gss_for_code): Likewise.
(gimple_statement_structure): Likewise.
(gimple_block): Likewise.
(gimple_location_ptr): Likewise.
(gimple_no_warning_p): Likewise.
(gimple_set_no_warning): Likewise.
(gimple_set_visited): Likewise.
(gimple_visited_p): Likewise.
(gimple_set_plf): Likewise.
(gimple_plf): Likewise.
(gimple_uid): Likewise.
(gimple_has_ops): Likewise.
(gimple_has_mem_ops): Likewise.
(gimple_use_ops): Likewise.
(gimple_vdef): Likewise.
(gimple_vuse_ptr): Likewise.
(gimple_vdef_ptr): Likewise.
(gimple_set_vuse): Likewise.
(gimple_modified_p): Likewise.
(gimple_has_volatile_ops): Likewise.
(gimple_set_has_volatile_ops): Likewise.
(gimple_in_transaction): Likewise.
(gimple_omp_subcode): Likewise.
(gimple_omp_set_subcode): Likewise.
(gimple_omp_return_nowait_p): Likewise.
(gimple_omp_return_lhs): Likewise.
(gimple_omp_section_last_p): Likewise.
(gimple_omp_parallel_combined_p): Likewise.
(gimple_omp_atomic_need_value_p): Likewise.
(gimple_omp_atomic_seq_cst_p): Likewise.
(gimple_num_ops): Likewise.
(gimple_set_num_ops): Likewise.
(gimple_op_ptr): Likewise.
(gimple_assign_lhs_ptr): Likewise.
(gimple_assign_rhs1_ptr): Likewise.
(gimple_assign_rhs2_ptr): Likewise.
(gimple_assign_rhs3_ptr): Likewise.
(gimple_assign_nontemporal_move_p): Likewise.
(gimple_assign_rhs_code): Likewise.
(gimple_call_lhs_ptr): Likewise.
(gimple_call_fntype): Likewise.
(gimple_call_fn_ptr): Likewise.
(gimple_call_set_fn): Likewise.
(gimple_call_set_fndecl): Likewise.
(gimple_call_chain_ptr): Likewise.
(gimple_call_arg_ptr): Likewise.
(gimple_call_set_arg): Likewise.
(gimple_call_set_tail): Likewise.
(gimple_call_tail_p): Likewise.
(gimple_call_set_return_slot_opt): Likewise.
(gimple_call_return_slot_opt_p): Likewise.
(gimple_call_set_from_thunk): Likewise.
(gimple_call_from_thunk_p): Likewise.
(gimple_call_set_va_arg_pack): Likewise.
(gimple_call_va_arg_pack_p): Likewise.
(gimple_call_noreturn_p): Likewise.
(gimple_call_set_nothrow): Likewise.
(gimple_call_nothrow_p): Likewise.
(gimple_call_set_alloca_for_var): Likewise.
(gimple_call_alloca_for_var_p): Likewise.
(gimple_call_copy_flags): Likewise.
(gimple_call_use_set): Likewise.
(gimple_call_clobber_set): Likewise.
(gimple_cond_code): Likewise.
(gimple_cond_lhs_ptr): Likewise.
(gimple_cond_rhs_ptr): Likewise.
(gimple_cond_true_label): Likewise.
(gimple_cond_set_true_label): Likewise.
(gimple_cond_false_label): Likewise.
(gimple_cond_make_false): Likewise.
(gimple_cond_false_p): Likewise.
(gimple_label_label): Likewise.
(gimple_goto_dest): Likewise.
(gimple_bind_vars): Likewise.
(gimple_bind_set_vars): Likewise.
(gimple_bind_append_vars): Likewise.
(gimple_bind_body_ptr): Likewise.
(gimple_bind_body): Likewise.
(gimple_bind_set_body): Likewise.
(gimple_bind_add_stmt): Likewise.
(gimple_bind_block): Likewise.
(gimple_asm_input_op_ptr): Likewise.
(gimple_asm_output_op_ptr): Likewise.
(gimple_asm_clobber_op): Likewise.
(gimple_asm_label_op): Likewise.
(gimple_asm_volatile_p): Likewise.
(gimple_asm_set_volatile): Likewise.
(gimple_catch_types): Likewise.
(gimple_catch_types_ptr): Likewise.
(gimple_catch_handler_ptr): Likewise.
(gimple_catch_handler): Likewise.
(gimple_catch_set_types): Likewise.
(gimple_eh_filter_types): Likewise.
(gimple_eh_filter_types_ptr): Likewise.
(gimple_eh_filter_failure_ptr): Likewise.
(gimple_eh_filter_failure): Likewise.
(gimple_eh_filter_set_types): Likewise.
(gimple_eh_filter_set_failure): Likewise.
(gimple_eh_must_not_throw_fndecl): Likewise.
(gimple_eh_must_not_throw_set_fndecl): Likewise.
(gimple_eh_else_n_body_ptr): Likewise.
(gimple_eh_else_n_body): Likewise.
(gimple_eh_else_e_body_ptr): Likewise.
(gimple_eh_else_e_body): Likewise.
(gimple_eh_else_set_n_body): Likewise.
(gimple_try_kind): Likewise.
(gimple_try_catch_is_cleanup): Likewise.
(gimple_try_eval_ptr): Likewise.
(gimple_try_eval): Likewise.
(gimple_try_cleanup_ptr): Likewise.
(gimple_try_cleanup): Likewise.
(gimple_try_set_catch_is_cleanup): Likewise.
(gimple_try_set_eval): Likewise.
(gimple_try_set_cleanup): Likewise.
(gimple_wce_cleanup_ptr): Likewise.
(gimple_wce_cleanup): Likewise.
(gimple_wce_cleanup_eh_only): Likewise.
(gimple_phi_result): Likewise.
(gimple_phi_result_ptr): Likewise.
(gimple_phi_set_result): Likewise.
(gimple_phi_arg): Likewise.
(phi_nodes_ptr): Likewise.
(gimple_phi_arg_def): Likewise.
(gimple_phi_arg_def_ptr): Likewise.
(gimple_phi_arg_edge): Likewise.
(gimple_phi_arg_location): Likewise.
(gimple_phi_arg_location_from_edge): Likewise.
(gimple_phi_arg_set_location): Likewise.
(gimple_resx_region): Likewise.
(gimple_eh_dispatch_region): Likewise.
(gimple_switch_num_labels): Likewise.
(gimple_switch_index_ptr): Likewise.
(gimple_switch_label): Likewise.
(gimple_switch_default_label): Likewise.
(gimple_debug_bind_p): Likewise.
(gimple_debug_bind_get_var): Likewise.
(gimple_debug_bind_get_value): Likewise.
(gimple_debug_bind_get_value_ptr): Likewise.
(gimple_debug_bind_set_var): Likewise.
(gimple_debug_bind_set_value): Likewise.
(gimple_debug_bind_reset_value): Likewise.
(gimple_debug_source_bind_p): Likewise.
(gimple_debug_source_bind_get_var): Likewise.
(gimple_debug_source_bind_get_value): Likewise.
(gimple_debug_source_bind_get_value_ptr): Likewise.
(gimple_debug_source_bind_set_var): Likewise.
(get_lineno): Likewise.
(gimple_omp_body_ptr): Likewise.
(gimple_omp_body): Likewise.
(gimple_omp_critical_name): Likewise.
(gimple_omp_critical_name_ptr): Likewise.
(gimple_omp_for_kind): Likewise.
(gimple_omp_for_combined_p): Likewise.
(gimple_omp_for_combined_into_p): Likewise.
(gimple_omp_for_clauses): Likewise.
(gimple_omp_for_clauses_ptr): Likewise.
(gimple_omp_for_set_clauses): Likewise.
(gimple_omp_for_index): Likewise.
(gimple_omp_for_index_ptr): Likewise.
(gimple_omp_for_initial): Likewise.
(gimple_omp_for_initial_ptr): Likewise.
(gimple_omp_for_final): Likewise.
(gimple_omp_for_final_ptr): Likewise.
(gimple_omp_for_incr): Likewise.
(gimple_omp_for_incr_ptr): Likewise.
(gimple_omp_for_set_incr): Likewise.
(gimple_omp_for_pre_body_ptr): Likewise.
(gimple_omp_for_pre_body): Likewise.
(gimple_omp_parallel_clauses): Likewise.
(gimple_omp_parallel_clauses_ptr): Likewise.
(gimple_omp_parallel_child_fn): Likewise.
(gimple_omp_parallel_child_fn_ptr): Likewise.
(gimple_omp_parallel_data_arg): Likewise.
(gimple_omp_parallel_data_arg_ptr): Likewise.
(gimple_omp_task_clauses): Likewise.
(gimple_omp_task_clauses_ptr): Likewise.
(gimple_omp_task_child_fn): Likewise.
(gimple_omp_task_child_fn_ptr): Likewise.
(gimple_omp_task_data_arg): Likewise.
(gimple_omp_task_data_arg_ptr): Likewise.
(gimple_omp_taskreg_clauses): Likewise.
(gimple_omp_taskreg_clauses_ptr): Likewise.
(gimple_omp_taskreg_child_fn): Likewise.
(gimple_omp_taskreg_child_fn_ptr): Likewise.
(gimple_omp_taskreg_data_arg): Likewise.
(gimple_omp_taskreg_data_arg_ptr): Likewise.
(gimple_omp_task_copy_fn): Likewise.
(gimple_omp_task_copy_fn_ptr): Likewise.
(gimple_omp_task_arg_size): Likewise.
(gimple_omp_task_arg_size_ptr): Likewise.
(gimple_omp_task_arg_align): Likewise.
(gimple_omp_task_arg_align_ptr): Likewise.
(gimple_omp_single_clauses): Likewise.
(gimple_omp_single_clauses_ptr): Likewise.
(gimple_omp_target_clauses): Likewise.
(gimple_omp_target_clauses_ptr): Likewise.
(gimple_omp_target_kind): Likewise.
(gimple_omp_target_child_fn): Likewise.
(gimple_omp_target_child_fn_ptr): Likewise.
(gimple_omp_target_data_arg): Likewise.
(gimple_omp_target_data_arg_ptr): Likewise.
(gimple_omp_teams_clauses): Likewise.
(gimple_omp_teams_clauses_ptr): Likewise.
(gimple_omp_sections_clauses): Likewise.
(gimple_omp_sections_clauses_ptr): Likewise.
(gimple_omp_sections_control): Likewise.
(gimple_omp_sections_control_ptr): Likewise.
(gimple_omp_sections_set_control): Likewise.
(gimple_omp_for_cond): Likewise.
(gimple_omp_atomic_store_val): Likewise.
(gimple_omp_atomic_store_val_ptr): Likewise.
(gimple_omp_atomic_load_lhs): Likewise.
(gimple_omp_atomic_load_lhs_ptr): Likewise.
(gimple_omp_atomic_load_rhs): Likewise.
(gimple_omp_continue_control_def): Likewise.
(gimple_omp_continue_control_def_ptr): Likewise.
(gimple_omp_continue_control_use): Likewise.
(gimple_omp_continue_control_use_ptr): Likewise.
(gimple_omp_continue_set_control_use): Likewise.
(gimple_transaction_body_ptr): Likewise.
(gimple_transaction_label): Likewise.
(gimple_transaction_subcode): Likewise.
(gimple_transaction_set_body): Likewise.
(gimple_transaction_set_label): Likewise.
(gimple_return_retval): Likewise.
(is_gimple_resx): Likewise.
(gimple_predict_predictor): Likewise.
(gimple_predict_set_predictor): Likewise.
(gimple_predict_outcome): Likewise.
(gimple_alloc_kind): Likewise.
(gimple_do_not_emit_location_p): Likewise.
* gimplify-me.c (force_gimple_operand_gsi): Likewise.
(gimple_regimplify_operands): Likewise.
* gimplify-me.h (gimple_regimplify_operands): Likewise.
* gimplify.c (equal): Likewise.
(gimplify_seq_add_stmt): Likewise.
(push_gimplify_context): Likewise.
(pop_gimplify_context): Likewise.
(gimple_pop_bind_expr): Likewise.
(gimple_current_bind_expr): Likewise.
(gimplify_and_add): Likewise.
(get_initialized_tmp_var): Likewise.
(voidify_wrapper_expr): Likewise.
(gimplify_bind_expr): Likewise.
(gimplify_return_expr): Likewise.
(gimplify_switch_expr): Likewise.
(gimplify_case_label_expr): Likewise.
(gimplify_call_expr): Likewise.
(gimplify_cond_expr): Likewise.
(gimplify_modify_expr_to_memcpy): Likewise.
(gimplify_modify_expr_to_memset): Likewise.
(gimplify_init_constructor): Likewise.
(gimplify_modify_expr): Likewise.
(gimplify_asm_expr): Likewise.
(gimplify_cleanup_point_expr): Likewise.
(gimple_push_cleanup): Likewise.
(gimplify_omp_parallel): Likewise.
(gimplify_omp_task): Likewise.
(gimplify_omp_for): Likewise.
(gimplify_omp_workshare): Likewise.
(gimplify_omp_target_update): Likewise.
(gimplify_omp_atomic): Likewise.
(gimplify_transaction): Likewise.
(gimplify_expr): Likewise.
(gimplify_one_sizepos): Likewise.
(gimplify_body): Likewise.
(gimplify_function_tree): Likewise.
(gimplify_va_arg_expr): Likewise.
* gimplify.h (pop_gimplify_context): Likewise.
(gimple_current_bind_expr): Likewise.
(declare_vars): Likewise.
(gimplify_one_sizepos): Likewise.
(gimplify_va_arg_expr): Likewise.
* graphite-poly.c (dump_gbb_cases): Likewise.
(dump_gbb_conditions): Likewise.
* graphite-scop-detection.c (graphite_can_represent_expr): Likewise.
(stmt_has_simple_data_refs_p): Likewise.
(stmt_simple_for_scop_p): Likewise.
(scopdet_basic_block_info): Likewise.
(limit_scops): Likewise.
(same_close_phi_node): Likewise.
(remove_duplicate_close_phi): Likewise.
(make_close_phi_nodes_unique): Likewise.
(canonicalize_loop_closed_ssa): Likewise.
* graphite-sese-to-poly.c (tree_int_to_gmp): Likewise.
(remove_simple_copy_phi): Likewise.
(remove_invariant_phi): Likewise.
(reduction_phi_p): Likewise.
(try_generate_gimple_bb): Likewise.
(find_params_in_bb): Likewise.
(create_pw_aff_from_tree): Likewise.
(add_conditions_to_domain): Likewise.
(add_conditions_to_constraints): Likewise.
(single_pred_cond_non_loop_exit): Likewise.
(build_scop_drs): Likewise.
(gsi_for_phi_node): Likewise.
(analyze_drs_in_stmts): Likewise.
(insert_stmts): Likewise.
(insert_out_of_ssa_copy): Likewise.
(insert_out_of_ssa_copy_on_edge): Likewise.
(create_zero_dim_array): Likewise.
(propagate_expr_outside_region): Likewise.
(rewrite_close_phi_out_of_ssa): Likewise.
(rewrite_phi_out_of_ssa): Likewise.
(rewrite_degenerate_phi): Likewise.
(rewrite_reductions_out_of_ssa): Likewise.
(rewrite_cross_bb_scalar_dependence): Likewise.
(handle_scalar_deps_crossing_scop_limits): Likewise.
(rewrite_cross_bb_scalar_deps): Likewise.
(nb_data_writes_in_bb): Likewise.
(split_pbb): Likewise.
(split_reduction_stmt): Likewise.
(is_reduction_operation_p): Likewise.
(phi_contains_arg): Likewise.
(follow_ssa_with_commutative_ops): Likewise.
(detect_commutative_reduction_arg): Likewise.
(detect_commutative_reduction_assign): Likewise.
(follow_inital_value_to_phi): Likewise.
(edge_initial_value_for_loop_phi): Likewise.
(initial_value_for_loop_phi): Likewise.
(used_outside_reduction): Likewise.
(detect_commutative_reduction): Likewise.
(translate_scalar_reduction_to_array_for_stmt): Likewise.
(remove_phi): Likewise.
(dr_indices_valid_in_loop): Likewise.
(close_phi_written_to_memory): Likewise.
(translate_scalar_reduction_to_array): Likewise.
(rewrite_commutative_reductions_out_of_ssa_close_phi): Likewise.
(scop_ivs_can_be_represented): Likewise.
* internal-fn.c (get_multi_vector_move): Likewise.
(expand_LOAD_LANES): Likewise.
(expand_STORE_LANES): Likewise.
(expand_ANNOTATE): Likewise.
(expand_GOMP_SIMD_LANE): Likewise.
(expand_GOMP_SIMD_VF): Likewise.
(expand_GOMP_SIMD_LAST_LANE): Likewise.
(expand_UBSAN_NULL): Likewise.
(ubsan_expand_si_overflow_addsub_check): Likewise.
(ubsan_expand_si_overflow_neg_check): Likewise.
(ubsan_expand_si_overflow_mul_check): Likewise.
(expand_UBSAN_CHECK_ADD): Likewise.
(expand_UBSAN_CHECK_SUB): Likewise.
(expand_UBSAN_CHECK_MUL): Likewise.
(expand_LOOP_VECTORIZED): Likewise.
(expand_MASK_LOAD): Likewise.
(expand_MASK_STORE): Likewise.
(expand_ABNORMAL_DISPATCHER): Likewise.
(expand_BUILTIN_EXPECT): Likewise.
* internal-fn.h (internal_fn_flags): Likewise.
* ipa-inline-analysis.c (mark_modified): Likewise.
(unmodified_parm_1): Likewise.
(unmodified_parm): Likewise.
(unmodified_parm_or_parm_agg_item): Likewise.
(set_cond_stmt_execution_predicate): Likewise.
(set_switch_stmt_execution_predicate): Likewise.
(will_be_nonconstant_expr_predicate): Likewise.
(will_be_nonconstant_predicate): Likewise.
(record_modified): Likewise.
(phi_result_unknown_predicate): Likewise.
(array_index_predicate): Likewise.
(find_foldable_builtin_expect): Likewise.
(clobber_only_eh_bb_p): Likewise.
(estimate_function_body_sizes): Likewise.
* ipa-inline.c (inline_small_functions): Likewise.
* ipa-profile.c (ipa_profile_generate_summary): Likewise.
* ipa-prop.c (ipa_binfo_from_known_type_jfunc): Likewise.
(stmt_may_be_vtbl_ptr_store): Likewise.
(check_stmt_for_type_change): Likewise.
(detect_type_change): Likewise.
(mark_modified): Likewise.
(parm_preserved_before_stmt_p): Likewise.
(load_from_unmodified_param): Likewise.
(parm_ref_data_preserved_p): Likewise.
(parm_ref_data_pass_through_p): Likewise.
(ipa_load_from_parm_agg_1): Likewise.
(ipa_load_from_parm_agg): Likewise.
(compute_complex_assign_jump_func): Likewise.
(get_ancestor_addr_info): Likewise.
(compute_complex_ancestor_jump_func): Likewise.
(get_ssa_def_if_simple_copy): Likewise.
(determine_known_aggregate_parts): Likewise.
(ipa_compute_jump_functions_for_edge): Likewise.
(ipa_compute_jump_functions): Likewise.
(ipa_is_ssa_with_stmt_def): Likewise.
(ipa_note_param_call): Likewise.
(ipa_analyze_indirect_call_uses): Likewise.
(ipa_analyze_virtual_call_uses): Likewise.
(ipa_analyze_call_uses): Likewise.
(ipa_analyze_stmt_uses): Likewise.
(ipa_analyze_params_uses): Likewise.
(ipa_analyze_node): Likewise.
(ipa_modify_formal_parameters): Likewise.
(ipa_modify_call_arguments): Likewise.
(ipcp_transform_function): Likewise.
* ipa-prop.h (ipa_get_agg_replacements_for_node): Likewise.
* ipa-pure-const.c (special_builtin_state): Likewise.
(check_call): Likewise.
(check_load): Likewise.
(check_store): Likewise.
(check_ipa_load): Likewise.
(check_stmt): Likewise.
* ipa-ref.c (statement): Likewise.
(ipa_record_reference): Likewise.
(ipa_dump_referring): Likewise.
(ipa_ref_has_aliases_p): Likewise.
(ipa_find_reference): Likewise.
* ipa-ref.h (Copyright): Likewise.
(ENUM_BITFIELD): Likewise.
(ipa_clone_referring): Likewise.
(ipa_ref_has_aliases_p): Likewise.
(ipa_remove_stmt_references): Likewise.
* ipa-split.c (test_nonssa_use): Likewise.
(verify_non_ssa_vars): Likewise.
(check_forbidden_calls): Likewise.
(consider_split): Likewise.
(find_return_bb): Likewise.
(find_retval): Likewise.
(visit_bb): Likewise.
(split_function): Likewise.
(execute_split_functions): Likewise.
* lto-streamer-in.c (input_ssa_names): Likewise.
(fixup_call_stmt_edges_1): Likewise.
(input_function): Likewise.
* lto-streamer-out.c (output_function): Likewise.
* omp-low.c (Copyright): Likewise.
(is_combined_parallel): Likewise.
(workshare_safe_to_combine_p): Likewise.
(determine_parallel_type): Likewise.
(free_omp_regions): Likewise.
(new_omp_context): Likewise.
(finalize_task_copyfn): Likewise.
(find_combined_for): Likewise.
(scan_omp_parallel): Likewise.
(scan_omp_task): Likewise.
(scan_omp_for): Likewise.
(scan_omp_sections): Likewise.
(scan_omp_single): Likewise.
(scan_omp_target): Likewise.
(scan_omp_teams): Likewise.
(scan_omp_1_stmt): Likewise.
(scan_omp): Likewise.
(build_omp_barrier): Likewise.
(lower_rec_input_clauses): Likewise.
(lower_lastprivate_clauses): Likewise.
(lower_reduction_clauses): Likewise.
(lower_send_shared_vars): Likewise.
(gimple_build_cond_empty): Likewise.
(expand_parallel_call): Likewise.
(maybe_catch_exception): Likewise.
(remove_exit_barrier): Likewise.
(remove_exit_barriers): Likewise.
(optimize_omp_library_calls): Likewise.
(expand_omp_build_assign): Likewise.
(expand_omp_taskreg): Likewise.
(expand_omp_for_init_counts): Likewise.
(expand_omp_for_init_vars): Likewise.
(extract_omp_for_update_vars): Likewise.
(expand_omp_for_generic): Likewise.
(expand_omp_for_static_nochunk): Likewise.
(expand_omp_for_static_chunk): Likewise.
(expand_omp_simd): Likewise.
(expand_omp_sections): Likewise.
(expand_omp_atomic_load): Likewise.
(expand_omp_atomic_store): Likewise.
(expand_omp_atomic_fetch_op): Likewise.
(expand_omp_atomic_pipeline): Likewise.
(expand_omp_atomic_mutex): Likewise.
(expand_omp_atomic): Likewise.
(expand_omp_target): Likewise.
(expand_omp): Likewise.
(build_omp_regions_1): Likewise.
(maybe_add_implicit_barrier_cancel): Likewise.
(lower_omp_sections): Likewise.
(lower_omp_single_simple): Likewise.
(lower_omp_single): Likewise.
(lower_omp_master): Likewise.
(lower_omp_taskgroup): Likewise.
(lower_omp_ordered): Likewise.
(lower_omp_critical): Likewise.
(lower_omp_for): Likewise.
(check_combined_parallel): Likewise.
(task_copyfn_remap_type): Likewise.
(create_task_copyfn): Likewise.
(lower_depend_clauses): Likewise.
(lower_omp_taskreg): Likewise.
(lower_omp_target): Likewise.
(lower_omp_teams): Likewise.
(lower_omp_1): Likewise.
(make_pass_lower_omp): Likewise.
(diagnose_sb_1): Likewise.
(diagnose_sb_2): Likewise.
(make_gimple_omp_edges): Likewise.
(simd_clone_init_simd_arrays): Likewise.
(ipa_simd_modify_stmt_ops): Likewise.
(ipa_simd_modify_function_body): Likewise.
(simd_clone_adjust): Likewise.
* passes.c (execute_ipa_pass_list): Likewise.
(execute_ipa_stmt_fixups): Likewise.
* predict.c (get_base_value): Likewise.
(expr_coherent_p): Likewise.
(predict_iv_comparison): Likewise.
(predict_extra_loop_exits): Likewise.
(predict_loops): Likewise.
(expr_expected_value_1): Likewise.
(tree_predict_by_opcode): Likewise.
(apply_return_prediction): Likewise.
(tree_bb_level_predictions): Likewise.
(tree_estimate_probability_bb): Likewise.
(make_pass_profile): Likewise.
* profile.c (compute_value_histograms): Likewise.
(branch_prob): Likewise.
* sese.c (sese_build_liveouts_bb): Likewise.
(sese_reset_debug_liveouts_bb): Likewise.
(sese_add_exit_phis_edge): Likewise.
(set_rename): Likewise.
(graphite_copy_stmts_from_block): Likewise.
(set_ifsese_condition): Likewise.
(scalar_evolution_in_region): Likewise.
* sese.h (bb_in_sese_p): Likewise.
(defined_in_sese_p): Likewise.
(recompute_all_dominators): Likewise.
* ssa-iterators.h (single_imm_use_1): Likewise.
(set_ssa_use_from_ptr): Likewise.
(relink_imm_use): Likewise.
(has_single_use): Likewise.
(clear_and_done_ssa_iter): Likewise.
(op_iter_init): Likewise.
(op_iter_init_use): Likewise.
(op_iter_init_def): Likewise.
(op_iter_init_tree): Likewise.
(single_ssa_tree_operand): Likewise.
(single_ssa_use_operand): Likewise.
(single_ssa_def_operand): Likewise.
(zero_ssa_operands): Likewise.
(num_ssa_operands): Likewise.
(single_phi_def): Likewise.
(op_iter_init_phiuse): Likewise.
(link_use_stmts_after): Likewise.
(first_imm_use_stmt): Likewise.
(next_imm_use_on_stmt): Likewise.
* stmt.c (reset_out_edges_aux): Likewise.
(compute_cases_per_edge): Likewise.
* tracer.c (ignore_bb_p): Likewise.
(count_insns): Likewise.
* trans-mem.c (is_tm_safe): Likewise.
(is_tm_ending_fndecl): Likewise.
(is_tm_ending): Likewise.
(is_tm_load): Likewise.
(is_tm_simple_load): Likewise.
(is_tm_store): Likewise.
(tm_malloc_replacement): Likewise.
(diagnose_tm_1): Likewise.
(transaction_invariant_address_p): Likewise.
(tm_log_add): Likewise.
(gimplify_addr): Likewise.
(tm_log_emit_stmt): Likewise.
(tm_log_emit): Likewise.
(tm_log_emit_saves): Likewise.
(tm_log_emit_restores): Likewise.
(thread_private_new_memory): Likewise.
(examine_assign_tm): Likewise.
(examine_call_tm): Likewise.
(lower_transaction): Likewise.
(lower_sequence_tm): Likewise.
(lower_sequence_no_tm): Likewise.
(make_pass_lower_tm): Likewise.
(tm_region_init_1): Likewise.
(tm_region_init): Likewise.
(transaction_subcode_ior): Likewise.
(build_tm_load): Likewise.
(build_tm_store): Likewise.
(expand_assign_tm): Likewise.
(expand_call_tm): Likewise.
(expand_block_tm): Likewise.
(expand_transaction): Likewise.
(make_pass_tm_mark): Likewise.
(expand_block_edges): Likewise.
(expand_regions): Likewise.
(tm_memopt_accumulate_memops): Likewise.
(tm_memopt_compute_antic): Likewise.
(dump_tm_memopt_transform): Likewise.
(tm_memopt_transform_blocks): Likewise.
(ipa_uninstrument_transaction): Likewise.
(ipa_tm_scan_calls_block): Likewise.
(ipa_tm_scan_irr_block): Likewise.
(ipa_tm_decrement_clone_counts): Likewise.
(ipa_tm_diagnose_transaction): Likewise.
(ipa_tm_insert_irr_call): Likewise.
(ipa_tm_insert_gettmclone_call): Likewise.
(ipa_tm_transform_calls_redirect): Likewise.
(ipa_tm_transform_calls_1): Likewise.
* trans-mem.h (is_tm_ending): Likewise.
* tree-affine.c (aff_combination_expand): Likewise.
* tree-call-cdce.c (check_target_format): Likewise.
(check_pow): Likewise.
(check_builtin_call): Likewise.
(is_call_dce_candidate): Likewise.
(gen_one_condition): Likewise.
(gen_conditions_for_domain): Likewise.
(gen_conditions_for_pow_cst_base): Likewise.
(gen_conditions_for_pow_int_base): Likewise.
(get_no_error_domain): Likewise.
(gen_shrink_wrap_conditions): Likewise.
(shrink_wrap_one_built_in_call): Likewise.
(shrink_wrap_conditional_dead_built_in_calls): Likewise.
* tree-cfg.c (verify_gimple_transaction): Likewise.
(find_case_label_for_value): Likewise.
(replace_loop_annotate): Likewise.
(make_pass_build_cfg): Likewise.
(assert_unreachable_fallthru_edge_p): Likewise.
(make_blocks): Likewise.
(fold_cond_expr_cond): Likewise.
(get_abnormal_succ_dispatcher): Likewise.
(handle_abnormal_edges): Likewise.
(make_edges): Likewise.
(assign_discriminators): Likewise.
(make_cond_expr_edges): Likewise.
(end_recording_case_labels): Likewise.
(make_gimple_switch_edges): Likewise.
(label_to_block_fn): Likewise.
(make_goto_expr_edges): Likewise.
(make_gimple_asm_edges): Likewise.
(cleanup_dead_labels): Likewise.
(group_case_labels): Likewise.
(gimple_can_merge_blocks_p): Likewise.
(replace_uses_by): Likewise.
(gimple_merge_blocks): Likewise.
(single_noncomplex_succ): Likewise.
(remove_bb): Likewise.
(find_taken_edge): Likewise.
(find_taken_edge_switch_expr): Likewise.
(debug_cfg_stats): Likewise.
(call_can_make_abnormal_goto): Likewise.
(stmt_can_make_abnormal_goto): Likewise.
(is_ctrl_stmt): Likewise.
(is_ctrl_altering_stmt): Likewise.
(simple_goto_p): Likewise.
(stmt_starts_bb_p): Likewise.
(delete_tree_cfg_annotations): Likewise.
(first_stmt): Likewise.
(first_non_label_stmt): Likewise.
(last_stmt): Likewise.
(last_and_only_stmt): Likewise.
(reinstall_phi_args): Likewise.
(valid_fixed_convert_types_p): Likewise.
(verify_gimple_comparison): Likewise.
(verify_gimple_assign_unary): Likewise.
(verify_gimple_assign_binary): Likewise.
(verify_gimple_assign_ternary): Likewise.
(verify_gimple_assign_single): Likewise.
(verify_gimple_assign): Likewise.
(verify_gimple_return): Likewise.
(verify_gimple_goto): Likewise.
(verify_gimple_switch): Likewise.
(verify_gimple_debug): Likewise.
(verify_gimple_label): Likewise.
(verify_gimple_stmt): Likewise.
(verify_gimple_in_seq_2): Likewise.
(verify_gimple_in_cfg): Likewise.
(gimple_verify_flow_info): Likewise.
(gimple_make_forwarder_block): Likewise.
(gimple_block_label): Likewise.
(gimple_try_redirect_by_replacing_jump): Likewise.
(gimple_redirect_edge_and_branch): Likewise.
(gimple_split_block): Likewise.
(gimple_split_block_before_cond_jump): Likewise.
(gimple_duplicate_bb): Likewise.
(add_phi_args_after_copy_edge): Likewise.
(gimple_duplicate_sese_tail): Likewise.
(move_stmt_r): Likewise.
(move_block_to_fn): Likewise.
(find_outermost_region_in_block): Likewise.
(gimple_block_ends_with_condjump_p): Likewise.
(gimple_flow_call_edges_add): Likewise.
(gimple_purge_dead_eh_edges): Likewise.
(gimple_purge_dead_abnormal_call_edges): Likewise.
(gimple_lv_adjust_loop_header_phi): Likewise.
(gimple_lv_add_condition_to_bb): Likewise.
(extract_true_false_edges_from_block): Likewise.
(do_warn_unused_result): Likewise.
(execute_fixup_cfg): Likewise.
(make_pass_fixup_cfg): Likewise.
(gt_ggc_mx): Likewise.
* tree-cfg.h (group_case_labels_stmt): Likewise.
(notice_special_calls): Likewise.
(computed_goto_p): Likewise.
(stmt_can_make_abnormal_goto): Likewise.
(is_ctrl_stmt): Likewise.
(is_ctrl_altering_stmt): Likewise.
(simple_goto_p): Likewise.
(stmt_ends_bb_p): Likewise.
(delete_tree_cfg_annotations): Likewise.
(first_stmt): Likewise.
(last_stmt): Likewise.
* tree-cfgcleanup.c (cleanup_control_expr_graph): Likewise.
(cleanup_control_flow_bb): Likewise.
(tree_forwarder_block_p): Likewise.
(phi_alternatives_equal): Likewise.
(remove_forwarder_block): Likewise.
(fixup_noreturn_call): Likewise.
(split_bbs_on_noreturn_calls): Likewise.
(remove_forwarder_block_with_phi): Likewise.
* tree-cfgcleanup.h (fixup_noreturn_call): Likewise.
* tree-chrec.c (nb_vars_in_chrec): Likewise.
(convert_affine_scev): Likewise.
(chrec_convert_rhs): Likewise.
(chrec_convert): Likewise.
* tree-chrec.h (tree_is_chrec): Likewise.
* tree-complex.c (init_dont_simulate_again): Likewise.
(complex_visit_stmt): Likewise.
(set_component_ssa_name): Likewise.
(extract_component): Likewise.
(update_complex_assignment): Likewise.
(update_phi_components): Likewise.
(expand_complex_move): Likewise.
(expand_complex_libcall): Likewise.
(expand_complex_div_wide): Likewise.
(expand_complex_comparison): Likewise.
(expand_complex_asm): Likewise.
(expand_complex_operations_1): Likewise.
* tree-core.h (GTY): Likewise.
* tree-data-ref.c (split_constant_offset_1): Likewise.
(dr_analyze_innermost): Likewise.
(free_data_ref): Likewise.
(compute_all_dependences): Likewise.
(get_references_in_stmt): Likewise.
(find_data_references_in_stmt): Likewise.
(find_data_references_in_bb): Likewise.
* tree-data-ref.h (am_vector_index_for_loop): Likewise.
* tree-dfa.c (renumber_gimple_stmt_uids): Likewise.
(renumber_gimple_stmt_uids_in_blocks): Likewise.
(collect_dfa_stats): Likewise.
(get_addr_base_and_unit_offset): Likewise.
* tree-dfa.h (stmt_references_abnormal_ssa_name): Likewise.
* tree-eh.c (Copyright): Likewise.
(add_stmt_to_eh_lp_fn): Likewise.
(add_stmt_to_eh_lp): Likewise.
(record_stmt_eh_region): Likewise.
(remove_stmt_from_eh_lp_fn): Likewise.
(remove_stmt_from_eh_lp): Likewise.
(lookup_stmt_eh_lp_fn): Likewise.
(lookup_stmt_eh_lp): Likewise.
(record_in_finally_tree): Likewise.
(collect_finally_tree_1): Likewise.
(collect_finally_tree): Likewise.
(outside_finally_tree): Likewise.
(replace_goto_queue_cond_clause): Likewise.
(record_in_goto_queue_label): Likewise.
(maybe_record_in_goto_queue): Likewise.
(do_return_redirection): Likewise.
(do_goto_redirection): Likewise.
(emit_post_landing_pad): Likewise.
(emit_resx): Likewise.
(emit_eh_dispatch): Likewise.
(eh_region_may_contain_throw): Likewise.
(frob_into_branch_around): Likewise.
(lower_try_finally_dup_block): Likewise.
(lower_try_finally_fallthru_label): Likewise.
(get_eh_else): Likewise.
(honor_protect_cleanup_actions): Likewise.
(lower_try_finally_nofallthru): Likewise.
(lower_try_finally_onedest): Likewise.
(lower_try_finally_copy): Likewise.
(lower_try_finally_switch): Likewise.
(decide_copy_try_finally): Likewise.
(cleanup_is_dead_in): Likewise.
(lower_try_finally): Likewise.
(lower_catch): Likewise.
(lower_eh_filter): Likewise.
(lower_eh_must_not_throw): Likewise.
(lower_cleanup): Likewise.
(lower_eh_constructs_2): Likewise.
(make_pass_lower_eh): Likewise.
(make_eh_dispatch_edges): Likewise.
(redirect_eh_edge_1): Likewise.
(redirect_eh_edge): Likewise.
(tree_could_trap_p): Likewise.
(stmt_could_throw_1_p): Likewise.
(tree_could_throw_p): Likewise.
(stmt_can_throw_external): Likewise.
(stmt_can_throw_internal): Likewise.
(maybe_clean_eh_stmt_fn): Likewise.
(maybe_clean_eh_stmt): Likewise.
(maybe_clean_or_replace_eh_stmt): Likewise.
(maybe_duplicate_eh_stmt_fn): Likewise.
(same_handler_p): Likewise.
(optimize_double_finally): Likewise.
(refactor_eh_r): Likewise.
(make_pass_refactor_eh): Likewise.
(lower_resx): Likewise.
(optimize_clobbers): Likewise.
(sink_clobbers): Likewise.
(lower_eh_dispatch): Likewise.
(mark_reachable_handlers): Likewise.
(unsplit_eh): Likewise.
(cleanup_empty_eh_merge_phis): Likewise.
(cleanup_empty_eh_unsplit): Likewise.
(cleanup_empty_eh): Likewise.
(make_pass_cleanup_eh): Likewise.
(verify_eh_edges): Likewise.
* tree-eh.h (add_stmt_to_eh_lp): Likewise.
(remove_stmt_from_eh_lp_fn): Likewise.
(remove_stmt_from_eh_lp): Likewise.
(lookup_stmt_eh_lp_fn): Likewise.
(lookup_stmt_eh_lp): Likewise.
(make_eh_dispatch_edges): Likewise.
(make_eh_edges): Likewise.
(redirect_eh_dispatch_edge): Likewise.
(stmt_could_throw_p): Likewise.
(stmt_can_throw_external): Likewise.
(stmt_can_throw_internal): Likewise.
(maybe_clean_eh_stmt_fn): Likewise.
(maybe_clean_eh_stmt): Likewise.
(maybe_clean_or_replace_eh_stmt): Likewise.
(maybe_duplicate_eh_stmt_fn): Likewise.
(maybe_duplicate_eh_stmt): Likewise.
(verify_eh_edges): Likewise.
(verify_eh_dispatch_edge): Likewise.
* tree-emutls.c (gen_emutls_addr): Likewise.
(lower_emutls_1): Likewise.
(lower_emutls_stmt): Likewise.
* tree-if-conv.c (ifc_temp_var): Likewise.
(parse_predicate): Likewise.
(bb_with_exit_edge_p): Likewise.
(if_convertible_phi_p): Likewise.
(memrefs_read_or_written_unconditionally): Likewise.
(write_memrefs_written_at_least_once): Likewise.
(ifcvt_memrefs_wont_trap): Likewise.
(ifcvt_could_trap_p): Likewise.
(ifcvt_can_use_mask_load_store): Likewise.
(if_convertible_gimple_assign_stmt_p): Likewise.
(predicate_bbs): Likewise.
(find_phi_replacement_condition): Likewise.
(is_cond_scalar_reduction): Likewise.
(convert_scalar_cond_reduction): Likewise.
(predicate_scalar_phi): Likewise.
(predicate_all_scalar_phis): Likewise.
(predicate_mem_writes): Likewise.
(version_loop_for_if_conversion): Likewise.
* tree-inline.c (copy_decl_maybe_to_var): Likewise.
(remap_ssa_name): Likewise.
(remap_gimple_seq): Likewise.
(copy_gimple_bind): Likewise.
(remap_eh_region_tree_nr): Likewise.
(remap_gimple_stmt): Likewise.
(copy_bb): Likewise.
(update_ssa_across_abnormal_edges): Likewise.
(copy_edges_for_bb): Likewise.
(copy_phis_for_bb): Likewise.
(maybe_move_debug_stmts_to_successors): Likewise.
(copy_cfg_body): Likewise.
(copy_debug_stmts): Likewise.
(self_inlining_addr_expr): Likewise.
(insert_init_debug_bind): Likewise.
(insert_init_stmt): Likewise.
(setup_one_parameter): Likewise.
(inline_forbidden_p_stmt): Likewise.
(inline_forbidden_p): Likewise.
(estimate_operator_cost): Likewise.
(add_local_variables): Likewise.
(expand_call_inline): Likewise.
(gimple_expand_calls_inline): Likewise.
(fold_marked_statements): Likewise.
(mark_local_labels_stmt): Likewise.
(replace_locals_stmt): Likewise.
(tree_function_versioning): Likewise.
* tree-inline.h (tree): Likewise.
(void): Likewise.
(estimate_num_insns): Likewise.
* tree-into-ssa.c (marked_for_renaming): Likewise.
(rewrite_uses_p): Likewise.
(set_rewrite_uses): Likewise.
(register_defs_p): Likewise.
(initialize_flags_in_bb): Likewise.
(add_new_name_mapping): Likewise.
(find_def_blocks_for): Likewise.
(insert_phi_nodes_for): Likewise.
(get_reaching_def): Likewise.
(rewrite_debug_stmt_uses): Likewise.
(rewrite_stmt): Likewise.
(rewrite_add_phi_arguments): Likewise.
(maybe_replace_use_in_debug_stmt): Likewise.
(maybe_register_def): Likewise.
(rewrite_update_phi_arguments): Likewise.
(make_pass_build_ssa): Likewise.
(mark_def_interesting): Likewise.
(prepare_block_for_update): Likewise.
(prepare_use_sites_for): Likewise.
(prepare_def_site_for): Likewise.
(delete_update_ssa): Likewise.
(mark_virtual_operand_for_renaming): Likewise.
* tree-into-ssa.h (create_new_def_for): Likewise.
(mark_virtual_phi_result_for_renaming): Likewise.
* tree-loop-distribution.c (Copyright): Likewise.
(dot_rdg): Likewise.
(create_edge_for_control_dependence): Likewise.
(create_rdg_cd_edges): Likewise.
(create_rdg_vertices): Likewise.
(stmts_from_loop): Likewise.
(build_rdg): Likewise.
(ssa_name_has_uses_outside_loop_p): Likewise.
(generate_loops_for_partition): Likewise.
(generate_memset_builtin): Likewise.
(generate_memcpy_builtin): Likewise.
(destroy_loop): Likewise.
(classify_partition): Likewise.
(similar_memory_accesses): Likewise.
(rdg_build_partitions): Likewise.
(pgcmp): Likewise.
(distribute_loop): Likewise.
* tree-nested.c (get_chain_field): Likewise.
(init_tmp_var): Likewise.
(save_tmp_var): Likewise.
(walk_function): Likewise.
(convert_nonlocal_reference_stmt): Likewise.
(convert_local_reference_stmt): Likewise.
(convert_nl_goto_reference): Likewise.
(convert_nl_goto_receiver): Likewise.
(convert_tramp_reference_op): Likewise.
(convert_tramp_reference_stmt): Likewise.
(convert_gimple_call): Likewise.
(finalize_nesting_tree_1): Likewise.
* tree-nrv.c (finalize_nrv_r): Likewise.
(make_pass_nrv): Likewise.
(dest_safe_for_nrv_p): Likewise.
* tree-object-size.c (pass_through_call): Likewise.
(addr_object_size): Likewise.
(alloc_object_size): Likewise.
(cond_expr_object_size): Likewise.
(expr_object_size): Likewise.
(merge_object_sizes): Likewise.
(plus_stmt_object_size): Likewise.
(collect_object_sizes_for): Likewise.
(check_for_plus_in_loops_1): Likewise.
(check_for_plus_in_loops): Likewise.
(fini_object_sizes): Likewise.
* tree-outof-ssa.c (ssa_is_replaceable_p): Likewise.
(set_location_for_edge): Likewise.
(eliminate_build): Likewise.
(eliminate_phi): Likewise.
(remove_gimple_phi_args): Likewise.
(eliminate_useless_phis): Likewise.
(rewrite_trees): Likewise.
(maybe_renumber_stmts_bb): Likewise.
(trivially_conflicts_p): Likewise.
(insert_backedge_copies): Likewise.
* tree-outof-ssa.h (get_rtx_for_ssa_name): Likewise.
(get_gimple_for_ssa_name): Likewise.
* tree-parloops.c (printf): Likewise.
(return): Likewise.
(take_address_of): Likewise.
(eliminate_local_variables_stmt): Likewise.
(separate_decls_in_region_name): Likewise.
(separate_decls_in_region_stmt): Likewise.
(create_phi_for_local_result): Likewise.
(create_call_for_reduction_1): Likewise.
(create_loads_for_reductions): Likewise.
(create_final_loads_for_reduction): Likewise.
(create_stores_for_reduction): Likewise.
(create_loads_and_stores_for_name): Likewise.
(separate_decls_in_region): Likewise.
(transform_to_exit_first_loop): Likewise.
(create_parallel_loop): Likewise.
(gen_parallel_loop): Likewise.
(loop_has_vector_phi_nodes): Likewise.
(gather_scalar_reductions): Likewise.
(try_create_reduction_list): Likewise.
* tree-pass.h (void): Likewise.
(ipa_opt_pass_d): Likewise.
(execute_all_ipa_stmt_fixups): Likewise.
* tree-phinodes.c (GTY): Likewise.
(ideal_phi_node_len): Likewise.
(make_phi_node): Likewise.
(reserve_phi_args_for_new_edge): Likewise.
(add_phi_node_to_bb): Likewise.
(create_phi_node): Likewise.
(remove_phi_node): Likewise.
(remove_phi_nodes): Likewise.
* tree-phinodes.h (release_phi_node): Likewise.
(add_phi_node_to_bb): Likewise.
(add_phi_arg): Likewise.
(degenerate_phi_result): Likewise.
(gimple_phi_arg_imm_use_ptr): Likewise.
(phi_arg_index_from_use): Likewise.
* tree-predcom.c (computations): Likewise.
(valid_initializer_p): Likewise.
(find_looparound_phi): Likewise.
(add_looparound_copies): Likewise.
(determine_roots): Likewise.
(replace_ref_with): Likewise.
(initialize_root_vars): Likewise.
(initialize_root_vars_lm): Likewise.
(execute_load_motion): Likewise.
(single_nonlooparound_use): Likewise.
(remove_stmt): Likewise.
(base_names_in_chain_on): Likewise.
(eliminate_temp_copies): Likewise.
(chain_can_be_combined_p): Likewise.
(find_use_stmt): Likewise.
(may_reassociate_p): Likewise.
(find_associative_operation_root): Likewise.
(find_common_use_stmt): Likewise.
(combinable_refs_p): Likewise.
(remove_name_from_operation): Likewise.
(reassociate_to_the_same_stmt): Likewise.
(stmt_combining_refs): Likewise.
(combine_chains): Likewise.
* tree-profile.c (gimple_gen_edge_profiler): Likewise.
(gimple_gen_interval_profiler): Likewise.
(gimple_gen_pow2_profiler): Likewise.
(gimple_gen_one_value_profiler): Likewise.
(gimple_gen_ic_profiler): Likewise.
(gimple_gen_ic_func_profiler): Likewise.
(gimple_gen_time_profiler): Likewise.
(gimple_gen_average_profiler): Likewise.
(gimple_gen_ior_profiler): Likewise.
(tree_profiling): Likewise.
* tree-scalar-evolution.c (chrec_contains_symbols_defined_in_loop):
Likewise.
(get_scalar_evolution): Likewise.
(add_to_evolution_1): Likewise.
(add_to_evolution): Likewise.
(get_loop_exit_condition): Likewise.
(follow_ssa_edge_binary): Likewise.
(follow_ssa_edge_expr): Likewise.
(follow_ssa_edge_in_rhs): Likewise.
(backedge_phi_arg_p): Likewise.
(follow_ssa_edge_in_condition_phi_branch): Likewise.
(follow_ssa_edge_in_condition_phi): Likewise.
(follow_ssa_edge_inner_loop_phi): Likewise.
(simplify_peeled_chrec): Likewise.
(analyze_evolution_in_loop): Likewise.
(analyze_initial_condition): Likewise.
(interpret_loop_phi): Likewise.
(interpret_condition_phi): Likewise.
(interpret_rhs_expr): Likewise.
(interpret_expr): Likewise.
(analyze_scalar_evolution_1): Likewise.
(loop_closed_phi_def): Likewise.
(scev_const_prop): Likewise.
* tree-scalar-evolution.h (number_of_latch_executions): Likewise.
* tree-sra.c (representatives): Likewise.
(get_ssa_base_param): Likewise.
(create_access_1): Likewise.
(disqualify_base_of_expr): Likewise.
(build_access_from_expr_1): Likewise.
(single_non_eh_succ): Likewise.
(disqualify_if_bad_bb_terminating_stmt): Likewise.
(build_accesses_from_assign): Likewise.
(asm_visit_addr): Likewise.
(scan_function): Likewise.
(build_ref_for_offset): Likewise.
(generate_subtree_copies): Likewise.
(init_subtree_with_zero): Likewise.
(sra_modify_expr): Likewise.
(load_assign_lhs_subreplacements): Likewise.
(contains_vce_or_bfcref_p): Likewise.
(sra_modify_assign): Likewise.
(sra_modify_function_body): Likewise.
(ptr_parm_has_direct_uses): Likewise.
(get_adjustment_for_base): Likewise.
(replace_removed_params_ssa_names): Likewise.
(sra_ipa_modify_assign): Likewise.
(ipa_sra_modify_function_body): Likewise.
(sra_ipa_reset_debug_stmts): Likewise.
(convert_callers): Likewise.
* tree-ssa-alias.c (ref_may_alias_global_p): Likewise.
(ao_ref_init_from_ptr_and_size): Likewise.
(refs_output_dependent_p): Likewise.
(ref_maybe_used_by_call_p_1): Likewise.
(ref_maybe_used_by_call_p): Likewise.
(ref_maybe_used_by_stmt_p): Likewise.
(call_may_clobber_ref_p_1): Likewise.
(call_may_clobber_ref_p): Likewise.
(stmt_may_clobber_ref_p_1): Likewise.
(stmt_may_clobber_ref_p): Likewise.
(stmt_kills_ref_p_1): Likewise.
(stmt_kills_ref_p): Likewise.
(maybe_skip_until): Likewise.
(get_continuation_for_phi_1): Likewise.
(walk_non_aliased_vuses): Likewise.
(walk_aliased_vdefs_1): Likewise.
* tree-ssa-alias.h (ref_maybe_used_by_stmt_p): Likewise.
(stmt_may_clobber_global_p): Likewise.
(stmt_may_clobber_ref_p): Likewise.
(stmt_may_clobber_ref_p_1): Likewise.
(call_may_clobber_ref_p): Likewise.
(call_may_clobber_ref_p_1): Likewise.
(stmt_kills_ref_p): Likewise.
(get_continuation_for_phi): Likewise.
* tree-ssa-ccp.c (get_default_value): Likewise.
(get_value_for_expr): Likewise.
(likely_value): Likewise.
(ccp_initialize): Likewise.
(ccp_lattice_meet): Likewise.
(valueize_op): Likewise.
(bit_value_binop): Likewise.
(bit_value_assume_aligned): Likewise.
(insert_clobber_before_stack_restore): Likewise.
(insert_clobbers_for_var): Likewise.
(ccp_fold_stmt): Likewise.
(visit_assignment): Likewise.
(visit_cond_stmt): Likewise.
(optimize_stack_restore): Likewise.
(optimize_unreachable): Likewise.
* tree-ssa-coalesce.c (build_ssa_conflict_graph): Likewise.
(create_outofssa_var_map): Likewise.
(coalesce_partitions): Likewise.
* tree-ssa-copy.c (stmt_may_generate_copy): Likewise.
(dump_copy_of): Likewise.
(copy_prop_visit_assignment): Likewise.
(copy_prop_visit_cond_stmt): Likewise.
(copy_prop_visit_stmt): Likewise.
(init_copy_prop): Likewise.
* tree-ssa-copyrename.c (copy_rename_partition_coalesce): Likewise.
* tree-ssa-dce.c (Copyright): Likewise.
(mark_stmt_necessary): Likewise.
(mark_operand_necessary): Likewise.
(mark_last_stmt_necessary): Likewise.
(find_obviously_necessary_stmts): Likewise.
(mark_aliased_reaching_defs_necessary_1): Likewise.
(mark_all_reaching_defs_necessary_1): Likewise.
(mark_all_reaching_defs_necessary): Likewise.
(propagate_necessity): Likewise.
(remove_dead_phis): Likewise.
(forward_edge_to_pdom): Likewise.
(remove_dead_stmt): Likewise.
(eliminate_unnecessary_stmts): Likewise.
* tree-ssa-dom.c (Copyright): Likewise.
(target): Likewise.
(remove): Likewise.
(lookup_avail_expr): Likewise.
(initialize_hash_element): Likewise.
(iterative_hash_hashable_expr): Likewise.
(print_expr_hash_elt): Likewise.
(free_all_edge_infos): Likewise.
(make_pass_dominator): Likewise.
(restore_vars_to_original_value): Likewise.
(record_equivalences_from_phis): Likewise.
(record_equivalences_from_incoming_edge): Likewise.
(loop_depth_of_name): Likewise.
(record_equality): Likewise.
(simple_iv_increment_p): Likewise.
(cprop_into_successor_phis): Likewise.
(record_edge_info): Likewise.
(eliminate_redundant_computations): Likewise.
(record_equivalences_from_stmt): Likewise.
(cprop_operand): Likewise.
(optimize_stmt): Likewise.
(avail_expr_hash): Likewise.
(remove_stmt_or_phi): Likewise.
(get_rhs_or_phi_arg): Likewise.
(get_lhs_or_phi_result): Likewise.
(propagate_rhs_into_lhs): Likewise.
(eliminate_const_or_copy): Likewise.
(eliminate_degenerate_phis_1): Likewise.
* tree-ssa-dom.h (simple_iv_increment_p): Likewise.
* tree-ssa-dse.c (dse_possible_dead_store_p): Likewise.
(dse_optimize_stmt): Likewise.
* tree-ssa-forwprop.c (get_prop_dest_stmt): Likewise.
(get_prop_source_stmt): Likewise.
(remove_prop_source_from_use): Likewise.
(rhs_to_tree): Likewise.
(combine_cond_expr_cond): Likewise.
(forward_propagate_into_comparison_1): Likewise.
(forward_propagate_into_comparison): Likewise.
(forward_propagate_into_cond): Likewise.
(combine_cond_exprs): Likewise.
(forward_propagate_addr_expr_1): Likewise.
(forward_propagate_addr_expr): Likewise.
(forward_propagate_comparison): Likewise.
(simplify_conversion_from_bitmask): Likewise.
(simplify_not_neg_expr): Likewise.
(simplify_gimple_switch_label_vec): Likewise.
(simplify_gimple_switch): Likewise.
(constant_pointer_difference): Likewise.
(simplify_builtin_call): Likewise.
(truth_valued_ssa_name): Likewise.
(lookup_logical_inverted_value): Likewise.
(defcodefor_name): Likewise.
(simplify_bitwise_binary_boolean): Likewise.
(simplify_bitwise_binary): Likewise.
(simplify_rotate): Likewise.
(associate_plusminus): Likewise.
(associate_pointerplus_align): Likewise.
(associate_pointerplus_diff): Likewise.
(associate_pointerplus): Likewise.
(combine_conversions): Likewise.
(simplify_vce): Likewise.
(simplify_bitfield_ref): Likewise.
(simplify_permutation): Likewise.
(simplify_vector_constructor): Likewise.
(simplify_mult): Likewise.
* tree-ssa-ifcombine.c (bb_no_side_effects_p): Likewise.
(same_phi_args_p): Likewise.
(get_name_for_bit_test): Likewise.
(recognize_single_bit_test): Likewise.
(recognize_bits_test): Likewise.
(ifcombine_ifandif): Likewise.
(tree_ssa_ifcombine_bb): Likewise.
* tree-ssa-live.c (clear_unused_block_pointer): Likewise.
(remove_unused_locals): Likewise.
(set_var_live_on_entry): Likewise.
(calculate_live_on_exit): Likewise.
(verify_live_on_entry): Likewise.
* tree-ssa-loop-ch.c (should_duplicate_loop_header_p): Likewise.
(do_while_loop_p): Likewise.
* tree-ssa-loop-im.c (if): Likewise.
(ref_indep_loop_p): Likewise.
(init_lim_data): Likewise.
(free_lim_aux_data): Likewise.
(clear_lim_data): Likewise.
(outermost_invariant_loop): Likewise.
(add_dependency): Likewise.
(outermost_indep_loop): Likewise.
(simple_mem_ref_in_stmt): Likewise.
(mem_ref_in_stmt): Likewise.
(extract_true_false_args_from_phi): Likewise.
(determine_max_movement): Likewise.
(set_level): Likewise.
(set_profitable_level): Likewise.
(nonpure_call_p): Likewise.
(rewrite_reciprocal): Likewise.
(rewrite_bittest): Likewise.
(force_move_till_op): Likewise.
(mem_ref_alloc): Likewise.
(mark_ref_stored): Likewise.
(execute_sm_if_changed): Likewise.
(execute_sm): Likewise.
* tree-ssa-loop-ivcanon.c (create_canonical_iv): Likewise.
(tree_estimate_loop_size): Likewise.
(remove_exits_and_undefined_stmts): Likewise.
(unloop_loops): Likewise.
(try_unroll_loop_completely): Likewise.
(propagate_into_all_uses): Likewise.
(propagate_constants_for_unrolling): Likewise.
* tree-ssa-loop-ivopts.c (avg_loop_niter): Likewise.
(name_info): Likewise.
(stmt_after_ip_normal_pos): Likewise.
(stmt_after_inc_pos): Likewise.
(get_iv): Likewise.
(find_bivs): Likewise.
(mark_bivs): Likewise.
(find_givs_in_stmt_scev): Likewise.
(find_induction_variables): Likewise.
(find_interesting_uses_op): Likewise.
(extract_cond_operands): Likewise.
(expr_invariant_in_loop_p): Likewise.
(may_be_nonaddressable_p): Likewise.
(find_interesting_uses_address): Likewise.
(find_invariants_stmt): Likewise.
(find_interesting_uses_outside): Likewise.
(find_depends): Likewise.
(add_old_iv_candidates): Likewise.
(computation_cost): Likewise.
(determine_common_wider_type): Likewise.
(get_use_type): Likewise.
(get_loop_invariant_expr_id): Likewise.
(determine_use_iv_cost_address): Likewise.
(expr_equal_p): Likewise.
(difference_cannot_overflow_p): Likewise.
(determine_set_costs): Likewise.
(rewrite_use_nonlinear_expr): Likewise.
(adjust_iv_update_pos): Likewise.
(remove_unused_ivs): Likewise.
(loop_body_includes_call): Likewise.
* tree-ssa-loop-manip.c (create_iv): Likewise.
(add_exit_phi): Likewise.
(find_uses_to_rename_use): Likewise.
(find_uses_to_rename_bb): Likewise.
(check_loop_closed_ssa_use): Likewise.
(verify_loop_closed_ssa): Likewise.
(split_loop_exit_edge): Likewise.
(ip_normal_pos): Likewise.
(standard_iv_increment_position): Likewise.
(tree_transform_and_unroll_loop): Likewise.
(rewrite_phi_with_iv): Likewise.
(canonicalize_loop_ivs): Likewise.
* tree-ssa-loop-niter.c (determine_value_range): Likewise.
(bound_difference): Likewise.
(expand_simple_operations): Likewise.
(simplify_using_initial_conditions): Likewise.
(loop_only_exit_p): Likewise.
(number_of_iterations_exit): Likewise.
(finite_loop_p): Likewise.
(chain_of_csts_start): Likewise.
(get_base_for): Likewise.
(get_val_for): Likewise.
(loop_niter_by_eval): Likewise.
(find_loop_niter_by_eval): Likewise.
(derive_constant_upper_bound_ops): Likewise.
(do_warn_aggressive_loop_optimizations): Likewise.
(record_estimate): Likewise.
(record_nonwrapping_iv): Likewise.
(idx_infer_loop_bounds): Likewise.
(infer_loop_bounds_from_ref): Likewise.
(infer_loop_bounds_from_array): Likewise.
(infer_loop_bounds_from_pointer_arith): Likewise.
(infer_loop_bounds_from_undefined): Likewise.
(maybe_lower_iteration_bound): Likewise.
(estimate_numbers_of_iterations): Likewise.
(stmt_dominates_stmt_p): Likewise.
(nowrap_type_p): Likewise.
* tree-ssa-loop-niter.h (stmt_dominates_stmt_p): Likewise.
(scev_probably_wraps_p): Likewise.
* tree-ssa-loop-prefetch.c (then): Likewise.
(find_or_create_group): Likewise.
(release_mem_refs): Likewise.
(idx_analyze_ref): Likewise.
(analyze_ref): Likewise.
(gather_memory_references): Likewise.
(issue_prefetch_ref): Likewise.
(emit_mfence_after_loop): Likewise.
* tree-ssa-loop-unswitch.c (tree_may_unswitch_on): Likewise.
(simplify_using_entry_checks): Likewise.
(tree_unswitch_single_loop): Likewise.
* tree-ssa-loop.h (tree_num_loop_insns): Likewise.
* tree-ssa-math-opts.c (Copyright): Likewise.
(compute_merit): Likewise.
(insert_reciprocals): Likewise.
(replace_reciprocal): Likewise.
(execute_cse_reciprocals_1): Likewise.
(make_pass_cse_reciprocals): Likewise.
(execute_cse_sincos_1): Likewise.
(powi_as_mults_1): Likewise.
(powi_as_mults): Likewise.
(build_and_insert_call): Likewise.
(build_and_insert_binop): Likewise.
(build_and_insert_ref): Likewise.
(build_and_insert_cast): Likewise.
(gimple_expand_builtin_cabs): Likewise.
(do_shift_rotate): Likewise.
(verify_symbolic_number_p): Likewise.
(find_bswap_1): Likewise.
(find_bswap): Likewise.
(make_pass_optimize_bswap): Likewise.
(is_widening_mult_rhs_p): Likewise.
(is_widening_mult_p): Likewise.
(convert_mult_to_widen): Likewise.
(convert_plusminus_to_widen): Likewise.
(convert_mult_to_fma): Likewise.
* tree-ssa-operands.c (alloc_use): Likewise.
(add_use_op): Likewise.
(finalize_ssa_defs): Likewise.
(cleanup_build_arrays): Likewise.
(append_vuse): Likewise.
(add_virtual_operand): Likewise.
(mark_address_taken): Likewise.
(get_mem_ref_operands): Likewise.
(get_tmr_operands): Likewise.
(maybe_add_call_vops): Likewise.
(get_asm_stmt_operands): Likewise.
(get_expr_operands): Likewise.
(parse_ssa_operands): Likewise.
(build_ssa_operands): Likewise.
(verify_ssa_operands): Likewise.
(free_stmt_operands): Likewise.
(update_stmt_operands): Likewise.
(debug_immediate_uses_for): Likewise.
(unlink_stmt_vdef): Likewise.
(has_zero_uses_1): Likewise.
* tree-ssa-operands.h (verify_ssa_operands): Likewise.
(free_stmt_operands): Likewise.
(update_stmt_operands): Likewise.
(swap_ssa_operands): Likewise.
(unlink_stmt_vdef): Likewise.
* tree-ssa-phiopt.c (tree_ssa_cs_elim): Likewise.
(single_non_singleton_phi_for_edges): Likewise.
(tree_ssa_phiopt_worker): Likewise.
(replace_phi_edge_with_variable): Likewise.
(conditional_replacement): Likewise.
(rhs_is_fed_for_value_replacement): Likewise.
(operand_equal_for_value_replacement): Likewise.
(absorbing_element_p): Likewise.
(value_replacement): Likewise.
(minmax_replacement): Likewise.
(abs_replacement): Likewise.
(neg_replacement): Likewise.
(add_or_mark_expr): Likewise.
(cond_store_replacement): Likewise.
(cond_if_else_store_replacement_1): Likewise.
(cond_if_else_store_replacement): Likewise.
(local_mem_dependence): Likewise.
(hoist_adjacent_loads): Likewise.
* tree-ssa-phiprop.c (phivn_valid_p): Likewise.
(phiprop_insert_phi): Likewise.
(propagate_with_phi): Likewise.
* tree-ssa-pre.c (translate_vuse_through_block): Likewise.
(phi_translate_1): Likewise.
(value_dies_in_block_x): Likewise.
(prune_clobbered_mems): Likewise.
(create_expression_by_pieces): Likewise.
(insert_into_preds_of_block): Likewise.
(do_regular_insertion): Likewise.
(compute_avail): Likewise.
(eliminate_insert): Likewise.
(eliminate): Likewise.
(fini_eliminate): Likewise.
(mark_operand_necessary): Likewise.
(remove_dead_inserted_code): Likewise.
* tree-ssa-propagate.c (block): Likewise.
(reexamined): Likewise.
(add_ssa_edge): Likewise.
(add_control_edge): Likewise.
(simulate_stmt): Likewise.
(process_ssa_edge_worklist): Likewise.
(simulate_block): Likewise.
(valid_gimple_call_p): Likewise.
(move_ssa_defining_stmt_for_defs): Likewise.
(update_gimple_call): Likewise.
(update_call_from_tree): Likewise.
(ssa_propagate): Likewise.
(stmt_makes_single_store): Likewise.
(replace_uses_in): Likewise.
(substitute_and_fold): Likewise.
(may_propagate_copy): Likewise.
(propagate_tree_value_into_stmt): Likewise.
* tree-ssa-propagate.h (prop_set_simulate_again): Likewise.
(prop_simulate_again_p): Likewise.
* tree-ssa-reassoc.c (reassoc_remove_stmt): Likewise.
(phi_rank): Likewise.
(loop_carried_phi): Likewise.
(get_rank): Likewise.
(sort_by_operand_rank): Likewise.
(add_repeat_to_ops_vec): Likewise.
(get_unary_op): Likewise.
(eliminate_using_constants): Likewise.
(oecount_cmp): Likewise.
(stmt_is_power_of_op): Likewise.
(decrement_power): Likewise.
(propagate_op_to_single_use): Likewise.
(zero_one_operation): Likewise.
(reassoc_stmt_dominates_stmt_p): Likewise.
(insert_stmt_after): Likewise.
(build_and_add_sum): Likewise.
(undistribute_ops_list): Likewise.
(eliminate_redundant_comparison): Likewise.
(optimize_ops_list): Likewise.
(update_range_test): Likewise.
(optimize_range_tests): Likewise.
(final_range_test_p): Likewise.
(suitable_cond_bb): Likewise.
(no_side_effect_bb): Likewise.
(get_ops): Likewise.
(update_ops): Likewise.
(maybe_optimize_range_tests): Likewise.
(is_phi_for_stmt): Likewise.
(remove_visited_stmt_chain): Likewise.
(swap_ops_for_binary_stmt): Likewise.
(find_insert_point): Likewise.
(rewrite_expr_tree): Likewise.
(get_reassociation_width): Likewise.
(rewrite_expr_tree_parallel): Likewise.
(linearize_expr): Likewise.
(get_single_immediate_use): Likewise.
(negate_value): Likewise.
(should_break_up_subtract): Likewise.
(break_up_subtract): Likewise.
(acceptable_pow_call): Likewise.
(linearize_expr_tree): Likewise.
(repropagate_negates): Likewise.
(break_up_subtract_bb): Likewise.
(compare_repeat_factors): Likewise.
(attempt_builtin_powi): Likewise.
(transform_stmt_to_copy): Likewise.
(reassociate_bb): Likewise.
* tree-ssa-sccvn.c (vn_get_expr_for): Likewise.
(ao_ref_init_from_vn_reference): Likewise.
(copy_reference_ops_from_call): Likewise.
(vn_reference_maybe_forwprop_address): Likewise.
(valueize_shared_reference_ops_from_ref): Likewise.
(vn_reference_lookup_3): Likewise.
(init_vn_nary_op_from_op): Likewise.
(vn_nary_length_from_stmt): Likewise.
(vn_nary_op_lookup): Likewise.
(vn_nary_op_insert): Likewise.
(vn_phi_eq): Likewise.
(vn_phi_lookup): Likewise.
(mark_use_processed): Likewise.
(visit_copy): Likewise.
(visit_nary_op): Likewise.
(visit_reference_op_call): Likewise.
(visit_reference_op_load): Likewise.
(visit_reference_op_store): Likewise.
(expr_has_constants): Likewise.
(stmt_has_constants): Likewise.
(simplify_binary_expression): Likewise.
(simplify_unary_expression): Likewise.
(visit_use): Likewise.
(compare_ops): Likewise.
(DFS): Likewise.
* tree-ssa-sccvn.h (sizeof_vn_nary_op): Likewise.
(vn_constant_eq_with_type): Likewise.
* tree-ssa-sink.c (find_bb_for_arg): Likewise.
(all_immediate_uses_same_place): Likewise.
(nearest_common_dominator_of_uses): Likewise.
(select_best_block): Likewise.
(statement_sink_location): Likewise.
(sink_code_in_bb): Likewise.
* tree-ssa-strlen.c (literal): Likewise.
(tree_map_base_eq): Likewise.
(get_string_length): Likewise.
(find_equal_ptrs): Likewise.
(adjust_last_stmt): Likewise.
(handle_builtin_strlen): Likewise.
(handle_builtin_strchr): Likewise.
(handle_builtin_strcpy): Likewise.
(handle_builtin_memcpy): Likewise.
(handle_builtin_strcat): Likewise.
(handle_pointer_plus): Likewise.
(handle_char_store): Likewise.
(strlen_optimize_stmt): Likewise.
(do_invalidate): Likewise.
* tree-ssa-structalias.c (new_var_info): Likewise.
(get_call_vi): Likewise.
(lookup_call_use_vi): Likewise.
(lookup_call_clobber_vi): Likewise.
(get_call_use_vi): Likewise.
(get_function_part_constraint): Likewise.
(handle_rhs_call): Likewise.
(handle_lhs_call): Likewise.
(handle_const_call): Likewise.
(handle_pure_call): Likewise.
(get_fi_for_callee): Likewise.
(find_func_aliases_for_builtin_call): Likewise.
(find_func_aliases_for_call): Likewise.
(find_func_aliases): Likewise.
(process_ipa_clobber): Likewise.
(find_func_clobbers): Likewise.
(compute_points_to_sets): Likewise.
(ipa_pta_execute): Likewise.
* tree-ssa-tail-merge.c (stmt_local_def): Likewise.
(gsi_advance_fw_nondebug_nonlocal): Likewise.
(update_dep_bb): Likewise.
(same_succ_hash): Likewise.
(inverse_flags): Likewise.
(release_last_vdef): Likewise.
(gimple_operand_equal_value_p): Likewise.
(gsi_advance_bw_nondebug_nonlocal): Likewise.
(find_duplicate): Likewise.
(same_phi_alternatives_1): Likewise.
(bb_has_non_vop_phi): Likewise.
(find_clusters): Likewise.
(vop_phi): Likewise.
(replace_block_by): Likewise.
(apply_clusters): Likewise.
(update_debug_stmt): Likewise.
(update_debug_stmts): Likewise.
* tree-ssa-ter.c (finished_with_expr): Likewise.
(ter_is_replaceable_p): Likewise.
(find_ssaname): Likewise.
(find_replaceable_in_bb): Likewise.
* tree-ssa-threadedge.c (potentially_threadable_block): Likewise.
(lhs_of_dominating_assert): Likewise.
(record_temporary_equivalences_from_phis): Likewise.
(invalidate_equivalences): Likewise.
(record_temporary_equivalences_from_stmts_at_dest): Likewise.
(dummy_simplify): Likewise.
(simplify_control_stmt_condition): Likewise.
(propagate_threaded_block_debug_into): Likewise.
(thread_around_empty_blocks): Likewise.
(thread_through_normal_block): Likewise.
(thread_across_edge): Likewise.
* tree-ssa-threadedge.h (thread_across_edge): Likewise.
* tree-ssa-threadupdate.c (copy_phi_arg_into_existing_phi): Likewise.
(get_value_locus_in_path): Likewise.
(copy_phi_args): Likewise.
(phi_args_equal_on_edges): Likewise.
(bb_ends_with_multiway_branch): Likewise.
* tree-ssa-uncprop.c (associate_equivalences_with_edges): Likewise.
(uncprop_into_successor_phis): Likewise.
* tree-ssa-uninit.c (warn_uninit): Likewise.
(warn_uninitialized_vars): Likewise.
(can_skip_redundant_opnd): Likewise.
(convert_control_dep_chain_into_preds): Likewise.
(find_predicates): Likewise.
(collect_phi_def_edges): Likewise.
(find_def_preds): Likewise.
(find_matching_predicate_in_rest_chains): Likewise.
(prune_uninit_phi_opnds_in_unrealizable_paths): Likewise.
(use_pred_not_overlap_with_undef_path_pred): Likewise.
(simplify_pred): Likewise.
(simplify_preds_4): Likewise.
(push_to_worklist): Likewise.
(get_pred_info_from_cmp): Likewise.
(is_degenerated_phi): Likewise.
(normalize_one_pred_1): Likewise.
(normalize_one_pred): Likewise.
(normalize_one_pred_chain): Likewise.
(normalize_preds): Likewise.
(is_use_properly_guarded): Likewise.
(find_uninit_use): Likewise.
(warn_uninitialized_phi): Likewise.
(gate_warn_uninitialized): Likewise.
* tree-ssa.c (ssa_redirect_edge): Likewise.
(flush_pending_stmts): Likewise.
(insert_debug_temp_for_var_def): Likewise.
(insert_debug_temps_for_defs): Likewise.
(reset_debug_uses): Likewise.
(release_defs_bitset): Likewise.
(verify_ssa_name): Likewise.
(verify_def): Likewise.
(verify_use): Likewise.
(verify_ssa): Likewise.
(ssa_undefined_value_p): Likewise.
(execute_update_addresses_taken): Likewise.
* tree-ssa.h (gimple_replace_ssa_lhs): Likewise.
(reset_debug_uses): Likewise.
* tree-ssanames.c (ssanames_print_statistics): Likewise.
(get_ptr_info): Likewise.
(duplicate_ssa_name_range_info): Likewise.
(duplicate_ssa_name_fn): Likewise.
* tree-ssanames.h (make_ssa_name_fn): Likewise.
(copy_ssa_name_fn): Likewise.
(duplicate_ssa_name_fn): Likewise.
(release_defs): Likewise.
(make_ssa_name): Likewise.
(copy_ssa_name): Likewise.
(release_ssa_name): Likewise.
* tree-stdarg.c (va_list_counter_bump): Likewise.
(check_all_va_list_escapes): Likewise.
* tree-switch-conversion.c (hoist_edge_and_branch_if_true): Likewise.
(case_bit_test_cmp): Likewise.
(emit_case_bit_tests): Likewise.
(check_final_bb): Likewise.
(gather_default_values): Likewise.
(build_constructors): Likewise.
(constructor_contains_same_values_p): Likewise.
(array_value_type): Likewise.
(build_one_array): Likewise.
(build_arrays): Likewise.
(gen_def_assigns): Likewise.
(fix_phi_nodes): Likewise.
(gen_inbound_check): Likewise.
(process_switch): Likewise.
* tree-tailcall.c (suitable_for_tail_call_opt_p): Likewise.
(independent_of_stmt_p): Likewise.
(propagate_through_phis): Likewise.
(find_tail_calls): Likewise.
(adjust_return_value_with_ops): Likewise.
(update_accumulator_with_ops): Likewise.
(adjust_return_value): Likewise.
(eliminate_tail_call): Likewise.
(optimize_tail_call): Likewise.
(create_tailcall_accumulator): Likewise.
(tree_optimize_tail_calls_1): Likewise.
* tree-vect-data-refs.c (vect_lanes_optab_supported_p): Likewise.
(vect_analyze_data_ref_dependence): Likewise.
(vect_slp_analyze_data_ref_dependence): Likewise.
(vect_compute_data_ref_alignment): Likewise.
(vect_verify_datarefs_alignment): Likewise.
(vector_alignment_reachable_p): Likewise.
(vect_get_data_access_cost): Likewise.
(vect_peeling_hash_get_lowest_cost): Likewise.
(vect_enhance_data_refs_alignment): Likewise.
(vect_analyze_group_access): Likewise.
(vect_analyze_data_ref_access): Likewise.
(vect_prune_runtime_alias_test_list): Likewise.
(vect_check_gather): Likewise.
(vect_analyze_data_refs): Likewise.
(vect_get_new_vect_var): Likewise.
(vect_create_addr_base_for_vector_ref): Likewise.
(vect_create_data_ref_ptr): Likewise.
(bump_vector_ptr): Likewise.
(vect_store_lanes_supported): Likewise.
(vect_permute_store_chain): Likewise.
(vect_setup_realignment): Likewise.
(vect_load_lanes_supported): Likewise.
(vect_permute_load_chain): Likewise.
(vect_transform_grouped_load): Likewise.
(vect_record_grouped_load_vectors): Likewise.
(vect_supportable_dr_alignment): Likewise.
* tree-vect-generic.c (expand_vector_divmod): Likewise.
(expand_vector_condition): Likewise.
(optimize_vector_constructor): Likewise.
(vector_element): Likewise.
(lower_vec_perm): Likewise.
(expand_vector_operations_1): Likewise.
* tree-vect-loop-manip.c (rename_variables_in_bb): Likewise.
(adjust_debug_stmts_now): Likewise.
(adjust_debug_stmts): Likewise.
(slpeel_update_phi_nodes_for_guard1): Likewise.
(slpeel_update_phi_nodes_for_guard2): Likewise.
(slpeel_make_loop_iterate_ntimes): Likewise.
(slpeel_duplicate_current_defs_from_edges): Likewise.
(slpeel_tree_duplicate_loop_to_edge_cfg): Likewise.
(slpeel_add_loop_guard): Likewise.
(slpeel_can_duplicate_loop_p): Likewise.
(set_prologue_iterations): Likewise.
(slpeel_tree_peel_loop_to_edge): Likewise.
(find_loop_location): Likewise.
(vect_can_advance_ivs_p): Likewise.
(vect_update_ivs_after_vectorizer): Likewise.
(vect_gen_niters_for_prolog_loop): Likewise.
(vect_create_cond_for_align_checks): Likewise.
(vect_loop_versioning): Likewise.
* tree-vect-loop.c (vect_determine_vectorization_factor): Likewise.
(vect_analyze_scalar_cycles_1): Likewise.
(vect_analyze_scalar_cycles): Likewise.
(new_loop_vec_info): Likewise.
(destroy_loop_vec_info): Likewise.
(vect_analyze_loop_form): Likewise.
(vect_analyze_loop_operations): Likewise.
(reduction_code_for_scalar_code): Likewise.
(report_vect_op): Likewise.
(vect_is_slp_reduction): Likewise.
(vect_is_simple_reduction_1): Likewise.
(vect_is_simple_reduction): Likewise.
(vect_get_single_scalar_iteration_cost): Likewise.
(vect_model_reduction_cost): Likewise.
(vect_model_induction_cost): Likewise.
(get_initial_def_for_induction): Likewise.
(get_initial_def_for_reduction): Likewise.
(vect_create_epilog_for_reduction): Likewise.
(vectorizable_reduction): Likewise.
(vect_min_worthwhile_factor): Likewise.
(vectorizable_induction): Likewise.
(vectorizable_live_operation): Likewise.
(vect_loop_kill_debug_uses): Likewise.
(vect_generate_tmps_on_preheader): Likewise.
(vect_transform_loop): Likewise.
* tree-vect-patterns.c (Copyright): Likewise.
(append_pattern_def_seq): Likewise.
(new_pattern_def_seq): Likewise.
(vect_same_loop_or_bb_p): Likewise.
(vect_single_imm_use): Likewise.
(type_conversion_p): Likewise.
(vect_recog_temp_ssa_var): Likewise.
(vect_recog_dot_prod_pattern): Likewise.
(vect_handle_widen_op_by_const): Likewise.
(vect_recog_widen_mult_pattern): Likewise.
(vect_recog_pow_pattern): Likewise.
(vect_recog_widen_sum_pattern): Likewise.
(vect_operation_fits_smaller_type): Likewise.
(vect_recog_over_widening_pattern): Likewise.
(vect_recog_widen_shift_pattern): Likewise.
(vect_recog_rotate_pattern): Likewise.
(vect_recog_vector_vector_shift_pattern): Likewise.
(vect_recog_divmod_pattern): Likewise.
(vect_recog_mixed_size_cond_pattern): Likewise.
(check_bool_pattern): Likewise.
(adjust_bool_pattern_cast): Likewise.
(adjust_bool_pattern): Likewise.
(vect_recog_bool_pattern): Likewise.
(vect_mark_pattern_stmts): Likewise.
(vect_pattern_recog_1): Likewise.
(vect_pattern_recog): Likewise.
* tree-vect-slp.c (find_bb_location): Likewise.
(vect_free_slp_instance): Likewise.
(vect_create_new_slp_node): Likewise.
(vect_free_oprnd_info): Likewise.
(vect_get_place_in_interleaving_chain): Likewise.
(vect_get_and_check_slp_defs): Likewise.
(vect_build_slp_tree_1): Likewise.
(vect_build_slp_tree): Likewise.
(vect_print_slp_tree): Likewise.
(vect_mark_slp_stmts): Likewise.
(vect_mark_slp_stmts_relevant): Likewise.
(vect_slp_rearrange_stmts): Likewise.
(vect_supported_load_permutation_p): Likewise.
(vect_find_first_load_in_slp_instance): Likewise.
(vect_find_last_store_in_slp_instance): Likewise.
(vect_analyze_slp_cost_1): Likewise.
(vect_analyze_slp_cost): Likewise.
(vect_analyze_slp_instance): Likewise.
(vect_analyze_slp): Likewise.
(vect_detect_hybrid_slp_stmts): Likewise.
(new_bb_vec_info): Likewise.
(destroy_bb_vec_info): Likewise.
(vect_slp_analyze_node_operations): Likewise.
(vect_bb_slp_scalar_cost): Likewise.
(vect_slp_analyze_bb): Likewise.
(vect_get_constant_vectors): Likewise.
(vect_get_slp_vect_defs): Likewise.
(vect_get_slp_defs): Likewise.
(vect_create_mask_and_perm): Likewise.
(vect_transform_slp_perm_load): Likewise.
(vect_schedule_slp_instance): Likewise.
(vect_remove_slp_scalar_calls): Likewise.
(vect_schedule_slp): Likewise.
(vect_slp_transform_bb): Likewise.
* tree-vect-stmts.c (stmt_in_inner_loop_p): Likewise.
(create_vector_array): Likewise.
(read_vector_array): Likewise.
(write_vector_array): Likewise.
(create_array_ref): Likewise.
(vect_mark_relevant): Likewise.
(vect_stmt_relevant_p): Likewise.
(exist_non_indexing_operands_for_use_p): Likewise.
(process_use): Likewise.
(vect_mark_stmts_to_be_vectorized): Likewise.
(vect_cost_group_size): Likewise.
(vect_model_store_cost): Likewise.
(vect_get_store_cost): Likewise.
(vect_model_load_cost): Likewise.
(vect_get_load_cost): Likewise.
(vect_init_vector_1): Likewise.
(vect_init_vector): Likewise.
(vect_get_vec_def_for_operand): Likewise.
(vect_get_vec_def_for_stmt_copy): Likewise.
(vect_get_vec_defs_for_stmt_copy): Likewise.
(vect_get_vec_defs): Likewise.
(vect_finish_stmt_generation): Likewise.
(vectorizable_function): Likewise.
(vectorizable_mask_load_store): Likewise.
(vectorizable_call): Likewise.
(vectorizable_simd_clone_call): Likewise.
(vect_gen_widened_results_half): Likewise.
(vect_get_loop_based_defs): Likewise.
(vect_create_vectorized_demotion_stmts): Likewise.
(vect_create_vectorized_promotion_stmts): Likewise.
(vectorizable_conversion): Likewise.
(vectorizable_assignment): Likewise.
(vect_supportable_shift): Likewise.
(vectorizable_shift): Likewise.
(vectorizable_operation): Likewise.
(perm_mask_for_reverse): Likewise.
(vectorizable_store): Likewise.
(vect_gen_perm_mask): Likewise.
(permute_vec_elements): Likewise.
(hoist_defs_of_uses): Likewise.
(vectorizable_load): Likewise.
(vect_is_simple_cond): Likewise.
(vectorizable_condition): Likewise.
(vect_analyze_stmt): Likewise.
(vect_transform_stmt): Likewise.
(vect_remove_stores): Likewise.
(free_stmt_vec_info_vec): Likewise.
(free_stmt_vec_info): Likewise.
(get_same_sized_vectype): Likewise.
(vect_is_simple_use): Likewise.
(vect_is_simple_use_1): Likewise.
(supportable_widening_operation): Likewise.
* tree-vectorizer.c (adjust_simduid_builtins): Likewise.
(note_simd_array_uses): Likewise.
(vect_destroy_datarefs): Likewise.
(vect_loop_vectorized_call): Likewise.
(fold_loop_vectorized_call): Likewise.
(vectorize_loops): Likewise.
* tree-vectorizer.h (Copyright): Likewise.
(add_stmt_info_to_vec): Likewise.
(loop_vec_info_for_loop): Likewise.
(nested_in_vect_loop_p): Likewise.
(vec_info_for_bb): Likewise.
(vinfo_for_stmt): Likewise.
(set_vinfo_for_stmt): Likewise.
(get_earlier_stmt): Likewise.
(is_pattern_stmt_p): Likewise.
(unlimited_cost_model): Likewise.
* tree-vrp.c (live_on_edge): Likewise.
(is_overflow_infinity): Likewise.
(usable_range_p): Likewise.
(gimple_assign_nonnegative_warnv_p): Likewise.
(gimple_call_nonnegative_warnv_p): Likewise.
(gimple_stmt_nonnegative_warnv_p): Likewise.
(gimple_assign_nonzero_warnv_p): Likewise.
(gimple_stmt_nonzero_warnv_p): Likewise.
(extract_range_from_unary_expr): Likewise.
(extract_range_from_comparison): Likewise.
(extract_range_basic): Likewise.
(extract_range_from_assignment): Likewise.
(debug_all_value_ranges): Likewise.
(build_assert_expr_for): Likewise.
(fp_predicate): Likewise.
(register_edge_assert_for_2): Likewise.
(register_edge_assert_for_1): Likewise.
(register_edge_assert_for): Likewise.
(compare_case_labels): Likewise.
(find_assert_locations_1): Likewise.
(find_assert_locations): Likewise.
(process_assert_insertions_for): Likewise.
(search_for_addr_array): Likewise.
(check_all_array_refs): Likewise.
(all_imm_uses_in_stmt_or_feed_cond): Likewise.
(maybe_set_nonzero_bits): Likewise.
(remove_range_assertions): Likewise.
(vrp_initialize): Likewise.
(vrp_valueize): Likewise.
(vrp_evaluate_conditional_warnv_with_ops): Likewise.
(vrp_evaluate_conditional): Likewise.
(vrp_visit_cond_stmt): Likewise.
(find_case_label_index): Likewise.
(find_case_label_range): Likewise.
(find_case_label_ranges): Likewise.
(vrp_visit_switch_stmt): Likewise.
(vrp_meet): Likewise.
(vrp_visit_phi_node): Likewise.
(simplify_truth_ops_using_ranges): Likewise.
(simplify_div_or_mod_using_ranges): Likewise.
(simplify_abs_using_ranges): Likewise.
(range_fits_type_p): Likewise.
(simplify_cond_using_ranges): Likewise.
(simplify_switch_using_ranges): Likewise.
(simplify_conversion_using_ranges): Likewise.
(simplify_float_conversion_using_ranges): Likewise.
(simplify_internal_call_using_ranges): Likewise.
(simplify_stmt_using_ranges): Likewise.
(fold_predicate_in): Likewise.
(vrp_fold_stmt): Likewise.
(identify_jump_threads): Likewise.
* tree.c (find_decls_types_in_node): Likewise.
* tree.h (tree_int_cst_compare): Likewise.
* tsan.c (get_memory_access_decl): Likewise.
(instrument_expr): Likewise.
(instrument_builtin_call): Likewise.
(instrument_gimple): Likewise.
(instrument_func_entry): Likewise.
(instrument_func_exit): Likewise.
* ubsan.c (ubsan_expand_null_ifn): Likewise.
(instrument_member_call): Likewise.
(instrument_mem_ref): Likewise.
(instrument_null): Likewise.
(instrument_si_overflow): Likewise.
(instrument_bool_enum_load): Likewise.
* value-prof.c (gimple_alloc_histogram_value): Likewise.
(histogram_eq): Likewise.
(set_histogram_value): Likewise.
(gimple_histogram_value): Likewise.
(gimple_add_histogram_value): Likewise.
(gimple_remove_histogram_value): Likewise.
(stream_out_histogram_value): Likewise.
(stream_in_histogram_value): Likewise.
(dump_histograms_for_stmt): Likewise.
(gimple_remove_stmt_histograms): Likewise.
(gimple_duplicate_stmt_histograms): Likewise.
(verify_histograms): Likewise.
(free_histograms): Likewise.
(gimple_value_profile_transformations): Likewise.
(gimple_divmod_fixed_value): Likewise.
(gimple_divmod_fixed_value_transform): Likewise.
(gimple_mod_pow2): Likewise.
(gimple_mod_pow2_value_transform): Likewise.
(gimple_mod_subtract): Likewise.
(gimple_mod_subtract_transform): Likewise.
(find_func_by_profile_id): Likewise.
(check_ic_target): Likewise.
(gimple_ic): Likewise.
(gimple_ic_transform): Likewise.
(interesting_stringop_to_profile_p): Likewise.
(gimple_stringop_fixed_value): Likewise.
(gimple_stringops_transform): Likewise.
(stringop_block_profile): Likewise.
(gimple_divmod_values_to_profile): Likewise.
(gimple_indirect_call_to_profile): Likewise.
(gimple_stringops_values_to_profile): Likewise.
* value-prof.h (Copyright): Likewise.
(gimple_histogram_value): Likewise.
(gimple_histogram_value_of_type): Likewise.
(gimple_add_histogram_value): Likewise.
(dump_histograms_for_stmt): Likewise.
(gimple_remove_histogram_value): Likewise.
(gimple_remove_stmt_histograms): Likewise.
(gimple_duplicate_stmt_histograms): Likewise.
(gimple_move_stmt_histograms): Likewise.
(stringop_block_profile): Likewise.
(gimple_ic): Likewise.
(stream_in_histogram_value): Likewise.
* vtable-verify.c (find_or_create_vtbl_map_node): Likewise.
(var_is_used_for_virtual_call_p): Likewise.
(verify_bb_vtables): Likewise.

gcc/c-family/

Patch autogenerated by rename_gimple.py from
https://github.com/davidmalcolm/gcc-refactoring-scripts
revision d0dcc1bc64a800765492e0c76ba714090414f555

* c-gimplify.c (add_block_to_enclosing): Replace "gimple" typedef with
"gimple *".

gcc/cp/

Patch autogenerated by rename_gimple.py from
https://github.com/davidmalcolm/gcc-refactoring-scripts
revision d0dcc1bc64a800765492e0c76ba714090414f555

* cp-gimplify.c (gimplify_must_not_throw_expr): Replace "gimple"
typedef with "gimple *".

gcc/java/

Patch autogenerated by rename_gimple.py from
https://github.com/davidmalcolm/gcc-refactoring-scripts
revision d0dcc1bc64a800765492e0c76ba714090414f555

* java-gimplify.c (java_gimplify_block): Replace "gimple" typedef with
"gimple *".
David Malcolm
2014-05-12 21:36:00 UTC
Permalink
gcc/
* coretypes.h (gimple): Drop typedef.
(const_gimple): Likewise.
(gimple_seq): Convert from being a "gimple" to a "gimple *".

* gimple.h (gimple_statement_base): Rename to...
(gimple): ...this.
(gimple_statement_with_ops_base): Rename to...
(gimple_with_ops_base): ...this.
(gimple_statement_with_ops): Rename to...
(gimple_with_ops): ...this.
(gimple_statement_with_memory_ops_base): Rename to...
(gimple_with_memory_ops_base): ...this.
(gimple_statement_with_memory_ops): Rename to...
(gimple_with_memory_ops): ...this.
(gimple_statement_call): Rename to...
(gcall): ...this.
(gimple_statement_omp): Rename to...
(gomp): ...this.
(gimple_statement_bind): Rename to...
(gbind): ...this.
(gimple_statement_catch): Rename to...
(gcatch): ...this.
(gimple_statement_eh_filter): Rename to...
(geh_filter): ...this.
(gimple_statement_eh_else): Rename to...
(geh_else): ...this.
(gimple_statement_eh_mnt): Rename to...
(geh_mnt): ...this.
(gimple_statement_phi): Rename to...
(gphi): ...this.
(gimple_statement_eh_ctrl): Rename to...
(geh_ctrl): ...this.
(gimple_statement_resx): Rename to...
(gresx): ...this.
(gimple_statement_eh_dispatch): Rename to...
(geh_dispatch): ...this.
(gimple_statement_try): Rename to...
(gtry): ...this.
(gimple_statement_wce): Rename to...
(gwce): ...this.
(gimple_statement_asm): Rename to...
(gasm): ...this.
(gimple_statement_omp_critical): Rename to...
(gomp_critical): ...this.
(gimple_statement_omp_for): Rename to...
(gomp_for): ...this.
(gimple_statement_omp_parallel_layout): Rename to...
(gomp_parallel_layout): ...this.
(gimple_statement_omp_taskreg): Rename to...
(gomp_taskreg): ...this.
(gimple_statement_omp_parallel): Rename to...
(gomp_parallel): ...this.
(gimple_statement_omp_target): Rename to...
(gomp_target): ...this.
(gimple_statement_omp_task): Rename to...
(gomp_task): ...this.
(gimple_statement_omp_sections): Rename to...
(gomp_sections): ...this.
(gimple_statement_omp_continue): Rename to...
(gomp_continue): ...this.
(gimple_statement_omp_single_layout): Rename to...
(gomp_single_layout): ...this.
(gimple_statement_omp_single): Rename to...
(gomp_single): ...this.
(gimple_statement_omp_teams): Rename to...
(gomp_teams): ...this.
(gimple_statement_omp_atomic_load): Rename to...
(gomp_atomic_load): ...this.
(gimple_statement_omp_atomic_store_layout): Rename to...
(gomp_atomic_store_layout): ...this.
(gimple_statement_omp_atomic_store): Rename to...
(gomp_atomic_store): ...this.
(gimple_statement_omp_return): Rename to...
(gomp_return): ...this.
(gimple_statement_transaction): Rename to...
(gtransaction): ...this.

(is_a_helper <gimple_statement_asm *>::test): Rename to...
(is_a_helper <gasm *>::test): ...this.
(is_a_helper <gimple_statement_bind *>::test): Rename to...
(is_a_helper <gbind *>::test): ...this.
(is_a_helper <gimple_statement_call *>::test): Rename to...
(is_a_helper <gcall *>::test): ...this.
(is_a_helper <gimple_statement_catch *>::test): Rename to...
(is_a_helper <gcatch *>::test): ...this.
(is_a_helper <gimple_statement_resx *>::test): Rename to...
(is_a_helper <gresx *>::test): ...this.
(is_a_helper <gimple_statement_eh_dispatch *>::test): Rename to...
(is_a_helper <geh_dispatch *>::test): ...this.
(is_a_helper <gimple_statement_eh_else *>::test): Rename to...
(is_a_helper <geh_else *>::test): ...this.
(is_a_helper <gimple_statement_eh_filter *>::test): Rename to...
(is_a_helper <geh_filter *>::test): ...this.
(is_a_helper <gimple_statement_eh_mnt *>::test): Rename to...
(is_a_helper <geh_mnt *>::test): ...this.
(is_a_helper <gimple_statement_omp_atomic_load *>::test): Rename to...
(is_a_helper <gomp_atomic_load *>::test): ...this.
(is_a_helper <gimple_statement_omp_atomic_store *>::test): Rename to...
(is_a_helper <gomp_atomic_store *>::test): ...this.
(is_a_helper <gimple_statement_omp_return *>::test): Rename to...
(is_a_helper <gomp_return *>::test): ...this.
(is_a_helper <gimple_statement_omp_continue *>::test): Rename to...
(is_a_helper <gomp_continue *>::test): ...this.
(is_a_helper <gimple_statement_omp_critical *>::test): Rename to...
(is_a_helper <gomp_critical *>::test): ...this.
(is_a_helper <gimple_statement_omp_for *>::test): Rename to...
(is_a_helper <gomp_for *>::test): ...this.
(is_a_helper <gimple_statement_omp_taskreg *>::test): Rename to...
(is_a_helper <gomp_taskreg *>::test): ...this.
(is_a_helper <gimple_statement_omp_parallel *>::test): Rename to...
(is_a_helper <gomp_parallel *>::test): ...this.
(is_a_helper <gimple_statement_omp_target *>::test): Rename to...
(is_a_helper <gomp_target *>::test): ...this.
(is_a_helper <gimple_statement_omp_sections *>::test): Rename to...
(is_a_helper <gomp_sections *>::test): ...this.
(is_a_helper <gimple_statement_omp_single *>::test): Rename to...
(is_a_helper <gomp_single *>::test): ...this.
(is_a_helper <gimple_statement_omp_teams *>::test): Rename to...
(is_a_helper <gomp_teams *>::test): ...this.
(is_a_helper <gimple_statement_omp_task *>::test): Rename to...
(is_a_helper <gomp_task *>::test): ...this.
(is_a_helper <gimple_statement_phi *>::test): Rename to...
(is_a_helper <gphi *>::test): ...this.
(is_a_helper <gimple_statement_transaction *>::test): Rename to...
(is_a_helper <gtransaction *>::test): ...this.
(is_a_helper <gimple_statement_try *>::test): Rename to...
(is_a_helper <gtry *>::test): ...this.
(is_a_helper <gimple_statement_wce *>::test): Rename to...
(is_a_helper <gwce *>::test): ...this.
(is_a_helper <gimple_statement_with_ops *>::test): Rename to...
(is_a_helper <gwith_ops *>::test): ...this.
(is_a_helper <gimple_statement_with_memory_ops *>::test): Rename to...
(is_a_helper <gwith_memory_ops *>::test): ...this.

(is_a_helper <const gimple_statement_asm *>::test): Rename to...
(is_a_helper <const gasm *>::test): ...this.
(is_a_helper <const gimple_statement_bind *>::test): Rename to...
(is_a_helper <const gbind *>::test): ...this.
(is_a_helper <const gimple_statement_call *>::test): Rename to...
(is_a_helper <const gcall *>::test): ...this.
(is_a_helper <const gimple_statement_catch *>::test): Rename to...
(is_a_helper <const gcatch *>::test): ...this.
(is_a_helper <const gimple_statement_resx *>::test): Rename to...
(is_a_helper <const gresx *>::test): ...this.
(is_a_helper <const gimple_statement_eh_dispatch *>::test): Rename to...
(is_a_helper <const geh_dispatch *>::test): ...this.
(is_a_helper <const gimple_statement_eh_filter *>::test): Rename to...
(is_a_helper <const geh_filter *>::test): ...this.
(is_a_helper <const gimple_statement_omp_atomic_load *>::test): Rename
to...
(is_a_helper <const gomp_atomic_load *>::test): ...this.
(is_a_helper <const gimple_statement_omp_atomic_store *>::test): Rename
to...
(is_a_helper <const gomp_atomic_store *>::test): ...this.
(is_a_helper <const gimple_statement_omp_return *>::test): Rename to...
(is_a_helper <const gomp_return *>::test): ...this.
(is_a_helper <const gimple_statement_omp_continue *>::test): Rename
to...
(is_a_helper <const gomp_continue *>::test): ...this.
(is_a_helper <const gimple_statement_omp_critical *>::test): Rename
to...
(is_a_helper <const gomp_critical *>::test): ...this.
(is_a_helper <const gimple_statement_omp_for *>::test): Rename to...
(is_a_helper <const gomp_for *>::test): ...this.
(is_a_helper <const gimple_statement_omp_taskreg *>::test): Rename to...
(is_a_helper <const gomp_taskreg *>::test): ...this.
(is_a_helper <const gimple_statement_omp_parallel *>::test): Rename
to...
(is_a_helper <const gomp_parallel *>::test): ...this.
(is_a_helper <const gimple_statement_omp_target *>::test): Rename to...
(is_a_helper <const gomp_target *>::test): ...this.
(is_a_helper <const gimple_statement_omp_sections *>::test): Rename
to...
(is_a_helper <const gomp_sections *>::test): ...this.
(is_a_helper <const gimple_statement_omp_single *>::test): Rename to...
(is_a_helper <const gomp_single *>::test): ...this.
(is_a_helper <const gimple_statement_omp_teams *>::test): Rename to...
(is_a_helper <const gomp_teams *>::test): ...this.
(is_a_helper <const gimple_statement_omp_task *>::test): Rename to...
(is_a_helper <const gomp_task *>::test): ...this.
(is_a_helper <const gimple_statement_phi *>::test): Rename to...
(is_a_helper <const gphi *>::test): ...this.
(is_a_helper <const gimple_statement_transaction *>::test): Rename to...
(is_a_helper <const gtransaction *>::test): ...this.
(is_a_helper <const gimple_statement_with_ops *>::test): Rename to...
(is_a_helper <const gwith_ops *>::test): ...this.
(is_a_helper <const gimple_statement_with_memory_ops *>::test): Rename
to...
(is_a_helper <const gwith_memory_ops *>::test): ...this.

(gimple_build_try): Update for renaming of gimple statement types.
(gimple_use_ops): Likewise.
(gimple_set_use_ops): Likewise.
(gimple_vuse): Likewise.
(gimple_vuse_ptr): Likewise.
(gimple_vdef_ptr): Likewise.
(gimple_set_vuse): Likewise.
(gimple_set_vdef): Likewise.
(gimple_omp_return_set_lhs): Likewise.
(gimple_omp_return_lhs): Likewise.
(gimple_omp_return_lhs_ptr): Likewise.
(gimple_call_internal_fn): Likewise.
(gimple_call_fntype): Likewise.
(gimple_call_set_fntype): Likewise.
(gimple_call_set_internal_fn): Likewise.
(gimple_call_use_set): Likewise.
(gimple_call_clobber_set): Likewise.
(gimple_bind_vars): Likewise.
(gimple_bind_set_vars): Likewise.
(gimple_bind_append_vars): Likewise.
(gimple_bind_body_ptr): Likewise.
(gimple_bind_set_body): Likewise.
(gimple_bind_add_stmt): Likewise.
(gimple_bind_add_seq): Likewise.
(gimple_bind_block): Likewise.
(gimple_bind_set_block): Likewise.
(gimple_asm_ninputs): Likewise.
(gimple_asm_noutputs): Likewise.
(gimple_asm_nclobbers): Likewise.
(gimple_asm_nlabels): Likewise.
(gimple_asm_input_op): Likewise.
(gimple_asm_input_op_ptr): Likewise.
(gimple_asm_set_input_op): Likewise.
(gimple_asm_output_op): Likewise.
(gimple_asm_output_op_ptr): Likewise.
(gimple_asm_set_output_op): Likewise.
(gimple_asm_clobber_op): Likewise.
(gimple_asm_set_clobber_op): Likewise.
(gimple_asm_label_op): Likewise.
(gimple_asm_set_label_op): Likewise.
(gimple_asm_string): Likewise.
(gimple_catch_types): Likewise.
(gimple_catch_types_ptr): Likewise.
(gimple_catch_handler_ptr): Likewise.
(gimple_catch_set_types): Likewise.
(gimple_catch_set_handler): Likewise.
(gimple_eh_filter_types): Likewise.
(gimple_eh_filter_types_ptr): Likewise.
(gimple_eh_filter_failure_ptr)
(gimple_eh_filter_set_types): Likewise.
(gimple_eh_filter_set_failure): Likewise.
(gimple_eh_must_not_throw_fndecl): Likewise.
(gimple_eh_must_not_throw_set_fndecl): Likewise.
(gimple_eh_else_n_body_ptr): Likewise.
(gimple_eh_else_e_body_ptr): Likewise.
(gimple_eh_else_set_n_body): Likewise.
(gimple_eh_else_set_e_body): Likewise.
(gimple_try_eval_ptr): Likewise.
(gimple_try_cleanup_ptr): Likewise.
(gimple_try_set_eval): Likewise.
(gimple_try_set_cleanup): Likewise.
(gimple_wce_cleanup_ptr): Likewise.
(gimple_wce_set_cleanup): Likewise.
(gimple_phi_capacity): Likewise.
(gimple_phi_num_args): Likewise.
(gimple_phi_result): Likewise.
(gimple_phi_result_ptr): Likewise.
(gimple_phi_set_result): Likewise.
(gimple_phi_arg): Likewise.
(gimple_phi_set_arg): Likewise.
(gimple_resx_region): Likewise.
(gimple_resx_set_region): Likewise.
(gimple_eh_dispatch_region): Likewise.
(gimple_eh_dispatch_set_region): Likewise.
(gimple_omp_body_ptr): Likewise.
(gimple_omp_set_body): Likewise.
(gimple_omp_critical_name): Likewise.
(gimple_omp_critical_name_ptr): Likewise.
(gimple_omp_critical_set_name): Likewise.
(gimple_omp_for_clauses): Likewise.
(gimple_omp_for_clauses_ptr): Likewise.
(gimple_omp_for_set_clauses): Likewise.
(gimple_omp_for_collapse): Likewise.
(gimple_omp_for_index): Likewise.
(gimple_omp_for_index_ptr): Likewise.
(gimple_omp_for_set_index): Likewise.
(gimple_omp_for_initial): Likewise.
(gimple_omp_for_initial_ptr): Likewise.
(gimple_omp_for_set_initial): Likewise.
(gimple_omp_for_final): Likewise.
(gimple_omp_for_final_ptr): Likewise.
(gimple_omp_for_set_final): Likewise.
(gimple_omp_for_incr): Likewise.
(gimple_omp_for_incr_ptr): Likewise.
(gimple_omp_for_set_incr): Likewise.
(gimple_omp_for_pre_body_ptr): Likewise.
(gimple_omp_for_set_pre_body): Likewise.
(gimple_omp_parallel_clauses): Likewise.
(gimple_omp_parallel_clauses_ptr): Likewise.
(gimple_omp_parallel_set_clauses): Likewise.
(gimple_omp_parallel_child_fn): Likewise.
(gimple_omp_parallel_child_fn_ptr): Likewise.
(gimple_omp_parallel_set_child_fn): Likewise.
(gimple_omp_parallel_data_arg): Likewise.
(gimple_omp_parallel_data_arg_ptr): Likewise.
(gimple_omp_parallel_set_data_arg): Likewise.
(gimple_omp_task_clauses): Likewise.
(gimple_omp_task_clauses_ptr): Likewise.
(gimple_omp_task_set_clauses): Likewise.
(gimple_omp_task_child_fn): Likewise.
(gimple_omp_task_child_fn_ptr): Likewise.
(gimple_omp_task_set_child_fn): Likewise.
(gimple_omp_task_data_arg): Likewise.
(gimple_omp_task_data_arg_ptr): Likewise.
(gimple_omp_task_set_data_arg): Likewise.
(gimple_omp_taskreg_clauses): Likewise.
(gimple_omp_taskreg_clauses_ptr): Likewise.
(gimple_omp_taskreg_set_clauses): Likewise.
(gimple_omp_taskreg_child_fn): Likewise.
(gimple_omp_taskreg_child_fn_ptr): Likewise.
(gimple_omp_taskreg_set_child_fn): Likewise.
(gimple_omp_taskreg_data_arg): Likewise.
(gimple_omp_taskreg_data_arg_ptr): Likewise.
(gimple_omp_taskreg_set_data_arg): Likewise.
(gimple_omp_task_copy_fn): Likewise.
(gimple_omp_task_copy_fn_ptr): Likewise.
(gimple_omp_task_set_copy_fn): Likewise.
(gimple_omp_task_arg_size): Likewise.
(gimple_omp_task_arg_size_ptr): Likewise.
(gimple_omp_task_set_arg_size): Likewise.
(gimple_omp_task_arg_align): Likewise.
(gimple_omp_task_arg_align_ptr): Likewise.
(gimple_omp_task_set_arg_align): Likewise.
(gimple_omp_single_clauses): Likewise.
(gimple_omp_single_clauses_ptr): Likewise.
(gimple_omp_single_set_clauses): Likewise.
(gimple_omp_target_clauses): Likewise.
(gimple_omp_target_clauses_ptr): Likewise.
(gimple_omp_target_set_clauses): Likewise.
(gimple_omp_target_child_fn): Likewise.
(gimple_omp_target_child_fn_ptr): Likewise.
(gimple_omp_target_set_child_fn): Likewise.
(gimple_omp_target_data_arg): Likewise.
(gimple_omp_target_data_arg_ptr): Likewise.
(gimple_omp_target_set_data_arg): Likewise.
(gimple_omp_teams_clauses): Likewise.
(gimple_omp_teams_clauses_ptr): Likewise.
(gimple_omp_teams_set_clauses): Likewise.
(gimple_omp_sections_clauses): Likewise.
(gimple_omp_sections_clauses_ptr): Likewise.
(gimple_omp_sections_set_clauses): Likewise.
(gimple_omp_sections_control): Likewise.
(gimple_omp_sections_control_ptr): Likewise.
(gimple_omp_sections_set_control): Likewise.
(gimple_omp_for_set_cond): Likewise.
(gimple_omp_for_cond): Likewise.
(gimple_omp_atomic_store_set_val): Likewise.
(gimple_omp_atomic_store_val): Likewise.
(gimple_omp_atomic_store_val_ptr): Likewise.
(gimple_omp_atomic_load_set_lhs): Likewise.
(gimple_omp_atomic_load_lhs): Likewise.
(gimple_omp_atomic_load_lhs_ptr): Likewise.
(gimple_omp_atomic_load_set_rhs): Likewise.
(gimple_omp_atomic_load_rhs): Likewise.
(gimple_omp_atomic_load_rhs_ptr): Likewise.
(gimple_omp_continue_control_def): Likewise.
(gimple_omp_continue_control_def_ptr): Likewise.
(gimple_omp_continue_set_control_def): Likewise.
(gimple_omp_continue_control_use): Likewise.
(gimple_omp_continue_control_use_ptr): Likewise.
(gimple_omp_continue_set_control_use): Likewise.
(gimple_transaction_body_ptr): Likewise.
(gimple_transaction_label): Likewise.
(gimple_transaction_label_ptr): Likewise.
(gimple_transaction_set_body): Likewise.
(gimple_transaction_set_label): Likewise.

* gsstruct.def: Update for renamings of the gimple statement classes.

* system.h (CONST_CAST_GIMPLE): Update for renaming of
"gimple_statement_base" to "gimple".

* target.def (DEFHOOK_UNDOC): Remove "const_gimple" in favor of
"const gimple *".

* ggc.h (ggc_alloc_cleared_gimple_statement_stat): Rename to...
(ggc_alloc_cleared_gimple_stat): ...this, updating for renaming
of gimple statement type.

* gimple-pretty-print.h (debug): Update for renaming of
"gimple_statement_base" to "gimple".
* gimple-pretty-print.c (debug): Likewise.

* gimple-ssa.h (gimple_vuse_op): Update for renaming of
"gimple_statement_with_memory_ops" to "gimple_with_memory_ops".
(gimple_vdef_op): Likewise.

* gimple.c (gimple_alloc_stat): Update for renaming of gimple
statement types.
(gimple_build_asm_1): Likewise.
(gimple_build_try): Likewise.
(gimple_build_resx): Likewise.
(gimple_build_eh_dispatch): Likewise.
(gimple_build_omp_for): Likewise.
(gimple_copy): Likewise.

* gimple-streamer-in.c (input_gimple_stmt): Update for renaming of
"gimple_statement_asm" to "gasm".

* gimplify.c (gimplify_cleanup_point_expr): Likewise for
"gimple_statement_try" to "gtry".

* tree-dfa.c (dump_dfa_stats): Likewise for "gimple_statement_phi"
to "gphi".

* tree-phinodes.c (allocate_phi_node): Likewise.
(ideal_phi_node_len): Likewise.
(make_phi_node): Likewise.
(resize_phi_node): Likewise.
(reserve_phi_args_for_new_edge): Likewise.
(remove_phi_arg_num): Likewise.
(remove_phi_args): Likewise.

* tree-ssa-ccp.c (gimple_htab): Likewise for renaming of
"gimple_statement_base" to "gimple".

* gdbhooks.py (build_pretty_printer): Update to reflect above changes.

* doc/gimple.texi: Update to reflect the above changes, and those
in the automated patch that follows.

gcc/testsuite/
* g++.dg/plugin/selfassign.c (get_real_ref_rhs): Replace "gimple"
typedef with "gimple *".
(get_non_ssa_expr): Likewise.
(compare_and_warn): Likewise.
(warn_self_assign): Likewise.

* gcc.dg/plugin/selfassign.c (get_real_ref_rhs): Likewise.
(get_non_ssa_expr): Likewise.
(compare_and_warn): Likewise.
(warn_self_assign): Likewise.
---
gcc/coretypes.h | 5 +-
gcc/doc/gimple.texi | 808 ++++++++++++++++++-------------
gcc/gdbhooks.py | 2 +-
gcc/ggc.h | 6 +-
gcc/gimple-pretty-print.c | 4 +-
gcc/gimple-pretty-print.h | 4 +-
gcc/gimple-ssa.h | 8 +-
gcc/gimple-streamer-in.c | 2 +-
gcc/gimple.c | 26 +-
gcc/gimple.h | 703 +++++++++++----------------
gcc/gimplify.c | 2 +-
gcc/gsstruct.def | 52 +-
gcc/system.h | 2 +-
gcc/target.def | 2 +-
gcc/testsuite/g++.dg/plugin/selfassign.c | 8 +-
gcc/testsuite/gcc.dg/plugin/selfassign.c | 8 +-
gcc/tree-dfa.c | 2 +-
gcc/tree-phinodes.c | 35 +-
gcc/tree-ssa-ccp.c | 2 +-
19 files changed, 842 insertions(+), 839 deletions(-)

diff --git a/gcc/coretypes.h b/gcc/coretypes.h
index 41ad1a3..9a1f172 100644
--- a/gcc/coretypes.h
+++ b/gcc/coretypes.h
@@ -64,9 +64,8 @@ typedef const struct hwivec_def *const_hwivec;
union tree_node;
typedef union tree_node *tree;
typedef const union tree_node *const_tree;
-typedef struct gimple_statement_base *gimple;
-typedef const struct gimple_statement_base *const_gimple;
-typedef gimple gimple_seq;
+class gimple;
+typedef gimple *gimple_seq;
struct gimple_stmt_iterator;
union section;
typedef union section section;
diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi
index 1e5473d..54bad5d 100644
--- a/gcc/doc/gimple.texi
+++ b/gcc/doc/gimple.texi
@@ -92,8 +92,8 @@ groups: a header describing the instruction and its locations,
and a variable length body with all the operands. Tuples are
organized into a hierarchy with 3 main classes of tuples.

-@subsection @code{gimple_statement_base} (gsbase)
-@cindex gimple_statement_base
+@subsection @code{gimple} (gsbase)
+@cindex gimple

This is the root of the hierarchy, it holds basic information
needed by most GIMPLE statements. There are some fields that
@@ -192,12 +192,12 @@ Lexical block holding this statement. Also used for debug
information generation.
@end itemize

-@subsection @code{gimple_statement_with_ops}
-@cindex gimple_statement_with_ops
+@subsection @code{gimple_with_ops}
+@cindex gimple_with_ops

This tuple is actually split in two:
-@code{gimple_statement_with_ops_base} and
-@code{gimple_statement_with_ops}. This is needed to accommodate the
+@code{gimple_with_ops_base} and
+@code{gimple_with_ops}. This is needed to accommodate the
way the operand vector is allocated. The operand vector is
defined to be an array of 1 element. So, to allocate a dynamic
number of operands, the memory allocator (@code{gimple_alloc}) simply
@@ -205,11 +205,11 @@ allocates enough memory to hold the structure itself plus @code{N
- 1} operands which run ``off the end'' of the structure. For
example, to allocate space for a tuple with 3 operands,
@code{gimple_alloc} reserves @code{sizeof (struct
-gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.
+gimple_with_ops) + 2 * sizeof (tree)} bytes.

On the other hand, several fields in this tuple need to be shared
-with the @code{gimple_statement_with_memory_ops} tuple. So, these
-common fields are placed in @code{gimple_statement_with_ops_base} which
+with the @code{gimple_with_memory_ops} tuple. So, these
+common fields are placed in @code{gimple_with_ops_base} which
is then inherited from the other two tuples.


@@ -223,7 +223,7 @@ is then inherited from the other two tuples.

@itemize @bullet
@item @code{gsbase}
-Inherited from @code{struct gimple_statement_base}.
+Inherited from @code{struct gimple}.

@item @code{def_ops}
Array of pointers into the operand array indicating all the slots that
@@ -239,14 +239,14 @@ Similar to @code{def_ops} but for variables read by the statement.
Array of trees with @code{num_ops} slots.
@end itemize

-@subsection @code{gimple_statement_with_memory_ops}
+@subsection @code{gimple_with_memory_ops}

-This tuple is essentially identical to @code{gimple_statement_with_ops},
+This tuple is essentially identical to @code{gimple_with_ops},
except that it contains 4 additional fields to hold vectors
related memory stores and loads. Similar to the previous case,
the structure is split in two to accommodate for the operand
-vector (@code{gimple_statement_with_memory_ops_base} and
-@code{gimple_statement_with_memory_ops}).
+vector (@code{gimple_with_memory_ops_base} and
+@code{gimple_with_memory_ops}).


@multitable {@code{vdef_ops}} {80 + 8 * @code{num_ops} bytes}
@@ -300,17 +300,17 @@ kinds, along with their relationships to @code{GSS_} values (layouts) and
@code{GIMPLE_} values (codes):

@smallexample
- gimple_statement_base
+ gimple
| layout: GSS_BASE
| used for 4 codes: GIMPLE_ERROR_MARK
| GIMPLE_NOP
| GIMPLE_OMP_SECTIONS_SWITCH
| GIMPLE_PREDICT
|
- + gimple_statement_with_ops_base
+ + gimple_with_ops_base
| | (no GSS layout)
| |
- | + gimple_statement_with_ops
+ | + gimple_with_ops
| | layout: GSS_WITH_OPS
| | Used for 5 codes: GIMPLE_COND
| | GIMPLE_DEBUG
@@ -318,104 +318,104 @@ kinds, along with their relationships to @code{GSS_} values (layouts) and
| | GIMPLE_LABEL
| | GIMPLE_SWITCH
| |
- | + gimple_statement_with_memory_ops_base
+ | + gimple_with_memory_ops_base
| | layout: GSS_WITH_MEM_OPS_BASE
| |
- | + gimple_statement_with_memory_ops
+ | + gimple_with_memory_ops
| | layout: GSS_WITH_MEM_OPS.
| | used for codes GIMPLE_ASSIGN and GIMPLE_RETURN.
| |
- | + gimple_statement_call
+ | + gcall
| | layout: GSS_CALL, code: GIMPLE_CALL
| |
- | + gimple_statement_asm
+ | + gasm
| | layout: GSS_ASM, code: GIMPLE_ASM
| |
- | + gimple_statement_transaction
+ | + gtransaction
| layout: GSS_TRANSACTION, code: GIMPLE_TRANSACTION
|
- + gimple_statement_omp
+ + gomp
| | layout: GSS_OMP. Used for code GIMPLE_OMP_SECTION
| |
- | + gimple_statement_omp_critical
+ | + gomp_critical
| | layout: GSS_OMP_CRITICAL, code: GIMPLE_OMP_CRITICAL
| |
- | + gimple_statement_omp_for
+ | + gomp_for
| | layout: GSS_OMP_FOR, code: GIMPLE_OMP_FOR
| |
- | + gimple_statement_omp_parallel_layout
+ | + gomp_parallel_layout
| | | layout: GSS_OMP_PARALLEL_LAYOUT
| | |
- | | + gimple_statement_omp_taskreg
+ | | + gomp_taskreg
| | | |
- | | | + gimple_statement_omp_parallel
+ | | | + gomp_parallel
| | | | code: GIMPLE_OMP_PARALLEL
| | | |
- | | | + gimple_statement_omp_task
+ | | | + gomp_task
| | | code: GIMPLE_OMP_TASK
| | |
- | | + gimple_statement_omp_target
+ | | + gomp_target
| | code: GIMPLE_OMP_TARGET
| |
- | + gimple_statement_omp_sections
+ | + gomp_sections
| | layout: GSS_OMP_SECTIONS, code: GIMPLE_OMP_SECTIONS
| |
- | + gimple_statement_omp_single_layout
+ | + gomp_single_layout
| | layout: GSS_OMP_SINGLE_LAYOUT
| |
- | + gimple_statement_omp_single
+ | + gomp_single
| | code: GIMPLE_OMP_SINGLE
| |
- | + gimple_statement_omp_teams
+ | + gomp_teams
| code: GIMPLE_OMP_TEAMS
|
- + gimple_statement_bind
+ + gbind
| layout: GSS_BIND, code: GIMPLE_BIND
|
- + gimple_statement_catch
+ + gcatch
| layout: GSS_CATCH, code: GIMPLE_CATCH
|
- + gimple_statement_eh_filter
+ + geh_filter
| layout: GSS_EH_FILTER, code: GIMPLE_EH_FILTER
|
- + gimple_statement_eh_else
+ + geh_else
| layout: GSS_EH_ELSE, code: GIMPLE_EH_ELSE
|
- + gimple_statement_eh_mnt
+ + geh_mnt
| layout: GSS_EH_MNT, code: GIMPLE_EH_MUST_NOT_THROW
|
- + gimple_statement_phi
+ + gphi
| layout: GSS_PHI, code: GIMPLE_PHI
|
- + gimple_statement_eh_ctrl
+ + geh_ctrl
| | layout: GSS_EH_CTRL
| |
- | + gimple_statement_resx
+ | + gresx
| | code: GIMPLE_RESX
| |
- | + gimple_statement_eh_dispatch
+ | + geh_dispatch
| code: GIMPLE_EH_DISPATCH
|
- + gimple_statement_try
+ + gtry
| layout: GSS_TRY, code: GIMPLE_TRY
|
- + gimple_statement_wce
+ + gwce
| layout: GSS_WCE, code: GIMPLE_WITH_CLEANUP_EXPR
|
- + gimple_statement_omp_continue
+ + gomp_continue
| layout: GSS_OMP_CONTINUE, code: GIMPLE_OMP_CONTINUE
|
- + gimple_statement_omp_atomic_load
+ + gomp_atomic_load
| layout: GSS_OMP_ATOMIC_LOAD, code: GIMPLE_OMP_ATOMIC_LOAD
|
- + gimple_statement_omp_atomic_store_layout
+ + gomp_atomic_store_layout
| layout: GSS_OMP_ATOMIC_STORE_LAYOUT,
| code: GIMPLE_OMP_ATOMIC_STORE
|
- + gimple_statement_omp_atomic_store
+ + gomp_atomic_store
| code: GIMPLE_OMP_ATOMIC_STORE
|
- + gimple_statement_omp_return
+ + gomp_return
code: GIMPLE_OMP_RETURN
@end smallexample

@@ -706,15 +706,15 @@ the code of a given statement, its operand vector will be at
different offsets from the base of the structure. To access
tuple operands use the following accessors

-@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple *g)
Returns the number of operands in statement G.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
+@deftypefn {GIMPLE function} tree gimple_op (gimple *g, unsigned i)
Returns operand @code{I} from statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple *g)
Returns a pointer into the operand vector for statement @code{G}. This
is computed using an internal table called @code{gimple_ops_offset_}[].
This table is indexed by the gimple code of @code{G}.
@@ -790,15 +790,15 @@ program is running (and which is valid in all functions).

@subsection Statement validation

-@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_assign (gimple *g)
Return true if the code of g is @code{GIMPLE_ASSIGN}.
@end deftypefn

-@deftypefn {GIMPLE function} bool is_gimple_call (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_call (gimple *g)
Return true if the code of g is @code{GIMPLE_CALL}.
@end deftypefn

-@deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_debug (gimple *g)
Return true if the code of g is @code{GIMPLE_DEBUG}.
@end deftypefn

@@ -807,12 +807,12 @@ Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast
operation.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple *g)
Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an
expression to a variable.
@end deftypefn

-@deftypefn {GIMPLE function} bool is_gimple_omp (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_omp (gimple *g)
Return true if g is any of the OpenMP codes.
@end deftypefn

@@ -826,19 +826,19 @@ of the GIMPLE instructions.
@subsection Common accessors
The following are common accessors for gimple statements.

-@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple *g)
Return the code for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
+@deftypefn {GIMPLE function} basic_block gimple_bb (gimple *g)
Return the basic block to which statement @code{G} belongs to.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_block (gimple g)
+@deftypefn {GIMPLE function} tree gimple_block (gimple *g)
Return the lexical scope block holding statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_expr_type (gimple *stmt)
Return the type of the main expression computed by @code{STMT}. Return
@code{void_type_node} if @code{STMT} computes nothing. This will only return
something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
@@ -846,7 +846,8 @@ something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
@code{void_type_node}.
@end deftypefn

-@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (@
+gimple *stmt)
Return the tree code for the expression computed by @code{STMT}. This
is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
@code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.
@@ -855,139 +856,153 @@ For @code{GIMPLE_ASSIGN} it returns the code of the operation performed
by the @code{RHS} of the assignment.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
+@deftypefn {GIMPLE function} void gimple_set_block (gimple *g, tree block)
Set the lexical scope block of @code{G} to @code{BLOCK}.
@end deftypefn

-@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
+@deftypefn {GIMPLE function} location_t gimple_locus (gimple *g)
Return locus information for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
+@deftypefn {GIMPLE function} void gimple_set_locus (gimple *g, @
+location_t locus)
Set locus information for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple *g)
Return true if @code{G} does not have locus information.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple *stmt)
Return true if no warnings should be emitted for statement @code{STMT}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
+@deftypefn {GIMPLE function} void gimple_set_visited (gimple *stmt, @
+bool visited_p)
Set the visited status on statement @code{STMT} to @code{VISITED_P}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_visited_p (gimple *stmt)
Return the visited status on statement @code{STMT}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
+@deftypefn {GIMPLE function} void gimple_set_plf (gimple *stmt, @
+enum plf_mask plf, bool val_p)
Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
@end deftypefn

-@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
+@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple *stmt, @
+enum plf_mask plf)
Return the value of pass local flag @code{PLF} on statement @code{STMT}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
+@deftypefn {GIMPLE function} bool gimple_has_ops (gimple *g)
Return true if statement @code{G} has register or memory operands.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
+@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple *g)
Return true if statement @code{G} has memory operands.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple *g)
Return the number of operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple *g)
Return the array of operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
+@deftypefn {GIMPLE function} tree gimple_op (gimple *g, unsigned i)
Return operand @code{I} for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
+@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple *g, unsigned i)
Return a pointer to operand @code{I} for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
+@deftypefn {GIMPLE function} void gimple_set_op (gimple *g, unsigned i, @
+tree op)
Set operand @code{I} of statement @code{G} to @code{OP}.
@end deftypefn

-@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
+@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple *stmt)
Return the set of symbols that have had their address taken by
@code{STMT}.
@end deftypefn

-@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
+@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (@
+gimple *g)
Return the set of @code{DEF} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
+@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple *g, @
+struct def_optype_d *def)
Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
+@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (@
+gimple *g)
Return the set of @code{USE} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
+@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple *g, @
+struct use_optype_d *use)
Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
+@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (@
+gimple *g)
Return the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
+@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple *g, @
+struct voptype_d *ops)
Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
+@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (@
+gimple *g)
Return the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
+@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple *g, @
+struct voptype_d *ops)
Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
+@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple *g)
Return the set of symbols loaded by statement @code{G}. Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn

-@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
+@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple *g)
Return the set of symbols stored by statement @code{G}. Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_modified_p (gimple *g)
Return true if statement @code{G} has operands and the modified field
has been set.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple *stmt)
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
+@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (@
+gimple *stmt, bool volatilep)
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn

-@deftypefn {GIMPLE function} void update_stmt (gimple s)
+@deftypefn {GIMPLE function} void update_stmt (gimple *s)
Mark statement @code{S} as modified, and update it.
@end deftypefn

-@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
+@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple *s)
Update statement @code{S} if it has been marked modified.
@end deftypefn

-@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
+@deftypefn {GIMPLE function} gimple *gimple_copy (gimple *stmt)
Return a deep copy of statement @code{STMT}.
@end deftypefn

@@ -1031,7 +1046,8 @@ Return a deep copy of statement @code{STMT}.
@subsection @code{GIMPLE_ASM}
@cindex @code{GIMPLE_ASM}

-@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
+@deftypefn {GIMPLE function} gimple *gimple_build_asm (@
+const char *string, ninputs, noutputs, nclobbers, ...)
Build a @code{GIMPLE_ASM} statement. This statement is used for
building in-line assembly constructs. @code{STRING} is the assembly
code. @code{NINPUT} is the number of register inputs. @code{NOUTPUT} is the
@@ -1040,58 +1056,64 @@ registers. The rest of the arguments trees for each input,
output, and clobbered registers.
@end deftypefn

-@deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
+@deftypefn {GIMPLE function} gimple *gimple_build_asm_vec (@
+const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)
Identical to gimple_build_asm, but the arguments are passed in
VECs.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple *g)
Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple *g)
Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple *g)
Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple *g, @
+unsigned index)
Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
+@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple *g, @
+unsigned index, tree in_op)
Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple *g, @
+unsigned index)
Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
+@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple *g, @
unsigned index, tree out_op)
Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple *g, @
+unsigned index)
Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
+@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple *g, @
+unsigned index, tree clobber_op)
Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple g)
+@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple *g)
Return the string representing the assembly instruction in
@code{GIMPLE_ASM} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple *g)
Return true if @code{G} is an asm statement marked volatile.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
+@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple *g)
Mark asm statement @code{G} as volatile.
@end deftypefn

@@ -1099,7 +1121,8 @@ Mark asm statement @code{G} as volatile.
@subsection @code{GIMPLE_ASSIGN}
@cindex @code{GIMPLE_ASSIGN}

-@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gimple *gimple_build_assign (tree lhs, @
+tree rhs)
Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue
passed in lhs. The right-hand side can be either a unary or
binary tree expression. The expression tree rhs will be
@@ -1113,7 +1136,8 @@ operands in separate trees, it is better to use
@end deftypefn


-@deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
+@deftypefn {GIMPLE function} gimple *gimplify_assign (tree dst, tree src, @
+gimple_seq *seq_p)
Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
@code{*SEQ_P}.
@end deftypefn
@@ -1124,7 +1148,7 @@ case they will be converted to a gimple operand if necessary.

This function returns the newly created @code{GIMPLE_ASSIGN} tuple.

-@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
+@deftypefn {GIMPLE function} gimple *gimple_build_assign_with_ops @
(enum tree_code subcode, tree lhs, tree op1, tree op2)
This function is similar to @code{gimple_build_assign}, but is used to
build a @code{GIMPLE_ASSIGN} statement when the operands of the
@@ -1137,73 +1161,79 @@ are the operands. If op2 is null, subcode must be a @code{tree_code}
for a unary expression.
@end deftypefn

-@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (@
+gimple *g)
Return the code of the expression computed on the @code{RHS} of
assignment statement @code{G}.
@end deftypefn


-@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (@
+gimple *g)
Return the gimple rhs class of the code for the expression
computed on the rhs of assignment statement @code{G}. This will never
return @code{GIMPLE_INVALID_RHS}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple *g)
Return the @code{LHS} of assignment statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple *g)
Return a pointer to the @code{LHS} of assignment statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple *g)
Return the first operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple *g)
Return the address of the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple *g)
Return the second operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple *g)
Return the address of the second operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple *g)
Return the third operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple *g)
Return the address of the third operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple *g, @
+tree lhs)
Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple *g, @
+tree rhs)
Set @code{RHS} to be the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple *g, @
+tree rhs)
Set @code{RHS} to be the second operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple *g, @
+tree rhs)
Set @code{RHS} to be the third operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple s)
+@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple *s)
Return true if @code{S} is a type-cast assignment.
@end deftypefn

@@ -1212,49 +1242,56 @@ Return true if @code{S} is a type-cast assignment.
@subsection @code{GIMPLE_BIND}
@cindex @code{GIMPLE_BIND}

-@deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_bind (tree vars, @
+gimple_seq body)
Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
and a body of statements in sequence @code{BODY}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
+@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple *g)
Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple *g, @
+tree vars)
Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple *g, @
+tree vars)
Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple *g)
Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple *g, @
+gimple_seq seq)
Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
+@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple *gs, @
+gimple *stmt)
Append a statement to the end of a @code{GIMPLE_BIND}'s body.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple *gs, @
+gimple_seq seq)
Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
body.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
+@deftypefn {GIMPLE function} tree gimple_bind_block (gimple *g)
Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
+@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple *g, @
+tree block)
Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
statement @code{G}.
@end deftypefn
@@ -1264,7 +1301,8 @@ statement @code{G}.
@subsection @code{GIMPLE_CALL}
@cindex @code{GIMPLE_CALL}

-@deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
+@deftypefn {GIMPLE function} gimple *gimple_build_call (tree fn, @
+unsigned nargs, ...)
Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN}
must be either a @code{FUNCTION_DECL} or a gimple call address as
determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of
@@ -1274,7 +1312,8 @@ operand is validated with @code{is_gimple_operand}).
@end deftypefn


-@deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
+@deftypefn {GIMPLE function} gimple *gimple_build_call_from_tree (@
+tree call_expr)
Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments and the
function are taken from the expression directly. This routine
assumes that @code{call_expr} is already in GIMPLE form. That is, its
@@ -1283,98 +1322,105 @@ simplification. All the call flags in @code{call_expr} are copied over
to the new @code{GIMPLE_CALL}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
+@deftypefn {GIMPLE function} gimple *gimple_build_call_vec (tree fn, @
+@code{VEC}(tree, heap) *args)
Identical to @code{gimple_build_call} but the arguments are stored in a
@code{VEC}().
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple *g)
Return the @code{LHS} of call statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple *g)
Return a pointer to the @code{LHS} of call statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple *g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_fn (gimple *g)
Return the tree node representing the function called by call
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
+@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple *g, tree fn)
Set @code{FN} to be the function called by call statement @code{G}. This has
to be a gimple value specifying the address of the called
function.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
+@deftypefn {GIMPLE *function} tree gimple_call_fndecl (gimple *g)
If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
Otherwise return @code{NULL}. This function is analogous to
@code{get_callee_fndecl} in @code{GENERIC}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
+@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple *g, @
+tree fndecl)
Set the called function to @code{FNDECL}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple *g)
Return the type returned by call statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_chain (gimple *g)
Return the static chain for call statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
+@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple *g, @
+tree chain)
Set @code{CHAIN} to be the static chain for call statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple *g)
Return the number of arguments used by call statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_call_arg (gimple *g, @
+unsigned index)
Return the argument at position @code{INDEX} for call statement @code{G}. The
first argument is 0.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
+@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple *g, @
+unsigned index)
Return a pointer to the argument at position @code{INDEX} for call
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
+@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple *g, @
+unsigned index, tree arg)
Set @code{ARG} to be the argument at position @code{INDEX} for call statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
+@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple *s)
Mark call statement @code{S} as being a tail call (i.e., a call just
before the exit of a function). These calls are candidate for
tail call optimization.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple *s)
Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
+@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple *s)
Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple *s)
Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple *s)
Return true if @code{S} is a noreturn call.
@end deftypefn

-@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
+@deftypefn {GIMPLE function} gimple *gimple_call_copy_skip_args (@
+gimple *stmt, bitmap args_to_skip)
Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
in the positions marked by the set @code{ARGS_TO_SKIP}.
@end deftypefn
@@ -1384,31 +1430,34 @@ in the positions marked by the set @code{ARGS_TO_SKIP}.
@subsection @code{GIMPLE_CATCH}
@cindex @code{GIMPLE_CATCH}

-@deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
+@deftypefn {GIMPLE function} gimple *gimple_build_catch (tree types, @
+gimple_seq handler)
Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this
catch handles. @code{HANDLER} is a sequence of statements with the code
for the handler.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
+@deftypefn {GIMPLE function} tree gimple_catch_types (gimple *g)
Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple *g)
Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple *g)
Return the GIMPLE sequence representing the body of the handler
of @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
+@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple *g, @
+tree t)
Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
+@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple *g, @
+gimple_seq handler)
Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
@end deftypefn

@@ -1417,7 +1466,8 @@ Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
@subsection @code{GIMPLE_COND}
@cindex @code{GIMPLE_COND}

-@deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gimple *gimple_build_cond (@
+enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares
@code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
@@ -1426,66 +1476,70 @@ the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
@end deftypefn


-@deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gimple *gimple_build_cond_from_tree (@
+tree cond, tree t_label, tree f_label)
Build a @code{GIMPLE_COND} statement from the conditional expression
tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
@end deftypefn

-@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple *g)
Return the code of the predicate computed by conditional
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
+@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple *g, @
+enum tree_code code)
Set @code{CODE} to be the predicate code for the conditional statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple *g)
Return the @code{LHS} of the predicate computed by conditional statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple *g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
conditional statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple *g)
Return the @code{RHS} operand of the predicate computed by conditional
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple *g, tree rhs)
Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
conditional statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple *g)
Return the label used by conditional statement @code{G} when its
predicate evaluates to true.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple *g, @
+tree label)
Set @code{LABEL} to be the label used by conditional statement @code{G} when
its predicate evaluates to true.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple *g, @
+tree label)
Set @code{LABEL} to be the label used by conditional statement @code{G} when
its predicate evaluates to false.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple *g)
Return the label used by conditional statement @code{G} when its
predicate evaluates to false.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
+@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple *g)
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
+@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple *g)
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
@end deftypefn

@@ -1494,7 +1548,8 @@ Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
@cindex @code{GIMPLE_DEBUG}
@cindex @code{GIMPLE_DEBUG_BIND}

-@deftypefn {GIMPLE function} gimple gimple_build_debug_bind (tree var, tree value, gimple stmt)
+@deftypefn {GIMPLE function} gimple *gimple_build_debug_bind (tree var, @
+tree value, gimple *stmt)
Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of
@code{subcode}. The effect of this statement is to tell debug
information generation machinery that the value of user variable
@@ -1533,35 +1588,41 @@ Block and location information for the newly-created stmt are
taken from @code{stmt}, if given.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple *stmt)
Return the user variable @var{var} that is bound at @code{stmt}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (@
+gimple *stmt)
Return the value expression that is bound to a user variable at
@code{stmt}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt)
+@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (@
+gimple *stmt)
Return a pointer to the value expression that is bound to a user
variable at @code{stmt}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
+@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (@
+gimple *stmt, tree var)
Modify the user variable bound at @code{stmt} to @var{var}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
+@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (@
+gimple *stmt, tree var)
Modify the value bound to the user variable bound at @code{stmt} to
@var{value}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
+@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (@
+gimple *stmt)
Modify the value bound to the user variable bound at @code{stmt} so
that the variable becomes unbound.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (@
+gimple *stmt)
Return @code{TRUE} if @code{stmt} binds a user variable to a value,
and @code{FALSE} if it unbinds the variable.
@end deftypefn
@@ -1570,39 +1631,46 @@ and @code{FALSE} if it unbinds the variable.
@subsection @code{GIMPLE_EH_FILTER}
@cindex @code{GIMPLE_EH_FILTER}

-@deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
+@deftypefn {GIMPLE function} gimple *gimple_build_eh_filter (@
+tree types, gimple_seq failure)
Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's
types. @code{FAILURE} is a sequence with the filter's failure action.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
+@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple *g)
Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (@
+gimple *g)
Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (@
+gimple *g)
Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
statement fails.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple *g, @
+tree types)
Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (@
+gimple *g, gimple_seq failure)
Set @code{FAILURE} to be the sequence of statements to execute on
failure for @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
+@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (@
+gimple *g)
Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (@
+gimple *g, bool mntp)
Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn

@@ -1611,30 +1679,32 @@ Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
@subsection @code{GIMPLE_LABEL}
@cindex @code{GIMPLE_LABEL}

-@deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
+@deftypefn {GIMPLE function} gimple *gimple_build_label (tree label)
Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
label, @code{LABEL}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_label_label (gimple *g)
Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_label_set_label (gimple *g, @
+tree label)
Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
statement @code{G}.
@end deftypefn


-@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
+@deftypefn {GIMPLE function} gimple *gimple_build_goto (tree dest)
Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
+@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple *g)
Return the destination of the unconditional jump @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
+@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple *g, @
+tree dest)
Set @code{DEST} to be the destination of the unconditional jump @code{G}.
@end deftypefn

@@ -1643,11 +1713,11 @@ Set @code{DEST} to be the destination of the unconditional jump @code{G}.
@subsection @code{GIMPLE_NOP}
@cindex @code{GIMPLE_NOP}

-@deftypefn {GIMPLE function} gimple gimple_build_nop (void)
+@deftypefn {GIMPLE function} gimple *gimple_build_nop (void)
Build a @code{GIMPLE_NOP} statement.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_nop_p (gimple *g)
Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
@end deftypefn

@@ -1655,25 +1725,28 @@ Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
@subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
@cindex @code{GIMPLE_OMP_ATOMIC_LOAD}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_atomic_load (@
+tree lhs, tree rhs)
Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand
side of the assignment. @code{RHS} is the right-hand side of the
assignment.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (@
+gimple *g, tree lhs)
Set the @code{LHS} of an atomic load.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple *g)
Get the @code{LHS} of an atomic load.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (@
+gimple *g, tree rhs)
Set the @code{RHS} of an atomic set.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple *g)
Get the @code{RHS} of an atomic set.
@end deftypefn

@@ -1682,16 +1755,18 @@ Get the @code{RHS} of an atomic set.
@subsection @code{GIMPLE_OMP_ATOMIC_STORE}
@cindex @code{GIMPLE_OMP_ATOMIC_STORE}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_atomic_store (@
+tree val)
Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
stored.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (@
+gimple *g, tree val)
Set the value being stored in an atomic store.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple *g)
Return the value being stored in an atomic store.
@end deftypefn

@@ -1699,36 +1774,43 @@ Return the value being stored in an atomic store.
@subsection @code{GIMPLE_OMP_CONTINUE}
@cindex @code{GIMPLE_OMP_CONTINUE}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_continue (@
+tree control_def, tree control_use)
Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the
definition of the control variable. @code{CONTROL_USE} is the use of
the control variable.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (@
+gimple *s)
Return the definition of the control variable on a
@code{GIMPLE_OMP_CONTINUE} in @code{S}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (@
+gimple *s)
Same as above, but return the pointer.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (@
+gimple *s)
Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
statement in @code{S}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (@
+gimple *s)
Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
in @code{S}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (@
+gimple *s)
Same as above, but return the pointer.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (@
+gimple *s)
Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
in @code{S}.
@end deftypefn
@@ -1738,22 +1820,25 @@ in @code{S}.
@subsection @code{GIMPLE_OMP_CRITICAL}
@cindex @code{GIMPLE_OMP_CRITICAL}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_critical (@
+gimple_seq body, tree name)
Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
statements for which only one thread can execute. @code{NAME} is an
optional identifier for this critical block.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple *g)
Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (@
+gimple *g)
Return a pointer to the name associated with @code{OMP} critical
statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
+@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (@
+gimple *g, tree name)
Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
@end deftypefn

@@ -1761,7 +1846,8 @@ Set @code{NAME} to be the name associated with @code{OMP} critical statement @co
@subsection @code{GIMPLE_OMP_FOR}
@cindex @code{GIMPLE_OMP_FOR}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_for (@
+gimple_seq body, @
tree clauses, tree index, tree initial, tree final, tree incr, @
gimple_seq pre_body, enum tree_code omp_for_cond)
Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
@@ -1774,81 +1860,91 @@ final value of @code{INDEX}. OMP_FOR_COND is the predicate used to
compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple *g)
Return the clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (@
+gimple *g)
Return a pointer to the @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple *g)
Return the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple *g)
Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_index (@
+gimple *g, tree index)
Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple *g)
Return the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (@
+gimple *g)
Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple *g, @
+tree initial)
Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple *g)
Return the final value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple *g)
turn a pointer to the final value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple *g, @
+tree final)
Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple *g)
Return the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple *g)
Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple *g, @
+tree incr)
Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple *g)
Return the sequence of statements to execute before the @code{OMP_FOR}
statement @code{G} starts.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple *g, @
+gimple_seq pre_body)
Set @code{PRE_BODY} to be the sequence of statements to execute before
the @code{OMP_FOR} statement @code{G} starts.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple *g, @
+enum tree_code cond)
Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (@
+gimple *g)
Return the condition code associated with @code{OMP_FOR} @code{G}.
@end deftypefn

@@ -1857,7 +1953,8 @@ Return the condition code associated with @code{OMP_FOR} @code{G}.
@subsection @code{GIMPLE_OMP_MASTER}
@cindex @code{GIMPLE_OMP_MASTER}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_master (@
+gimple_seq body)
Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
statements to be executed by just the master.
@end deftypefn
@@ -1867,7 +1964,8 @@ statements to be executed by just the master.
@subsection @code{GIMPLE_OMP_ORDERED}
@cindex @code{GIMPLE_OMP_ORDERED}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_ordered (@
+gimple_seq body)
Build a @code{GIMPLE_OMP_ORDERED} statement.
@end deftypefn

@@ -1879,8 +1977,8 @@ executed in sequence.
@subsection @code{GIMPLE_OMP_PARALLEL}
@cindex @code{GIMPLE_OMP_PARALLEL}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq @
-body, tree clauses, tree child_fn, tree data_arg)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_parallel (@
+gimple_seq body, tree clauses, tree child_fn, tree data_arg)
Build a @code{GIMPLE_OMP_PARALLEL} statement.
@end deftypefn

@@ -1889,61 +1987,70 @@ Build a @code{GIMPLE_OMP_PARALLEL} statement.
the function created for the parallel threads to execute.
@code{DATA_ARG} are the shared data argument(s).

-@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (@
+gimple *g)
Return true if @code{OMP} parallel statement @code{G} has the
@code{GF_OMP_PARALLEL_COMBINED} flag set.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (@
+gimple *g)
Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple *g)
Return the body for the @code{OMP} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
+@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple *g, @
+gimple_seq body)
Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple *g)
Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (@
+gimple *g)
Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the list of clauses associated with
@code{OMP_PARALLEL} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple *g)
Return the child function used to hold the body of @code{OMP_PARALLEL}
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (@
+gimple *g)
Return a pointer to the child function used to hold the body of
@code{OMP_PARALLEL} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (@
+gimple *g, tree child_fn)
Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple *g)
Return the artificial argument used to send variables and values
from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (@
+gimple *g)
Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (@
+gimple *g, tree data_arg)
Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn

@@ -1952,17 +2059,17 @@ Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
@subsection @code{GIMPLE_OMP_RETURN}
@cindex @code{GIMPLE_OMP_RETURN}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_return (bool wait_p)
Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
non-waiting return.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
+@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple *s)
Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
@end deftypefn


-@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple *g)
Return true if @code{OMP} return statement @code{G} has the
@code{GF_OMP_RETURN_NOWAIT} flag set.
@end deftypefn
@@ -1971,18 +2078,19 @@ Return true if @code{OMP} return statement @code{G} has the
@subsection @code{GIMPLE_OMP_SECTION}
@cindex @code{GIMPLE_OMP_SECTION}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_section (@
+gimple_seq body)
Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
@end deftypefn

@code{BODY} is the sequence of statements in the section.

-@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple *g)
Return true if @code{OMP} section statement @code{G} has the
@code{GF_OMP_SECTION_LAST} flag set.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
+@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple *g)
Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
@end deftypefn

@@ -1990,7 +2098,8 @@ Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
@subsection @code{GIMPLE_OMP_SECTIONS}
@cindex @code{GIMPLE_OMP_SECTIONS}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_sections (@
+gimple_seq body, tree clauses)
Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
section statements. @code{CLAUSES} are any of the @code{OMP} sections
construct's clauses: private, firstprivate, lastprivate,
@@ -1998,34 +2107,39 @@ reduction, and nowait.
@end deftypefn


-@deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_sections_switch (@
+void)
Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple *g)
Return the control variable associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (@
+gimple *g)
Return a pointer to the clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (@
+gimple *g, tree control)
Set @code{CONTROL} to be the set of clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple *g)
Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (@
+gimple *g)
Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
@code{G}.
@end deftypefn
@@ -2035,22 +2149,25 @@ Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
@subsection @code{GIMPLE_OMP_SINGLE}
@cindex @code{GIMPLE_OMP_SINGLE}

-@deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_single (@
+gimple_seq body, tree clauses)
Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
statements that will be executed once. @code{CLAUSES} are any of the
@code{OMP} single construct's clauses: private, firstprivate,
copyprivate, nowait.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple *g)
Return the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (@
+gimple *g)
Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn

@@ -2059,34 +2176,37 @@ Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
@subsection @code{GIMPLE_PHI}
@cindex @code{GIMPLE_PHI}

-@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple *g)
Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple *g)
Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
be exactly the number of incoming edges for the basic block
holding @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
+@deftypefn {GIMPLE function} tree gimple_phi_result (gimple *g)
Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple *g)
Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
+@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple *g, @
+tree result)
Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
+@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (@
+gimple *g, index)
Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
@code{GIMPLE_PHI} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
+@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple *g, @
+index, struct phi_arg_d * phiarg)
Set @code{PHIARG} to be the argument corresponding to incoming edge
@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@@ -2095,18 +2215,19 @@ Set @code{PHIARG} to be the argument corresponding to incoming edge
@subsection @code{GIMPLE_RESX}
@cindex @code{GIMPLE_RESX}

-@deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
+@deftypefn {GIMPLE function} gimple *gimple_build_resx (int region)
Build a @code{GIMPLE_RESX} statement which is a statement. This
statement is a placeholder for _Unwind_Resume before we know if a
function call or a branch is needed. @code{REGION} is the exception
region from which control is flowing.
@end deftypefn

-@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
+@deftypefn {GIMPLE function} int gimple_resx_region (gimple *g)
Return the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
+@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple *g, @
+int region)
Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn

@@ -2114,15 +2235,16 @@ Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
@subsection @code{GIMPLE_RETURN}
@cindex @code{GIMPLE_RETURN}

-@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
+@deftypefn {GIMPLE function} gimple *gimple_build_return (tree retval)
Build a @code{GIMPLE_RETURN} statement whose return value is retval.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
+@deftypefn {GIMPLE function} tree gimple_return_retval (gimple *g)
Return the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
+@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple *g, @
+tree retval)
Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn

@@ -2130,50 +2252,52 @@ Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@subsection @code{GIMPLE_SWITCH}
@cindex @code{GIMPLE_SWITCH}

-@deftypefn {GIMPLE function} gimple gimple_build_switch (tree index, tree @
-default_label, @code{VEC}(tree,heap) *args)
+@deftypefn {GIMPLE function} gimple *gimple_build_switch (tree index, @
+tree default_label, @code{VEC}(tree,heap) *args)
Build a @code{GIMPLE_SWITCH} statement. @code{INDEX} is the index variable
to switch on, and @code{DEFAULT_LABEL} represents the default label.
@code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
non-default case labels. Each label is a tree of code @code{CASE_LABEL_EXPR}.
@end deftypefn

-@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple *g)
Return the number of labels associated with the switch statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, @
-unsigned nlabels)
+@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (@
+gimple *g, unsigned nlabels)
Set @code{NLABELS} to be the number of labels for the switch statement
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
+@deftypefn {GIMPLE function} tree gimple_switch_index (gimple *g)
Return the index variable used by the switch statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
+@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple *g, @
+tree index)
Set @code{INDEX} to be the index variable for switch statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_switch_label (gimple *g, @
+unsigned index)
Return the label numbered @code{INDEX}. The default label is 0, followed
by any labels in a switch statement.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned @
-index, tree label)
+@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple *g, @
+unsigned index, tree label)
Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
label.
@end deftypefn

-@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple *g)
Return the default label for a switch statement.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, @
-tree label)
+@deftypefn {GIMPLE function} void gimple_switch_set_default_label (@
+gimple *g, tree label)
Set the default label for a switch statement.
@end deftypefn

@@ -2182,7 +2306,7 @@ Set the default label for a switch statement.
@subsection @code{GIMPLE_TRY}
@cindex @code{GIMPLE_TRY}

-@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, @
+@deftypefn {GIMPLE function} gimple *gimple_build_try (gimple_seq eval, @
gimple_seq cleanup, unsigned int kind)
Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the
expression to evaluate. @code{CLEANUP} is a sequence of statements to
@@ -2192,36 +2316,39 @@ or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
construct.
@end deftypefn

-@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (@
+gimple *g)
Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
+@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple *g)
Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple *g)
Return the sequence of statements used as the body for @code{GIMPLE_TRY}
@code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple *g)
Return the sequence of statements used as the cleanup body for
@code{GIMPLE_TRY} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
-bool catch_is_cleanup)
+@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (@
+gimple *g, bool catch_is_cleanup)
Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
+@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple *g, @
+gimple_seq eval)
Set @code{EVAL} to be the sequence of statements to use as the body for
@code{GIMPLE_TRY} @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
+@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple *g, @
+gimple_seq cleanup)
Set @code{CLEANUP} to be the sequence of statements to use as the
cleanup body for @code{GIMPLE_TRY} @code{G}.
@end deftypefn
@@ -2230,24 +2357,26 @@ cleanup body for @code{GIMPLE_TRY} @code{G}.
@subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
@cindex @code{GIMPLE_WITH_CLEANUP_EXPR}

-@deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
+@deftypefn {GIMPLE function} gimple *gimple_build_wce (gimple_seq cleanup)
Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement. @code{CLEANUP} is the
clean-up expression.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple *g)
Return the cleanup sequence for cleanup statement @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
+@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple *g, @
+gimple_seq cleanup)
Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
@end deftypefn

-@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
+@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple *g)
Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
+@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (@
+gimple *g, bool eh_only_p)
Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn

@@ -2274,7 +2403,8 @@ in the section entitled Sequence Iterators.

Below is a list of functions to manipulate and query sequences.

-@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
+@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, @
+gimple *g)
Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
not @code{NULL}. If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
@end deftypefn
@@ -2294,19 +2424,21 @@ Reverse the order of the statements in the sequence @code{SEQ}. Return
@code{SEQ}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
+@deftypefn {GIMPLE function} gimple *gimple_seq_first (gimple_seq s)
Return the first statement in sequence @code{S}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
+@deftypefn {GIMPLE function} gimple *gimple_seq_last (gimple_seq s)
Return the last statement in sequence @code{S}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
+@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, @
+gimple *last)
Set the last statement in sequence @code{S} to the statement in @code{LAST}.
@end deftypefn

-@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
+@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, @
+gimple *first)
Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
@end deftypefn

@@ -2352,7 +2484,7 @@ gimple_stmt_iterator gsi;

for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
@{
- gimple g = gsi_stmt (gsi);
+ gimple *g = gsi_stmt (gsi);
/* Do something with gimple statement @code{G}. */
@}
@end smallexample
@@ -2424,7 +2556,7 @@ Advance the iterator to the next gimple statement.
Advance the iterator to the previous gimple statement.
@end deftypefn

-@deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
+@deftypefn {GIMPLE function} gimple *gsi_stmt (gimple_stmt_iterator i)
Return the current stmt.
@end deftypefn

@@ -2433,7 +2565,8 @@ Return a block statement iterator that points to the first
non-label statement in block @code{BB}.
@end deftypefn

-@deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i)
+@deftypefn {GIMPLE function} {gimple **} gsi_stmt_ptr (@
+gimple_stmt_iterator *i)
Return a pointer to the current stmt.
@end deftypefn

@@ -2460,7 +2593,8 @@ by iterator @code{I}. @code{MODE} indicates what to do with the iterator
after insertion (see @code{enum gsi_iterator_update} above).
@end deftypefn

-@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, @
+gimple *g, enum gsi_iterator_update mode)
Links statement @code{G} before the statement pointed-to by iterator @code{I}.
Updates iterator @code{I} according to @code{MODE}.
@end deftypefn
@@ -2472,7 +2606,7 @@ Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
@end deftypefn

@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
-gimple g, enum gsi_iterator_update mode)
+gimple *g, enum gsi_iterator_update mode)
Links statement @code{G} after the statement pointed-to by iterator @code{I}.
@code{MODE} is as in @code{gsi_insert_after}.
@end deftypefn
@@ -2488,14 +2622,14 @@ Return this new sequence.
@end deftypefn

@deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @
-gimple stmt, bool update_eh_info)
+gimple *stmt, bool update_eh_info)
Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO}
is true, the exception handling information of the original
statement is moved to the new statement.
@end deftypefn

@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
-gimple stmt, enum gsi_iterator_update mode)
+gimple *stmt, enum gsi_iterator_update mode)
Insert statement @code{STMT} before the statement pointed-to by iterator
@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
specifies how to update iterator @code{I} after insertion (see enum
@@ -2508,7 +2642,7 @@ Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
@end deftypefn

@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
-gimple stmt, enum gsi_iterator_update mode)
+gimple *stmt, enum gsi_iterator_update mode)
Insert statement @code{STMT} after the statement pointed-to by iterator
@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
specifies how to update iterator @code{I} after insertion (see enum
@@ -2520,7 +2654,8 @@ gimple_seq seq, enum gsi_iterator_update mode)
Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
@end deftypefn

-@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (@
+gimple *stmt)
Finds iterator for @code{STMT}.
@end deftypefn

@@ -2541,7 +2676,7 @@ basic_block bb)
Move the statement at @code{FROM} to the end of basic block @code{BB}.
@end deftypefn

-@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
+@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple *stmt)
Add @code{STMT} to the pending list of edge @code{E}. No actual insertion is
made until a call to @code{gsi_commit_edge_inserts}() is made.
@end deftypefn
@@ -2552,7 +2687,8 @@ Add the sequence of statements in @code{SEQ} to the pending list of edge
@code{gsi_commit_edge_inserts}() is made.
@end deftypefn

-@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
+@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (@
+edge e, gimple *stmt)
Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}. If a new
block has to be created, it is returned.
@end deftypefn
@@ -2626,7 +2762,7 @@ The return value is that returned by the last call to
@end deftypefn


-@deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @
+@deftypefn {GIMPLE function} tree walk_gimple_op (gimple *stmt, @
walk_tree_fn callback_op, struct walk_stmt_info *wi)
Use this function to walk the operands of statement @code{STMT}. Every
operand is walked via @code{walk_tree} with optional state information
diff --git a/gcc/gdbhooks.py b/gcc/gdbhooks.py
index 85608dc..a0d94bb 100644
--- a/gcc/gdbhooks.py
+++ b/gcc/gdbhooks.py
@@ -454,7 +454,7 @@ def build_pretty_printer():
'tree', TreePrinter)
pp.add_printer_for_types(['cgraph_node *'],
'cgraph_node', CGraphNodePrinter)
- pp.add_printer_for_types(['gimple', 'gimple_statement_base *'],
+ pp.add_printer_for_types(['gimple *'],
'gimple',
GimplePrinter)
pp.add_printer_for_types(['basic_block', 'basic_block_def *'],
diff --git a/gcc/ggc.h b/gcc/ggc.h
index 55f3fe9..337d222 100644
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -270,10 +270,10 @@ ggc_alloc_cleared_tree_node_stat (size_t s MEM_STAT_DECL)
return (union tree_node *) ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
}

-static inline struct gimple_statement_base *
-ggc_alloc_cleared_gimple_statement_stat (size_t s MEM_STAT_DECL)
+static inline gimple
+ggc_alloc_cleared_gimple_stat (size_t s MEM_STAT_DECL)
{
- return (struct gimple_statement_base *)
+ return (gimple)
ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
}

diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 77afa20..b80ae72 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -94,13 +94,13 @@ print_gimple_stmt (FILE *file, gimple g, int spc, int flags)
}

DEBUG_FUNCTION void
-debug (gimple_statement_base &ref)
+debug (gimple &ref)
{
print_gimple_stmt (stderr, &ref, 0, 0);
}

DEBUG_FUNCTION void
-debug (gimple_statement_base *ptr)
+debug (gimple *ptr)
{
if (ptr)
debug (*ptr);
diff --git a/gcc/gimple-pretty-print.h b/gcc/gimple-pretty-print.h
index 37db243..82ef760 100644
--- a/gcc/gimple-pretty-print.h
+++ b/gcc/gimple-pretty-print.h
@@ -29,8 +29,8 @@ extern void debug_gimple_stmt (gimple);
extern void debug_gimple_seq (gimple_seq);
extern void print_gimple_seq (FILE *, gimple_seq, int, int);
extern void print_gimple_stmt (FILE *, gimple, int, int);
-extern void debug (gimple_statement_base &ref);
-extern void debug (gimple_statement_base *ptr);
+extern void debug (gimple &ref);
+extern void debug (gimple *ptr);
extern void print_gimple_expr (FILE *, gimple, int, int);
extern void pp_gimple_stmt_1 (pretty_printer *, gimple, int, int);
extern void gimple_dump_bb (FILE *, basic_block, int, int);
diff --git a/gcc/gimple-ssa.h b/gcc/gimple-ssa.h
index 904f002..21d6426 100644
--- a/gcc/gimple-ssa.h
+++ b/gcc/gimple-ssa.h
@@ -108,8 +108,8 @@ static inline use_operand_p
gimple_vuse_op (const_gimple g)
{
struct use_optype_d *ops;
- const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops *> (g);
+ const gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <const gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_USE_OPERAND_P;
ops = mem_ops_stmt->use_ops;
@@ -124,8 +124,8 @@ gimple_vuse_op (const_gimple g)
static inline def_operand_p
gimple_vdef_op (gimple g)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_DEF_OPERAND_P;
if (mem_ops_stmt->vdef)
diff --git a/gcc/gimple-streamer-in.c b/gcc/gimple-streamer-in.c
index f7b5d01..5c685f4 100644
--- a/gcc/gimple-streamer-in.c
+++ b/gcc/gimple-streamer-in.c
@@ -137,7 +137,7 @@ input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
case GIMPLE_ASM:
{
/* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (stmt);
+ gasm *asm_stmt = as_a <gasm *> (stmt);
tree str;
asm_stmt->ni = streamer_read_uhwi (ib);
asm_stmt->no = streamer_read_uhwi (ib);
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 091467e..cba2d1b 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -132,7 +132,7 @@ gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
gimple_alloc_sizes[(int) kind] += size;
}

- stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
+ stmt = ggc_alloc_cleared_gimple_stat (size PASS_MEM_STAT);
gimple_set_code (stmt, code);
gimple_set_num_ops (stmt, num_ops);

@@ -537,14 +537,14 @@ static inline gimple
gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
unsigned nclobbers, unsigned nlabels)
{
- gimple_statement_asm *p;
+ gasm *p;
int size = strlen (string);

/* ASMs with labels cannot have outputs. This should have been
enforced by the front end. */
gcc_assert (nlabels == 0 || noutputs == 0);

- p = as_a <gimple_statement_asm *> (
+ p = as_a <gasm *> (
gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
ninputs + noutputs + nclobbers + nlabels));

@@ -664,14 +664,14 @@ gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
whether this is a try/catch or a try/finally respectively. */

-gimple_statement_try *
+gtry *
gimple_build_try (gimple_seq eval, gimple_seq cleanup,
enum gimple_try_flags kind)
{
- gimple_statement_try *p;
+ gtry *p;

gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
- p = as_a <gimple_statement_try *> (gimple_alloc (GIMPLE_TRY, 0));
+ p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
gimple_set_subcode (p, kind);
if (eval)
gimple_try_set_eval (p, eval);
@@ -701,8 +701,8 @@ gimple_build_wce (gimple_seq cleanup)
gimple
gimple_build_resx (int region)
{
- gimple_statement_resx *p =
- as_a <gimple_statement_resx *> (
+ gresx *p =
+ as_a <gresx *> (
gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
p->region = region;
return p;
@@ -751,8 +751,8 @@ gimple_build_switch (tree index, tree default_label, vec<tree> args)
gimple
gimple_build_eh_dispatch (int region)
{
- gimple_statement_eh_dispatch *p =
- as_a <gimple_statement_eh_dispatch *> (
+ geh_dispatch *p =
+ as_a <geh_dispatch *> (
gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
p->region = region;
return p;
@@ -828,8 +828,7 @@ gimple
gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
gimple_seq pre_body)
{
- gimple_statement_omp_for *p =
- as_a <gimple_statement_omp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
+ gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
if (body)
gimple_omp_set_body (p, body);
gimple_omp_for_set_clauses (p, clauses);
@@ -1663,8 +1662,7 @@ gimple_copy (gimple stmt)
t = unshare_expr (gimple_omp_for_clauses (stmt));
gimple_omp_for_set_clauses (copy, t);
{
- gimple_statement_omp_for *omp_for_copy =
- as_a <gimple_statement_omp_for *> (copy);
+ gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
omp_for_copy->iter =
static_cast <struct gimple_omp_for_iter *> (
ggc_internal_vec_alloc_stat (sizeof (struct gimple_omp_for_iter),
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 9df45de..1635ab5 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -70,7 +70,7 @@ enum gimple_rhs_class
};

/* Specific flags for individual GIMPLE statements. These flags are
- always stored in gimple_statement_base.subcode and they may only be
+ always stored in gimple.subcode and they may only be
defined for statement codes that do not use subcodes.

Values for the masks can overlap as long as the overlapping values
@@ -136,7 +136,7 @@ enum plf_mask {

struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
chain_next ("%h.next"), variable_size))
- gimple_statement_base
+ gimple
{
/* [ WORD 1 ]
Main identifying code for a tuple. */
@@ -206,7 +206,7 @@ struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),

/* This gimple subclass has no tag value. */
struct GTY(())
- gimple_statement_with_ops_base : public gimple_statement_base
+ gimple_with_ops_base : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -222,7 +222,7 @@ struct GTY(())
/* Statements that take register operands. */

struct GTY((tag("GSS_WITH_OPS")))
- gimple_statement_with_ops : public gimple_statement_with_ops_base
+ gimple_with_ops : public gimple_with_ops_base
{
/* [ WORD 1-7 ] : base class */

@@ -237,7 +237,7 @@ struct GTY((tag("GSS_WITH_OPS")))
/* Base for statements that take both memory and register operands. */

struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
- gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base
+ gimple_with_memory_ops_base : public gimple_with_ops_base
{
/* [ WORD 1-7 ] : base class */

@@ -252,8 +252,8 @@ struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
/* Statements that take both memory and register operands. */

struct GTY((tag("GSS_WITH_MEM_OPS")))
- gimple_statement_with_memory_ops :
- public gimple_statement_with_memory_ops_base
+ gimple_with_memory_ops :
+ public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */

@@ -268,7 +268,7 @@ struct GTY((tag("GSS_WITH_MEM_OPS")))
/* Call statements that take both memory and register operands. */

struct GTY((tag("GSS_CALL")))
- gimple_statement_call : public gimple_statement_with_memory_ops_base
+ gcall : public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */

@@ -293,7 +293,7 @@ struct GTY((tag("GSS_CALL")))
/* OpenMP statements (#pragma omp). */

struct GTY((tag("GSS_OMP")))
- gimple_statement_omp : public gimple_statement_base
+ gomp : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -305,7 +305,7 @@ struct GTY((tag("GSS_OMP")))
/* GIMPLE_BIND */

struct GTY((tag("GSS_BIND")))
- gimple_statement_bind : public gimple_statement_base
+ gbind : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -314,7 +314,7 @@ struct GTY((tag("GSS_BIND")))
tree vars;

/* [ WORD 8 ]
- This is different than the BLOCK field in gimple_statement_base,
+ This is different than the BLOCK field in gimple,
which is analogous to TREE_BLOCK (i.e., the lexical block holding
this statement). This field is the equivalent of BIND_EXPR_BLOCK
in tree land (i.e., the lexical scope defined by this bind). See
@@ -329,7 +329,7 @@ struct GTY((tag("GSS_BIND")))
/* GIMPLE_CATCH */

struct GTY((tag("GSS_CATCH")))
- gimple_statement_catch : public gimple_statement_base
+ gcatch : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -344,7 +344,7 @@ struct GTY((tag("GSS_CATCH")))
/* GIMPLE_EH_FILTER */

struct GTY((tag("GSS_EH_FILTER")))
- gimple_statement_eh_filter : public gimple_statement_base
+ geh_filter : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -360,7 +360,7 @@ struct GTY((tag("GSS_EH_FILTER")))
/* GIMPLE_EH_ELSE */

struct GTY((tag("GSS_EH_ELSE")))
- gimple_statement_eh_else : public gimple_statement_base
+ geh_else : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -371,7 +371,7 @@ struct GTY((tag("GSS_EH_ELSE")))
/* GIMPLE_EH_MUST_NOT_THROW */

struct GTY((tag("GSS_EH_MNT")))
- gimple_statement_eh_mnt : public gimple_statement_base
+ geh_mnt : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -382,7 +382,7 @@ struct GTY((tag("GSS_EH_MNT")))
/* GIMPLE_PHI */

struct GTY((tag("GSS_PHI")))
- gimple_statement_phi : public gimple_statement_base
+ gphi : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -401,7 +401,7 @@ struct GTY((tag("GSS_PHI")))
/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */

struct GTY((tag("GSS_EH_CTRL")))
- gimple_statement_eh_ctrl : public gimple_statement_base
+ geh_ctrl : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -411,14 +411,14 @@ struct GTY((tag("GSS_EH_CTRL")))
};

struct GTY((tag("GSS_EH_CTRL")))
- gimple_statement_resx : public gimple_statement_eh_ctrl
+ gresx : public geh_ctrl
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_RESX. */
};

struct GTY((tag("GSS_EH_CTRL")))
- gimple_statement_eh_dispatch : public gimple_statement_eh_ctrl
+ geh_dispatch : public geh_ctrl
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_EH_DISPATH. */
@@ -428,7 +428,7 @@ struct GTY((tag("GSS_EH_CTRL")))
/* GIMPLE_TRY */

struct GTY((tag("GSS_TRY")))
- gimple_statement_try : public gimple_statement_base
+ gtry : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -458,7 +458,7 @@ enum gimple_try_flags
/* GIMPLE_WITH_CLEANUP_EXPR */

struct GTY((tag("GSS_WCE")))
- gimple_statement_wce : public gimple_statement_base
+ gwce : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -476,7 +476,7 @@ struct GTY((tag("GSS_WCE")))
/* GIMPLE_ASM */

struct GTY((tag("GSS_ASM")))
- gimple_statement_asm : public gimple_statement_with_memory_ops_base
+ gasm : public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */

@@ -501,7 +501,7 @@ struct GTY((tag("GSS_ASM")))
/* GIMPLE_OMP_CRITICAL */

struct GTY((tag("GSS_OMP_CRITICAL")))
- gimple_statement_omp_critical : public gimple_statement_omp
+ gomp_critical : public gomp
{
/* [ WORD 1-7 ] : base class */

@@ -531,7 +531,7 @@ struct GTY(()) gimple_omp_for_iter {
/* GIMPLE_OMP_FOR */

struct GTY((tag("GSS_OMP_FOR")))
- gimple_statement_omp_for : public gimple_statement_omp
+ gomp_for : public gomp
{
/* [ WORD 1-7 ] : base class */

@@ -553,7 +553,7 @@ struct GTY((tag("GSS_OMP_FOR")))

/* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET */
struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_parallel_layout : public gimple_statement_omp
+ gomp_parallel_layout : public gomp
{
/* [ WORD 1-7 ] : base class */

@@ -572,7 +572,7 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))

/* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout
+ gomp_taskreg : public gomp_parallel_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_PARALLEL
@@ -582,14 +582,14 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))

/* GIMPLE_OMP_PARALLEL */
struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_parallel : public gimple_statement_omp_taskreg
+ gomp_parallel : public gomp_taskreg
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_PARALLEL. */
};

struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_target : public gimple_statement_omp_parallel_layout
+ gomp_target : public gomp_parallel_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_TARGET. */
@@ -598,7 +598,7 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
/* GIMPLE_OMP_TASK */

struct GTY((tag("GSS_OMP_TASK")))
- gimple_statement_omp_task : public gimple_statement_omp_taskreg
+ gomp_task : public gomp_taskreg
{
/* [ WORD 1-10 ] : base class */

@@ -614,13 +614,13 @@ struct GTY((tag("GSS_OMP_TASK")))


/* GIMPLE_OMP_SECTION */
-/* Uses struct gimple_statement_omp. */
+/* Uses struct gimple_omp. */


/* GIMPLE_OMP_SECTIONS */

struct GTY((tag("GSS_OMP_SECTIONS")))
- gimple_statement_omp_sections : public gimple_statement_omp
+ gomp_sections : public gomp
{
/* [ WORD 1-7 ] : base class */

@@ -635,11 +635,11 @@ struct GTY((tag("GSS_OMP_SECTIONS")))

/* GIMPLE_OMP_CONTINUE.

- Note: This does not inherit from gimple_statement_omp, because we
+ Note: This does not inherit from gomp, because we
do not need the body field. */

struct GTY((tag("GSS_OMP_CONTINUE")))
- gimple_statement_omp_continue : public gimple_statement_base
+ gomp_continue : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -653,7 +653,7 @@ struct GTY((tag("GSS_OMP_CONTINUE")))
/* GIMPLE_OMP_SINGLE, GIMPLE_OMP_TEAMS */

struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
- gimple_statement_omp_single_layout : public gimple_statement_omp
+ gomp_single_layout : public gomp
{
/* [ WORD 1-7 ] : base class */

@@ -662,14 +662,14 @@ struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
};

struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
- gimple_statement_omp_single : public gimple_statement_omp_single_layout
+ gomp_single : public gomp_single_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_SINGLE. */
};

struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
- gimple_statement_omp_teams : public gimple_statement_omp_single_layout
+ gomp_teams : public gomp_single_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_TEAMS. */
@@ -677,11 +677,11 @@ struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))


/* GIMPLE_OMP_ATOMIC_LOAD.
- Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
+ Note: This is based on gimple, not gomp, because gomp
contains a sequence, which we don't need here. */

struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
- gimple_statement_omp_atomic_load : public gimple_statement_base
+ gomp_atomic_load : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -693,7 +693,7 @@ struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
See note on GIMPLE_OMP_ATOMIC_LOAD. */

struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
- gimple_statement_omp_atomic_store_layout : public gimple_statement_base
+ gomp_atomic_store_layout : public gimple
{
/* [ WORD 1-6 ] : base class */

@@ -702,16 +702,16 @@ struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
};

struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
- gimple_statement_omp_atomic_store :
- public gimple_statement_omp_atomic_store_layout
+ gomp_atomic_store :
+ public gomp_atomic_store_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
};

struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
- gimple_statement_omp_return :
- public gimple_statement_omp_atomic_store_layout
+ gomp_return :
+ public gomp_atomic_store_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_RETURN. */
@@ -746,7 +746,7 @@ struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
#define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)

struct GTY((tag("GSS_TRANSACTION")))
- gimple_statement_transaction : public gimple_statement_with_memory_ops_base
+ gtransaction : public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */

@@ -767,7 +767,7 @@ enum gimple_statement_structure_enum {
template <>
template <>
inline bool
-is_a_helper <gimple_statement_asm *>::test (gimple gs)
+is_a_helper <gasm *>::test (gimple gs)
{
return gs->code == GIMPLE_ASM;
}
@@ -775,7 +775,7 @@ is_a_helper <gimple_statement_asm *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_bind *>::test (gimple gs)
+is_a_helper <gbind *>::test (gimple gs)
{
return gs->code == GIMPLE_BIND;
}
@@ -783,7 +783,7 @@ is_a_helper <gimple_statement_bind *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_call *>::test (gimple gs)
+is_a_helper <gcall *>::test (gimple gs)
{
return gs->code == GIMPLE_CALL;
}
@@ -791,7 +791,7 @@ is_a_helper <gimple_statement_call *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_catch *>::test (gimple gs)
+is_a_helper <gcatch *>::test (gimple gs)
{
return gs->code == GIMPLE_CATCH;
}
@@ -799,7 +799,7 @@ is_a_helper <gimple_statement_catch *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_resx *>::test (gimple gs)
+is_a_helper <gresx *>::test (gimple gs)
{
return gs->code == GIMPLE_RESX;
}
@@ -807,7 +807,7 @@ is_a_helper <gimple_statement_resx *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_dispatch *>::test (gimple gs)
+is_a_helper <geh_dispatch *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_DISPATCH;
}
@@ -815,7 +815,7 @@ is_a_helper <gimple_statement_eh_dispatch *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_else *>::test (gimple gs)
+is_a_helper <geh_else *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_ELSE;
}
@@ -823,7 +823,7 @@ is_a_helper <gimple_statement_eh_else *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_filter *>::test (gimple gs)
+is_a_helper <geh_filter *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_FILTER;
}
@@ -831,7 +831,7 @@ is_a_helper <gimple_statement_eh_filter *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_mnt *>::test (gimple gs)
+is_a_helper <geh_mnt *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_MUST_NOT_THROW;
}
@@ -839,7 +839,7 @@ is_a_helper <gimple_statement_eh_mnt *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_atomic_load *>::test (gimple gs)
+is_a_helper <gomp_atomic_load *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
}
@@ -847,7 +847,7 @@ is_a_helper <gimple_statement_omp_atomic_load *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_atomic_store *>::test (gimple gs)
+is_a_helper <gomp_atomic_store *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_STORE;
}
@@ -855,7 +855,7 @@ is_a_helper <gimple_statement_omp_atomic_store *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
+is_a_helper <gomp_return *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_RETURN;
}
@@ -863,7 +863,7 @@ is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_continue *>::test (gimple gs)
+is_a_helper <gomp_continue *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_CONTINUE;
}
@@ -871,7 +871,7 @@ is_a_helper <gimple_statement_omp_continue *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_critical *>::test (gimple gs)
+is_a_helper <gomp_critical *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_CRITICAL;
}
@@ -879,7 +879,7 @@ is_a_helper <gimple_statement_omp_critical *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_for *>::test (gimple gs)
+is_a_helper <gomp_for *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_FOR;
}
@@ -887,7 +887,7 @@ is_a_helper <gimple_statement_omp_for *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
+is_a_helper <gomp_taskreg *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
}
@@ -895,7 +895,7 @@ is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_parallel *>::test (gimple gs)
+is_a_helper <gomp_parallel *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL;
}
@@ -903,7 +903,7 @@ is_a_helper <gimple_statement_omp_parallel *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_target *>::test (gimple gs)
+is_a_helper <gomp_target *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TARGET;
}
@@ -911,7 +911,7 @@ is_a_helper <gimple_statement_omp_target *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_sections *>::test (gimple gs)
+is_a_helper <gomp_sections *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_SECTIONS;
}
@@ -919,7 +919,7 @@ is_a_helper <gimple_statement_omp_sections *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_single *>::test (gimple gs)
+is_a_helper <gomp_single *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_SINGLE;
}
@@ -927,7 +927,7 @@ is_a_helper <gimple_statement_omp_single *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_teams *>::test (gimple gs)
+is_a_helper <gomp_teams *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TEAMS;
}
@@ -935,7 +935,7 @@ is_a_helper <gimple_statement_omp_teams *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_task *>::test (gimple gs)
+is_a_helper <gomp_task *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TASK;
}
@@ -943,7 +943,7 @@ is_a_helper <gimple_statement_omp_task *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_phi *>::test (gimple gs)
+is_a_helper <gphi *>::test (gimple gs)
{
return gs->code == GIMPLE_PHI;
}
@@ -951,7 +951,7 @@ is_a_helper <gimple_statement_phi *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_transaction *>::test (gimple gs)
+is_a_helper <gtransaction *>::test (gimple gs)
{
return gs->code == GIMPLE_TRANSACTION;
}
@@ -959,7 +959,7 @@ is_a_helper <gimple_statement_transaction *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_try *>::test (gimple gs)
+is_a_helper <gtry *>::test (gimple gs)
{
return gs->code == GIMPLE_TRY;
}
@@ -967,7 +967,7 @@ is_a_helper <gimple_statement_try *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_wce *>::test (gimple gs)
+is_a_helper <gwce *>::test (gimple gs)
{
return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
}
@@ -975,7 +975,7 @@ is_a_helper <gimple_statement_wce *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_asm *>::test (const_gimple gs)
+is_a_helper <const gasm *>::test (const_gimple gs)
{
return gs->code == GIMPLE_ASM;
}
@@ -983,7 +983,7 @@ is_a_helper <const gimple_statement_asm *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_bind *>::test (const_gimple gs)
+is_a_helper <const gbind *>::test (const_gimple gs)
{
return gs->code == GIMPLE_BIND;
}
@@ -991,7 +991,7 @@ is_a_helper <const gimple_statement_bind *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_call *>::test (const_gimple gs)
+is_a_helper <const gcall *>::test (const_gimple gs)
{
return gs->code == GIMPLE_CALL;
}
@@ -999,7 +999,7 @@ is_a_helper <const gimple_statement_call *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_catch *>::test (const_gimple gs)
+is_a_helper <const gcatch *>::test (const_gimple gs)
{
return gs->code == GIMPLE_CATCH;
}
@@ -1007,7 +1007,7 @@ is_a_helper <const gimple_statement_catch *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_resx *>::test (const_gimple gs)
+is_a_helper <const gresx *>::test (const_gimple gs)
{
return gs->code == GIMPLE_RESX;
}
@@ -1015,7 +1015,7 @@ is_a_helper <const gimple_statement_resx *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_eh_dispatch *>::test (const_gimple gs)
+is_a_helper <const geh_dispatch *>::test (const_gimple gs)
{
return gs->code == GIMPLE_EH_DISPATCH;
}
@@ -1023,7 +1023,7 @@ is_a_helper <const gimple_statement_eh_dispatch *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_eh_filter *>::test (const_gimple gs)
+is_a_helper <const geh_filter *>::test (const_gimple gs)
{
return gs->code == GIMPLE_EH_FILTER;
}
@@ -1031,7 +1031,7 @@ is_a_helper <const gimple_statement_eh_filter *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_atomic_load *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_load *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
}
@@ -1039,7 +1039,7 @@ is_a_helper <const gimple_statement_omp_atomic_load *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_atomic_store *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_store *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_STORE;
}
@@ -1047,7 +1047,7 @@ is_a_helper <const gimple_statement_omp_atomic_store *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
+is_a_helper <const gomp_return *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_RETURN;
}
@@ -1055,7 +1055,7 @@ is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_continue *>::test (const_gimple gs)
+is_a_helper <const gomp_continue *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_CONTINUE;
}
@@ -1063,7 +1063,7 @@ is_a_helper <const gimple_statement_omp_continue *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_critical *>::test (const_gimple gs)
+is_a_helper <const gomp_critical *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_CRITICAL;
}
@@ -1071,7 +1071,7 @@ is_a_helper <const gimple_statement_omp_critical *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_for *>::test (const_gimple gs)
+is_a_helper <const gomp_for *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_FOR;
}
@@ -1079,7 +1079,7 @@ is_a_helper <const gimple_statement_omp_for *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
+is_a_helper <const gomp_taskreg *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
}
@@ -1087,7 +1087,7 @@ is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_parallel *>::test (const_gimple gs)
+is_a_helper <const gomp_parallel *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL;
}
@@ -1095,7 +1095,7 @@ is_a_helper <const gimple_statement_omp_parallel *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_target *>::test (const_gimple gs)
+is_a_helper <const gomp_target *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TARGET;
}
@@ -1103,7 +1103,7 @@ is_a_helper <const gimple_statement_omp_target *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_sections *>::test (const_gimple gs)
+is_a_helper <const gomp_sections *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_SECTIONS;
}
@@ -1111,7 +1111,7 @@ is_a_helper <const gimple_statement_omp_sections *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_single *>::test (const_gimple gs)
+is_a_helper <const gomp_single *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_SINGLE;
}
@@ -1119,7 +1119,7 @@ is_a_helper <const gimple_statement_omp_single *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_teams *>::test (const_gimple gs)
+is_a_helper <const gomp_teams *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TEAMS;
}
@@ -1127,7 +1127,7 @@ is_a_helper <const gimple_statement_omp_teams *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_task *>::test (const_gimple gs)
+is_a_helper <const gomp_task *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TASK;
}
@@ -1135,7 +1135,7 @@ is_a_helper <const gimple_statement_omp_task *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_phi *>::test (const_gimple gs)
+is_a_helper <const gphi *>::test (const_gimple gs)
{
return gs->code == GIMPLE_PHI;
}
@@ -1143,7 +1143,7 @@ is_a_helper <const gimple_statement_phi *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_transaction *>::test (const_gimple gs)
+is_a_helper <const gtransaction *>::test (const_gimple gs)
{
return gs->code == GIMPLE_TRANSACTION;
}
@@ -1189,8 +1189,8 @@ gimple gimple_build_catch (tree, gimple_seq);
gimple gimple_build_eh_filter (tree, gimple_seq);
gimple gimple_build_eh_must_not_throw (tree);
gimple gimple_build_eh_else (gimple_seq, gimple_seq);
-gimple_statement_try *gimple_build_try (gimple_seq, gimple_seq,
- enum gimple_try_flags);
+gtry *gimple_build_try (gimple_seq, gimple_seq,
+ enum gimple_try_flags);
gimple gimple_build_wce (gimple_seq);
gimple gimple_build_resx (int);
gimple gimple_build_switch_nlabels (unsigned, tree, tree);
@@ -1647,7 +1647,7 @@ gimple_has_ops (const_gimple g)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_with_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_ops *>::test (const_gimple gs)
{
return gimple_has_ops (gs);
}
@@ -1655,7 +1655,7 @@ is_a_helper <const gimple_statement_with_ops *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_with_ops *>::test (gimple gs)
+is_a_helper <gimple_with_ops *>::test (gimple gs)
{
return gimple_has_ops (gs);
}
@@ -1671,7 +1671,7 @@ gimple_has_mem_ops (const_gimple g)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_with_memory_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_memory_ops *>::test (const_gimple gs)
{
return gimple_has_mem_ops (gs);
}
@@ -1679,7 +1679,7 @@ is_a_helper <const gimple_statement_with_memory_ops *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
+is_a_helper <gimple_with_memory_ops *>::test (gimple gs)
{
return gimple_has_mem_ops (gs);
}
@@ -1689,8 +1689,7 @@ is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
static inline struct use_optype_d *
gimple_use_ops (const_gimple g)
{
- const gimple_statement_with_ops *ops_stmt =
- dyn_cast <const gimple_statement_with_ops *> (g);
+ const gimple_with_ops *ops_stmt = dyn_cast <const gimple_with_ops *> (g);
if (!ops_stmt)
return NULL;
return ops_stmt->use_ops;
@@ -1702,8 +1701,7 @@ gimple_use_ops (const_gimple g)
static inline void
gimple_set_use_ops (gimple g, struct use_optype_d *use)
{
- gimple_statement_with_ops *ops_stmt =
- as_a <gimple_statement_with_ops *> (g);
+ gimple_with_ops *ops_stmt = as_a <gimple_with_ops *> (g);
ops_stmt->use_ops = use;
}

@@ -1713,8 +1711,8 @@ gimple_set_use_ops (gimple g, struct use_optype_d *use)
static inline tree
gimple_vuse (const_gimple g)
{
- const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops *> (g);
+ const gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <const gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_TREE;
return mem_ops_stmt->vuse;
@@ -1725,8 +1723,8 @@ gimple_vuse (const_gimple g)
static inline tree
gimple_vdef (const_gimple g)
{
- const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops *> (g);
+ const gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <const gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_TREE;
return mem_ops_stmt->vdef;
@@ -1737,8 +1735,8 @@ gimple_vdef (const_gimple g)
static inline tree *
gimple_vuse_ptr (gimple g)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL;
return &mem_ops_stmt->vuse;
@@ -1749,8 +1747,8 @@ gimple_vuse_ptr (gimple g)
static inline tree *
gimple_vdef_ptr (gimple g)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL;
return &mem_ops_stmt->vdef;
@@ -1761,8 +1759,8 @@ gimple_vdef_ptr (gimple g)
static inline void
gimple_set_vuse (gimple g, tree vuse)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- as_a <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ as_a <gimple_with_memory_ops *> (g);
mem_ops_stmt->vuse = vuse;
}

@@ -1771,8 +1769,8 @@ gimple_set_vuse (gimple g, tree vuse)
static inline void
gimple_set_vdef (gimple g, tree vdef)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- as_a <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ as_a <gimple_with_memory_ops *> (g);
mem_ops_stmt->vdef = vdef;
}

@@ -1903,8 +1901,7 @@ gimple_omp_return_nowait_p (const_gimple g)
static inline void
gimple_omp_return_set_lhs (gimple g, tree lhs)
{
- gimple_statement_omp_return *omp_return_stmt =
- as_a <gimple_statement_omp_return *> (g);
+ gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
omp_return_stmt->val = lhs;
}

@@ -1914,8 +1911,7 @@ gimple_omp_return_set_lhs (gimple g, tree lhs)
static inline tree
gimple_omp_return_lhs (const_gimple g)
{
- const gimple_statement_omp_return *omp_return_stmt =
- as_a <const gimple_statement_omp_return *> (g);
+ const gomp_return *omp_return_stmt = as_a <const gomp_return *> (g);
return omp_return_stmt->val;
}

@@ -1925,8 +1921,7 @@ gimple_omp_return_lhs (const_gimple g)
static inline tree *
gimple_omp_return_lhs_ptr (gimple g)
{
- gimple_statement_omp_return *omp_return_stmt =
- as_a <gimple_statement_omp_return *> (g);
+ gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
return &omp_return_stmt->val;
}

@@ -2444,7 +2439,7 @@ static inline enum internal_fn
gimple_call_internal_fn (const_gimple gs)
{
gcc_gimple_checking_assert (gimple_call_internal_p (gs));
- return static_cast <const gimple_statement_call *> (gs)->u.internal_fn;
+ return static_cast <const gcall *> (gs)->u.internal_fn;
}


@@ -2453,8 +2448,8 @@ gimple_call_internal_fn (const_gimple gs)
static inline tree
gimple_call_fntype (const_gimple gs)
{
- const gimple_statement_call *call_stmt =
- as_a <const gimple_statement_call *> (gs);
+ const gcall *call_stmt =
+ as_a <const gcall *> (gs);
if (gimple_call_internal_p (gs))
return NULL_TREE;
return call_stmt->u.fntype;
@@ -2465,7 +2460,7 @@ gimple_call_fntype (const_gimple gs)
static inline void
gimple_call_set_fntype (gimple gs, tree fntype)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
+ gcall *call_stmt = as_a <gcall *> (gs);
gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
call_stmt->u.fntype = fntype;
}
@@ -2519,7 +2514,7 @@ gimple_call_set_fndecl (gimple gs, tree decl)
static inline void
gimple_call_set_internal_fn (gimple gs, enum internal_fn fn)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
+ gcall *call_stmt = as_a <gcall *> (gs);
gcc_gimple_checking_assert (gimple_call_internal_p (gs));
call_stmt->u.internal_fn = fn;
}
@@ -2797,7 +2792,7 @@ gimple_call_copy_flags (gimple dest_call, gimple orig_call)
static inline struct pt_solution *
gimple_call_use_set (gimple call)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
+ gcall *call_stmt = as_a <gcall *> (call);
return &call_stmt->call_used;
}

@@ -2808,7 +2803,7 @@ gimple_call_use_set (gimple call)
static inline struct pt_solution *
gimple_call_clobber_set (gimple call)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
+ gcall *call_stmt = as_a <gcall *> (call);
return &call_stmt->call_clobbered;
}

@@ -3077,8 +3072,7 @@ gimple_goto_set_dest (gimple gs, tree dest)
static inline tree
gimple_bind_vars (const_gimple gs)
{
- const gimple_statement_bind *bind_stmt =
- as_a <const gimple_statement_bind *> (gs);
+ const gbind *bind_stmt = as_a <const gbind *> (gs);
return bind_stmt->vars;
}

@@ -3089,7 +3083,7 @@ gimple_bind_vars (const_gimple gs)
static inline void
gimple_bind_set_vars (gimple gs, tree vars)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
bind_stmt->vars = vars;
}

@@ -3100,7 +3094,7 @@ gimple_bind_set_vars (gimple gs, tree vars)
static inline void
gimple_bind_append_vars (gimple gs, tree vars)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
bind_stmt->vars = chainon (bind_stmt->vars, vars);
}

@@ -3108,7 +3102,7 @@ gimple_bind_append_vars (gimple gs, tree vars)
static inline gimple_seq *
gimple_bind_body_ptr (gimple gs)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
return &bind_stmt->body;
}

@@ -3127,7 +3121,7 @@ gimple_bind_body (gimple gs)
static inline void
gimple_bind_set_body (gimple gs, gimple_seq seq)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
bind_stmt->body = seq;
}

@@ -3137,7 +3131,7 @@ gimple_bind_set_body (gimple gs, gimple_seq seq)
static inline void
gimple_bind_add_stmt (gimple gs, gimple stmt)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
gimple_seq_add_stmt (&bind_stmt->body, stmt);
}

@@ -3147,7 +3141,7 @@ gimple_bind_add_stmt (gimple gs, gimple stmt)
static inline void
gimple_bind_add_seq (gimple gs, gimple_seq seq)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
gimple_seq_add_seq (&bind_stmt->body, seq);
}

@@ -3158,8 +3152,7 @@ gimple_bind_add_seq (gimple gs, gimple_seq seq)
static inline tree
gimple_bind_block (const_gimple gs)
{
- const gimple_statement_bind *bind_stmt =
- as_a <const gimple_statement_bind *> (gs);
+ const gbind *bind_stmt = as_a <const gbind *> (gs);
return bind_stmt->block;
}

@@ -3170,7 +3163,7 @@ gimple_bind_block (const_gimple gs)
static inline void
gimple_bind_set_block (gimple gs, tree block)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
gcc_gimple_checking_assert (block == NULL_TREE
|| TREE_CODE (block) == BLOCK);
bind_stmt->block = block;
@@ -3182,8 +3175,7 @@ gimple_bind_set_block (gimple gs, tree block)
static inline unsigned
gimple_asm_ninputs (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->ni;
}

@@ -3193,8 +3185,7 @@ gimple_asm_ninputs (const_gimple gs)
static inline unsigned
gimple_asm_noutputs (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->no;
}

@@ -3204,8 +3195,7 @@ gimple_asm_noutputs (const_gimple gs)
static inline unsigned
gimple_asm_nclobbers (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->nc;
}

@@ -3214,8 +3204,7 @@ gimple_asm_nclobbers (const_gimple gs)
static inline unsigned
gimple_asm_nlabels (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->nl;
}

@@ -3224,8 +3213,7 @@ gimple_asm_nlabels (const_gimple gs)
static inline tree
gimple_asm_input_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni);
return gimple_op (gs, index + asm_stmt->no);
}
@@ -3235,8 +3223,7 @@ gimple_asm_input_op (const_gimple gs, unsigned index)
static inline tree *
gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni);
return gimple_op_ptr (gs, index + asm_stmt->no);
}
@@ -3247,7 +3234,7 @@ gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni
&& TREE_CODE (in_op) == TREE_LIST);
gimple_set_op (gs, index + asm_stmt->no, in_op);
@@ -3259,8 +3246,7 @@ gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
static inline tree
gimple_asm_output_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no);
return gimple_op (gs, index);
}
@@ -3270,8 +3256,7 @@ gimple_asm_output_op (const_gimple gs, unsigned index)
static inline tree *
gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no);
return gimple_op_ptr (gs, index);
}
@@ -3282,7 +3267,7 @@ gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no
&& TREE_CODE (out_op) == TREE_LIST);
gimple_set_op (gs, index, out_op);
@@ -3294,8 +3279,7 @@ gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
static inline tree
gimple_asm_clobber_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nc);
return gimple_op (gs, index + asm_stmt->ni + asm_stmt->no);
}
@@ -3306,7 +3290,7 @@ gimple_asm_clobber_op (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nc
&& TREE_CODE (clobber_op) == TREE_LIST);
gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->no, clobber_op);
@@ -3317,8 +3301,7 @@ gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
static inline tree
gimple_asm_label_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nl);
return gimple_op (gs, index + asm_stmt->ni + asm_stmt->nc);
}
@@ -3328,7 +3311,7 @@ gimple_asm_label_op (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nl
&& TREE_CODE (label_op) == TREE_LIST);
gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->nc, label_op);
@@ -3340,8 +3323,7 @@ gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
static inline const char *
gimple_asm_string (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->string;
}

@@ -3397,8 +3379,7 @@ gimple_asm_input_p (const_gimple gs)
static inline tree
gimple_catch_types (const_gimple gs)
{
- const gimple_statement_catch *catch_stmt =
- as_a <const gimple_statement_catch *> (gs);
+ const gcatch *catch_stmt = as_a <const gcatch *> (gs);
return catch_stmt->types;
}

@@ -3408,7 +3389,7 @@ gimple_catch_types (const_gimple gs)
static inline tree *
gimple_catch_types_ptr (gimple gs)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
return &catch_stmt->types;
}

@@ -3419,7 +3400,7 @@ gimple_catch_types_ptr (gimple gs)
static inline gimple_seq *
gimple_catch_handler_ptr (gimple gs)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
return &catch_stmt->handler;
}

@@ -3439,7 +3420,7 @@ gimple_catch_handler (gimple gs)
static inline void
gimple_catch_set_types (gimple gs, tree t)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
catch_stmt->types = t;
}

@@ -3449,7 +3430,7 @@ gimple_catch_set_types (gimple gs, tree t)
static inline void
gimple_catch_set_handler (gimple gs, gimple_seq handler)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
catch_stmt->handler = handler;
}

@@ -3459,8 +3440,7 @@ gimple_catch_set_handler (gimple gs, gimple_seq handler)
static inline tree
gimple_eh_filter_types (const_gimple gs)
{
- const gimple_statement_eh_filter *eh_filter_stmt =
- as_a <const gimple_statement_eh_filter *> (gs);
+ const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
return eh_filter_stmt->types;
}

@@ -3471,8 +3451,7 @@ gimple_eh_filter_types (const_gimple gs)
static inline tree *
gimple_eh_filter_types_ptr (gimple gs)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
return &eh_filter_stmt->types;
}

@@ -3483,8 +3462,7 @@ gimple_eh_filter_types_ptr (gimple gs)
static inline gimple_seq *
gimple_eh_filter_failure_ptr (gimple gs)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
return &eh_filter_stmt->failure;
}

@@ -3504,8 +3482,7 @@ gimple_eh_filter_failure (gimple gs)
static inline void
gimple_eh_filter_set_types (gimple gs, tree types)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
eh_filter_stmt->types = types;
}

@@ -3516,8 +3493,7 @@ gimple_eh_filter_set_types (gimple gs, tree types)
static inline void
gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
eh_filter_stmt->failure = failure;
}

@@ -3526,7 +3502,7 @@ gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
static inline tree
gimple_eh_must_not_throw_fndecl (gimple gs)
{
- gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
+ geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
return eh_mnt_stmt->fndecl;
}

@@ -3535,7 +3511,7 @@ gimple_eh_must_not_throw_fndecl (gimple gs)
static inline void
gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
{
- gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
+ geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
eh_mnt_stmt->fndecl = decl;
}

@@ -3544,8 +3520,7 @@ gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
static inline gimple_seq *
gimple_eh_else_n_body_ptr (gimple gs)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
return &eh_else_stmt->n_body;
}

@@ -3558,8 +3533,7 @@ gimple_eh_else_n_body (gimple gs)
static inline gimple_seq *
gimple_eh_else_e_body_ptr (gimple gs)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
return &eh_else_stmt->e_body;
}

@@ -3572,16 +3546,14 @@ gimple_eh_else_e_body (gimple gs)
static inline void
gimple_eh_else_set_n_body (gimple gs, gimple_seq seq)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
eh_else_stmt->n_body = seq;
}

static inline void
gimple_eh_else_set_e_body (gimple gs, gimple_seq seq)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
eh_else_stmt->e_body = seq;
}

@@ -3627,7 +3599,7 @@ gimple_try_catch_is_cleanup (const_gimple gs)
static inline gimple_seq *
gimple_try_eval_ptr (gimple gs)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
return &try_stmt->eval;
}

@@ -3647,7 +3619,7 @@ gimple_try_eval (gimple gs)
static inline gimple_seq *
gimple_try_cleanup_ptr (gimple gs)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
return &try_stmt->cleanup;
}

@@ -3681,7 +3653,7 @@ gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
static inline void
gimple_try_set_eval (gimple gs, gimple_seq eval)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
try_stmt->eval = eval;
}

@@ -3692,7 +3664,7 @@ gimple_try_set_eval (gimple gs, gimple_seq eval)
static inline void
gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
try_stmt->cleanup = cleanup;
}

@@ -3702,7 +3674,7 @@ gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
static inline gimple_seq *
gimple_wce_cleanup_ptr (gimple gs)
{
- gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+ gwce *wce_stmt = as_a <gwce *> (gs);
return &wce_stmt->cleanup;
}

@@ -3721,7 +3693,7 @@ gimple_wce_cleanup (gimple gs)
static inline void
gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
{
- gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+ gwce *wce_stmt = as_a <gwce *> (gs);
wce_stmt->cleanup = cleanup;
}

@@ -3751,8 +3723,7 @@ gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
static inline unsigned
gimple_phi_capacity (const_gimple gs)
{
- const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi *> (gs);
+ const gphi *phi_stmt = as_a <const gphi *> (gs);
return phi_stmt->capacity;
}

@@ -3764,8 +3735,7 @@ gimple_phi_capacity (const_gimple gs)
static inline unsigned
gimple_phi_num_args (const_gimple gs)
{
- const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi *> (gs);
+ const gphi *phi_stmt = as_a <const gphi *> (gs);
return phi_stmt->nargs;
}

@@ -3775,8 +3745,7 @@ gimple_phi_num_args (const_gimple gs)
static inline tree
gimple_phi_result (const_gimple gs)
{
- const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi *> (gs);
+ const gphi *phi_stmt = as_a <const gphi *> (gs);
return phi_stmt->result;
}

@@ -3785,7 +3754,7 @@ gimple_phi_result (const_gimple gs)
static inline tree *
gimple_phi_result_ptr (gimple gs)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
return &phi_stmt->result;
}

@@ -3794,7 +3763,7 @@ gimple_phi_result_ptr (gimple gs)
static inline void
gimple_phi_set_result (gimple gs, tree result)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
phi_stmt->result = result;
if (result && TREE_CODE (result) == SSA_NAME)
SSA_NAME_DEF_STMT (result) = gs;
@@ -3807,7 +3776,7 @@ gimple_phi_set_result (gimple gs, tree result)
static inline struct phi_arg_d *
gimple_phi_arg (gimple gs, unsigned index)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
gcc_gimple_checking_assert (index <= phi_stmt->capacity);
return &(phi_stmt->args[index]);
}
@@ -3818,7 +3787,7 @@ gimple_phi_arg (gimple gs, unsigned index)
static inline void
gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
gcc_gimple_checking_assert (index <= phi_stmt->nargs);
phi_stmt->args[index] = *phiarg;
}
@@ -3905,8 +3874,7 @@ gimple_phi_arg_has_location (gimple gs, size_t i)
static inline int
gimple_resx_region (const_gimple gs)
{
- const gimple_statement_resx *resx_stmt =
- as_a <const gimple_statement_resx *> (gs);
+ const gresx *resx_stmt = as_a <const gresx *> (gs);
return resx_stmt->region;
}

@@ -3915,7 +3883,7 @@ gimple_resx_region (const_gimple gs)
static inline void
gimple_resx_set_region (gimple gs, int region)
{
- gimple_statement_resx *resx_stmt = as_a <gimple_statement_resx *> (gs);
+ gresx *resx_stmt = as_a <gresx *> (gs);
resx_stmt->region = region;
}

@@ -3924,8 +3892,7 @@ gimple_resx_set_region (gimple gs, int region)
static inline int
gimple_eh_dispatch_region (const_gimple gs)
{
- const gimple_statement_eh_dispatch *eh_dispatch_stmt =
- as_a <const gimple_statement_eh_dispatch *> (gs);
+ const geh_dispatch *eh_dispatch_stmt = as_a <const geh_dispatch *> (gs);
return eh_dispatch_stmt->region;
}

@@ -3934,8 +3901,7 @@ gimple_eh_dispatch_region (const_gimple gs)
static inline void
gimple_eh_dispatch_set_region (gimple gs, int region)
{
- gimple_statement_eh_dispatch *eh_dispatch_stmt =
- as_a <gimple_statement_eh_dispatch *> (gs);
+ geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (gs);
eh_dispatch_stmt->region = region;
}

@@ -4221,7 +4187,7 @@ get_lineno (const_gimple stmt)
static inline gimple_seq *
gimple_omp_body_ptr (gimple gs)
{
- return &static_cast <gimple_statement_omp *> (gs)->body;
+ return &static_cast <gomp *> (gs)->body;
}

/* Return the body for the OMP statement GS. */
@@ -4237,7 +4203,7 @@ gimple_omp_body (gimple gs)
static inline void
gimple_omp_set_body (gimple gs, gimple_seq body)
{
- static_cast <gimple_statement_omp *> (gs)->body = body;
+ static_cast <gomp *> (gs)->body = body;
}


@@ -4246,8 +4212,7 @@ gimple_omp_set_body (gimple gs, gimple_seq body)
static inline tree
gimple_omp_critical_name (const_gimple gs)
{
- const gimple_statement_omp_critical *omp_critical_stmt =
- as_a <const gimple_statement_omp_critical *> (gs);
+ const gomp_critical *omp_critical_stmt = as_a <const gomp_critical *> (gs);
return omp_critical_stmt->name;
}

@@ -4257,8 +4222,7 @@ gimple_omp_critical_name (const_gimple gs)
static inline tree *
gimple_omp_critical_name_ptr (gimple gs)
{
- gimple_statement_omp_critical *omp_critical_stmt =
- as_a <gimple_statement_omp_critical *> (gs);
+ gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
return &omp_critical_stmt->name;
}

@@ -4268,8 +4232,7 @@ gimple_omp_critical_name_ptr (gimple gs)
static inline void
gimple_omp_critical_set_name (gimple gs, tree name)
{
- gimple_statement_omp_critical *omp_critical_stmt =
- as_a <gimple_statement_omp_critical *> (gs);
+ gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
omp_critical_stmt->name = name;
}

@@ -4350,8 +4313,7 @@ gimple_omp_for_set_combined_into_p (gimple g, bool combined_p)
static inline tree
gimple_omp_for_clauses (const_gimple gs)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
return omp_for_stmt->clauses;
}

@@ -4361,8 +4323,7 @@ gimple_omp_for_clauses (const_gimple gs)
static inline tree *
gimple_omp_for_clauses_ptr (gimple gs)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
return &omp_for_stmt->clauses;
}

@@ -4372,8 +4333,7 @@ gimple_omp_for_clauses_ptr (gimple gs)
static inline void
gimple_omp_for_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
omp_for_stmt->clauses = clauses;
}

@@ -4383,8 +4343,7 @@ gimple_omp_for_set_clauses (gimple gs, tree clauses)
static inline size_t
gimple_omp_for_collapse (gimple gs)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
return omp_for_stmt->collapse;
}

@@ -4394,8 +4353,7 @@ gimple_omp_for_collapse (gimple gs)
static inline tree
gimple_omp_for_index (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].index;
}
@@ -4406,8 +4364,7 @@ gimple_omp_for_index (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_index_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].index;
}
@@ -4418,8 +4375,7 @@ gimple_omp_for_index_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_index (gimple gs, size_t i, tree index)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].index = index;
}
@@ -4430,8 +4386,7 @@ gimple_omp_for_set_index (gimple gs, size_t i, tree index)
static inline tree
gimple_omp_for_initial (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].initial;
}
@@ -4442,8 +4397,7 @@ gimple_omp_for_initial (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_initial_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].initial;
}
@@ -4454,8 +4408,7 @@ gimple_omp_for_initial_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].initial = initial;
}
@@ -4466,8 +4419,7 @@ gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
static inline tree
gimple_omp_for_final (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].final;
}
@@ -4478,8 +4430,7 @@ gimple_omp_for_final (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_final_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].final;
}
@@ -4490,8 +4441,7 @@ gimple_omp_for_final_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_final (gimple gs, size_t i, tree final)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].final = final;
}
@@ -4502,8 +4452,7 @@ gimple_omp_for_set_final (gimple gs, size_t i, tree final)
static inline tree
gimple_omp_for_incr (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].incr;
}
@@ -4514,8 +4463,7 @@ gimple_omp_for_incr (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_incr_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].incr;
}
@@ -4526,8 +4474,7 @@ gimple_omp_for_incr_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].incr = incr;
}
@@ -4539,8 +4486,7 @@ gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
static inline gimple_seq *
gimple_omp_for_pre_body_ptr (gimple gs)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
return &omp_for_stmt->pre_body;
}

@@ -4561,8 +4507,7 @@ gimple_omp_for_pre_body (gimple gs)
static inline void
gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
omp_for_stmt->pre_body = pre_body;
}

@@ -4572,8 +4517,8 @@ gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
static inline tree
gimple_omp_parallel_clauses (const_gimple gs)
{
- const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel *> (gs);
+ const gomp_parallel *omp_parallel_stmt =
+ as_a <const gomp_parallel *> (gs);
return omp_parallel_stmt->clauses;
}

@@ -4583,8 +4528,7 @@ gimple_omp_parallel_clauses (const_gimple gs)
static inline tree *
gimple_omp_parallel_clauses_ptr (gimple gs)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
return &omp_parallel_stmt->clauses;
}

@@ -4595,8 +4539,7 @@ gimple_omp_parallel_clauses_ptr (gimple gs)
static inline void
gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
omp_parallel_stmt->clauses = clauses;
}

@@ -4606,8 +4549,8 @@ gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_parallel_child_fn (const_gimple gs)
{
- const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel *> (gs);
+ const gomp_parallel *omp_parallel_stmt =
+ as_a <const gomp_parallel *> (gs);
return omp_parallel_stmt->child_fn;
}

@@ -4617,8 +4560,7 @@ gimple_omp_parallel_child_fn (const_gimple gs)
static inline tree *
gimple_omp_parallel_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
return &omp_parallel_stmt->child_fn;
}

@@ -4628,8 +4570,7 @@ gimple_omp_parallel_child_fn_ptr (gimple gs)
static inline void
gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt =as_a <gomp_parallel *> (gs);
omp_parallel_stmt->child_fn = child_fn;
}

@@ -4640,8 +4581,8 @@ gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_parallel_data_arg (const_gimple gs)
{
- const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel *> (gs);
+ const gomp_parallel *omp_parallel_stmt =
+ as_a <const gomp_parallel *> (gs);
return omp_parallel_stmt->data_arg;
}

@@ -4651,8 +4592,7 @@ gimple_omp_parallel_data_arg (const_gimple gs)
static inline tree *
gimple_omp_parallel_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
return &omp_parallel_stmt->data_arg;
}

@@ -4662,8 +4602,7 @@ gimple_omp_parallel_data_arg_ptr (gimple gs)
static inline void
gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
omp_parallel_stmt->data_arg = data_arg;
}

@@ -4673,8 +4612,7 @@ gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_task_clauses (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->clauses;
}

@@ -4684,8 +4622,7 @@ gimple_omp_task_clauses (const_gimple gs)
static inline tree *
gimple_omp_task_clauses_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->clauses;
}

@@ -4696,8 +4633,7 @@ gimple_omp_task_clauses_ptr (gimple gs)
static inline void
gimple_omp_task_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->clauses = clauses;
}

@@ -4707,8 +4643,7 @@ gimple_omp_task_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_task_child_fn (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->child_fn;
}

@@ -4718,8 +4653,7 @@ gimple_omp_task_child_fn (const_gimple gs)
static inline tree *
gimple_omp_task_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->child_fn;
}

@@ -4729,8 +4663,7 @@ gimple_omp_task_child_fn_ptr (gimple gs)
static inline void
gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->child_fn = child_fn;
}

@@ -4741,8 +4674,7 @@ gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_task_data_arg (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->data_arg;
}

@@ -4752,8 +4684,7 @@ gimple_omp_task_data_arg (const_gimple gs)
static inline tree *
gimple_omp_task_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->data_arg;
}

@@ -4763,8 +4694,7 @@ gimple_omp_task_data_arg_ptr (gimple gs)
static inline void
gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->data_arg = data_arg;
}

@@ -4774,8 +4704,7 @@ gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_taskreg_clauses (const_gimple gs)
{
- const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg *> (gs);
+ const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
return omp_taskreg_stmt->clauses;
}

@@ -4785,8 +4714,7 @@ gimple_omp_taskreg_clauses (const_gimple gs)
static inline tree *
gimple_omp_taskreg_clauses_ptr (gimple gs)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
return &omp_taskreg_stmt->clauses;
}

@@ -4797,8 +4725,7 @@ gimple_omp_taskreg_clauses_ptr (gimple gs)
static inline void
gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
omp_taskreg_stmt->clauses = clauses;
}

@@ -4808,8 +4735,7 @@ gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_taskreg_child_fn (const_gimple gs)
{
- const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg *> (gs);
+ const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
return omp_taskreg_stmt->child_fn;
}

@@ -4819,8 +4745,7 @@ gimple_omp_taskreg_child_fn (const_gimple gs)
static inline tree *
gimple_omp_taskreg_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
return &omp_taskreg_stmt->child_fn;
}

@@ -4830,8 +4755,7 @@ gimple_omp_taskreg_child_fn_ptr (gimple gs)
static inline void
gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
omp_taskreg_stmt->child_fn = child_fn;
}

@@ -4842,8 +4766,7 @@ gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_taskreg_data_arg (const_gimple gs)
{
- const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg *> (gs);
+ const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
return omp_taskreg_stmt->data_arg;
}

@@ -4853,8 +4776,7 @@ gimple_omp_taskreg_data_arg (const_gimple gs)
static inline tree *
gimple_omp_taskreg_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
return &omp_taskreg_stmt->data_arg;
}

@@ -4864,8 +4786,7 @@ gimple_omp_taskreg_data_arg_ptr (gimple gs)
static inline void
gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
omp_taskreg_stmt->data_arg = data_arg;
}

@@ -4875,8 +4796,7 @@ gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_task_copy_fn (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->copy_fn;
}

@@ -4886,8 +4806,7 @@ gimple_omp_task_copy_fn (const_gimple gs)
static inline tree *
gimple_omp_task_copy_fn_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->copy_fn;
}

@@ -4897,8 +4816,7 @@ gimple_omp_task_copy_fn_ptr (gimple gs)
static inline void
gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->copy_fn = copy_fn;
}

@@ -4908,8 +4826,7 @@ gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
static inline tree
gimple_omp_task_arg_size (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->arg_size;
}

@@ -4919,8 +4836,7 @@ gimple_omp_task_arg_size (const_gimple gs)
static inline tree *
gimple_omp_task_arg_size_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->arg_size;
}

@@ -4930,8 +4846,7 @@ gimple_omp_task_arg_size_ptr (gimple gs)
static inline void
gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->arg_size = arg_size;
}

@@ -4941,8 +4856,7 @@ gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
static inline tree
gimple_omp_task_arg_align (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->arg_align;
}

@@ -4952,8 +4866,7 @@ gimple_omp_task_arg_align (const_gimple gs)
static inline tree *
gimple_omp_task_arg_align_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->arg_align;
}

@@ -4963,8 +4876,7 @@ gimple_omp_task_arg_align_ptr (gimple gs)
static inline void
gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->arg_align = arg_align;
}

@@ -4974,8 +4886,7 @@ gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
static inline tree
gimple_omp_single_clauses (const_gimple gs)
{
- const gimple_statement_omp_single *omp_single_stmt =
- as_a <const gimple_statement_omp_single *> (gs);
+ const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
return omp_single_stmt->clauses;
}

@@ -4985,8 +4896,7 @@ gimple_omp_single_clauses (const_gimple gs)
static inline tree *
gimple_omp_single_clauses_ptr (gimple gs)
{
- gimple_statement_omp_single *omp_single_stmt =
- as_a <gimple_statement_omp_single *> (gs);
+ gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
return &omp_single_stmt->clauses;
}

@@ -4996,8 +4906,7 @@ gimple_omp_single_clauses_ptr (gimple gs)
static inline void
gimple_omp_single_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_single *omp_single_stmt =
- as_a <gimple_statement_omp_single *> (gs);
+ gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
omp_single_stmt->clauses = clauses;
}

@@ -5007,8 +4916,7 @@ gimple_omp_single_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_target_clauses (const_gimple gs)
{
- const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target *> (gs);
+ const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
return omp_target_stmt->clauses;
}

@@ -5018,8 +4926,7 @@ gimple_omp_target_clauses (const_gimple gs)
static inline tree *
gimple_omp_target_clauses_ptr (gimple gs)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
return &omp_target_stmt->clauses;
}

@@ -5029,8 +4936,7 @@ gimple_omp_target_clauses_ptr (gimple gs)
static inline void
gimple_omp_target_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
omp_target_stmt->clauses = clauses;
}

@@ -5061,8 +4967,7 @@ gimple_omp_target_set_kind (gimple g, int kind)
static inline tree
gimple_omp_target_child_fn (const_gimple gs)
{
- const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target *> (gs);
+ const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
return omp_target_stmt->child_fn;
}

@@ -5072,8 +4977,7 @@ gimple_omp_target_child_fn (const_gimple gs)
static inline tree *
gimple_omp_target_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
return &omp_target_stmt->child_fn;
}

@@ -5083,8 +4987,7 @@ gimple_omp_target_child_fn_ptr (gimple gs)
static inline void
gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
omp_target_stmt->child_fn = child_fn;
}

@@ -5095,8 +4998,7 @@ gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_target_data_arg (const_gimple gs)
{
- const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target *> (gs);
+ const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
return omp_target_stmt->data_arg;
}

@@ -5106,8 +5008,7 @@ gimple_omp_target_data_arg (const_gimple gs)
static inline tree *
gimple_omp_target_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
return &omp_target_stmt->data_arg;
}

@@ -5117,8 +5018,7 @@ gimple_omp_target_data_arg_ptr (gimple gs)
static inline void
gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
omp_target_stmt->data_arg = data_arg;
}

@@ -5128,8 +5028,7 @@ gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_teams_clauses (const_gimple gs)
{
- const gimple_statement_omp_teams *omp_teams_stmt =
- as_a <const gimple_statement_omp_teams *> (gs);
+ const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
return omp_teams_stmt->clauses;
}

@@ -5139,8 +5038,7 @@ gimple_omp_teams_clauses (const_gimple gs)
static inline tree *
gimple_omp_teams_clauses_ptr (gimple gs)
{
- gimple_statement_omp_teams *omp_teams_stmt =
- as_a <gimple_statement_omp_teams *> (gs);
+ gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
return &omp_teams_stmt->clauses;
}

@@ -5150,8 +5048,7 @@ gimple_omp_teams_clauses_ptr (gimple gs)
static inline void
gimple_omp_teams_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_teams *omp_teams_stmt =
- as_a <gimple_statement_omp_teams *> (gs);
+ gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
omp_teams_stmt->clauses = clauses;
}

@@ -5161,8 +5058,8 @@ gimple_omp_teams_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_sections_clauses (const_gimple gs)
{
- const gimple_statement_omp_sections *omp_sections_stmt =
- as_a <const gimple_statement_omp_sections *> (gs);
+ const gomp_sections *omp_sections_stmt =
+ as_a <const gomp_sections *> (gs);
return omp_sections_stmt->clauses;
}

@@ -5172,8 +5069,7 @@ gimple_omp_sections_clauses (const_gimple gs)
static inline tree *
gimple_omp_sections_clauses_ptr (gimple gs)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
return &omp_sections_stmt->clauses;
}

@@ -5184,8 +5080,7 @@ gimple_omp_sections_clauses_ptr (gimple gs)
static inline void
gimple_omp_sections_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
omp_sections_stmt->clauses = clauses;
}

@@ -5196,8 +5091,8 @@ gimple_omp_sections_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_sections_control (const_gimple gs)
{
- const gimple_statement_omp_sections *omp_sections_stmt =
- as_a <const gimple_statement_omp_sections *> (gs);
+ const gomp_sections *omp_sections_stmt =
+ as_a <const gomp_sections *> (gs);
return omp_sections_stmt->control;
}

@@ -5208,8 +5103,7 @@ gimple_omp_sections_control (const_gimple gs)
static inline tree *
gimple_omp_sections_control_ptr (gimple gs)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
return &omp_sections_stmt->control;
}

@@ -5220,8 +5114,7 @@ gimple_omp_sections_control_ptr (gimple gs)
static inline void
gimple_omp_sections_set_control (gimple gs, tree control)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
omp_sections_stmt->control = control;
}

@@ -5231,8 +5124,7 @@ gimple_omp_sections_set_control (gimple gs, tree control)
static inline void
gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
&& i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].cond = cond;
@@ -5244,8 +5136,7 @@ gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
static inline enum tree_code
gimple_omp_for_cond (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].cond;
}
@@ -5256,8 +5147,7 @@ gimple_omp_for_cond (const_gimple gs, size_t i)
static inline void
gimple_omp_atomic_store_set_val (gimple g, tree val)
{
- gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <gimple_statement_omp_atomic_store *> (g);
+ gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
omp_atomic_store_stmt->val = val;
}

@@ -5267,8 +5157,8 @@ gimple_omp_atomic_store_set_val (gimple g, tree val)
static inline tree
gimple_omp_atomic_store_val (const_gimple g)
{
- const gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <const gimple_statement_omp_atomic_store *> (g);
+ const gomp_atomic_store *omp_atomic_store_stmt =
+ as_a <const gomp_atomic_store *> (g);
return omp_atomic_store_stmt->val;
}

@@ -5278,8 +5168,7 @@ gimple_omp_atomic_store_val (const_gimple g)
static inline tree *
gimple_omp_atomic_store_val_ptr (gimple g)
{
- gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <gimple_statement_omp_atomic_store *> (g);
+ gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
return &omp_atomic_store_stmt->val;
}

@@ -5289,8 +5178,7 @@ gimple_omp_atomic_store_val_ptr (gimple g)
static inline void
gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
omp_atomic_load_stmt->lhs = lhs;
}

@@ -5300,8 +5188,8 @@ gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
static inline tree
gimple_omp_atomic_load_lhs (const_gimple g)
{
- const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <const gimple_statement_omp_atomic_load *> (g);
+ const gomp_atomic_load *omp_atomic_load_stmt =
+ as_a <const gomp_atomic_load *> (g);
return omp_atomic_load_stmt->lhs;
}

@@ -5311,8 +5199,7 @@ gimple_omp_atomic_load_lhs (const_gimple g)
static inline tree *
gimple_omp_atomic_load_lhs_ptr (gimple g)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
return &omp_atomic_load_stmt->lhs;
}

@@ -5322,8 +5209,7 @@ gimple_omp_atomic_load_lhs_ptr (gimple g)
static inline void
gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
omp_atomic_load_stmt->rhs = rhs;
}

@@ -5333,8 +5219,7 @@ gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
static inline tree
gimple_omp_atomic_load_rhs (const_gimple g)
{
- const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <const gimple_statement_omp_atomic_load *> (g);
+ const gomp_atomic_load *omp_atomic_load_stmt = as_a <const gomp_atomic_load *> (g);
return omp_atomic_load_stmt->rhs;
}

@@ -5344,8 +5229,7 @@ gimple_omp_atomic_load_rhs (const_gimple g)
static inline tree *
gimple_omp_atomic_load_rhs_ptr (gimple g)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
return &omp_atomic_load_stmt->rhs;
}

@@ -5355,8 +5239,7 @@ gimple_omp_atomic_load_rhs_ptr (gimple g)
static inline tree
gimple_omp_continue_control_def (const_gimple g)
{
- const gimple_statement_omp_continue *omp_continue_stmt =
- as_a <const gimple_statement_omp_continue *> (g);
+ const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
return omp_continue_stmt->control_def;
}

@@ -5365,8 +5248,7 @@ gimple_omp_continue_control_def (const_gimple g)
static inline tree *
gimple_omp_continue_control_def_ptr (gimple g)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
return &omp_continue_stmt->control_def;
}

@@ -5375,8 +5257,7 @@ gimple_omp_continue_control_def_ptr (gimple g)
static inline void
gimple_omp_continue_set_control_def (gimple g, tree def)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
omp_continue_stmt->control_def = def;
}

@@ -5386,8 +5267,7 @@ gimple_omp_continue_set_control_def (gimple g, tree def)
static inline tree
gimple_omp_continue_control_use (const_gimple g)
{
- const gimple_statement_omp_continue *omp_continue_stmt =
- as_a <const gimple_statement_omp_continue *> (g);
+ const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
return omp_continue_stmt->control_use;
}

@@ -5397,8 +5277,7 @@ gimple_omp_continue_control_use (const_gimple g)
static inline tree *
gimple_omp_continue_control_use_ptr (gimple g)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
return &omp_continue_stmt->control_use;
}

@@ -5408,8 +5287,7 @@ gimple_omp_continue_control_use_ptr (gimple g)
static inline void
gimple_omp_continue_set_control_use (gimple g, tree use)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
omp_continue_stmt->control_use = use;
}

@@ -5418,8 +5296,7 @@ gimple_omp_continue_set_control_use (gimple g, tree use)
static inline gimple_seq *
gimple_transaction_body_ptr (gimple gs)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
return &transaction_stmt->body;
}

@@ -5436,16 +5313,14 @@ gimple_transaction_body (gimple gs)
static inline tree
gimple_transaction_label (const_gimple gs)
{
- const gimple_statement_transaction *transaction_stmt =
- as_a <const gimple_statement_transaction *> (gs);
+ const gtransaction *transaction_stmt = as_a <const gtransaction *> (gs);
return transaction_stmt->label;
}

static inline tree *
gimple_transaction_label_ptr (gimple gs)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
return &transaction_stmt->label;
}

@@ -5463,8 +5338,7 @@ gimple_transaction_subcode (const_gimple gs)
static inline void
gimple_transaction_set_body (gimple gs, gimple_seq body)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
transaction_stmt->body = body;
}

@@ -5473,8 +5347,7 @@ gimple_transaction_set_body (gimple gs, gimple_seq body)
static inline void
gimple_transaction_set_label (gimple gs, tree label)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
transaction_stmt->label = label;
}

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index be4d719..e9544f7 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -5173,7 +5173,7 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
}
else
{
- gimple_statement_try *gtry;
+ gtry *gtry;
gimple_seq seq;
enum gimple_try_flags kind;

diff --git a/gcc/gsstruct.def b/gcc/gsstruct.def
index c061dce..67ddcb3 100644
--- a/gcc/gsstruct.def
+++ b/gcc/gsstruct.def
@@ -25,29 +25,29 @@ along with GCC; see the file COPYING3. If not see
Each enum value should correspond with a single member of the union
gimple_statement_d. */

-DEFGSSTRUCT(GSS_BASE, gimple_statement_base, false)
-DEFGSSTRUCT(GSS_WITH_OPS, gimple_statement_with_ops, true)
-DEFGSSTRUCT(GSS_WITH_MEM_OPS_BASE, gimple_statement_with_memory_ops_base, false)
-DEFGSSTRUCT(GSS_WITH_MEM_OPS, gimple_statement_with_memory_ops, true)
-DEFGSSTRUCT(GSS_CALL, gimple_statement_call, true)
-DEFGSSTRUCT(GSS_ASM, gimple_statement_asm, true)
-DEFGSSTRUCT(GSS_BIND, gimple_statement_bind, false)
-DEFGSSTRUCT(GSS_PHI, gimple_statement_phi, false)
-DEFGSSTRUCT(GSS_TRY, gimple_statement_try, false)
-DEFGSSTRUCT(GSS_CATCH, gimple_statement_catch, false)
-DEFGSSTRUCT(GSS_EH_FILTER, gimple_statement_eh_filter, false)
-DEFGSSTRUCT(GSS_EH_MNT, gimple_statement_eh_mnt, false)
-DEFGSSTRUCT(GSS_EH_CTRL, gimple_statement_eh_ctrl, false)
-DEFGSSTRUCT(GSS_EH_ELSE, gimple_statement_eh_else, false)
-DEFGSSTRUCT(GSS_WCE, gimple_statement_wce, false)
-DEFGSSTRUCT(GSS_OMP, gimple_statement_omp, false)
-DEFGSSTRUCT(GSS_OMP_CRITICAL, gimple_statement_omp_critical, false)
-DEFGSSTRUCT(GSS_OMP_FOR, gimple_statement_omp_for, false)
-DEFGSSTRUCT(GSS_OMP_PARALLEL_LAYOUT, gimple_statement_omp_parallel_layout, false)
-DEFGSSTRUCT(GSS_OMP_TASK, gimple_statement_omp_task, false)
-DEFGSSTRUCT(GSS_OMP_SECTIONS, gimple_statement_omp_sections, false)
-DEFGSSTRUCT(GSS_OMP_SINGLE_LAYOUT, gimple_statement_omp_single_layout, false)
-DEFGSSTRUCT(GSS_OMP_CONTINUE, gimple_statement_omp_continue, false)
-DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gimple_statement_omp_atomic_load, false)
-DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE_LAYOUT, gimple_statement_omp_atomic_store, false)
-DEFGSSTRUCT(GSS_TRANSACTION, gimple_statement_transaction, false)
+DEFGSSTRUCT(GSS_BASE, gimple, false)
+DEFGSSTRUCT(GSS_WITH_OPS, gimple_with_ops, true)
+DEFGSSTRUCT(GSS_WITH_MEM_OPS_BASE, gimple_with_memory_ops_base, false)
+DEFGSSTRUCT(GSS_WITH_MEM_OPS, gimple_with_memory_ops, true)
+DEFGSSTRUCT(GSS_CALL, gcall, true)
+DEFGSSTRUCT(GSS_ASM, gasm, true)
+DEFGSSTRUCT(GSS_BIND, gbind, false)
+DEFGSSTRUCT(GSS_PHI, gphi, false)
+DEFGSSTRUCT(GSS_TRY, gtry, false)
+DEFGSSTRUCT(GSS_CATCH, gcatch, false)
+DEFGSSTRUCT(GSS_EH_FILTER, geh_filter, false)
+DEFGSSTRUCT(GSS_EH_MNT, geh_mnt, false)
+DEFGSSTRUCT(GSS_EH_CTRL, geh_ctrl, false)
+DEFGSSTRUCT(GSS_EH_ELSE, geh_else, false)
+DEFGSSTRUCT(GSS_WCE, gwce, false)
+DEFGSSTRUCT(GSS_OMP, gomp, false)
+DEFGSSTRUCT(GSS_OMP_CRITICAL, gomp_critical, false)
+DEFGSSTRUCT(GSS_OMP_FOR, gomp_for, false)
+DEFGSSTRUCT(GSS_OMP_PARALLEL_LAYOUT, gomp_parallel_layout, false)
+DEFGSSTRUCT(GSS_OMP_TASK, gomp_task, false)
+DEFGSSTRUCT(GSS_OMP_SECTIONS, gomp_sections, false)
+DEFGSSTRUCT(GSS_OMP_SINGLE_LAYOUT, gomp_single_layout, false)
+DEFGSSTRUCT(GSS_OMP_CONTINUE, gomp_continue, false)
+DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gomp_atomic_load, false)
+DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE_LAYOUT, gomp_atomic_store, false)
+DEFGSSTRUCT(GSS_TRANSACTION, gtransaction, false)
diff --git a/gcc/system.h b/gcc/system.h
index b20b5cf..17fb7c8 100644
--- a/gcc/system.h
+++ b/gcc/system.h
@@ -1023,7 +1023,7 @@ helper_const_non_const_cast (const char *p)
#define CONST_CAST_TREE(X) CONST_CAST (union tree_node *, (X))
#define CONST_CAST_RTX(X) CONST_CAST (struct rtx_def *, (X))
#define CONST_CAST_BB(X) CONST_CAST (struct basic_block_def *, (X))
-#define CONST_CAST_GIMPLE(X) CONST_CAST (struct gimple_statement_base *, (X))
+#define CONST_CAST_GIMPLE(X) CONST_CAST (gimple *, (X))

/* Activate certain diagnostics as warnings (not errors via the
-Werror flag). */
diff --git a/gcc/target.def b/gcc/target.def
index febd320..692ecf2 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -3500,7 +3500,7 @@ DEFHOOK_UNDOC
"Perform architecture specific checking of statements gimplified\
from @code{VA_ARG_EXPR}. @var{stmt} is the statement. Returns true if\
the statement doesn't need to be checked for @code{va_list} references.",
- bool, (struct stdarg_info *ai, const_gimple stmt), NULL)
+ bool, (struct stdarg_info *ai, const gimple *stmt), NULL)

/* This target hook allows the operating system to override the DECL
that represents the external variable that contains the stack
diff --git a/gcc/testsuite/g++.dg/plugin/selfassign.c b/gcc/testsuite/g++.dg/plugin/selfassign.c
index 59bb03a..deb3c39 100644
--- a/gcc/testsuite/g++.dg/plugin/selfassign.c
+++ b/gcc/testsuite/g++.dg/plugin/selfassign.c
@@ -64,7 +64,7 @@ get_real_ref_rhs (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
/* We are only interested in an assignment with a single
rhs operand because if it is not, the original assignment
will not possibly be a self-assignment. */
@@ -169,7 +169,7 @@ get_non_ssa_expr (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
if (gimple_assign_single_p (def_stmt))
vdecl = gimple_assign_rhs1 (def_stmt);
}
@@ -187,7 +187,7 @@ get_non_ssa_expr (tree expr)
they are the same. If so, print a warning message about self-assignment. */

static void
-compare_and_warn (gimple stmt, tree lhs, tree rhs)
+compare_and_warn (gimple *stmt, tree lhs, tree rhs)
{
if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
{
@@ -211,7 +211,7 @@ compare_and_warn (gimple stmt, tree lhs, tree rhs)
/* Check and warn if STMT is a self-assign statement. */

static void
-warn_self_assign (gimple stmt)
+warn_self_assign (gimple *stmt)
{
tree rhs, lhs;

diff --git a/gcc/testsuite/gcc.dg/plugin/selfassign.c b/gcc/testsuite/gcc.dg/plugin/selfassign.c
index 4dad0c2..41f19cd 100644
--- a/gcc/testsuite/gcc.dg/plugin/selfassign.c
+++ b/gcc/testsuite/gcc.dg/plugin/selfassign.c
@@ -64,7 +64,7 @@ get_real_ref_rhs (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
/* We are only interested in an assignment with a single
rhs operand because if it is not, the original assignment
will not possibly be a self-assignment. */
@@ -169,7 +169,7 @@ get_non_ssa_expr (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
if (gimple_assign_single_p (def_stmt))
vdecl = gimple_assign_rhs1 (def_stmt);
}
@@ -187,7 +187,7 @@ get_non_ssa_expr (tree expr)
they are the same. If so, print a warning message about self-assignment. */

static void
-compare_and_warn (gimple stmt, tree lhs, tree rhs)
+compare_and_warn (gimple *stmt, tree lhs, tree rhs)
{
if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
{
@@ -211,7 +211,7 @@ compare_and_warn (gimple stmt, tree lhs, tree rhs)
/* Check and warn if STMT is a self-assign statement. */

static void
-warn_self_assign (gimple stmt)
+warn_self_assign (gimple *stmt)
{
tree rhs, lhs;

diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index 77f3cc0..f289cec 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -233,7 +233,7 @@ dump_dfa_stats (FILE *file)
fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
SCALE (size), LABEL (size));

- size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
+ size = dfa_stats.num_phis * sizeof (struct gphi);
total += size;
fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
SCALE (size), LABEL (size));
diff --git a/gcc/tree-phinodes.c b/gcc/tree-phinodes.c
index 0be431e..a42e1c4 100644
--- a/gcc/tree-phinodes.c
+++ b/gcc/tree-phinodes.c
@@ -97,13 +97,12 @@ phinodes_print_statistics (void)
happens to contain a PHI node with LEN arguments or more, return
that one. */

-static inline gimple_statement_phi *
+static inline gphi *
allocate_phi_node (size_t len)
{
- gimple_statement_phi *phi;
+ gphi *phi;
size_t bucket = NUM_BUCKETS - 2;
- size_t size = sizeof (struct gimple_statement_phi)
- + (len - 1) * sizeof (struct phi_arg_d);
+ size_t size = sizeof (struct gphi) + (len - 1) * sizeof (struct phi_arg_d);

if (free_phinode_count)
for (bucket = len - 2; bucket < NUM_BUCKETS - 2; bucket++)
@@ -115,7 +114,7 @@ allocate_phi_node (size_t len)
&& gimple_phi_capacity ((*free_phinodes[bucket])[0]) >= len)
{
free_phinode_count--;
- phi = as_a <gimple_statement_phi *> (free_phinodes[bucket]->pop ());
+ phi = as_a <gimple_phi *> (free_phinodes[bucket]->pop ());
if (free_phinodes[bucket]->is_empty ())
vec_free (free_phinodes[bucket]);
if (GATHER_STATISTICS)
@@ -123,7 +122,7 @@ allocate_phi_node (size_t len)
}
else
{
- phi = static_cast <gimple_statement_phi *> (
+ phi = static_cast <gimple_phi *> (
ggc_internal_alloc_stat (size MEM_STAT_INFO));
if (GATHER_STATISTICS)
{
@@ -158,8 +157,7 @@ ideal_phi_node_len (int len)
len = 2;

/* Compute the number of bytes of the original request. */
- size = sizeof (struct gimple_statement_phi)
- + (len - 1) * sizeof (struct phi_arg_d);
+ size = sizeof (struct gphi) + (len - 1) * sizeof (struct phi_arg_d);

/* Round it up to the next power of two. */
log2 = ceil_log2 (size);
@@ -176,7 +174,7 @@ ideal_phi_node_len (int len)
static gimple
make_phi_node (tree var, int len)
{
- gimple_statement_phi *phi;
+ gphi *phi;
int capacity, i;

capacity = ideal_phi_node_len (len);
@@ -186,7 +184,7 @@ make_phi_node (tree var, int len)
/* We need to clear the entire PHI node, including the argument
portion, because we represent a "missing PHI argument" by placing
NULL_TREE in PHI_ARG_DEF. */
- memset (phi, 0, (sizeof (struct gimple_statement_phi)
+ memset (phi, 0, (sizeof (struct gphi)
- sizeof (struct phi_arg_d)
+ sizeof (struct phi_arg_d) * len));
phi->code = GIMPLE_PHI;
@@ -241,18 +239,18 @@ release_phi_node (gimple phi)
/* Resize an existing PHI node. The only way is up. Return the
possibly relocated phi. */

-static gimple_statement_phi *
-resize_phi_node (gimple_statement_phi *phi, size_t len)
+static gphi *
+resize_phi_node (gphi *phi, size_t len)
{
size_t old_size, i;
- gimple_statement_phi *new_phi;
+ gphi *new_phi;

gcc_assert (len > gimple_phi_capacity (phi));

/* The garbage collector will not look at the PHI node beyond the
first PHI_NUM_ARGS elements. Therefore, all we have to copy is a
portion of the PHI node currently in use. */
- old_size = sizeof (struct gimple_statement_phi)
+ old_size = sizeof (struct gphi)
+ (gimple_phi_num_args (phi) - 1) * sizeof (struct phi_arg_d);

new_phi = allocate_phi_node (len);
@@ -296,12 +294,11 @@ reserve_phi_args_for_new_edge (basic_block bb)

for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple_statement_phi *stmt =
- as_a <gimple_statement_phi *> (gsi_stmt (gsi));
+ gphi *stmt = as_a <gphi *> (gsi_stmt (gsi));

if (len > gimple_phi_capacity (stmt))
{
- gimple_statement_phi *new_phi = resize_phi_node (stmt, cap);
+ gphi *new_phi = resize_phi_node (stmt, cap);

/* The result of the PHI is defined by this PHI node. */
SSA_NAME_DEF_STMT (gimple_phi_result (new_phi)) = new_phi;
@@ -397,7 +394,7 @@ add_phi_arg (gimple phi, tree def, edge e, source_location locus)
is consistent with how we remove an edge from the edge vector. */

static void
-remove_phi_arg_num (gimple_statement_phi *phi, int i)
+remove_phi_arg_num (gphi *phi, int i)
{
int num_elem = gimple_phi_num_args (phi);

@@ -436,7 +433,7 @@ remove_phi_args (edge e)
gimple_stmt_iterator gsi;

for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
- remove_phi_arg_num (as_a <gimple_statement_phi *> (gsi_stmt (gsi)),
+ remove_phi_arg_num (as_a <gphi *> (gsi_stmt (gsi)),
e->dest_idx);
}

diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index d741012..7311f5e 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -1895,7 +1895,7 @@ evaluate_stmt (gimple stmt)
return val;
}

-typedef hash_table <pointer_hash <gimple_statement_base> > gimple_htab;
+typedef hash_table <pointer_hash <gimple> > gimple_htab;

/* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
each matching BUILT_IN_STACK_RESTORE. Mark visited phis in VISITED. */
--
1.8.5.3
Jeff Law
2014-05-14 18:09:26 UTC
Permalink
On 05/12/14 15:36, David Malcolm wrote:
[ ... Big Snip ... ]
This series of 3 patches is approved.

Jeff
David Malcolm
2014-05-19 17:02:14 UTC
Permalink
Post by Jeff Law
[ ... Big Snip ... ]
This series of 3 patches is approved.
FWIW, I've been working my way through the remainder of the patches,
updating them to take account of the largely mechanical changes [1] for
the v4 approach; so far I've done up to:
"[PATCH 28/89] Introduce gimple_eh_else".

and FWIW I've backed these up here:
http://dmalcolm.fedorapeople.org/gcc/patch-backups/gimple-classes/v4-patches/
in case of hard drive failure or me messing up a git command along the
way. [2]

I'm not expecting reviews of the those patches at this time. I believe
these are all largely "grandfathered in" from the reviews you've already
done; I'm mostly posting here as a heads-up of what the code will look
like, and in case of catastrophe (indeed I've only occasionally
bootstrapped&regrested as I've gone along).

After all 89 are done, I can take a look at the accessor renaming ideas
Richi asked me to investigate.

I'm also experimenting with trying a similar thing for RTL.

Dave

[1] though sadly there's a lot of handwritten manipulation needed to
them, due to "bitrot" due to the gimple -> gimple* transition, so this
has been rather tedious. Basically every line in each of the patches
has needed some kind of manual fixup :(

[2] this is via a huge "git rebase" command which means there's a few
FIXME commits in there for when I forgot something.

Michael Matz
2014-05-13 12:37:05 UTC
Permalink
Hi,
Post by David Malcolm
The "gfoo" type names are pleasantly terse, though I'm a little unhappy
about how they no longer match the prefix of the accessor functions e.g.
gimple_switch_num_labels (const gswitch *gs)
vs
gimple_switch_num_labels (const gimple_switch *gs)
But it works.
That could also be changed with a followup to make it consistent again
(i.e. rename the accessors to gswitch_num_labels). I'd be in favor of
such renaming later.


Ciao,
Michael.
Richard Biener
2014-05-13 13:10:51 UTC
Permalink
Post by Michael Matz
Hi,
Post by David Malcolm
The "gfoo" type names are pleasantly terse, though I'm a little unhappy
about how they no longer match the prefix of the accessor functions e.g.
gimple_switch_num_labels (const gswitch *gs)
vs
gimple_switch_num_labels (const gimple_switch *gs)
But it works.
That could also be changed with a followup to make it consistent again
(i.e. rename the accessors to gswitch_num_labels). I'd be in favor of
such renaming later.
Yeah, or go all the way to member functions.

I'd like to see this addresses as followup, together with a discussion
on whether we want standalone or member functions here.

Thanks,
Richard.
Post by Michael Matz
Ciao,
Michael.
David Malcolm
2014-05-13 13:27:58 UTC
Permalink
Post by Richard Biener
Post by Michael Matz
Hi,
Post by David Malcolm
The "gfoo" type names are pleasantly terse, though I'm a little unhappy
about how they no longer match the prefix of the accessor functions e.g.
gimple_switch_num_labels (const gswitch *gs)
vs
gimple_switch_num_labels (const gimple_switch *gs)
But it works.
That could also be changed with a followup to make it consistent again
(i.e. rename the accessors to gswitch_num_labels). I'd be in favor of
such renaming later.
Yeah, or go all the way to member functions.
I'd like to see this addresses as followup, together with a discussion
on whether we want standalone or member functions here.
Or both, perhaps as a transition strategy e.g. something like:

struct GTY((tag("GSS_WITH_OPS")))
gswitch : public gimple_with_ops
{
public:
unsigned num_labels () const
{
unsigned num_ops = num_ops ();
gcc_gimple_checking_assert (num_ops > 1);
return num_ops - 1;
}
};

static inline unsigned
gimple_switch_num_labels (const gswitch *gs)
{
return gs->num_labels ();
}

where the accessor function simply calls the member fn??? This
both-worlds approach might not be desirable as a end-goal, but might be
a useful tactic when creating the patches.

FWIW, if we want to do a grand renaming - which would touch most lines
in the middle-end - I'd prefer to go the whole way and have member
functions (though the gimple_ -> gswitch_ would be much easier to
automate :) )

I can have a look at making the data fields be private too, I guess.
(with judicious use of "friend", it may be possible to do that patch
without needing to make the accessors be members).

An idea I had for a method-naming convention: keep the type as a prefix
of the name, so that instead of:
(A) tree label = gimple_switch_label (switch_stmt, i);
becoming:
(B) tree label = switch_stmt->label (i);
you'd have:
(C) tree label = switch_stmt->switch_label (i);
^^^^^^^ note the prefix
which might allow us to keep most of the "grepability" of the existing
code (you can't easily find "label" *method* calls in approach (B),
whereas "switch_label" should give much better results in approach (C)).
(and perhaps omit the prefix when it's unambiguous e.g.
gimple_cond_make_false would become
simply cond_stmt->make_false () ?)


Dave
Richard Biener
2014-05-13 14:40:08 UTC
Permalink
Post by David Malcolm
Post by Richard Biener
Post by Michael Matz
Hi,
Post by David Malcolm
The "gfoo" type names are pleasantly terse, though I'm a little unhappy
about how they no longer match the prefix of the accessor functions e.g.
gimple_switch_num_labels (const gswitch *gs)
vs
gimple_switch_num_labels (const gimple_switch *gs)
But it works.
That could also be changed with a followup to make it consistent again
(i.e. rename the accessors to gswitch_num_labels). I'd be in favor of
such renaming later.
Yeah, or go all the way to member functions.
I'd like to see this addresses as followup, together with a discussion
on whether we want standalone or member functions here.
struct GTY((tag("GSS_WITH_OPS")))
gswitch : public gimple_with_ops
{
unsigned num_labels () const
{
unsigned num_ops = num_ops ();
gcc_gimple_checking_assert (num_ops > 1);
return num_ops - 1;
}
};
static inline unsigned
gimple_switch_num_labels (const gswitch *gs)
{
return gs->num_labels ();
}
where the accessor function simply calls the member fn??? This
both-worlds approach might not be desirable as a end-goal, but might be
a useful tactic when creating the patches.
Well, we can then also simply rename the functions first. And not bother
touching each line twice eventually.
Post by David Malcolm
FWIW, if we want to do a grand renaming - which would touch most lines
in the middle-end - I'd prefer to go the whole way and have member
functions (though the gimple_ -> gswitch_ would be much easier to
automate :) )
I can have a look at making the data fields be private too, I guess.
(with judicious use of "friend", it may be possible to do that patch
without needing to make the accessors be members).
An idea I had for a method-naming convention: keep the type as a prefix
(A) tree label = gimple_switch_label (switch_stmt, i);
(B) tree label = switch_stmt->label (i);
(C) tree label = switch_stmt->switch_label (i);
^^^^^^^ note the prefix
which might allow us to keep most of the "grepability" of the existing
code (you can't easily find "label" *method* calls in approach (B),
whereas "switch_label" should give much better results in approach (C)).
Eh :/ But then we can as well keep the function as gswitch_label
(switch_stmt, i).

C++ isn't really a good greppable language. But well. We voted for it.

Richard.
Post by David Malcolm
(and perhaps omit the prefix when it's unambiguous e.g.
gimple_cond_make_false would become
simply cond_stmt->make_false () ?)
Dave
Continue reading on narkive:
Loading...