[08/46] Add vec_info::lookup_def

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

Commit Message

Richard Sandiford July 24, 2018, 9:55 a.m.
This patch adds a vec_info helper for checking whether an operand is an
SSA_NAME that is defined in the vectorisable region.


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

gcc/
	* tree-vectorizer.h (vec_info::lookup_def): Declare.
	* tree-vectorizer.c (vec_info::lookup_def): New function.
	* tree-vect-patterns.c (vect_get_internal_def): Use it.
	(vect_widened_op_tree): Likewise.
	* tree-vect-stmts.c (vect_is_simple_use): Likewise.
	* tree-vect-loop.c (vect_analyze_loop_operations): Likewise.
	(vectorizable_reduction): Likewise.
	(vect_valid_reduction_input_p): Take a stmt_vec_info instead
	of a gimple *.
	(vect_is_slp_reduction): Update calls accordingly.  Use
	vec_info::lookup_def.
	(vect_is_simple_reduction): Likewise
	* tree-vect-slp.c (vect_detect_hybrid_slp_1): Use vec_info::lookup_def.

Comments

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

> This patch adds a vec_info helper for checking whether an operand is an

> SSA_NAME that is defined in the vectorisable region.


OK.

>

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

>

> gcc/

>         * tree-vectorizer.h (vec_info::lookup_def): Declare.

>         * tree-vectorizer.c (vec_info::lookup_def): New function.

>         * tree-vect-patterns.c (vect_get_internal_def): Use it.

>         (vect_widened_op_tree): Likewise.

>         * tree-vect-stmts.c (vect_is_simple_use): Likewise.

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

>         (vectorizable_reduction): Likewise.

>         (vect_valid_reduction_input_p): Take a stmt_vec_info instead

>         of a gimple *.

>         (vect_is_slp_reduction): Update calls accordingly.  Use

>         vec_info::lookup_def.

>         (vect_is_simple_reduction): Likewise

>         * tree-vect-slp.c (vect_detect_hybrid_slp_1): Use vec_info::lookup_def.

>

> Index: gcc/tree-vectorizer.h

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

> --- gcc/tree-vectorizer.h       2018-07-24 10:22:23.797367688 +0100

> +++ gcc/tree-vectorizer.h       2018-07-24 10:22:27.285336715 +0100

> @@ -219,6 +219,7 @@ struct vec_info {

>

>    stmt_vec_info add_stmt (gimple *);

>    stmt_vec_info lookup_stmt (gimple *);

> +  stmt_vec_info lookup_def (tree);

>

>    /* The type of vectorization.  */

>    vec_kind kind;

> Index: gcc/tree-vectorizer.c

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

> --- gcc/tree-vectorizer.c       2018-07-24 10:22:23.797367688 +0100

> +++ gcc/tree-vectorizer.c       2018-07-24 10:22:27.285336715 +0100

> @@ -535,6 +535,19 @@ vec_info::lookup_stmt (gimple *stmt)

>    return NULL;

>  }

>

> +/* If NAME is an SSA_NAME and its definition has an associated stmt_vec_info,

> +   return that stmt_vec_info, otherwise return null.  It is safe to call

> +   this on arbitrary operands.  */

> +

> +stmt_vec_info

> +vec_info::lookup_def (tree name)

> +{

> +  if (TREE_CODE (name) == SSA_NAME

> +      && !SSA_NAME_IS_DEFAULT_DEF (name))

> +    return lookup_stmt (SSA_NAME_DEF_STMT (name));

> +  return NULL;

> +}

> +

>  /* A helper function to free scev and LOOP niter information, as well as

>     clear loop constraint LOOP_C_FINITE.  */

>

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

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

> --- gcc/tree-vect-patterns.c    2018-07-24 10:22:23.793367723 +0100

> +++ gcc/tree-vect-patterns.c    2018-07-24 10:22:27.281336751 +0100

> @@ -227,14 +227,11 @@ vect_element_precision (unsigned int pre

>  static stmt_vec_info

>  vect_get_internal_def (vec_info *vinfo, tree op)

>  {

> -  vect_def_type dt;

> -  gimple *def_stmt;

> -  if (TREE_CODE (op) != SSA_NAME

> -      || !vect_is_simple_use (op, vinfo, &dt, &def_stmt)

> -      || dt != vect_internal_def)

> -    return NULL;

> -

> -  return vinfo_for_stmt (def_stmt);

> +  stmt_vec_info def_stmt_info = vinfo->lookup_def (op);

> +  if (def_stmt_info

> +      && STMT_VINFO_DEF_TYPE (def_stmt_info) == vect_internal_def)

> +    return def_stmt_info;

> +  return NULL;

>  }

>

>  /* Check whether NAME, an ssa-name used in USE_STMT,

> @@ -528,6 +525,7 @@ vect_widened_op_tree (stmt_vec_info stmt

>                       vect_unpromoted_value *unprom, tree *common_type)

>  {

>    /* Check for an integer operation with the right code.  */

> +  vec_info *vinfo = stmt_info->vinfo;

>    gassign *assign = dyn_cast <gassign *> (stmt_info->stmt);

>    if (!assign)

>      return 0;

> @@ -584,7 +582,7 @@ vect_widened_op_tree (stmt_vec_info stmt

>

>               /* Recursively process the definition of the operand.  */

>               stmt_vec_info def_stmt_info

> -               = vinfo_for_stmt (SSA_NAME_DEF_STMT (this_unprom->op));

> +               = vinfo->lookup_def (this_unprom->op);

>               nops = vect_widened_op_tree (def_stmt_info, code, widened_code,

>                                            shift_p, max_nops, this_unprom,

>                                            common_type);

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

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

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

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

> @@ -10092,11 +10092,11 @@ vect_is_simple_use (tree operand, vec_in

>    else

>      {

>        gimple *def_stmt = SSA_NAME_DEF_STMT (operand);

> -      if (! vect_stmt_in_region_p (vinfo, def_stmt))

> +      stmt_vec_info stmt_vinfo = vinfo->lookup_def (operand);

> +      if (!stmt_vinfo)

>         *dt = vect_external_def;

>        else

>         {

> -         stmt_vec_info stmt_vinfo = vinfo_for_stmt (def_stmt);

>           if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo))

>             {

>               def_stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo);

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

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

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

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

> @@ -1569,26 +1569,19 @@ vect_analyze_loop_operations (loop_vec_i

>                if (STMT_VINFO_RELEVANT_P (stmt_info))

>                  {

>                    tree phi_op;

> -                 gimple *op_def_stmt;

>

>                    if (gimple_phi_num_args (phi) != 1)

>                      return false;

>

>                    phi_op = PHI_ARG_DEF (phi, 0);

> -                  if (TREE_CODE (phi_op) != SSA_NAME)

> +                 stmt_vec_info op_def_info = loop_vinfo->lookup_def (phi_op);

> +                 if (!op_def_info)

>                      return false;

>

> -                  op_def_stmt = SSA_NAME_DEF_STMT (phi_op);

> -                 if (gimple_nop_p (op_def_stmt)

> -                     || !flow_bb_inside_loop_p (loop, gimple_bb (op_def_stmt))

> -                     || !vinfo_for_stmt (op_def_stmt))

> -                    return false;

> -

> -                  if (STMT_VINFO_RELEVANT (vinfo_for_stmt (op_def_stmt))

> -                        != vect_used_in_outer

> -                      && STMT_VINFO_RELEVANT (vinfo_for_stmt (op_def_stmt))

> -                           != vect_used_in_outer_by_reduction)

> -                    return false;

> +                 if (STMT_VINFO_RELEVANT (op_def_info) != vect_used_in_outer

> +                     && (STMT_VINFO_RELEVANT (op_def_info)

> +                         != vect_used_in_outer_by_reduction))

> +                   return false;

>                  }

>

>                continue;

> @@ -2504,20 +2497,19 @@ report_vect_op (dump_flags_t msg_type, g

>    dump_gimple_stmt (msg_type, TDF_SLIM, stmt, 0);

>  }

>

> -/* DEF_STMT occurs in a loop that contains a potential reduction operation.

> -   Return true if the results of DEF_STMT are something that can be

> -   accumulated by such a reduction.  */

> +/* DEF_STMT_INFO occurs in a loop that contains a potential reduction

> +   operation.  Return true if the results of DEF_STMT_INFO are something

> +   that can be accumulated by such a reduction.  */

>

>  static bool

> -vect_valid_reduction_input_p (gimple *def_stmt)

> +vect_valid_reduction_input_p (stmt_vec_info def_stmt_info)

>  {

> -  stmt_vec_info def_stmt_info = vinfo_for_stmt (def_stmt);

> -  return (is_gimple_assign (def_stmt)

> -         || is_gimple_call (def_stmt)

> +  return (is_gimple_assign (def_stmt_info->stmt)

> +         || is_gimple_call (def_stmt_info->stmt)

>           || STMT_VINFO_DEF_TYPE (def_stmt_info) == vect_induction_def

> -         || (gimple_code (def_stmt) == GIMPLE_PHI

> +         || (gimple_code (def_stmt_info->stmt) == GIMPLE_PHI

>               && STMT_VINFO_DEF_TYPE (def_stmt_info) == vect_internal_def

> -             && !is_loop_header_bb_p (gimple_bb (def_stmt))));

> +             && !is_loop_header_bb_p (gimple_bb (def_stmt_info->stmt))));

>  }

>

>  /* Detect SLP reduction of the form:

> @@ -2633,18 +2625,14 @@ vect_is_slp_reduction (loop_vec_info loo

>        if (gimple_assign_rhs2 (next_stmt) == lhs)

>         {

>           tree op = gimple_assign_rhs1 (next_stmt);

> -         gimple *def_stmt = NULL;

> -

> -          if (TREE_CODE (op) == SSA_NAME)

> -            def_stmt = SSA_NAME_DEF_STMT (op);

> +         stmt_vec_info def_stmt_info = loop_info->lookup_def (op);

>

>           /* Check that the other def is either defined in the loop

>              ("vect_internal_def"), or it's an induction (defined by a

>              loop-header phi-node).  */

> -          if (def_stmt

> -             && gimple_bb (def_stmt)

> -             && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))

> -             && vect_valid_reduction_input_p (def_stmt))

> +         if (def_stmt_info

> +             && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt_info->stmt))

> +             && vect_valid_reduction_input_p (def_stmt_info))

>             {

>               lhs = gimple_assign_lhs (next_stmt);

>               next_stmt = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));

> @@ -2656,18 +2644,14 @@ vect_is_slp_reduction (loop_vec_info loo

>        else

>         {

>            tree op = gimple_assign_rhs2 (next_stmt);

> -         gimple *def_stmt = NULL;

> -

> -          if (TREE_CODE (op) == SSA_NAME)

> -            def_stmt = SSA_NAME_DEF_STMT (op);

> +         stmt_vec_info def_stmt_info = loop_info->lookup_def (op);

>

>            /* Check that the other def is either defined in the loop

>              ("vect_internal_def"), or it's an induction (defined by a

>              loop-header phi-node).  */

> -          if (def_stmt

> -             && gimple_bb (def_stmt)

> -             && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))

> -             && vect_valid_reduction_input_p (def_stmt))

> +         if (def_stmt_info

> +             && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt_info->stmt))

> +             && vect_valid_reduction_input_p (def_stmt_info))

>             {

>               if (dump_enabled_p ())

>                 {

> @@ -2896,7 +2880,7 @@ vect_is_simple_reduction (loop_vec_info

>  {

>    struct loop *loop = (gimple_bb (phi))->loop_father;

>    struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);

> -  gimple *def_stmt, *def1 = NULL, *def2 = NULL, *phi_use_stmt = NULL;

> +  gimple *def_stmt, *phi_use_stmt = NULL;

>    enum tree_code orig_code, code;

>    tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;

>    tree type;

> @@ -3020,7 +3004,7 @@ vect_is_simple_reduction (loop_vec_info

>            return NULL;

>          }

>

> -      def1 = SSA_NAME_DEF_STMT (op1);

> +      gimple *def1 = SSA_NAME_DEF_STMT (op1);

>        if (gimple_bb (def1)

>           && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))

>            && loop->inner

> @@ -3178,14 +3162,9 @@ vect_is_simple_reduction (loop_vec_info

>       1) integer arithmetic and no trapv

>       2) floating point arithmetic, and special flags permit this optimization

>       3) nested cycle (i.e., outer loop vectorization).  */

> -  if (TREE_CODE (op1) == SSA_NAME)

> -    def1 = SSA_NAME_DEF_STMT (op1);

> -

> -  if (TREE_CODE (op2) == SSA_NAME)

> -    def2 = SSA_NAME_DEF_STMT (op2);

> -

> -  if (code != COND_EXPR

> -      && ((!def1 || gimple_nop_p (def1)) && (!def2 || gimple_nop_p (def2))))

> +  stmt_vec_info def1_info = loop_info->lookup_def (op1);

> +  stmt_vec_info def2_info = loop_info->lookup_def (op2);

> +  if (code != COND_EXPR && !def1_info && !def2_info)

>      {

>        if (dump_enabled_p ())

>         report_vect_op (MSG_NOTE, def_stmt, "reduction: no defs for operands: ");

> @@ -3196,22 +3175,22 @@ vect_is_simple_reduction (loop_vec_info

>       the other def is either defined in the loop ("vect_internal_def"),

>       or it's an induction (defined by a loop-header phi-node).  */

>

> -  if (def2 && def2 == phi

> +  if (def2_info

> +      && def2_info->stmt == phi

>        && (code == COND_EXPR

> -         || !def1 || gimple_nop_p (def1)

> -         || !flow_bb_inside_loop_p (loop, gimple_bb (def1))

> -         || vect_valid_reduction_input_p (def1)))

> +         || !def1_info

> +         || vect_valid_reduction_input_p (def1_info)))

>      {

>        if (dump_enabled_p ())

>         report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");

>        return def_stmt;

>      }

>

> -  if (def1 && def1 == phi

> +  if (def1_info

> +      && def1_info->stmt == phi

>        && (code == COND_EXPR

> -         || !def2 || gimple_nop_p (def2)

> -         || !flow_bb_inside_loop_p (loop, gimple_bb (def2))

> -         || vect_valid_reduction_input_p (def2)))

> +         || !def2_info

> +         || vect_valid_reduction_input_p (def2_info)))

>      {

>        if (! nested_in_vect_loop && orig_code != MINUS_EXPR)

>         {

> @@ -6131,9 +6110,8 @@ vectorizable_reduction (gimple *stmt, gi

>    bool nested_cycle = false, found_nested_cycle_def = false;

>    bool double_reduc = false;

>    basic_block def_bb;

> -  struct loop * def_stmt_loop, *outer_loop = NULL;

> +  struct loop * def_stmt_loop;

>    tree def_arg;

> -  gimple *def_arg_stmt;

>    auto_vec<tree> vec_oprnds0;

>    auto_vec<tree> vec_oprnds1;

>    auto_vec<tree> vec_oprnds2;

> @@ -6151,7 +6129,6 @@ vectorizable_reduction (gimple *stmt, gi

>

>    if (nested_in_vect_loop_p (loop, stmt))

>      {

> -      outer_loop = loop;

>        loop = loop->inner;

>        nested_cycle = true;

>      }

> @@ -6731,13 +6708,10 @@ vectorizable_reduction (gimple *stmt, gi

>        def_stmt_loop = def_bb->loop_father;

>        def_arg = PHI_ARG_DEF_FROM_EDGE (reduc_def_stmt,

>                                         loop_preheader_edge (def_stmt_loop));

> -      if (TREE_CODE (def_arg) == SSA_NAME

> -          && (def_arg_stmt = SSA_NAME_DEF_STMT (def_arg))

> -          && gimple_code (def_arg_stmt) == GIMPLE_PHI

> -          && flow_bb_inside_loop_p (outer_loop, gimple_bb (def_arg_stmt))

> -          && vinfo_for_stmt (def_arg_stmt)

> -          && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_arg_stmt))

> -              == vect_double_reduction_def)

> +      stmt_vec_info def_arg_stmt_info = loop_vinfo->lookup_def (def_arg);

> +      if (def_arg_stmt_info

> +         && (STMT_VINFO_DEF_TYPE (def_arg_stmt_info)

> +             == vect_double_reduction_def))

>          double_reduc = true;

>      }

>

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

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

> --- gcc/tree-vect-slp.c 2018-07-24 10:22:23.793367723 +0100

> +++ gcc/tree-vect-slp.c 2018-07-24 10:22:27.281336751 +0100

> @@ -2389,11 +2389,8 @@ vect_detect_hybrid_slp_1 (tree *tp, int

>    if (wi->is_lhs)

>      return NULL_TREE;

>

> -  stmt_vec_info def_stmt_info;

> -  if (TREE_CODE (*tp) == SSA_NAME

> -      && !SSA_NAME_IS_DEFAULT_DEF (*tp)

> -      && (def_stmt_info = loop_vinfo->lookup_stmt (SSA_NAME_DEF_STMT (*tp)))

> -      && PURE_SLP_STMT (def_stmt_info))

> +  stmt_vec_info def_stmt_info = loop_vinfo->lookup_def (*tp);

> +  if (def_stmt_info && PURE_SLP_STMT (def_stmt_info))

>      {

>        if (dump_enabled_p ())

>         {

Patch

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2018-07-24 10:22:23.797367688 +0100
+++ gcc/tree-vectorizer.h	2018-07-24 10:22:27.285336715 +0100
@@ -219,6 +219,7 @@  struct vec_info {
 
   stmt_vec_info add_stmt (gimple *);
   stmt_vec_info lookup_stmt (gimple *);
+  stmt_vec_info lookup_def (tree);
 
   /* The type of vectorization.  */
   vec_kind kind;
Index: gcc/tree-vectorizer.c
===================================================================
--- gcc/tree-vectorizer.c	2018-07-24 10:22:23.797367688 +0100
+++ gcc/tree-vectorizer.c	2018-07-24 10:22:27.285336715 +0100
@@ -535,6 +535,19 @@  vec_info::lookup_stmt (gimple *stmt)
   return NULL;
 }
 
+/* If NAME is an SSA_NAME and its definition has an associated stmt_vec_info,
+   return that stmt_vec_info, otherwise return null.  It is safe to call
+   this on arbitrary operands.  */
+
+stmt_vec_info
+vec_info::lookup_def (tree name)
+{
+  if (TREE_CODE (name) == SSA_NAME
+      && !SSA_NAME_IS_DEFAULT_DEF (name))
+    return lookup_stmt (SSA_NAME_DEF_STMT (name));
+  return NULL;
+}
+
 /* A helper function to free scev and LOOP niter information, as well as
    clear loop constraint LOOP_C_FINITE.  */
 
Index: gcc/tree-vect-patterns.c
===================================================================
--- gcc/tree-vect-patterns.c	2018-07-24 10:22:23.793367723 +0100
+++ gcc/tree-vect-patterns.c	2018-07-24 10:22:27.281336751 +0100
@@ -227,14 +227,11 @@  vect_element_precision (unsigned int pre
 static stmt_vec_info
 vect_get_internal_def (vec_info *vinfo, tree op)
 {
-  vect_def_type dt;
-  gimple *def_stmt;
-  if (TREE_CODE (op) != SSA_NAME
-      || !vect_is_simple_use (op, vinfo, &dt, &def_stmt)
-      || dt != vect_internal_def)
-    return NULL;
-
-  return vinfo_for_stmt (def_stmt);
+  stmt_vec_info def_stmt_info = vinfo->lookup_def (op);
+  if (def_stmt_info
+      && STMT_VINFO_DEF_TYPE (def_stmt_info) == vect_internal_def)
+    return def_stmt_info;
+  return NULL;
 }
 
 /* Check whether NAME, an ssa-name used in USE_STMT,
@@ -528,6 +525,7 @@  vect_widened_op_tree (stmt_vec_info stmt
 		      vect_unpromoted_value *unprom, tree *common_type)
 {
   /* Check for an integer operation with the right code.  */
+  vec_info *vinfo = stmt_info->vinfo;
   gassign *assign = dyn_cast <gassign *> (stmt_info->stmt);
   if (!assign)
     return 0;
@@ -584,7 +582,7 @@  vect_widened_op_tree (stmt_vec_info stmt
 
 	      /* Recursively process the definition of the operand.  */
 	      stmt_vec_info def_stmt_info
-		= vinfo_for_stmt (SSA_NAME_DEF_STMT (this_unprom->op));
+		= vinfo->lookup_def (this_unprom->op);
 	      nops = vect_widened_op_tree (def_stmt_info, code, widened_code,
 					   shift_p, max_nops, this_unprom,
 					   common_type);
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2018-07-24 10:22:23.797367688 +0100
+++ gcc/tree-vect-stmts.c	2018-07-24 10:22:27.281336751 +0100
@@ -10092,11 +10092,11 @@  vect_is_simple_use (tree operand, vec_in
   else
     {
       gimple *def_stmt = SSA_NAME_DEF_STMT (operand);
-      if (! vect_stmt_in_region_p (vinfo, def_stmt))
+      stmt_vec_info stmt_vinfo = vinfo->lookup_def (operand);
+      if (!stmt_vinfo)
 	*dt = vect_external_def;
       else
 	{
-	  stmt_vec_info stmt_vinfo = vinfo_for_stmt (def_stmt);
 	  if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo))
 	    {
 	      def_stmt = STMT_VINFO_RELATED_STMT (stmt_vinfo);
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2018-07-24 10:22:23.793367723 +0100
+++ gcc/tree-vect-loop.c	2018-07-24 10:22:27.277336786 +0100
@@ -1569,26 +1569,19 @@  vect_analyze_loop_operations (loop_vec_i
               if (STMT_VINFO_RELEVANT_P (stmt_info))
                 {
                   tree phi_op;
-		  gimple *op_def_stmt;
 
                   if (gimple_phi_num_args (phi) != 1)
                     return false;
 
                   phi_op = PHI_ARG_DEF (phi, 0);
-                  if (TREE_CODE (phi_op) != SSA_NAME)
+		  stmt_vec_info op_def_info = loop_vinfo->lookup_def (phi_op);
+		  if (!op_def_info)
                     return false;
 
-                  op_def_stmt = SSA_NAME_DEF_STMT (phi_op);
-		  if (gimple_nop_p (op_def_stmt)
-		      || !flow_bb_inside_loop_p (loop, gimple_bb (op_def_stmt))
-		      || !vinfo_for_stmt (op_def_stmt))
-                    return false;
-
-                  if (STMT_VINFO_RELEVANT (vinfo_for_stmt (op_def_stmt))
-                        != vect_used_in_outer
-                      && STMT_VINFO_RELEVANT (vinfo_for_stmt (op_def_stmt))
-                           != vect_used_in_outer_by_reduction)
-                    return false;
+		  if (STMT_VINFO_RELEVANT (op_def_info) != vect_used_in_outer
+		      && (STMT_VINFO_RELEVANT (op_def_info)
+			  != vect_used_in_outer_by_reduction))
+		    return false;
                 }
 
               continue;
@@ -2504,20 +2497,19 @@  report_vect_op (dump_flags_t msg_type, g
   dump_gimple_stmt (msg_type, TDF_SLIM, stmt, 0);
 }
 
-/* DEF_STMT occurs in a loop that contains a potential reduction operation.
-   Return true if the results of DEF_STMT are something that can be
-   accumulated by such a reduction.  */
+/* DEF_STMT_INFO occurs in a loop that contains a potential reduction
+   operation.  Return true if the results of DEF_STMT_INFO are something
+   that can be accumulated by such a reduction.  */
 
 static bool
-vect_valid_reduction_input_p (gimple *def_stmt)
+vect_valid_reduction_input_p (stmt_vec_info def_stmt_info)
 {
-  stmt_vec_info def_stmt_info = vinfo_for_stmt (def_stmt);
-  return (is_gimple_assign (def_stmt)
-	  || is_gimple_call (def_stmt)
+  return (is_gimple_assign (def_stmt_info->stmt)
+	  || is_gimple_call (def_stmt_info->stmt)
 	  || STMT_VINFO_DEF_TYPE (def_stmt_info) == vect_induction_def
-	  || (gimple_code (def_stmt) == GIMPLE_PHI
+	  || (gimple_code (def_stmt_info->stmt) == GIMPLE_PHI
 	      && STMT_VINFO_DEF_TYPE (def_stmt_info) == vect_internal_def
-	      && !is_loop_header_bb_p (gimple_bb (def_stmt))));
+	      && !is_loop_header_bb_p (gimple_bb (def_stmt_info->stmt))));
 }
 
 /* Detect SLP reduction of the form:
@@ -2633,18 +2625,14 @@  vect_is_slp_reduction (loop_vec_info loo
       if (gimple_assign_rhs2 (next_stmt) == lhs)
 	{
 	  tree op = gimple_assign_rhs1 (next_stmt);
-	  gimple *def_stmt = NULL;
-
-          if (TREE_CODE (op) == SSA_NAME)
-            def_stmt = SSA_NAME_DEF_STMT (op);
+	  stmt_vec_info def_stmt_info = loop_info->lookup_def (op);
 
 	  /* Check that the other def is either defined in the loop
 	     ("vect_internal_def"), or it's an induction (defined by a
 	     loop-header phi-node).  */
-          if (def_stmt
-	      && gimple_bb (def_stmt)
-	      && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
-	      && vect_valid_reduction_input_p (def_stmt))
+	  if (def_stmt_info
+	      && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt_info->stmt))
+	      && vect_valid_reduction_input_p (def_stmt_info))
 	    {
 	      lhs = gimple_assign_lhs (next_stmt);
 	      next_stmt = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
@@ -2656,18 +2644,14 @@  vect_is_slp_reduction (loop_vec_info loo
       else
 	{
           tree op = gimple_assign_rhs2 (next_stmt);
-	  gimple *def_stmt = NULL;
-
-          if (TREE_CODE (op) == SSA_NAME)
-            def_stmt = SSA_NAME_DEF_STMT (op);
+	  stmt_vec_info def_stmt_info = loop_info->lookup_def (op);
 
           /* Check that the other def is either defined in the loop
             ("vect_internal_def"), or it's an induction (defined by a
             loop-header phi-node).  */
-          if (def_stmt
-	      && gimple_bb (def_stmt)
-	      && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
-	      && vect_valid_reduction_input_p (def_stmt))
+	  if (def_stmt_info
+	      && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt_info->stmt))
+	      && vect_valid_reduction_input_p (def_stmt_info))
   	    {
 	      if (dump_enabled_p ())
 		{
@@ -2896,7 +2880,7 @@  vect_is_simple_reduction (loop_vec_info
 {
   struct loop *loop = (gimple_bb (phi))->loop_father;
   struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
-  gimple *def_stmt, *def1 = NULL, *def2 = NULL, *phi_use_stmt = NULL;
+  gimple *def_stmt, *phi_use_stmt = NULL;
   enum tree_code orig_code, code;
   tree op1, op2, op3 = NULL_TREE, op4 = NULL_TREE;
   tree type;
@@ -3020,7 +3004,7 @@  vect_is_simple_reduction (loop_vec_info
           return NULL;
         }
 
-      def1 = SSA_NAME_DEF_STMT (op1);
+      gimple *def1 = SSA_NAME_DEF_STMT (op1);
       if (gimple_bb (def1)
 	  && flow_bb_inside_loop_p (loop, gimple_bb (def_stmt))
           && loop->inner
@@ -3178,14 +3162,9 @@  vect_is_simple_reduction (loop_vec_info
      1) integer arithmetic and no trapv
      2) floating point arithmetic, and special flags permit this optimization
      3) nested cycle (i.e., outer loop vectorization).  */
-  if (TREE_CODE (op1) == SSA_NAME)
-    def1 = SSA_NAME_DEF_STMT (op1);
-
-  if (TREE_CODE (op2) == SSA_NAME)
-    def2 = SSA_NAME_DEF_STMT (op2);
-
-  if (code != COND_EXPR
-      && ((!def1 || gimple_nop_p (def1)) && (!def2 || gimple_nop_p (def2))))
+  stmt_vec_info def1_info = loop_info->lookup_def (op1);
+  stmt_vec_info def2_info = loop_info->lookup_def (op2);
+  if (code != COND_EXPR && !def1_info && !def2_info)
     {
       if (dump_enabled_p ())
 	report_vect_op (MSG_NOTE, def_stmt, "reduction: no defs for operands: ");
@@ -3196,22 +3175,22 @@  vect_is_simple_reduction (loop_vec_info
      the other def is either defined in the loop ("vect_internal_def"),
      or it's an induction (defined by a loop-header phi-node).  */
 
-  if (def2 && def2 == phi
+  if (def2_info
+      && def2_info->stmt == phi
       && (code == COND_EXPR
-	  || !def1 || gimple_nop_p (def1)
-	  || !flow_bb_inside_loop_p (loop, gimple_bb (def1))
-	  || vect_valid_reduction_input_p (def1)))
+	  || !def1_info
+	  || vect_valid_reduction_input_p (def1_info)))
     {
       if (dump_enabled_p ())
 	report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");
       return def_stmt;
     }
 
-  if (def1 && def1 == phi
+  if (def1_info
+      && def1_info->stmt == phi
       && (code == COND_EXPR
-	  || !def2 || gimple_nop_p (def2)
-	  || !flow_bb_inside_loop_p (loop, gimple_bb (def2))
-	  || vect_valid_reduction_input_p (def2)))
+	  || !def2_info
+	  || vect_valid_reduction_input_p (def2_info)))
     {
       if (! nested_in_vect_loop && orig_code != MINUS_EXPR)
 	{
@@ -6131,9 +6110,8 @@  vectorizable_reduction (gimple *stmt, gi
   bool nested_cycle = false, found_nested_cycle_def = false;
   bool double_reduc = false;
   basic_block def_bb;
-  struct loop * def_stmt_loop, *outer_loop = NULL;
+  struct loop * def_stmt_loop;
   tree def_arg;
-  gimple *def_arg_stmt;
   auto_vec<tree> vec_oprnds0;
   auto_vec<tree> vec_oprnds1;
   auto_vec<tree> vec_oprnds2;
@@ -6151,7 +6129,6 @@  vectorizable_reduction (gimple *stmt, gi
 
   if (nested_in_vect_loop_p (loop, stmt))
     {
-      outer_loop = loop;
       loop = loop->inner;
       nested_cycle = true;
     }
@@ -6731,13 +6708,10 @@  vectorizable_reduction (gimple *stmt, gi
       def_stmt_loop = def_bb->loop_father;
       def_arg = PHI_ARG_DEF_FROM_EDGE (reduc_def_stmt,
                                        loop_preheader_edge (def_stmt_loop));
-      if (TREE_CODE (def_arg) == SSA_NAME
-          && (def_arg_stmt = SSA_NAME_DEF_STMT (def_arg))
-          && gimple_code (def_arg_stmt) == GIMPLE_PHI
-          && flow_bb_inside_loop_p (outer_loop, gimple_bb (def_arg_stmt))
-          && vinfo_for_stmt (def_arg_stmt)
-          && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (def_arg_stmt))
-              == vect_double_reduction_def)
+      stmt_vec_info def_arg_stmt_info = loop_vinfo->lookup_def (def_arg);
+      if (def_arg_stmt_info
+	  && (STMT_VINFO_DEF_TYPE (def_arg_stmt_info)
+	      == vect_double_reduction_def))
         double_reduc = true;
     }
 
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c	2018-07-24 10:22:23.793367723 +0100
+++ gcc/tree-vect-slp.c	2018-07-24 10:22:27.281336751 +0100
@@ -2389,11 +2389,8 @@  vect_detect_hybrid_slp_1 (tree *tp, int
   if (wi->is_lhs)
     return NULL_TREE;
 
-  stmt_vec_info def_stmt_info;
-  if (TREE_CODE (*tp) == SSA_NAME
-      && !SSA_NAME_IS_DEFAULT_DEF (*tp)
-      && (def_stmt_info = loop_vinfo->lookup_stmt (SSA_NAME_DEF_STMT (*tp)))
-      && PURE_SLP_STMT (def_stmt_info))
+  stmt_vec_info def_stmt_info = loop_vinfo->lookup_def (*tp);
+  if (def_stmt_info && PURE_SLP_STMT (def_stmt_info))
     {
       if (dump_enabled_p ())
 	{