switch from gimple to gimple*

This renames the gimple_statement_base struct to gimple removes the
typedef of gimple_statement_base * to gimple, and then adjusts all of
the places that use the type.

gcc/ChangeLog:

2015-09-19  Trevor Saunders  <tbsaunde@tbsaunde.org>

	* coretypes.h (gimple): Change typedef to be a forward
	declaration.
	* gimple.h (gimple_statement_base): rename to gimple.
	* (all functions and types using gimple): Adjust.
	* *.[ch]: Likewise.

gcc/cp/ChangeLog:

2015-09-19  Trevor Saunders  <tbsaunde@tbsaunde.org>

	* cp-gimplify.c (gimplify_must_not_throw_expr): Adjust.

From-SVN: r227941

1 files changed, 349 insertions, 349 deletions

diff --git a/gcc/gimple.h b/gcc/gimple.h
index 55f2131..91c26b6 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -25,7 +25,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-ssa-alias.h"
 #include "gimple-expr.h"
 
-typedef gimple gimple_seq_node;
+typedef gimple *gimple_seq_node;
 
 enum gimple_code {
 #define DEFGSCODE(SYM, STRING, STRUCT)	SYM,
@@ -44,20 +44,20 @@ template<typename T> struct remove_pointer<T *> { typedef T type; };
 /* Error out if a gimple tuple is addressed incorrectly.  */
 #if defined ENABLE_GIMPLE_CHECKING
 #define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR)
-extern void gimple_check_failed (const_gimple, const char *, int,          \
+extern void gimple_check_failed (const gimple *, const char *, int,        \
                                  const char *, enum gimple_code,           \
 				 enum tree_code) ATTRIBUTE_NORETURN;
 
 #define GIMPLE_CHECK(GS, CODE)						\
   do {									\
-    const_gimple __gs = (GS);						\
+    const gimple *__gs = (GS);						\
     if (gimple_code (__gs) != (CODE))					\
       gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,	\
 	  		   (CODE), ERROR_MARK);				\
   } while (0)
 template <typename T>
 static inline T
-GIMPLE_CHECK2(const_gimple gs,
+GIMPLE_CHECK2(const gimple *gs,
 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 	      const char *file = __builtin_FILE (),
 	      int line = __builtin_LINE (),
@@ -76,7 +76,7 @@ GIMPLE_CHECK2(const_gimple gs,
 }
 template <typename T>
 static inline T
-GIMPLE_CHECK2(gimple gs,
+GIMPLE_CHECK2(gimple *gs,
 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 	      const char *file = __builtin_FILE (),
 	      int line = __builtin_LINE (),
@@ -98,13 +98,13 @@ GIMPLE_CHECK2(gimple gs,
 #define GIMPLE_CHECK(GS, CODE)			(void)0
 template <typename T>
 static inline T
-GIMPLE_CHECK2(gimple gs)
+GIMPLE_CHECK2(gimple *gs)
 {
   return as_a <T> (gs);
 }
 template <typename T>
 static inline T
-GIMPLE_CHECK2(const_gimple gs)
+GIMPLE_CHECK2(const gimple *gs)
 {
   return as_a <T> (gs);
 }
@@ -200,7 +200,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.  */
@@ -261,8 +261,8 @@ struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
      A gimple statement is hence also a double-ended list of
      statements, with the pointer itself being the first element,
      and the prev pointer being the last.  */
-  gimple next;
-  gimple GTY((skip)) prev;
+  gimple *next;
+  gimple *GTY((skip)) prev;
 };
 
 
@@ -270,7 +270,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_statement_with_ops_base : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -359,7 +359,7 @@ struct GTY((tag("GSS_CALL")))
 /* OMP statements.  */
 
 struct GTY((tag("GSS_OMP")))
-  gimple_statement_omp : public gimple_statement_base
+  gimple_statement_omp : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -371,7 +371,7 @@ struct GTY((tag("GSS_OMP")))
 /* GIMPLE_BIND */
 
 struct GTY((tag("GSS_BIND")))
-  gbind : public gimple_statement_base
+  gbind : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -395,7 +395,7 @@ struct GTY((tag("GSS_BIND")))
 /* GIMPLE_CATCH */
 
 struct GTY((tag("GSS_CATCH")))
-  gcatch : public gimple_statement_base
+  gcatch : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -410,7 +410,7 @@ struct GTY((tag("GSS_CATCH")))
 /* GIMPLE_EH_FILTER */
 
 struct GTY((tag("GSS_EH_FILTER")))
-  geh_filter : public gimple_statement_base
+  geh_filter : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -426,7 +426,7 @@ struct GTY((tag("GSS_EH_FILTER")))
 /* GIMPLE_EH_ELSE */
 
 struct GTY((tag("GSS_EH_ELSE")))
-  geh_else : public gimple_statement_base
+  geh_else : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -437,7 +437,7 @@ struct GTY((tag("GSS_EH_ELSE")))
 /* GIMPLE_EH_MUST_NOT_THROW */
 
 struct GTY((tag("GSS_EH_MNT")))
-  geh_mnt : public gimple_statement_base
+  geh_mnt : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -448,7 +448,7 @@ struct GTY((tag("GSS_EH_MNT")))
 /* GIMPLE_PHI */
 
 struct GTY((tag("GSS_PHI")))
-  gphi : public gimple_statement_base
+  gphi : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -467,7 +467,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
+  gimple_statement_eh_ctrl : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -494,7 +494,7 @@ struct GTY((tag("GSS_EH_CTRL")))
 /* GIMPLE_TRY */
 
 struct GTY((tag("GSS_TRY")))
-  gtry : public gimple_statement_base
+  gtry : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -524,7 +524,7 @@ enum gimple_try_flags
 /* GIMPLE_WITH_CLEANUP_EXPR */
 
 struct GTY((tag("GSS_WCE")))
-  gimple_statement_wce : public gimple_statement_base
+  gimple_statement_wce : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -706,7 +706,7 @@ struct GTY((tag("GSS_OMP_SECTIONS")))
          do not need the body field.  */
 
 struct GTY((tag("GSS_OMP_CONTINUE")))
-  gomp_continue : public gimple_statement_base
+  gomp_continue : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -748,7 +748,7 @@ struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
    contains a sequence, which we don't need here.  */
 
 struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
-  gomp_atomic_load : public gimple_statement_base
+  gomp_atomic_load : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -760,7 +760,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
+  gimple_statement_omp_atomic_store_layout : public gimple
 {
   /* [ WORD 1-6 ] : base class */
 
@@ -906,7 +906,7 @@ struct GTY((tag("GSS_WITH_MEM_OPS")))
 template <>
 template <>
 inline bool
-is_a_helper <gasm *>::test (gimple gs)
+is_a_helper <gasm *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_ASM;
 }
@@ -914,7 +914,7 @@ is_a_helper <gasm *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gassign *>::test (gimple gs)
+is_a_helper <gassign *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_ASSIGN;
 }
@@ -922,7 +922,7 @@ is_a_helper <gassign *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gassign *>::test (const_gimple gs)
+is_a_helper <const gassign *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_ASSIGN;
 }
@@ -930,7 +930,7 @@ is_a_helper <const gassign *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gbind *>::test (gimple gs)
+is_a_helper <gbind *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_BIND;
 }
@@ -938,7 +938,7 @@ is_a_helper <gbind *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gcall *>::test (gimple gs)
+is_a_helper <gcall *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_CALL;
 }
@@ -946,7 +946,7 @@ is_a_helper <gcall *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gcatch *>::test (gimple gs)
+is_a_helper <gcatch *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_CATCH;
 }
@@ -954,7 +954,7 @@ is_a_helper <gcatch *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gcond *>::test (gimple gs)
+is_a_helper <gcond *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_COND;
 }
@@ -962,7 +962,7 @@ is_a_helper <gcond *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gcond *>::test (const_gimple gs)
+is_a_helper <const gcond *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_COND;
 }
@@ -970,7 +970,7 @@ is_a_helper <const gcond *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gdebug *>::test (gimple gs)
+is_a_helper <gdebug *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_DEBUG;
 }
@@ -978,7 +978,7 @@ is_a_helper <gdebug *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <ggoto *>::test (gimple gs)
+is_a_helper <ggoto *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_GOTO;
 }
@@ -986,7 +986,7 @@ is_a_helper <ggoto *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <glabel *>::test (gimple gs)
+is_a_helper <glabel *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_LABEL;
 }
@@ -994,7 +994,7 @@ is_a_helper <glabel *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gresx *>::test (gimple gs)
+is_a_helper <gresx *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_RESX;
 }
@@ -1002,7 +1002,7 @@ is_a_helper <gresx *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_dispatch *>::test (gimple gs)
+is_a_helper <geh_dispatch *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_DISPATCH;
 }
@@ -1010,7 +1010,7 @@ is_a_helper <geh_dispatch *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_else *>::test (gimple gs)
+is_a_helper <geh_else *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_ELSE;
 }
@@ -1018,7 +1018,7 @@ is_a_helper <geh_else *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_filter *>::test (gimple gs)
+is_a_helper <geh_filter *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_FILTER;
 }
@@ -1026,7 +1026,7 @@ is_a_helper <geh_filter *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <geh_mnt *>::test (gimple gs)
+is_a_helper <geh_mnt *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_EH_MUST_NOT_THROW;
 }
@@ -1034,7 +1034,7 @@ is_a_helper <geh_mnt *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_atomic_load *>::test (gimple gs)
+is_a_helper <gomp_atomic_load *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
 }
@@ -1042,7 +1042,7 @@ is_a_helper <gomp_atomic_load *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_atomic_store *>::test (gimple gs)
+is_a_helper <gomp_atomic_store *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_STORE;
 }
@@ -1050,7 +1050,7 @@ is_a_helper <gomp_atomic_store *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
+is_a_helper <gimple_statement_omp_return *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_RETURN;
 }
@@ -1058,7 +1058,7 @@ is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_continue *>::test (gimple gs)
+is_a_helper <gomp_continue *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CONTINUE;
 }
@@ -1066,7 +1066,7 @@ is_a_helper <gomp_continue *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_critical *>::test (gimple gs)
+is_a_helper <gomp_critical *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CRITICAL;
 }
@@ -1074,7 +1074,7 @@ is_a_helper <gomp_critical *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_for *>::test (gimple gs)
+is_a_helper <gomp_for *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_FOR;
 }
@@ -1082,7 +1082,7 @@ is_a_helper <gomp_for *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
+is_a_helper <gimple_statement_omp_taskreg *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
 }
@@ -1090,7 +1090,7 @@ is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_parallel *>::test (gimple gs)
+is_a_helper <gomp_parallel *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL;
 }
@@ -1098,7 +1098,7 @@ is_a_helper <gomp_parallel *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_target *>::test (gimple gs)
+is_a_helper <gomp_target *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TARGET;
 }
@@ -1106,7 +1106,7 @@ is_a_helper <gomp_target *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_sections *>::test (gimple gs)
+is_a_helper <gomp_sections *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SECTIONS;
 }
@@ -1114,7 +1114,7 @@ is_a_helper <gomp_sections *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_single *>::test (gimple gs)
+is_a_helper <gomp_single *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SINGLE;
 }
@@ -1122,7 +1122,7 @@ is_a_helper <gomp_single *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_teams *>::test (gimple gs)
+is_a_helper <gomp_teams *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TEAMS;
 }
@@ -1130,7 +1130,7 @@ is_a_helper <gomp_teams *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gomp_task *>::test (gimple gs)
+is_a_helper <gomp_task *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TASK;
 }
@@ -1138,7 +1138,7 @@ is_a_helper <gomp_task *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gphi *>::test (gimple gs)
+is_a_helper <gphi *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_PHI;
 }
@@ -1146,7 +1146,7 @@ is_a_helper <gphi *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <greturn *>::test (gimple gs)
+is_a_helper <greturn *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_RETURN;
 }
@@ -1154,7 +1154,7 @@ is_a_helper <greturn *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gswitch *>::test (gimple gs)
+is_a_helper <gswitch *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_SWITCH;
 }
@@ -1162,7 +1162,7 @@ is_a_helper <gswitch *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gtransaction *>::test (gimple gs)
+is_a_helper <gtransaction *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_TRANSACTION;
 }
@@ -1170,7 +1170,7 @@ is_a_helper <gtransaction *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gtry *>::test (gimple gs)
+is_a_helper <gtry *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_TRY;
 }
@@ -1178,7 +1178,7 @@ is_a_helper <gtry *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <gimple_statement_wce *>::test (gimple gs)
+is_a_helper <gimple_statement_wce *>::test (gimple *gs)
 {
   return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
 }
@@ -1186,7 +1186,7 @@ is_a_helper <gimple_statement_wce *>::test (gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gasm *>::test (const_gimple gs)
+is_a_helper <const gasm *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_ASM;
 }
@@ -1194,7 +1194,7 @@ is_a_helper <const gasm *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gbind *>::test (const_gimple gs)
+is_a_helper <const gbind *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_BIND;
 }
@@ -1202,7 +1202,7 @@ is_a_helper <const gbind *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gcall *>::test (const_gimple gs)
+is_a_helper <const gcall *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_CALL;
 }
@@ -1210,7 +1210,7 @@ is_a_helper <const gcall *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gcatch *>::test (const_gimple gs)
+is_a_helper <const gcatch *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_CATCH;
 }
@@ -1218,7 +1218,7 @@ is_a_helper <const gcatch *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gresx *>::test (const_gimple gs)
+is_a_helper <const gresx *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_RESX;
 }
@@ -1226,7 +1226,7 @@ is_a_helper <const gresx *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const geh_dispatch *>::test (const_gimple gs)
+is_a_helper <const geh_dispatch *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_EH_DISPATCH;
 }
@@ -1234,7 +1234,7 @@ is_a_helper <const geh_dispatch *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const geh_filter *>::test (const_gimple gs)
+is_a_helper <const geh_filter *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_EH_FILTER;
 }
@@ -1242,7 +1242,7 @@ is_a_helper <const geh_filter *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_atomic_load *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_load *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
 }
@@ -1250,7 +1250,7 @@ is_a_helper <const gomp_atomic_load *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_atomic_store *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_store *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_ATOMIC_STORE;
 }
@@ -1258,7 +1258,7 @@ is_a_helper <const gomp_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 gimple_statement_omp_return *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_RETURN;
 }
@@ -1266,7 +1266,7 @@ is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_continue *>::test (const_gimple gs)
+is_a_helper <const gomp_continue *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CONTINUE;
 }
@@ -1274,7 +1274,7 @@ is_a_helper <const gomp_continue *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_critical *>::test (const_gimple gs)
+is_a_helper <const gomp_critical *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_CRITICAL;
 }
@@ -1282,7 +1282,7 @@ is_a_helper <const gomp_critical *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_for *>::test (const_gimple gs)
+is_a_helper <const gomp_for *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_FOR;
 }
@@ -1290,7 +1290,7 @@ is_a_helper <const gomp_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 gimple_statement_omp_taskreg *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
 }
@@ -1298,7 +1298,7 @@ is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_parallel *>::test (const_gimple gs)
+is_a_helper <const gomp_parallel *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_PARALLEL;
 }
@@ -1306,7 +1306,7 @@ is_a_helper <const gomp_parallel *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_target *>::test (const_gimple gs)
+is_a_helper <const gomp_target *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TARGET;
 }
@@ -1314,7 +1314,7 @@ is_a_helper <const gomp_target *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_sections *>::test (const_gimple gs)
+is_a_helper <const gomp_sections *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SECTIONS;
 }
@@ -1322,7 +1322,7 @@ is_a_helper <const gomp_sections *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_single *>::test (const_gimple gs)
+is_a_helper <const gomp_single *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_SINGLE;
 }
@@ -1330,7 +1330,7 @@ is_a_helper <const gomp_single *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_teams *>::test (const_gimple gs)
+is_a_helper <const gomp_teams *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TEAMS;
 }
@@ -1338,7 +1338,7 @@ is_a_helper <const gomp_teams *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gomp_task *>::test (const_gimple gs)
+is_a_helper <const gomp_task *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_OMP_TASK;
 }
@@ -1346,7 +1346,7 @@ is_a_helper <const gomp_task *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gphi *>::test (const_gimple gs)
+is_a_helper <const gphi *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_PHI;
 }
@@ -1354,7 +1354,7 @@ is_a_helper <const gphi *>::test (const_gimple gs)
 template <>
 template <>
 inline bool
-is_a_helper <const gtransaction *>::test (const_gimple gs)
+is_a_helper <const gtransaction *>::test (const gimple *gs)
 {
   return gs->code == GIMPLE_TRANSACTION;
 }
@@ -1368,10 +1368,10 @@ extern enum gimple_statement_structure_enum const gss_for_code_[];
 
 /* This variable holds the currently expanded gimple statement for purposes
    of comminucating the profile info to the builtin expanders.  */
-extern gimple currently_expanding_gimple_stmt;
+extern gimple *currently_expanding_gimple_stmt;
 
 #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO)
-gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL);
+gimple *gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL);
 greturn *gimple_build_return (tree);
 void gimple_call_reset_alias_info (gcall *);
 gcall *gimple_build_call_vec (tree, vec<tree> );
@@ -1391,7 +1391,7 @@ gcond *gimple_build_cond_from_tree (tree, tree, tree);
 void gimple_cond_set_condition_from_tree (gcond *, tree);
 glabel *gimple_build_label (tree label);
 ggoto *gimple_build_goto (tree dest);
-gimple gimple_build_nop (void);
+gimple *gimple_build_nop (void);
 gbind *gimple_build_bind (tree, gimple_seq, tree);
 gasm *gimple_build_asm_vec (const char *, vec<tree, va_gc> *,
 				 vec<tree, va_gc> *, vec<tree, va_gc> *,
@@ -1402,15 +1402,15 @@ geh_mnt *gimple_build_eh_must_not_throw (tree);
 geh_else *gimple_build_eh_else (gimple_seq, gimple_seq);
 gtry *gimple_build_try (gimple_seq, gimple_seq,
 					enum gimple_try_flags);
-gimple gimple_build_wce (gimple_seq);
+gimple *gimple_build_wce (gimple_seq);
 gresx *gimple_build_resx (int);
 gswitch *gimple_build_switch_nlabels (unsigned, tree, tree);
 gswitch *gimple_build_switch (tree, tree, vec<tree> );
 geh_dispatch *gimple_build_eh_dispatch (int);
-gdebug *gimple_build_debug_bind_stat (tree, tree, gimple MEM_STAT_DECL);
+gdebug *gimple_build_debug_bind_stat (tree, tree, gimple * MEM_STAT_DECL);
 #define gimple_build_debug_bind(var,val,stmt)			\
   gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
-gdebug *gimple_build_debug_source_bind_stat (tree, tree, gimple MEM_STAT_DECL);
+gdebug *gimple_build_debug_source_bind_stat (tree, tree, gimple * MEM_STAT_DECL);
 #define gimple_build_debug_source_bind(var,val,stmt)			\
   gimple_build_debug_source_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
 gomp_critical *gimple_build_omp_critical (gimple_seq, tree);
@@ -1418,22 +1418,22 @@ gomp_for *gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq);
 gomp_parallel *gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
 gomp_task *gimple_build_omp_task (gimple_seq, tree, tree, tree, tree,
 				       tree, tree);
-gimple gimple_build_omp_section (gimple_seq);
-gimple gimple_build_omp_master (gimple_seq);
-gimple gimple_build_omp_taskgroup (gimple_seq);
+gimple *gimple_build_omp_section (gimple_seq);
+gimple *gimple_build_omp_master (gimple_seq);
+gimple *gimple_build_omp_taskgroup (gimple_seq);
 gomp_continue *gimple_build_omp_continue (tree, tree);
-gimple gimple_build_omp_ordered (gimple_seq);
-gimple gimple_build_omp_return (bool);
+gimple *gimple_build_omp_ordered (gimple_seq);
+gimple *gimple_build_omp_return (bool);
 gomp_sections *gimple_build_omp_sections (gimple_seq, tree);
-gimple gimple_build_omp_sections_switch (void);
+gimple *gimple_build_omp_sections_switch (void);
 gomp_single *gimple_build_omp_single (gimple_seq, tree);
 gomp_target *gimple_build_omp_target (gimple_seq, int, tree);
 gomp_teams *gimple_build_omp_teams (gimple_seq, tree);
 gomp_atomic_load *gimple_build_omp_atomic_load (tree, tree);
 gomp_atomic_store *gimple_build_omp_atomic_store (tree);
 gtransaction *gimple_build_transaction (gimple_seq, tree);
-extern void gimple_seq_add_stmt (gimple_seq *, gimple);
-extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple);
+extern void gimple_seq_add_stmt (gimple_seq *, gimple *);
+extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *);
 void gimple_seq_add_seq (gimple_seq *, gimple_seq);
 void gimple_seq_add_seq_without_update (gimple_seq *, gimple_seq);
 extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator,
@@ -1441,24 +1441,24 @@ extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator,
 extern void annotate_all_with_location (gimple_seq, location_t);
 bool empty_body_p (gimple_seq);
 gimple_seq gimple_seq_copy (gimple_seq);
-bool gimple_call_same_target_p (const_gimple, const_gimple);
-int gimple_call_flags (const_gimple);
+bool gimple_call_same_target_p (const gimple *, const gimple *);
+int gimple_call_flags (const gimple *);
 int gimple_call_arg_flags (const gcall *, unsigned);
 int gimple_call_return_flags (const gcall *);
-bool gimple_assign_copy_p (gimple);
-bool gimple_assign_ssa_name_copy_p (gimple);
-bool gimple_assign_unary_nop_p (gimple);
-void gimple_set_bb (gimple, basic_block);
+bool gimple_assign_copy_p (gimple *);
+bool gimple_assign_ssa_name_copy_p (gimple *);
+bool gimple_assign_unary_nop_p (gimple *);
+void gimple_set_bb (gimple *, basic_block);
 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
 void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
 				     tree, tree, tree);
-tree gimple_get_lhs (const_gimple);
-void gimple_set_lhs (gimple, tree);
-gimple gimple_copy (gimple);
-bool gimple_has_side_effects (const_gimple);
-bool gimple_could_trap_p_1 (gimple, bool, bool);
-bool gimple_could_trap_p (gimple);
-bool gimple_assign_rhs_could_trap_p (gimple);
+tree gimple_get_lhs (const gimple *);
+void gimple_set_lhs (gimple *, tree);
+gimple *gimple_copy (gimple *);
+bool gimple_has_side_effects (const gimple *);
+bool gimple_could_trap_p_1 (gimple *, bool, bool);
+bool gimple_could_trap_p (gimple *);
+bool gimple_assign_rhs_could_trap_p (gimple *);
 extern void dump_gimple_statistics (void);
 unsigned get_gimple_rhs_num_ops (enum tree_code);
 extern tree canonicalize_cond_expr_cond (tree);
@@ -1467,22 +1467,22 @@ extern bool gimple_compare_field_offset (tree, tree);
 extern tree gimple_unsigned_type (tree);
 extern tree gimple_signed_type (tree);
 extern alias_set_type gimple_get_alias_set (tree);
-extern bool gimple_ior_addresses_taken (bitmap, gimple);
-extern bool gimple_builtin_call_types_compatible_p (const_gimple, tree);
-extern bool gimple_call_builtin_p (const_gimple);
-extern bool gimple_call_builtin_p (const_gimple, enum built_in_class);
-extern bool gimple_call_builtin_p (const_gimple, enum built_in_function);
+extern bool gimple_ior_addresses_taken (bitmap, gimple *);
+extern bool gimple_builtin_call_types_compatible_p (const gimple *, tree);
+extern bool gimple_call_builtin_p (const gimple *);
+extern bool gimple_call_builtin_p (const gimple *, enum built_in_class);
+extern bool gimple_call_builtin_p (const gimple *, enum built_in_function);
 extern bool gimple_asm_clobbers_memory_p (const gasm *);
 extern void dump_decl_set (FILE *, bitmap);
-extern bool nonfreeing_call_p (gimple);
-extern bool infer_nonnull_range (gimple, tree);
-extern bool infer_nonnull_range_by_dereference (gimple, tree);
-extern bool infer_nonnull_range_by_attribute (gimple, tree);
+extern bool nonfreeing_call_p (gimple *);
+extern bool infer_nonnull_range (gimple *, tree);
+extern bool infer_nonnull_range_by_dereference (gimple *, tree);
+extern bool infer_nonnull_range_by_attribute (gimple *, tree);
 extern void sort_case_labels (vec<tree>);
 extern void preprocess_case_label_vec_for_gimple (vec<tree>, tree, tree *);
 extern void gimple_seq_set_location (gimple_seq, location_t);
 extern void gimple_seq_discard (gimple_seq);
-extern void maybe_remove_unused_call_args (struct function *, gimple);
+extern void maybe_remove_unused_call_args (struct function *, gimple *);
 
 /* Formal (expression) temporary table handling: multiple occurrences of
    the same scalar expression are evaluated into the same temporary.  */
@@ -1525,7 +1525,7 @@ gimple_seq_first (gimple_seq s)
 
 /* Return the first statement in GIMPLE sequence S.  */
 
-static inline gimple
+static inline gimple *
 gimple_seq_first_stmt (gimple_seq s)
 {
   gimple_seq_node n = gimple_seq_first (s);
@@ -1554,7 +1554,7 @@ gimple_seq_last (gimple_seq s)
 
 /* Return the last statement in GIMPLE sequence S.  */
 
-static inline gimple
+static inline gimple *
 gimple_seq_last_stmt (gimple_seq s)
 {
   gimple_seq_node n = gimple_seq_last (s);
@@ -1591,7 +1591,7 @@ gimple_seq_empty_p (gimple_seq s)
 /* Allocate a new sequence and initialize its first element with STMT.  */
 
 static inline gimple_seq
-gimple_seq_alloc_with_stmt (gimple stmt)
+gimple_seq_alloc_with_stmt (gimple *stmt)
 {
   gimple_seq seq = NULL;
   gimple_seq_add_stmt (&seq, stmt);
@@ -1626,7 +1626,7 @@ set_bb_seq (basic_block bb, gimple_seq seq)
 /* Return the code for GIMPLE statement G.  */
 
 static inline enum gimple_code
-gimple_code (const_gimple g)
+gimple_code (const gimple *g)
 {
   return g->code;
 }
@@ -1645,7 +1645,7 @@ gss_for_code (enum gimple_code code)
 /* Return which GSS code is used by GS.  */
 
 static inline enum gimple_statement_structure_enum
-gimple_statement_structure (gimple gs)
+gimple_statement_structure (gimple *gs)
 {
   return gss_for_code (gimple_code (gs));
 }
@@ -1655,7 +1655,7 @@ gimple_statement_structure (gimple gs)
    High GIMPLE statements.  */
 
 static inline bool
-gimple_has_substatements (gimple g)
+gimple_has_substatements (gimple *g)
 {
   switch (gimple_code (g))
     {
@@ -1689,7 +1689,7 @@ gimple_has_substatements (gimple g)
 /* Return the basic block holding statement G.  */
 
 static inline basic_block
-gimple_bb (const_gimple g)
+gimple_bb (const gimple *g)
 {
   return g->bb;
 }
@@ -1698,7 +1698,7 @@ gimple_bb (const_gimple g)
 /* Return the lexical scope block holding statement G.  */
 
 static inline tree
-gimple_block (const_gimple g)
+gimple_block (const gimple *g)
 {
   return LOCATION_BLOCK (g->location);
 }
@@ -1707,7 +1707,7 @@ gimple_block (const_gimple g)
 /* Set BLOCK to be the lexical scope block holding statement G.  */
 
 static inline void
-gimple_set_block (gimple g, tree block)
+gimple_set_block (gimple *g, tree block)
 {
   if (block)
     g->location =
@@ -1720,7 +1720,7 @@ gimple_set_block (gimple g, tree block)
 /* Return location information for statement G.  */
 
 static inline location_t
-gimple_location (const_gimple g)
+gimple_location (const gimple *g)
 {
   return g->location;
 }
@@ -1729,7 +1729,7 @@ gimple_location (const_gimple g)
    Otherwise, UNKNOWN_LOCATION is returned.  */
 
 static inline location_t
-gimple_location_safe (const_gimple g)
+gimple_location_safe (const gimple *g)
 {
   return g ? gimple_location (g) : UNKNOWN_LOCATION;
 }
@@ -1737,7 +1737,7 @@ gimple_location_safe (const_gimple g)
 /* Return pointer to location information for statement G.  */
 
 static inline const location_t *
-gimple_location_ptr (const_gimple g)
+gimple_location_ptr (const gimple *g)
 {
   return &g->location;
 }
@@ -1746,7 +1746,7 @@ gimple_location_ptr (const_gimple g)
 /* Set location information for statement G.  */
 
 static inline void
-gimple_set_location (gimple g, location_t location)
+gimple_set_location (gimple *g, location_t location)
 {
   g->location = location;
 }
@@ -1755,7 +1755,7 @@ gimple_set_location (gimple g, location_t location)
 /* Return true if G contains location information.  */
 
 static inline bool
-gimple_has_location (const_gimple g)
+gimple_has_location (const gimple *g)
 {
   return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION;
 }
@@ -1764,7 +1764,7 @@ gimple_has_location (const_gimple g)
 /* Return the file name of the location of STMT.  */
 
 static inline const char *
-gimple_filename (const_gimple stmt)
+gimple_filename (const gimple *stmt)
 {
   return LOCATION_FILE (gimple_location (stmt));
 }
@@ -1773,7 +1773,7 @@ gimple_filename (const_gimple stmt)
 /* Return the line number of the location of STMT.  */
 
 static inline int
-gimple_lineno (const_gimple stmt)
+gimple_lineno (const gimple *stmt)
 {
   return LOCATION_LINE (gimple_location (stmt));
 }
@@ -1791,7 +1791,7 @@ gimple_seq_singleton_p (gimple_seq seq)
 /* Return true if no warnings should be emitted for statement STMT.  */
 
 static inline bool
-gimple_no_warning_p (const_gimple stmt)
+gimple_no_warning_p (const gimple *stmt)
 {
   return stmt->no_warning;
 }
@@ -1799,7 +1799,7 @@ gimple_no_warning_p (const_gimple stmt)
 /* Set the no_warning flag of STMT to NO_WARNING.  */
 
 static inline void
-gimple_set_no_warning (gimple stmt, bool no_warning)
+gimple_set_no_warning (gimple *stmt, bool no_warning)
 {
   stmt->no_warning = (unsigned) no_warning;
 }
@@ -1817,7 +1817,7 @@ gimple_set_no_warning (gimple stmt, bool no_warning)
  */
 
 static inline void
-gimple_set_visited (gimple stmt, bool visited_p)
+gimple_set_visited (gimple *stmt, bool visited_p)
 {
   stmt->visited = (unsigned) visited_p;
 }
@@ -1835,7 +1835,7 @@ gimple_set_visited (gimple stmt, bool visited_p)
    struct gimple statement_base.  */
 
 static inline bool
-gimple_visited_p (gimple stmt)
+gimple_visited_p (gimple *stmt)
 {
   return stmt->visited;
 }
@@ -1852,7 +1852,7 @@ gimple_visited_p (gimple stmt)
    the 'plf' data member of struct gimple_statement_structure.  */
 
 static inline void
-gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
+gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
 {
   if (val_p)
     stmt->plf |= (unsigned int) plf;
@@ -1872,7 +1872,7 @@ gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
    the 'plf' data member of struct gimple_statement_structure.  */
 
 static inline unsigned int
-gimple_plf (gimple stmt, enum plf_mask plf)
+gimple_plf (gimple *stmt, enum plf_mask plf)
 {
   return stmt->plf & ((unsigned int) plf);
 }
@@ -1886,7 +1886,7 @@ gimple_plf (gimple stmt, enum plf_mask plf)
    to any value it sees fit.  */
 
 static inline void
-gimple_set_uid (gimple g, unsigned uid)
+gimple_set_uid (gimple *g, unsigned uid)
 {
   g->uid = uid;
 }
@@ -1900,7 +1900,7 @@ gimple_set_uid (gimple g, unsigned uid)
    to any value it sees fit.  */
 
 static inline unsigned
-gimple_uid (const_gimple g)
+gimple_uid (const gimple *g)
 {
   return g->uid;
 }
@@ -1909,7 +1909,7 @@ gimple_uid (const_gimple g)
 /* Make statement G a singleton sequence.  */
 
 static inline void
-gimple_init_singleton (gimple g)
+gimple_init_singleton (gimple *g)
 {
   g->next = NULL;
   g->prev = g;
@@ -1919,7 +1919,7 @@ gimple_init_singleton (gimple g)
 /* Return true if GIMPLE statement G has register or memory operands.  */
 
 static inline bool
-gimple_has_ops (const_gimple g)
+gimple_has_ops (const gimple *g)
 {
   return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
 }
@@ -1927,7 +1927,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_statement_with_ops *>::test (const gimple *gs)
 {
   return gimple_has_ops (gs);
 }
@@ -1935,7 +1935,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_statement_with_ops *>::test (gimple *gs)
 {
   return gimple_has_ops (gs);
 }
@@ -1943,7 +1943,7 @@ is_a_helper <gimple_statement_with_ops *>::test (gimple gs)
 /* Return true if GIMPLE statement G has memory operands.  */
 
 static inline bool
-gimple_has_mem_ops (const_gimple g)
+gimple_has_mem_ops (const gimple *g)
 {
   return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
 }
@@ -1951,7 +1951,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_statement_with_memory_ops *>::test (const gimple *gs)
 {
   return gimple_has_mem_ops (gs);
 }
@@ -1959,7 +1959,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_statement_with_memory_ops *>::test (gimple *gs)
 {
   return gimple_has_mem_ops (gs);
 }
@@ -1967,7 +1967,7 @@ is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
 /* Return the set of USE operands for statement G.  */
 
 static inline struct use_optype_d *
-gimple_use_ops (const_gimple g)
+gimple_use_ops (const gimple *g)
 {
   const gimple_statement_with_ops *ops_stmt =
     dyn_cast <const gimple_statement_with_ops *> (g);
@@ -1980,7 +1980,7 @@ gimple_use_ops (const_gimple g)
 /* Set USE to be the set of USE operands for statement G.  */
 
 static inline void
-gimple_set_use_ops (gimple g, struct use_optype_d *use)
+gimple_set_use_ops (gimple *g, struct use_optype_d *use)
 {
   gimple_statement_with_ops *ops_stmt =
     as_a <gimple_statement_with_ops *> (g);
@@ -1991,7 +1991,7 @@ gimple_set_use_ops (gimple g, struct use_optype_d *use)
 /* Return the single VUSE operand of the statement G.  */
 
 static inline tree
-gimple_vuse (const_gimple g)
+gimple_vuse (const gimple *g)
 {
   const gimple_statement_with_memory_ops *mem_ops_stmt =
      dyn_cast <const gimple_statement_with_memory_ops *> (g);
@@ -2003,7 +2003,7 @@ gimple_vuse (const_gimple g)
 /* Return the single VDEF operand of the statement G.  */
 
 static inline tree
-gimple_vdef (const_gimple g)
+gimple_vdef (const gimple *g)
 {
   const gimple_statement_with_memory_ops *mem_ops_stmt =
      dyn_cast <const gimple_statement_with_memory_ops *> (g);
@@ -2015,7 +2015,7 @@ gimple_vdef (const_gimple g)
 /* Return the single VUSE operand of the statement G.  */
 
 static inline tree *
-gimple_vuse_ptr (gimple g)
+gimple_vuse_ptr (gimple *g)
 {
   gimple_statement_with_memory_ops *mem_ops_stmt =
      dyn_cast <gimple_statement_with_memory_ops *> (g);
@@ -2027,7 +2027,7 @@ gimple_vuse_ptr (gimple g)
 /* Return the single VDEF operand of the statement G.  */
 
 static inline tree *
-gimple_vdef_ptr (gimple g)
+gimple_vdef_ptr (gimple *g)
 {
   gimple_statement_with_memory_ops *mem_ops_stmt =
      dyn_cast <gimple_statement_with_memory_ops *> (g);
@@ -2039,7 +2039,7 @@ gimple_vdef_ptr (gimple g)
 /* Set the single VUSE operand of the statement G.  */
 
 static inline void
-gimple_set_vuse (gimple g, tree vuse)
+gimple_set_vuse (gimple *g, tree vuse)
 {
   gimple_statement_with_memory_ops *mem_ops_stmt =
     as_a <gimple_statement_with_memory_ops *> (g);
@@ -2049,7 +2049,7 @@ gimple_set_vuse (gimple g, tree vuse)
 /* Set the single VDEF operand of the statement G.  */
 
 static inline void
-gimple_set_vdef (gimple g, tree vdef)
+gimple_set_vdef (gimple *g, tree vdef)
 {
   gimple_statement_with_memory_ops *mem_ops_stmt =
     as_a <gimple_statement_with_memory_ops *> (g);
@@ -2061,7 +2061,7 @@ gimple_set_vdef (gimple g, tree vdef)
    been set.  */
 
 static inline bool
-gimple_modified_p (const_gimple g)
+gimple_modified_p (const gimple *g)
 {
   return (gimple_has_ops (g)) ? (bool) g->modified : false;
 }
@@ -2071,7 +2071,7 @@ gimple_modified_p (const_gimple g)
    a MODIFIED field.  */
 
 static inline void
-gimple_set_modified (gimple s, bool modifiedp)
+gimple_set_modified (gimple *s, bool modifiedp)
 {
   if (gimple_has_ops (s))
     s->modified = (unsigned) modifiedp;
@@ -2085,7 +2085,7 @@ gimple_set_modified (gimple s, bool modifiedp)
    three kinds of computation that GIMPLE supports.  */
 
 static inline enum tree_code
-gimple_expr_code (const_gimple stmt)
+gimple_expr_code (const gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
   if (code == GIMPLE_ASSIGN || code == GIMPLE_COND)
@@ -2101,7 +2101,7 @@ gimple_expr_code (const_gimple stmt)
 /* Return true if statement STMT contains volatile operands.  */
 
 static inline bool
-gimple_has_volatile_ops (const_gimple stmt)
+gimple_has_volatile_ops (const gimple *stmt)
 {
   if (gimple_has_mem_ops (stmt))
     return stmt->has_volatile_ops;
@@ -2113,7 +2113,7 @@ gimple_has_volatile_ops (const_gimple stmt)
 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP.  */
 
 static inline void
-gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
+gimple_set_has_volatile_ops (gimple *stmt, bool volatilep)
 {
   if (gimple_has_mem_ops (stmt))
     stmt->has_volatile_ops = (unsigned) volatilep;
@@ -2122,7 +2122,7 @@ gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
 /* Return true if STMT is in a transaction.  */
 
 static inline bool
-gimple_in_transaction (gimple stmt)
+gimple_in_transaction (const gimple *stmt)
 {
   return bb_in_transaction (gimple_bb (stmt));
 }
@@ -2130,7 +2130,7 @@ gimple_in_transaction (gimple stmt)
 /* Return true if statement STMT may access memory.  */
 
 static inline bool
-gimple_references_memory_p (gimple stmt)
+gimple_references_memory_p (gimple *stmt)
 {
   return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
 }
@@ -2139,7 +2139,7 @@ gimple_references_memory_p (gimple stmt)
 /* Return the subcode for OMP statement S.  */
 
 static inline unsigned
-gimple_omp_subcode (const_gimple s)
+gimple_omp_subcode (const gimple *s)
 {
   gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
 	      && gimple_code (s) <= GIMPLE_OMP_TEAMS);
@@ -2149,7 +2149,7 @@ gimple_omp_subcode (const_gimple s)
 /* Set the subcode for OMP statement S to SUBCODE.  */
 
 static inline void
-gimple_omp_set_subcode (gimple s, unsigned int subcode)
+gimple_omp_set_subcode (gimple *s, unsigned int subcode)
 {
   /* We only have 16 bits for the subcode.  Assert that we are not
      overflowing it.  */
@@ -2160,7 +2160,7 @@ gimple_omp_set_subcode (gimple s, unsigned int subcode)
 /* Set the nowait flag on OMP_RETURN statement S.  */
 
 static inline void
-gimple_omp_return_set_nowait (gimple s)
+gimple_omp_return_set_nowait (gimple *s)
 {
   GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
   s->subcode |= GF_OMP_RETURN_NOWAIT;
@@ -2171,7 +2171,7 @@ gimple_omp_return_set_nowait (gimple s)
    flag set.  */
 
 static inline bool
-gimple_omp_return_nowait_p (const_gimple g)
+gimple_omp_return_nowait_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
   return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
@@ -2181,7 +2181,7 @@ gimple_omp_return_nowait_p (const_gimple g)
 /* Set the LHS of OMP return.  */
 
 static inline void
-gimple_omp_return_set_lhs (gimple g, tree lhs)
+gimple_omp_return_set_lhs (gimple *g, tree lhs)
 {
   gimple_statement_omp_return *omp_return_stmt =
     as_a <gimple_statement_omp_return *> (g);
@@ -2192,7 +2192,7 @@ gimple_omp_return_set_lhs (gimple g, tree lhs)
 /* Get the LHS of OMP return.  */
 
 static inline tree
-gimple_omp_return_lhs (const_gimple g)
+gimple_omp_return_lhs (const gimple *g)
 {
   const gimple_statement_omp_return *omp_return_stmt =
     as_a <const gimple_statement_omp_return *> (g);
@@ -2203,7 +2203,7 @@ gimple_omp_return_lhs (const_gimple g)
 /* Return a pointer to the LHS of OMP return.  */
 
 static inline tree *
-gimple_omp_return_lhs_ptr (gimple g)
+gimple_omp_return_lhs_ptr (gimple *g)
 {
   gimple_statement_omp_return *omp_return_stmt =
     as_a <gimple_statement_omp_return *> (g);
@@ -2215,7 +2215,7 @@ gimple_omp_return_lhs_ptr (gimple g)
    flag set.  */
 
 static inline bool
-gimple_omp_section_last_p (const_gimple g)
+gimple_omp_section_last_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
   return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
@@ -2225,7 +2225,7 @@ gimple_omp_section_last_p (const_gimple g)
 /* Set the GF_OMP_SECTION_LAST flag on G.  */
 
 static inline void
-gimple_omp_section_set_last (gimple g)
+gimple_omp_section_set_last (gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
   g->subcode |= GF_OMP_SECTION_LAST;
@@ -2236,7 +2236,7 @@ gimple_omp_section_set_last (gimple g)
    GF_OMP_PARALLEL_COMBINED flag set.  */
 
 static inline bool
-gimple_omp_parallel_combined_p (const_gimple g)
+gimple_omp_parallel_combined_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
   return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
@@ -2247,7 +2247,7 @@ gimple_omp_parallel_combined_p (const_gimple g)
    value of COMBINED_P.  */
 
 static inline void
-gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
+gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
   if (combined_p)
@@ -2261,7 +2261,7 @@ gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
    GF_OMP_ATOMIC_NEED_VALUE flag set.  */
 
 static inline bool
-gimple_omp_atomic_need_value_p (const_gimple g)
+gimple_omp_atomic_need_value_p (const gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -2272,7 +2272,7 @@ gimple_omp_atomic_need_value_p (const_gimple g)
 /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G.  */
 
 static inline void
-gimple_omp_atomic_set_need_value (gimple g)
+gimple_omp_atomic_set_need_value (gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -2284,7 +2284,7 @@ gimple_omp_atomic_set_need_value (gimple g)
    GF_OMP_ATOMIC_SEQ_CST flag set.  */
 
 static inline bool
-gimple_omp_atomic_seq_cst_p (const_gimple g)
+gimple_omp_atomic_seq_cst_p (const gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -2295,7 +2295,7 @@ gimple_omp_atomic_seq_cst_p (const_gimple g)
 /* Set the GF_OMP_ATOMIC_SEQ_CST flag on G.  */
 
 static inline void
-gimple_omp_atomic_set_seq_cst (gimple g)
+gimple_omp_atomic_set_seq_cst (gimple *g)
 {
   if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
     GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
@@ -2306,7 +2306,7 @@ gimple_omp_atomic_set_seq_cst (gimple g)
 /* Return the number of operands for statement GS.  */
 
 static inline unsigned
-gimple_num_ops (const_gimple gs)
+gimple_num_ops (const gimple *gs)
 {
   return gs->num_ops;
 }
@@ -2315,7 +2315,7 @@ gimple_num_ops (const_gimple gs)
 /* Set the number of operands for statement GS.  */
 
 static inline void
-gimple_set_num_ops (gimple gs, unsigned num_ops)
+gimple_set_num_ops (gimple *gs, unsigned num_ops)
 {
   gs->num_ops = num_ops;
 }
@@ -2324,7 +2324,7 @@ gimple_set_num_ops (gimple gs, unsigned num_ops)
 /* Return the array of operands for statement GS.  */
 
 static inline tree *
-gimple_ops (gimple gs)
+gimple_ops (gimple *gs)
 {
   size_t off;
 
@@ -2341,7 +2341,7 @@ gimple_ops (gimple gs)
 /* Return operand I for statement GS.  */
 
 static inline tree
-gimple_op (const_gimple gs, unsigned i)
+gimple_op (const gimple *gs, unsigned i)
 {
   if (gimple_has_ops (gs))
     {
@@ -2355,7 +2355,7 @@ gimple_op (const_gimple gs, unsigned i)
 /* Return a pointer to operand I for statement GS.  */
 
 static inline tree *
-gimple_op_ptr (const_gimple gs, unsigned i)
+gimple_op_ptr (const gimple *gs, unsigned i)
 {
   if (gimple_has_ops (gs))
     {
@@ -2369,7 +2369,7 @@ gimple_op_ptr (const_gimple gs, unsigned i)
 /* Set operand I of statement GS to OP.  */
 
 static inline void
-gimple_set_op (gimple gs, unsigned i, tree op)
+gimple_set_op (gimple *gs, unsigned i, tree op)
 {
   gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
 
@@ -2383,7 +2383,7 @@ gimple_set_op (gimple gs, unsigned i, tree op)
 /* Return true if GS is a GIMPLE_ASSIGN.  */
 
 static inline bool
-is_gimple_assign (const_gimple gs)
+is_gimple_assign (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_ASSIGN;
 }
@@ -2406,7 +2406,7 @@ gimple_assign_lhs (const gassign *gs)
 }
 
 static inline tree
-gimple_assign_lhs (const_gimple gs)
+gimple_assign_lhs (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_lhs (ass);
@@ -2422,7 +2422,7 @@ gimple_assign_lhs_ptr (const gassign *gs)
 }
 
 static inline tree *
-gimple_assign_lhs_ptr (const_gimple gs)
+gimple_assign_lhs_ptr (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_lhs_ptr (ass);
@@ -2441,7 +2441,7 @@ gimple_assign_set_lhs (gassign *gs, tree lhs)
 }
 
 static inline void
-gimple_assign_set_lhs (gimple gs, tree lhs)
+gimple_assign_set_lhs (gimple *gs, tree lhs)
 {
   gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
   gimple_assign_set_lhs (ass, lhs);
@@ -2457,7 +2457,7 @@ gimple_assign_rhs1 (const gassign *gs)
 }
 
 static inline tree
-gimple_assign_rhs1 (const_gimple gs)
+gimple_assign_rhs1 (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_rhs1 (ass);
@@ -2474,7 +2474,7 @@ gimple_assign_rhs1_ptr (const gassign *gs)
 }
 
 static inline tree *
-gimple_assign_rhs1_ptr (const_gimple gs)
+gimple_assign_rhs1_ptr (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_rhs1_ptr (ass);
@@ -2489,7 +2489,7 @@ gimple_assign_set_rhs1 (gassign *gs, tree rhs)
 }
 
 static inline void
-gimple_assign_set_rhs1 (gimple gs, tree rhs)
+gimple_assign_set_rhs1 (gimple *gs, tree rhs)
 {
   gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
   gimple_assign_set_rhs1 (ass, rhs);
@@ -2509,7 +2509,7 @@ gimple_assign_rhs2 (const gassign *gs)
 }
 
 static inline tree
-gimple_assign_rhs2 (const_gimple gs)
+gimple_assign_rhs2 (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_rhs2 (ass);
@@ -2527,7 +2527,7 @@ gimple_assign_rhs2_ptr (const gassign *gs)
 }
 
 static inline tree *
-gimple_assign_rhs2_ptr (const_gimple gs)
+gimple_assign_rhs2_ptr (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_rhs2_ptr (ass);
@@ -2544,7 +2544,7 @@ gimple_assign_set_rhs2 (gassign *gs, tree rhs)
 }
 
 static inline void
-gimple_assign_set_rhs2 (gimple gs, tree rhs)
+gimple_assign_set_rhs2 (gimple *gs, tree rhs)
 {
   gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
   return gimple_assign_set_rhs2 (ass, rhs);
@@ -2563,7 +2563,7 @@ gimple_assign_rhs3 (const gassign *gs)
 }
 
 static inline tree
-gimple_assign_rhs3 (const_gimple gs)
+gimple_assign_rhs3 (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_rhs3 (ass);
@@ -2573,7 +2573,7 @@ gimple_assign_rhs3 (const_gimple gs)
    statement GS.  */
 
 static inline tree *
-gimple_assign_rhs3_ptr (const_gimple gs)
+gimple_assign_rhs3_ptr (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
@@ -2591,7 +2591,7 @@ gimple_assign_set_rhs3 (gassign *gs, tree rhs)
 }
 
 static inline void
-gimple_assign_set_rhs3 (gimple gs, tree rhs)
+gimple_assign_set_rhs3 (gimple *gs, tree rhs)
 {
   gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
   gimple_assign_set_rhs3 (ass, rhs);
@@ -2629,7 +2629,7 @@ gimple_assign_nontemporal_move_p (const gassign *gs)
 /* Sets nontemporal move flag of GS to NONTEMPORAL.  */
 
 static inline void
-gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
+gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
 {
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
   gs->nontemporal_move = nontemporal;
@@ -2654,7 +2654,7 @@ gimple_assign_rhs_code (const gassign *gs)
 }
 
 static inline enum tree_code
-gimple_assign_rhs_code (const_gimple gs)
+gimple_assign_rhs_code (const gimple *gs)
 {
   const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
   return gimple_assign_rhs_code (ass);
@@ -2665,7 +2665,7 @@ gimple_assign_rhs_code (const_gimple gs)
    assignment S.  */
 
 static inline void
-gimple_assign_set_rhs_code (gimple s, enum tree_code code)
+gimple_assign_set_rhs_code (gimple *s, enum tree_code code)
 {
   GIMPLE_CHECK (s, GIMPLE_ASSIGN);
   s->subcode = code;
@@ -2677,7 +2677,7 @@ gimple_assign_set_rhs_code (gimple s, enum tree_code code)
    This will never return GIMPLE_INVALID_RHS.  */
 
 static inline enum gimple_rhs_class
-gimple_assign_rhs_class (const_gimple gs)
+gimple_assign_rhs_class (const gimple *gs)
 {
   return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
 }
@@ -2689,7 +2689,7 @@ gimple_assign_rhs_class (const_gimple gs)
    and do not have the semantics of a copy, such as COND_EXPR.  */
 
 static inline bool
-gimple_assign_single_p (const_gimple gs)
+gimple_assign_single_p (const gimple *gs)
 {
   return (is_gimple_assign (gs)
           && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
@@ -2698,7 +2698,7 @@ gimple_assign_single_p (const_gimple gs)
 /* Return true if GS performs a store to its lhs.  */
 
 static inline bool
-gimple_store_p (const_gimple gs)
+gimple_store_p (const gimple *gs)
 {
   tree lhs = gimple_get_lhs (gs);
   return lhs && !is_gimple_reg (lhs);
@@ -2707,7 +2707,7 @@ gimple_store_p (const_gimple gs)
 /* Return true if GS is an assignment that loads from its rhs1.  */
 
 static inline bool
-gimple_assign_load_p (const_gimple gs)
+gimple_assign_load_p (const gimple *gs)
 {
   tree rhs;
   if (!gimple_assign_single_p (gs))
@@ -2724,7 +2724,7 @@ gimple_assign_load_p (const_gimple gs)
 /* Return true if S is a type-cast assignment.  */
 
 static inline bool
-gimple_assign_cast_p (const_gimple s)
+gimple_assign_cast_p (const gimple *s)
 {
   if (is_gimple_assign (s))
     {
@@ -2740,7 +2740,7 @@ gimple_assign_cast_p (const_gimple s)
 /* Return true if S is a clobber statement.  */
 
 static inline bool
-gimple_clobber_p (const_gimple s)
+gimple_clobber_p (const gimple *s)
 {
   return gimple_assign_single_p (s)
          && TREE_CLOBBER_P (gimple_assign_rhs1 (s));
@@ -2749,7 +2749,7 @@ gimple_clobber_p (const_gimple s)
 /* Return true if GS is a GIMPLE_CALL.  */
 
 static inline bool
-is_gimple_call (const_gimple gs)
+is_gimple_call (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_CALL;
 }
@@ -2763,7 +2763,7 @@ gimple_call_lhs (const gcall *gs)
 }
 
 static inline tree
-gimple_call_lhs (const_gimple gs)
+gimple_call_lhs (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_lhs (gc);
@@ -2779,7 +2779,7 @@ gimple_call_lhs_ptr (const gcall *gs)
 }
 
 static inline tree *
-gimple_call_lhs_ptr (const_gimple gs)
+gimple_call_lhs_ptr (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_lhs_ptr (gc);
@@ -2797,7 +2797,7 @@ gimple_call_set_lhs (gcall *gs, tree lhs)
 }
 
 static inline void
-gimple_call_set_lhs (gimple gs, tree lhs)
+gimple_call_set_lhs (gimple *gs, tree lhs)
 {
   gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
   gimple_call_set_lhs (gc, lhs);
@@ -2814,7 +2814,7 @@ gimple_call_internal_p (const gcall *gs)
 }
 
 static inline bool
-gimple_call_internal_p (const_gimple gs)
+gimple_call_internal_p (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_internal_p (gc);
@@ -2831,7 +2831,7 @@ gimple_call_with_bounds_p (const gcall *gs)
 }
 
 static inline bool
-gimple_call_with_bounds_p (const_gimple gs)
+gimple_call_with_bounds_p (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_with_bounds_p (gc);
@@ -2851,7 +2851,7 @@ gimple_call_set_with_bounds (gcall *gs, bool with_bounds)
 }
 
 static inline void
-gimple_call_set_with_bounds (gimple gs, bool with_bounds)
+gimple_call_set_with_bounds (gimple *gs, bool with_bounds)
 {
   gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
   gimple_call_set_with_bounds (gc, with_bounds);
@@ -2868,7 +2868,7 @@ gimple_call_internal_fn (const gcall *gs)
 }
 
 static inline enum internal_fn
-gimple_call_internal_fn (const_gimple gs)
+gimple_call_internal_fn (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_internal_fn (gc);
@@ -2887,7 +2887,7 @@ gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
 }
 
 static inline void
-gimple_call_set_ctrl_altering (gimple s, bool ctrl_altering_p)
+gimple_call_set_ctrl_altering (gimple *s, bool ctrl_altering_p)
 {
   gcall *gc = GIMPLE_CHECK2<gcall *> (s);
   gimple_call_set_ctrl_altering (gc, ctrl_altering_p);
@@ -2903,7 +2903,7 @@ gimple_call_ctrl_altering_p (const gcall *gs)
 }
 
 static inline bool
-gimple_call_ctrl_altering_p (const_gimple gs)
+gimple_call_ctrl_altering_p (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_ctrl_altering_p (gc);
@@ -2921,7 +2921,7 @@ gimple_call_fntype (const gcall *gs)
 }
 
 static inline tree
-gimple_call_fntype (const_gimple gs)
+gimple_call_fntype (const gimple *gs)
 {
   const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_fntype (call_stmt);
@@ -2947,7 +2947,7 @@ gimple_call_fn (const gcall *gs)
 }
 
 static inline tree
-gimple_call_fn (const_gimple gs)
+gimple_call_fn (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_fn (gc);
@@ -2963,7 +2963,7 @@ gimple_call_fn_ptr (const gcall *gs)
 }
 
 static inline tree *
-gimple_call_fn_ptr (const_gimple gs)
+gimple_call_fn_ptr (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_fn_ptr (gc);
@@ -2991,7 +2991,7 @@ gimple_call_set_fndecl (gcall *gs, tree decl)
 }
 
 static inline void
-gimple_call_set_fndecl (gimple gs, tree decl)
+gimple_call_set_fndecl (gimple *gs, tree decl)
 {
   gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
   gimple_call_set_fndecl (gc, decl);
@@ -3019,7 +3019,7 @@ gimple_call_fndecl (const gcall *gs)
 }
 
 static inline tree
-gimple_call_fndecl (const_gimple gs)
+gimple_call_fndecl (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_fndecl (gc);
@@ -3051,7 +3051,7 @@ gimple_call_chain (const gcall *gs)
 }
 
 static inline tree
-gimple_call_chain (const_gimple gs)
+gimple_call_chain (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_chain (gc);
@@ -3084,7 +3084,7 @@ gimple_call_num_args (const gcall *gs)
 }
 
 static inline unsigned
-gimple_call_num_args (const_gimple gs)
+gimple_call_num_args (const gimple *gs)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_num_args (gc);
@@ -3101,7 +3101,7 @@ gimple_call_arg (const gcall *gs, unsigned index)
 }
 
 static inline tree
-gimple_call_arg (const_gimple gs, unsigned index)
+gimple_call_arg (const gimple *gs, unsigned index)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_arg (gc, index);
@@ -3119,7 +3119,7 @@ gimple_call_arg_ptr (const gcall *gs, unsigned index)
 }
 
 static inline tree *
-gimple_call_arg_ptr (const_gimple gs, unsigned index)
+gimple_call_arg_ptr (const gimple *gs, unsigned index)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
   return gimple_call_arg_ptr (gc, index);
@@ -3136,7 +3136,7 @@ gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
 }
 
 static inline void
-gimple_call_set_arg (gimple gs, unsigned index, tree arg)
+gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
 {
   gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
   gimple_call_set_arg (gc, index, arg);
@@ -3243,7 +3243,7 @@ gimple_call_noreturn_p (const gcall *s)
 }
 
 static inline bool
-gimple_call_noreturn_p (const_gimple s)
+gimple_call_noreturn_p (const gimple *s)
 {
   const gcall *gc = GIMPLE_CHECK2<const gcall *> (s);
   return gimple_call_noreturn_p (gc);
@@ -3325,7 +3325,7 @@ gimple_call_clobber_set (gcall *call_stmt)
    non-NULL lhs.  */
 
 static inline bool
-gimple_has_lhs (gimple stmt)
+gimple_has_lhs (gimple *stmt)
 {
   if (is_gimple_assign (stmt))
     return true;
@@ -3344,7 +3344,7 @@ gimple_cond_code (const gcond *gs)
 }
 
 static inline enum tree_code
-gimple_cond_code (const_gimple gs)
+gimple_cond_code (const gimple *gs)
 {
   const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
   return gimple_cond_code (gc);
@@ -3369,7 +3369,7 @@ gimple_cond_lhs (const gcond *gs)
 }
 
 static inline tree
-gimple_cond_lhs (const_gimple gs)
+gimple_cond_lhs (const gimple *gs)
 {
   const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
   return gimple_cond_lhs (gc);
@@ -3403,7 +3403,7 @@ gimple_cond_rhs (const gcond *gs)
 }
 
 static inline tree
-gimple_cond_rhs (const_gimple gs)
+gimple_cond_rhs (const gimple *gs)
 {
   const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
   return gimple_cond_rhs (gc);
@@ -3573,7 +3573,7 @@ gimple_label_set_label (glabel *gs, tree label)
 /* Return the destination of the unconditional jump GS.  */
 
 static inline tree
-gimple_goto_dest (const_gimple gs)
+gimple_goto_dest (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_GOTO);
   return gimple_op (gs, 0);
@@ -3646,7 +3646,7 @@ gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq)
 /* Append a statement to the end of a GIMPLE_BIND's body.  */
 
 static inline void
-gimple_bind_add_stmt (gbind *bind_stmt, gimple stmt)
+gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt)
 {
   gimple_seq_add_stmt (&bind_stmt->body, stmt);
 }
@@ -3927,7 +3927,7 @@ gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler)
 /* Return the types handled by GIMPLE_EH_FILTER statement GS.  */
 
 static inline tree
-gimple_eh_filter_types (const_gimple gs)
+gimple_eh_filter_types (const gimple *gs)
 {
   const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
   return eh_filter_stmt->types;
@@ -3938,7 +3938,7 @@ gimple_eh_filter_types (const_gimple gs)
    GS.  */
 
 static inline tree *
-gimple_eh_filter_types_ptr (gimple gs)
+gimple_eh_filter_types_ptr (gimple *gs)
 {
   geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   return &eh_filter_stmt->types;
@@ -3949,7 +3949,7 @@ gimple_eh_filter_types_ptr (gimple gs)
    GIMPLE_EH_FILTER statement fails.  */
 
 static inline gimple_seq *
-gimple_eh_filter_failure_ptr (gimple gs)
+gimple_eh_filter_failure_ptr (gimple *gs)
 {
   geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
   return &eh_filter_stmt->failure;
@@ -3960,7 +3960,7 @@ gimple_eh_filter_failure_ptr (gimple gs)
    statement fails.  */
 
 static inline gimple_seq
-gimple_eh_filter_failure (gimple gs)
+gimple_eh_filter_failure (gimple *gs)
 {
   return *gimple_eh_filter_failure_ptr (gs);
 }
@@ -4047,7 +4047,7 @@ gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq)
    either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.  */
 
 static inline enum gimple_try_flags
-gimple_try_kind (const_gimple gs)
+gimple_try_kind (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_TRY);
   return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
@@ -4069,7 +4069,7 @@ gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind)
 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
 
 static inline bool
-gimple_try_catch_is_cleanup (const_gimple gs)
+gimple_try_catch_is_cleanup (const gimple *gs)
 {
   gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
   return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
@@ -4080,7 +4080,7 @@ gimple_try_catch_is_cleanup (const_gimple gs)
    body for GIMPLE_TRY GS.  */
 
 static inline gimple_seq *
-gimple_try_eval_ptr (gimple gs)
+gimple_try_eval_ptr (gimple *gs)
 {
   gtry *try_stmt = as_a <gtry *> (gs);
   return &try_stmt->eval;
@@ -4090,7 +4090,7 @@ gimple_try_eval_ptr (gimple gs)
 /* Return the sequence of statements used as the body for GIMPLE_TRY GS.  */
 
 static inline gimple_seq
-gimple_try_eval (gimple gs)
+gimple_try_eval (gimple *gs)
 {
   return *gimple_try_eval_ptr (gs);
 }
@@ -4100,7 +4100,7 @@ gimple_try_eval (gimple gs)
    GIMPLE_TRY GS.  */
 
 static inline gimple_seq *
-gimple_try_cleanup_ptr (gimple gs)
+gimple_try_cleanup_ptr (gimple *gs)
 {
   gtry *try_stmt = as_a <gtry *> (gs);
   return &try_stmt->cleanup;
@@ -4111,7 +4111,7 @@ gimple_try_cleanup_ptr (gimple gs)
    GIMPLE_TRY GS.  */
 
 static inline gimple_seq
-gimple_try_cleanup (gimple gs)
+gimple_try_cleanup (gimple *gs)
 {
   return *gimple_try_cleanup_ptr (gs);
 }
@@ -4153,7 +4153,7 @@ gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup)
 /* Return a pointer to the cleanup sequence for cleanup statement GS.  */
 
 static inline gimple_seq *
-gimple_wce_cleanup_ptr (gimple gs)
+gimple_wce_cleanup_ptr (gimple *gs)
 {
   gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
   return &wce_stmt->cleanup;
@@ -4163,7 +4163,7 @@ gimple_wce_cleanup_ptr (gimple gs)
 /* Return the cleanup sequence for cleanup statement GS.  */
 
 static inline gimple_seq
-gimple_wce_cleanup (gimple gs)
+gimple_wce_cleanup (gimple *gs)
 {
   return *gimple_wce_cleanup_ptr (gs);
 }
@@ -4172,7 +4172,7 @@ gimple_wce_cleanup (gimple gs)
 /* Set CLEANUP to be the cleanup sequence for GS.  */
 
 static inline void
-gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
+gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup)
 {
   gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
   wce_stmt->cleanup = cleanup;
@@ -4182,7 +4182,7 @@ gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple.  */
 
 static inline bool
-gimple_wce_cleanup_eh_only (const_gimple gs)
+gimple_wce_cleanup_eh_only (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
   return gs->subcode != 0;
@@ -4192,7 +4192,7 @@ gimple_wce_cleanup_eh_only (const_gimple gs)
 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple.  */
 
 static inline void
-gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
+gimple_wce_set_cleanup_eh_only (gimple *gs, bool eh_only_p)
 {
   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
   gs->subcode = (unsigned int) eh_only_p;
@@ -4202,7 +4202,7 @@ gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
 /* Return the maximum number of arguments supported by GIMPLE_PHI GS.  */
 
 static inline unsigned
-gimple_phi_capacity (const_gimple gs)
+gimple_phi_capacity (const gimple *gs)
 {
   const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->capacity;
@@ -4214,7 +4214,7 @@ gimple_phi_capacity (const_gimple gs)
    GS.  */
 
 static inline unsigned
-gimple_phi_num_args (const_gimple gs)
+gimple_phi_num_args (const gimple *gs)
 {
   const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->nargs;
@@ -4224,7 +4224,7 @@ gimple_phi_num_args (const_gimple gs)
 /* Return the SSA name created by GIMPLE_PHI GS.  */
 
 static inline tree
-gimple_phi_result (const_gimple gs)
+gimple_phi_result (const gimple *gs)
 {
   const gphi *phi_stmt = as_a <const gphi *> (gs);
   return phi_stmt->result;
@@ -4233,7 +4233,7 @@ gimple_phi_result (const_gimple gs)
 /* Return a pointer to the SSA name created by GIMPLE_PHI GS.  */
 
 static inline tree *
-gimple_phi_result_ptr (gimple gs)
+gimple_phi_result_ptr (gimple *gs)
 {
   gphi *phi_stmt = as_a <gphi *> (gs);
   return &phi_stmt->result;
@@ -4254,7 +4254,7 @@ gimple_phi_set_result (gphi *phi, tree result)
    GIMPLE_PHI GS.  */
 
 static inline struct phi_arg_d *
-gimple_phi_arg (gimple gs, unsigned index)
+gimple_phi_arg (gimple *gs, unsigned index)
 {
   gphi *phi_stmt = as_a <gphi *> (gs);
   gcc_gimple_checking_assert (index <= phi_stmt->capacity);
@@ -4293,7 +4293,7 @@ phi_nodes_ptr (basic_block bb)
 /* Return the tree operand for argument I of PHI node GS.  */
 
 static inline tree
-gimple_phi_arg_def (gimple gs, size_t index)
+gimple_phi_arg_def (gimple *gs, size_t index)
 {
   return gimple_phi_arg (gs, index)->def;
 }
@@ -4475,7 +4475,7 @@ gimple_switch_set_default_label (gswitch *gs, tree label)
 /* Return true if GS is a GIMPLE_DEBUG statement.  */
 
 static inline bool
-is_gimple_debug (const_gimple gs)
+is_gimple_debug (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_DEBUG;
 }
@@ -4483,7 +4483,7 @@ is_gimple_debug (const_gimple gs)
 /* Return true if S is a GIMPLE_DEBUG BIND statement.  */
 
 static inline bool
-gimple_debug_bind_p (const_gimple s)
+gimple_debug_bind_p (const gimple *s)
 {
   if (is_gimple_debug (s))
     return s->subcode == GIMPLE_DEBUG_BIND;
@@ -4494,7 +4494,7 @@ gimple_debug_bind_p (const_gimple s)
 /* Return the variable bound in a GIMPLE_DEBUG bind statement.  */
 
 static inline tree
-gimple_debug_bind_get_var (gimple dbg)
+gimple_debug_bind_get_var (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4505,7 +4505,7 @@ gimple_debug_bind_get_var (gimple dbg)
    statement.  */
 
 static inline tree
-gimple_debug_bind_get_value (gimple dbg)
+gimple_debug_bind_get_value (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4516,7 +4516,7 @@ gimple_debug_bind_get_value (gimple dbg)
    GIMPLE_DEBUG bind statement.  */
 
 static inline tree *
-gimple_debug_bind_get_value_ptr (gimple dbg)
+gimple_debug_bind_get_value_ptr (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4526,7 +4526,7 @@ gimple_debug_bind_get_value_ptr (gimple dbg)
 /* Set the variable bound in a GIMPLE_DEBUG bind statement.  */
 
 static inline void
-gimple_debug_bind_set_var (gimple dbg, tree var)
+gimple_debug_bind_set_var (gimple *dbg, tree var)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4537,7 +4537,7 @@ gimple_debug_bind_set_var (gimple dbg, tree var)
    statement.  */
 
 static inline void
-gimple_debug_bind_set_value (gimple dbg, tree value)
+gimple_debug_bind_set_value (gimple *dbg, tree value)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4552,7 +4552,7 @@ gimple_debug_bind_set_value (gimple dbg, tree value)
    statement.  */
 
 static inline void
-gimple_debug_bind_reset_value (gimple dbg)
+gimple_debug_bind_reset_value (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4563,7 +4563,7 @@ gimple_debug_bind_reset_value (gimple dbg)
    value.  */
 
 static inline bool
-gimple_debug_bind_has_value_p (gimple dbg)
+gimple_debug_bind_has_value_p (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
@@ -4575,7 +4575,7 @@ gimple_debug_bind_has_value_p (gimple dbg)
 /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement.  */
 
 static inline bool
-gimple_debug_source_bind_p (const_gimple s)
+gimple_debug_source_bind_p (const gimple *s)
 {
   if (is_gimple_debug (s))
     return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
@@ -4586,7 +4586,7 @@ gimple_debug_source_bind_p (const_gimple s)
 /* Return the variable bound in a GIMPLE_DEBUG source bind statement.  */
 
 static inline tree
-gimple_debug_source_bind_get_var (gimple dbg)
+gimple_debug_source_bind_get_var (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4597,7 +4597,7 @@ gimple_debug_source_bind_get_var (gimple dbg)
    statement.  */
 
 static inline tree
-gimple_debug_source_bind_get_value (gimple dbg)
+gimple_debug_source_bind_get_value (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4608,7 +4608,7 @@ gimple_debug_source_bind_get_value (gimple dbg)
    GIMPLE_DEBUG source bind statement.  */
 
 static inline tree *
-gimple_debug_source_bind_get_value_ptr (gimple dbg)
+gimple_debug_source_bind_get_value_ptr (gimple *dbg)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4618,7 +4618,7 @@ gimple_debug_source_bind_get_value_ptr (gimple dbg)
 /* Set the variable bound in a GIMPLE_DEBUG source bind statement.  */
 
 static inline void
-gimple_debug_source_bind_set_var (gimple dbg, tree var)
+gimple_debug_source_bind_set_var (gimple *dbg, tree var)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4629,7 +4629,7 @@ gimple_debug_source_bind_set_var (gimple dbg, tree var)
    statement.  */
 
 static inline void
-gimple_debug_source_bind_set_value (gimple dbg, tree value)
+gimple_debug_source_bind_set_value (gimple *dbg, tree value)
 {
   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
@@ -4639,7 +4639,7 @@ gimple_debug_source_bind_set_value (gimple dbg, tree value)
 /* Return the line number for EXPR, or return -1 if we have no line
    number information for it.  */
 static inline int
-get_lineno (const_gimple stmt)
+get_lineno (const gimple *stmt)
 {
   location_t loc;
 
@@ -4656,7 +4656,7 @@ get_lineno (const_gimple stmt)
 /* Return a pointer to the body for the OMP statement GS.  */
 
 static inline gimple_seq *
-gimple_omp_body_ptr (gimple gs)
+gimple_omp_body_ptr (gimple *gs)
 {
   return &static_cast <gimple_statement_omp *> (gs)->body;
 }
@@ -4664,7 +4664,7 @@ gimple_omp_body_ptr (gimple gs)
 /* Return the body for the OMP statement GS.  */
 
 static inline gimple_seq
-gimple_omp_body (gimple gs)
+gimple_omp_body (gimple *gs)
 {
   return *gimple_omp_body_ptr (gs);
 }
@@ -4672,7 +4672,7 @@ gimple_omp_body (gimple gs)
 /* Set BODY to be the body for the OMP statement GS.  */
 
 static inline void
-gimple_omp_set_body (gimple gs, gimple_seq body)
+gimple_omp_set_body (gimple *gs, gimple_seq body)
 {
   static_cast <gimple_statement_omp *> (gs)->body = body;
 }
@@ -4708,7 +4708,7 @@ gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
 /* Return the kind of the OMP_FOR statemement G.  */
 
 static inline int
-gimple_omp_for_kind (const_gimple g)
+gimple_omp_for_kind (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK);
@@ -4729,7 +4729,7 @@ gimple_omp_for_set_kind (gomp_for *g, int kind)
    GF_OMP_FOR_COMBINED flag set.  */
 
 static inline bool
-gimple_omp_for_combined_p (const_gimple g)
+gimple_omp_for_combined_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0;
@@ -4753,7 +4753,7 @@ gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
    GF_OMP_FOR_COMBINED_INTO flag set.  */
 
 static inline bool
-gimple_omp_for_combined_into_p (const_gimple g)
+gimple_omp_for_combined_into_p (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
   return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0;
@@ -4776,7 +4776,7 @@ gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
 /* Return the clauses associated with the OMP_FOR statement GS.  */
 
 static inline tree
-gimple_omp_for_clauses (const_gimple gs)
+gimple_omp_for_clauses (const gimple *gs)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   return omp_for_stmt->clauses;
@@ -4787,7 +4787,7 @@ gimple_omp_for_clauses (const_gimple gs)
    GS.  */
 
 static inline tree *
-gimple_omp_for_clauses_ptr (gimple gs)
+gimple_omp_for_clauses_ptr (gimple *gs)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return &omp_for_stmt->clauses;
@@ -4798,7 +4798,7 @@ gimple_omp_for_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_for_set_clauses (gimple gs, tree clauses)
+gimple_omp_for_set_clauses (gimple *gs, tree clauses)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   omp_for_stmt->clauses = clauses;
@@ -4808,7 +4808,7 @@ gimple_omp_for_set_clauses (gimple gs, tree clauses)
 /* Get the collapse count of the OMP_FOR statement GS.  */
 
 static inline size_t
-gimple_omp_for_collapse (gimple gs)
+gimple_omp_for_collapse (gimple *gs)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return omp_for_stmt->collapse;
@@ -4818,7 +4818,7 @@ gimple_omp_for_collapse (gimple gs)
 /* Return the condition code associated with the OMP_FOR statement GS.  */
 
 static inline enum tree_code
-gimple_omp_for_cond (const_gimple gs, size_t i)
+gimple_omp_for_cond (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4829,7 +4829,7 @@ gimple_omp_for_cond (const_gimple gs, size_t i)
 /* Set COND to be the condition code for the OMP_FOR statement GS.  */
 
 static inline void
-gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
+gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
@@ -4841,7 +4841,7 @@ gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
 /* Return the index variable for the OMP_FOR statement GS.  */
 
 static inline tree
-gimple_omp_for_index (const_gimple gs, size_t i)
+gimple_omp_for_index (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4852,7 +4852,7 @@ gimple_omp_for_index (const_gimple gs, size_t i)
 /* Return a pointer to the index variable for the OMP_FOR statement GS.  */
 
 static inline tree *
-gimple_omp_for_index_ptr (gimple gs, size_t i)
+gimple_omp_for_index_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4863,7 +4863,7 @@ gimple_omp_for_index_ptr (gimple gs, size_t i)
 /* Set INDEX to be the index variable for the OMP_FOR statement GS.  */
 
 static inline void
-gimple_omp_for_set_index (gimple gs, size_t i, tree index)
+gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4874,7 +4874,7 @@ gimple_omp_for_set_index (gimple gs, size_t i, tree index)
 /* Return the initial value for the OMP_FOR statement GS.  */
 
 static inline tree
-gimple_omp_for_initial (const_gimple gs, size_t i)
+gimple_omp_for_initial (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4885,7 +4885,7 @@ gimple_omp_for_initial (const_gimple gs, size_t i)
 /* Return a pointer to the initial value for the OMP_FOR statement GS.  */
 
 static inline tree *
-gimple_omp_for_initial_ptr (gimple gs, size_t i)
+gimple_omp_for_initial_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4896,7 +4896,7 @@ gimple_omp_for_initial_ptr (gimple gs, size_t i)
 /* Set INITIAL to be the initial value for the OMP_FOR statement GS.  */
 
 static inline void
-gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
+gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4907,7 +4907,7 @@ gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
 /* Return the final value for the OMP_FOR statement GS.  */
 
 static inline tree
-gimple_omp_for_final (const_gimple gs, size_t i)
+gimple_omp_for_final (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4918,7 +4918,7 @@ gimple_omp_for_final (const_gimple gs, size_t i)
 /* Return a pointer to the final value for the OMP_FOR statement GS.  */
 
 static inline tree *
-gimple_omp_for_final_ptr (gimple gs, size_t i)
+gimple_omp_for_final_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4929,7 +4929,7 @@ gimple_omp_for_final_ptr (gimple gs, size_t i)
 /* Set FINAL to be the final value for the OMP_FOR statement GS.  */
 
 static inline void
-gimple_omp_for_set_final (gimple gs, size_t i, tree final)
+gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4940,7 +4940,7 @@ gimple_omp_for_set_final (gimple gs, size_t i, tree final)
 /* Return the increment value for the OMP_FOR statement GS.  */
 
 static inline tree
-gimple_omp_for_incr (const_gimple gs, size_t i)
+gimple_omp_for_incr (const gimple *gs, size_t i)
 {
   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4951,7 +4951,7 @@ gimple_omp_for_incr (const_gimple gs, size_t i)
 /* Return a pointer to the increment value for the OMP_FOR statement GS.  */
 
 static inline tree *
-gimple_omp_for_incr_ptr (gimple gs, size_t i)
+gimple_omp_for_incr_ptr (gimple *gs, size_t i)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4962,7 +4962,7 @@ gimple_omp_for_incr_ptr (gimple gs, size_t i)
 /* Set INCR to be the increment value for the OMP_FOR statement GS.  */
 
 static inline void
-gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
+gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
@@ -4974,7 +4974,7 @@ gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
    statement GS starts.  */
 
 static inline gimple_seq *
-gimple_omp_for_pre_body_ptr (gimple gs)
+gimple_omp_for_pre_body_ptr (gimple *gs)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   return &omp_for_stmt->pre_body;
@@ -4985,7 +4985,7 @@ gimple_omp_for_pre_body_ptr (gimple gs)
    statement GS starts.  */
 
 static inline gimple_seq
-gimple_omp_for_pre_body (gimple gs)
+gimple_omp_for_pre_body (gimple *gs)
 {
   return *gimple_omp_for_pre_body_ptr (gs);
 }
@@ -4995,7 +4995,7 @@ gimple_omp_for_pre_body (gimple gs)
    OMP_FOR statement GS starts.  */
 
 static inline void
-gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
+gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body)
 {
   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
   omp_for_stmt->pre_body = pre_body;
@@ -5005,7 +5005,7 @@ gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
 /* Return the clauses associated with OMP_PARALLEL GS.  */
 
 static inline tree
-gimple_omp_parallel_clauses (const_gimple gs)
+gimple_omp_parallel_clauses (const gimple *gs)
 {
   const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs);
   return omp_parallel_stmt->clauses;
@@ -5091,7 +5091,7 @@ gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt,
 /* Return the clauses associated with OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_clauses (const_gimple gs)
+gimple_omp_task_clauses (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->clauses;
@@ -5101,7 +5101,7 @@ gimple_omp_task_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_clauses_ptr (gimple gs)
+gimple_omp_task_clauses_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->clauses;
@@ -5112,7 +5112,7 @@ gimple_omp_task_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_task_set_clauses (gimple gs, tree clauses)
+gimple_omp_task_set_clauses (gimple *gs, tree clauses)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->clauses = clauses;
@@ -5122,7 +5122,7 @@ gimple_omp_task_set_clauses (gimple gs, tree clauses)
 /* Return the child function used to hold the body of OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_child_fn (const_gimple gs)
+gimple_omp_task_child_fn (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->child_fn;
@@ -5132,7 +5132,7 @@ gimple_omp_task_child_fn (const_gimple gs)
    OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_child_fn_ptr (gimple gs)
+gimple_omp_task_child_fn_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->child_fn;
@@ -5142,7 +5142,7 @@ gimple_omp_task_child_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
+gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->child_fn = child_fn;
@@ -5153,7 +5153,7 @@ gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
    from the parent to the children threads in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_data_arg (const_gimple gs)
+gimple_omp_task_data_arg (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->data_arg;
@@ -5163,7 +5163,7 @@ gimple_omp_task_data_arg (const_gimple gs)
 /* Return a pointer to the data argument for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_data_arg_ptr (gimple gs)
+gimple_omp_task_data_arg_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->data_arg;
@@ -5173,7 +5173,7 @@ gimple_omp_task_data_arg_ptr (gimple gs)
 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
+gimple_omp_task_set_data_arg (gimple *gs, tree data_arg)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->data_arg = data_arg;
@@ -5183,7 +5183,7 @@ gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
 /* Return the clauses associated with OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_taskreg_clauses (const_gimple gs)
+gimple_omp_taskreg_clauses (const gimple *gs)
 {
   const gimple_statement_omp_taskreg *omp_taskreg_stmt
     = as_a <const gimple_statement_omp_taskreg *> (gs);
@@ -5194,7 +5194,7 @@ gimple_omp_taskreg_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_taskreg_clauses_ptr (gimple gs)
+gimple_omp_taskreg_clauses_ptr (gimple *gs)
 {
   gimple_statement_omp_taskreg *omp_taskreg_stmt
     = as_a <gimple_statement_omp_taskreg *> (gs);
@@ -5206,7 +5206,7 @@ gimple_omp_taskreg_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
+gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
 {
   gimple_statement_omp_taskreg *omp_taskreg_stmt
     = as_a <gimple_statement_omp_taskreg *> (gs);
@@ -5217,7 +5217,7 @@ gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
 /* Return the child function used to hold the body of OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_taskreg_child_fn (const_gimple gs)
+gimple_omp_taskreg_child_fn (const gimple *gs)
 {
   const gimple_statement_omp_taskreg *omp_taskreg_stmt
     = as_a <const gimple_statement_omp_taskreg *> (gs);
@@ -5228,7 +5228,7 @@ gimple_omp_taskreg_child_fn (const_gimple gs)
    OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_taskreg_child_fn_ptr (gimple gs)
+gimple_omp_taskreg_child_fn_ptr (gimple *gs)
 {
   gimple_statement_omp_taskreg *omp_taskreg_stmt
     = as_a <gimple_statement_omp_taskreg *> (gs);
@@ -5239,7 +5239,7 @@ gimple_omp_taskreg_child_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
+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);
@@ -5251,7 +5251,7 @@ gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
    from the parent to the children threads in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_taskreg_data_arg (const_gimple gs)
+gimple_omp_taskreg_data_arg (const gimple *gs)
 {
   const gimple_statement_omp_taskreg *omp_taskreg_stmt
     = as_a <const gimple_statement_omp_taskreg *> (gs);
@@ -5262,7 +5262,7 @@ gimple_omp_taskreg_data_arg (const_gimple gs)
 /* Return a pointer to the data argument for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_taskreg_data_arg_ptr (gimple gs)
+gimple_omp_taskreg_data_arg_ptr (gimple *gs)
 {
   gimple_statement_omp_taskreg *omp_taskreg_stmt
     = as_a <gimple_statement_omp_taskreg *> (gs);
@@ -5273,7 +5273,7 @@ gimple_omp_taskreg_data_arg_ptr (gimple gs)
 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
+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);
@@ -5284,7 +5284,7 @@ gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
 /* Return the copy function used to hold the body of OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_copy_fn (const_gimple gs)
+gimple_omp_task_copy_fn (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->copy_fn;
@@ -5294,7 +5294,7 @@ gimple_omp_task_copy_fn (const_gimple gs)
    OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_copy_fn_ptr (gimple gs)
+gimple_omp_task_copy_fn_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->copy_fn;
@@ -5304,7 +5304,7 @@ gimple_omp_task_copy_fn_ptr (gimple gs)
 /* Set CHILD_FN to be the copy function for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
+gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->copy_fn = copy_fn;
@@ -5314,7 +5314,7 @@ gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
 /* Return size of the data block in bytes in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_arg_size (const_gimple gs)
+gimple_omp_task_arg_size (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->arg_size;
@@ -5324,7 +5324,7 @@ gimple_omp_task_arg_size (const_gimple gs)
 /* Return a pointer to the data block size for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_arg_size_ptr (gimple gs)
+gimple_omp_task_arg_size_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->arg_size;
@@ -5334,7 +5334,7 @@ gimple_omp_task_arg_size_ptr (gimple gs)
 /* Set ARG_SIZE to be the data block size for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
+gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->arg_size = arg_size;
@@ -5344,7 +5344,7 @@ gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
 /* Return align of the data block in bytes in OMP_TASK GS.  */
 
 static inline tree
-gimple_omp_task_arg_align (const_gimple gs)
+gimple_omp_task_arg_align (const gimple *gs)
 {
   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
   return omp_task_stmt->arg_align;
@@ -5354,7 +5354,7 @@ gimple_omp_task_arg_align (const_gimple gs)
 /* Return a pointer to the data block align for OMP_TASK GS.  */
 
 static inline tree *
-gimple_omp_task_arg_align_ptr (gimple gs)
+gimple_omp_task_arg_align_ptr (gimple *gs)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   return &omp_task_stmt->arg_align;
@@ -5364,7 +5364,7 @@ gimple_omp_task_arg_align_ptr (gimple gs)
 /* Set ARG_SIZE to be the data block align for OMP_TASK GS.  */
 
 static inline void
-gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
+gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
 {
   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
   omp_task_stmt->arg_align = arg_align;
@@ -5374,7 +5374,7 @@ gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
 /* Return the clauses associated with OMP_SINGLE GS.  */
 
 static inline tree
-gimple_omp_single_clauses (const_gimple gs)
+gimple_omp_single_clauses (const gimple *gs)
 {
   const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
   return omp_single_stmt->clauses;
@@ -5384,7 +5384,7 @@ gimple_omp_single_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_SINGLE GS.  */
 
 static inline tree *
-gimple_omp_single_clauses_ptr (gimple gs)
+gimple_omp_single_clauses_ptr (gimple *gs)
 {
   gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
   return &omp_single_stmt->clauses;
@@ -5403,7 +5403,7 @@ gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
 /* Return the clauses associated with OMP_TARGET GS.  */
 
 static inline tree
-gimple_omp_target_clauses (const_gimple gs)
+gimple_omp_target_clauses (const gimple *gs)
 {
   const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
   return omp_target_stmt->clauses;
@@ -5413,7 +5413,7 @@ gimple_omp_target_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TARGET GS.  */
 
 static inline tree *
-gimple_omp_target_clauses_ptr (gimple gs)
+gimple_omp_target_clauses_ptr (gimple *gs)
 {
   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
   return &omp_target_stmt->clauses;
@@ -5433,7 +5433,7 @@ gimple_omp_target_set_clauses (gomp_target *omp_target_stmt,
 /* Return the kind of the OMP_TARGET G.  */
 
 static inline int
-gimple_omp_target_kind (const_gimple g)
+gimple_omp_target_kind (const gimple *g)
 {
   GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
   return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK);
@@ -5510,7 +5510,7 @@ gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt,
 /* Return the clauses associated with OMP_TEAMS GS.  */
 
 static inline tree
-gimple_omp_teams_clauses (const_gimple gs)
+gimple_omp_teams_clauses (const gimple *gs)
 {
   const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
   return omp_teams_stmt->clauses;
@@ -5520,7 +5520,7 @@ gimple_omp_teams_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_TEAMS GS.  */
 
 static inline tree *
-gimple_omp_teams_clauses_ptr (gimple gs)
+gimple_omp_teams_clauses_ptr (gimple *gs)
 {
   gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
   return &omp_teams_stmt->clauses;
@@ -5539,7 +5539,7 @@ gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
 /* Return the clauses associated with OMP_SECTIONS GS.  */
 
 static inline tree
-gimple_omp_sections_clauses (const_gimple gs)
+gimple_omp_sections_clauses (const gimple *gs)
 {
   const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
   return omp_sections_stmt->clauses;
@@ -5549,7 +5549,7 @@ gimple_omp_sections_clauses (const_gimple gs)
 /* Return a pointer to the clauses associated with OMP_SECTIONS GS.  */
 
 static inline tree *
-gimple_omp_sections_clauses_ptr (gimple gs)
+gimple_omp_sections_clauses_ptr (gimple *gs)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   return &omp_sections_stmt->clauses;
@@ -5560,7 +5560,7 @@ gimple_omp_sections_clauses_ptr (gimple gs)
    GS.  */
 
 static inline void
-gimple_omp_sections_set_clauses (gimple gs, tree clauses)
+gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   omp_sections_stmt->clauses = clauses;
@@ -5571,7 +5571,7 @@ gimple_omp_sections_set_clauses (gimple gs, tree clauses)
    in GS.  */
 
 static inline tree
-gimple_omp_sections_control (const_gimple gs)
+gimple_omp_sections_control (const gimple *gs)
 {
   const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
   return omp_sections_stmt->control;
@@ -5582,7 +5582,7 @@ gimple_omp_sections_control (const_gimple gs)
    GS.  */
 
 static inline tree *
-gimple_omp_sections_control_ptr (gimple gs)
+gimple_omp_sections_control_ptr (gimple *gs)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   return &omp_sections_stmt->control;
@@ -5593,7 +5593,7 @@ gimple_omp_sections_control_ptr (gimple gs)
    GIMPLE_OMP_SECTIONS in GS.  */
 
 static inline void
-gimple_omp_sections_set_control (gimple gs, tree control)
+gimple_omp_sections_set_control (gimple *gs, tree control)
 {
   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
   omp_sections_stmt->control = control;
@@ -5828,7 +5828,7 @@ gimple_return_set_retval (greturn *gs, tree retval)
 /* Return the return bounds for GIMPLE_RETURN GS.  */
 
 static inline tree
-gimple_return_retbnd (const_gimple gs)
+gimple_return_retbnd (const gimple *gs)
 {
   GIMPLE_CHECK (gs, GIMPLE_RETURN);
   return gimple_op (gs, 1);
@@ -5838,7 +5838,7 @@ gimple_return_retbnd (const_gimple gs)
 /* Set RETVAL to be the return bounds for GIMPLE_RETURN GS.  */
 
 static inline void
-gimple_return_set_retbnd (gimple gs, tree retval)
+gimple_return_set_retbnd (gimple *gs, tree retval)
 {
   GIMPLE_CHECK (gs, GIMPLE_RETURN);
   gimple_set_op (gs, 1, retval);
@@ -5867,7 +5867,7 @@ gimple_return_set_retbnd (gimple gs, tree retval)
     case GIMPLE_OMP_CONTINUE
 
 static inline bool
-is_gimple_omp (const_gimple stmt)
+is_gimple_omp (const gimple *stmt)
 {
   switch (gimple_code (stmt))
     {
@@ -5882,7 +5882,7 @@ is_gimple_omp (const_gimple stmt)
    specifically.  */
 
 static inline bool
-is_gimple_omp_oacc (const_gimple stmt)
+is_gimple_omp_oacc (const gimple *stmt)
 {
   gcc_assert (is_gimple_omp (stmt));
   switch (gimple_code (stmt))
@@ -5916,7 +5916,7 @@ is_gimple_omp_oacc (const_gimple stmt)
 /* Return true if the OMP gimple statement STMT is offloaded.  */
 
 static inline bool
-is_gimple_omp_offloaded (const_gimple stmt)
+is_gimple_omp_offloaded (const gimple *stmt)
 {
   gcc_assert (is_gimple_omp (stmt));
   switch (gimple_code (stmt))
@@ -5940,7 +5940,7 @@ is_gimple_omp_offloaded (const_gimple stmt)
 /* Returns TRUE if statement G is a GIMPLE_NOP.  */
 
 static inline bool
-gimple_nop_p (const_gimple g)
+gimple_nop_p (const gimple *g)
 {
   return gimple_code (g) == GIMPLE_NOP;
 }
@@ -5949,7 +5949,7 @@ gimple_nop_p (const_gimple g)
 /* Return true if GS is a GIMPLE_RESX.  */
 
 static inline bool
-is_gimple_resx (const_gimple gs)
+is_gimple_resx (const gimple *gs)
 {
   return gimple_code (gs) == GIMPLE_RESX;
 }
@@ -5958,7 +5958,7 @@ is_gimple_resx (const_gimple gs)
    void_type_node if the statement computes nothing.  */
 
 static inline tree
-gimple_expr_type (const_gimple stmt)
+gimple_expr_type (const gimple *stmt)
 {
   enum gimple_code code = gimple_code (stmt);
   /* In general we want to pass out a type that can be substituted
@@ -6023,7 +6023,7 @@ gimple_alloc_kind (enum gimple_code code)
    by annotate_all_with_location.  */
 
 static inline bool
-gimple_do_not_emit_location_p (gimple g)
+gimple_do_not_emit_location_p (gimple *g)
 {
   return gimple_plf (g, GF_PLF_1);
 }
@@ -6032,7 +6032,7 @@ gimple_do_not_emit_location_p (gimple g)
    annotate_one_with_location.  */
 
 static inline void
-gimple_set_do_not_emit_location (gimple g)
+gimple_set_do_not_emit_location (gimple *g)
 {
   /* The PLF flags are initialized to 0 when a new tuple is created,
      so no need to initialize it anywhere.  */