[26/46] Make more use of dyn_cast in tree-vect*

Message ID 87sh49ne6u.fsf@arm.com
State New
Headers show
Series
  • Remove vinfo_for_stmt etc.
Related show

Commit Message

Richard Sandiford July 24, 2018, 10:03 a.m.
If we use stmt_vec_infos to represent statements in the vectoriser,
it's then more natural to use dyn_cast when processing the statement
as an assignment, call, etc.  This patch does that in a few more places.


2018-07-24  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vect-data-refs.c (vect_check_gather_scatter): Pass the
	gcall rather than the generic gimple stmt to gimple_call_internal_fn.
	(vect_get_smallest_scalar_type, can_group_stmts_p): Use dyn_cast
	to get gassigns and gcalls, rather than operating on generc gimple
	stmts.
	* tree-vect-stmts.c (exist_non_indexing_operands_for_use_p)
	(vect_mark_stmts_to_be_vectorized, vectorizable_store)
	(vectorizable_load, vect_analyze_stmt): Likewise.
	* tree-vect-loop.c (vectorizable_reduction): Likewise gphi.

Comments

Richard Biener July 25, 2018, 9:31 a.m. | #1
On Tue, Jul 24, 2018 at 12:03 PM Richard Sandiford
<richard.sandiford@arm.com> wrote:
>

> If we use stmt_vec_infos to represent statements in the vectoriser,

> it's then more natural to use dyn_cast when processing the statement

> as an assignment, call, etc.  This patch does that in a few more places.


OK.

>

> 2018-07-24  Richard Sandiford  <richard.sandiford@arm.com>

>

> gcc/

>         * tree-vect-data-refs.c (vect_check_gather_scatter): Pass the

>         gcall rather than the generic gimple stmt to gimple_call_internal_fn.

>         (vect_get_smallest_scalar_type, can_group_stmts_p): Use dyn_cast

>         to get gassigns and gcalls, rather than operating on generc gimple

>         stmts.

>         * tree-vect-stmts.c (exist_non_indexing_operands_for_use_p)

>         (vect_mark_stmts_to_be_vectorized, vectorizable_store)

>         (vectorizable_load, vect_analyze_stmt): Likewise.

>         * tree-vect-loop.c (vectorizable_reduction): Likewise gphi.

>

> Index: gcc/tree-vect-data-refs.c

> ===================================================================

> --- gcc/tree-vect-data-refs.c   2018-07-24 10:23:25.228822172 +0100

> +++ gcc/tree-vect-data-refs.c   2018-07-24 10:23:28.452793542 +0100

> @@ -130,15 +130,16 @@ vect_get_smallest_scalar_type (gimple *s

>

>    lhs = rhs = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type));

>

> -  if (is_gimple_assign (stmt)

> -      && (gimple_assign_cast_p (stmt)

> -          || gimple_assign_rhs_code (stmt) == DOT_PROD_EXPR

> -          || gimple_assign_rhs_code (stmt) == WIDEN_SUM_EXPR

> -          || gimple_assign_rhs_code (stmt) == WIDEN_MULT_EXPR

> -          || gimple_assign_rhs_code (stmt) == WIDEN_LSHIFT_EXPR

> -          || gimple_assign_rhs_code (stmt) == FLOAT_EXPR))

> +  gassign *assign = dyn_cast <gassign *> (stmt);

> +  if (assign

> +      && (gimple_assign_cast_p (assign)

> +         || gimple_assign_rhs_code (assign) == DOT_PROD_EXPR

> +         || gimple_assign_rhs_code (assign) == WIDEN_SUM_EXPR

> +         || gimple_assign_rhs_code (assign) == WIDEN_MULT_EXPR

> +         || gimple_assign_rhs_code (assign) == WIDEN_LSHIFT_EXPR

> +         || gimple_assign_rhs_code (assign) == FLOAT_EXPR))

>      {

> -      tree rhs_type = TREE_TYPE (gimple_assign_rhs1 (stmt));

> +      tree rhs_type = TREE_TYPE (gimple_assign_rhs1 (assign));

>

>        rhs = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (rhs_type));

>        if (rhs < lhs)

> @@ -2850,21 +2851,23 @@ can_group_stmts_p (gimple *stmt1, gimple

>    if (gimple_assign_single_p (stmt1))

>      return gimple_assign_single_p (stmt2);

>

> -  if (is_gimple_call (stmt1) && gimple_call_internal_p (stmt1))

> +  gcall *call1 = dyn_cast <gcall *> (stmt1);

> +  if (call1 && gimple_call_internal_p (call1))

>      {

>        /* Check for two masked loads or two masked stores.  */

> -      if (!is_gimple_call (stmt2) || !gimple_call_internal_p (stmt2))

> +      gcall *call2 = dyn_cast <gcall *> (stmt2);

> +      if (!call2 || !gimple_call_internal_p (call2))

>         return false;

> -      internal_fn ifn = gimple_call_internal_fn (stmt1);

> +      internal_fn ifn = gimple_call_internal_fn (call1);

>        if (ifn != IFN_MASK_LOAD && ifn != IFN_MASK_STORE)

>         return false;

> -      if (ifn != gimple_call_internal_fn (stmt2))

> +      if (ifn != gimple_call_internal_fn (call2))

>         return false;

>

>        /* Check that the masks are the same.  Cope with casts of masks,

>          like those created by build_mask_conversion.  */

> -      tree mask1 = gimple_call_arg (stmt1, 2);

> -      tree mask2 = gimple_call_arg (stmt2, 2);

> +      tree mask1 = gimple_call_arg (call1, 2);

> +      tree mask2 = gimple_call_arg (call2, 2);

>        if (!operand_equal_p (mask1, mask2, 0))

>         {

>           mask1 = strip_conversion (mask1);

> @@ -3665,7 +3668,7 @@ vect_check_gather_scatter (gimple *stmt,

>    gcall *call = dyn_cast <gcall *> (stmt);

>    if (call && gimple_call_internal_p (call))

>      {

> -      ifn = gimple_call_internal_fn (stmt);

> +      ifn = gimple_call_internal_fn (call);

>        if (internal_gather_scatter_fn_p (ifn))

>         {

>           vect_describe_gather_scatter_call (call, info);

> Index: gcc/tree-vect-stmts.c

> ===================================================================

> --- gcc/tree-vect-stmts.c       2018-07-24 10:23:22.260848529 +0100

> +++ gcc/tree-vect-stmts.c       2018-07-24 10:23:28.456793506 +0100

> @@ -389,30 +389,31 @@ exist_non_indexing_operands_for_use_p (t

>       Therefore, all we need to check is if STMT falls into the

>       first case, and whether var corresponds to USE.  */

>

> -  if (!gimple_assign_copy_p (stmt))

> +  gassign *assign = dyn_cast <gassign *> (stmt);

> +  if (!assign || !gimple_assign_copy_p (assign))

>      {

> -      if (is_gimple_call (stmt)

> -         && gimple_call_internal_p (stmt))

> +      gcall *call = dyn_cast <gcall *> (stmt);

> +      if (call && gimple_call_internal_p (call))

>         {

> -         internal_fn ifn = gimple_call_internal_fn (stmt);

> +         internal_fn ifn = gimple_call_internal_fn (call);

>           int mask_index = internal_fn_mask_index (ifn);

>           if (mask_index >= 0

> -             && use == gimple_call_arg (stmt, mask_index))

> +             && use == gimple_call_arg (call, mask_index))

>             return true;

>           int stored_value_index = internal_fn_stored_value_index (ifn);

>           if (stored_value_index >= 0

> -             && use == gimple_call_arg (stmt, stored_value_index))

> +             && use == gimple_call_arg (call, stored_value_index))

>             return true;

>           if (internal_gather_scatter_fn_p (ifn)

> -             && use == gimple_call_arg (stmt, 1))

> +             && use == gimple_call_arg (call, 1))

>             return true;

>         }

>        return false;

>      }

>

> -  if (TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME)

> +  if (TREE_CODE (gimple_assign_lhs (assign)) == SSA_NAME)

>      return false;

> -  operand = gimple_assign_rhs1 (stmt);

> +  operand = gimple_assign_rhs1 (assign);

>    if (TREE_CODE (operand) != SSA_NAME)

>      return false;

>

> @@ -739,10 +740,10 @@ vect_mark_stmts_to_be_vectorized (loop_v

>            /* Pattern statements are not inserted into the code, so

>               FOR_EACH_PHI_OR_STMT_USE optimizes their operands out, and we

>               have to scan the RHS or function arguments instead.  */

> -          if (is_gimple_assign (stmt))

> -            {

> -             enum tree_code rhs_code = gimple_assign_rhs_code (stmt);

> -             tree op = gimple_assign_rhs1 (stmt);

> +         if (gassign *assign = dyn_cast <gassign *> (stmt))

> +           {

> +             enum tree_code rhs_code = gimple_assign_rhs_code (assign);

> +             tree op = gimple_assign_rhs1 (assign);

>

>               i = 1;

>               if (rhs_code == COND_EXPR && COMPARISON_CLASS_P (op))

> @@ -754,25 +755,25 @@ vect_mark_stmts_to_be_vectorized (loop_v

>                     return false;

>                   i = 2;

>                 }

> -             for (; i < gimple_num_ops (stmt); i++)

> -                {

> -                 op = gimple_op (stmt, i);

> +             for (; i < gimple_num_ops (assign); i++)

> +               {

> +                 op = gimple_op (assign, i);

>                    if (TREE_CODE (op) == SSA_NAME

>                       && !process_use (stmt, op, loop_vinfo, relevant,

>                                        &worklist, false))

>                      return false;

>                   }

>              }

> -          else if (is_gimple_call (stmt))

> -            {

> -              for (i = 0; i < gimple_call_num_args (stmt); i++)

> -                {

> -                  tree arg = gimple_call_arg (stmt, i);

> +         else if (gcall *call = dyn_cast <gcall *> (stmt))

> +           {

> +             for (i = 0; i < gimple_call_num_args (call); i++)

> +               {

> +                 tree arg = gimple_call_arg (call, i);

>                   if (!process_use (stmt, arg, loop_vinfo, relevant,

>                                     &worklist, false))

>                      return false;

> -                }

> -            }

> +               }

> +           }

>          }

>        else

>          FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_USE)

> @@ -6274,9 +6275,9 @@ vectorizable_store (gimple *stmt, gimple

>    /* Is vectorizable store? */

>

>    tree mask = NULL_TREE, mask_vectype = NULL_TREE;

> -  if (is_gimple_assign (stmt))

> +  if (gassign *assign = dyn_cast <gassign *> (stmt))

>      {

> -      tree scalar_dest = gimple_assign_lhs (stmt);

> +      tree scalar_dest = gimple_assign_lhs (assign);

>        if (TREE_CODE (scalar_dest) == VIEW_CONVERT_EXPR

>           && is_pattern_stmt_p (stmt_info))

>         scalar_dest = TREE_OPERAND (scalar_dest, 0);

> @@ -7445,13 +7446,13 @@ vectorizable_load (gimple *stmt, gimple_

>      return false;

>

>    tree mask = NULL_TREE, mask_vectype = NULL_TREE;

> -  if (is_gimple_assign (stmt))

> +  if (gassign *assign = dyn_cast <gassign *> (stmt))

>      {

> -      scalar_dest = gimple_assign_lhs (stmt);

> +      scalar_dest = gimple_assign_lhs (assign);

>        if (TREE_CODE (scalar_dest) != SSA_NAME)

>         return false;

>

> -      tree_code code = gimple_assign_rhs_code (stmt);

> +      tree_code code = gimple_assign_rhs_code (assign);

>        if (code != ARRAY_REF

>           && code != BIT_FIELD_REF

>           && code != INDIRECT_REF

> @@ -9557,9 +9558,9 @@ vect_analyze_stmt (gimple *stmt, bool *n

>    if (STMT_VINFO_RELEVANT_P (stmt_info))

>      {

>        gcc_assert (!VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt))));

> +      gcall *call = dyn_cast <gcall *> (stmt);

>        gcc_assert (STMT_VINFO_VECTYPE (stmt_info)

> -                 || (is_gimple_call (stmt)

> -                     && gimple_call_lhs (stmt) == NULL_TREE));

> +                 || (call && gimple_call_lhs (call) == NULL_TREE));

>        *need_to_vectorize = true;

>      }

>

> Index: gcc/tree-vect-loop.c

> ===================================================================

> --- gcc/tree-vect-loop.c        2018-07-24 10:23:22.260848529 +0100

> +++ gcc/tree-vect-loop.c        2018-07-24 10:23:28.456793506 +0100

> @@ -6109,9 +6109,9 @@ vectorizable_reduction (gimple *stmt, gi

>      gcc_assert (slp_node

>                 && REDUC_GROUP_FIRST_ELEMENT (stmt_info) == stmt_info);

>

> -  if (gimple_code (stmt) == GIMPLE_PHI)

> +  if (gphi *phi = dyn_cast <gphi *> (stmt))

>      {

> -      tree phi_result = gimple_phi_result (stmt);

> +      tree phi_result = gimple_phi_result (phi);

>        /* Analysis is fully done on the reduction stmt invocation.  */

>        if (! vec_stmt)

>         {

> @@ -6141,7 +6141,7 @@ vectorizable_reduction (gimple *stmt, gi

>        for (unsigned k = 1; k < gimple_num_ops (reduc_stmt); ++k)

>         {

>           tree op = gimple_op (reduc_stmt, k);

> -         if (op == gimple_phi_result (stmt))

> +         if (op == phi_result)

>             continue;

>           if (k == 1

>               && gimple_assign_rhs_code (reduc_stmt) == COND_EXPR)

Patch

Index: gcc/tree-vect-data-refs.c
===================================================================
--- gcc/tree-vect-data-refs.c	2018-07-24 10:23:25.228822172 +0100
+++ gcc/tree-vect-data-refs.c	2018-07-24 10:23:28.452793542 +0100
@@ -130,15 +130,16 @@  vect_get_smallest_scalar_type (gimple *s
 
   lhs = rhs = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type));
 
-  if (is_gimple_assign (stmt)
-      && (gimple_assign_cast_p (stmt)
-          || gimple_assign_rhs_code (stmt) == DOT_PROD_EXPR
-          || gimple_assign_rhs_code (stmt) == WIDEN_SUM_EXPR
-          || gimple_assign_rhs_code (stmt) == WIDEN_MULT_EXPR
-          || gimple_assign_rhs_code (stmt) == WIDEN_LSHIFT_EXPR
-          || gimple_assign_rhs_code (stmt) == FLOAT_EXPR))
+  gassign *assign = dyn_cast <gassign *> (stmt);
+  if (assign
+      && (gimple_assign_cast_p (assign)
+	  || gimple_assign_rhs_code (assign) == DOT_PROD_EXPR
+	  || gimple_assign_rhs_code (assign) == WIDEN_SUM_EXPR
+	  || gimple_assign_rhs_code (assign) == WIDEN_MULT_EXPR
+	  || gimple_assign_rhs_code (assign) == WIDEN_LSHIFT_EXPR
+	  || gimple_assign_rhs_code (assign) == FLOAT_EXPR))
     {
-      tree rhs_type = TREE_TYPE (gimple_assign_rhs1 (stmt));
+      tree rhs_type = TREE_TYPE (gimple_assign_rhs1 (assign));
 
       rhs = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (rhs_type));
       if (rhs < lhs)
@@ -2850,21 +2851,23 @@  can_group_stmts_p (gimple *stmt1, gimple
   if (gimple_assign_single_p (stmt1))
     return gimple_assign_single_p (stmt2);
 
-  if (is_gimple_call (stmt1) && gimple_call_internal_p (stmt1))
+  gcall *call1 = dyn_cast <gcall *> (stmt1);
+  if (call1 && gimple_call_internal_p (call1))
     {
       /* Check for two masked loads or two masked stores.  */
-      if (!is_gimple_call (stmt2) || !gimple_call_internal_p (stmt2))
+      gcall *call2 = dyn_cast <gcall *> (stmt2);
+      if (!call2 || !gimple_call_internal_p (call2))
 	return false;
-      internal_fn ifn = gimple_call_internal_fn (stmt1);
+      internal_fn ifn = gimple_call_internal_fn (call1);
       if (ifn != IFN_MASK_LOAD && ifn != IFN_MASK_STORE)
 	return false;
-      if (ifn != gimple_call_internal_fn (stmt2))
+      if (ifn != gimple_call_internal_fn (call2))
 	return false;
 
       /* Check that the masks are the same.  Cope with casts of masks,
 	 like those created by build_mask_conversion.  */
-      tree mask1 = gimple_call_arg (stmt1, 2);
-      tree mask2 = gimple_call_arg (stmt2, 2);
+      tree mask1 = gimple_call_arg (call1, 2);
+      tree mask2 = gimple_call_arg (call2, 2);
       if (!operand_equal_p (mask1, mask2, 0))
 	{
 	  mask1 = strip_conversion (mask1);
@@ -3665,7 +3668,7 @@  vect_check_gather_scatter (gimple *stmt,
   gcall *call = dyn_cast <gcall *> (stmt);
   if (call && gimple_call_internal_p (call))
     {
-      ifn = gimple_call_internal_fn (stmt);
+      ifn = gimple_call_internal_fn (call);
       if (internal_gather_scatter_fn_p (ifn))
 	{
 	  vect_describe_gather_scatter_call (call, info);
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2018-07-24 10:23:22.260848529 +0100
+++ gcc/tree-vect-stmts.c	2018-07-24 10:23:28.456793506 +0100
@@ -389,30 +389,31 @@  exist_non_indexing_operands_for_use_p (t
      Therefore, all we need to check is if STMT falls into the
      first case, and whether var corresponds to USE.  */
 
-  if (!gimple_assign_copy_p (stmt))
+  gassign *assign = dyn_cast <gassign *> (stmt);
+  if (!assign || !gimple_assign_copy_p (assign))
     {
-      if (is_gimple_call (stmt)
-	  && gimple_call_internal_p (stmt))
+      gcall *call = dyn_cast <gcall *> (stmt);
+      if (call && gimple_call_internal_p (call))
 	{
-	  internal_fn ifn = gimple_call_internal_fn (stmt);
+	  internal_fn ifn = gimple_call_internal_fn (call);
 	  int mask_index = internal_fn_mask_index (ifn);
 	  if (mask_index >= 0
-	      && use == gimple_call_arg (stmt, mask_index))
+	      && use == gimple_call_arg (call, mask_index))
 	    return true;
 	  int stored_value_index = internal_fn_stored_value_index (ifn);
 	  if (stored_value_index >= 0
-	      && use == gimple_call_arg (stmt, stored_value_index))
+	      && use == gimple_call_arg (call, stored_value_index))
 	    return true;
 	  if (internal_gather_scatter_fn_p (ifn)
-	      && use == gimple_call_arg (stmt, 1))
+	      && use == gimple_call_arg (call, 1))
 	    return true;
 	}
       return false;
     }
 
-  if (TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME)
+  if (TREE_CODE (gimple_assign_lhs (assign)) == SSA_NAME)
     return false;
-  operand = gimple_assign_rhs1 (stmt);
+  operand = gimple_assign_rhs1 (assign);
   if (TREE_CODE (operand) != SSA_NAME)
     return false;
 
@@ -739,10 +740,10 @@  vect_mark_stmts_to_be_vectorized (loop_v
           /* Pattern statements are not inserted into the code, so
              FOR_EACH_PHI_OR_STMT_USE optimizes their operands out, and we
              have to scan the RHS or function arguments instead.  */
-          if (is_gimple_assign (stmt))
-            {
-	      enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
-	      tree op = gimple_assign_rhs1 (stmt);
+	  if (gassign *assign = dyn_cast <gassign *> (stmt))
+	    {
+	      enum tree_code rhs_code = gimple_assign_rhs_code (assign);
+	      tree op = gimple_assign_rhs1 (assign);
 
 	      i = 1;
 	      if (rhs_code == COND_EXPR && COMPARISON_CLASS_P (op))
@@ -754,25 +755,25 @@  vect_mark_stmts_to_be_vectorized (loop_v
 		    return false;
 		  i = 2;
 		}
-	      for (; i < gimple_num_ops (stmt); i++)
-                {
-		  op = gimple_op (stmt, i);
+	      for (; i < gimple_num_ops (assign); i++)
+		{
+		  op = gimple_op (assign, i);
                   if (TREE_CODE (op) == SSA_NAME
 		      && !process_use (stmt, op, loop_vinfo, relevant,
 				       &worklist, false))
                     return false;
                  }
             }
-          else if (is_gimple_call (stmt))
-            {
-              for (i = 0; i < gimple_call_num_args (stmt); i++)
-                {
-                  tree arg = gimple_call_arg (stmt, i);
+	  else if (gcall *call = dyn_cast <gcall *> (stmt))
+	    {
+	      for (i = 0; i < gimple_call_num_args (call); i++)
+		{
+		  tree arg = gimple_call_arg (call, i);
 		  if (!process_use (stmt, arg, loop_vinfo, relevant,
 				    &worklist, false))
                     return false;
-                }
-            }
+		}
+	    }
         }
       else
         FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_USE)
@@ -6274,9 +6275,9 @@  vectorizable_store (gimple *stmt, gimple
   /* Is vectorizable store? */
 
   tree mask = NULL_TREE, mask_vectype = NULL_TREE;
-  if (is_gimple_assign (stmt))
+  if (gassign *assign = dyn_cast <gassign *> (stmt))
     {
-      tree scalar_dest = gimple_assign_lhs (stmt);
+      tree scalar_dest = gimple_assign_lhs (assign);
       if (TREE_CODE (scalar_dest) == VIEW_CONVERT_EXPR
 	  && is_pattern_stmt_p (stmt_info))
 	scalar_dest = TREE_OPERAND (scalar_dest, 0);
@@ -7445,13 +7446,13 @@  vectorizable_load (gimple *stmt, gimple_
     return false;
 
   tree mask = NULL_TREE, mask_vectype = NULL_TREE;
-  if (is_gimple_assign (stmt))
+  if (gassign *assign = dyn_cast <gassign *> (stmt))
     {
-      scalar_dest = gimple_assign_lhs (stmt);
+      scalar_dest = gimple_assign_lhs (assign);
       if (TREE_CODE (scalar_dest) != SSA_NAME)
 	return false;
 
-      tree_code code = gimple_assign_rhs_code (stmt);
+      tree_code code = gimple_assign_rhs_code (assign);
       if (code != ARRAY_REF
 	  && code != BIT_FIELD_REF
 	  && code != INDIRECT_REF
@@ -9557,9 +9558,9 @@  vect_analyze_stmt (gimple *stmt, bool *n
   if (STMT_VINFO_RELEVANT_P (stmt_info))
     {
       gcc_assert (!VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt))));
+      gcall *call = dyn_cast <gcall *> (stmt);
       gcc_assert (STMT_VINFO_VECTYPE (stmt_info)
-		  || (is_gimple_call (stmt)
-		      && gimple_call_lhs (stmt) == NULL_TREE));
+		  || (call && gimple_call_lhs (call) == NULL_TREE));
       *need_to_vectorize = true;
     }
 
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2018-07-24 10:23:22.260848529 +0100
+++ gcc/tree-vect-loop.c	2018-07-24 10:23:28.456793506 +0100
@@ -6109,9 +6109,9 @@  vectorizable_reduction (gimple *stmt, gi
     gcc_assert (slp_node
 		&& REDUC_GROUP_FIRST_ELEMENT (stmt_info) == stmt_info);
 
-  if (gimple_code (stmt) == GIMPLE_PHI)
+  if (gphi *phi = dyn_cast <gphi *> (stmt))
     {
-      tree phi_result = gimple_phi_result (stmt);
+      tree phi_result = gimple_phi_result (phi);
       /* Analysis is fully done on the reduction stmt invocation.  */
       if (! vec_stmt)
 	{
@@ -6141,7 +6141,7 @@  vectorizable_reduction (gimple *stmt, gi
       for (unsigned k = 1; k < gimple_num_ops (reduc_stmt); ++k)
 	{
 	  tree op = gimple_op (reduc_stmt, k);
-	  if (op == gimple_phi_result (stmt))
+	  if (op == phi_result)
 	    continue;
 	  if (k == 1
 	      && gimple_assign_rhs_code (reduc_stmt) == COND_EXPR)