[PATCH] More gimple accessor refactoring

[Richard Biener <rguenther at suse dot de>]

This handles calls and conds.

Bootstrapped and tested on x86_64-unknown-linux-gnu, applied.

Richard.

2015-08-13  Richard Biener  <rguenther@suse.de>

	* gimple.h (gcall::code_): New constant static member.
	(gcond::code_): Likewise.
	* gimple.c (gcall::code_): Define.
	(gcond::code_): Likewise.
	(is_a_helper <const gcond *>): Add.
	(gimple_call_lhs): Use GIMPLE_CHECK2 in the gimple overload
	and forward to a new gcall overload with less checking and a
	cheaper way to access the operand.
	(gimple_call_lhs_ptr): Likewise.
	(gimple_call_set_lhs): Likewise.
	(gimple_call_internal_p): Likewise.
	(gimple_call_with_bounds_p): Likewise.
	(gimple_call_set_with_bounds): Likewise.
	(gimple_call_internal_fn): Likewise.
	(gimple_call_set_ctrl_altering): Likewise.
	(gimple_call_ctrl_altering_p): Likewise.
	(gimple_call_fntype): Likewise.
	(gimple_call_fn): Likewise.
	(gimple_call_fn_ptr): Likewise.
	(gimple_call_set_fndecl): Likewise.
	(gimple_call_fndecl): Likewise.
	(gimple_call_chain): Likewise.
	(gimple_call_num_args): Likewise.
	(gimple_call_arg): Likewise.
	(gimple_call_arg_ptr): Likewise.
	(gimple_call_set_arg): Likewise.
	(gimple_call_noreturn_p): Likewise.
	(gimple_cond_code): Likewise.
	(gimple_cond_lhs): Likewise.
	(gimple_cond_rhs): Likewise.
	(gimple_has_lhs): Reduce checking.

Index: gcc/gimple.c
===================================================================
--- gcc/gimple.c	(revision 226802)
+++ gcc/gimple.c	(working copy)
@@ -91,6 +91,8 @@ static const char * const gimple_alloc_k
 
 /* Static gimple tuple members.  */
 const enum gimple_code gassign::code_;
+const enum gimple_code gcall::code_;
+const enum gimple_code gcond::code_;
 
 
 /* Gimple tuple constructors.
Index: gcc/gimple.h
===================================================================
--- gcc/gimple.h	(revision 226802)
+++ gcc/gimple.h	(working copy)
@@ -351,6 +351,8 @@ struct GTY((tag("GSS_CALL")))
      of this structure.  In particular, this means that this
      structure cannot be embedded inside another one.  */
   tree GTY((length ("%h.num_ops"))) op[1];
+
+  static const enum gimple_code code_ = GIMPLE_CALL;
 };
 
 
@@ -837,6 +839,7 @@ struct GTY((tag("GSS_WITH_OPS")))
   gcond : public gimple_statement_with_ops
 {
   /* no additional fields; this uses the layout for GSS_WITH_OPS. */
+  static const enum gimple_code code_ = GIMPLE_COND;
 };
 
 /* A statement with the invariant that
@@ -959,6 +962,14 @@ is_a_helper <gcond *>::test (gimple gs)
 template <>
 template <>
 inline bool
+is_a_helper <const gcond *>::test (const_gimple gs)
+{
+  return gs->code == GIMPLE_COND;
+}
+
+template <>
+template <>
+inline bool
 is_a_helper <gdebug *>::test (gimple gs)
 {
   return gs->code == GIMPLE_DEBUG;
@@ -2746,113 +2757,174 @@ is_gimple_call (const_gimple gs)
 /* Return the LHS of call statement GS.  */
 
 static inline tree
+gimple_call_lhs (const gcall *gs)
+{
+  return gs->op[0];
+}
+
+static inline tree
 gimple_call_lhs (const_gimple gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  return gimple_op (gs, 0);
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_lhs (gc);
 }
 
 
 /* Return a pointer to the LHS of call statement GS.  */
 
 static inline tree *
+gimple_call_lhs_ptr (const gcall *gs)
+{
+  return const_cast<tree *> (&gs->op[0]);
+}
+
+static inline tree *
 gimple_call_lhs_ptr (const_gimple gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  return gimple_op_ptr (gs, 0);
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_lhs_ptr (gc);
 }
 
 
 /* Set LHS to be the LHS operand of call statement GS.  */
 
 static inline void
-gimple_call_set_lhs (gimple gs, tree lhs)
+gimple_call_set_lhs (gcall *gs, tree lhs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  gimple_set_op (gs, 0, lhs);
+  gs->op[0] = lhs;
   if (lhs && TREE_CODE (lhs) == SSA_NAME)
     SSA_NAME_DEF_STMT (lhs) = gs;
 }
 
+static inline void
+gimple_call_set_lhs (gimple gs, tree lhs)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  gimple_call_set_lhs (gc, lhs);
+}
+
 
 /* Return true if call GS calls an internal-only function, as enumerated
    by internal_fn.  */
 
 static inline bool
-gimple_call_internal_p (const_gimple gs)
+gimple_call_internal_p (const gcall *gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
   return (gs->subcode & GF_CALL_INTERNAL) != 0;
 }
 
+static inline bool
+gimple_call_internal_p (const_gimple gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_internal_p (gc);
+}
+
 
 /* Return true if call GS is marked as instrumented by
    Pointer Bounds Checker.  */
 
 static inline bool
-gimple_call_with_bounds_p (const_gimple gs)
+gimple_call_with_bounds_p (const gcall *gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
   return (gs->subcode & GF_CALL_WITH_BOUNDS) != 0;
 }
 
+static inline bool
+gimple_call_with_bounds_p (const_gimple gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_with_bounds_p (gc);
+}
+
 
 /* If INSTRUMENTED_P is true, marm statement GS as instrumented by
    Pointer Bounds Checker.  */
 
 static inline void
-gimple_call_set_with_bounds (gimple gs, bool with_bounds)
+gimple_call_set_with_bounds (gcall *gs, bool with_bounds)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
   if (with_bounds)
     gs->subcode |= GF_CALL_WITH_BOUNDS;
   else
     gs->subcode &= ~GF_CALL_WITH_BOUNDS;
 }
 
+static inline void
+gimple_call_set_with_bounds (gimple gs, bool with_bounds)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  gimple_call_set_with_bounds (gc, with_bounds);
+}
+
 
 /* Return the target of internal call GS.  */
 
 static inline enum internal_fn
-gimple_call_internal_fn (const_gimple gs)
+gimple_call_internal_fn (const gcall *gs)
 {
   gcc_gimple_checking_assert (gimple_call_internal_p (gs));
-  return static_cast <const gcall *> (gs)->u.internal_fn;
+  return gs->u.internal_fn;
+}
+
+static inline enum internal_fn
+gimple_call_internal_fn (const_gimple gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_internal_fn (gc);
 }
 
 /* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
    that could alter control flow.  */
 
 static inline void
-gimple_call_set_ctrl_altering (gimple s, bool ctrl_altering_p)
+gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
 {
-  GIMPLE_CHECK (s, GIMPLE_CALL);
   if (ctrl_altering_p)
     s->subcode |= GF_CALL_CTRL_ALTERING;
   else
     s->subcode &= ~GF_CALL_CTRL_ALTERING;
 }
 
+static inline void
+gimple_call_set_ctrl_altering (gimple s, bool ctrl_altering_p)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (s);
+  gimple_call_set_ctrl_altering (gc, ctrl_altering_p);
+}
+
 /* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
    flag is set. Such call could not be a stmt in the middle of a bb.  */
 
 static inline bool
-gimple_call_ctrl_altering_p (const_gimple gs)
+gimple_call_ctrl_altering_p (const gcall *gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
   return (gs->subcode & GF_CALL_CTRL_ALTERING) != 0;
 }
 
+static inline bool
+gimple_call_ctrl_altering_p (const_gimple gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_ctrl_altering_p (gc);
+}
+
 
 /* Return the function type of the function called by GS.  */
 
 static inline tree
-gimple_call_fntype (const_gimple gs)
+gimple_call_fntype (const gcall *gs)
 {
-  const gcall *call_stmt = as_a <const gcall *> (gs);
   if (gimple_call_internal_p (gs))
     return NULL_TREE;
-  return call_stmt->u.fntype;
+  return gs->u.fntype;
+}
+
+static inline tree
+gimple_call_fntype (const_gimple gs)
+{
+  const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_fntype (call_stmt);
 }
 
 /* Set the type of the function called by CALL_STMT to FNTYPE.  */
@@ -2869,20 +2941,32 @@ gimple_call_set_fntype (gcall *call_stmt
    statement GS.  */
 
 static inline tree
+gimple_call_fn (const gcall *gs)
+{
+  return gs->op[1];
+}
+
+static inline tree
 gimple_call_fn (const_gimple gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  return gimple_op (gs, 1);
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_fn (gc);
 }
 
 /* Return a pointer to the tree node representing the function called by call
    statement GS.  */
 
 static inline tree *
+gimple_call_fn_ptr (const gcall *gs)
+{
+  return const_cast<tree *> (&gs->op[1]);
+}
+
+static inline tree *
 gimple_call_fn_ptr (const_gimple gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  return gimple_op_ptr (gs, 1);
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_fn_ptr (gc);
 }
 
 
@@ -2899,13 +2983,18 @@ gimple_call_set_fn (gcall *gs, tree fn)
 /* Set FNDECL to be the function called by call statement GS.  */
 
 static inline void
-gimple_call_set_fndecl (gimple gs, tree decl)
+gimple_call_set_fndecl (gcall *gs, tree decl)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
   gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
-  gimple_set_op (gs, 1, build1_loc (gimple_location (gs), ADDR_EXPR,
-				     build_pointer_type (TREE_TYPE (decl)),
-				     decl));
+  gs->op[1] = build1_loc (gimple_location (gs), ADDR_EXPR,
+			  build_pointer_type (TREE_TYPE (decl)), decl);
+}
+
+static inline void
+gimple_call_set_fndecl (gimple gs, tree decl)
+{
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  gimple_call_set_fndecl (gc, decl);
 }
 
 
@@ -2924,11 +3013,18 @@ gimple_call_set_internal_fn (gcall *call
    get_callee_fndecl in tree land.  */
 
 static inline tree
-gimple_call_fndecl (const_gimple gs)
+gimple_call_fndecl (const gcall *gs)
 {
   return gimple_call_addr_fndecl (gimple_call_fn (gs));
 }
 
+static inline tree
+gimple_call_fndecl (const_gimple gs)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_fndecl (gc);
+}
+
 
 /* Return the type returned by call statement GS.  */
 
@@ -2949,10 +3045,16 @@ gimple_call_return_type (const gcall *gs
 /* Return the static chain for call statement GS.  */
 
 static inline tree
+gimple_call_chain (const gcall *gs)
+{
+  return gs->op[2];
+}
+
+static inline tree
 gimple_call_chain (const_gimple gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  return gimple_op (gs, 2);
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_chain (gc);
 }
 
 
@@ -2976,22 +3078,33 @@ gimple_call_set_chain (gcall *call_stmt,
 /* Return the number of arguments used by call statement GS.  */
 
 static inline unsigned
+gimple_call_num_args (const gcall *gs)
+{
+  return gimple_num_ops (gs) - 3;
+}
+
+static inline unsigned
 gimple_call_num_args (const_gimple gs)
 {
-  unsigned num_ops;
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  num_ops = gimple_num_ops (gs);
-  return num_ops - 3;
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_num_args (gc);
 }
 
 
 /* Return the argument at position INDEX for call statement GS.  */
 
 static inline tree
+gimple_call_arg (const gcall *gs, unsigned index)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
+  return gs->op[index + 3];
+}
+
+static inline tree
 gimple_call_arg (const_gimple gs, unsigned index)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  return gimple_op (gs, index + 3);
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_arg (gc, index);
 }
 
 
@@ -2999,20 +3112,34 @@ gimple_call_arg (const_gimple gs, unsign
    statement GS.  */
 
 static inline tree *
+gimple_call_arg_ptr (const gcall *gs, unsigned index)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
+  return const_cast<tree *> (&gs->op[index + 3]);
+}
+
+static inline tree *
 gimple_call_arg_ptr (const_gimple gs, unsigned index)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  return gimple_op_ptr (gs, index + 3);
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
+  return gimple_call_arg_ptr (gc, index);
 }
 
 
 /* Set ARG to be the argument at position INDEX for call statement GS.  */
 
 static inline void
+gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
+{
+  gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
+  gs->op[index + 3] = arg;
+}
+
+static inline void
 gimple_call_set_arg (gimple gs, unsigned index, tree arg)
 {
-  GIMPLE_CHECK (gs, GIMPLE_CALL);
-  gimple_set_op (gs, index + 3, arg);
+  gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
+  gimple_call_set_arg (gc, index, arg);
 }
 
 
@@ -3110,12 +3237,18 @@ gimple_call_va_arg_pack_p (gcall *s)
 /* Return true if S is a noreturn call.  */
 
 static inline bool
-gimple_call_noreturn_p (gimple s)
+gimple_call_noreturn_p (const gcall *s)
 {
-  GIMPLE_CHECK (s, GIMPLE_CALL);
   return (gimple_call_flags (s) & ECF_NORETURN) != 0;
 }
 
+static inline bool
+gimple_call_noreturn_p (const_gimple s)
+{
+  const gcall *gc = GIMPLE_CHECK2<const gcall *> (s);
+  return gimple_call_noreturn_p (gc);
+}
+
 
 /* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
    even if the called function can throw in other cases.  */
@@ -3194,21 +3327,29 @@ gimple_call_clobber_set (gcall *call_stm
 static inline bool
 gimple_has_lhs (gimple stmt)
 {
-  return (is_gimple_assign (stmt)
-	  || (is_gimple_call (stmt)
-	      && gimple_call_lhs (stmt) != NULL_TREE));
+  if (is_gimple_assign (stmt))
+    return true;
+  if (gcall *call = dyn_cast <gcall *> (stmt))
+    return gimple_call_lhs (call) != NULL_TREE;
+  return false;
 }
 
 
 /* Return the code of the predicate computed by conditional statement GS.  */
 
 static inline enum tree_code
-gimple_cond_code (const_gimple gs)
+gimple_cond_code (const gcond *gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_COND);
   return (enum tree_code) gs->subcode;
 }
 
+static inline enum tree_code
+gimple_cond_code (const_gimple gs)
+{
+  const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
+  return gimple_cond_code (gc);
+}
+
 
 /* Set CODE to be the predicate code for the conditional statement GS.  */
 
@@ -3222,10 +3363,16 @@ gimple_cond_set_code (gcond *gs, enum tr
 /* Return the LHS of the predicate computed by conditional statement GS.  */
 
 static inline tree
+gimple_cond_lhs (const gcond *gs)
+{
+  return gs->op[0];
+}
+
+static inline tree
 gimple_cond_lhs (const_gimple gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_COND);
-  return gimple_op (gs, 0);
+  const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
+  return gimple_cond_lhs (gc);
 }
 
 /* Return the pointer to the LHS of the predicate computed by conditional
@@ -3250,10 +3397,16 @@ gimple_cond_set_lhs (gcond *gs, tree lhs
 /* Return the RHS operand of the predicate computed by conditional GS.  */
 
 static inline tree
+gimple_cond_rhs (const gcond *gs)
+{
+  return gs->op[1];
+}
+
+static inline tree
 gimple_cond_rhs (const_gimple gs)
 {
-  GIMPLE_CHECK (gs, GIMPLE_COND);
-  return gimple_op (gs, 1);
+  const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
+  return gimple_cond_rhs (gc);
 }
 
 /* Return the pointer to the RHS operand of the predicate computed by