CbC/CbC_gcc: gcc/gimple.h comparison

comparison gcc/gimple.h @ 19:58ad6c70ea60

update gcc from 4.4.0 to 4.4.1.

author	kent@firefly.cr.ie.u-ryukyu.ac.jp
date	Thu, 24 Sep 2009 13:21:57 +0900
parents	a06113de4d67
children	9de9dad105d4 77e2b8dfacca

comparison

equal deleted inserted replaced

-:33936f7f2835
+:58ad6c70ea60
 gimple_modified_p (const_gimple g)
 {
 return (gimple_has_ops (g)) ? (bool) g->gsbase.modified : false;
 }
+/* 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.  */
+static inline enum tree_code
+gimple_expr_code (const_gimple stmt)
+{
+enum gimple_code code = gimple_code (stmt);
+if (code == GIMPLE_ASSIGN || code == GIMPLE_COND)
+return (enum tree_code) stmt->gsbase.subcode;
+else if (code == GIMPLE_CALL)
+return CALL_EXPR;
+else
+gcc_unreachable ();
+}
+/* Mark statement S as modified, and update it.  */
+static inline void
+update_stmt (gimple s)
+{
+if (gimple_has_ops (s))
+{
+gimple_set_modified (s, true);
+update_stmt_operands (s);
+}
+}
+/* Update statement S if it has been optimized.  */
+static inline void
+update_stmt_if_modified (gimple s)
+{
+if (gimple_modified_p (s))
+update_stmt_operands (s);
+}
+/* Return true if statement STMT contains volatile operands.  */
+static inline bool
+gimple_has_volatile_ops (const_gimple stmt)
+{
+if (gimple_has_mem_ops (stmt))
+return stmt->gsbase.has_volatile_ops;
+else
+return false;
+}
+/* Set the HAS_VOLATILE_OPS flag to VOLATILEP.  */
+static inline void
+gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
+{
+if (gimple_has_mem_ops (stmt))
+stmt->gsbase.has_volatile_ops = (unsigned) volatilep;
+}
+/* Return true if statement STMT may access memory.  */
+static inline bool
+gimple_references_memory_p (gimple stmt)
+{
+return gimple_has_mem_ops (stmt) && stmt->gsbase.references_memory_p;
+}
+/* Set the REFERENCES_MEMORY_P flag for STMT to MEM_P.  */
+static inline void
+gimple_set_references_memory (gimple stmt, bool mem_p)
+{
+if (gimple_has_mem_ops (stmt))
+stmt->gsbase.references_memory_p = (unsigned) mem_p;
+}
+/* Return the subcode for OMP statement S.  */
+static inline unsigned
+gimple_omp_subcode (const_gimple s)
+{
+gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
+	      && gimple_code (s) <= GIMPLE_OMP_SINGLE);
+return s->gsbase.subcode;
+}
+/* Set the subcode for OMP statement S to SUBCODE.  */
+static 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_assert (subcode < (1 << 16));
+s->gsbase.subcode = subcode;
+}
+/* Set the nowait flag on OMP_RETURN statement S.  */
+static inline void
+gimple_omp_return_set_nowait (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
+s->gsbase.subcode |= GF_OMP_RETURN_NOWAIT;
+}
+/* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
+flag set.  */
+static 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;
+}
+/* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
+flag set.  */
+static 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.  */
+static inline void
+gimple_omp_section_set_last (gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
+g->gsbase.subcode |= GF_OMP_SECTION_LAST;
+}
+/* Return true if OMP parallel statement G has the
+GF_OMP_PARALLEL_COMBINED flag set.  */
+static 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.  */
+static inline void
+gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
+if (combined_p)
+g->gsbase.subcode |= GF_OMP_PARALLEL_COMBINED;
+else
+g->gsbase.subcode &= ~GF_OMP_PARALLEL_COMBINED;
+}
+/* Return the number of operands for statement GS.  */
+static inline unsigned
+gimple_num_ops (const_gimple gs)
+{
+return gs->gsbase.num_ops;
+}
+/* Set the number of operands for statement GS.  */
+static inline void
+gimple_set_num_ops (gimple gs, unsigned num_ops)
+{
+gs->gsbase.num_ops = num_ops;
+}
+/* Return the array of operands for statement GS.  */
+static inline tree *
+gimple_ops (gimple gs)
+{
+/* Offset in bytes to the location of the operand vector in every
+tuple structure.  Defined in gimple.c  */
+extern size_t const gimple_ops_offset_[];
+if (!gimple_has_ops (gs))
+return NULL;
+/* All the tuples have their operand vector at the very bottom
+of the structure.  */
+return ((tree *) ((char *) gs + gimple_ops_offset_[gimple_code (gs)]));
+}
+/* Return operand I for statement GS.  */
+static inline tree
+gimple_op (const_gimple gs, unsigned i)
+{
+if (gimple_has_ops (gs))
+{
+gcc_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.  */
+static inline tree *
+gimple_op_ptr (const_gimple gs, unsigned i)
+{
+if (gimple_has_ops (gs))
+{
+gcc_assert (i < gimple_num_ops (gs));
+return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
+}
+else
+return NULL;
+}
+/* Set operand I of statement GS to OP.  */
+static inline void
+gimple_set_op (gimple gs, unsigned i, tree op)
+{
+gcc_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.  */
+static 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.  */
+static 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.  */
+static inline tree
+gimple_assign_lhs (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+return gimple_op (gs, 0);
+}
+/* Return a pointer to the LHS of assignment statement GS.  */
+static inline tree *
+gimple_assign_lhs_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+return gimple_op_ptr (gs, 0);
+}
+/* Set LHS to be the LHS operand of assignment statement GS.  */
+static inline void
+gimple_assign_set_lhs (gimple gs, tree lhs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+gcc_assert (is_gimple_operand (lhs));
+gimple_set_op (gs, 0, lhs);
+if (lhs && TREE_CODE (lhs) == SSA_NAME)
+SSA_NAME_DEF_STMT (lhs) = gs;
+}
+/* Return the first operand on the RHS of assignment statement GS.  */
+static inline tree
+gimple_assign_rhs1 (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+return gimple_op (gs, 1);
+}
+/* Return a pointer to the first operand on the RHS of assignment
+statement GS.  */
+static inline tree *
+gimple_assign_rhs1_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+return gimple_op_ptr (gs, 1);
+}
+/* Set RHS to be the first operand on the RHS of assignment statement GS.  */
+static inline void
+gimple_assign_set_rhs1 (gimple gs, tree rhs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+/* If there are 3 or more operands, the 2 operands on the RHS must be
+GIMPLE values.  */
+if (gimple_num_ops (gs) >= 3)
+gcc_assert (is_gimple_val (rhs));
+else
+gcc_assert (is_gimple_operand (rhs));
+gimple_set_op (gs, 1, rhs);
+}
+/* Return the second operand on the RHS of assignment statement GS.
+If GS does not have two operands, NULL is returned instead.  */
+static inline tree
+gimple_assign_rhs2 (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+if (gimple_num_ops (gs) >= 3)
+return gimple_op (gs, 2);
+else
+return NULL_TREE;
+}
+/* Return a pointer to the second operand on the RHS of assignment
+statement GS.  */
+static inline tree *
+gimple_assign_rhs2_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+return gimple_op_ptr (gs, 2);
+}
+/* Set RHS to be the second operand on the RHS of assignment statement GS.  */
+static inline void
+gimple_assign_set_rhs2 (gimple gs, tree rhs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+/* The 2 operands on the RHS must be GIMPLE values.  */
+gcc_assert (is_gimple_val (rhs));
+gimple_set_op (gs, 2, rhs);
+}
+/* Returns true if GS is a nontemporal move.  */
+static inline bool
+gimple_assign_nontemporal_move_p (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+return gs->gsbase.nontemporal_move;
+}
+/* Sets nontemporal move flag of GS to NONTEMPORAL.  */
+static inline void
+gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+gs->gsbase.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.  */
+static inline enum tree_code
+gimple_assign_rhs_code (const_gimple gs)
+{
+enum tree_code code;
+GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
+code = gimple_expr_code (gs);
+if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
+code = TREE_CODE (gimple_assign_rhs1 (gs));
+return code;
+}
+/* Set CODE to be the code for the expression computed on the RHS of
+assignment S.  */
+static inline void
+gimple_assign_set_rhs_code (gimple s, enum tree_code code)
+{
+GIMPLE_CHECK (s, GIMPLE_ASSIGN);
+s->gsbase.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.  */
+static 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 S is a type-cast assignment.  */
+static inline bool
+gimple_assign_cast_p (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 GS is a GIMPLE_CALL.  */
+static inline bool
+is_gimple_call (const_gimple gs)
+{
+return gimple_code (gs) == GIMPLE_CALL;
+}
+/* Return the LHS of call statement GS.  */
+static inline tree
+gimple_call_lhs (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op (gs, 0);
+}
+/* Return a pointer to the LHS of call statement GS.  */
+static inline tree *
+gimple_call_lhs_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op_ptr (gs, 0);
+}
+/* Set LHS to be the LHS operand of call statement GS.  */
+static inline void
+gimple_call_set_lhs (gimple gs, tree lhs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+gcc_assert (!lhs || is_gimple_operand (lhs));
+gimple_set_op (gs, 0, lhs);
+if (lhs && TREE_CODE (lhs) == SSA_NAME)
+SSA_NAME_DEF_STMT (lhs) = gs;
+}
+/* Return the tree node representing the function called by call
+statement GS.  */
+static inline tree
+gimple_call_fn (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op (gs, 1);
+}
+/* Return a pointer to the tree node representing the function called by call
+statement GS.  */
+static inline tree *
+gimple_call_fn_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op_ptr (gs, 1);
+}
+/* Set FN to be the function called by call statement GS.  */
+static inline void
+gimple_call_set_fn (gimple gs, tree fn)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+gcc_assert (is_gimple_operand (fn));
+gimple_set_op (gs, 1, fn);
+}
+/* Set FNDECL to be the function called by call statement GS.  */
+static inline void
+gimple_call_set_fndecl (gimple gs, tree decl)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
+gimple_set_op (gs, 1, build_fold_addr_expr (decl));
+}
+/* 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.  */
+static inline tree
+gimple_call_fndecl (const_gimple gs)
+{
+tree addr = gimple_call_fn (gs);
+if (TREE_CODE (addr) == ADDR_EXPR)
+{
+gcc_assert (TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL);
+return TREE_OPERAND (addr, 0);
+}
+return NULL_TREE;
+}
+/* Return the type returned by call statement GS.  */
+static inline tree
+gimple_call_return_type (const_gimple gs)
+{
+tree fn = gimple_call_fn (gs);
+tree type = TREE_TYPE (fn);
+/* See through the pointer.  */
+gcc_assert (POINTER_TYPE_P (type));
+type = TREE_TYPE (type);
+gcc_assert (TREE_CODE (type) == FUNCTION_TYPE
+	      || TREE_CODE (type) == METHOD_TYPE);
+/* The type returned by a FUNCTION_DECL is the type of its
+function type.  */
+return TREE_TYPE (type);
+}
+/* Return the static chain for call statement GS.  */
+static inline tree
+gimple_call_chain (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op (gs, 2);
+}
+/* Return a pointer to the static chain for call statement GS.  */
+static inline tree *
+gimple_call_chain_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op_ptr (gs, 2);
+}
+/* Set CHAIN to be the static chain for call statement GS.  */
+static inline void
+gimple_call_set_chain (gimple gs, tree chain)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+gcc_assert (chain == NULL
+|| TREE_CODE (chain) == ADDR_EXPR
+|| SSA_VAR_P (chain));
+gimple_set_op (gs, 2, chain);
+}
+/* Return the number of arguments used by call statement GS.  */
+static inline unsigned
+gimple_call_num_args (const_gimple gs)
+{
+unsigned num_ops;
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+num_ops = gimple_num_ops (gs);
+gcc_assert (num_ops >= 3);
+return num_ops - 3;
+}
+/* Return the argument at position INDEX for call statement GS.  */
+static inline tree
+gimple_call_arg (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op (gs, index + 3);
+}
+/* Return a pointer to the argument at position INDEX for call
+statement GS.  */
+static inline tree *
+gimple_call_arg_ptr (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+return gimple_op_ptr (gs, index + 3);
+}
+/* Set ARG to be the argument at position INDEX for call statement GS.  */
+static inline void
+gimple_call_set_arg (gimple gs, unsigned index, tree arg)
+{
+GIMPLE_CHECK (gs, GIMPLE_CALL);
+gcc_assert (is_gimple_operand (arg));
+gimple_set_op (gs, index + 3, 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.  */
+static inline void
+gimple_call_set_tail (gimple s, bool tail_p)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+if (tail_p)
+s->gsbase.subcode |= GF_CALL_TAILCALL;
+else
+s->gsbase.subcode &= ~GF_CALL_TAILCALL;
+}
+/* Return true if GIMPLE_CALL S is marked as a tail call.  */
+static inline bool
+gimple_call_tail_p (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+return (s->gsbase.subcode & GF_CALL_TAILCALL) != 0;
+}
+/* Set the inlinable status of GIMPLE_CALL S to INLINABLE_P.  */
+static inline void
+gimple_call_set_cannot_inline (gimple s, bool inlinable_p)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+if (inlinable_p)
+s->gsbase.subcode |= GF_CALL_CANNOT_INLINE;
+else
+s->gsbase.subcode &= ~GF_CALL_CANNOT_INLINE;
+}
+/* Return true if GIMPLE_CALL S cannot be inlined.  */
+static inline bool
+gimple_call_cannot_inline_p (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+return (s->gsbase.subcode & GF_CALL_CANNOT_INLINE) != 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.  */
+static inline void
+gimple_call_set_return_slot_opt (gimple s, bool return_slot_opt_p)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+if (return_slot_opt_p)
+s->gsbase.subcode |= GF_CALL_RETURN_SLOT_OPT;
+else
+s->gsbase.subcode &= ~GF_CALL_RETURN_SLOT_OPT;
+}
+/* Return true if S is marked for return slot optimization.  */
+static inline bool
+gimple_call_return_slot_opt_p (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+return (s->gsbase.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.  */
+static inline void
+gimple_call_set_from_thunk (gimple s, bool from_thunk_p)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+if (from_thunk_p)
+s->gsbase.subcode |= GF_CALL_FROM_THUNK;
+else
+s->gsbase.subcode &= ~GF_CALL_FROM_THUNK;
+}
+/* Return true if GIMPLE_CALL S is a jump from a thunk.  */
+static inline bool
+gimple_call_from_thunk_p (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+return (s->gsbase.subcode & GF_CALL_FROM_THUNK) != 0;
+}
+/* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
+argument pack in its argument list.  */
+static inline void
+gimple_call_set_va_arg_pack (gimple s, bool pass_arg_pack_p)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+if (pass_arg_pack_p)
+s->gsbase.subcode |= GF_CALL_VA_ARG_PACK;
+else
+s->gsbase.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.  */
+static inline bool
+gimple_call_va_arg_pack_p (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+return (s->gsbase.subcode & GF_CALL_VA_ARG_PACK) != 0;
+}
+/* Return true if S is a noreturn call.  */
+static inline bool
+gimple_call_noreturn_p (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+return (gimple_call_flags (s) & ECF_NORETURN) != 0;
+}
+/* Return true if S is a nothrow call.  */
+static inline bool
+gimple_call_nothrow_p (gimple s)
+{
+GIMPLE_CHECK (s, GIMPLE_CALL);
+return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
+}
+/* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.  */
+static inline void
+gimple_call_copy_flags (gimple dest_call, gimple orig_call)
+{
+GIMPLE_CHECK (dest_call, GIMPLE_CALL);
+GIMPLE_CHECK (orig_call, GIMPLE_CALL);
+dest_call->gsbase.subcode = orig_call->gsbase.subcode;
+}
+/* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
+non-NULL lhs.  */
+static inline bool
+gimple_has_lhs (gimple stmt)
+{
+return (is_gimple_assign (stmt)
+	  || (is_gimple_call (stmt)
+	      && gimple_call_lhs (stmt) != NULL_TREE));
+}
+/* Return the code of the predicate computed by conditional statement GS.  */
+static inline enum tree_code
+gimple_cond_code (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+return gs->gsbase.subcode;
+}
+/* Set CODE to be the predicate code for the conditional statement GS.  */
+static inline void
+gimple_cond_set_code (gimple gs, enum tree_code code)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
+gs->gsbase.subcode = code;
+}
+/* Return the LHS of the predicate computed by conditional statement GS.  */
+static inline tree
+gimple_cond_lhs (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+return gimple_op (gs, 0);
+}
+/* Return the pointer to the LHS of the predicate computed by conditional
+statement GS.  */
+static inline tree *
+gimple_cond_lhs_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+return gimple_op_ptr (gs, 0);
+}
+/* Set LHS to be the LHS operand of the predicate computed by
+conditional statement GS.  */
+static inline void
+gimple_cond_set_lhs (gimple gs, tree lhs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+gcc_assert (is_gimple_operand (lhs));
+gimple_set_op (gs, 0, lhs);
+}
+/* Return the RHS operand of the predicate computed by conditional GS.  */
+static inline tree
+gimple_cond_rhs (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+return gimple_op (gs, 1);
+}
+/* Return the pointer to the RHS operand of the predicate computed by
+conditional GS.  */
+static inline tree *
+gimple_cond_rhs_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+return gimple_op_ptr (gs, 1);
+}
+/* Set RHS to be the RHS operand of the predicate computed by
+conditional statement GS.  */
+static inline void
+gimple_cond_set_rhs (gimple gs, tree rhs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+gcc_assert (is_gimple_operand (rhs));
+gimple_set_op (gs, 1, rhs);
+}
+/* Return the label used by conditional statement GS when its
+predicate evaluates to true.  */
+static inline tree
+gimple_cond_true_label (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+return gimple_op (gs, 2);
+}
+/* Set LABEL to be the label used by conditional statement GS when its
+predicate evaluates to true.  */
+static inline void
+gimple_cond_set_true_label (gimple gs, tree label)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
+gimple_set_op (gs, 2, label);
+}
+/* Set LABEL to be the label used by conditional statement GS when its
+predicate evaluates to false.  */
+static inline void
+gimple_cond_set_false_label (gimple gs, tree label)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
+gimple_set_op (gs, 3, label);
+}
+/* Return the label used by conditional statement GS when its
+predicate evaluates to false.  */
+static inline tree
+gimple_cond_false_label (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_COND);
+return gimple_op (gs, 3);
+}
+/* Set the conditional COND_STMT to be of the form 'if (1 == 0)'.  */
+static inline void
+gimple_cond_make_false (gimple gs)
+{
+gimple_cond_set_lhs (gs, boolean_true_node);
+gimple_cond_set_rhs (gs, boolean_false_node);
+gs->gsbase.subcode = EQ_EXPR;
+}
+/* Set the conditional COND_STMT to be of the form 'if (1 == 1)'.  */
+static inline void
+gimple_cond_make_true (gimple gs)
+{
+gimple_cond_set_lhs (gs, boolean_true_node);
+gimple_cond_set_rhs (gs, boolean_true_node);
+gs->gsbase.subcode = EQ_EXPR;
+}
+/* Check if conditional statemente GS is of the form 'if (1 == 1)',
+'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
+static inline bool
+gimple_cond_true_p (const_gimple 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)' */
+static inline bool
+gimple_cond_false_p (const_gimple 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 (var != 0)' or
+'if (var == 1)' */
+static inline bool
+gimple_cond_single_var_p (gimple gs)
+{
+if (gimple_cond_code (gs) == NE_EXPR
+&& gimple_cond_rhs (gs) == boolean_false_node)
+return true;
+if (gimple_cond_code (gs) == EQ_EXPR
+&& gimple_cond_rhs (gs) == boolean_true_node)
+return true;
+return false;
+}
+/* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS.  */
+static inline void
+gimple_cond_set_condition (gimple 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 LABEL_DECL node used by GIMPLE_LABEL statement GS.  */
+static inline tree
+gimple_label_label (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_LABEL);
+return gimple_op (gs, 0);
+}
+/* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
+GS.  */
+static inline void
+gimple_label_set_label (gimple gs, tree label)
+{
+GIMPLE_CHECK (gs, GIMPLE_LABEL);
+gcc_assert (TREE_CODE (label) == LABEL_DECL);
+gimple_set_op (gs, 0, label);
+}
+/* Return the destination of the unconditional jump GS.  */
+static 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.  */
+static inline void
+gimple_goto_set_dest (gimple gs, tree dest)
+{
+GIMPLE_CHECK (gs, GIMPLE_GOTO);
+gcc_assert (is_gimple_operand (dest));
+gimple_set_op (gs, 0, dest);
+}
+/* Return the variables declared in the GIMPLE_BIND statement GS.  */
+static inline tree
+gimple_bind_vars (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+return gs->gimple_bind.vars;
+}
+/* Set VARS to be the set of variables declared in the GIMPLE_BIND
+statement GS.  */
+static inline void
+gimple_bind_set_vars (gimple gs, tree vars)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+gs->gimple_bind.vars = vars;
+}
+/* Append VARS to the set of variables declared in the GIMPLE_BIND
+statement GS.  */
+static inline void
+gimple_bind_append_vars (gimple gs, tree vars)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+gs->gimple_bind.vars = chainon (gs->gimple_bind.vars, vars);
+}
+/* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS.  */
+static inline gimple_seq
+gimple_bind_body (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+return gs->gimple_bind.body;
+}
+/* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
+statement GS.  */
+static inline void
+gimple_bind_set_body (gimple gs, gimple_seq seq)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+gs->gimple_bind.body = seq;
+}
+/* Append a statement to the end of a GIMPLE_BIND's body.  */
+static inline void
+gimple_bind_add_stmt (gimple gs, gimple stmt)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+gimple_seq_add_stmt (&gs->gimple_bind.body, stmt);
+}
+/* Append a sequence of statements to the end of a GIMPLE_BIND's body.  */
+static inline void
+gimple_bind_add_seq (gimple gs, gimple_seq seq)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+gimple_seq_add_seq (&gs->gimple_bind.body, seq);
+}
+/* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
+GS.  This is analogous to the BIND_EXPR_BLOCK field in trees.  */
+static inline tree
+gimple_bind_block (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+return gs->gimple_bind.block;
+}
+/* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
+statement GS.  */
+static inline void
+gimple_bind_set_block (gimple gs, tree block)
+{
+GIMPLE_CHECK (gs, GIMPLE_BIND);
+gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
+gs->gimple_bind.block = block;
+}
+/* Return the number of input operands for GIMPLE_ASM GS.  */
+static inline unsigned
+gimple_asm_ninputs (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+return gs->gimple_asm.ni;
+}
+/* Return the number of output operands for GIMPLE_ASM GS.  */
+static inline unsigned
+gimple_asm_noutputs (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+return gs->gimple_asm.no;
+}
+/* Return the number of clobber operands for GIMPLE_ASM GS.  */
+static inline unsigned
+gimple_asm_nclobbers (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+return gs->gimple_asm.nc;
+}
+/* Return input operand INDEX of GIMPLE_ASM GS.  */
+static inline tree
+gimple_asm_input_op (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.ni);
+return gimple_op (gs, index);
+}
+/* Return a pointer to input operand INDEX of GIMPLE_ASM GS.  */
+static inline tree *
+gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.ni);
+return gimple_op_ptr (gs, index);
+}
+/* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS.  */
+static inline void
+gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.ni);
+gcc_assert (TREE_CODE (in_op) == TREE_LIST);
+gimple_set_op (gs, index, in_op);
+}
+/* Return output operand INDEX of GIMPLE_ASM GS.  */
+static inline tree
+gimple_asm_output_op (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.no);
+return gimple_op (gs, index + gs->gimple_asm.ni);
+}
+/* Return a pointer to output operand INDEX of GIMPLE_ASM GS.  */
+static inline tree *
+gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.no);
+return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
+}
+/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS.  */
+static inline void
+gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.no);
+gcc_assert (TREE_CODE (out_op) == TREE_LIST);
+gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
+}
+/* Return clobber operand INDEX of GIMPLE_ASM GS.  */
+static inline tree
+gimple_asm_clobber_op (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.nc);
+return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
+}
+/* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS.  */
+static inline void
+gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+gcc_assert (index <= gs->gimple_asm.nc);
+gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
+gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
+}
+/* Return the string representing the assembly instruction in
+GIMPLE_ASM GS.  */
+static inline const char *
+gimple_asm_string (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+return gs->gimple_asm.string;
+}
+/* Return true if GS is an asm statement marked volatile.  */
+static inline bool
+gimple_asm_volatile_p (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+return (gs->gsbase.subcode & GF_ASM_VOLATILE) != 0;
+}
+/* If VOLATLE_P is true, mark asm statement GS as volatile.  */
+static inline void
+gimple_asm_set_volatile (gimple gs, bool volatile_p)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+if (volatile_p)
+gs->gsbase.subcode |= GF_ASM_VOLATILE;
+else
+gs->gsbase.subcode &= ~GF_ASM_VOLATILE;
+}
+/* If INPUT_P is true, mark asm GS as an ASM_INPUT.  */
+static inline void
+gimple_asm_set_input (gimple gs, bool input_p)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+if (input_p)
+gs->gsbase.subcode |= GF_ASM_INPUT;
+else
+gs->gsbase.subcode &= ~GF_ASM_INPUT;
+}
+/* Return true if asm GS is an ASM_INPUT.  */
+static inline bool
+gimple_asm_input_p (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_ASM);
+return (gs->gsbase.subcode & GF_ASM_INPUT) != 0;
+}
+/* Return the types handled by GIMPLE_CATCH statement GS.  */
+static inline tree
+gimple_catch_types (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CATCH);
+return gs->gimple_catch.types;
+}
+/* Return a pointer to the types handled by GIMPLE_CATCH statement GS.  */
+static inline tree *
+gimple_catch_types_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CATCH);
+return &gs->gimple_catch.types;
+}
+/* Return the GIMPLE sequence representing the body of the handler of
+GIMPLE_CATCH statement GS.  */
+static inline gimple_seq
+gimple_catch_handler (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CATCH);
+return gs->gimple_catch.handler;
+}
+/* Return a pointer to the GIMPLE sequence representing the body of
+the handler of GIMPLE_CATCH statement GS.  */
+static inline gimple_seq *
+gimple_catch_handler_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CATCH);
+return &gs->gimple_catch.handler;
+}
+/* Set T to be the set of types handled by GIMPLE_CATCH GS.  */
+static inline void
+gimple_catch_set_types (gimple gs, tree t)
+{
+GIMPLE_CHECK (gs, GIMPLE_CATCH);
+gs->gimple_catch.types = t;
+}
+/* Set HANDLER to be the body of GIMPLE_CATCH GS.  */
+static inline void
+gimple_catch_set_handler (gimple gs, gimple_seq handler)
+{
+GIMPLE_CHECK (gs, GIMPLE_CATCH);
+gs->gimple_catch.handler = handler;
+}
+/* Return the types handled by GIMPLE_EH_FILTER statement GS.  */
+static inline tree
+gimple_eh_filter_types (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+return gs->gimple_eh_filter.types;
+}
+/* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
+GS.  */
+static inline tree *
+gimple_eh_filter_types_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+return &gs->gimple_eh_filter.types;
+}
+/* Return the sequence of statement to execute when GIMPLE_EH_FILTER
+statement fails.  */
+static inline gimple_seq
+gimple_eh_filter_failure (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+return gs->gimple_eh_filter.failure;
+}
+/* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS.  */
+static inline void
+gimple_eh_filter_set_types (gimple gs, tree types)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+gs->gimple_eh_filter.types = types;
+}
+/* Set FAILURE to be the sequence of statements to execute on failure
+for GIMPLE_EH_FILTER GS.  */
+static inline void
+gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+gs->gimple_eh_filter.failure = failure;
+}
+/* Return the EH_FILTER_MUST_NOT_THROW flag.  */
+static inline bool
+gimple_eh_filter_must_not_throw (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+return gs->gsbase.subcode != 0;
+}
+/* Set the EH_FILTER_MUST_NOT_THROW flag to the value MNTP.  */
+static inline void
+gimple_eh_filter_set_must_not_throw (gimple gs, bool mntp)
+{
+GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
+gs->gsbase.subcode = (unsigned int) mntp;
+}
+/* GIMPLE_TRY accessors. */
+/* Return the kind of try block represented by GIMPLE_TRY GS.  This is
+either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.  */
+static inline enum gimple_try_flags
+gimple_try_kind (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_TRY);
+return (enum gimple_try_flags) (gs->gsbase.subcode & GIMPLE_TRY_KIND);
+}
+/* Set the kind of try block represented by GIMPLE_TRY GS.  */
+static inline void
+gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
+{
+GIMPLE_CHECK (gs, GIMPLE_TRY);
+gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
+if (gimple_try_kind (gs) != kind)
+gs->gsbase.subcode = (unsigned int) kind;
+}
+/* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
+static inline bool
+gimple_try_catch_is_cleanup (const_gimple gs)
+{
+gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
+return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
+}
+/* Return the sequence of statements used as the body for GIMPLE_TRY GS.  */
+static inline gimple_seq
+gimple_try_eval (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_TRY);
+return gs->gimple_try.eval;
+}
+/* Return the sequence of statements used as the cleanup body for
+GIMPLE_TRY GS.  */
+static inline gimple_seq
+gimple_try_cleanup (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_TRY);
+return gs->gimple_try.cleanup;
+}
+/* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
+static inline void
+gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
+{
+gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
+if (catch_is_cleanup)
+g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
+else
+g->gsbase.subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
+}
+/* Set EVAL to be the sequence of statements to use as the body for
+GIMPLE_TRY GS.  */
+static inline void
+gimple_try_set_eval (gimple gs, gimple_seq eval)
+{
+GIMPLE_CHECK (gs, GIMPLE_TRY);
+gs->gimple_try.eval = eval;
+}
+/* Set CLEANUP to be the sequence of statements to use as the cleanup
+body for GIMPLE_TRY GS.  */
+static inline void
+gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
+{
+GIMPLE_CHECK (gs, GIMPLE_TRY);
+gs->gimple_try.cleanup = cleanup;
+}
+/* Return the cleanup sequence for cleanup statement GS.  */
+static inline gimple_seq
+gimple_wce_cleanup (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
+return gs->gimple_wce.cleanup;
+}
+/* Set CLEANUP to be the cleanup sequence for GS.  */
+static inline void
+gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
+{
+GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
+gs->gimple_wce.cleanup = cleanup;
+}
+/* Return the CLEANUP_EH_ONLY flag for a WCE tuple.  */
+static inline bool
+gimple_wce_cleanup_eh_only (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
+return gs->gsbase.subcode != 0;
+}
+/* Set the CLEANUP_EH_ONLY flag for a WCE tuple.  */
+static inline void
+gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
+{
+GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
+gs->gsbase.subcode = (unsigned int) eh_only_p;
+}
+/* Return the maximum number of arguments supported by GIMPLE_PHI GS.  */
+static inline unsigned
+gimple_phi_capacity (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_PHI);
+return gs->gimple_phi.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.  */
+static inline unsigned
+gimple_phi_num_args (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_PHI);
+return gs->gimple_phi.nargs;
+}
+/* Return the SSA name created by GIMPLE_PHI GS.  */
+static inline tree
+gimple_phi_result (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_PHI);
+return gs->gimple_phi.result;
+}
+/* Return a pointer to the SSA name created by GIMPLE_PHI GS.  */
+static inline tree *
+gimple_phi_result_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_PHI);
+return &gs->gimple_phi.result;
+}
+/* Set RESULT to be the SSA name created by GIMPLE_PHI GS.  */
+static inline void
+gimple_phi_set_result (gimple gs, tree result)
+{
+GIMPLE_CHECK (gs, GIMPLE_PHI);
+gs->gimple_phi.result = result;
+}
+/* Return the PHI argument corresponding to incoming edge INDEX for
+GIMPLE_PHI GS.  */
+static inline struct phi_arg_d *
+gimple_phi_arg (gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_PHI);
+gcc_assert (index <= gs->gimple_phi.capacity);
+return &(gs->gimple_phi.args[index]);
+}
+/* Set PHIARG to be the argument corresponding to incoming edge INDEX
+for GIMPLE_PHI GS.  */
+static inline void
+gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
+{
+GIMPLE_CHECK (gs, GIMPLE_PHI);
+gcc_assert (index <= gs->gimple_phi.nargs);
+memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
+}
+/* Return the region number for GIMPLE_RESX GS.  */
+static inline int
+gimple_resx_region (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_RESX);
+return gs->gimple_resx.region;
+}
+/* Set REGION to be the region number for GIMPLE_RESX GS.  */
+static inline void
+gimple_resx_set_region (gimple gs, int region)
+{
+GIMPLE_CHECK (gs, GIMPLE_RESX);
+gs->gimple_resx.region = region;
+}
+/* Return the number of labels associated with the switch statement GS.  */
+static inline unsigned
+gimple_switch_num_labels (const_gimple gs)
+{
+unsigned num_ops;
+GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+num_ops = gimple_num_ops (gs);
+gcc_assert (num_ops > 1);
+return num_ops - 1;
+}
+/* Set NLABELS to be the number of labels for the switch statement GS.  */
+static inline void
+gimple_switch_set_num_labels (gimple g, unsigned nlabels)
+{
+GIMPLE_CHECK (g, GIMPLE_SWITCH);
+gimple_set_num_ops (g, nlabels + 1);
+}
+/* Return the index variable used by the switch statement GS.  */
+static inline tree
+gimple_switch_index (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+return gimple_op (gs, 0);
+}
+/* Return a pointer to the index variable for the switch statement GS.  */
+static inline tree *
+gimple_switch_index_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+return gimple_op_ptr (gs, 0);
+}
+/* Set INDEX to be the index variable for switch statement GS.  */
+static inline void
+gimple_switch_set_index (gimple gs, tree index)
+{
+GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
+gimple_set_op (gs, 0, index);
+}
+/* Return the label numbered INDEX.  The default label is 0, followed by any
+labels in a switch statement.  */
+static inline tree
+gimple_switch_label (const_gimple gs, unsigned index)
+{
+GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+gcc_assert (gimple_num_ops (gs) > index + 1);
+return gimple_op (gs, index + 1);
+}
+/* Set the label number INDEX to LABEL.  0 is always the default label.  */
+static inline void
+gimple_switch_set_label (gimple gs, unsigned index, tree label)
+{
+GIMPLE_CHECK (gs, GIMPLE_SWITCH);
+gcc_assert (gimple_num_ops (gs) > index + 1);
+gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
+gimple_set_op (gs, index + 1, label);
+}
+/* Return the default label for a switch statement.  */
+static inline tree
+gimple_switch_default_label (const_gimple gs)
+{
+return gimple_switch_label (gs, 0);
+}
+/* Set the default label for a switch statement.  */
+static inline void
+gimple_switch_set_default_label (gimple gs, tree label)
+{
+gimple_switch_set_label (gs, 0, label);
+}
+/* Return the body for the OMP statement GS.  */
+static inline gimple_seq
+gimple_omp_body (gimple gs)
+{
+return gs->omp.body;
+}
+/* Set BODY to be the body for the OMP statement GS.  */
+static inline void
+gimple_omp_set_body (gimple gs, gimple_seq body)
+{
+gs->omp.body = body;
+}
+/* Return the name associated with OMP_CRITICAL statement GS.  */
+static inline tree
+gimple_omp_critical_name (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
+return gs->gimple_omp_critical.name;
+}
+/* Return a pointer to the name associated with OMP critical statement GS.  */
+static inline tree *
+gimple_omp_critical_name_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
+return &gs->gimple_omp_critical.name;
+}
+/* Set NAME to be the name associated with OMP critical statement GS.  */
+static inline void
+gimple_omp_critical_set_name (gimple gs, tree name)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
+gs->gimple_omp_critical.name = name;
+}
+/* Return the clauses associated with OMP_FOR GS.  */
+static inline tree
+gimple_omp_for_clauses (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+return gs->gimple_omp_for.clauses;
+}
+/* Return a pointer to the OMP_FOR GS.  */
+static inline tree *
+gimple_omp_for_clauses_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+return &gs->gimple_omp_for.clauses;
+}
+/* Set CLAUSES to be the list of clauses associated with OMP_FOR GS.  */
+static inline void
+gimple_omp_for_set_clauses (gimple gs, tree clauses)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gs->gimple_omp_for.clauses = clauses;
+}
+/* Get the collapse count of OMP_FOR GS.  */
+static inline size_t
+gimple_omp_for_collapse (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+return gs->gimple_omp_for.collapse;
+}
+/* Return the index variable for OMP_FOR GS.  */
+static inline tree
+gimple_omp_for_index (const_gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return gs->gimple_omp_for.iter[i].index;
+}
+/* Return a pointer to the index variable for OMP_FOR GS.  */
+static inline tree *
+gimple_omp_for_index_ptr (gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return &gs->gimple_omp_for.iter[i].index;
+}
+/* Set INDEX to be the index variable for OMP_FOR GS.  */
+static inline void
+gimple_omp_for_set_index (gimple gs, size_t i, tree index)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+gs->gimple_omp_for.iter[i].index = index;
+}
+/* Return the initial value for OMP_FOR GS.  */
+static inline tree
+gimple_omp_for_initial (const_gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return gs->gimple_omp_for.iter[i].initial;
+}
+/* Return a pointer to the initial value for OMP_FOR GS.  */
+static inline tree *
+gimple_omp_for_initial_ptr (gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return &gs->gimple_omp_for.iter[i].initial;
+}
+/* Set INITIAL to be the initial value for OMP_FOR GS.  */
+static inline void
+gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+gs->gimple_omp_for.iter[i].initial = initial;
+}
+/* Return the final value for OMP_FOR GS.  */
+static inline tree
+gimple_omp_for_final (const_gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return gs->gimple_omp_for.iter[i].final;
+}
+/* Return a pointer to the final value for OMP_FOR GS.  */
+static inline tree *
+gimple_omp_for_final_ptr (gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return &gs->gimple_omp_for.iter[i].final;
+}
+/* Set FINAL to be the final value for OMP_FOR GS.  */
+static inline void
+gimple_omp_for_set_final (gimple gs, size_t i, tree final)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+gs->gimple_omp_for.iter[i].final = final;
+}
+/* Return the increment value for OMP_FOR GS.  */
+static inline tree
+gimple_omp_for_incr (const_gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return gs->gimple_omp_for.iter[i].incr;
+}
+/* Return a pointer to the increment value for OMP_FOR GS.  */
+static inline tree *
+gimple_omp_for_incr_ptr (gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return &gs->gimple_omp_for.iter[i].incr;
+}
+/* Set INCR to be the increment value for OMP_FOR GS.  */
+static inline void
+gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+gs->gimple_omp_for.iter[i].incr = incr;
+}
+/* Return the sequence of statements to execute before the OMP_FOR
+statement GS starts.  */
+static inline gimple_seq
+gimple_omp_for_pre_body (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+return gs->gimple_omp_for.pre_body;
+}
+/* Set PRE_BODY to be the sequence of statements to execute before the
+OMP_FOR statement GS starts.  */
+static inline void
+gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gs->gimple_omp_for.pre_body = pre_body;
+}
+/* Return the clauses associated with OMP_PARALLEL GS.  */
+static inline tree
+gimple_omp_parallel_clauses (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+return gs->gimple_omp_parallel.clauses;
+}
+/* Return a pointer to the clauses associated with OMP_PARALLEL GS.  */
+static inline tree *
+gimple_omp_parallel_clauses_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+return &gs->gimple_omp_parallel.clauses;
+}
+/* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL
+GS.  */
+static inline void
+gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+gs->gimple_omp_parallel.clauses = clauses;
+}
+/* Return the child function used to hold the body of OMP_PARALLEL GS.  */
+static inline tree
+gimple_omp_parallel_child_fn (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+return gs->gimple_omp_parallel.child_fn;
+}
+/* Return a pointer to the child function used to hold the body of
+OMP_PARALLEL GS.  */
+static inline tree *
+gimple_omp_parallel_child_fn_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+return &gs->gimple_omp_parallel.child_fn;
+}
+/* Set CHILD_FN to be the child function for OMP_PARALLEL GS.  */
+static inline void
+gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+gs->gimple_omp_parallel.child_fn = child_fn;
+}
+/* Return the artificial argument used to send variables and values
+from the parent to the children threads in OMP_PARALLEL GS.  */
+static inline tree
+gimple_omp_parallel_data_arg (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+return gs->gimple_omp_parallel.data_arg;
+}
+/* Return a pointer to the data argument for OMP_PARALLEL GS.  */
+static inline tree *
+gimple_omp_parallel_data_arg_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+return &gs->gimple_omp_parallel.data_arg;
+}
+/* Set DATA_ARG to be the data argument for OMP_PARALLEL GS.  */
+static inline void
+gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
+gs->gimple_omp_parallel.data_arg = data_arg;
+}
+/* Return the clauses associated with OMP_TASK GS.  */
+static inline tree
+gimple_omp_task_clauses (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_parallel.clauses;
+}
+/* Return a pointer to the clauses associated with OMP_TASK GS.  */
+static inline tree *
+gimple_omp_task_clauses_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_parallel.clauses;
+}
+/* Set CLAUSES to be the list of clauses associated with OMP_TASK
+GS.  */
+static inline void
+gimple_omp_task_set_clauses (gimple gs, tree clauses)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_parallel.clauses = clauses;
+}
+/* Return the child function used to hold the body of OMP_TASK GS.  */
+static inline tree
+gimple_omp_task_child_fn (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_parallel.child_fn;
+}
+/* Return a pointer to the child function used to hold the body of
+OMP_TASK GS.  */
+static inline tree *
+gimple_omp_task_child_fn_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_parallel.child_fn;
+}
+/* Set CHILD_FN to be the child function for OMP_TASK GS.  */
+static inline void
+gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_parallel.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.  */
+static inline tree
+gimple_omp_task_data_arg (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_parallel.data_arg;
+}
+/* Return a pointer to the data argument for OMP_TASK GS.  */
+static inline tree *
+gimple_omp_task_data_arg_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_parallel.data_arg;
+}
+/* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
+static inline void
+gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_parallel.data_arg = data_arg;
+}
+/* Return the clauses associated with OMP_TASK GS.  */
+static inline tree
+gimple_omp_taskreg_clauses (const_gimple gs)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_parallel.clauses;
+}
+/* Return a pointer to the clauses associated with OMP_TASK GS.  */
+static inline tree *
+gimple_omp_taskreg_clauses_ptr (gimple gs)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_parallel.clauses;
+}
+/* Set CLAUSES to be the list of clauses associated with OMP_TASK
+GS.  */
+static inline void
+gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_parallel.clauses = clauses;
+}
+/* Return the child function used to hold the body of OMP_TASK GS.  */
+static inline tree
+gimple_omp_taskreg_child_fn (const_gimple gs)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_parallel.child_fn;
+}
+/* Return a pointer to the child function used to hold the body of
+OMP_TASK GS.  */
+static inline tree *
+gimple_omp_taskreg_child_fn_ptr (gimple gs)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_parallel.child_fn;
+}
+/* Set CHILD_FN to be the child function for OMP_TASK GS.  */
+static inline void
+gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_parallel.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.  */
+static inline tree
+gimple_omp_taskreg_data_arg (const_gimple gs)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_parallel.data_arg;
+}
+/* Return a pointer to the data argument for OMP_TASK GS.  */
+static inline tree *
+gimple_omp_taskreg_data_arg_ptr (gimple gs)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_parallel.data_arg;
+}
+/* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
+static inline void
+gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
+{
+if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_parallel.data_arg = data_arg;
+}
+/* Return the copy function used to hold the body of OMP_TASK GS.  */
+static inline tree
+gimple_omp_task_copy_fn (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_task.copy_fn;
+}
+/* Return a pointer to the copy function used to hold the body of
+OMP_TASK GS.  */
+static inline tree *
+gimple_omp_task_copy_fn_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_task.copy_fn;
+}
+/* Set CHILD_FN to be the copy function for OMP_TASK GS.  */
+static inline void
+gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_task.copy_fn = copy_fn;
+}
+/* Return size of the data block in bytes in OMP_TASK GS.  */
+static inline tree
+gimple_omp_task_arg_size (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_task.arg_size;
+}
+/* Return a pointer to the data block size for OMP_TASK GS.  */
+static inline tree *
+gimple_omp_task_arg_size_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_task.arg_size;
+}
+/* Set ARG_SIZE to be the data block size for OMP_TASK GS.  */
+static inline void
+gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_task.arg_size = arg_size;
+}
+/* Return align of the data block in bytes in OMP_TASK GS.  */
+static inline tree
+gimple_omp_task_arg_align (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return gs->gimple_omp_task.arg_align;
+}
+/* Return a pointer to the data block align for OMP_TASK GS.  */
+static inline tree *
+gimple_omp_task_arg_align_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+return &gs->gimple_omp_task.arg_align;
+}
+/* Set ARG_SIZE to be the data block align for OMP_TASK GS.  */
+static inline void
+gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
+gs->gimple_omp_task.arg_align = arg_align;
+}
+/* Return the clauses associated with OMP_SINGLE GS.  */
+static inline tree
+gimple_omp_single_clauses (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
+return gs->gimple_omp_single.clauses;
+}
+/* Return a pointer to the clauses associated with OMP_SINGLE GS.  */
+static inline tree *
+gimple_omp_single_clauses_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
+return &gs->gimple_omp_single.clauses;
+}
+/* Set CLAUSES to be the clauses associated with OMP_SINGLE GS.  */
+static inline void
+gimple_omp_single_set_clauses (gimple gs, tree clauses)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
+gs->gimple_omp_single.clauses = clauses;
+}
+/* Return the clauses associated with OMP_SECTIONS GS.  */
+static inline tree
+gimple_omp_sections_clauses (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
+return gs->gimple_omp_sections.clauses;
+}
+/* Return a pointer to the clauses associated with OMP_SECTIONS GS.  */
+static inline tree *
+gimple_omp_sections_clauses_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
+return &gs->gimple_omp_sections.clauses;
+}
+/* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
+GS.  */
+static inline void
+gimple_omp_sections_set_clauses (gimple gs, tree clauses)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
+gs->gimple_omp_sections.clauses = clauses;
+}
+/* Return the control variable associated with the GIMPLE_OMP_SECTIONS
+in GS.  */
+static inline tree
+gimple_omp_sections_control (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
+return gs->gimple_omp_sections.control;
+}
+/* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
+GS.  */
+static inline tree *
+gimple_omp_sections_control_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
+return &gs->gimple_omp_sections.control;
+}
+/* Set CONTROL to be the set of clauses associated with the
+GIMPLE_OMP_SECTIONS in GS.  */
+static inline void
+gimple_omp_sections_set_control (gimple gs, tree control)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
+gs->gimple_omp_sections.control = control;
+}
+/* Set COND to be the condition code for OMP_FOR GS.  */
+static inline void
+gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+gs->gimple_omp_for.iter[i].cond = cond;
+}
+/* Return the condition code associated with OMP_FOR GS.  */
+static inline enum tree_code
+gimple_omp_for_cond (const_gimple gs, size_t i)
+{
+GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
+gcc_assert (i < gs->gimple_omp_for.collapse);
+return gs->gimple_omp_for.iter[i].cond;
+}
+/* Set the value being stored in an atomic store.  */
+static inline void
+gimple_omp_atomic_store_set_val (gimple g, tree val)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+g->gimple_omp_atomic_store.val = val;
+}
+/* Return the value being stored in an atomic store.  */
+static inline tree
+gimple_omp_atomic_store_val (const_gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+return g->gimple_omp_atomic_store.val;
+}
+/* Return a pointer to the value being stored in an atomic store.  */
+static inline tree *
+gimple_omp_atomic_store_val_ptr (gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
+return &g->gimple_omp_atomic_store.val;
+}
+/* Set the LHS of an atomic load.  */
+static inline void
+gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
+g->gimple_omp_atomic_load.lhs = lhs;
+}
+/* Get the LHS of an atomic load.  */
+static inline tree
+gimple_omp_atomic_load_lhs (const_gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
+return g->gimple_omp_atomic_load.lhs;
+}
+/* Return a pointer to the LHS of an atomic load.  */
+static inline tree *
+gimple_omp_atomic_load_lhs_ptr (gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
+return &g->gimple_omp_atomic_load.lhs;
+}
+/* Set the RHS of an atomic load.  */
+static inline void
+gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
+g->gimple_omp_atomic_load.rhs = rhs;
+}
+/* Get the RHS of an atomic load.  */
+static inline tree
+gimple_omp_atomic_load_rhs (const_gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
+return g->gimple_omp_atomic_load.rhs;
+}
+/* Return a pointer to the RHS of an atomic load.  */
+static inline tree *
+gimple_omp_atomic_load_rhs_ptr (gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
+return &g->gimple_omp_atomic_load.rhs;
+}
+/* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
+static inline tree
+gimple_omp_continue_control_def (const_gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
+return g->gimple_omp_continue.control_def;
+}
+/* The same as above, but return the address.  */
+static inline tree *
+gimple_omp_continue_control_def_ptr (gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
+return &g->gimple_omp_continue.control_def;
+}
+/* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
+static inline void
+gimple_omp_continue_set_control_def (gimple g, tree def)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
+g->gimple_omp_continue.control_def = def;
+}
+/* Get the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
+static inline tree
+gimple_omp_continue_control_use (const_gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
+return g->gimple_omp_continue.control_use;
+}
+/* The same as above, but return the address.  */
+static inline tree *
+gimple_omp_continue_control_use_ptr (gimple g)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
+return &g->gimple_omp_continue.control_use;
+}
+/* Set the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
+static inline void
+gimple_omp_continue_set_control_use (gimple g, tree use)
+{
+GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
+g->gimple_omp_continue.control_use = use;
+}
+/* Return a pointer to the return value for GIMPLE_RETURN GS.  */
+static inline tree *
+gimple_return_retval_ptr (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_RETURN);
+gcc_assert (gimple_num_ops (gs) == 1);
+return gimple_op_ptr (gs, 0);
+}
+/* Return the return value for GIMPLE_RETURN GS.  */
+static inline tree
+gimple_return_retval (const_gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_RETURN);
+gcc_assert (gimple_num_ops (gs) == 1);
+return gimple_op (gs, 0);
+}
+/* Set RETVAL to be the return value for GIMPLE_RETURN GS.  */
+static inline void
+gimple_return_set_retval (gimple gs, tree retval)
+{
+GIMPLE_CHECK (gs, GIMPLE_RETURN);
+gcc_assert (gimple_num_ops (gs) == 1);
+gcc_assert (retval == NULL_TREE
+|| TREE_CODE (retval) == RESULT_DECL
+	      || is_gimple_val (retval));
+gimple_set_op (gs, 0, retval);
+}
+/* Returns true when the gimple statment STMT is any of the OpenMP types.  */
+static inline bool
+is_gimple_omp (const_gimple stmt)
+{
+return (gimple_code (stmt) == GIMPLE_OMP_PARALLEL
+	  || gimple_code (stmt) == GIMPLE_OMP_TASK
+	  || gimple_code (stmt) == GIMPLE_OMP_FOR
+	  || gimple_code (stmt) == GIMPLE_OMP_SECTIONS
+	  || gimple_code (stmt) == GIMPLE_OMP_SECTIONS_SWITCH
+	  || gimple_code (stmt) == GIMPLE_OMP_SINGLE
+	  || gimple_code (stmt) == GIMPLE_OMP_SECTION
+	  || gimple_code (stmt) == GIMPLE_OMP_MASTER
+	  || gimple_code (stmt) == GIMPLE_OMP_ORDERED
+	  || gimple_code (stmt) == GIMPLE_OMP_CRITICAL
+	  || gimple_code (stmt) == GIMPLE_OMP_RETURN
+	  || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_LOAD
+	  || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_STORE
+	  || gimple_code (stmt) == GIMPLE_OMP_CONTINUE);
+}
+/* Returns TRUE if statement G is a GIMPLE_NOP.  */
+static inline bool
+gimple_nop_p (const_gimple g)
+{
+return gimple_code (g) == GIMPLE_NOP;
+}
+/* Return the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS.  */
+static inline tree
+gimple_cdt_new_type (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
+return gimple_op (gs, 1);
+}
+/* Return a pointer to the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE
+statement GS.  */
+static inline tree *
+gimple_cdt_new_type_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
+return gimple_op_ptr (gs, 1);
+}
+/* Set NEW_TYPE to be the type returned by GIMPLE_CHANGE_DYNAMIC_TYPE
+statement GS.  */
+static inline void
+gimple_cdt_set_new_type (gimple gs, tree new_type)
+{
+GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
+gcc_assert (TREE_CODE_CLASS (TREE_CODE (new_type)) == tcc_type);
+gimple_set_op (gs, 1, new_type);
+}
+/* Return the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS.  */
+static inline tree
+gimple_cdt_location (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
+return gimple_op (gs, 0);
+}
+/* Return a pointer to the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
+statement GS.  */
+static inline tree *
+gimple_cdt_location_ptr (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
+return gimple_op_ptr (gs, 0);
+}
+/* Set PTR to be the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
+statement GS.  */
+static inline void
+gimple_cdt_set_location (gimple gs, tree ptr)
+{
+GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
+gimple_set_op (gs, 0, ptr);
+}
+/* Return the predictor of GIMPLE_PREDICT statement GS.  */
+static inline enum br_predictor
+gimple_predict_predictor (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_PREDICT);
+return (enum br_predictor) (gs->gsbase.subcode & ~GF_PREDICT_TAKEN);
+}
+/* Set the predictor of GIMPLE_PREDICT statement GS to PREDICT.  */
+static inline void
+gimple_predict_set_predictor (gimple gs, enum br_predictor predictor)
+{
+GIMPLE_CHECK (gs, GIMPLE_PREDICT);
+gs->gsbase.subcode = (gs->gsbase.subcode & GF_PREDICT_TAKEN)
+		       | (unsigned) predictor;
+}
+/* Return the outcome of GIMPLE_PREDICT statement GS.  */
+static inline enum prediction
+gimple_predict_outcome (gimple gs)
+{
+GIMPLE_CHECK (gs, GIMPLE_PREDICT);
+return (gs->gsbase.subcode & GF_PREDICT_TAKEN) ? TAKEN : NOT_TAKEN;
+}
+/* Set the outcome of GIMPLE_PREDICT statement GS to OUTCOME.  */
+static inline void
+gimple_predict_set_outcome (gimple gs, enum prediction outcome)
+{
+GIMPLE_CHECK (gs, GIMPLE_PREDICT);
+if (outcome == TAKEN)
+gs->gsbase.subcode |= GF_PREDICT_TAKEN;
+else
+gs->gsbase.subcode &= ~GF_PREDICT_TAKEN;
+}
 /* Return the type of the main expression computed by STMT.  Return
 void_type_node if the statement computes nothing.  */
 static inline tree
 gimple_expr_type (const_gimple stmt)
 {
 enum gimple_code code = gimple_code (stmt);
 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
 {
-tree type = TREE_TYPE (gimple_get_lhs (stmt));
+tree type;
+/* In general we want to pass out a type that can be substituted
+for both the RHS and the LHS types if there is a possibly
+	 useless conversion involved.  That means returning the
+	 original RHS type as far as we can reconstruct it.  */
+if (code == GIMPLE_CALL)
+	type = gimple_call_return_type (stmt);
+else
+	switch (gimple_assign_rhs_code (stmt))
+	  {
+	  case POINTER_PLUS_EXPR:
+	    type = TREE_TYPE (gimple_assign_rhs1 (stmt));
+	    break;
+	  default:
+	    /* As fallback use the type of the LHS.  */
+	    type = TREE_TYPE (gimple_get_lhs (stmt));
+	    break;
+	  }
 /* Integral sub-types are never the type of the expression,
 but they still can be the type of the result as the base
 	 type (in which expressions are computed) is trivially
 	 convertible to one of its sub-types.  So always return
 	 the base type here.  */
 }
 else if (code == GIMPLE_COND)
 return boolean_type_node;
 else
 return void_type_node;
-}
-/* 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.  */
-static inline enum tree_code
-gimple_expr_code (const_gimple stmt)
-{
-enum gimple_code code = gimple_code (stmt);
-if (code == GIMPLE_ASSIGN || code == GIMPLE_COND)
-return (enum tree_code) stmt->gsbase.subcode;
-else if (code == GIMPLE_CALL)
-return CALL_EXPR;
-else
-gcc_unreachable ();
-}
-/* Mark statement S as modified, and update it.  */
-static inline void
-update_stmt (gimple s)
-{
-if (gimple_has_ops (s))
-{
-gimple_set_modified (s, true);
-update_stmt_operands (s);
-}
-}
-/* Update statement S if it has been optimized.  */
-static inline void
-update_stmt_if_modified (gimple s)
-{
-if (gimple_modified_p (s))
-update_stmt_operands (s);
-}
-/* Return true if statement STMT contains volatile operands.  */
-static inline bool
-gimple_has_volatile_ops (const_gimple stmt)
-{
-if (gimple_has_mem_ops (stmt))
-return stmt->gsbase.has_volatile_ops;
-else
-return false;
-}
-/* Set the HAS_VOLATILE_OPS flag to VOLATILEP.  */
-static inline void
-gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
-{
-if (gimple_has_mem_ops (stmt))
-stmt->gsbase.has_volatile_ops = (unsigned) volatilep;
-}
-/* Return true if statement STMT may access memory.  */
-static inline bool
-gimple_references_memory_p (gimple stmt)
-{
-return gimple_has_mem_ops (stmt) && stmt->gsbase.references_memory_p;
-}
-/* Set the REFERENCES_MEMORY_P flag for STMT to MEM_P.  */
-static inline void
-gimple_set_references_memory (gimple stmt, bool mem_p)
-{
-if (gimple_has_mem_ops (stmt))
-stmt->gsbase.references_memory_p = (unsigned) mem_p;
-}
-/* Return the subcode for OMP statement S.  */
-static inline unsigned
-gimple_omp_subcode (const_gimple s)
-{
-gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
-	      && gimple_code (s) <= GIMPLE_OMP_SINGLE);
-return s->gsbase.subcode;
-}
-/* Set the subcode for OMP statement S to SUBCODE.  */
-static 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_assert (subcode < (1 << 16));
-s->gsbase.subcode = subcode;
-}
-/* Set the nowait flag on OMP_RETURN statement S.  */
-static inline void
-gimple_omp_return_set_nowait (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
-s->gsbase.subcode |= GF_OMP_RETURN_NOWAIT;
-}
-/* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
-flag set.  */
-static 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;
-}
-/* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
-flag set.  */
-static 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.  */
-static inline void
-gimple_omp_section_set_last (gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
-g->gsbase.subcode |= GF_OMP_SECTION_LAST;
-}
-/* Return true if OMP parallel statement G has the
-GF_OMP_PARALLEL_COMBINED flag set.  */
-static 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.  */
-static inline void
-gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
-if (combined_p)
-g->gsbase.subcode |= GF_OMP_PARALLEL_COMBINED;
-else
-g->gsbase.subcode &= ~GF_OMP_PARALLEL_COMBINED;
-}
-/* Return the number of operands for statement GS.  */
-static inline unsigned
-gimple_num_ops (const_gimple gs)
-{
-return gs->gsbase.num_ops;
-}
-/* Set the number of operands for statement GS.  */
-static inline void
-gimple_set_num_ops (gimple gs, unsigned num_ops)
-{
-gs->gsbase.num_ops = num_ops;
-}
-/* Return the array of operands for statement GS.  */
-static inline tree *
-gimple_ops (gimple gs)
-{
-/* Offset in bytes to the location of the operand vector in every
-tuple structure.  Defined in gimple.c  */
-extern size_t const gimple_ops_offset_[];
-if (!gimple_has_ops (gs))
-return NULL;
-/* All the tuples have their operand vector at the very bottom
-of the structure.  */
-return ((tree *) ((char *) gs + gimple_ops_offset_[gimple_code (gs)]));
-}
-/* Return operand I for statement GS.  */
-static inline tree
-gimple_op (const_gimple gs, unsigned i)
-{
-if (gimple_has_ops (gs))
-{
-gcc_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.  */
-static inline tree *
-gimple_op_ptr (const_gimple gs, unsigned i)
-{
-if (gimple_has_ops (gs))
-{
-gcc_assert (i < gimple_num_ops (gs));
-return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
-}
-else
-return NULL;
-}
-/* Set operand I of statement GS to OP.  */
-static inline void
-gimple_set_op (gimple gs, unsigned i, tree op)
-{
-gcc_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.  */
-static 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.  */
-static 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.  */
-static inline tree
-gimple_assign_lhs (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-return gimple_op (gs, 0);
-}
-/* Return a pointer to the LHS of assignment statement GS.  */
-static inline tree *
-gimple_assign_lhs_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-return gimple_op_ptr (gs, 0);
-}
-/* Set LHS to be the LHS operand of assignment statement GS.  */
-static inline void
-gimple_assign_set_lhs (gimple gs, tree lhs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-gcc_assert (is_gimple_operand (lhs));
-gimple_set_op (gs, 0, lhs);
-if (lhs && TREE_CODE (lhs) == SSA_NAME)
-SSA_NAME_DEF_STMT (lhs) = gs;
-}
-/* Return the first operand on the RHS of assignment statement GS.  */
-static inline tree
-gimple_assign_rhs1 (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-return gimple_op (gs, 1);
-}
-/* Return a pointer to the first operand on the RHS of assignment
-statement GS.  */
-static inline tree *
-gimple_assign_rhs1_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-return gimple_op_ptr (gs, 1);
-}
-/* Set RHS to be the first operand on the RHS of assignment statement GS.  */
-static inline void
-gimple_assign_set_rhs1 (gimple gs, tree rhs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-/* If there are 3 or more operands, the 2 operands on the RHS must be
-GIMPLE values.  */
-if (gimple_num_ops (gs) >= 3)
-gcc_assert (is_gimple_val (rhs));
-else
-gcc_assert (is_gimple_operand (rhs));
-gimple_set_op (gs, 1, rhs);
-}
-/* Return the second operand on the RHS of assignment statement GS.
-If GS does not have two operands, NULL is returned instead.  */
-static inline tree
-gimple_assign_rhs2 (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-if (gimple_num_ops (gs) >= 3)
-return gimple_op (gs, 2);
-else
-return NULL_TREE;
-}
-/* Return a pointer to the second operand on the RHS of assignment
-statement GS.  */
-static inline tree *
-gimple_assign_rhs2_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-return gimple_op_ptr (gs, 2);
-}
-/* Set RHS to be the second operand on the RHS of assignment statement GS.  */
-static inline void
-gimple_assign_set_rhs2 (gimple gs, tree rhs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-/* The 2 operands on the RHS must be GIMPLE values.  */
-gcc_assert (is_gimple_val (rhs));
-gimple_set_op (gs, 2, rhs);
-}
-/* Returns true if GS is a nontemporal move.  */
-static inline bool
-gimple_assign_nontemporal_move_p (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-return gs->gsbase.nontemporal_move;
-}
-/* Sets nontemporal move flag of GS to NONTEMPORAL.  */
-static inline void
-gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-gs->gsbase.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.  */
-static inline enum tree_code
-gimple_assign_rhs_code (const_gimple gs)
-{
-enum tree_code code;
-GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
-code = gimple_expr_code (gs);
-if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
-code = TREE_CODE (gimple_assign_rhs1 (gs));
-return code;
-}
-/* Set CODE to be the code for the expression computed on the RHS of
-assignment S.  */
-static inline void
-gimple_assign_set_rhs_code (gimple s, enum tree_code code)
-{
-GIMPLE_CHECK (s, GIMPLE_ASSIGN);
-s->gsbase.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.  */
-static 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 S is a type-cast assignment.  */
-static inline bool
-gimple_assign_cast_p (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 GS is a GIMPLE_CALL.  */
-static inline bool
-is_gimple_call (const_gimple gs)
-{
-return gimple_code (gs) == GIMPLE_CALL;
-}
-/* Return the LHS of call statement GS.  */
-static inline tree
-gimple_call_lhs (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op (gs, 0);
-}
-/* Return a pointer to the LHS of call statement GS.  */
-static inline tree *
-gimple_call_lhs_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op_ptr (gs, 0);
-}
-/* Set LHS to be the LHS operand of call statement GS.  */
-static inline void
-gimple_call_set_lhs (gimple gs, tree lhs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (!lhs || is_gimple_operand (lhs));
-gimple_set_op (gs, 0, lhs);
-if (lhs && TREE_CODE (lhs) == SSA_NAME)
-SSA_NAME_DEF_STMT (lhs) = gs;
-}
-/* Return the tree node representing the function called by call
-statement GS.  */
-static inline tree
-gimple_call_fn (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op (gs, 1);
-}
-/* Return a pointer to the tree node representing the function called by call
-statement GS.  */
-static inline tree *
-gimple_call_fn_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op_ptr (gs, 1);
-}
-/* Set FN to be the function called by call statement GS.  */
-static inline void
-gimple_call_set_fn (gimple gs, tree fn)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (is_gimple_operand (fn));
-gimple_set_op (gs, 1, fn);
-}
-/* Set FNDECL to be the function called by call statement GS.  */
-static inline void
-gimple_call_set_fndecl (gimple gs, tree decl)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
-gimple_set_op (gs, 1, build_fold_addr_expr (decl));
-}
-/* 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.  */
-static inline tree
-gimple_call_fndecl (const_gimple gs)
-{
-tree addr = gimple_call_fn (gs);
-if (TREE_CODE (addr) == ADDR_EXPR)
-{
-gcc_assert (TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL);
-return TREE_OPERAND (addr, 0);
-}
-return NULL_TREE;
-}
-/* Return the type returned by call statement GS.  */
-static inline tree
-gimple_call_return_type (const_gimple gs)
-{
-tree fn = gimple_call_fn (gs);
-tree type = TREE_TYPE (fn);
-/* See through the pointer.  */
-gcc_assert (POINTER_TYPE_P (type));
-type = TREE_TYPE (type);
-gcc_assert (TREE_CODE (type) == FUNCTION_TYPE
-	      || TREE_CODE (type) == METHOD_TYPE);
-/* The type returned by a FUNCTION_DECL is the type of its
-function type.  */
-return TREE_TYPE (type);
-}
-/* Return the static chain for call statement GS.  */
-static inline tree
-gimple_call_chain (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op (gs, 2);
-}
-/* Return a pointer to the static chain for call statement GS.  */
-static inline tree *
-gimple_call_chain_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op_ptr (gs, 2);
-}
-/* Set CHAIN to be the static chain for call statement GS.  */
-static inline void
-gimple_call_set_chain (gimple gs, tree chain)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (chain == NULL
-|| TREE_CODE (chain) == ADDR_EXPR
-|| SSA_VAR_P (chain));
-gimple_set_op (gs, 2, chain);
-}
-/* Return the number of arguments used by call statement GS.  */
-static inline unsigned
-gimple_call_num_args (const_gimple gs)
-{
-unsigned num_ops;
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-num_ops = gimple_num_ops (gs);
-gcc_assert (num_ops >= 3);
-return num_ops - 3;
-}
-/* Return the argument at position INDEX for call statement GS.  */
-static inline tree
-gimple_call_arg (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op (gs, index + 3);
-}
-/* Return a pointer to the argument at position INDEX for call
-statement GS.  */
-static inline tree *
-gimple_call_arg_ptr (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-return gimple_op_ptr (gs, index + 3);
-}
-/* Set ARG to be the argument at position INDEX for call statement GS.  */
-static inline void
-gimple_call_set_arg (gimple gs, unsigned index, tree arg)
-{
-GIMPLE_CHECK (gs, GIMPLE_CALL);
-gcc_assert (is_gimple_operand (arg));
-gimple_set_op (gs, index + 3, 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.  */
-static inline void
-gimple_call_set_tail (gimple s, bool tail_p)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-if (tail_p)
-s->gsbase.subcode |= GF_CALL_TAILCALL;
-else
-s->gsbase.subcode &= ~GF_CALL_TAILCALL;
-}
-/* Return true if GIMPLE_CALL S is marked as a tail call.  */
-static inline bool
-gimple_call_tail_p (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-return (s->gsbase.subcode & GF_CALL_TAILCALL) != 0;
-}
-/* Set the inlinable status of GIMPLE_CALL S to INLINABLE_P.  */
-static inline void
-gimple_call_set_cannot_inline (gimple s, bool inlinable_p)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-if (inlinable_p)
-s->gsbase.subcode |= GF_CALL_CANNOT_INLINE;
-else
-s->gsbase.subcode &= ~GF_CALL_CANNOT_INLINE;
-}
-/* Return true if GIMPLE_CALL S cannot be inlined.  */
-static inline bool
-gimple_call_cannot_inline_p (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-return (s->gsbase.subcode & GF_CALL_CANNOT_INLINE) != 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.  */
-static inline void
-gimple_call_set_return_slot_opt (gimple s, bool return_slot_opt_p)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-if (return_slot_opt_p)
-s->gsbase.subcode |= GF_CALL_RETURN_SLOT_OPT;
-else
-s->gsbase.subcode &= ~GF_CALL_RETURN_SLOT_OPT;
-}
-/* Return true if S is marked for return slot optimization.  */
-static inline bool
-gimple_call_return_slot_opt_p (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-return (s->gsbase.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.  */
-static inline void
-gimple_call_set_from_thunk (gimple s, bool from_thunk_p)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-if (from_thunk_p)
-s->gsbase.subcode |= GF_CALL_FROM_THUNK;
-else
-s->gsbase.subcode &= ~GF_CALL_FROM_THUNK;
-}
-/* Return true if GIMPLE_CALL S is a jump from a thunk.  */
-static inline bool
-gimple_call_from_thunk_p (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-return (s->gsbase.subcode & GF_CALL_FROM_THUNK) != 0;
-}
-/* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
-argument pack in its argument list.  */
-static inline void
-gimple_call_set_va_arg_pack (gimple s, bool pass_arg_pack_p)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-if (pass_arg_pack_p)
-s->gsbase.subcode |= GF_CALL_VA_ARG_PACK;
-else
-s->gsbase.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.  */
-static inline bool
-gimple_call_va_arg_pack_p (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-return (s->gsbase.subcode & GF_CALL_VA_ARG_PACK) != 0;
-}
-/* Return true if S is a noreturn call.  */
-static inline bool
-gimple_call_noreturn_p (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-return (gimple_call_flags (s) & ECF_NORETURN) != 0;
-}
-/* Return true if S is a nothrow call.  */
-static inline bool
-gimple_call_nothrow_p (gimple s)
-{
-GIMPLE_CHECK (s, GIMPLE_CALL);
-return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
-}
-/* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.  */
-static inline void
-gimple_call_copy_flags (gimple dest_call, gimple orig_call)
-{
-GIMPLE_CHECK (dest_call, GIMPLE_CALL);
-GIMPLE_CHECK (orig_call, GIMPLE_CALL);
-dest_call->gsbase.subcode = orig_call->gsbase.subcode;
-}
-/* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
-non-NULL lhs.  */
-static inline bool
-gimple_has_lhs (gimple stmt)
-{
-return (is_gimple_assign (stmt)
-	  || (is_gimple_call (stmt)
-	      && gimple_call_lhs (stmt) != NULL_TREE));
-}
-/* Return the code of the predicate computed by conditional statement GS.  */
-static inline enum tree_code
-gimple_cond_code (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-return gs->gsbase.subcode;
-}
-/* Set CODE to be the predicate code for the conditional statement GS.  */
-static inline void
-gimple_cond_set_code (gimple gs, enum tree_code code)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
-gs->gsbase.subcode = code;
-}
-/* Return the LHS of the predicate computed by conditional statement GS.  */
-static inline tree
-gimple_cond_lhs (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-return gimple_op (gs, 0);
-}
-/* Return the pointer to the LHS of the predicate computed by conditional
-statement GS.  */
-static inline tree *
-gimple_cond_lhs_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-return gimple_op_ptr (gs, 0);
-}
-/* Set LHS to be the LHS operand of the predicate computed by
-conditional statement GS.  */
-static inline void
-gimple_cond_set_lhs (gimple gs, tree lhs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (is_gimple_operand (lhs));
-gimple_set_op (gs, 0, lhs);
-}
-/* Return the RHS operand of the predicate computed by conditional GS.  */
-static inline tree
-gimple_cond_rhs (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-return gimple_op (gs, 1);
-}
-/* Return the pointer to the RHS operand of the predicate computed by
-conditional GS.  */
-static inline tree *
-gimple_cond_rhs_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-return gimple_op_ptr (gs, 1);
-}
-/* Set RHS to be the RHS operand of the predicate computed by
-conditional statement GS.  */
-static inline void
-gimple_cond_set_rhs (gimple gs, tree rhs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (is_gimple_operand (rhs));
-gimple_set_op (gs, 1, rhs);
-}
-/* Return the label used by conditional statement GS when its
-predicate evaluates to true.  */
-static inline tree
-gimple_cond_true_label (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-return gimple_op (gs, 2);
-}
-/* Set LABEL to be the label used by conditional statement GS when its
-predicate evaluates to true.  */
-static inline void
-gimple_cond_set_true_label (gimple gs, tree label)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
-gimple_set_op (gs, 2, label);
-}
-/* Set LABEL to be the label used by conditional statement GS when its
-predicate evaluates to false.  */
-static inline void
-gimple_cond_set_false_label (gimple gs, tree label)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
-gimple_set_op (gs, 3, label);
-}
-/* Return the label used by conditional statement GS when its
-predicate evaluates to false.  */
-static inline tree
-gimple_cond_false_label (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_COND);
-return gimple_op (gs, 3);
-}
-/* Set the conditional COND_STMT to be of the form 'if (1 == 0)'.  */
-static inline void
-gimple_cond_make_false (gimple gs)
-{
-gimple_cond_set_lhs (gs, boolean_true_node);
-gimple_cond_set_rhs (gs, boolean_false_node);
-gs->gsbase.subcode = EQ_EXPR;
-}
-/* Set the conditional COND_STMT to be of the form 'if (1 == 1)'.  */
-static inline void
-gimple_cond_make_true (gimple gs)
-{
-gimple_cond_set_lhs (gs, boolean_true_node);
-gimple_cond_set_rhs (gs, boolean_true_node);
-gs->gsbase.subcode = EQ_EXPR;
-}
-/* Check if conditional statemente GS is of the form 'if (1 == 1)',
-'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
-static inline bool
-gimple_cond_true_p (const_gimple 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)' */
-static inline bool
-gimple_cond_false_p (const_gimple 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 (var != 0)' or
-'if (var == 1)' */
-static inline bool
-gimple_cond_single_var_p (gimple gs)
-{
-if (gimple_cond_code (gs) == NE_EXPR
-&& gimple_cond_rhs (gs) == boolean_false_node)
-return true;
-if (gimple_cond_code (gs) == EQ_EXPR
-&& gimple_cond_rhs (gs) == boolean_true_node)
-return true;
-return false;
-}
-/* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS.  */
-static inline void
-gimple_cond_set_condition (gimple 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 LABEL_DECL node used by GIMPLE_LABEL statement GS.  */
-static inline tree
-gimple_label_label (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_LABEL);
-return gimple_op (gs, 0);
-}
-/* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
-GS.  */
-static inline void
-gimple_label_set_label (gimple gs, tree label)
-{
-GIMPLE_CHECK (gs, GIMPLE_LABEL);
-gcc_assert (TREE_CODE (label) == LABEL_DECL);
-gimple_set_op (gs, 0, label);
-}
-/* Return the destination of the unconditional jump GS.  */
-static 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.  */
-static inline void
-gimple_goto_set_dest (gimple gs, tree dest)
-{
-GIMPLE_CHECK (gs, GIMPLE_GOTO);
-gcc_assert (is_gimple_operand (dest));
-gimple_set_op (gs, 0, dest);
-}
-/* Return the variables declared in the GIMPLE_BIND statement GS.  */
-static inline tree
-gimple_bind_vars (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-return gs->gimple_bind.vars;
-}
-/* Set VARS to be the set of variables declared in the GIMPLE_BIND
-statement GS.  */
-static inline void
-gimple_bind_set_vars (gimple gs, tree vars)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-gs->gimple_bind.vars = vars;
-}
-/* Append VARS to the set of variables declared in the GIMPLE_BIND
-statement GS.  */
-static inline void
-gimple_bind_append_vars (gimple gs, tree vars)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-gs->gimple_bind.vars = chainon (gs->gimple_bind.vars, vars);
-}
-/* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS.  */
-static inline gimple_seq
-gimple_bind_body (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-return gs->gimple_bind.body;
-}
-/* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
-statement GS.  */
-static inline void
-gimple_bind_set_body (gimple gs, gimple_seq seq)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-gs->gimple_bind.body = seq;
-}
-/* Append a statement to the end of a GIMPLE_BIND's body.  */
-static inline void
-gimple_bind_add_stmt (gimple gs, gimple stmt)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-gimple_seq_add_stmt (&gs->gimple_bind.body, stmt);
-}
-/* Append a sequence of statements to the end of a GIMPLE_BIND's body.  */
-static inline void
-gimple_bind_add_seq (gimple gs, gimple_seq seq)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-gimple_seq_add_seq (&gs->gimple_bind.body, seq);
-}
-/* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
-GS.  This is analogous to the BIND_EXPR_BLOCK field in trees.  */
-static inline tree
-gimple_bind_block (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-return gs->gimple_bind.block;
-}
-/* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
-statement GS.  */
-static inline void
-gimple_bind_set_block (gimple gs, tree block)
-{
-GIMPLE_CHECK (gs, GIMPLE_BIND);
-gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
-gs->gimple_bind.block = block;
-}
-/* Return the number of input operands for GIMPLE_ASM GS.  */
-static inline unsigned
-gimple_asm_ninputs (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-return gs->gimple_asm.ni;
-}
-/* Return the number of output operands for GIMPLE_ASM GS.  */
-static inline unsigned
-gimple_asm_noutputs (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-return gs->gimple_asm.no;
-}
-/* Return the number of clobber operands for GIMPLE_ASM GS.  */
-static inline unsigned
-gimple_asm_nclobbers (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-return gs->gimple_asm.nc;
-}
-/* Return input operand INDEX of GIMPLE_ASM GS.  */
-static inline tree
-gimple_asm_input_op (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.ni);
-return gimple_op (gs, index);
-}
-/* Return a pointer to input operand INDEX of GIMPLE_ASM GS.  */
-static inline tree *
-gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.ni);
-return gimple_op_ptr (gs, index);
-}
-/* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS.  */
-static inline void
-gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.ni);
-gcc_assert (TREE_CODE (in_op) == TREE_LIST);
-gimple_set_op (gs, index, in_op);
-}
-/* Return output operand INDEX of GIMPLE_ASM GS.  */
-static inline tree
-gimple_asm_output_op (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.no);
-return gimple_op (gs, index + gs->gimple_asm.ni);
-}
-/* Return a pointer to output operand INDEX of GIMPLE_ASM GS.  */
-static inline tree *
-gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.no);
-return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
-}
-/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS.  */
-static inline void
-gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.no);
-gcc_assert (TREE_CODE (out_op) == TREE_LIST);
-gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
-}
-/* Return clobber operand INDEX of GIMPLE_ASM GS.  */
-static inline tree
-gimple_asm_clobber_op (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.nc);
-return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
-}
-/* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS.  */
-static inline void
-gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-gcc_assert (index <= gs->gimple_asm.nc);
-gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
-gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
-}
-/* Return the string representing the assembly instruction in
-GIMPLE_ASM GS.  */
-static inline const char *
-gimple_asm_string (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-return gs->gimple_asm.string;
-}
-/* Return true if GS is an asm statement marked volatile.  */
-static inline bool
-gimple_asm_volatile_p (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-return (gs->gsbase.subcode & GF_ASM_VOLATILE) != 0;
-}
-/* If VOLATLE_P is true, mark asm statement GS as volatile.  */
-static inline void
-gimple_asm_set_volatile (gimple gs, bool volatile_p)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-if (volatile_p)
-gs->gsbase.subcode |= GF_ASM_VOLATILE;
-else
-gs->gsbase.subcode &= ~GF_ASM_VOLATILE;
-}
-/* If INPUT_P is true, mark asm GS as an ASM_INPUT.  */
-static inline void
-gimple_asm_set_input (gimple gs, bool input_p)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-if (input_p)
-gs->gsbase.subcode |= GF_ASM_INPUT;
-else
-gs->gsbase.subcode &= ~GF_ASM_INPUT;
-}
-/* Return true if asm GS is an ASM_INPUT.  */
-static inline bool
-gimple_asm_input_p (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_ASM);
-return (gs->gsbase.subcode & GF_ASM_INPUT) != 0;
-}
-/* Return the types handled by GIMPLE_CATCH statement GS.  */
-static inline tree
-gimple_catch_types (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CATCH);
-return gs->gimple_catch.types;
-}
-/* Return a pointer to the types handled by GIMPLE_CATCH statement GS.  */
-static inline tree *
-gimple_catch_types_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CATCH);
-return &gs->gimple_catch.types;
-}
-/* Return the GIMPLE sequence representing the body of the handler of
-GIMPLE_CATCH statement GS.  */
-static inline gimple_seq
-gimple_catch_handler (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CATCH);
-return gs->gimple_catch.handler;
-}
-/* Return a pointer to the GIMPLE sequence representing the body of
-the handler of GIMPLE_CATCH statement GS.  */
-static inline gimple_seq *
-gimple_catch_handler_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CATCH);
-return &gs->gimple_catch.handler;
-}
-/* Set T to be the set of types handled by GIMPLE_CATCH GS.  */
-static inline void
-gimple_catch_set_types (gimple gs, tree t)
-{
-GIMPLE_CHECK (gs, GIMPLE_CATCH);
-gs->gimple_catch.types = t;
-}
-/* Set HANDLER to be the body of GIMPLE_CATCH GS.  */
-static inline void
-gimple_catch_set_handler (gimple gs, gimple_seq handler)
-{
-GIMPLE_CHECK (gs, GIMPLE_CATCH);
-gs->gimple_catch.handler = handler;
-}
-/* Return the types handled by GIMPLE_EH_FILTER statement GS.  */
-static inline tree
-gimple_eh_filter_types (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
-return gs->gimple_eh_filter.types;
-}
-/* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
-GS.  */
-static inline tree *
-gimple_eh_filter_types_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
-return &gs->gimple_eh_filter.types;
-}
-/* Return the sequence of statement to execute when GIMPLE_EH_FILTER
-statement fails.  */
-static inline gimple_seq
-gimple_eh_filter_failure (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
-return gs->gimple_eh_filter.failure;
-}
-/* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS.  */
-static inline void
-gimple_eh_filter_set_types (gimple gs, tree types)
-{
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
-gs->gimple_eh_filter.types = types;
-}
-/* Set FAILURE to be the sequence of statements to execute on failure
-for GIMPLE_EH_FILTER GS.  */
-static inline void
-gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
-{
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
-gs->gimple_eh_filter.failure = failure;
-}
-/* Return the EH_FILTER_MUST_NOT_THROW flag.  */
-static inline bool
-gimple_eh_filter_must_not_throw (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
-return gs->gsbase.subcode != 0;
-}
-/* Set the EH_FILTER_MUST_NOT_THROW flag to the value MNTP.  */
-static inline void
-gimple_eh_filter_set_must_not_throw (gimple gs, bool mntp)
-{
-GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
-gs->gsbase.subcode = (unsigned int) mntp;
-}
-/* GIMPLE_TRY accessors. */
-/* Return the kind of try block represented by GIMPLE_TRY GS.  This is
-either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.  */
-static inline enum gimple_try_flags
-gimple_try_kind (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_TRY);
-return (enum gimple_try_flags) (gs->gsbase.subcode & GIMPLE_TRY_KIND);
-}
-/* Set the kind of try block represented by GIMPLE_TRY GS.  */
-static inline void
-gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
-{
-GIMPLE_CHECK (gs, GIMPLE_TRY);
-gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
-if (gimple_try_kind (gs) != kind)
-gs->gsbase.subcode = (unsigned int) kind;
-}
-/* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
-static inline bool
-gimple_try_catch_is_cleanup (const_gimple gs)
-{
-gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
-return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
-}
-/* Return the sequence of statements used as the body for GIMPLE_TRY GS.  */
-static inline gimple_seq
-gimple_try_eval (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_TRY);
-return gs->gimple_try.eval;
-}
-/* Return the sequence of statements used as the cleanup body for
-GIMPLE_TRY GS.  */
-static inline gimple_seq
-gimple_try_cleanup (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_TRY);
-return gs->gimple_try.cleanup;
-}
-/* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
-static inline void
-gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
-{
-gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
-if (catch_is_cleanup)
-g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
-else
-g->gsbase.subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
-}
-/* Set EVAL to be the sequence of statements to use as the body for
-GIMPLE_TRY GS.  */
-static inline void
-gimple_try_set_eval (gimple gs, gimple_seq eval)
-{
-GIMPLE_CHECK (gs, GIMPLE_TRY);
-gs->gimple_try.eval = eval;
-}
-/* Set CLEANUP to be the sequence of statements to use as the cleanup
-body for GIMPLE_TRY GS.  */
-static inline void
-gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
-{
-GIMPLE_CHECK (gs, GIMPLE_TRY);
-gs->gimple_try.cleanup = cleanup;
-}
-/* Return the cleanup sequence for cleanup statement GS.  */
-static inline gimple_seq
-gimple_wce_cleanup (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
-return gs->gimple_wce.cleanup;
-}
-/* Set CLEANUP to be the cleanup sequence for GS.  */
-static inline void
-gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
-{
-GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
-gs->gimple_wce.cleanup = cleanup;
-}
-/* Return the CLEANUP_EH_ONLY flag for a WCE tuple.  */
-static inline bool
-gimple_wce_cleanup_eh_only (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
-return gs->gsbase.subcode != 0;
-}
-/* Set the CLEANUP_EH_ONLY flag for a WCE tuple.  */
-static inline void
-gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
-{
-GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
-gs->gsbase.subcode = (unsigned int) eh_only_p;
-}
-/* Return the maximum number of arguments supported by GIMPLE_PHI GS.  */
-static inline unsigned
-gimple_phi_capacity (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_PHI);
-return gs->gimple_phi.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.  */
-static inline unsigned
-gimple_phi_num_args (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_PHI);
-return gs->gimple_phi.nargs;
-}
-/* Return the SSA name created by GIMPLE_PHI GS.  */
-static inline tree
-gimple_phi_result (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_PHI);
-return gs->gimple_phi.result;
-}
-/* Return a pointer to the SSA name created by GIMPLE_PHI GS.  */
-static inline tree *
-gimple_phi_result_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_PHI);
-return &gs->gimple_phi.result;
-}
-/* Set RESULT to be the SSA name created by GIMPLE_PHI GS.  */
-static inline void
-gimple_phi_set_result (gimple gs, tree result)
-{
-GIMPLE_CHECK (gs, GIMPLE_PHI);
-gs->gimple_phi.result = result;
-}
-/* Return the PHI argument corresponding to incoming edge INDEX for
-GIMPLE_PHI GS.  */
-static inline struct phi_arg_d *
-gimple_phi_arg (gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_PHI);
-gcc_assert (index <= gs->gimple_phi.capacity);
-return &(gs->gimple_phi.args[index]);
-}
-/* Set PHIARG to be the argument corresponding to incoming edge INDEX
-for GIMPLE_PHI GS.  */
-static inline void
-gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
-{
-GIMPLE_CHECK (gs, GIMPLE_PHI);
-gcc_assert (index <= gs->gimple_phi.nargs);
-memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
-}
-/* Return the region number for GIMPLE_RESX GS.  */
-static inline int
-gimple_resx_region (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_RESX);
-return gs->gimple_resx.region;
-}
-/* Set REGION to be the region number for GIMPLE_RESX GS.  */
-static inline void
-gimple_resx_set_region (gimple gs, int region)
-{
-GIMPLE_CHECK (gs, GIMPLE_RESX);
-gs->gimple_resx.region = region;
-}
-/* Return the number of labels associated with the switch statement GS.  */
-static inline unsigned
-gimple_switch_num_labels (const_gimple gs)
-{
-unsigned num_ops;
-GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-num_ops = gimple_num_ops (gs);
-gcc_assert (num_ops > 1);
-return num_ops - 1;
-}
-/* Set NLABELS to be the number of labels for the switch statement GS.  */
-static inline void
-gimple_switch_set_num_labels (gimple g, unsigned nlabels)
-{
-GIMPLE_CHECK (g, GIMPLE_SWITCH);
-gimple_set_num_ops (g, nlabels + 1);
-}
-/* Return the index variable used by the switch statement GS.  */
-static inline tree
-gimple_switch_index (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-return gimple_op (gs, 0);
-}
-/* Return a pointer to the index variable for the switch statement GS.  */
-static inline tree *
-gimple_switch_index_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-return gimple_op_ptr (gs, 0);
-}
-/* Set INDEX to be the index variable for switch statement GS.  */
-static inline void
-gimple_switch_set_index (gimple gs, tree index)
-{
-GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
-gimple_set_op (gs, 0, index);
-}
-/* Return the label numbered INDEX.  The default label is 0, followed by any
-labels in a switch statement.  */
-static inline tree
-gimple_switch_label (const_gimple gs, unsigned index)
-{
-GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-gcc_assert (gimple_num_ops (gs) > index + 1);
-return gimple_op (gs, index + 1);
-}
-/* Set the label number INDEX to LABEL.  0 is always the default label.  */
-static inline void
-gimple_switch_set_label (gimple gs, unsigned index, tree label)
-{
-GIMPLE_CHECK (gs, GIMPLE_SWITCH);
-gcc_assert (gimple_num_ops (gs) > index + 1);
-gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
-gimple_set_op (gs, index + 1, label);
-}
-/* Return the default label for a switch statement.  */
-static inline tree
-gimple_switch_default_label (const_gimple gs)
-{
-return gimple_switch_label (gs, 0);
-}
-/* Set the default label for a switch statement.  */
-static inline void
-gimple_switch_set_default_label (gimple gs, tree label)
-{
-gimple_switch_set_label (gs, 0, label);
-}
-/* Return the body for the OMP statement GS.  */
-static inline gimple_seq
-gimple_omp_body (gimple gs)
-{
-return gs->omp.body;
-}
-/* Set BODY to be the body for the OMP statement GS.  */
-static inline void
-gimple_omp_set_body (gimple gs, gimple_seq body)
-{
-gs->omp.body = body;
-}
-/* Return the name associated with OMP_CRITICAL statement GS.  */
-static inline tree
-gimple_omp_critical_name (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
-return gs->gimple_omp_critical.name;
-}
-/* Return a pointer to the name associated with OMP critical statement GS.  */
-static inline tree *
-gimple_omp_critical_name_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
-return &gs->gimple_omp_critical.name;
-}
-/* Set NAME to be the name associated with OMP critical statement GS.  */
-static inline void
-gimple_omp_critical_set_name (gimple gs, tree name)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
-gs->gimple_omp_critical.name = name;
-}
-/* Return the clauses associated with OMP_FOR GS.  */
-static inline tree
-gimple_omp_for_clauses (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-return gs->gimple_omp_for.clauses;
-}
-/* Return a pointer to the OMP_FOR GS.  */
-static inline tree *
-gimple_omp_for_clauses_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-return &gs->gimple_omp_for.clauses;
-}
-/* Set CLAUSES to be the list of clauses associated with OMP_FOR GS.  */
-static inline void
-gimple_omp_for_set_clauses (gimple gs, tree clauses)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gs->gimple_omp_for.clauses = clauses;
-}
-/* Get the collapse count of OMP_FOR GS.  */
-static inline size_t
-gimple_omp_for_collapse (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-return gs->gimple_omp_for.collapse;
-}
-/* Return the index variable for OMP_FOR GS.  */
-static inline tree
-gimple_omp_for_index (const_gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return gs->gimple_omp_for.iter[i].index;
-}
-/* Return a pointer to the index variable for OMP_FOR GS.  */
-static inline tree *
-gimple_omp_for_index_ptr (gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return &gs->gimple_omp_for.iter[i].index;
-}
-/* Set INDEX to be the index variable for OMP_FOR GS.  */
-static inline void
-gimple_omp_for_set_index (gimple gs, size_t i, tree index)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-gs->gimple_omp_for.iter[i].index = index;
-}
-/* Return the initial value for OMP_FOR GS.  */
-static inline tree
-gimple_omp_for_initial (const_gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return gs->gimple_omp_for.iter[i].initial;
-}
-/* Return a pointer to the initial value for OMP_FOR GS.  */
-static inline tree *
-gimple_omp_for_initial_ptr (gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return &gs->gimple_omp_for.iter[i].initial;
-}
-/* Set INITIAL to be the initial value for OMP_FOR GS.  */
-static inline void
-gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-gs->gimple_omp_for.iter[i].initial = initial;
-}
-/* Return the final value for OMP_FOR GS.  */
-static inline tree
-gimple_omp_for_final (const_gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return gs->gimple_omp_for.iter[i].final;
-}
-/* Return a pointer to the final value for OMP_FOR GS.  */
-static inline tree *
-gimple_omp_for_final_ptr (gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return &gs->gimple_omp_for.iter[i].final;
-}
-/* Set FINAL to be the final value for OMP_FOR GS.  */
-static inline void
-gimple_omp_for_set_final (gimple gs, size_t i, tree final)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-gs->gimple_omp_for.iter[i].final = final;
-}
-/* Return the increment value for OMP_FOR GS.  */
-static inline tree
-gimple_omp_for_incr (const_gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return gs->gimple_omp_for.iter[i].incr;
-}
-/* Return a pointer to the increment value for OMP_FOR GS.  */
-static inline tree *
-gimple_omp_for_incr_ptr (gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return &gs->gimple_omp_for.iter[i].incr;
-}
-/* Set INCR to be the increment value for OMP_FOR GS.  */
-static inline void
-gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-gs->gimple_omp_for.iter[i].incr = incr;
-}
-/* Return the sequence of statements to execute before the OMP_FOR
-statement GS starts.  */
-static inline gimple_seq
-gimple_omp_for_pre_body (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-return gs->gimple_omp_for.pre_body;
-}
-/* Set PRE_BODY to be the sequence of statements to execute before the
-OMP_FOR statement GS starts.  */
-static inline void
-gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gs->gimple_omp_for.pre_body = pre_body;
-}
-/* Return the clauses associated with OMP_PARALLEL GS.  */
-static inline tree
-gimple_omp_parallel_clauses (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-return gs->gimple_omp_parallel.clauses;
-}
-/* Return a pointer to the clauses associated with OMP_PARALLEL GS.  */
-static inline tree *
-gimple_omp_parallel_clauses_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-return &gs->gimple_omp_parallel.clauses;
-}
-/* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL
-GS.  */
-static inline void
-gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-gs->gimple_omp_parallel.clauses = clauses;
-}
-/* Return the child function used to hold the body of OMP_PARALLEL GS.  */
-static inline tree
-gimple_omp_parallel_child_fn (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-return gs->gimple_omp_parallel.child_fn;
-}
-/* Return a pointer to the child function used to hold the body of
-OMP_PARALLEL GS.  */
-static inline tree *
-gimple_omp_parallel_child_fn_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-return &gs->gimple_omp_parallel.child_fn;
-}
-/* Set CHILD_FN to be the child function for OMP_PARALLEL GS.  */
-static inline void
-gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-gs->gimple_omp_parallel.child_fn = child_fn;
-}
-/* Return the artificial argument used to send variables and values
-from the parent to the children threads in OMP_PARALLEL GS.  */
-static inline tree
-gimple_omp_parallel_data_arg (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-return gs->gimple_omp_parallel.data_arg;
-}
-/* Return a pointer to the data argument for OMP_PARALLEL GS.  */
-static inline tree *
-gimple_omp_parallel_data_arg_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-return &gs->gimple_omp_parallel.data_arg;
-}
-/* Set DATA_ARG to be the data argument for OMP_PARALLEL GS.  */
-static inline void
-gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
-gs->gimple_omp_parallel.data_arg = data_arg;
-}
-/* Return the clauses associated with OMP_TASK GS.  */
-static inline tree
-gimple_omp_task_clauses (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_parallel.clauses;
-}
-/* Return a pointer to the clauses associated with OMP_TASK GS.  */
-static inline tree *
-gimple_omp_task_clauses_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_parallel.clauses;
-}
-/* Set CLAUSES to be the list of clauses associated with OMP_TASK
-GS.  */
-static inline void
-gimple_omp_task_set_clauses (gimple gs, tree clauses)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_parallel.clauses = clauses;
-}
-/* Return the child function used to hold the body of OMP_TASK GS.  */
-static inline tree
-gimple_omp_task_child_fn (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_parallel.child_fn;
-}
-/* Return a pointer to the child function used to hold the body of
-OMP_TASK GS.  */
-static inline tree *
-gimple_omp_task_child_fn_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_parallel.child_fn;
-}
-/* Set CHILD_FN to be the child function for OMP_TASK GS.  */
-static inline void
-gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_parallel.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.  */
-static inline tree
-gimple_omp_task_data_arg (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_parallel.data_arg;
-}
-/* Return a pointer to the data argument for OMP_TASK GS.  */
-static inline tree *
-gimple_omp_task_data_arg_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_parallel.data_arg;
-}
-/* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
-static inline void
-gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_parallel.data_arg = data_arg;
-}
-/* Return the clauses associated with OMP_TASK GS.  */
-static inline tree
-gimple_omp_taskreg_clauses (const_gimple gs)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_parallel.clauses;
-}
-/* Return a pointer to the clauses associated with OMP_TASK GS.  */
-static inline tree *
-gimple_omp_taskreg_clauses_ptr (gimple gs)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_parallel.clauses;
-}
-/* Set CLAUSES to be the list of clauses associated with OMP_TASK
-GS.  */
-static inline void
-gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_parallel.clauses = clauses;
-}
-/* Return the child function used to hold the body of OMP_TASK GS.  */
-static inline tree
-gimple_omp_taskreg_child_fn (const_gimple gs)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_parallel.child_fn;
-}
-/* Return a pointer to the child function used to hold the body of
-OMP_TASK GS.  */
-static inline tree *
-gimple_omp_taskreg_child_fn_ptr (gimple gs)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_parallel.child_fn;
-}
-/* Set CHILD_FN to be the child function for OMP_TASK GS.  */
-static inline void
-gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_parallel.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.  */
-static inline tree
-gimple_omp_taskreg_data_arg (const_gimple gs)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_parallel.data_arg;
-}
-/* Return a pointer to the data argument for OMP_TASK GS.  */
-static inline tree *
-gimple_omp_taskreg_data_arg_ptr (gimple gs)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_parallel.data_arg;
-}
-/* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
-static inline void
-gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
-{
-if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_parallel.data_arg = data_arg;
-}
-/* Return the copy function used to hold the body of OMP_TASK GS.  */
-static inline tree
-gimple_omp_task_copy_fn (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_task.copy_fn;
-}
-/* Return a pointer to the copy function used to hold the body of
-OMP_TASK GS.  */
-static inline tree *
-gimple_omp_task_copy_fn_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_task.copy_fn;
-}
-/* Set CHILD_FN to be the copy function for OMP_TASK GS.  */
-static inline void
-gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_task.copy_fn = copy_fn;
-}
-/* Return size of the data block in bytes in OMP_TASK GS.  */
-static inline tree
-gimple_omp_task_arg_size (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_task.arg_size;
-}
-/* Return a pointer to the data block size for OMP_TASK GS.  */
-static inline tree *
-gimple_omp_task_arg_size_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_task.arg_size;
-}
-/* Set ARG_SIZE to be the data block size for OMP_TASK GS.  */
-static inline void
-gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_task.arg_size = arg_size;
-}
-/* Return align of the data block in bytes in OMP_TASK GS.  */
-static inline tree
-gimple_omp_task_arg_align (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return gs->gimple_omp_task.arg_align;
-}
-/* Return a pointer to the data block align for OMP_TASK GS.  */
-static inline tree *
-gimple_omp_task_arg_align_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-return &gs->gimple_omp_task.arg_align;
-}
-/* Set ARG_SIZE to be the data block align for OMP_TASK GS.  */
-static inline void
-gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
-gs->gimple_omp_task.arg_align = arg_align;
-}
-/* Return the clauses associated with OMP_SINGLE GS.  */
-static inline tree
-gimple_omp_single_clauses (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
-return gs->gimple_omp_single.clauses;
-}
-/* Return a pointer to the clauses associated with OMP_SINGLE GS.  */
-static inline tree *
-gimple_omp_single_clauses_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
-return &gs->gimple_omp_single.clauses;
-}
-/* Set CLAUSES to be the clauses associated with OMP_SINGLE GS.  */
-static inline void
-gimple_omp_single_set_clauses (gimple gs, tree clauses)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
-gs->gimple_omp_single.clauses = clauses;
-}
-/* Return the clauses associated with OMP_SECTIONS GS.  */
-static inline tree
-gimple_omp_sections_clauses (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
-return gs->gimple_omp_sections.clauses;
-}
-/* Return a pointer to the clauses associated with OMP_SECTIONS GS.  */
-static inline tree *
-gimple_omp_sections_clauses_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
-return &gs->gimple_omp_sections.clauses;
-}
-/* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
-GS.  */
-static inline void
-gimple_omp_sections_set_clauses (gimple gs, tree clauses)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
-gs->gimple_omp_sections.clauses = clauses;
-}
-/* Return the control variable associated with the GIMPLE_OMP_SECTIONS
-in GS.  */
-static inline tree
-gimple_omp_sections_control (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
-return gs->gimple_omp_sections.control;
-}
-/* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
-GS.  */
-static inline tree *
-gimple_omp_sections_control_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
-return &gs->gimple_omp_sections.control;
-}
-/* Set CONTROL to be the set of clauses associated with the
-GIMPLE_OMP_SECTIONS in GS.  */
-static inline void
-gimple_omp_sections_set_control (gimple gs, tree control)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
-gs->gimple_omp_sections.control = control;
-}
-/* Set COND to be the condition code for OMP_FOR GS.  */
-static inline void
-gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-gs->gimple_omp_for.iter[i].cond = cond;
-}
-/* Return the condition code associated with OMP_FOR GS.  */
-static inline enum tree_code
-gimple_omp_for_cond (const_gimple gs, size_t i)
-{
-GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
-gcc_assert (i < gs->gimple_omp_for.collapse);
-return gs->gimple_omp_for.iter[i].cond;
-}
-/* Set the value being stored in an atomic store.  */
-static inline void
-gimple_omp_atomic_store_set_val (gimple g, tree val)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
-g->gimple_omp_atomic_store.val = val;
-}
-/* Return the value being stored in an atomic store.  */
-static inline tree
-gimple_omp_atomic_store_val (const_gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
-return g->gimple_omp_atomic_store.val;
-}
-/* Return a pointer to the value being stored in an atomic store.  */
-static inline tree *
-gimple_omp_atomic_store_val_ptr (gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
-return &g->gimple_omp_atomic_store.val;
-}
-/* Set the LHS of an atomic load.  */
-static inline void
-gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
-g->gimple_omp_atomic_load.lhs = lhs;
-}
-/* Get the LHS of an atomic load.  */
-static inline tree
-gimple_omp_atomic_load_lhs (const_gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
-return g->gimple_omp_atomic_load.lhs;
-}
-/* Return a pointer to the LHS of an atomic load.  */
-static inline tree *
-gimple_omp_atomic_load_lhs_ptr (gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
-return &g->gimple_omp_atomic_load.lhs;
-}
-/* Set the RHS of an atomic load.  */
-static inline void
-gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
-g->gimple_omp_atomic_load.rhs = rhs;
-}
-/* Get the RHS of an atomic load.  */
-static inline tree
-gimple_omp_atomic_load_rhs (const_gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
-return g->gimple_omp_atomic_load.rhs;
-}
-/* Return a pointer to the RHS of an atomic load.  */
-static inline tree *
-gimple_omp_atomic_load_rhs_ptr (gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
-return &g->gimple_omp_atomic_load.rhs;
-}
-/* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
-static inline tree
-gimple_omp_continue_control_def (const_gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
-return g->gimple_omp_continue.control_def;
-}
-/* The same as above, but return the address.  */
-static inline tree *
-gimple_omp_continue_control_def_ptr (gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
-return &g->gimple_omp_continue.control_def;
-}
-/* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
-static inline void
-gimple_omp_continue_set_control_def (gimple g, tree def)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
-g->gimple_omp_continue.control_def = def;
-}
-/* Get the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
-static inline tree
-gimple_omp_continue_control_use (const_gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
-return g->gimple_omp_continue.control_use;
-}
-/* The same as above, but return the address.  */
-static inline tree *
-gimple_omp_continue_control_use_ptr (gimple g)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
-return &g->gimple_omp_continue.control_use;
-}
-/* Set the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
-static inline void
-gimple_omp_continue_set_control_use (gimple g, tree use)
-{
-GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
-g->gimple_omp_continue.control_use = use;
-}
-/* Return a pointer to the return value for GIMPLE_RETURN GS.  */
-static inline tree *
-gimple_return_retval_ptr (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_RETURN);
-gcc_assert (gimple_num_ops (gs) == 1);
-return gimple_op_ptr (gs, 0);
-}
-/* Return the return value for GIMPLE_RETURN GS.  */
-static inline tree
-gimple_return_retval (const_gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_RETURN);
-gcc_assert (gimple_num_ops (gs) == 1);
-return gimple_op (gs, 0);
-}
-/* Set RETVAL to be the return value for GIMPLE_RETURN GS.  */
-static inline void
-gimple_return_set_retval (gimple gs, tree retval)
-{
-GIMPLE_CHECK (gs, GIMPLE_RETURN);
-gcc_assert (gimple_num_ops (gs) == 1);
-gcc_assert (retval == NULL_TREE
-|| TREE_CODE (retval) == RESULT_DECL
-	      || is_gimple_val (retval));
-gimple_set_op (gs, 0, retval);
-}
-/* Returns true when the gimple statment STMT is any of the OpenMP types.  */
-static inline bool
-is_gimple_omp (const_gimple stmt)
-{
-return (gimple_code (stmt) == GIMPLE_OMP_PARALLEL
-	  || gimple_code (stmt) == GIMPLE_OMP_TASK
-	  || gimple_code (stmt) == GIMPLE_OMP_FOR
-	  || gimple_code (stmt) == GIMPLE_OMP_SECTIONS
-	  || gimple_code (stmt) == GIMPLE_OMP_SECTIONS_SWITCH
-	  || gimple_code (stmt) == GIMPLE_OMP_SINGLE
-	  || gimple_code (stmt) == GIMPLE_OMP_SECTION
-	  || gimple_code (stmt) == GIMPLE_OMP_MASTER
-	  || gimple_code (stmt) == GIMPLE_OMP_ORDERED
-	  || gimple_code (stmt) == GIMPLE_OMP_CRITICAL
-	  || gimple_code (stmt) == GIMPLE_OMP_RETURN
-	  || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_LOAD
-	  || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_STORE
-	  || gimple_code (stmt) == GIMPLE_OMP_CONTINUE);
-}
-/* Returns TRUE if statement G is a GIMPLE_NOP.  */
-static inline bool
-gimple_nop_p (const_gimple g)
-{
-return gimple_code (g) == GIMPLE_NOP;
-}
-/* Return the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS.  */
-static inline tree
-gimple_cdt_new_type (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-return gimple_op (gs, 1);
-}
-/* Return a pointer to the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline tree *
-gimple_cdt_new_type_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-return gimple_op_ptr (gs, 1);
-}
-/* Set NEW_TYPE to be the type returned by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline void
-gimple_cdt_set_new_type (gimple gs, tree new_type)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-gcc_assert (TREE_CODE_CLASS (TREE_CODE (new_type)) == tcc_type);
-gimple_set_op (gs, 1, new_type);
-}
-/* Return the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS.  */
-static inline tree
-gimple_cdt_location (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-return gimple_op (gs, 0);
-}
-/* Return a pointer to the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline tree *
-gimple_cdt_location_ptr (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-return gimple_op_ptr (gs, 0);
-}
-/* Set PTR to be the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
-statement GS.  */
-static inline void
-gimple_cdt_set_location (gimple gs, tree ptr)
-{
-GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
-gimple_set_op (gs, 0, ptr);
-}
-/* Return the predictor of GIMPLE_PREDICT statement GS.  */
-static inline enum br_predictor
-gimple_predict_predictor (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_PREDICT);
-return (enum br_predictor) (gs->gsbase.subcode & ~GF_PREDICT_TAKEN);
-}
-/* Set the predictor of GIMPLE_PREDICT statement GS to PREDICT.  */
-static inline void
-gimple_predict_set_predictor (gimple gs, enum br_predictor predictor)
-{
-GIMPLE_CHECK (gs, GIMPLE_PREDICT);
-gs->gsbase.subcode = (gs->gsbase.subcode & GF_PREDICT_TAKEN)
-		       | (unsigned) predictor;
-}
-/* Return the outcome of GIMPLE_PREDICT statement GS.  */
-static inline enum prediction
-gimple_predict_outcome (gimple gs)
-{
-GIMPLE_CHECK (gs, GIMPLE_PREDICT);
-return (gs->gsbase.subcode & GF_PREDICT_TAKEN) ? TAKEN : NOT_TAKEN;
-}
-/* Set the outcome of GIMPLE_PREDICT statement GS to OUTCOME.  */
-static inline void
-gimple_predict_set_outcome (gimple gs, enum prediction outcome)
-{
-GIMPLE_CHECK (gs, GIMPLE_PREDICT);
-if (outcome == TAKEN)
-gs->gsbase.subcode |= GF_PREDICT_TAKEN;
-else
-gs->gsbase.subcode &= ~GF_PREDICT_TAKEN;
 }
 /* Return a new iterator pointing to GIMPLE_SEQ's first statement.  */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple.h @ 19:58ad6c70ea60