Import stripped Arm GNU Toolchain 13.2.Rel1HEADumineko

https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads

Change-Id: I7303388733328cd98ab9aa3c30236db67f2e9e9c

1 files changed, 6911 insertions, 0 deletions

diff --git a/lib/gcc/arm-none-eabi/13.2.1/plugin/include/gimple.h b/lib/gcc/arm-none-eabi/13.2.1/plugin/include/gimple.h
new file mode 100644
index 0000000..081d18e
--- /dev/null
+++ b/lib/gcc/arm-none-eabi/13.2.1/plugin/include/gimple.h
@@ -0,0 +1,6911 @@
+/* Gimple IR definitions.
+
+   Copyright (C) 2007-2023 Free Software Foundation, Inc.
+   Contributed by Aldy Hernandez <aldyh@redhat.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef GCC_GIMPLE_H
+#define GCC_GIMPLE_H
+
+#include "tree-ssa-alias.h"
+#include "gimple-expr.h"
+
+typedef gimple *gimple_seq_node;
+
+enum gimple_code {
+#define DEFGSCODE(SYM, STRING, STRUCT)	SYM,
+#include "gimple.def"
+#undef DEFGSCODE
+    LAST_AND_UNUSED_GIMPLE_CODE
+};
+
+extern const char *const gimple_code_name[];
+extern const unsigned char gimple_rhs_class_table[];
+
+/* Strip the outermost pointer, from tr1/type_traits.  */
+template<typename T> struct remove_pointer { typedef T type; };
+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,        \
+                                 const char *, enum gimple_code,           \
+				 enum tree_code) ATTRIBUTE_NORETURN 	   \
+						 ATTRIBUTE_COLD;
+
+#define GIMPLE_CHECK(GS, CODE)						\
+  do {									\
+    const gimple *__gs = (GS);						\
+    if (gimple_code (__gs) != (CODE))					\
+      gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,	\
+	  		   (CODE), ERROR_MARK);				\
+  } while (0)
+template <typename T>
+inline T
+GIMPLE_CHECK2(const gimple *gs,
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+	      const char *file = __builtin_FILE (),
+	      int line = __builtin_LINE (),
+	      const char *fun = __builtin_FUNCTION ())
+#else
+	      const char *file = __FILE__,
+	      int line = __LINE__,
+	      const char *fun = NULL)
+#endif
+{
+  T ret = dyn_cast <T> (gs);
+  if (!ret)
+    gimple_check_failed (gs, file, line, fun,
+			 remove_pointer<T>::type::code_, ERROR_MARK);
+  return ret;
+}
+template <typename T>
+inline T
+GIMPLE_CHECK2(gimple *gs,
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+	      const char *file = __builtin_FILE (),
+	      int line = __builtin_LINE (),
+	      const char *fun = __builtin_FUNCTION ())
+#else
+	      const char *file = __FILE__,
+	      int line = __LINE__,
+	      const char *fun = NULL)
+#endif
+{
+  T ret = dyn_cast <T> (gs);
+  if (!ret)
+    gimple_check_failed (gs, file, line, fun,
+			 remove_pointer<T>::type::code_, ERROR_MARK);
+  return ret;
+}
+#else  /* not ENABLE_GIMPLE_CHECKING  */
+#define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR)))
+#define GIMPLE_CHECK(GS, CODE)			(void)0
+template <typename T>
+inline T
+GIMPLE_CHECK2(gimple *gs)
+{
+  return as_a <T> (gs);
+}
+template <typename T>
+inline T
+GIMPLE_CHECK2(const gimple *gs)
+{
+  return as_a <T> (gs);
+}
+#endif
+
+/* Class of GIMPLE expressions suitable for the RHS of assignments.  See
+   get_gimple_rhs_class.  */
+enum gimple_rhs_class
+{
+  GIMPLE_INVALID_RHS,	/* The expression cannot be used on the RHS.  */
+  GIMPLE_TERNARY_RHS,	/* The expression is a ternary operation.  */
+  GIMPLE_BINARY_RHS,	/* The expression is a binary operation.  */
+  GIMPLE_UNARY_RHS,	/* The expression is a unary operation.  */
+  GIMPLE_SINGLE_RHS	/* The expression is a single object (an SSA
+			   name, a _DECL, a _REF, etc.  */
+};
+
+/* Specific flags for individual GIMPLE statements.  These flags are
+   always stored in gimple.subcode and they may only be
+   defined for statement codes that do not use subcodes.
+
+   Values for the masks can overlap as long as the overlapping values
+   are never used in the same statement class.
+
+   The maximum mask value that can be defined is 1 << 15 (i.e., each
+   statement code can hold up to 16 bitflags).
+
+   Keep this list sorted.  */
+enum gf_mask {
+    GF_ASM_INPUT		= 1 << 0,
+    GF_ASM_VOLATILE		= 1 << 1,
+    GF_ASM_INLINE		= 1 << 2,
+    GF_CALL_FROM_THUNK		= 1 << 0,
+    GF_CALL_RETURN_SLOT_OPT	= 1 << 1,
+    GF_CALL_TAILCALL		= 1 << 2,
+    GF_CALL_VA_ARG_PACK		= 1 << 3,
+    GF_CALL_NOTHROW		= 1 << 4,
+    GF_CALL_ALLOCA_FOR_VAR	= 1 << 5,
+    GF_CALL_INTERNAL		= 1 << 6,
+    GF_CALL_CTRL_ALTERING       = 1 << 7,
+    GF_CALL_MUST_TAIL_CALL	= 1 << 9,
+    GF_CALL_BY_DESCRIPTOR	= 1 << 10,
+    GF_CALL_NOCF_CHECK		= 1 << 11,
+    GF_CALL_FROM_NEW_OR_DELETE	= 1 << 12,
+    GF_OMP_PARALLEL_COMBINED	= 1 << 0,
+    GF_OMP_TASK_TASKLOOP	= 1 << 0,
+    GF_OMP_TASK_TASKWAIT	= 1 << 1,
+    GF_OMP_FOR_KIND_MASK	= (1 << 3) - 1,
+    GF_OMP_FOR_KIND_FOR		= 0,
+    GF_OMP_FOR_KIND_DISTRIBUTE	= 1,
+    GF_OMP_FOR_KIND_TASKLOOP	= 2,
+    GF_OMP_FOR_KIND_OACC_LOOP	= 4,
+    GF_OMP_FOR_KIND_SIMD	= 5,
+    GF_OMP_FOR_COMBINED		= 1 << 3,
+    GF_OMP_FOR_COMBINED_INTO	= 1 << 4,
+    GF_OMP_TARGET_KIND_MASK	= (1 << 5) - 1,
+    GF_OMP_TARGET_KIND_REGION	= 0,
+    GF_OMP_TARGET_KIND_DATA	= 1,
+    GF_OMP_TARGET_KIND_UPDATE	= 2,
+    GF_OMP_TARGET_KIND_ENTER_DATA = 3,
+    GF_OMP_TARGET_KIND_EXIT_DATA = 4,
+    GF_OMP_TARGET_KIND_OACC_PARALLEL = 5,
+    GF_OMP_TARGET_KIND_OACC_KERNELS = 6,
+    GF_OMP_TARGET_KIND_OACC_SERIAL = 7,
+    GF_OMP_TARGET_KIND_OACC_DATA = 8,
+    GF_OMP_TARGET_KIND_OACC_UPDATE = 9,
+    GF_OMP_TARGET_KIND_OACC_ENTER_DATA = 10,
+    GF_OMP_TARGET_KIND_OACC_EXIT_DATA = 11,
+    GF_OMP_TARGET_KIND_OACC_DECLARE = 12,
+    GF_OMP_TARGET_KIND_OACC_HOST_DATA = 13,
+    /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
+       decomposed part, parallelized.  */
+    GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED = 14,
+    /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
+       decomposed part, "gang-single".  */
+    GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE = 15,
+    /* A 'GF_OMP_TARGET_KIND_OACC_DATA' representing an OpenACC 'kernels'
+       decomposed parts' 'data' construct.  */
+    GF_OMP_TARGET_KIND_OACC_DATA_KERNELS = 16,
+    GF_OMP_TEAMS_HOST		= 1 << 0,
+
+    /* True on an GIMPLE_OMP_RETURN statement if the return does not require
+       a thread synchronization via some sort of barrier.  The exact barrier
+       that would otherwise be emitted is dependent on the OMP statement with
+       which this return is associated.  */
+    GF_OMP_RETURN_NOWAIT	= 1 << 0,
+
+    GF_OMP_SECTION_LAST		= 1 << 0,
+    GF_OMP_ORDERED_STANDALONE   = 1 << 0,
+    GF_OMP_ATOMIC_MEMORY_ORDER  = (1 << 6) - 1,
+    GF_OMP_ATOMIC_NEED_VALUE	= 1 << 6,
+    GF_OMP_ATOMIC_WEAK		= 1 << 7,
+    GF_PREDICT_TAKEN		= 1 << 15
+};
+
+/* This subcode tells apart different kinds of stmts that are not used
+   for codegen, but rather to retain debug information.  */
+enum gimple_debug_subcode {
+  GIMPLE_DEBUG_BIND = 0,
+  GIMPLE_DEBUG_SOURCE_BIND = 1,
+  GIMPLE_DEBUG_BEGIN_STMT = 2,
+  GIMPLE_DEBUG_INLINE_ENTRY = 3
+};
+
+/* Masks for selecting a pass local flag (PLF) to work on.  These
+   masks are used by gimple_set_plf and gimple_plf.  */
+enum plf_mask {
+    GF_PLF_1	= 1 << 0,
+    GF_PLF_2	= 1 << 1
+};
+
+/* Data structure definitions for GIMPLE tuples.  NOTE: word markers
+   are for 64 bit hosts.  */
+
+struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
+	    chain_next ("%h.next"), variable_size))
+  gimple
+{
+  /* [ WORD 1 ]
+     Main identifying code for a tuple.  */
+  ENUM_BITFIELD(gimple_code) code : 8;
+
+  /* Nonzero if a warning should not be emitted on this tuple.  */
+  unsigned int no_warning	: 1;
+
+  /* Nonzero if this tuple has been visited.  Passes are responsible
+     for clearing this bit before using it.  */
+  unsigned int visited		: 1;
+
+  /* Nonzero if this tuple represents a non-temporal move.  */
+  unsigned int nontemporal_move	: 1;
+
+  /* Pass local flags.  These flags are free for any pass to use as
+     they see fit.  Passes should not assume that these flags contain
+     any useful value when the pass starts.  Any initial state that
+     the pass requires should be set on entry to the pass.  See
+     gimple_set_plf and gimple_plf for usage.  */
+  unsigned int plf		: 2;
+
+  /* Nonzero if this statement has been modified and needs to have its
+     operands rescanned.  */
+  unsigned modified 		: 1;
+
+  /* Nonzero if this statement contains volatile operands.  */
+  unsigned has_volatile_ops 	: 1;
+
+  /* Padding to get subcode to 16 bit alignment.  */
+  unsigned pad			: 1;
+
+  /* The SUBCODE field can be used for tuple-specific flags for tuples
+     that do not require subcodes.  Note that SUBCODE should be at
+     least as wide as tree codes, as several tuples store tree codes
+     in there.  */
+  unsigned int subcode		: 16;
+
+  /* UID of this statement.  This is used by passes that want to
+     assign IDs to statements.  It must be assigned and used by each
+     pass.  By default it should be assumed to contain garbage.  */
+  unsigned uid;
+
+  /* [ WORD 2 ]
+     Locus information for debug info.  */
+  location_t location;
+
+  /* Number of operands in this tuple.  */
+  unsigned num_ops;
+
+  /* [ WORD 3 ]
+     Basic block holding this statement.  */
+  basic_block bb;
+
+  /* [ WORD 4-5 ]
+     Linked lists of gimple statements.  The next pointers form
+     a NULL terminated list, the prev pointers are a cyclic list.
+     A gimple statement is hence also a double-ended list of
+     statements, with the pointer itself being the first element,
+     and the prev pointer being the last.  */
+  gimple *next;
+  gimple *GTY((skip)) prev;
+};
+
+
+/* Base structure for tuples with operands.  */
+
+/* This gimple subclass has no tag value.  */
+struct GTY(())
+  gimple_statement_with_ops_base : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]
+     SSA operand vectors.  NOTE: It should be possible to
+     amalgamate these vectors with the operand vector OP.  However,
+     the SSA operand vectors are organized differently and contain
+     more information (like immediate use chaining).  */
+  struct use_optype_d GTY((skip (""))) *use_ops;
+};
+
+
+/* Statements that take register operands.  */
+
+struct GTY((tag("GSS_WITH_OPS")))
+  gimple_statement_with_ops : public gimple_statement_with_ops_base
+{
+  /* [ WORD 1-7 ] : base class */
+
+  /* [ WORD 8 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.num_ops"))) op[1];
+};
+
+
+/* Base for statements that take both memory and register operands.  */
+
+struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
+  gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base
+{
+  /* [ WORD 1-7 ] : base class */
+
+  /* [ WORD 8-9 ]
+     Virtual operands for this statement.  The GC will pick them
+     up via the ssa_names array.  */
+  tree GTY((skip (""))) vdef;
+  tree GTY((skip (""))) vuse;
+};
+
+
+/* Statements that take both memory and register operands.  */
+
+struct GTY((tag("GSS_WITH_MEM_OPS")))
+  gimple_statement_with_memory_ops :
+    public gimple_statement_with_memory_ops_base
+{
+  /* [ WORD 1-9 ] : base class */
+
+  /* [ WORD 10 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.num_ops"))) op[1];
+};
+
+
+/* Call statements that take both memory and register operands.  */
+
+struct GTY((tag("GSS_CALL")))
+  gcall : public gimple_statement_with_memory_ops_base
+{
+  /* [ WORD 1-9 ] : base class */
+
+  /* [ WORD 10-13 ]  */
+  struct pt_solution call_used;
+  struct pt_solution call_clobbered;
+
+  /* [ WORD 14 ]  */
+  union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) {
+    tree GTY ((tag ("0"))) fntype;
+    enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn;
+  } u;
+
+  /* [ WORD 15 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.num_ops"))) op[1];
+
+  static const enum gimple_code code_ = GIMPLE_CALL;
+};
+
+
+/* OMP statements.  */
+
+struct GTY((tag("GSS_OMP")))
+  gimple_statement_omp : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]  */
+  gimple_seq body;
+};
+
+
+/* GIMPLE_BIND */
+
+struct GTY((tag("GSS_BIND")))
+  gbind : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]
+     Variables declared in this scope.  */
+  tree vars;
+
+  /* [ WORD 8 ]
+     This is different than the BLOCK field in gimple,
+     which is analogous to TREE_BLOCK (i.e., the lexical block holding
+     this statement).  This field is the equivalent of BIND_EXPR_BLOCK
+     in tree land (i.e., the lexical scope defined by this bind).  See
+     gimple-low.cc.  */
+  tree block;
+
+  /* [ WORD 9 ]  */
+  gimple_seq body;
+};
+
+
+/* GIMPLE_CATCH */
+
+struct GTY((tag("GSS_CATCH")))
+  gcatch : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]  */
+  tree types;
+
+  /* [ WORD 8 ]  */
+  gimple_seq handler;
+};
+
+
+/* GIMPLE_EH_FILTER */
+
+struct GTY((tag("GSS_EH_FILTER")))
+  geh_filter : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]
+     Filter types.  */
+  tree types;
+
+  /* [ WORD 8 ]
+     Failure actions.  */
+  gimple_seq failure;
+};
+
+/* GIMPLE_EH_ELSE */
+
+struct GTY((tag("GSS_EH_ELSE")))
+  geh_else : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7,8 ] */
+  gimple_seq n_body, e_body;
+};
+
+/* GIMPLE_EH_MUST_NOT_THROW */
+
+struct GTY((tag("GSS_EH_MNT")))
+  geh_mnt : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ] Abort function decl.  */
+  tree fndecl;
+};
+
+/* GIMPLE_PHI */
+
+struct GTY((tag("GSS_PHI")))
+  gphi : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]  */
+  unsigned capacity;
+  unsigned nargs;
+
+  /* [ WORD 8 ]  */
+  tree result;
+
+  /* [ WORD 9 ]  */
+  struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
+};
+
+
+/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
+
+struct GTY((tag("GSS_EH_CTRL")))
+  gimple_statement_eh_ctrl : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]
+     Exception region number.  */
+  int region;
+};
+
+struct GTY((tag("GSS_EH_CTRL")))
+  gresx : public gimple_statement_eh_ctrl
+{
+  /* No extra fields; adds invariant:
+       stmt->code == GIMPLE_RESX.  */
+};
+
+struct GTY((tag("GSS_EH_CTRL")))
+  geh_dispatch : public gimple_statement_eh_ctrl
+{
+  /* No extra fields; adds invariant:
+       stmt->code == GIMPLE_EH_DISPATH.  */
+};
+
+
+/* GIMPLE_TRY */
+
+struct GTY((tag("GSS_TRY")))
+  gtry : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]
+     Expression to evaluate.  */
+  gimple_seq eval;
+
+  /* [ WORD 8 ]
+     Cleanup expression.  */
+  gimple_seq cleanup;
+};
+
+/* Kind of GIMPLE_TRY statements.  */
+enum gimple_try_flags
+{
+  /* A try/catch.  */
+  GIMPLE_TRY_CATCH = 1 << 0,
+
+  /* A try/finally.  */
+  GIMPLE_TRY_FINALLY = 1 << 1,
+  GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY,
+
+  /* Analogous to TRY_CATCH_IS_CLEANUP.  */
+  GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
+};
+
+/* GIMPLE_WITH_CLEANUP_EXPR */
+
+struct GTY((tag("GSS_WCE")))
+  gimple_statement_wce : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* Subcode: CLEANUP_EH_ONLY.  True if the cleanup should only be
+	      executed if an exception is thrown, not on normal exit of its
+	      scope.  This flag is analogous to the CLEANUP_EH_ONLY flag
+	      in TARGET_EXPRs.  */
+
+  /* [ WORD 7 ]
+     Cleanup expression.  */
+  gimple_seq cleanup;
+};
+
+
+/* GIMPLE_ASM  */
+
+struct GTY((tag("GSS_ASM")))
+  gasm : public gimple_statement_with_memory_ops_base
+{
+  /* [ WORD 1-9 ] : base class */
+
+  /* [ WORD 10 ]
+     __asm__ statement.  */
+  const char *string;
+
+  /* [ WORD 11 ]
+       Number of inputs, outputs, clobbers, labels.  */
+  unsigned char ni;
+  unsigned char no;
+  unsigned char nc;
+  unsigned char nl;
+
+  /* [ WORD 12 ]
+     Operand vector.  NOTE!  This must always be the last field
+     of this structure.  In particular, this means that this
+     structure cannot be embedded inside another one.  */
+  tree GTY((length ("%h.num_ops"))) op[1];
+};
+
+/* GIMPLE_OMP_CRITICAL */
+
+struct GTY((tag("GSS_OMP_CRITICAL")))
+  gomp_critical : public gimple_statement_omp
+{
+  /* [ WORD 1-7 ] : base class */
+
+  /* [ WORD 8 ]  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Critical section name.  */
+  tree name;
+};
+
+
+struct GTY(()) gimple_omp_for_iter {
+  /* Condition code.  */
+  enum tree_code cond;
+
+  /* Index variable.  */
+  tree index;
+
+  /* Initial value.  */
+  tree initial;
+
+  /* Final value.  */
+  tree final;
+
+  /* Increment.  */
+  tree incr;
+};
+
+/* GIMPLE_OMP_FOR */
+
+struct GTY((tag("GSS_OMP_FOR")))
+  gomp_for : public gimple_statement_omp
+{
+  /* [ WORD 1-7 ] : base class */
+
+  /* [ WORD 8 ]  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Number of elements in iter array.  */
+  size_t collapse;
+
+  /* [ WORD 10 ]  */
+  struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
+
+  /* [ WORD 11 ]
+     Pre-body evaluated before the loop body begins.  */
+  gimple_seq pre_body;
+};
+
+
+/* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK, GIMPLE_OMP_TEAMS */
+
+struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
+  gimple_statement_omp_parallel_layout : public gimple_statement_omp
+{
+  /* [ WORD 1-7 ] : base class */
+
+  /* [ WORD 8 ]
+     Clauses.  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Child function holding the body of the parallel region.  */
+  tree child_fn;
+
+  /* [ WORD 10 ]
+     Shared data argument.  */
+  tree data_arg;
+};
+
+/* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
+struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
+  gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout
+{
+    /* No extra fields; adds invariant:
+         stmt->code == GIMPLE_OMP_PARALLEL
+	 || stmt->code == GIMPLE_OMP_TASK
+	 || stmt->code == GIMPLE_OMP_TEAMS.  */
+};
+
+/* GIMPLE_OMP_PARALLEL */
+struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
+  gomp_parallel : public gimple_statement_omp_taskreg
+{
+    /* No extra fields; adds invariant:
+         stmt->code == GIMPLE_OMP_PARALLEL.  */
+};
+
+/* GIMPLE_OMP_TARGET */
+struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
+  gomp_target : public gimple_statement_omp_parallel_layout
+{
+    /* No extra fields; adds invariant:
+         stmt->code == GIMPLE_OMP_TARGET.  */
+};
+
+/* GIMPLE_OMP_TASK */
+
+struct GTY((tag("GSS_OMP_TASK")))
+  gomp_task : public gimple_statement_omp_taskreg
+{
+  /* [ WORD 1-10 ] : base class */
+
+  /* [ WORD 11 ]
+     Child function holding firstprivate initialization if needed.  */
+  tree copy_fn;
+
+  /* [ WORD 12-13 ]
+     Size and alignment in bytes of the argument data block.  */
+  tree arg_size;
+  tree arg_align;
+};
+
+
+/* GIMPLE_OMP_SECTION */
+/* Uses struct gimple_statement_omp.  */
+
+
+/* GIMPLE_OMP_SECTIONS */
+
+struct GTY((tag("GSS_OMP_SECTIONS")))
+  gomp_sections : public gimple_statement_omp
+{
+  /* [ WORD 1-7 ] : base class */
+
+  /* [ WORD 8 ]  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     The control variable used for deciding which of the sections to
+     execute.  */
+  tree control;
+};
+
+/* GIMPLE_OMP_CONTINUE.
+
+   Note: This does not inherit from gimple_statement_omp, because we
+         do not need the body field.  */
+
+struct GTY((tag("GSS_OMP_CONTINUE")))
+  gomp_continue : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]  */
+  tree control_def;
+
+  /* [ WORD 8 ]  */
+  tree control_use;
+};
+
+/* GIMPLE_OMP_SINGLE, GIMPLE_OMP_ORDERED, GIMPLE_OMP_TASKGROUP,
+   GIMPLE_OMP_SCAN, GIMPLE_OMP_MASKED, GIMPLE_OMP_SCOPE.  */
+
+struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
+  gimple_statement_omp_single_layout : public gimple_statement_omp
+{
+  /* [ WORD 1-7 ] : base class */
+
+  /* [ WORD 8 ]  */
+  tree clauses;
+};
+
+struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
+  gomp_single : public gimple_statement_omp_single_layout
+{
+    /* No extra fields; adds invariant:
+         stmt->code == GIMPLE_OMP_SINGLE.  */
+};
+
+struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
+  gomp_teams : public gimple_statement_omp_taskreg
+{
+    /* No extra fields; adds invariant:
+         stmt->code == GIMPLE_OMP_TEAMS.  */
+};
+
+struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
+  gomp_ordered : public gimple_statement_omp_single_layout
+{
+    /* No extra fields; adds invariant:
+	 stmt->code == GIMPLE_OMP_ORDERED.  */
+};
+
+struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
+  gomp_scan : public gimple_statement_omp_single_layout
+{
+    /* No extra fields; adds invariant:
+	 stmt->code == GIMPLE_OMP_SCAN.  */
+};
+
+
+/* GIMPLE_OMP_ATOMIC_LOAD.
+   Note: This is based on gimple, not g_s_omp, because g_s_omp
+   contains a sequence, which we don't need here.  */
+
+struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
+  gomp_atomic_load : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7-8 ]  */
+  tree rhs, lhs;
+};
+
+/* GIMPLE_OMP_ATOMIC_STORE.
+   See note on GIMPLE_OMP_ATOMIC_LOAD.  */
+
+struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
+  gimple_statement_omp_atomic_store_layout : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]  */
+  tree val;
+};
+
+struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
+  gomp_atomic_store :
+    public gimple_statement_omp_atomic_store_layout
+{
+    /* No extra fields; adds invariant:
+         stmt->code == GIMPLE_OMP_ATOMIC_STORE.  */
+};
+
+struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
+  gimple_statement_omp_return :
+    public gimple_statement_omp_atomic_store_layout
+{
+    /* No extra fields; adds invariant:
+         stmt->code == GIMPLE_OMP_RETURN.  */
+};
+
+/* Assumptions.  */
+
+struct GTY((tag("GSS_ASSUME")))
+  gimple_statement_assume : public gimple
+{
+  /* [ WORD 1-6 ] : base class */
+
+  /* [ WORD 7 ]  */
+  tree guard;
+
+  /* [ WORD 8 ]  */
+  gimple_seq body;
+};
+
+/* GIMPLE_TRANSACTION.  */
+
+/* Bits to be stored in the GIMPLE_TRANSACTION subcode.  */
+
+/* The __transaction_atomic was declared [[outer]] or it is
+   __transaction_relaxed.  */
+#define GTMA_IS_OUTER			(1u << 0)
+#define GTMA_IS_RELAXED			(1u << 1)
+#define GTMA_DECLARATION_MASK		(GTMA_IS_OUTER | GTMA_IS_RELAXED)
+
+/* The transaction is seen to not have an abort.  */
+#define GTMA_HAVE_ABORT			(1u << 2)
+/* The transaction is seen to have loads or stores.  */
+#define GTMA_HAVE_LOAD			(1u << 3)
+#define GTMA_HAVE_STORE			(1u << 4)
+/* The transaction MAY enter serial irrevocable mode in its dynamic scope.  */
+#define GTMA_MAY_ENTER_IRREVOCABLE	(1u << 5)
+/* The transaction WILL enter serial irrevocable mode.
+   An irrevocable block post-dominates the entire transaction, such
+   that all invocations of the transaction will go serial-irrevocable.
+   In such case, we don't bother instrumenting the transaction, and
+   tell the runtime that it should begin the transaction in
+   serial-irrevocable mode.  */
+#define GTMA_DOES_GO_IRREVOCABLE	(1u << 6)
+/* The transaction contains no instrumentation code whatsover, most
+   likely because it is guaranteed to go irrevocable upon entry.  */
+#define GTMA_HAS_NO_INSTRUMENTATION	(1u << 7)
+
+struct GTY((tag("GSS_TRANSACTION")))
+  gtransaction : public gimple_statement_with_memory_ops_base
+{
+  /* [ WORD 1-9 ] : base class */
+
+  /* [ WORD 10 ] */
+  gimple_seq body;
+
+  /* [ WORD 11-13 ] */
+  tree label_norm;
+  tree label_uninst;
+  tree label_over;
+};
+
+#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)	SYM,
+enum gimple_statement_structure_enum {
+#include "gsstruct.def"
+    LAST_GSS_ENUM
+};
+#undef DEFGSSTRUCT
+
+/* A statement with the invariant that
+      stmt->code == GIMPLE_COND
+   i.e. a conditional jump statement.  */
+
+struct GTY((tag("GSS_WITH_OPS")))
+  gcond : public gimple_statement_with_ops
+{
+  /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+  static const enum gimple_code code_ = GIMPLE_COND;
+};
+
+/* A statement with the invariant that
+      stmt->code == GIMPLE_DEBUG
+   i.e. a debug statement.  */
+
+struct GTY((tag("GSS_WITH_OPS")))
+  gdebug : public gimple_statement_with_ops
+{
+  /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+};
+
+/* A statement with the invariant that
+      stmt->code == GIMPLE_GOTO
+   i.e. a goto statement.  */
+
+struct GTY((tag("GSS_WITH_OPS")))
+  ggoto : public gimple_statement_with_ops
+{
+  /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+};
+
+/* A statement with the invariant that
+      stmt->code == GIMPLE_LABEL
+   i.e. a label statement.  */
+
+struct GTY((tag("GSS_WITH_OPS")))
+  glabel : public gimple_statement_with_ops
+{
+  /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+};
+
+/* A statement with the invariant that
+      stmt->code == GIMPLE_SWITCH
+   i.e. a switch statement.  */
+
+struct GTY((tag("GSS_WITH_OPS")))
+  gswitch : public gimple_statement_with_ops
+{
+  /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+};
+
+/* A statement with the invariant that
+      stmt->code == GIMPLE_ASSIGN
+   i.e. an assignment statement.  */
+
+struct GTY((tag("GSS_WITH_MEM_OPS")))
+  gassign : public gimple_statement_with_memory_ops
+{
+  static const enum gimple_code code_ = GIMPLE_ASSIGN;
+  /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
+};
+
+/* A statement with the invariant that
+      stmt->code == GIMPLE_RETURN
+   i.e. a return statement.  */
+
+struct GTY((tag("GSS_WITH_MEM_OPS")))
+  greturn : public gimple_statement_with_memory_ops
+{
+  /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
+};
+
+template <>
+template <>
+inline bool
+is_a_helper <gasm *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_ASM;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gassign *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_ASSIGN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gassign *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_ASSIGN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gbind *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_BIND;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gcall *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_CALL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gcatch *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_CATCH;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gcond *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_COND;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gcond *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_COND;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gdebug *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_DEBUG;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gdebug *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_DEBUG;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <ggoto *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_GOTO;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const ggoto *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_GOTO;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <glabel *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_LABEL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const glabel *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_LABEL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gresx *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_RESX;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <geh_dispatch *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_EH_DISPATCH;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <geh_else *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_EH_ELSE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const geh_else *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_EH_ELSE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <geh_filter *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_EH_FILTER;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <geh_mnt *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_EH_MUST_NOT_THROW;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const geh_mnt *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_EH_MUST_NOT_THROW;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_atomic_load *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_atomic_store *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_ATOMIC_STORE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gimple_statement_omp_return *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_RETURN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_continue *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_CONTINUE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_critical *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_CRITICAL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_ordered *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_ORDERED;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_scan *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_SCAN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_for *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_FOR;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gimple_statement_omp_taskreg *>::test (gimple *gs)
+{
+  return (gs->code == GIMPLE_OMP_PARALLEL
+	  || gs->code == GIMPLE_OMP_TASK
+	  || gs->code == GIMPLE_OMP_TEAMS);
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_parallel *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_PARALLEL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_target *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_TARGET;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_sections *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_SECTIONS;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_single *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_SINGLE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_teams *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_TEAMS;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gomp_task *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_TASK;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gphi *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_PHI;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <greturn *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_RETURN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gswitch *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_SWITCH;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gswitch *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_SWITCH;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gimple_statement_assume *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_ASSUME;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gtransaction *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_TRANSACTION;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gtry *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_TRY;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gtry *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_TRY;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gimple_statement_wce *>::test (gimple *gs)
+{
+  return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gasm *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_ASM;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gbind *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_BIND;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gcall *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_CALL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gcatch *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_CATCH;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gresx *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_RESX;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const geh_dispatch *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_EH_DISPATCH;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const geh_filter *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_EH_FILTER;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_atomic_load *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_atomic_store *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_ATOMIC_STORE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gimple_statement_omp_return *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_RETURN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_continue *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_CONTINUE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_critical *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_CRITICAL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_ordered *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_ORDERED;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_scan *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_SCAN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_for *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_FOR;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gimple_statement_omp_taskreg *>::test (const gimple *gs)
+{
+  return (gs->code == GIMPLE_OMP_PARALLEL
+	  || gs->code == GIMPLE_OMP_TASK
+	  || gs->code == GIMPLE_OMP_TEAMS);
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_parallel *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_PARALLEL;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_target *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_TARGET;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_sections *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_SECTIONS;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_single *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_SINGLE;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_teams *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_TEAMS;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gomp_task *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_OMP_TASK;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gphi *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_PHI;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const greturn *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_RETURN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gimple_statement_assume *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_ASSUME;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gtransaction *>::test (const gimple *gs)
+{
+  return gs->code == GIMPLE_TRANSACTION;
+}
+
+/* Offset in bytes to the location of the operand vector.
+   Zero if there is no operand vector for this tuple structure.  */
+extern size_t const gimple_ops_offset_[];
+
+/* Map GIMPLE codes to GSS codes.  */
+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;
+
+size_t gimple_size (enum gimple_code code, unsigned num_ops = 0);
+void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops);
+gimple *gimple_alloc (enum gimple_code, unsigned CXX_MEM_STAT_INFO);
+greturn *gimple_build_return (tree);
+void gimple_call_reset_alias_info (gcall *);
+gcall *gimple_build_call_vec (tree, const vec<tree> &);
+gcall *gimple_build_call (tree, unsigned, ...);
+gcall *gimple_build_call_valist (tree, unsigned, va_list);
+gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
+gcall *gimple_build_call_internal_vec (enum internal_fn, const vec<tree> &);
+gcall *gimple_build_call_from_tree (tree, tree);
+gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_INFO);
+gassign *gimple_build_assign (tree, enum tree_code,
+			      tree, tree, tree CXX_MEM_STAT_INFO);
+gassign *gimple_build_assign (tree, enum tree_code,
+			      tree, tree CXX_MEM_STAT_INFO);
+gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO);
+gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
+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);
+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> *,
+				 vec<tree, va_gc> *);
+gcatch *gimple_build_catch (tree, gimple_seq);
+geh_filter *gimple_build_eh_filter (tree, gimple_seq);
+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);
+gresx *gimple_build_resx (int);
+gswitch *gimple_build_switch_nlabels (unsigned, tree, tree);
+gswitch *gimple_build_switch (tree, tree, const vec<tree> &);
+geh_dispatch *gimple_build_eh_dispatch (int);
+gdebug *gimple_build_debug_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
+gdebug *gimple_build_debug_source_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
+gdebug *gimple_build_debug_begin_stmt (tree, location_t CXX_MEM_STAT_INFO);
+gdebug *gimple_build_debug_inline_entry (tree, location_t CXX_MEM_STAT_INFO);
+gomp_critical *gimple_build_omp_critical (gimple_seq, tree, tree);
+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_scope (gimple_seq, tree);
+gimple *gimple_build_omp_master (gimple_seq);
+gimple *gimple_build_omp_masked (gimple_seq, tree);
+gimple *gimple_build_omp_taskgroup (gimple_seq, tree);
+gomp_continue *gimple_build_omp_continue (tree, tree);
+gomp_ordered *gimple_build_omp_ordered (gimple_seq, tree);
+gimple *gimple_build_omp_return (bool);
+gomp_scan *gimple_build_omp_scan (gimple_seq, tree);
+gomp_sections *gimple_build_omp_sections (gimple_seq, tree);
+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,
+						enum omp_memory_order);
+gomp_atomic_store *gimple_build_omp_atomic_store (tree, enum omp_memory_order);
+gimple *gimple_build_assume (tree, gimple_seq);
+gtransaction *gimple_build_transaction (gimple_seq);
+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,
+					      location_t);
+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 *);
+int gimple_call_arg_flags (const gcall *, unsigned);
+int gimple_call_retslot_flags (const gcall *);
+int gimple_call_static_chain_flags (const gcall *);
+int gimple_call_return_flags (const gcall *);
+bool gimple_call_nonnull_result_p (gcall *);
+tree gimple_call_nonnull_arg (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);
+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 *);
+void gimple_move_vops (gimple *, gimple *);
+bool gimple_has_side_effects (const gimple *);
+bool gimple_could_trap_p_1 (const gimple *, bool, bool);
+bool gimple_could_trap_p (const gimple *);
+bool gimple_assign_rhs_could_trap_p (gimple *);
+extern void dump_gimple_statistics (void);
+unsigned get_gimple_rhs_num_ops (enum tree_code);
+gcall *gimple_call_copy_skip_args (gcall *, bitmap);
+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 combined_fn gimple_call_combined_fn (const gimple *);
+extern bool gimple_call_operator_delete_p (const gcall *);
+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 nonbarrier_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 bool gimple_inexpensive_call_p (gcall *);
+extern bool stmt_can_terminate_bb_p (gimple *);
+extern location_t gimple_or_expr_nonartificial_location (gimple *, tree);
+gcall *gimple_build_builtin_unreachable (location_t);
+
+/* Return the disposition for a warning (or all warnings by default)
+   for a statement.  */
+extern bool warning_suppressed_p (const gimple *, opt_code = all_warnings)
+  ATTRIBUTE_NONNULL (1);
+/* Set the disposition for a warning (or all warnings by default)
+   at a location to enabled by default.  */
+extern void suppress_warning (gimple *, opt_code = all_warnings,
+			      bool = true) ATTRIBUTE_NONNULL (1);
+
+/* Copy the warning disposition mapping from one statement to another.  */
+extern void copy_warning (gimple *, const gimple *)
+  ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
+/* Copy the warning disposition mapping from an expression to a statement.  */
+extern void copy_warning (gimple *, const_tree)
+  ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
+/* Copy the warning disposition mapping from a statement to an expression.  */
+extern void copy_warning (tree, const gimple *)
+  ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
+
+/* Formal (expression) temporary table handling: multiple occurrences of
+   the same scalar expression are evaluated into the same temporary.  */
+
+typedef struct gimple_temp_hash_elt
+{
+  tree val;   /* Key */
+  tree temp;  /* Value */
+} elt_t;
+
+/* Get the number of the next statement uid to be allocated.  */
+inline unsigned int
+gimple_stmt_max_uid (struct function *fn)
+{
+  return fn->last_stmt_uid;
+}
+
+/* Set the number of the next statement uid to be allocated.  */
+inline void
+set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
+{
+  fn->last_stmt_uid = maxid;
+}
+
+/* Set the number of the next statement uid to be allocated.  */
+inline unsigned int
+inc_gimple_stmt_max_uid (struct function *fn)
+{
+  return fn->last_stmt_uid++;
+}
+
+/* Return the first node in GIMPLE sequence S.  */
+
+inline gimple_seq_node
+gimple_seq_first (gimple_seq s)
+{
+  return s;
+}
+
+
+/* Return the first statement in GIMPLE sequence S.  */
+
+inline gimple *
+gimple_seq_first_stmt (gimple_seq s)
+{
+  gimple_seq_node n = gimple_seq_first (s);
+  return n;
+}
+
+/* Return the first statement in GIMPLE sequence S as a gbind *,
+   verifying that it has code GIMPLE_BIND in a checked build.  */
+
+inline gbind *
+gimple_seq_first_stmt_as_a_bind (gimple_seq s)
+{
+  gimple_seq_node n = gimple_seq_first (s);
+  return as_a <gbind *> (n);
+}
+
+
+/* Return the last node in GIMPLE sequence S.  */
+
+inline gimple_seq_node
+gimple_seq_last (gimple_seq s)
+{
+  return s ? s->prev : NULL;
+}
+
+
+/* Return the last statement in GIMPLE sequence S.  */
+
+inline gimple *
+gimple_seq_last_stmt (gimple_seq s)
+{
+  gimple_seq_node n = gimple_seq_last (s);
+  return n;
+}
+
+
+/* Set the last node in GIMPLE sequence *PS to LAST.  */
+
+inline void
+gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last)
+{
+  (*ps)->prev = last;
+}
+
+
+/* Set the first node in GIMPLE sequence *PS to FIRST.  */
+
+inline void
+gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first)
+{
+  *ps = first;
+}
+
+
+/* Return true if GIMPLE sequence S is empty.  */
+
+inline bool
+gimple_seq_empty_p (gimple_seq s)
+{
+  return s == NULL;
+}
+
+/* Allocate a new sequence and initialize its first element with STMT.  */
+
+inline gimple_seq
+gimple_seq_alloc_with_stmt (gimple *stmt)
+{
+  gimple_seq seq = NULL;
+  gimple_seq_add_stmt (&seq, stmt);
+  return seq;
+}
+
+
+/* Returns the sequence of statements in BB.  */
+
+inline gimple_seq
+bb_seq (const_basic_block bb)
+{
+  return (!(bb->flags & BB_RTL)) ? bb->il.gimple.seq : NULL;
+}
+
+inline gimple_seq *
+bb_seq_addr (basic_block bb)
+{
+  return (!(bb->flags & BB_RTL)) ? &bb->il.gimple.seq : NULL;
+}
+
+/* Sets the sequence of statements in BB to SEQ.  */
+
+inline void
+set_bb_seq (basic_block bb, gimple_seq seq)
+{
+  gcc_checking_assert (!(bb->flags & BB_RTL));
+  bb->il.gimple.seq = seq;
+}
+
+
+/* Return the code for GIMPLE statement G.  */
+
+inline enum gimple_code
+gimple_code (const gimple *g)
+{
+  return g->code;
+}
+
+
+/* Return the GSS code used by a GIMPLE code.  */
+
+inline enum gimple_statement_structure_enum
+gss_for_code (enum gimple_code code)
+{
+  gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
+  return gss_for_code_[code];
+}
+
+
+/* Return which GSS code is used by GS.  */
+
+inline enum gimple_statement_structure_enum
+gimple_statement_structure (gimple *gs)
+{
+  return gss_for_code (gimple_code (gs));
+}
+
+
+/* Return true if statement G has sub-statements.  This is only true for
+   High GIMPLE statements.  */
+
+inline bool
+gimple_has_substatements (gimple *g)
+{
+  switch (gimple_code (g))
+    {
+    case GIMPLE_ASSUME:
+    case GIMPLE_BIND:
+    case GIMPLE_CATCH:
+    case GIMPLE_EH_FILTER:
+    case GIMPLE_EH_ELSE:
+    case GIMPLE_TRY:
+    case GIMPLE_OMP_FOR:
+    case GIMPLE_OMP_MASTER:
+    case GIMPLE_OMP_MASKED:
+    case GIMPLE_OMP_TASKGROUP:
+    case GIMPLE_OMP_ORDERED:
+    case GIMPLE_OMP_SECTION:
+    case GIMPLE_OMP_PARALLEL:
+    case GIMPLE_OMP_TASK:
+    case GIMPLE_OMP_SCOPE:
+    case GIMPLE_OMP_SECTIONS:
+    case GIMPLE_OMP_SINGLE:
+    case GIMPLE_OMP_TARGET:
+    case GIMPLE_OMP_TEAMS:
+    case GIMPLE_OMP_CRITICAL:
+    case GIMPLE_WITH_CLEANUP_EXPR:
+    case GIMPLE_TRANSACTION:
+      return true;
+
+    default:
+      return false;
+    }
+}
+
+
+/* Return the basic block holding statement G.  */
+
+inline basic_block
+gimple_bb (const gimple *g)
+{
+  return g->bb;
+}
+
+
+/* Return the lexical scope block holding statement G.  */
+
+inline tree
+gimple_block (const gimple *g)
+{
+  return LOCATION_BLOCK (g->location);
+}
+
+/* Forward declare.  */
+inline void gimple_set_location (gimple *, location_t);
+
+/* Set BLOCK to be the lexical scope block holding statement G.  */
+
+inline void
+gimple_set_block (gimple *g, tree block)
+{
+  gimple_set_location (g, set_block (g->location, block));
+}
+
+/* Return location information for statement G.  */
+
+inline location_t
+gimple_location (const gimple *g)
+{
+  return g->location;
+}
+
+/* Return location information for statement G if g is not NULL.
+   Otherwise, UNKNOWN_LOCATION is returned.  */
+
+inline location_t
+gimple_location_safe (const gimple *g)
+{
+  return g ? gimple_location (g) : UNKNOWN_LOCATION;
+}
+
+/* Set location information for statement G.  */
+
+inline void
+gimple_set_location (gimple *g, location_t location)
+{
+  /* Copy the no-warning data to the statement location.  */
+  if (g->location != UNKNOWN_LOCATION)
+    copy_warning (location, g->location);
+  g->location = location;
+}
+
+/* Return address of the location information for statement G.  */
+
+inline location_t *
+gimple_location_ptr (gimple *g)
+{
+  return &g->location;
+}
+
+
+/* Return true if G contains location information.  */
+
+inline bool
+gimple_has_location (const gimple *g)
+{
+  return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION;
+}
+
+
+/* Return non-artificial location information for statement G.  */
+
+inline location_t
+gimple_nonartificial_location (const gimple *g)
+{
+  location_t *ploc = NULL;
+
+  if (tree block = gimple_block (g))
+    ploc = block_nonartificial_location (block);
+
+  return ploc ? *ploc : gimple_location (g);
+}
+
+
+/* Return the file name of the location of STMT.  */
+
+inline const char *
+gimple_filename (const gimple *stmt)
+{
+  return LOCATION_FILE (gimple_location (stmt));
+}
+
+
+/* Return the line number of the location of STMT.  */
+
+inline int
+gimple_lineno (const gimple *stmt)
+{
+  return LOCATION_LINE (gimple_location (stmt));
+}
+
+
+/* Determine whether SEQ is a singleton. */
+
+inline bool
+gimple_seq_singleton_p (gimple_seq seq)
+{
+  return ((gimple_seq_first (seq) != NULL)
+	  && (gimple_seq_first (seq) == gimple_seq_last (seq)));
+}
+
+/* Return true if no warnings should be emitted for statement STMT.  */
+
+inline bool
+gimple_no_warning_p (const gimple *stmt)
+{
+  return stmt->no_warning;
+}
+
+/* Set the no_warning flag of STMT to NO_WARNING.  */
+
+inline void
+gimple_set_no_warning (gimple *stmt, bool no_warning)
+{
+  stmt->no_warning = (unsigned) no_warning;
+}
+
+/* Set the visited status on statement STMT to VISITED_P.
+
+   Please note that this 'visited' property of the gimple statement is
+   supposed to be undefined at pass boundaries.  This means that a
+   given pass should not assume it contains any useful value when the
+   pass starts and thus can set it to any value it sees fit.
+
+   You can learn more about the visited property of the gimple
+   statement by reading the comments of the 'visited' data member of
+   struct gimple.
+ */
+
+inline void
+gimple_set_visited (gimple *stmt, bool visited_p)
+{
+  stmt->visited = (unsigned) visited_p;
+}
+
+
+/* Return the visited status for statement STMT.
+
+   Please note that this 'visited' property of the gimple statement is
+   supposed to be undefined at pass boundaries.  This means that a
+   given pass should not assume it contains any useful value when the
+   pass starts and thus can set it to any value it sees fit.
+
+   You can learn more about the visited property of the gimple
+   statement by reading the comments of the 'visited' data member of
+   struct gimple.  */
+
+inline bool
+gimple_visited_p (gimple *stmt)
+{
+  return stmt->visited;
+}
+
+
+/* Set pass local flag PLF on statement STMT to VAL_P.
+
+   Please note that this PLF property of the gimple statement is
+   supposed to be undefined at pass boundaries.  This means that a
+   given pass should not assume it contains any useful value when the
+   pass starts and thus can set it to any value it sees fit.
+
+   You can learn more about the PLF property by reading the comment of
+   the 'plf' data member of struct gimple_statement_structure.  */
+
+inline void
+gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
+{
+  if (val_p)
+    stmt->plf |= (unsigned int) plf;
+  else
+    stmt->plf &= ~((unsigned int) plf);
+}
+
+
+/* Return the value of pass local flag PLF on statement STMT.
+
+   Please note that this 'plf' property of the gimple statement is
+   supposed to be undefined at pass boundaries.  This means that a
+   given pass should not assume it contains any useful value when the
+   pass starts and thus can set it to any value it sees fit.
+
+   You can learn more about the plf property by reading the comment of
+   the 'plf' data member of struct gimple_statement_structure.  */
+
+inline unsigned int
+gimple_plf (gimple *stmt, enum plf_mask plf)
+{
+  return stmt->plf & ((unsigned int) plf);
+}
+
+
+/* Set the UID of statement.
+
+   Please note that this UID property is supposed to be undefined at
+   pass boundaries.  This means that a given pass should not assume it
+   contains any useful value when the pass starts and thus can set it
+   to any value it sees fit.  */
+
+inline void
+gimple_set_uid (gimple *g, unsigned uid)
+{
+  g->uid = uid;
+}
+
+
+/* Return the UID of statement.
+
+   Please note that this UID property is supposed to be undefined at
+   pass boundaries.  This means that a given pass should not assume it
+   contains any useful value when the pass starts and thus can set it
+   to any value it sees fit.  */
+
+inline unsigned
+gimple_uid (const gimple *g)
+{
+  return g->uid;
+}
+
+
+/* Make statement G a singleton sequence.  */
+
+inline void
+gimple_init_singleton (gimple *g)
+{
+  g->next = NULL;
+  g->prev = g;
+}
+
+
+/* Return true if GIMPLE statement G has register or memory operands.  */
+
+inline bool
+gimple_has_ops (const gimple *g)
+{
+  return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gimple_statement_with_ops *>::test (const gimple *gs)
+{
+  return gimple_has_ops (gs);
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gimple_statement_with_ops *>::test (gimple *gs)
+{
+  return gimple_has_ops (gs);
+}
+
+/* Return true if GIMPLE statement G has memory operands.  */
+
+inline bool
+gimple_has_mem_ops (const gimple *g)
+{
+  return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <const gimple_statement_with_memory_ops *>::test (const gimple *gs)
+{
+  return gimple_has_mem_ops (gs);
+}
+
+template <>
+template <>
+inline bool
+is_a_helper <gimple_statement_with_memory_ops *>::test (gimple *gs)
+{
+  return gimple_has_mem_ops (gs);
+}
+
+/* Return the set of USE operands for statement G.  */
+
+inline struct use_optype_d *
+gimple_use_ops (const gimple *g)
+{
+  const gimple_statement_with_ops *ops_stmt =
+    dyn_cast <const gimple_statement_with_ops *> (g);
+  if (!ops_stmt)
+    return NULL;
+  return ops_stmt->use_ops;
+}
+
+
+/* Set USE to be the set of USE operands for statement G.  */
+
+inline void
+gimple_set_use_ops (gimple *g, struct use_optype_d *use)
+{
+  gimple_statement_with_ops *ops_stmt =
+    as_a <gimple_statement_with_ops *> (g);
+  ops_stmt->use_ops = use;
+}
+
+
+/* Return the single VUSE operand of the statement G.  */
+
+inline tree
+gimple_vuse (const gimple *g)
+{
+  const gimple_statement_with_memory_ops *mem_ops_stmt =
+     dyn_cast <const gimple_statement_with_memory_ops *> (g);
+  if (!mem_ops_stmt)
+    return NULL_TREE;
+  return mem_ops_stmt->vuse;
+}
+
+/* Return the single VDEF operand of the statement G.  */
+
+inline tree
+gimple_vdef (const gimple *g)
+{
+  const gimple_statement_with_memory_ops *mem_ops_stmt =
+     dyn_cast <const gimple_statement_with_memory_ops *> (g);
+  if (!mem_ops_stmt)
+    return NULL_TREE;
+  return mem_ops_stmt->vdef;
+}
+
+/* Return the single VUSE operand of the statement G.  */
+
+inline tree *
+gimple_vuse_ptr (gimple *g)
+{
+  gimple_statement_with_memory_ops *mem_ops_stmt =
+     dyn_cast <gimple_statement_with_memory_ops *> (g);
+  if (!mem_ops_stmt)
+    return NULL;
+  return &mem_ops_stmt->vuse;
+}
+
+/* Return the single VDEF operand of the statement G.  */
+
+inline tree *
+gimple_vdef_ptr (gimple *g)
+{
+  gimple_statement_with_memory_ops *mem_ops_stmt =
+     dyn_cast <gimple_statement_with_memory_ops *> (g);
+  if (!mem_ops_stmt)
+    return NULL;
+  return &mem_ops_stmt->vdef;
+}
+
+/* Set the single VUSE operand of the statement G.  */
+
+inline void
+gimple_set_vuse (gimple *g, tree vuse)
+{
+  gimple_statement_with_memory_ops *mem_ops_stmt =
+    as_a <gimple_statement_with_memory_ops *> (g);
+  mem_ops_stmt->vuse = vuse;
+}
+
+/* Set the single VDEF operand of the statement G.  */
+
+inline void
+gimple_set_vdef (gimple *g, tree vdef)
+{
+  gimple_statement_with_memory_ops *mem_ops_stmt =
+    as_a <gimple_statement_with_memory_ops *> (g);
+  mem_ops_stmt->vdef = vdef;
+}
+
+
+/* Return true if statement G has operands and the modified field has
+   been set.  */
+
+inline bool
+gimple_modified_p (const gimple *g)
+{
+  return (gimple_has_ops (g)) ? (bool) g->modified : false;
+}
+
+
+/* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
+   a MODIFIED field.  */
+
+inline void
+gimple_set_modified (gimple *s, bool modifiedp)
+{
+  if (gimple_has_ops (s))
+    s->modified = (unsigned) modifiedp;
+}
+
+
+/* Return true if statement STMT contains volatile operands.  */
+
+inline bool
+gimple_has_volatile_ops (const gimple *stmt)
+{
+  if (gimple_has_mem_ops (stmt))
+    return stmt->has_volatile_ops;
+  else
+    return false;
+}
+
+
+/* Set the HAS_VOLATILE_OPS flag to VOLATILEP.  */
+
+inline void
+gimple_set_has_volatile_ops (gimple *stmt, bool volatilep)
+{
+  if (gimple_has_mem_ops (stmt))
+    stmt->has_volatile_ops = (unsigned) volatilep;
+}
+
+/* Return true if STMT is in a transaction.  */
+
+inline bool
+gimple_in_transaction (const gimple *stmt)
+{
+  return bb_in_transaction (gimple_bb (stmt));
+}
+
+/* Return true if statement STMT may access memory.  */
+
+inline bool
+gimple_references_memory_p (gimple *stmt)
+{
+  return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
+}
+
+
+/* Return the subcode for OMP statement S.  */
+
+inline unsigned
+gimple_omp_subcode (const gimple *s)
+{
+  gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
+			      && gimple_code (s) <= GIMPLE_OMP_ORDERED);
+  return s->subcode;
+}
+
+/* Set the subcode for OMP statement S to SUBCODE.  */
+
+inline void
+gimple_omp_set_subcode (gimple *s, unsigned int subcode)
+{
+  /* We only have 16 bits for the subcode.  Assert that we are not
+     overflowing it.  */
+  gcc_gimple_checking_assert (subcode < (1 << 16));
+  s->subcode = subcode;
+}
+
+/* Set the nowait flag on OMP_RETURN statement S.  */
+
+inline void
+gimple_omp_return_set_nowait (gimple *s)
+{
+  GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
+  s->subcode |= GF_OMP_RETURN_NOWAIT;
+}
+
+
+/* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
+   flag set.  */
+
+inline bool
+gimple_omp_return_nowait_p (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
+  return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
+}
+
+
+/* Set the LHS of OMP return.  */
+
+inline void
+gimple_omp_return_set_lhs (gimple *g, tree lhs)
+{
+  gimple_statement_omp_return *omp_return_stmt =
+    as_a <gimple_statement_omp_return *> (g);
+  omp_return_stmt->val = lhs;
+}
+
+
+/* Get the LHS of OMP return.  */
+
+inline tree
+gimple_omp_return_lhs (const gimple *g)
+{
+  const gimple_statement_omp_return *omp_return_stmt =
+    as_a <const gimple_statement_omp_return *> (g);
+  return omp_return_stmt->val;
+}
+
+
+/* Return a pointer to the LHS of OMP return.  */
+
+inline tree *
+gimple_omp_return_lhs_ptr (gimple *g)
+{
+  gimple_statement_omp_return *omp_return_stmt =
+    as_a <gimple_statement_omp_return *> (g);
+  return &omp_return_stmt->val;
+}
+
+
+/* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
+   flag set.  */
+
+inline bool
+gimple_omp_section_last_p (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
+  return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
+}
+
+
+/* Set the GF_OMP_SECTION_LAST flag on G.  */
+
+inline void
+gimple_omp_section_set_last (gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
+  g->subcode |= GF_OMP_SECTION_LAST;
+}
+
+
+/* Return true if OMP ordered construct is stand-alone
+   (G has the GF_OMP_ORDERED_STANDALONE flag set).  */
+
+inline bool
+gimple_omp_ordered_standalone_p (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
+  return (gimple_omp_subcode (g) & GF_OMP_ORDERED_STANDALONE) != 0;
+}
+
+
+/* Set the GF_OMP_ORDERED_STANDALONE flag on G.  */
+
+inline void
+gimple_omp_ordered_standalone (gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
+  g->subcode |= GF_OMP_ORDERED_STANDALONE;
+}
+
+
+/* Return true if OMP parallel statement G has the
+   GF_OMP_PARALLEL_COMBINED flag set.  */
+
+inline bool
+gimple_omp_parallel_combined_p (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
+  return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
+}
+
+
+/* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
+   value of COMBINED_P.  */
+
+inline void
+gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
+  if (combined_p)
+    g->subcode |= GF_OMP_PARALLEL_COMBINED;
+  else
+    g->subcode &= ~GF_OMP_PARALLEL_COMBINED;
+}
+
+
+/* Return true if OMP atomic load/store statement G has the
+   GF_OMP_ATOMIC_NEED_VALUE flag set.  */
+
+inline bool
+gimple_omp_atomic_need_value_p (const gimple *g)
+{
+  if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
+    GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+  return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_NEED_VALUE) != 0;
+}
+
+
+/* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G.  */
+
+inline void
+gimple_omp_atomic_set_need_value (gimple *g)
+{
+  if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
+    GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+  g->subcode |= GF_OMP_ATOMIC_NEED_VALUE;
+}
+
+
+/* Return true if OMP atomic load/store statement G has the
+   GF_OMP_ATOMIC_WEAK flag set.  */
+
+inline bool
+gimple_omp_atomic_weak_p (const gimple *g)
+{
+  if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
+    GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+  return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_WEAK) != 0;
+}
+
+
+/* Set the GF_OMP_ATOMIC_WEAK flag on G.  */
+
+inline void
+gimple_omp_atomic_set_weak (gimple *g)
+{
+  if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
+    GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+  g->subcode |= GF_OMP_ATOMIC_WEAK;
+}
+
+
+/* Return the memory order of the OMP atomic load/store statement G.  */
+
+inline enum omp_memory_order
+gimple_omp_atomic_memory_order (const gimple *g)
+{
+  if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
+    GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+  return (enum omp_memory_order)
+	 (gimple_omp_subcode (g) & GF_OMP_ATOMIC_MEMORY_ORDER);
+}
+
+
+/* Set the memory order on G.  */
+
+inline void
+gimple_omp_atomic_set_memory_order (gimple *g, enum omp_memory_order mo)
+{
+  if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
+    GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+  g->subcode = ((g->subcode & ~GF_OMP_ATOMIC_MEMORY_ORDER)
+		| (mo & GF_OMP_ATOMIC_MEMORY_ORDER));
+}
+
+
+/* Return the number of operands for statement GS.  */
+
+inline unsigned
+gimple_num_ops (const gimple *gs)
+{
+  return gs->num_ops;
+}
+
+
+/* Set the number of operands for statement GS.  */
+
+inline void
+gimple_set_num_ops (gimple *gs, unsigned num_ops)
+{
+  gs->num_ops = num_ops;
+}
+
+
+/* Return the array of operands for statement GS.  */
+
+inline tree *
+gimple_ops (gimple *gs)
+{
+  size_t off;
+
+  /* All the tuples have their operand vector at the very bottom
+     of the structure.  Note that those structures that do not
+     have an operand vector have a zero offset.  */
+  off = gimple_ops_offset_[gimple_statement_structure (gs)];
+  gcc_gimple_checking_assert (off != 0);
+
+  return (tree *) ((char *) gs + off);
+}
+
+
+/* Return operand I for statement GS.  */
+
+inline tree
+gimple_op (const gimple *gs, unsigned i)
+{
+  if (gimple_has_ops (gs))
+    {
+      gcc_gimple_checking_assert (i < gimple_num_ops (gs));
+      return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
+    }
+  else
+    return NULL_TREE;
+}
+
+/* Return a pointer to operand I for statement GS.  */
+
+inline tree *
+gimple_op_ptr (gimple *gs, unsigned i)
+{
+  if (gimple_has_ops (gs))
+    {
+      gcc_gimple_checking_assert (i < gimple_num_ops (gs));
+      return gimple_ops (gs) + i;
+    }
+  else
+    return NULL;
+}
+
+/* Set operand I of statement GS to OP.  */
+
+inline void
+gimple_set_op (gimple *gs, unsigned i, tree op)
+{
+  gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
+
+  /* Note.  It may be tempting to assert that OP matches
+     is_gimple_operand, but that would be wrong.  Different tuples
+     accept slightly different sets of tree operands.  Each caller
+     should perform its own validation.  */
+  gimple_ops (gs)[i] = op;
+}
+
+/* Return true if GS is a GIMPLE_ASSIGN.  */
+
+inline bool
+is_gimple_assign (const gimple *gs)
+{
+  return gimple_code (gs) == GIMPLE_ASSIGN;
+}
+
+/* Determine if expression CODE is one of the valid expressions that can
+   be used on the RHS of GIMPLE assignments.  */
+
+inline enum gimple_rhs_class
+get_gimple_rhs_class (enum tree_code code)
+{
+  return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code];
+}
+
+/* Return the LHS of assignment statement GS.  */
+
+inline tree
+gimple_assign_lhs (const gassign *gs)
+{
+  return gs->op[0];
+}
+
+inline tree
+gimple_assign_lhs (const gimple *gs)
+{
+  const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
+  return gimple_assign_lhs (ass);
+}
+
+
+/* Return a pointer to the LHS of assignment statement GS.  */
+
+inline tree *
+gimple_assign_lhs_ptr (gassign *gs)
+{
+  return &gs->op[0];
+}
+
+inline tree *
+gimple_assign_lhs_ptr (gimple *gs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  return gimple_assign_lhs_ptr (ass);
+}
+
+
+/* Set LHS to be the LHS operand of assignment statement GS.  */
+
+inline void
+gimple_assign_set_lhs (gassign *gs, tree lhs)
+{
+  gs->op[0] = lhs;
+
+  if (lhs && TREE_CODE (lhs) == SSA_NAME)
+    SSA_NAME_DEF_STMT (lhs) = gs;
+}
+
+inline void
+gimple_assign_set_lhs (gimple *gs, tree lhs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  gimple_assign_set_lhs (ass, lhs);
+}
+
+
+/* Return the first operand on the RHS of assignment statement GS.  */
+
+inline tree
+gimple_assign_rhs1 (const gassign *gs)
+{
+  return gs->op[1];
+}
+
+inline tree
+gimple_assign_rhs1 (const gimple *gs)
+{
+  const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
+  return gimple_assign_rhs1 (ass);
+}
+
+
+/* Return a pointer to the first operand on the RHS of assignment
+   statement GS.  */
+
+inline tree *
+gimple_assign_rhs1_ptr (gassign *gs)
+{
+  return &gs->op[1];
+}
+
+inline tree *
+gimple_assign_rhs1_ptr (gimple *gs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  return gimple_assign_rhs1_ptr (ass);
+}
+
+/* Set RHS to be the first operand on the RHS of assignment statement GS.  */
+
+inline void
+gimple_assign_set_rhs1 (gassign *gs, tree rhs)
+{
+  gs->op[1] = rhs;
+}
+
+inline void
+gimple_assign_set_rhs1 (gimple *gs, tree rhs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  gimple_assign_set_rhs1 (ass, rhs);
+}
+
+
+/* Return the second operand on the RHS of assignment statement GS.
+   If GS does not have two operands, NULL is returned instead.  */
+
+inline tree
+gimple_assign_rhs2 (const gassign *gs)
+{
+  if (gimple_num_ops (gs) >= 3)
+    return gs->op[2];
+  else
+    return NULL_TREE;
+}
+
+inline tree
+gimple_assign_rhs2 (const gimple *gs)
+{
+  const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
+  return gimple_assign_rhs2 (ass);
+}
+
+
+/* Return a pointer to the second operand on the RHS of assignment
+   statement GS.  */
+
+inline tree *
+gimple_assign_rhs2_ptr (gassign *gs)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
+  return &gs->op[2];
+}
+
+inline tree *
+gimple_assign_rhs2_ptr (gimple *gs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  return gimple_assign_rhs2_ptr (ass);
+}
+
+
+/* Set RHS to be the second operand on the RHS of assignment statement GS.  */
+
+inline void
+gimple_assign_set_rhs2 (gassign *gs, tree rhs)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
+  gs->op[2] = rhs;
+}
+
+inline void
+gimple_assign_set_rhs2 (gimple *gs, tree rhs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  return gimple_assign_set_rhs2 (ass, rhs);
+}
+
+/* Return the third operand on the RHS of assignment statement GS.
+   If GS does not have two operands, NULL is returned instead.  */
+
+inline tree
+gimple_assign_rhs3 (const gassign *gs)
+{
+  if (gimple_num_ops (gs) >= 4)
+    return gs->op[3];
+  else
+    return NULL_TREE;
+}
+
+inline tree
+gimple_assign_rhs3 (const gimple *gs)
+{
+  const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
+  return gimple_assign_rhs3 (ass);
+}
+
+/* Return a pointer to the third operand on the RHS of assignment
+   statement GS.  */
+
+inline tree *
+gimple_assign_rhs3_ptr (gimple *gs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
+  return &ass->op[3];
+}
+
+
+/* Set RHS to be the third operand on the RHS of assignment statement GS.  */
+
+inline void
+gimple_assign_set_rhs3 (gassign *gs, tree rhs)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
+  gs->op[3] = rhs;
+}
+
+inline void
+gimple_assign_set_rhs3 (gimple *gs, tree rhs)
+{
+  gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
+  gimple_assign_set_rhs3 (ass, rhs);
+}
+
+
+/* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
+   which expect to see only two operands.  */
+
+inline void
+gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
+				tree op1, tree op2)
+{
+  gimple_assign_set_rhs_with_ops (gsi, code, op1, op2, NULL);
+}
+
+/* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
+   which expect to see only one operands.  */
+
+inline void
+gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
+				tree op1)
+{
+  gimple_assign_set_rhs_with_ops (gsi, code, op1, NULL, NULL);
+}
+
+/* Returns true if GS is a nontemporal move.  */
+
+inline bool
+gimple_assign_nontemporal_move_p (const gassign *gs)
+{
+  return gs->nontemporal_move;
+}
+
+/* Sets nontemporal move flag of GS to NONTEMPORAL.  */
+
+inline void
+gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+  gs->nontemporal_move = nontemporal;
+}
+
+
+/* Return the code of the expression computed on the rhs of assignment
+   statement GS.  In case that the RHS is a single object, returns the
+   tree code of the object.  */
+
+inline enum tree_code
+gimple_assign_rhs_code (const gassign *gs)
+{
+  enum tree_code code = (enum tree_code) gs->subcode;
+  /* While we initially set subcode to the TREE_CODE of the rhs for
+     GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
+     in sync when we rewrite stmts into SSA form or do SSA propagations.  */
+  if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
+    code = TREE_CODE (gs->op[1]);
+
+  return code;
+}
+
+inline enum tree_code
+gimple_assign_rhs_code (const gimple *gs)
+{
+  const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
+  return gimple_assign_rhs_code (ass);
+}
+
+
+/* Set CODE to be the code for the expression computed on the RHS of
+   assignment S.  */
+
+inline void
+gimple_assign_set_rhs_code (gimple *s, enum tree_code code)
+{
+  GIMPLE_CHECK (s, GIMPLE_ASSIGN);
+  s->subcode = code;
+}
+
+
+/* Return the gimple rhs class of the code of the expression computed on
+   the rhs of assignment statement GS.
+   This will never return GIMPLE_INVALID_RHS.  */
+
+inline enum gimple_rhs_class
+gimple_assign_rhs_class (const gimple *gs)
+{
+  return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
+}
+
+/* Return true if GS is an assignment with a singleton RHS, i.e.,
+   there is no operator associated with the assignment itself.
+   Unlike gimple_assign_copy_p, this predicate returns true for
+   any RHS operand, including those that perform an operation
+   and do not have the semantics of a copy, such as COND_EXPR.  */
+
+inline bool
+gimple_assign_single_p (const gimple *gs)
+{
+  return (is_gimple_assign (gs)
+          && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
+}
+
+/* Return true if GS performs a store to its lhs.  */
+
+inline bool
+gimple_store_p (const gimple *gs)
+{
+  tree lhs = gimple_get_lhs (gs);
+  return lhs && !is_gimple_reg (lhs);
+}
+
+/* Return true if GS is an assignment that loads from its rhs1.  */
+
+inline bool
+gimple_assign_load_p (const gimple *gs)
+{
+  tree rhs;
+  if (!gimple_assign_single_p (gs))
+    return false;
+  rhs = gimple_assign_rhs1 (gs);
+  if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
+    return true;
+  rhs = get_base_address (rhs);
+  return (DECL_P (rhs)
+	  || TREE_CODE (rhs) == MEM_REF || TREE_CODE (rhs) == TARGET_MEM_REF);
+}
+
+
+/* Return true if S is a type-cast assignment.  */
+
+inline bool
+gimple_assign_cast_p (const gimple *s)
+{
+  if (is_gimple_assign (s))
+    {
+      enum tree_code sc = gimple_assign_rhs_code (s);
+      return CONVERT_EXPR_CODE_P (sc)
+	     || sc == VIEW_CONVERT_EXPR
+	     || sc == FIX_TRUNC_EXPR;
+    }
+
+  return false;
+}
+
+/* Return true if S is a clobber statement.  */
+
+inline bool
+gimple_clobber_p (const gimple *s)
+{
+  return gimple_assign_single_p (s)
+         && TREE_CLOBBER_P (gimple_assign_rhs1 (s));
+}
+
+/* Return true if S is a clobber statement.  */
+
+inline bool
+gimple_clobber_p (const gimple *s, enum clobber_kind kind)
+{
+  return gimple_clobber_p (s)
+	 && CLOBBER_KIND (gimple_assign_rhs1 (s)) == kind;
+}
+
+/* Return true if GS is a GIMPLE_CALL.  */
+
+inline bool
+is_gimple_call (const gimple *gs)
+{
+  return gimple_code (gs) == GIMPLE_CALL;
+}
+
+/* Return the LHS of call statement GS.  */
+
+inline tree
+gimple_call_lhs (const gcall *gs)
+{
+  return gs->op[0];
+}
+
+inline tree
+gimple_call_lhs (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_lhs (gc);
+}
+
+
+/* Return a pointer to the LHS of call statement GS.  */
+
+inline tree *
+gimple_call_lhs_ptr (gcall *gs)
+{
+  return &gs->op[0];
+}
+
+inline tree *
+gimple_call_lhs_ptr (gimple *gs)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  return gimple_call_lhs_ptr (gc);
+}
+
+
+/* Set LHS to be the LHS operand of call statement GS.  */
+
+inline void
+gimple_call_set_lhs (gcall *gs, tree lhs)
+{
+  gs->op[0] = lhs;
+  if (lhs && TREE_CODE (lhs) == SSA_NAME)
+    SSA_NAME_DEF_STMT (lhs) = gs;
+}
+
+inline void
+gimple_call_set_lhs (gimple *gs, tree lhs)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  gimple_call_set_lhs (gc, lhs);
+}
+
+
+/* Return true if call GS calls an internal-only function, as enumerated
+   by internal_fn.  */
+
+inline bool
+gimple_call_internal_p (const gcall *gs)
+{
+  return (gs->subcode & GF_CALL_INTERNAL) != 0;
+}
+
+inline bool
+gimple_call_internal_p (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_internal_p (gc);
+}
+
+/* Return true if call GS is marked as nocf_check.  */
+
+inline bool
+gimple_call_nocf_check_p (const gcall *gs)
+{
+  return (gs->subcode & GF_CALL_NOCF_CHECK) != 0;
+}
+
+/* Mark statement GS as nocf_check call.  */
+
+inline void
+gimple_call_set_nocf_check (gcall *gs, bool nocf_check)
+{
+  if (nocf_check)
+    gs->subcode |= GF_CALL_NOCF_CHECK;
+  else
+    gs->subcode &= ~GF_CALL_NOCF_CHECK;
+}
+
+/* Return the target of internal call GS.  */
+
+inline enum internal_fn
+gimple_call_internal_fn (const gcall *gs)
+{
+  gcc_gimple_checking_assert (gimple_call_internal_p (gs));
+  return gs->u.internal_fn;
+}
+
+inline enum internal_fn
+gimple_call_internal_fn (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_internal_fn (gc);
+}
+
+/* Return true, if this internal gimple call is unique.  */
+
+inline bool
+gimple_call_internal_unique_p (const gcall *gs)
+{
+  return gimple_call_internal_fn (gs) == IFN_UNIQUE;
+}
+
+inline bool
+gimple_call_internal_unique_p (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_internal_unique_p (gc);
+}
+
+/* Return true if GS is an internal function FN.  */
+
+inline bool
+gimple_call_internal_p (const gimple *gs, internal_fn fn)
+{
+  return (is_gimple_call (gs)
+	  && gimple_call_internal_p (gs)
+	  && gimple_call_internal_fn (gs) == fn);
+}
+
+/* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
+   that could alter control flow.  */
+
+inline void
+gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
+{
+  if (ctrl_altering_p)
+    s->subcode |= GF_CALL_CTRL_ALTERING;
+  else
+    s->subcode &= ~GF_CALL_CTRL_ALTERING;
+}
+
+inline void
+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);
+}
+
+/* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
+   flag is set. Such call could not be a stmt in the middle of a bb.  */
+
+inline bool
+gimple_call_ctrl_altering_p (const gcall *gs)
+{
+  return (gs->subcode & GF_CALL_CTRL_ALTERING) != 0;
+}
+
+inline bool
+gimple_call_ctrl_altering_p (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_ctrl_altering_p (gc);
+}
+
+
+/* Return the function type of the function called by GS.  */
+
+inline tree
+gimple_call_fntype (const gcall *gs)
+{
+  if (gimple_call_internal_p (gs))
+    return NULL_TREE;
+  return gs->u.fntype;
+}
+
+inline tree
+gimple_call_fntype (const gimple *gs)
+{
+  const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_fntype (call_stmt);
+}
+
+/* Set the type of the function called by CALL_STMT to FNTYPE.  */
+
+inline void
+gimple_call_set_fntype (gcall *call_stmt, tree fntype)
+{
+  gcc_gimple_checking_assert (!gimple_call_internal_p (call_stmt));
+  call_stmt->u.fntype = fntype;
+}
+
+
+/* Return the tree node representing the function called by call
+   statement GS.  */
+
+inline tree
+gimple_call_fn (const gcall *gs)
+{
+  return gs->op[1];
+}
+
+inline tree
+gimple_call_fn (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_fn (gc);
+}
+
+/* Return a pointer to the tree node representing the function called by call
+   statement GS.  */
+
+inline tree *
+gimple_call_fn_ptr (gcall *gs)
+{
+  return &gs->op[1];
+}
+
+inline tree *
+gimple_call_fn_ptr (gimple *gs)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  return gimple_call_fn_ptr (gc);
+}
+
+
+/* Set FN to be the function called by call statement GS.  */
+
+inline void
+gimple_call_set_fn (gcall *gs, tree fn)
+{
+  gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
+  gs->op[1] = fn;
+}
+
+
+/* Set FNDECL to be the function called by call statement GS.  */
+
+inline void
+gimple_call_set_fndecl (gcall *gs, tree decl)
+{
+  gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
+  gs->op[1] = build1_loc (gimple_location (gs), ADDR_EXPR,
+			  build_pointer_type (TREE_TYPE (decl)), decl);
+}
+
+inline void
+gimple_call_set_fndecl (gimple *gs, tree decl)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  gimple_call_set_fndecl (gc, decl);
+}
+
+
+/* Set internal function FN to be the function called by call statement CALL_STMT.  */
+
+inline void
+gimple_call_set_internal_fn (gcall *call_stmt, enum internal_fn fn)
+{
+  gcc_gimple_checking_assert (gimple_call_internal_p (call_stmt));
+  call_stmt->u.internal_fn = fn;
+}
+
+
+/* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
+   Otherwise return NULL.  This function is analogous to
+   get_callee_fndecl in tree land.  */
+
+inline tree
+gimple_call_fndecl (const gcall *gs)
+{
+  return gimple_call_addr_fndecl (gimple_call_fn (gs));
+}
+
+inline tree
+gimple_call_fndecl (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_fndecl (gc);
+}
+
+
+/* Return the type returned by call statement GS.  */
+
+inline tree
+gimple_call_return_type (const gcall *gs)
+{
+  tree type = gimple_call_fntype (gs);
+
+  if (type == NULL_TREE)
+    return TREE_TYPE (gimple_call_lhs (gs));
+
+  /* The type returned by a function is the type of its
+     function type.  */
+  return TREE_TYPE (type);
+}
+
+
+/* Return the static chain for call statement GS.  */
+
+inline tree
+gimple_call_chain (const gcall *gs)
+{
+  return gs->op[2];
+}
+
+inline tree
+gimple_call_chain (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_chain (gc);
+}
+
+
+/* Return a pointer to the static chain for call statement CALL_STMT.  */
+
+inline tree *
+gimple_call_chain_ptr (gcall *call_stmt)
+{
+  return &call_stmt->op[2];
+}
+
+/* Set CHAIN to be the static chain for call statement CALL_STMT.  */
+
+inline void
+gimple_call_set_chain (gcall *call_stmt, tree chain)
+{
+  call_stmt->op[2] = chain;
+}
+
+
+/* Return the number of arguments used by call statement GS.  */
+
+inline unsigned
+gimple_call_num_args (const gcall *gs)
+{
+  return gimple_num_ops (gs) - 3;
+}
+
+inline unsigned
+gimple_call_num_args (const gimple *gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_num_args (gc);
+}
+
+
+/* Return the argument at position INDEX for call statement GS.  */
+
+inline tree
+gimple_call_arg (const gcall *gs, unsigned index)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
+  return gs->op[index + 3];
+}
+
+inline tree
+gimple_call_arg (const gimple *gs, unsigned index)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_arg (gc, index);
+}
+
+
+/* Return a pointer to the argument at position INDEX for call
+   statement GS.  */
+
+inline tree *
+gimple_call_arg_ptr (gcall *gs, unsigned index)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
+  return &gs->op[index + 3];
+}
+
+inline tree *
+gimple_call_arg_ptr (gimple *gs, unsigned index)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  return gimple_call_arg_ptr (gc, index);
+}
+
+
+/* Set ARG to be the argument at position INDEX for call statement GS.  */
+
+inline void
+gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
+  gs->op[index + 3] = arg;
+}
+
+inline void
+gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  gimple_call_set_arg (gc, index, arg);
+}
+
+
+/* If TAIL_P is true, mark call statement S as being a tail call
+   (i.e., a call just before the exit of a function).  These calls are
+   candidate for tail call optimization.  */
+
+inline void
+gimple_call_set_tail (gcall *s, bool tail_p)
+{
+  if (tail_p)
+    s->subcode |= GF_CALL_TAILCALL;
+  else
+    s->subcode &= ~GF_CALL_TAILCALL;
+}
+
+
+/* Return true if GIMPLE_CALL S is marked as a tail call.  */
+
+inline bool
+gimple_call_tail_p (const gcall *s)
+{
+  return (s->subcode & GF_CALL_TAILCALL) != 0;
+}
+
+/* Mark (or clear) call statement S as requiring tail call optimization.  */
+
+inline void
+gimple_call_set_must_tail (gcall *s, bool must_tail_p)
+{
+  if (must_tail_p)
+    s->subcode |= GF_CALL_MUST_TAIL_CALL;
+  else
+    s->subcode &= ~GF_CALL_MUST_TAIL_CALL;
+}
+
+/* Return true if call statement has been marked as requiring
+   tail call optimization.  */
+
+inline bool
+gimple_call_must_tail_p (const gcall *s)
+{
+  return (s->subcode & GF_CALL_MUST_TAIL_CALL) != 0;
+}
+
+/* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
+   slot optimization.  This transformation uses the target of the call
+   expansion as the return slot for calls that return in memory.  */
+
+inline void
+gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p)
+{
+  if (return_slot_opt_p)
+    s->subcode |= GF_CALL_RETURN_SLOT_OPT;
+  else
+    s->subcode &= ~GF_CALL_RETURN_SLOT_OPT;
+}
+
+
+/* Return true if S is marked for return slot optimization.  */
+
+inline bool
+gimple_call_return_slot_opt_p (const gcall *s)
+{
+  return (s->subcode & GF_CALL_RETURN_SLOT_OPT) != 0;
+}
+
+
+/* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
+   thunk to the thunked-to function.  */
+
+inline void
+gimple_call_set_from_thunk (gcall *s, bool from_thunk_p)
+{
+  if (from_thunk_p)
+    s->subcode |= GF_CALL_FROM_THUNK;
+  else
+    s->subcode &= ~GF_CALL_FROM_THUNK;
+}
+
+
+/* Return true if GIMPLE_CALL S is a jump from a thunk.  */
+
+inline bool
+gimple_call_from_thunk_p (gcall *s)
+{
+  return (s->subcode & GF_CALL_FROM_THUNK) != 0;
+}
+
+
+/* If FROM_NEW_OR_DELETE_P is true, mark GIMPLE_CALL S as being a call
+   to operator new or delete created from a new or delete expression.  */
+
+inline void
+gimple_call_set_from_new_or_delete (gcall *s, bool from_new_or_delete_p)
+{
+  if (from_new_or_delete_p)
+    s->subcode |= GF_CALL_FROM_NEW_OR_DELETE;
+  else
+    s->subcode &= ~GF_CALL_FROM_NEW_OR_DELETE;
+}
+
+
+/* Return true if GIMPLE_CALL S is a call to operator new or delete from
+   from a new or delete expression.  */
+
+inline bool
+gimple_call_from_new_or_delete (const gcall *s)
+{
+  return (s->subcode & GF_CALL_FROM_NEW_OR_DELETE) != 0;
+}
+
+
+/* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
+   argument pack in its argument list.  */
+
+inline void
+gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p)
+{
+  if (pass_arg_pack_p)
+    s->subcode |= GF_CALL_VA_ARG_PACK;
+  else
+    s->subcode &= ~GF_CALL_VA_ARG_PACK;
+}
+
+
+/* Return true if GIMPLE_CALL S is a stdarg call that needs the
+   argument pack in its argument list.  */
+
+inline bool
+gimple_call_va_arg_pack_p (const gcall *s)
+{
+  return (s->subcode & GF_CALL_VA_ARG_PACK) != 0;
+}
+
+
+/* Return true if S is a noreturn call.  */
+
+inline bool
+gimple_call_noreturn_p (const gcall *s)
+{
+  return (gimple_call_flags (s) & ECF_NORETURN) != 0;
+}
+
+inline bool
+gimple_call_noreturn_p (const gimple *s)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (s);
+  return gimple_call_noreturn_p (gc);
+}
+
+
+/* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
+   even if the called function can throw in other cases.  */
+
+inline void
+gimple_call_set_nothrow (gcall *s, bool nothrow_p)
+{
+  if (nothrow_p)
+    s->subcode |= GF_CALL_NOTHROW;
+  else
+    s->subcode &= ~GF_CALL_NOTHROW;
+}
+
+/* Return true if S is a nothrow call.  */
+
+inline bool
+gimple_call_nothrow_p (gcall *s)
+{
+  return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
+}
+
+/* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
+   is known to be emitted for VLA objects.  Those are wrapped by
+   stack_save/stack_restore calls and hence can't lead to unbounded
+   stack growth even when they occur in loops.  */
+
+inline void
+gimple_call_set_alloca_for_var (gcall *s, bool for_var)
+{
+  if (for_var)
+    s->subcode |= GF_CALL_ALLOCA_FOR_VAR;
+  else
+    s->subcode &= ~GF_CALL_ALLOCA_FOR_VAR;
+}
+
+/* Return true of S is a call to builtin_alloca emitted for VLA objects.  */
+
+inline bool
+gimple_call_alloca_for_var_p (gcall *s)
+{
+  return (s->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
+}
+
+inline bool
+gimple_call_alloca_for_var_p (gimple *s)
+{
+  const gcall *gc = GIMPLE_CHECK2<gcall *> (s);
+  return (gc->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
+}
+
+/* If BY_DESCRIPTOR_P is true, GIMPLE_CALL S is an indirect call for which
+   pointers to nested function are descriptors instead of trampolines.  */
+
+inline void
+gimple_call_set_by_descriptor (gcall  *s, bool by_descriptor_p)
+{
+  if (by_descriptor_p)
+    s->subcode |= GF_CALL_BY_DESCRIPTOR;
+  else
+    s->subcode &= ~GF_CALL_BY_DESCRIPTOR;
+}
+
+/* Return true if S is a by-descriptor call.  */
+
+inline bool
+gimple_call_by_descriptor_p (gcall *s)
+{
+  return (s->subcode & GF_CALL_BY_DESCRIPTOR) != 0;
+}
+
+/* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.  */
+
+inline void
+gimple_call_copy_flags (gcall *dest_call, gcall *orig_call)
+{
+  dest_call->subcode = orig_call->subcode;
+}
+
+
+/* Return a pointer to the points-to solution for the set of call-used
+   variables of the call CALL_STMT.  */
+
+inline struct pt_solution *
+gimple_call_use_set (gcall *call_stmt)
+{
+  return &call_stmt->call_used;
+}
+
+/* As above, but const.  */
+
+inline const pt_solution *
+gimple_call_use_set (const gcall *call_stmt)
+{
+  return &call_stmt->call_used;
+}
+
+/* Return a pointer to the points-to solution for the set of call-used
+   variables of the call CALL_STMT.  */
+
+inline struct pt_solution *
+gimple_call_clobber_set (gcall *call_stmt)
+{
+  return &call_stmt->call_clobbered;
+}
+
+/* As above, but const.  */
+
+inline const pt_solution *
+gimple_call_clobber_set (const gcall *call_stmt)
+{
+  return &call_stmt->call_clobbered;
+}
+
+
+/* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
+   non-NULL lhs.  */
+
+inline bool
+gimple_has_lhs (const gimple *stmt)
+{
+  if (is_gimple_assign (stmt))
+    return true;
+  if (const gcall *call = dyn_cast <const gcall *> (stmt))
+    return gimple_call_lhs (call) != NULL_TREE;
+  return false;
+}
+
+
+/* Return the code of the predicate computed by conditional statement GS.  */
+
+inline enum tree_code
+gimple_cond_code (const gcond *gs)
+{
+  return (enum tree_code) gs->subcode;
+}
+
+inline enum tree_code
+gimple_cond_code (const gimple *gs)
+{
+  const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
+  return gimple_cond_code (gc);
+}
+
+
+/* Set CODE to be the predicate code for the conditional statement GS.  */
+
+inline void
+gimple_cond_set_code (gcond *gs, enum tree_code code)
+{
+  gs->subcode = code;
+}
+
+
+/* Return the LHS of the predicate computed by conditional statement GS.  */
+
+inline tree
+gimple_cond_lhs (const gcond *gs)
+{
+  return gs->op[0];
+}
+
+inline tree
+gimple_cond_lhs (const gimple *gs)
+{
+  const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
+  return gimple_cond_lhs (gc);
+}
+
+/* Return the pointer to the LHS of the predicate computed by conditional
+   statement GS.  */
+
+inline tree *
+gimple_cond_lhs_ptr (gcond *gs)
+{
+  return &gs->op[0];
+}
+
+/* Set LHS to be the LHS operand of the predicate computed by
+   conditional statement GS.  */
+
+inline void
+gimple_cond_set_lhs (gcond *gs, tree lhs)
+{
+  gs->op[0] = lhs;
+}
+
+
+/* Return the RHS operand of the predicate computed by conditional GS.  */
+
+inline tree
+gimple_cond_rhs (const gcond *gs)
+{
+  return gs->op[1];
+}
+
+inline tree
+gimple_cond_rhs (const gimple *gs)
+{
+  const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
+  return gimple_cond_rhs (gc);
+}
+
+/* Return the pointer to the RHS operand of the predicate computed by
+   conditional GS.  */
+
+inline tree *
+gimple_cond_rhs_ptr (gcond *gs)
+{
+  return &gs->op[1];
+}
+
+
+/* Set RHS to be the RHS operand of the predicate computed by
+   conditional statement GS.  */
+
+inline void
+gimple_cond_set_rhs (gcond *gs, tree rhs)
+{
+  gs->op[1] = rhs;
+}
+
+
+/* Return the label used by conditional statement GS when its
+   predicate evaluates to true.  */
+
+inline tree
+gimple_cond_true_label (const gcond *gs)
+{
+  return gs->op[2];
+}
+
+
+/* Set LABEL to be the label used by conditional statement GS when its
+   predicate evaluates to true.  */
+
+inline void
+gimple_cond_set_true_label (gcond *gs, tree label)
+{
+  gs->op[2] = label;
+}
+
+
+/* Set LABEL to be the label used by conditional statement GS when its
+   predicate evaluates to false.  */
+
+inline void
+gimple_cond_set_false_label (gcond *gs, tree label)
+{
+  gs->op[3] = label;
+}
+
+
+/* Return the label used by conditional statement GS when its
+   predicate evaluates to false.  */
+
+inline tree
+gimple_cond_false_label (const gcond *gs)
+{
+  return gs->op[3];
+}
+
+
+/* Set the conditional COND_STMT to be of the form 'if (1 == 0)'.  */
+
+inline void
+gimple_cond_make_false (gcond *gs)
+{
+  gimple_cond_set_lhs (gs, boolean_false_node);
+  gimple_cond_set_rhs (gs, boolean_false_node);
+  gs->subcode = NE_EXPR;
+}
+
+
+/* Set the conditional COND_STMT to be of the form 'if (1 == 1)'.  */
+
+inline void
+gimple_cond_make_true (gcond *gs)
+{
+  gimple_cond_set_lhs (gs, boolean_true_node);
+  gimple_cond_set_rhs (gs, boolean_false_node);
+  gs->subcode = NE_EXPR;
+}
+
+/* Check if conditional statemente GS is of the form 'if (1 == 1)',
+  'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
+
+inline bool
+gimple_cond_true_p (const gcond *gs)
+{
+  tree lhs = gimple_cond_lhs (gs);
+  tree rhs = gimple_cond_rhs (gs);
+  enum tree_code code = gimple_cond_code (gs);
+
+  if (lhs != boolean_true_node && lhs != boolean_false_node)
+    return false;
+
+  if (rhs != boolean_true_node && rhs != boolean_false_node)
+    return false;
+
+  if (code == NE_EXPR && lhs != rhs)
+    return true;
+
+  if (code == EQ_EXPR && lhs == rhs)
+      return true;
+
+  return false;
+}
+
+/* Check if conditional statement GS is of the form 'if (1 != 1)',
+   'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
+
+inline bool
+gimple_cond_false_p (const gcond *gs)
+{
+  tree lhs = gimple_cond_lhs (gs);
+  tree rhs = gimple_cond_rhs (gs);
+  enum tree_code code = gimple_cond_code (gs);
+
+  if (lhs != boolean_true_node && lhs != boolean_false_node)
+    return false;
+
+  if (rhs != boolean_true_node && rhs != boolean_false_node)
+    return false;
+
+  if (code == NE_EXPR && lhs == rhs)
+    return true;
+
+  if (code == EQ_EXPR && lhs != rhs)
+      return true;
+
+  return false;
+}
+
+/* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS.  */
+
+inline void
+gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs,
+			   tree rhs)
+{
+  gimple_cond_set_code (stmt, code);
+  gimple_cond_set_lhs (stmt, lhs);
+  gimple_cond_set_rhs (stmt, rhs);
+}
+
+
+/* Return the tree code for the expression computed by STMT.  This is
+   only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN.  For
+   GIMPLE_CALL, return CALL_EXPR as the expression code for
+   consistency.  This is useful when the caller needs to deal with the
+   three kinds of computation that GIMPLE supports.  */
+
+inline enum tree_code
+gimple_expr_code (const gimple *stmt)
+{
+  if (const gassign *ass = dyn_cast<const gassign *> (stmt))
+    return gimple_assign_rhs_code (ass);
+  if (const gcond *cond = dyn_cast<const gcond *> (stmt))
+    return gimple_cond_code (cond);
+  else
+    {
+      gcc_gimple_checking_assert (gimple_code (stmt) == GIMPLE_CALL);
+      return CALL_EXPR;
+    }
+}
+
+
+/* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS.  */
+
+inline tree
+gimple_label_label (const glabel *gs)
+{
+  return gs->op[0];
+}
+
+
+/* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
+   GS.  */
+
+inline void
+gimple_label_set_label (glabel *gs, tree label)
+{
+  gs->op[0] = label;
+}
+
+
+/* Return the destination of the unconditional jump GS.  */
+
+inline tree
+gimple_goto_dest (const gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_GOTO);
+  return gimple_op (gs, 0);
+}
+
+
+/* Set DEST to be the destination of the unconditonal jump GS.  */
+
+inline void
+gimple_goto_set_dest (ggoto *gs, tree dest)
+{
+  gs->op[0] = dest;
+}
+
+
+/* Return the variables declared in the GIMPLE_BIND statement GS.  */
+
+inline tree
+gimple_bind_vars (const gbind *bind_stmt)
+{
+  return bind_stmt->vars;
+}
+
+
+/* Set VARS to be the set of variables declared in the GIMPLE_BIND
+   statement GS.  */
+
+inline void
+gimple_bind_set_vars (gbind *bind_stmt, tree vars)
+{
+  bind_stmt->vars = vars;
+}
+
+
+/* Append VARS to the set of variables declared in the GIMPLE_BIND
+   statement GS.  */
+
+inline void
+gimple_bind_append_vars (gbind *bind_stmt, tree vars)
+{
+  bind_stmt->vars = chainon (bind_stmt->vars, vars);
+}
+
+
+inline gimple_seq *
+gimple_bind_body_ptr (gbind *bind_stmt)
+{
+  return &bind_stmt->body;
+}
+
+/* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS.  */
+
+inline gimple_seq
+gimple_bind_body (const gbind *gs)
+{
+  return *gimple_bind_body_ptr (const_cast <gbind *> (gs));
+}
+
+
+/* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
+   statement GS.  */
+
+inline void
+gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq)
+{
+  bind_stmt->body = seq;
+}
+
+
+/* Append a statement to the end of a GIMPLE_BIND's body.  */
+
+inline void
+gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt)
+{
+  gimple_seq_add_stmt (&bind_stmt->body, stmt);
+}
+
+
+/* Append a sequence of statements to the end of a GIMPLE_BIND's body.  */
+
+inline void
+gimple_bind_add_seq (gbind *bind_stmt, gimple_seq seq)
+{
+  gimple_seq_add_seq (&bind_stmt->body, seq);
+}
+
+
+/* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
+   GS.  This is analogous to the BIND_EXPR_BLOCK field in trees.  */
+
+inline tree
+gimple_bind_block (const gbind *bind_stmt)
+{
+  return bind_stmt->block;
+}
+
+
+/* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
+   statement GS.  */
+
+inline void
+gimple_bind_set_block (gbind *bind_stmt, tree block)
+{
+  gcc_gimple_checking_assert (block == NULL_TREE
+			      || TREE_CODE (block) == BLOCK);
+  bind_stmt->block = block;
+}
+
+
+/* Return the number of input operands for GIMPLE_ASM ASM_STMT.  */
+
+inline unsigned
+gimple_asm_ninputs (const gasm *asm_stmt)
+{
+  return asm_stmt->ni;
+}
+
+
+/* Return the number of output operands for GIMPLE_ASM ASM_STMT.  */
+
+inline unsigned
+gimple_asm_noutputs (const gasm *asm_stmt)
+{
+  return asm_stmt->no;
+}
+
+
+/* Return the number of clobber operands for GIMPLE_ASM ASM_STMT.  */
+
+inline unsigned
+gimple_asm_nclobbers (const gasm *asm_stmt)
+{
+  return asm_stmt->nc;
+}
+
+/* Return the number of label operands for GIMPLE_ASM ASM_STMT.  */
+
+inline unsigned
+gimple_asm_nlabels (const gasm *asm_stmt)
+{
+  return asm_stmt->nl;
+}
+
+/* Return input operand INDEX of GIMPLE_ASM ASM_STMT.  */
+
+inline tree
+gimple_asm_input_op (const gasm *asm_stmt, unsigned index)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->ni);
+  return asm_stmt->op[index + asm_stmt->no];
+}
+
+/* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT.  */
+
+inline void
+gimple_asm_set_input_op (gasm *asm_stmt, unsigned index, tree in_op)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->ni
+			      && TREE_CODE (in_op) == TREE_LIST);
+  asm_stmt->op[index + asm_stmt->no] = in_op;
+}
+
+
+/* Return output operand INDEX of GIMPLE_ASM ASM_STMT.  */
+
+inline tree
+gimple_asm_output_op (const gasm *asm_stmt, unsigned index)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->no);
+  return asm_stmt->op[index];
+}
+
+/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT.  */
+
+inline void
+gimple_asm_set_output_op (gasm *asm_stmt, unsigned index, tree out_op)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->no
+			      && TREE_CODE (out_op) == TREE_LIST);
+  asm_stmt->op[index] = out_op;
+}
+
+
+/* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT.  */
+
+inline tree
+gimple_asm_clobber_op (const gasm *asm_stmt, unsigned index)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->nc);
+  return asm_stmt->op[index + asm_stmt->ni + asm_stmt->no];
+}
+
+
+/* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT.  */
+
+inline void
+gimple_asm_set_clobber_op (gasm *asm_stmt, unsigned index, tree clobber_op)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->nc
+			      && TREE_CODE (clobber_op) == TREE_LIST);
+  asm_stmt->op[index + asm_stmt->ni + asm_stmt->no] = clobber_op;
+}
+
+/* Return label operand INDEX of GIMPLE_ASM ASM_STMT.  */
+
+inline tree
+gimple_asm_label_op (const gasm *asm_stmt, unsigned index)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->nl);
+  return asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc];
+}
+
+/* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT.  */
+
+inline void
+gimple_asm_set_label_op (gasm *asm_stmt, unsigned index, tree label_op)
+{
+  gcc_gimple_checking_assert (index < asm_stmt->nl
+			      && TREE_CODE (label_op) == TREE_LIST);
+  asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc] = label_op;
+}
+
+/* Return the string representing the assembly instruction in
+   GIMPLE_ASM ASM_STMT.  */
+
+inline const char *
+gimple_asm_string (const gasm *asm_stmt)
+{
+  return asm_stmt->string;
+}
+
+
+/* Return true if ASM_STMT is marked volatile.  */
+
+inline bool
+gimple_asm_volatile_p (const gasm *asm_stmt)
+{
+  return (asm_stmt->subcode & GF_ASM_VOLATILE) != 0;
+}
+
+
+/* If VOLATILE_P is true, mark asm statement ASM_STMT as volatile.  */
+
+inline void
+gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
+{
+  if (volatile_p)
+    asm_stmt->subcode |= GF_ASM_VOLATILE;
+  else
+    asm_stmt->subcode &= ~GF_ASM_VOLATILE;
+}
+
+
+/* Return true if ASM_STMT is marked inline.  */
+
+inline bool
+gimple_asm_inline_p (const gasm *asm_stmt)
+{
+  return (asm_stmt->subcode & GF_ASM_INLINE) != 0;
+}
+
+
+/* If INLINE_P is true, mark asm statement ASM_STMT as inline.  */
+
+inline void
+gimple_asm_set_inline (gasm *asm_stmt, bool inline_p)
+{
+  if (inline_p)
+    asm_stmt->subcode |= GF_ASM_INLINE;
+  else
+    asm_stmt->subcode &= ~GF_ASM_INLINE;
+}
+
+
+/* If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT.  */
+
+inline void
+gimple_asm_set_input (gasm *asm_stmt, bool input_p)
+{
+  if (input_p)
+    asm_stmt->subcode |= GF_ASM_INPUT;
+  else
+    asm_stmt->subcode &= ~GF_ASM_INPUT;
+}
+
+
+/* Return true if asm ASM_STMT is an ASM_INPUT.  */
+
+inline bool
+gimple_asm_input_p (const gasm *asm_stmt)
+{
+  return (asm_stmt->subcode & GF_ASM_INPUT) != 0;
+}
+
+
+/* Return the types handled by GIMPLE_CATCH statement CATCH_STMT.  */
+
+inline tree
+gimple_catch_types (const gcatch *catch_stmt)
+{
+  return catch_stmt->types;
+}
+
+
+/* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT.  */
+
+inline tree *
+gimple_catch_types_ptr (gcatch *catch_stmt)
+{
+  return &catch_stmt->types;
+}
+
+
+/* Return a pointer to the GIMPLE sequence representing the body of
+   the handler of GIMPLE_CATCH statement CATCH_STMT.  */
+
+inline gimple_seq *
+gimple_catch_handler_ptr (gcatch *catch_stmt)
+{
+  return &catch_stmt->handler;
+}
+
+
+/* Return the GIMPLE sequence representing the body of the handler of
+   GIMPLE_CATCH statement CATCH_STMT.  */
+
+inline gimple_seq
+gimple_catch_handler (const gcatch *catch_stmt)
+{
+  return *gimple_catch_handler_ptr (const_cast <gcatch *> (catch_stmt));
+}
+
+
+/* Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT.  */
+
+inline void
+gimple_catch_set_types (gcatch *catch_stmt, tree t)
+{
+  catch_stmt->types = t;
+}
+
+
+/* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT.  */
+
+inline void
+gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler)
+{
+  catch_stmt->handler = handler;
+}
+
+
+/* Return the types handled by GIMPLE_EH_FILTER statement GS.  */
+
+inline tree
+gimple_eh_filter_types (const gimple *gs)
+{
+  const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
+  return eh_filter_stmt->types;
+}
+
+
+/* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
+   GS.  */
+
+inline tree *
+gimple_eh_filter_types_ptr (gimple *gs)
+{
+  geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
+  return &eh_filter_stmt->types;
+}
+
+
+/* Return a pointer to the sequence of statement to execute when
+   GIMPLE_EH_FILTER statement fails.  */
+
+inline gimple_seq *
+gimple_eh_filter_failure_ptr (gimple *gs)
+{
+  geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
+  return &eh_filter_stmt->failure;
+}
+
+
+/* Return the sequence of statement to execute when GIMPLE_EH_FILTER
+   statement fails.  */
+
+inline gimple_seq
+gimple_eh_filter_failure (const gimple *gs)
+{
+  return *gimple_eh_filter_failure_ptr (const_cast <gimple *> (gs));
+}
+
+
+/* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
+   EH_FILTER_STMT.  */
+
+inline void
+gimple_eh_filter_set_types (geh_filter *eh_filter_stmt, tree types)
+{
+  eh_filter_stmt->types = types;
+}
+
+
+/* Set FAILURE to be the sequence of statements to execute on failure
+   for GIMPLE_EH_FILTER EH_FILTER_STMT.  */
+
+inline void
+gimple_eh_filter_set_failure (geh_filter *eh_filter_stmt,
+			      gimple_seq failure)
+{
+  eh_filter_stmt->failure = failure;
+}
+
+/* Get the function decl to be called by the MUST_NOT_THROW region.  */
+
+inline tree
+gimple_eh_must_not_throw_fndecl (const geh_mnt *eh_mnt_stmt)
+{
+  return eh_mnt_stmt->fndecl;
+}
+
+/* Set the function decl to be called by GS to DECL.  */
+
+inline void
+gimple_eh_must_not_throw_set_fndecl (geh_mnt *eh_mnt_stmt,
+				     tree decl)
+{
+  eh_mnt_stmt->fndecl = decl;
+}
+
+/* GIMPLE_EH_ELSE accessors.  */
+
+inline gimple_seq *
+gimple_eh_else_n_body_ptr (geh_else *eh_else_stmt)
+{
+  return &eh_else_stmt->n_body;
+}
+
+inline gimple_seq
+gimple_eh_else_n_body (const geh_else *eh_else_stmt)
+{
+  return *gimple_eh_else_n_body_ptr (const_cast <geh_else *> (eh_else_stmt));
+}
+
+inline gimple_seq *
+gimple_eh_else_e_body_ptr (geh_else *eh_else_stmt)
+{
+  return &eh_else_stmt->e_body;
+}
+
+inline gimple_seq
+gimple_eh_else_e_body (const geh_else *eh_else_stmt)
+{
+  return *gimple_eh_else_e_body_ptr (const_cast <geh_else *> (eh_else_stmt));
+}
+
+inline void
+gimple_eh_else_set_n_body (geh_else *eh_else_stmt, gimple_seq seq)
+{
+  eh_else_stmt->n_body = seq;
+}
+
+inline void
+gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq)
+{
+  eh_else_stmt->e_body = seq;
+}
+
+/* GIMPLE_TRY accessors. */
+
+/* Return the kind of try block represented by GIMPLE_TRY GS.  This is
+   either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.  */
+
+inline enum gimple_try_flags
+gimple_try_kind (const gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_TRY);
+  return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
+}
+
+
+/* Set the kind of try block represented by GIMPLE_TRY GS.  */
+
+inline void
+gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind)
+{
+  gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH
+			      || kind == GIMPLE_TRY_FINALLY);
+  if (gimple_try_kind (gs) != kind)
+    gs->subcode = (unsigned int) kind;
+}
+
+
+/* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
+
+inline bool
+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;
+}
+
+
+/* Return a pointer to the sequence of statements used as the
+   body for GIMPLE_TRY GS.  */
+
+inline gimple_seq *
+gimple_try_eval_ptr (gimple *gs)
+{
+  gtry *try_stmt = as_a <gtry *> (gs);
+  return &try_stmt->eval;
+}
+
+
+/* Return the sequence of statements used as the body for GIMPLE_TRY GS.  */
+
+inline gimple_seq
+gimple_try_eval (const gimple *gs)
+{
+  return *gimple_try_eval_ptr (const_cast <gimple *> (gs));
+}
+
+
+/* Return a pointer to the sequence of statements used as the cleanup body for
+   GIMPLE_TRY GS.  */
+
+inline gimple_seq *
+gimple_try_cleanup_ptr (gimple *gs)
+{
+  gtry *try_stmt = as_a <gtry *> (gs);
+  return &try_stmt->cleanup;
+}
+
+
+/* Return the sequence of statements used as the cleanup body for
+   GIMPLE_TRY GS.  */
+
+inline gimple_seq
+gimple_try_cleanup (const gimple *gs)
+{
+  return *gimple_try_cleanup_ptr (const_cast <gimple *> (gs));
+}
+
+
+/* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
+
+inline void
+gimple_try_set_catch_is_cleanup (gtry *g, bool catch_is_cleanup)
+{
+  gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
+  if (catch_is_cleanup)
+    g->subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
+  else
+    g->subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
+}
+
+
+/* Set EVAL to be the sequence of statements to use as the body for
+   GIMPLE_TRY TRY_STMT.  */
+
+inline void
+gimple_try_set_eval (gtry *try_stmt, gimple_seq eval)
+{
+  try_stmt->eval = eval;
+}
+
+
+/* Set CLEANUP to be the sequence of statements to use as the cleanup
+   body for GIMPLE_TRY TRY_STMT.  */
+
+inline void
+gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup)
+{
+  try_stmt->cleanup = cleanup;
+}
+
+
+/* Return a pointer to the cleanup sequence for cleanup statement GS.  */
+
+inline gimple_seq *
+gimple_wce_cleanup_ptr (gimple *gs)
+{
+  gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+  return &wce_stmt->cleanup;
+}
+
+
+/* Return the cleanup sequence for cleanup statement GS.  */
+
+inline gimple_seq
+gimple_wce_cleanup (gimple *gs)
+{
+  return *gimple_wce_cleanup_ptr (gs);
+}
+
+
+/* Set CLEANUP to be the cleanup sequence for GS.  */
+
+inline void
+gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup)
+{
+  gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+  wce_stmt->cleanup = cleanup;
+}
+
+
+/* Return the CLEANUP_EH_ONLY flag for a WCE tuple.  */
+
+inline bool
+gimple_wce_cleanup_eh_only (const gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
+  return gs->subcode != 0;
+}
+
+
+/* Set the CLEANUP_EH_ONLY flag for a WCE tuple.  */
+
+inline void
+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;
+}
+
+
+/* Return the maximum number of arguments supported by GIMPLE_PHI GS.  */
+
+inline unsigned
+gimple_phi_capacity (const gimple *gs)
+{
+  const gphi *phi_stmt = as_a <const gphi *> (gs);
+  return phi_stmt->capacity;
+}
+
+
+/* Return the number of arguments in GIMPLE_PHI GS.  This must always
+   be exactly the number of incoming edges for the basic block holding
+   GS.  */
+
+inline unsigned
+gimple_phi_num_args (const gimple *gs)
+{
+  const gphi *phi_stmt = as_a <const gphi *> (gs);
+  return phi_stmt->nargs;
+}
+
+
+/* Return the SSA name created by GIMPLE_PHI GS.  */
+
+inline tree
+gimple_phi_result (const gphi *gs)
+{
+  return gs->result;
+}
+
+inline tree
+gimple_phi_result (const gimple *gs)
+{
+  const gphi *phi_stmt = as_a <const gphi *> (gs);
+  return gimple_phi_result (phi_stmt);
+}
+
+/* Return a pointer to the SSA name created by GIMPLE_PHI GS.  */
+
+inline tree *
+gimple_phi_result_ptr (gphi *gs)
+{
+  return &gs->result;
+}
+
+inline tree *
+gimple_phi_result_ptr (gimple *gs)
+{
+  gphi *phi_stmt = as_a <gphi *> (gs);
+  return gimple_phi_result_ptr (phi_stmt);
+}
+
+/* Set RESULT to be the SSA name created by GIMPLE_PHI PHI.  */
+
+inline void
+gimple_phi_set_result (gphi *phi, tree result)
+{
+  phi->result = result;
+  if (result && TREE_CODE (result) == SSA_NAME)
+    SSA_NAME_DEF_STMT (result) = phi;
+}
+
+
+/* Return the PHI argument corresponding to incoming edge INDEX for
+   GIMPLE_PHI GS.  */
+
+inline struct phi_arg_d *
+gimple_phi_arg (gphi *gs, unsigned index)
+{
+  gcc_gimple_checking_assert (index < gs->nargs);
+  return &(gs->args[index]);
+}
+
+inline const phi_arg_d *
+gimple_phi_arg (const gphi *gs, unsigned index)
+{
+  gcc_gimple_checking_assert (index < gs->nargs);
+  return &(gs->args[index]);
+}
+
+inline struct phi_arg_d *
+gimple_phi_arg (gimple *gs, unsigned index)
+{
+  gphi *phi_stmt = as_a <gphi *> (gs);
+  return gimple_phi_arg (phi_stmt, index);
+}
+
+/* Set PHIARG to be the argument corresponding to incoming edge INDEX
+   for GIMPLE_PHI PHI.  */
+
+inline void
+gimple_phi_set_arg (gphi *phi, unsigned index, struct phi_arg_d * phiarg)
+{
+  gcc_gimple_checking_assert (index < phi->nargs);
+  phi->args[index] = *phiarg;
+}
+
+/* Return the PHI nodes for basic block BB, or NULL if there are no
+   PHI nodes.  */
+
+inline gimple_seq
+phi_nodes (const_basic_block bb)
+{
+  gcc_checking_assert (!(bb->flags & BB_RTL));
+  return bb->il.gimple.phi_nodes;
+}
+
+/* Return a pointer to the PHI nodes for basic block BB.  */
+
+inline gimple_seq *
+phi_nodes_ptr (basic_block bb)
+{
+  gcc_checking_assert (!(bb->flags & BB_RTL));
+  return &bb->il.gimple.phi_nodes;
+}
+
+/* Return the tree operand for argument I of PHI node GS.  */
+
+inline tree
+gimple_phi_arg_def (const gphi *gs, size_t index)
+{
+  return gimple_phi_arg (gs, index)->def;
+}
+
+inline tree
+gimple_phi_arg_def (gimple *gs, size_t index)
+{
+  return gimple_phi_arg (gs, index)->def;
+}
+
+
+/* Return a pointer to the tree operand for argument I of phi node PHI.  */
+
+inline tree *
+gimple_phi_arg_def_ptr (gphi *phi, size_t index)
+{
+  return &gimple_phi_arg (phi, index)->def;
+}
+
+/* Return the edge associated with argument I of phi node PHI.  */
+
+inline edge
+gimple_phi_arg_edge (const gphi *phi, size_t i)
+{
+  return EDGE_PRED (gimple_bb (phi), i);
+}
+
+/* Return the source location of gimple argument I of phi node PHI.  */
+
+inline location_t
+gimple_phi_arg_location (const gphi *phi, size_t i)
+{
+  return gimple_phi_arg (phi, i)->locus;
+}
+
+/* Return the source location of the argument on edge E of phi node PHI.  */
+
+inline location_t
+gimple_phi_arg_location_from_edge (gphi *phi, edge e)
+{
+  return gimple_phi_arg (phi, e->dest_idx)->locus;
+}
+
+/* Set the source location of gimple argument I of phi node PHI to LOC.  */
+
+inline void
+gimple_phi_arg_set_location (gphi *phi, size_t i, location_t loc)
+{
+  gimple_phi_arg (phi, i)->locus = loc;
+}
+
+/* Return address of source location of gimple argument I of phi node PHI.  */
+
+inline location_t *
+gimple_phi_arg_location_ptr (gphi *phi, size_t i)
+{
+  return &gimple_phi_arg (phi, i)->locus;
+}
+
+/* Return TRUE if argument I of phi node PHI has a location record.  */
+
+inline bool
+gimple_phi_arg_has_location (const gphi *phi, size_t i)
+{
+  return gimple_phi_arg_location (phi, i) != UNKNOWN_LOCATION;
+}
+
+/* Return the number of arguments that can be accessed by gimple_arg.  */
+
+inline unsigned
+gimple_num_args (const gimple *gs)
+{
+  if (auto phi = dyn_cast<const gphi *> (gs))
+    return gimple_phi_num_args (phi);
+  if (auto call = dyn_cast<const gcall *> (gs))
+    return gimple_call_num_args (call);
+  return gimple_num_ops (as_a <const gassign *> (gs)) - 1;
+}
+
+/* GS must be an assignment, a call, or a PHI.
+   If it's an assignment, return rhs operand I.
+   If it's a call, return function argument I.
+   If it's a PHI, return the value of PHI argument I.  */
+
+inline tree
+gimple_arg (const gimple *gs, unsigned int i)
+{
+  if (auto phi = dyn_cast<const gphi *> (gs))
+    return gimple_phi_arg_def (phi, i);
+  if (auto call = dyn_cast<const gcall *> (gs))
+    return gimple_call_arg (call, i);
+  return gimple_op (as_a <const gassign *> (gs), i + 1);
+}
+
+/* Return a pointer to gimple_arg (GS, I).  */
+
+inline tree *
+gimple_arg_ptr (gimple *gs, unsigned int i)
+{
+  if (auto phi = dyn_cast<gphi *> (gs))
+    return gimple_phi_arg_def_ptr (phi, i);
+  if (auto call = dyn_cast<gcall *> (gs))
+    return gimple_call_arg_ptr (call, i);
+  return gimple_op_ptr (as_a <gassign *> (gs), i + 1);
+}
+
+/* Return the region number for GIMPLE_RESX RESX_STMT.  */
+
+inline int
+gimple_resx_region (const gresx *resx_stmt)
+{
+  return resx_stmt->region;
+}
+
+/* Set REGION to be the region number for GIMPLE_RESX RESX_STMT.  */
+
+inline void
+gimple_resx_set_region (gresx *resx_stmt, int region)
+{
+  resx_stmt->region = region;
+}
+
+/* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT.  */
+
+inline int
+gimple_eh_dispatch_region (const geh_dispatch *eh_dispatch_stmt)
+{
+  return eh_dispatch_stmt->region;
+}
+
+/* Set REGION to be the region number for GIMPLE_EH_DISPATCH
+   EH_DISPATCH_STMT.  */
+
+inline void
+gimple_eh_dispatch_set_region (geh_dispatch *eh_dispatch_stmt, int region)
+{
+  eh_dispatch_stmt->region = region;
+}
+
+/* Return the number of labels associated with the switch statement GS.  */
+
+inline unsigned
+gimple_switch_num_labels (const gswitch *gs)
+{
+  unsigned num_ops;
+  GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+  num_ops = gimple_num_ops (gs);
+  gcc_gimple_checking_assert (num_ops > 1);
+  return num_ops - 1;
+}
+
+
+/* Set NLABELS to be the number of labels for the switch statement GS.  */
+
+inline void
+gimple_switch_set_num_labels (gswitch *g, unsigned nlabels)
+{
+  GIMPLE_CHECK (g, GIMPLE_SWITCH);
+  gimple_set_num_ops (g, nlabels + 1);
+}
+
+
+/* Return the index variable used by the switch statement GS.  */
+
+inline tree
+gimple_switch_index (const gswitch *gs)
+{
+  return gs->op[0];
+}
+
+
+/* Return a pointer to the index variable for the switch statement GS.  */
+
+inline tree *
+gimple_switch_index_ptr (gswitch *gs)
+{
+  return &gs->op[0];
+}
+
+
+/* Set INDEX to be the index variable for switch statement GS.  */
+
+inline void
+gimple_switch_set_index (gswitch *gs, tree index)
+{
+  gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
+  gs->op[0] = index;
+}
+
+
+/* Return the label numbered INDEX.  The default label is 0, followed by any
+   labels in a switch statement.  */
+
+inline tree
+gimple_switch_label (const gswitch *gs, unsigned index)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
+  return gs->op[index + 1];
+}
+
+/* Set the label number INDEX to LABEL.  0 is always the default label.  */
+
+inline void
+gimple_switch_set_label (gswitch *gs, unsigned index, tree label)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1
+			      && (label == NULL_TREE
+			          || TREE_CODE (label) == CASE_LABEL_EXPR));
+  gs->op[index + 1] = label;
+}
+
+/* Return the default label for a switch statement.  */
+
+inline tree
+gimple_switch_default_label (const gswitch *gs)
+{
+  tree label = gimple_switch_label (gs, 0);
+  gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
+  return label;
+}
+
+/* Set the default label for a switch statement.  */
+
+inline void
+gimple_switch_set_default_label (gswitch *gs, tree label)
+{
+  gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
+  gimple_switch_set_label (gs, 0, label);
+}
+
+/* Return true if GS is a GIMPLE_DEBUG statement.  */
+
+inline bool
+is_gimple_debug (const gimple *gs)
+{
+  return gimple_code (gs) == GIMPLE_DEBUG;
+}
+
+
+/* Return the first nondebug statement in GIMPLE sequence S.  */
+
+inline gimple *
+gimple_seq_first_nondebug_stmt (gimple_seq s)
+{
+  gimple_seq_node n = gimple_seq_first (s);
+  while (n && is_gimple_debug (n))
+    n = n->next;
+  return n;
+}
+
+
+/* Return the last nondebug statement in GIMPLE sequence S.  */
+
+inline gimple *
+gimple_seq_last_nondebug_stmt (gimple_seq s)
+{
+  gimple_seq_node n;
+  for (n = gimple_seq_last (s);
+       n && is_gimple_debug (n);
+       n = n->prev)
+    if (n == s)
+      return NULL;
+  return n;
+}
+
+
+/* Return true if S is a GIMPLE_DEBUG BIND statement.  */
+
+inline bool
+gimple_debug_bind_p (const gimple *s)
+{
+  if (is_gimple_debug (s))
+    return s->subcode == GIMPLE_DEBUG_BIND;
+
+  return false;
+}
+
+/* Return the variable bound in a GIMPLE_DEBUG bind statement.  */
+
+inline tree
+gimple_debug_bind_get_var (const gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
+  return gimple_op (dbg, 0);
+}
+
+/* Return the value bound to the variable in a GIMPLE_DEBUG bind
+   statement.  */
+
+inline tree
+gimple_debug_bind_get_value (const gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
+  return gimple_op (dbg, 1);
+}
+
+/* Return a pointer to the value bound to the variable in a
+   GIMPLE_DEBUG bind statement.  */
+
+inline tree *
+gimple_debug_bind_get_value_ptr (gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
+  return gimple_op_ptr (dbg, 1);
+}
+
+/* Set the variable bound in a GIMPLE_DEBUG bind statement.  */
+
+inline void
+gimple_debug_bind_set_var (gimple *dbg, tree var)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
+  gimple_set_op (dbg, 0, var);
+}
+
+/* Set the value bound to the variable in a GIMPLE_DEBUG bind
+   statement.  */
+
+inline void
+gimple_debug_bind_set_value (gimple *dbg, tree value)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
+  gimple_set_op (dbg, 1, value);
+}
+
+/* The second operand of a GIMPLE_DEBUG_BIND, when the value was
+   optimized away.  */
+#define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
+
+/* Remove the value bound to the variable in a GIMPLE_DEBUG bind
+   statement.  */
+
+inline void
+gimple_debug_bind_reset_value (gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
+  gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
+}
+
+/* Return true if the GIMPLE_DEBUG bind statement is bound to a
+   value.  */
+
+inline bool
+gimple_debug_bind_has_value_p (gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
+  return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
+}
+
+#undef GIMPLE_DEBUG_BIND_NOVALUE
+
+/* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement.  */
+
+inline bool
+gimple_debug_source_bind_p (const gimple *s)
+{
+  if (is_gimple_debug (s))
+    return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
+
+  return false;
+}
+
+/* Return the variable bound in a GIMPLE_DEBUG source bind statement.  */
+
+inline tree
+gimple_debug_source_bind_get_var (const gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
+  return gimple_op (dbg, 0);
+}
+
+/* Return the value bound to the variable in a GIMPLE_DEBUG source bind
+   statement.  */
+
+inline tree
+gimple_debug_source_bind_get_value (const gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
+  return gimple_op (dbg, 1);
+}
+
+/* Return a pointer to the value bound to the variable in a
+   GIMPLE_DEBUG source bind statement.  */
+
+inline tree *
+gimple_debug_source_bind_get_value_ptr (gimple *dbg)
+{
+  GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+  gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
+  return gimple_op_ptr (dbg, 1);
+}
+
+/* Set the variable bound in a GIMPLE_DEBUG source bind statement.  */
+
+inline void
+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));
+  gimple_set_op (dbg, 0, var);
+}
+
+/* Set the value bound to the variable in a GIMPLE_DEBUG source bind
+   statement.  */
+
+inline void
+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));
+  gimple_set_op (dbg, 1, value);
+}
+
+/* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement.  */
+
+inline bool
+gimple_debug_begin_stmt_p (const gimple *s)
+{
+  if (is_gimple_debug (s))
+    return s->subcode == GIMPLE_DEBUG_BEGIN_STMT;
+
+  return false;
+}
+
+/* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement.  */
+
+inline bool
+gimple_debug_inline_entry_p (const gimple *s)
+{
+  if (is_gimple_debug (s))
+    return s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
+
+  return false;
+}
+
+/* Return true if S is a GIMPLE_DEBUG non-binding marker statement.  */
+
+inline bool
+gimple_debug_nonbind_marker_p (const gimple *s)
+{
+  if (is_gimple_debug (s))
+    return s->subcode == GIMPLE_DEBUG_BEGIN_STMT
+      || s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
+
+  return false;
+}
+
+/* Return the line number for EXPR, or return -1 if we have no line
+   number information for it.  */
+inline int
+get_lineno (const gimple *stmt)
+{
+  location_t loc;
+
+  if (!stmt)
+    return -1;
+
+  loc = gimple_location (stmt);
+  if (loc == UNKNOWN_LOCATION)
+    return -1;
+
+  return LOCATION_LINE (loc);
+}
+
+/* Return a pointer to the body for the OMP statement GS.  */
+
+inline gimple_seq *
+gimple_omp_body_ptr (gimple *gs)
+{
+  return &static_cast <gimple_statement_omp *> (gs)->body;
+}
+
+/* Return the body for the OMP statement GS.  */
+
+inline gimple_seq
+gimple_omp_body (const gimple *gs)
+{
+  return *gimple_omp_body_ptr (const_cast <gimple *> (gs));
+}
+
+/* Set BODY to be the body for the OMP statement GS.  */
+
+inline void
+gimple_omp_set_body (gimple *gs, gimple_seq body)
+{
+  static_cast <gimple_statement_omp *> (gs)->body = body;
+}
+
+
+/* Return the name associated with OMP_CRITICAL statement CRIT_STMT.  */
+
+inline tree
+gimple_omp_critical_name (const gomp_critical *crit_stmt)
+{
+  return crit_stmt->name;
+}
+
+
+/* Return a pointer to the name associated with OMP critical statement
+   CRIT_STMT.  */
+
+inline tree *
+gimple_omp_critical_name_ptr (gomp_critical *crit_stmt)
+{
+  return &crit_stmt->name;
+}
+
+
+/* Set NAME to be the name associated with OMP critical statement
+   CRIT_STMT.  */
+
+inline void
+gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
+{
+  crit_stmt->name = name;
+}
+
+
+/* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT.  */
+
+inline tree
+gimple_omp_critical_clauses (const gomp_critical *crit_stmt)
+{
+  return crit_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP critical statement
+   CRIT_STMT.  */
+
+inline tree *
+gimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt)
+{
+  return &crit_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP critical statement
+   CRIT_STMT.  */
+
+inline void
+gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses)
+{
+  crit_stmt->clauses = clauses;
+}
+
+
+/* Return the clauses associated with OMP_ORDERED statement ORD_STMT.  */
+
+inline tree
+gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt)
+{
+  return ord_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP ordered statement
+   ORD_STMT.  */
+
+inline tree *
+gimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt)
+{
+  return &ord_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP ordered statement
+   ORD_STMT.  */
+
+inline void
+gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
+{
+  ord_stmt->clauses = clauses;
+}
+
+
+/* Return the clauses associated with OMP_SCAN statement SCAN_STMT.  */
+
+inline tree
+gimple_omp_scan_clauses (const gomp_scan *scan_stmt)
+{
+  return scan_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP scan statement
+   ORD_STMT.  */
+
+inline tree *
+gimple_omp_scan_clauses_ptr (gomp_scan *scan_stmt)
+{
+  return &scan_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP scan statement
+   ORD_STMT.  */
+
+inline void
+gimple_omp_scan_set_clauses (gomp_scan *scan_stmt, tree clauses)
+{
+  scan_stmt->clauses = clauses;
+}
+
+
+/* Return the clauses associated with OMP_TASKGROUP statement GS.  */
+
+inline tree
+gimple_omp_taskgroup_clauses (const gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
+  return
+    static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP taskgroup statement
+   GS.  */
+
+inline tree *
+gimple_omp_taskgroup_clauses_ptr (gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
+  return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP taskgroup statement
+   GS.  */
+
+inline void
+gimple_omp_taskgroup_set_clauses (gimple *gs, tree clauses)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
+  static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
+    = clauses;
+}
+
+
+/* Return the clauses associated with OMP_MASKED statement GS.  */
+
+inline tree
+gimple_omp_masked_clauses (const gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
+  return
+    static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP masked statement
+   GS.  */
+
+inline tree *
+gimple_omp_masked_clauses_ptr (gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
+  return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP masked statement
+   GS.  */
+
+inline void
+gimple_omp_masked_set_clauses (gimple *gs, tree clauses)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
+  static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
+    = clauses;
+}
+
+
+/* Return the clauses associated with OMP_SCOPE statement GS.  */
+
+inline tree
+gimple_omp_scope_clauses (const gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
+  return
+    static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP scope statement
+   GS.  */
+
+inline tree *
+gimple_omp_scope_clauses_ptr (gimple *gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
+  return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP scope statement
+   GS.  */
+
+inline void
+gimple_omp_scope_set_clauses (gimple *gs, tree clauses)
+{
+  GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
+  static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
+    = clauses;
+}
+
+
+/* Return the kind of the OMP_FOR statemement G.  */
+
+inline int
+gimple_omp_for_kind (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
+  return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK);
+}
+
+
+/* Set the kind of the OMP_FOR statement G.  */
+
+inline void
+gimple_omp_for_set_kind (gomp_for *g, int kind)
+{
+  g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK)
+		      | (kind & GF_OMP_FOR_KIND_MASK);
+}
+
+
+/* Return true if OMP_FOR statement G has the
+   GF_OMP_FOR_COMBINED flag set.  */
+
+inline bool
+gimple_omp_for_combined_p (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
+  return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0;
+}
+
+
+/* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
+   the boolean value of COMBINED_P.  */
+
+inline void
+gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
+{
+  if (combined_p)
+    g->subcode |= GF_OMP_FOR_COMBINED;
+  else
+    g->subcode &= ~GF_OMP_FOR_COMBINED;
+}
+
+
+/* Return true if the OMP_FOR statement G has the
+   GF_OMP_FOR_COMBINED_INTO flag set.  */
+
+inline bool
+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;
+}
+
+
+/* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
+   on the boolean value of COMBINED_P.  */
+
+inline void
+gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
+{
+  if (combined_p)
+    g->subcode |= GF_OMP_FOR_COMBINED_INTO;
+  else
+    g->subcode &= ~GF_OMP_FOR_COMBINED_INTO;
+}
+
+
+/* Return the clauses associated with the OMP_FOR statement GS.  */
+
+inline tree
+gimple_omp_for_clauses (const gimple *gs)
+{
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
+  return omp_for_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with the OMP_FOR statement
+   GS.  */
+
+inline tree *
+gimple_omp_for_clauses_ptr (gimple *gs)
+{
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
+  return &omp_for_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
+   GS.  */
+
+inline void
+gimple_omp_for_set_clauses (gimple *gs, tree clauses)
+{
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
+  omp_for_stmt->clauses = clauses;
+}
+
+
+/* Get the collapse count of the OMP_FOR statement GS.  */
+
+inline size_t
+gimple_omp_for_collapse (const gimple *gs)
+{
+  const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
+  return omp_for_stmt->collapse;
+}
+
+
+/* Return the condition code associated with the OMP_FOR statement GS.  */
+
+inline enum tree_code
+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);
+  return omp_for_stmt->iter[i].cond;
+}
+
+
+/* Set COND to be the condition code for the OMP_FOR statement GS.  */
+
+inline void
+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
+			      && i < omp_for_stmt->collapse);
+  omp_for_stmt->iter[i].cond = cond;
+}
+
+
+/* Return the index variable for the OMP_FOR statement GS.  */
+
+inline tree
+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);
+  return omp_for_stmt->iter[i].index;
+}
+
+
+/* Return a pointer to the index variable for the OMP_FOR statement GS.  */
+
+inline tree *
+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);
+  return &omp_for_stmt->iter[i].index;
+}
+
+
+/* Set INDEX to be the index variable for the OMP_FOR statement GS.  */
+
+inline void
+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);
+  omp_for_stmt->iter[i].index = index;
+}
+
+
+/* Return the initial value for the OMP_FOR statement GS.  */
+
+inline tree
+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);
+  return omp_for_stmt->iter[i].initial;
+}
+
+
+/* Return a pointer to the initial value for the OMP_FOR statement GS.  */
+
+inline tree *
+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);
+  return &omp_for_stmt->iter[i].initial;
+}
+
+
+/* Set INITIAL to be the initial value for the OMP_FOR statement GS.  */
+
+inline void
+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);
+  omp_for_stmt->iter[i].initial = initial;
+}
+
+
+/* Return the final value for the OMP_FOR statement GS.  */
+
+inline tree
+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);
+  return omp_for_stmt->iter[i].final;
+}
+
+
+/* Return a pointer to the final value for the OMP_FOR statement GS.  */
+
+inline tree *
+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);
+  return &omp_for_stmt->iter[i].final;
+}
+
+
+/* Set FINAL to be the final value for the OMP_FOR statement GS.  */
+
+inline void
+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);
+  omp_for_stmt->iter[i].final = final;
+}
+
+
+/* Return the increment value for the OMP_FOR statement GS.  */
+
+inline tree
+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);
+  return omp_for_stmt->iter[i].incr;
+}
+
+
+/* Return a pointer to the increment value for the OMP_FOR statement GS.  */
+
+inline tree *
+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);
+  return &omp_for_stmt->iter[i].incr;
+}
+
+
+/* Set INCR to be the increment value for the OMP_FOR statement GS.  */
+
+inline void
+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);
+  omp_for_stmt->iter[i].incr = incr;
+}
+
+
+/* Return a pointer to the sequence of statements to execute before the OMP_FOR
+   statement GS starts.  */
+
+inline gimple_seq *
+gimple_omp_for_pre_body_ptr (gimple *gs)
+{
+  gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
+  return &omp_for_stmt->pre_body;
+}
+
+
+/* Return the sequence of statements to execute before the OMP_FOR
+   statement GS starts.  */
+
+inline gimple_seq
+gimple_omp_for_pre_body (const gimple *gs)
+{
+  return *gimple_omp_for_pre_body_ptr (const_cast <gimple *> (gs));
+}
+
+
+/* Set PRE_BODY to be the sequence of statements to execute before the
+   OMP_FOR statement GS starts.  */
+
+inline void
+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;
+}
+
+/* Return the clauses associated with OMP_PARALLEL GS.  */
+
+inline tree
+gimple_omp_parallel_clauses (const gimple *gs)
+{
+  const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs);
+  return omp_parallel_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP_PARALLEL_STMT.  */
+
+inline tree *
+gimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt)
+{
+  return &omp_parallel_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT.  */
+
+inline void
+gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt,
+				 tree clauses)
+{
+  omp_parallel_stmt->clauses = clauses;
+}
+
+
+/* Return the child function used to hold the body of OMP_PARALLEL_STMT.  */
+
+inline tree
+gimple_omp_parallel_child_fn (const gomp_parallel *omp_parallel_stmt)
+{
+  return omp_parallel_stmt->child_fn;
+}
+
+/* Return a pointer to the child function used to hold the body of
+   OMP_PARALLEL_STMT.  */
+
+inline tree *
+gimple_omp_parallel_child_fn_ptr (gomp_parallel *omp_parallel_stmt)
+{
+  return &omp_parallel_stmt->child_fn;
+}
+
+
+/* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT.  */
+
+inline void
+gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt,
+				  tree child_fn)
+{
+  omp_parallel_stmt->child_fn = child_fn;
+}
+
+
+/* Return the artificial argument used to send variables and values
+   from the parent to the children threads in OMP_PARALLEL_STMT.  */
+
+inline tree
+gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt)
+{
+  return omp_parallel_stmt->data_arg;
+}
+
+
+/* Return a pointer to the data argument for OMP_PARALLEL_STMT.  */
+
+inline tree *
+gimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt)
+{
+  return &omp_parallel_stmt->data_arg;
+}
+
+
+/* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT.  */
+
+inline void
+gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt,
+				  tree data_arg)
+{
+  omp_parallel_stmt->data_arg = data_arg;
+}
+
+/* Return the clauses associated with OMP_TASK GS.  */
+
+inline tree
+gimple_omp_task_clauses (const gimple *gs)
+{
+  const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
+  return omp_task_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_task_clauses_ptr (gimple *gs)
+{
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
+  return &omp_task_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the list of clauses associated with OMP_TASK
+   GS.  */
+
+inline void
+gimple_omp_task_set_clauses (gimple *gs, tree clauses)
+{
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
+  omp_task_stmt->clauses = clauses;
+}
+
+
+/* Return true if OMP task statement G has the
+   GF_OMP_TASK_TASKLOOP flag set.  */
+
+inline bool
+gimple_omp_task_taskloop_p (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
+  return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKLOOP) != 0;
+}
+
+
+/* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
+   value of TASKLOOP_P.  */
+
+inline void
+gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
+  if (taskloop_p)
+    g->subcode |= GF_OMP_TASK_TASKLOOP;
+  else
+    g->subcode &= ~GF_OMP_TASK_TASKLOOP;
+}
+
+
+/* Return true if OMP task statement G has the
+   GF_OMP_TASK_TASKWAIT flag set.  */
+
+inline bool
+gimple_omp_task_taskwait_p (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
+  return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKWAIT) != 0;
+}
+
+
+/* Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
+   value of TASKWAIT_P.  */
+
+inline void
+gimple_omp_task_set_taskwait_p (gimple *g, bool taskwait_p)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
+  if (taskwait_p)
+    g->subcode |= GF_OMP_TASK_TASKWAIT;
+  else
+    g->subcode &= ~GF_OMP_TASK_TASKWAIT;
+}
+
+
+/* Return the child function used to hold the body of OMP_TASK GS.  */
+
+inline tree
+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;
+}
+
+/* Return a pointer to the child function used to hold the body of
+   OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_task_child_fn_ptr (gimple *gs)
+{
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
+  return &omp_task_stmt->child_fn;
+}
+
+
+/* Set CHILD_FN to be the child function for OMP_TASK GS.  */
+
+inline void
+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;
+}
+
+
+/* Return the artificial argument used to send variables and values
+   from the parent to the children threads in OMP_TASK GS.  */
+
+inline tree
+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;
+}
+
+
+/* Return a pointer to the data argument for OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_task_data_arg_ptr (gimple *gs)
+{
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
+  return &omp_task_stmt->data_arg;
+}
+
+
+/* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
+
+inline void
+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;
+}
+
+
+/* Return the clauses associated with OMP_TASK GS.  */
+
+inline tree
+gimple_omp_taskreg_clauses (const gimple *gs)
+{
+  const gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <const gimple_statement_omp_taskreg *> (gs);
+  return omp_taskreg_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_taskreg_clauses_ptr (gimple *gs)
+{
+  gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <gimple_statement_omp_taskreg *> (gs);
+  return &omp_taskreg_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the list of clauses associated with OMP_TASK
+   GS.  */
+
+inline void
+gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
+{
+  gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <gimple_statement_omp_taskreg *> (gs);
+  omp_taskreg_stmt->clauses = clauses;
+}
+
+
+/* Return the child function used to hold the body of OMP_TASK GS.  */
+
+inline tree
+gimple_omp_taskreg_child_fn (const gimple *gs)
+{
+  const gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <const gimple_statement_omp_taskreg *> (gs);
+  return omp_taskreg_stmt->child_fn;
+}
+
+/* Return a pointer to the child function used to hold the body of
+   OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_taskreg_child_fn_ptr (gimple *gs)
+{
+  gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <gimple_statement_omp_taskreg *> (gs);
+  return &omp_taskreg_stmt->child_fn;
+}
+
+
+/* Set CHILD_FN to be the child function for OMP_TASK GS.  */
+
+inline void
+gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn)
+{
+  gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <gimple_statement_omp_taskreg *> (gs);
+  omp_taskreg_stmt->child_fn = child_fn;
+}
+
+
+/* Return the artificial argument used to send variables and values
+   from the parent to the children threads in OMP_TASK GS.  */
+
+inline tree
+gimple_omp_taskreg_data_arg (const gimple *gs)
+{
+  const gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <const gimple_statement_omp_taskreg *> (gs);
+  return omp_taskreg_stmt->data_arg;
+}
+
+
+/* Return a pointer to the data argument for OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_taskreg_data_arg_ptr (gimple *gs)
+{
+  gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <gimple_statement_omp_taskreg *> (gs);
+  return &omp_taskreg_stmt->data_arg;
+}
+
+
+/* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
+
+inline void
+gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
+{
+  gimple_statement_omp_taskreg *omp_taskreg_stmt
+    = as_a <gimple_statement_omp_taskreg *> (gs);
+  omp_taskreg_stmt->data_arg = data_arg;
+}
+
+
+/* Return the copy function used to hold the body of OMP_TASK GS.  */
+
+inline tree
+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;
+}
+
+/* Return a pointer to the copy function used to hold the body of
+   OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_task_copy_fn_ptr (gimple *gs)
+{
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
+  return &omp_task_stmt->copy_fn;
+}
+
+
+/* Set CHILD_FN to be the copy function for OMP_TASK GS.  */
+
+inline void
+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;
+}
+
+
+/* Return size of the data block in bytes in OMP_TASK GS.  */
+
+inline tree
+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;
+}
+
+
+/* Return a pointer to the data block size for OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_task_arg_size_ptr (gimple *gs)
+{
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
+  return &omp_task_stmt->arg_size;
+}
+
+
+/* Set ARG_SIZE to be the data block size for OMP_TASK GS.  */
+
+inline void
+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;
+}
+
+
+/* Return align of the data block in bytes in OMP_TASK GS.  */
+
+inline tree
+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;
+}
+
+
+/* Return a pointer to the data block align for OMP_TASK GS.  */
+
+inline tree *
+gimple_omp_task_arg_align_ptr (gimple *gs)
+{
+  gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
+  return &omp_task_stmt->arg_align;
+}
+
+
+/* Set ARG_SIZE to be the data block align for OMP_TASK GS.  */
+
+inline void
+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;
+}
+
+
+/* Return the clauses associated with OMP_SINGLE GS.  */
+
+inline tree
+gimple_omp_single_clauses (const gimple *gs)
+{
+  const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
+  return omp_single_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP_SINGLE GS.  */
+
+inline tree *
+gimple_omp_single_clauses_ptr (gimple *gs)
+{
+  gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
+  return &omp_single_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT.  */
+
+inline void
+gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
+{
+  omp_single_stmt->clauses = clauses;
+}
+
+
+/* Return the clauses associated with OMP_TARGET GS.  */
+
+inline tree
+gimple_omp_target_clauses (const gimple *gs)
+{
+  const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
+  return omp_target_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP_TARGET GS.  */
+
+inline tree *
+gimple_omp_target_clauses_ptr (gimple *gs)
+{
+  gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
+  return &omp_target_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT.  */
+
+inline void
+gimple_omp_target_set_clauses (gomp_target *omp_target_stmt,
+			       tree clauses)
+{
+  omp_target_stmt->clauses = clauses;
+}
+
+
+/* Return the kind of the OMP_TARGET G.  */
+
+inline int
+gimple_omp_target_kind (const gimple *g)
+{
+  GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
+  return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK);
+}
+
+
+/* Set the kind of the OMP_TARGET G.  */
+
+inline void
+gimple_omp_target_set_kind (gomp_target *g, int kind)
+{
+  g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK)
+		      | (kind & GF_OMP_TARGET_KIND_MASK);
+}
+
+
+/* Return the child function used to hold the body of OMP_TARGET_STMT.  */
+
+inline tree
+gimple_omp_target_child_fn (const gomp_target *omp_target_stmt)
+{
+  return omp_target_stmt->child_fn;
+}
+
+/* Return a pointer to the child function used to hold the body of
+   OMP_TARGET_STMT.  */
+
+inline tree *
+gimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt)
+{
+  return &omp_target_stmt->child_fn;
+}
+
+
+/* Set CHILD_FN to be the child function for OMP_TARGET_STMT.  */
+
+inline void
+gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt,
+				tree child_fn)
+{
+  omp_target_stmt->child_fn = child_fn;
+}
+
+
+/* Return the artificial argument used to send variables and values
+   from the parent to the children threads in OMP_TARGET_STMT.  */
+
+inline tree
+gimple_omp_target_data_arg (const gomp_target *omp_target_stmt)
+{
+  return omp_target_stmt->data_arg;
+}
+
+
+/* Return a pointer to the data argument for OMP_TARGET GS.  */
+
+inline tree *
+gimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt)
+{
+  return &omp_target_stmt->data_arg;
+}
+
+
+/* Set DATA_ARG to be the data argument for OMP_TARGET_STMT.  */
+
+inline void
+gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt,
+				tree data_arg)
+{
+  omp_target_stmt->data_arg = data_arg;
+}
+
+
+/* Return the clauses associated with OMP_TEAMS GS.  */
+
+inline tree
+gimple_omp_teams_clauses (const gimple *gs)
+{
+  const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
+  return omp_teams_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP_TEAMS GS.  */
+
+inline tree *
+gimple_omp_teams_clauses_ptr (gimple *gs)
+{
+  gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
+  return &omp_teams_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT.  */
+
+inline void
+gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
+{
+  omp_teams_stmt->clauses = clauses;
+}
+
+/* Return the child function used to hold the body of OMP_TEAMS_STMT.  */
+
+inline tree
+gimple_omp_teams_child_fn (const gomp_teams *omp_teams_stmt)
+{
+  return omp_teams_stmt->child_fn;
+}
+
+/* Return a pointer to the child function used to hold the body of
+   OMP_TEAMS_STMT.  */
+
+inline tree *
+gimple_omp_teams_child_fn_ptr (gomp_teams *omp_teams_stmt)
+{
+  return &omp_teams_stmt->child_fn;
+}
+
+
+/* Set CHILD_FN to be the child function for OMP_TEAMS_STMT.  */
+
+inline void
+gimple_omp_teams_set_child_fn (gomp_teams *omp_teams_stmt, tree child_fn)
+{
+  omp_teams_stmt->child_fn = child_fn;
+}
+
+
+/* Return the artificial argument used to send variables and values
+   from the parent to the children threads in OMP_TEAMS_STMT.  */
+
+inline tree
+gimple_omp_teams_data_arg (const gomp_teams *omp_teams_stmt)
+{
+  return omp_teams_stmt->data_arg;
+}
+
+
+/* Return a pointer to the data argument for OMP_TEAMS_STMT.  */
+
+inline tree *
+gimple_omp_teams_data_arg_ptr (gomp_teams *omp_teams_stmt)
+{
+  return &omp_teams_stmt->data_arg;
+}
+
+
+/* Set DATA_ARG to be the data argument for OMP_TEAMS_STMT.  */
+
+inline void
+gimple_omp_teams_set_data_arg (gomp_teams *omp_teams_stmt, tree data_arg)
+{
+  omp_teams_stmt->data_arg = data_arg;
+}
+
+/* Return the host flag of an OMP_TEAMS_STMT.  */
+
+inline bool
+gimple_omp_teams_host (const gomp_teams *omp_teams_stmt)
+{
+  return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_HOST) != 0;
+}
+
+/* Set host flag of an OMP_TEAMS_STMT to VALUE.  */
+
+inline void
+gimple_omp_teams_set_host (gomp_teams *omp_teams_stmt, bool value)
+{
+  if (value)
+    omp_teams_stmt->subcode |= GF_OMP_TEAMS_HOST;
+  else
+    omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_HOST;
+}
+
+/* Return the clauses associated with OMP_SECTIONS GS.  */
+
+inline tree
+gimple_omp_sections_clauses (const gimple *gs)
+{
+  const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
+  return omp_sections_stmt->clauses;
+}
+
+
+/* Return a pointer to the clauses associated with OMP_SECTIONS GS.  */
+
+inline tree *
+gimple_omp_sections_clauses_ptr (gimple *gs)
+{
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
+  return &omp_sections_stmt->clauses;
+}
+
+
+/* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
+   GS.  */
+
+inline void
+gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
+{
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
+  omp_sections_stmt->clauses = clauses;
+}
+
+
+/* Return the control variable associated with the GIMPLE_OMP_SECTIONS
+   in GS.  */
+
+inline tree
+gimple_omp_sections_control (const gimple *gs)
+{
+  const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
+  return omp_sections_stmt->control;
+}
+
+
+/* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
+   GS.  */
+
+inline tree *
+gimple_omp_sections_control_ptr (gimple *gs)
+{
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
+  return &omp_sections_stmt->control;
+}
+
+
+/* Set CONTROL to be the set of clauses associated with the
+   GIMPLE_OMP_SECTIONS in GS.  */
+
+inline void
+gimple_omp_sections_set_control (gimple *gs, tree control)
+{
+  gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
+  omp_sections_stmt->control = control;
+}
+
+
+/* Set the value being stored in an atomic store.  */
+
+inline void
+gimple_omp_atomic_store_set_val (gomp_atomic_store *store_stmt, tree val)
+{
+  store_stmt->val = val;
+}
+
+
+/* Return the value being stored in an atomic store.  */
+
+inline tree
+gimple_omp_atomic_store_val (const gomp_atomic_store *store_stmt)
+{
+  return store_stmt->val;
+}
+
+
+/* Return a pointer to the value being stored in an atomic store.  */
+
+inline tree *
+gimple_omp_atomic_store_val_ptr (gomp_atomic_store *store_stmt)
+{
+  return &store_stmt->val;
+}
+
+
+/* Set the LHS of an atomic load.  */
+
+inline void
+gimple_omp_atomic_load_set_lhs (gomp_atomic_load *load_stmt, tree lhs)
+{
+  load_stmt->lhs = lhs;
+}
+
+
+/* Get the LHS of an atomic load.  */
+
+inline tree
+gimple_omp_atomic_load_lhs (const gomp_atomic_load *load_stmt)
+{
+  return load_stmt->lhs;
+}
+
+
+/* Return a pointer to the LHS of an atomic load.  */
+
+inline tree *
+gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load *load_stmt)
+{
+  return &load_stmt->lhs;
+}
+
+
+/* Set the RHS of an atomic load.  */
+
+inline void
+gimple_omp_atomic_load_set_rhs (gomp_atomic_load *load_stmt, tree rhs)
+{
+  load_stmt->rhs = rhs;
+}
+
+
+/* Get the RHS of an atomic load.  */
+
+inline tree
+gimple_omp_atomic_load_rhs (const gomp_atomic_load *load_stmt)
+{
+  return load_stmt->rhs;
+}
+
+
+/* Return a pointer to the RHS of an atomic load.  */
+
+inline tree *
+gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt)
+{
+  return &load_stmt->rhs;
+}
+
+
+/* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
+
+inline tree
+gimple_omp_continue_control_def (const gomp_continue *cont_stmt)
+{
+  return cont_stmt->control_def;
+}
+
+/* The same as above, but return the address.  */
+
+inline tree *
+gimple_omp_continue_control_def_ptr (gomp_continue *cont_stmt)
+{
+  return &cont_stmt->control_def;
+}
+
+/* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
+
+inline void
+gimple_omp_continue_set_control_def (gomp_continue *cont_stmt, tree def)
+{
+  cont_stmt->control_def = def;
+}
+
+
+/* Get the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
+
+inline tree
+gimple_omp_continue_control_use (const gomp_continue *cont_stmt)
+{
+  return cont_stmt->control_use;
+}
+
+
+/* The same as above, but return the address.  */
+
+inline tree *
+gimple_omp_continue_control_use_ptr (gomp_continue *cont_stmt)
+{
+  return &cont_stmt->control_use;
+}
+
+
+/* Set the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
+
+inline void
+gimple_omp_continue_set_control_use (gomp_continue *cont_stmt, tree use)
+{
+  cont_stmt->control_use = use;
+}
+
+/* Return the guard associated with the GIMPLE_ASSUME statement GS.  */
+
+inline tree
+gimple_assume_guard (const gimple *gs)
+{
+  const gimple_statement_assume *assume_stmt
+    = as_a <const gimple_statement_assume *> (gs);
+  return assume_stmt->guard;
+}
+
+/* Set the guard associated with the GIMPLE_ASSUME statement GS.  */
+
+inline void
+gimple_assume_set_guard (gimple *gs, tree guard)
+{
+  gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
+  assume_stmt->guard = guard;
+}
+
+inline tree *
+gimple_assume_guard_ptr (gimple *gs)
+{
+  gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
+  return &assume_stmt->guard;
+}
+
+/* Return the address of the GIMPLE sequence contained in the GIMPLE_ASSUME
+   statement GS.  */
+
+inline gimple_seq *
+gimple_assume_body_ptr (gimple *gs)
+{
+  gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
+  return &assume_stmt->body;
+}
+
+/* Return the GIMPLE sequence contained in the GIMPLE_ASSUME statement GS.  */
+
+inline gimple_seq
+gimple_assume_body (const gimple *gs)
+{
+  const gimple_statement_assume *assume_stmt
+    = as_a <const gimple_statement_assume *> (gs);
+  return assume_stmt->body;
+}
+
+/* Return a pointer to the body for the GIMPLE_TRANSACTION statement
+   TRANSACTION_STMT.  */
+
+inline gimple_seq *
+gimple_transaction_body_ptr (gtransaction *transaction_stmt)
+{
+  return &transaction_stmt->body;
+}
+
+/* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT.  */
+
+inline gimple_seq
+gimple_transaction_body (const gtransaction *transaction_stmt)
+{
+  return transaction_stmt->body;
+}
+
+/* Return the label associated with a GIMPLE_TRANSACTION.  */
+
+inline tree
+gimple_transaction_label_norm (const gtransaction *transaction_stmt)
+{
+  return transaction_stmt->label_norm;
+}
+
+inline tree *
+gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)
+{
+  return &transaction_stmt->label_norm;
+}
+
+inline tree
+gimple_transaction_label_uninst (const gtransaction *transaction_stmt)
+{
+  return transaction_stmt->label_uninst;
+}
+
+inline tree *
+gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)
+{
+  return &transaction_stmt->label_uninst;
+}
+
+inline tree
+gimple_transaction_label_over (const gtransaction *transaction_stmt)
+{
+  return transaction_stmt->label_over;
+}
+
+inline tree *
+gimple_transaction_label_over_ptr (gtransaction *transaction_stmt)
+{
+  return &transaction_stmt->label_over;
+}
+
+/* Return the subcode associated with a GIMPLE_TRANSACTION.  */
+
+inline unsigned int
+gimple_transaction_subcode (const gtransaction *transaction_stmt)
+{
+  return transaction_stmt->subcode;
+}
+
+/* Set BODY to be the body for the GIMPLE_TRANSACTION statement
+   TRANSACTION_STMT.  */
+
+inline void
+gimple_transaction_set_body (gtransaction *transaction_stmt,
+			     gimple_seq body)
+{
+  transaction_stmt->body = body;
+}
+
+/* Set the label associated with a GIMPLE_TRANSACTION.  */
+
+inline void
+gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label)
+{
+  transaction_stmt->label_norm = label;
+}
+
+inline void
+gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label)
+{
+  transaction_stmt->label_uninst = label;
+}
+
+inline void
+gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label)
+{
+  transaction_stmt->label_over = label;
+}
+
+/* Set the subcode associated with a GIMPLE_TRANSACTION.  */
+
+inline void
+gimple_transaction_set_subcode (gtransaction *transaction_stmt,
+				unsigned int subcode)
+{
+  transaction_stmt->subcode = subcode;
+}
+
+/* Return a pointer to the return value for GIMPLE_RETURN GS.  */
+
+inline tree *
+gimple_return_retval_ptr (greturn *gs)
+{
+  return &gs->op[0];
+}
+
+/* Return the return value for GIMPLE_RETURN GS.  */
+
+inline tree
+gimple_return_retval (const greturn *gs)
+{
+  return gs->op[0];
+}
+
+
+/* Set RETVAL to be the return value for GIMPLE_RETURN GS.  */
+
+inline void
+gimple_return_set_retval (greturn *gs, tree retval)
+{
+  gs->op[0] = retval;
+}
+
+
+/* Returns true when the gimple statement STMT is any of the OMP types.  */
+
+#define CASE_GIMPLE_OMP				\
+    case GIMPLE_OMP_PARALLEL:			\
+    case GIMPLE_OMP_TASK:			\
+    case GIMPLE_OMP_FOR:			\
+    case GIMPLE_OMP_SECTIONS:			\
+    case GIMPLE_OMP_SECTIONS_SWITCH:		\
+    case GIMPLE_OMP_SINGLE:			\
+    case GIMPLE_OMP_TARGET:			\
+    case GIMPLE_OMP_TEAMS:			\
+    case GIMPLE_OMP_SCOPE:			\
+    case GIMPLE_OMP_SECTION:			\
+    case GIMPLE_OMP_MASTER:			\
+    case GIMPLE_OMP_MASKED:			\
+    case GIMPLE_OMP_TASKGROUP:			\
+    case GIMPLE_OMP_ORDERED:			\
+    case GIMPLE_OMP_CRITICAL:			\
+    case GIMPLE_OMP_SCAN:			\
+    case GIMPLE_OMP_RETURN:			\
+    case GIMPLE_OMP_ATOMIC_LOAD:		\
+    case GIMPLE_OMP_ATOMIC_STORE:		\
+    case GIMPLE_OMP_CONTINUE
+
+inline bool
+is_gimple_omp (const gimple *stmt)
+{
+  switch (gimple_code (stmt))
+    {
+    CASE_GIMPLE_OMP:
+      return true;
+    default:
+      return false;
+    }
+}
+
+/* Return true if the OMP gimple statement STMT is any of the OpenACC types
+   specifically.  */
+
+inline bool
+is_gimple_omp_oacc (const gimple *stmt)
+{
+  gcc_assert (is_gimple_omp (stmt));
+  switch (gimple_code (stmt))
+    {
+    case GIMPLE_OMP_ATOMIC_LOAD:
+    case GIMPLE_OMP_ATOMIC_STORE:
+    case GIMPLE_OMP_CONTINUE:
+    case GIMPLE_OMP_RETURN:
+      /* Codes shared between OpenACC and OpenMP cannot be used to disambiguate
+	 the two.  */
+      gcc_unreachable ();
+
+    case GIMPLE_OMP_FOR:
+      switch (gimple_omp_for_kind (stmt))
+	{
+	case GF_OMP_FOR_KIND_OACC_LOOP:
+	  return true;
+	default:
+	  return false;
+	}
+    case GIMPLE_OMP_TARGET:
+      switch (gimple_omp_target_kind (stmt))
+	{
+	case GF_OMP_TARGET_KIND_OACC_PARALLEL:
+	case GF_OMP_TARGET_KIND_OACC_KERNELS:
+	case GF_OMP_TARGET_KIND_OACC_SERIAL:
+	case GF_OMP_TARGET_KIND_OACC_DATA:
+	case GF_OMP_TARGET_KIND_OACC_UPDATE:
+	case GF_OMP_TARGET_KIND_OACC_ENTER_DATA:
+	case GF_OMP_TARGET_KIND_OACC_EXIT_DATA:
+	case GF_OMP_TARGET_KIND_OACC_DECLARE:
+	case GF_OMP_TARGET_KIND_OACC_HOST_DATA:
+	case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
+	case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
+	case GF_OMP_TARGET_KIND_OACC_DATA_KERNELS:
+	  return true;
+	default:
+	  return false;
+	}
+    default:
+      return false;
+    }
+}
+
+
+/* Return true if the OMP gimple statement STMT is offloaded.  */
+
+inline bool
+is_gimple_omp_offloaded (const gimple *stmt)
+{
+  gcc_assert (is_gimple_omp (stmt));
+  switch (gimple_code (stmt))
+    {
+    case GIMPLE_OMP_TARGET:
+      switch (gimple_omp_target_kind (stmt))
+	{
+	case GF_OMP_TARGET_KIND_REGION:
+	case GF_OMP_TARGET_KIND_OACC_PARALLEL:
+	case GF_OMP_TARGET_KIND_OACC_KERNELS:
+	case GF_OMP_TARGET_KIND_OACC_SERIAL:
+	case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
+	case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
+	  return true;
+	default:
+	  return false;
+	}
+    default:
+      return false;
+    }
+}
+
+
+/* Returns TRUE if statement G is a GIMPLE_NOP.  */
+
+inline bool
+gimple_nop_p (const gimple *g)
+{
+  return gimple_code (g) == GIMPLE_NOP;
+}
+
+
+/* Return true if GS is a GIMPLE_RESX.  */
+
+inline bool
+is_gimple_resx (const gimple *gs)
+{
+  return gimple_code (gs) == GIMPLE_RESX;
+}
+
+
+/* Enum and arrays used for allocation stats.  Keep in sync with
+   gimple.cc:gimple_alloc_kind_names.  */
+enum gimple_alloc_kind
+{
+  gimple_alloc_kind_assign,	/* Assignments.  */
+  gimple_alloc_kind_phi,	/* PHI nodes.  */
+  gimple_alloc_kind_cond,	/* Conditionals.  */
+  gimple_alloc_kind_rest,	/* Everything else.  */
+  gimple_alloc_kind_all
+};
+
+extern uint64_t gimple_alloc_counts[];
+extern uint64_t gimple_alloc_sizes[];
+
+/* Return the allocation kind for a given stmt CODE.  */
+inline enum gimple_alloc_kind
+gimple_alloc_kind (enum gimple_code code)
+{
+  switch (code)
+    {
+      case GIMPLE_ASSIGN:
+	return gimple_alloc_kind_assign;
+      case GIMPLE_PHI:
+	return gimple_alloc_kind_phi;
+      case GIMPLE_COND:
+	return gimple_alloc_kind_cond;
+      default:
+	return gimple_alloc_kind_rest;
+    }
+}
+
+/* Return true if a location should not be emitted for this statement
+   by annotate_all_with_location.  */
+
+inline bool
+gimple_do_not_emit_location_p (gimple *g)
+{
+  return gimple_plf (g, GF_PLF_1);
+}
+
+/* Mark statement G so a location will not be emitted by
+   annotate_one_with_location.  */
+
+inline void
+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.  */
+  gimple_set_plf (g, GF_PLF_1, true);
+}
+
+#endif  /* GCC_GIMPLE_H */