[29/46] Use stmt_vec_info instead of gimple stmts internally (part 2)

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

Commit Message

Richard Sandiford July 24, 2018, 10:04 a.m.
This second part handles the less mechnical cases, i.e. those that don't
just involve swapping a gimple stmt for an existing stmt_vec_info.


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

gcc/
	* tree-vect-loop.c (vect_analyze_loop_operations): Look up the
	statement before passing it to vect_analyze_stmt.
	(vect_create_epilog_for_reduction): Use a stmt_vec_info to walk
	the chain of phi vector definitions.  Track the exit phi via its
	stmt_vec_info.
	(vectorizable_reduction): Set cond_stmt_vinfo directly from the
	STMT_VINFO_REDUC_DEF.
	* tree-vect-slp.c (vect_get_place_in_interleaving_chain): Use
	stmt_vec_infos to handle the statement chains.
	(vect_get_slp_defs): Record the first statement in the node
	using a stmt_vec_info.
	* tree-vect-stmts.c (vect_mark_stmts_to_be_vectorized): Look up
	statements here and pass their stmt_vec_info down to subroutines.
	(vect_init_vector_1): Hoist call to vinfo_for_stmt and pass it
	down to vect_finish_stmt_generation.
	(vect_init_vector, vect_get_vec_defs, vect_finish_replace_stmt)
	(vect_finish_stmt_generation): Call vinfo_for_stmt and pass
	stmt_vec_infos to subroutines.
	(vect_remove_stores): Use stmt_vec_infos to handle the statement
	chains.

Comments

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

> This second part handles the less mechnical cases, i.e. those that don't

> just involve swapping a gimple stmt for an existing stmt_vec_info.


OK.

>

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

>

> gcc/

>         * tree-vect-loop.c (vect_analyze_loop_operations): Look up the

>         statement before passing it to vect_analyze_stmt.

>         (vect_create_epilog_for_reduction): Use a stmt_vec_info to walk

>         the chain of phi vector definitions.  Track the exit phi via its

>         stmt_vec_info.

>         (vectorizable_reduction): Set cond_stmt_vinfo directly from the

>         STMT_VINFO_REDUC_DEF.

>         * tree-vect-slp.c (vect_get_place_in_interleaving_chain): Use

>         stmt_vec_infos to handle the statement chains.

>         (vect_get_slp_defs): Record the first statement in the node

>         using a stmt_vec_info.

>         * tree-vect-stmts.c (vect_mark_stmts_to_be_vectorized): Look up

>         statements here and pass their stmt_vec_info down to subroutines.

>         (vect_init_vector_1): Hoist call to vinfo_for_stmt and pass it

>         down to vect_finish_stmt_generation.

>         (vect_init_vector, vect_get_vec_defs, vect_finish_replace_stmt)

>         (vect_finish_stmt_generation): Call vinfo_for_stmt and pass

>         stmt_vec_infos to subroutines.

>         (vect_remove_stores): Use stmt_vec_infos to handle the statement

>         chains.

>

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

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

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

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

> @@ -1629,8 +1629,9 @@ vect_analyze_loop_operations (loop_vec_i

>          {

>           gimple *stmt = gsi_stmt (si);

>           if (!gimple_clobber_p (stmt)

> -             && !vect_analyze_stmt (stmt, &need_to_vectorize, NULL, NULL,

> -                                    &cost_vec))

> +             && !vect_analyze_stmt (loop_vinfo->lookup_stmt (stmt),

> +                                    &need_to_vectorize,

> +                                    NULL, NULL, &cost_vec))

>             return false;

>          }

>      } /* bbs */

> @@ -4832,11 +4833,11 @@ vect_create_epilog_for_reduction (vec<tr

>        tree first_vect = PHI_RESULT (new_phis[0]);

>        gassign *new_vec_stmt = NULL;

>        vec_dest = vect_create_destination_var (scalar_dest, vectype);

> -      gimple *next_phi = new_phis[0];

> +      stmt_vec_info next_phi_info = loop_vinfo->lookup_stmt (new_phis[0]);

>        for (int k = 1; k < ncopies; ++k)

>         {

> -         next_phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (next_phi));

> -         tree second_vect = PHI_RESULT (next_phi);

> +         next_phi_info = STMT_VINFO_RELATED_STMT (next_phi_info);

> +         tree second_vect = PHI_RESULT (next_phi_info->stmt);

>            tree tem = make_ssa_name (vec_dest, new_vec_stmt);

>            new_vec_stmt = gimple_build_assign (tem, code,

>                                               first_vect, second_vect);

> @@ -5573,11 +5574,12 @@ vect_create_epilog_for_reduction (vec<tr

>    else

>      ratio = 1;

>

> +  stmt_vec_info epilog_stmt_info = NULL;

>    for (k = 0; k < group_size; k++)

>      {

>        if (k % ratio == 0)

>          {

> -          epilog_stmt = new_phis[k / ratio];

> +         epilog_stmt_info = loop_vinfo->lookup_stmt (new_phis[k / ratio]);

>           reduction_phi_info = reduction_phis[k / ratio];

>           if (double_reduc)

>             inner_phi = inner_phis[k / ratio];

> @@ -5623,8 +5625,7 @@ vect_create_epilog_for_reduction (vec<tr

>               if (double_reduc)

>                 STMT_VINFO_VEC_STMT (exit_phi_vinfo) = inner_phi;

>               else

> -               STMT_VINFO_VEC_STMT (exit_phi_vinfo)

> -                 = vinfo_for_stmt (epilog_stmt);

> +               STMT_VINFO_VEC_STMT (exit_phi_vinfo) = epilog_stmt_info;

>                if (!double_reduc

>                    || STMT_VINFO_DEF_TYPE (exit_phi_vinfo)

>                        != vect_double_reduction_def)

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

>    optab optab;

>    tree new_temp = NULL_TREE;

>    enum vect_def_type dt, cond_reduc_dt = vect_unknown_def_type;

> -  gimple *cond_reduc_def_stmt = NULL;

> +  stmt_vec_info cond_stmt_vinfo = NULL;

>    enum tree_code cond_reduc_op_code = ERROR_MARK;

>    tree scalar_type;

>    bool is_simple_use;

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

>               && is_nonwrapping_integer_induction (def_stmt_info, loop))

>             {

>               cond_reduc_dt = dt;

> -             cond_reduc_def_stmt = def_stmt_info;

> +             cond_stmt_vinfo = def_stmt_info;

>             }

>         }

>      }

> @@ -6454,7 +6455,6 @@ vectorizable_reduction (gimple *stmt, gi

>         }

>        else if (cond_reduc_dt == vect_induction_def)

>         {

> -         stmt_vec_info cond_stmt_vinfo = vinfo_for_stmt (cond_reduc_def_stmt);

>           tree base

>             = STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED (cond_stmt_vinfo);

>           tree step = STMT_VINFO_LOOP_PHI_EVOLUTION_PART (cond_stmt_vinfo);

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

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

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

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

> @@ -201,21 +201,23 @@ vect_free_oprnd_info (vec<slp_oprnd_info

>  int

>  vect_get_place_in_interleaving_chain (gimple *stmt, gimple *first_stmt)

>  {

> -  gimple *next_stmt = first_stmt;

> +  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);

> +  stmt_vec_info first_stmt_info = vinfo_for_stmt (first_stmt);

> +  stmt_vec_info next_stmt_info = first_stmt_info;

>    int result = 0;

>

> -  if (first_stmt != DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)))

> +  if (first_stmt_info != DR_GROUP_FIRST_ELEMENT (stmt_info))

>      return -1;

>

>    do

>      {

> -      if (next_stmt == stmt)

> +      if (next_stmt_info == stmt_info)

>         return result;

> -      next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));

> -      if (next_stmt)

> -       result += DR_GROUP_GAP (vinfo_for_stmt (next_stmt));

> +      next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

> +      if (next_stmt_info)

> +       result += DR_GROUP_GAP (next_stmt_info);

>      }

> -  while (next_stmt);

> +  while (next_stmt_info);

>

>    return -1;

>  }

> @@ -3577,7 +3579,6 @@ vect_get_slp_vect_defs (slp_tree slp_nod

>  vect_get_slp_defs (vec<tree> ops, slp_tree slp_node,

>                    vec<vec<tree> > *vec_oprnds)

>  {

> -  gimple *first_stmt;

>    int number_of_vects = 0, i;

>    unsigned int child_index = 0;

>    HOST_WIDE_INT lhs_size_unit, rhs_size_unit;

> @@ -3586,7 +3587,7 @@ vect_get_slp_defs (vec<tree> ops, slp_tr

>    tree oprnd;

>    bool vectorized_defs;

>

> -  first_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[0];

> +  stmt_vec_info first_stmt_info = SLP_TREE_SCALAR_STMTS (slp_node)[0];

>    FOR_EACH_VEC_ELT (ops, i, oprnd)

>      {

>        /* For each operand we check if it has vectorized definitions in a child

> @@ -3637,8 +3638,8 @@ vect_get_slp_defs (vec<tree> ops, slp_tr

>                   vect_schedule_slp_instance (), fix it by replacing LHS with

>                   RHS, if necessary.  See vect_get_smallest_scalar_type () for

>                   details.  */

> -              vect_get_smallest_scalar_type (first_stmt, &lhs_size_unit,

> -                                             &rhs_size_unit);

> +             vect_get_smallest_scalar_type (first_stmt_info, &lhs_size_unit,

> +                                            &rhs_size_unit);

>                if (rhs_size_unit != lhs_size_unit)

>                  {

>                    number_of_vects *= rhs_size_unit;

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

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

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

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

> @@ -622,7 +622,6 @@ vect_mark_stmts_to_be_vectorized (loop_v

>    unsigned int i;

>    stmt_vec_info stmt_vinfo;

>    basic_block bb;

> -  gimple *phi;

>    bool live_p;

>    enum vect_relevant relevant;

>

> @@ -636,27 +635,27 @@ vect_mark_stmts_to_be_vectorized (loop_v

>        bb = bbs[i];

>        for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))

>         {

> -         phi = gsi_stmt (si);

> +         stmt_vec_info phi_info = loop_vinfo->lookup_stmt (gsi_stmt (si));

>           if (dump_enabled_p ())

>             {

>               dump_printf_loc (MSG_NOTE, vect_location, "init: phi relevant? ");

> -             dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);

> +             dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi_info->stmt, 0);

>             }

>

> -         if (vect_stmt_relevant_p (phi, loop_vinfo, &relevant, &live_p))

> -           vect_mark_relevant (&worklist, phi, relevant, live_p);

> +         if (vect_stmt_relevant_p (phi_info, loop_vinfo, &relevant, &live_p))

> +           vect_mark_relevant (&worklist, phi_info, relevant, live_p);

>         }

>        for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))

>         {

> -         stmt = gsi_stmt (si);

> +         stmt_vec_info stmt_info = loop_vinfo->lookup_stmt (gsi_stmt (si));

>           if (dump_enabled_p ())

>             {

>               dump_printf_loc (MSG_NOTE, vect_location, "init: stmt relevant? ");

> -             dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);

> +             dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt_info->stmt, 0);

>             }

>

> -         if (vect_stmt_relevant_p (stmt, loop_vinfo, &relevant, &live_p))

> -           vect_mark_relevant (&worklist, stmt, relevant, live_p);

> +         if (vect_stmt_relevant_p (stmt_info, loop_vinfo, &relevant, &live_p))

> +           vect_mark_relevant (&worklist, stmt_info, relevant, live_p);

>         }

>      }

>

> @@ -1350,11 +1349,11 @@ vect_get_load_cost (stmt_vec_info stmt_i

>  static void

>  vect_init_vector_1 (gimple *stmt, gimple *new_stmt, gimple_stmt_iterator *gsi)

>  {

> +  stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);

>    if (gsi)

> -    vect_finish_stmt_generation (stmt, new_stmt, gsi);

> +    vect_finish_stmt_generation (stmt_vinfo, new_stmt, gsi);

>    else

>      {

> -      stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);

>        loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);

>

>        if (loop_vinfo)

> @@ -1404,6 +1403,7 @@ vect_init_vector_1 (gimple *stmt, gimple

>  tree

>  vect_init_vector (gimple *stmt, tree val, tree type, gimple_stmt_iterator *gsi)

>  {

> +  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);

>    gimple *init_stmt;

>    tree new_temp;

>

> @@ -1427,7 +1427,7 @@ vect_init_vector (gimple *stmt, tree val

>                   new_temp = make_ssa_name (TREE_TYPE (type));

>                   init_stmt = gimple_build_assign (new_temp, COND_EXPR,

>                                                    val, true_val, false_val);

> -                 vect_init_vector_1 (stmt, init_stmt, gsi);

> +                 vect_init_vector_1 (stmt_info, init_stmt, gsi);

>                   val = new_temp;

>                 }

>             }

> @@ -1443,7 +1443,7 @@ vect_init_vector (gimple *stmt, tree val

>                                                               val));

>               else

>                 init_stmt = gimple_build_assign (new_temp, NOP_EXPR, val);

> -             vect_init_vector_1 (stmt, init_stmt, gsi);

> +             vect_init_vector_1 (stmt_info, init_stmt, gsi);

>               val = new_temp;

>             }

>         }

> @@ -1452,7 +1452,7 @@ vect_init_vector (gimple *stmt, tree val

>

>    new_temp = vect_get_new_ssa_name (type, vect_simple_var, "cst_");

>    init_stmt = gimple_build_assign  (new_temp, val);

> -  vect_init_vector_1 (stmt, init_stmt, gsi);

> +  vect_init_vector_1 (stmt_info, init_stmt, gsi);

>    return new_temp;

>  }

>

> @@ -1690,6 +1690,7 @@ vect_get_vec_defs (tree op0, tree op1, g

>                    vec<tree> *vec_oprnds1,

>                    slp_tree slp_node)

>  {

> +  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);

>    if (slp_node)

>      {

>        int nops = (op1 == NULL_TREE) ? 1 : 2;

> @@ -1711,13 +1712,13 @@ vect_get_vec_defs (tree op0, tree op1, g

>        tree vec_oprnd;

>

>        vec_oprnds0->create (1);

> -      vec_oprnd = vect_get_vec_def_for_operand (op0, stmt);

> +      vec_oprnd = vect_get_vec_def_for_operand (op0, stmt_info);

>        vec_oprnds0->quick_push (vec_oprnd);

>

>        if (op1)

>         {

>           vec_oprnds1->create (1);

> -         vec_oprnd = vect_get_vec_def_for_operand (op1, stmt);

> +         vec_oprnd = vect_get_vec_def_for_operand (op1, stmt_info);

>           vec_oprnds1->quick_push (vec_oprnd);

>         }

>      }

> @@ -1760,12 +1761,13 @@ vect_finish_stmt_generation_1 (gimple *s

>  stmt_vec_info

>  vect_finish_replace_stmt (gimple *stmt, gimple *vec_stmt)

>  {

> -  gcc_assert (gimple_get_lhs (stmt) == gimple_get_lhs (vec_stmt));

> +  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);

> +  gcc_assert (gimple_get_lhs (stmt_info->stmt) == gimple_get_lhs (vec_stmt));

>

> -  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);

> +  gimple_stmt_iterator gsi = gsi_for_stmt (stmt_info->stmt);

>    gsi_replace (&gsi, vec_stmt, false);

>

> -  return vect_finish_stmt_generation_1 (stmt, vec_stmt);

> +  return vect_finish_stmt_generation_1 (stmt_info, vec_stmt);

>  }

>

>  /* Add VEC_STMT to the vectorized implementation of STMT and insert it

> @@ -1775,7 +1777,8 @@ vect_finish_replace_stmt (gimple *stmt,

>  vect_finish_stmt_generation (gimple *stmt, gimple *vec_stmt,

>                              gimple_stmt_iterator *gsi)

>  {

> -  gcc_assert (gimple_code (stmt) != GIMPLE_LABEL);

> +  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);

> +  gcc_assert (gimple_code (stmt_info->stmt) != GIMPLE_LABEL);

>

>    if (!gsi_end_p (*gsi)

>        && gimple_has_mem_ops (vec_stmt))

> @@ -1804,7 +1807,7 @@ vect_finish_stmt_generation (gimple *stm

>         }

>      }

>    gsi_insert_before (gsi, vec_stmt, GSI_SAME_STMT);

> -  return vect_finish_stmt_generation_1 (stmt, vec_stmt);

> +  return vect_finish_stmt_generation_1 (stmt_info, vec_stmt);

>  }

>

>  /* We want to vectorize a call to combined function CFN with function

> @@ -9856,23 +9859,21 @@ vect_transform_stmt (gimple *stmt, gimpl

>  void

>  vect_remove_stores (gimple *first_stmt)

>  {

> -  gimple *next = first_stmt;

> +  stmt_vec_info next_stmt_info = vinfo_for_stmt (first_stmt);

>    gimple_stmt_iterator next_si;

>

> -  while (next)

> +  while (next_stmt_info)

>      {

> -      stmt_vec_info stmt_info = vinfo_for_stmt (next);

> -

> -      stmt_vec_info tmp = DR_GROUP_NEXT_ELEMENT (stmt_info);

> -      if (is_pattern_stmt_p (stmt_info))

> -       next = STMT_VINFO_RELATED_STMT (stmt_info);

> +      stmt_vec_info tmp = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

> +      if (is_pattern_stmt_p (next_stmt_info))

> +       next_stmt_info = STMT_VINFO_RELATED_STMT (next_stmt_info);

>        /* Free the attached stmt_vec_info and remove the stmt.  */

> -      next_si = gsi_for_stmt (next);

> -      unlink_stmt_vdef (next);

> +      next_si = gsi_for_stmt (next_stmt_info->stmt);

> +      unlink_stmt_vdef (next_stmt_info->stmt);

>        gsi_remove (&next_si, true);

> -      release_defs (next);

> -      free_stmt_vec_info (next);

> -      next = tmp;

> +      release_defs (next_stmt_info->stmt);

> +      free_stmt_vec_info (next_stmt_info);

> +      next_stmt_info = tmp;

>      }

>  }

>

Patch

Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2018-07-24 10:23:35.376732054 +0100
+++ gcc/tree-vect-loop.c	2018-07-24 10:23:38.964700191 +0100
@@ -1629,8 +1629,9 @@  vect_analyze_loop_operations (loop_vec_i
         {
 	  gimple *stmt = gsi_stmt (si);
 	  if (!gimple_clobber_p (stmt)
-	      && !vect_analyze_stmt (stmt, &need_to_vectorize, NULL, NULL,
-				     &cost_vec))
+	      && !vect_analyze_stmt (loop_vinfo->lookup_stmt (stmt),
+				     &need_to_vectorize,
+				     NULL, NULL, &cost_vec))
 	    return false;
         }
     } /* bbs */
@@ -4832,11 +4833,11 @@  vect_create_epilog_for_reduction (vec<tr
       tree first_vect = PHI_RESULT (new_phis[0]);
       gassign *new_vec_stmt = NULL;
       vec_dest = vect_create_destination_var (scalar_dest, vectype);
-      gimple *next_phi = new_phis[0];
+      stmt_vec_info next_phi_info = loop_vinfo->lookup_stmt (new_phis[0]);
       for (int k = 1; k < ncopies; ++k)
 	{
-	  next_phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (next_phi));
-	  tree second_vect = PHI_RESULT (next_phi);
+	  next_phi_info = STMT_VINFO_RELATED_STMT (next_phi_info);
+	  tree second_vect = PHI_RESULT (next_phi_info->stmt);
           tree tem = make_ssa_name (vec_dest, new_vec_stmt);
           new_vec_stmt = gimple_build_assign (tem, code,
 					      first_vect, second_vect);
@@ -5573,11 +5574,12 @@  vect_create_epilog_for_reduction (vec<tr
   else
     ratio = 1;
 
+  stmt_vec_info epilog_stmt_info = NULL;
   for (k = 0; k < group_size; k++)
     {
       if (k % ratio == 0)
         {
-          epilog_stmt = new_phis[k / ratio];
+	  epilog_stmt_info = loop_vinfo->lookup_stmt (new_phis[k / ratio]);
 	  reduction_phi_info = reduction_phis[k / ratio];
 	  if (double_reduc)
 	    inner_phi = inner_phis[k / ratio];
@@ -5623,8 +5625,7 @@  vect_create_epilog_for_reduction (vec<tr
 	      if (double_reduc)
 		STMT_VINFO_VEC_STMT (exit_phi_vinfo) = inner_phi;
 	      else
-		STMT_VINFO_VEC_STMT (exit_phi_vinfo)
-		  = vinfo_for_stmt (epilog_stmt);
+		STMT_VINFO_VEC_STMT (exit_phi_vinfo) = epilog_stmt_info;
               if (!double_reduc
                   || STMT_VINFO_DEF_TYPE (exit_phi_vinfo)
                       != vect_double_reduction_def)
@@ -6070,7 +6071,7 @@  vectorizable_reduction (gimple *stmt, gi
   optab optab;
   tree new_temp = NULL_TREE;
   enum vect_def_type dt, cond_reduc_dt = vect_unknown_def_type;
-  gimple *cond_reduc_def_stmt = NULL;
+  stmt_vec_info cond_stmt_vinfo = NULL;
   enum tree_code cond_reduc_op_code = ERROR_MARK;
   tree scalar_type;
   bool is_simple_use;
@@ -6348,7 +6349,7 @@  vectorizable_reduction (gimple *stmt, gi
 	      && is_nonwrapping_integer_induction (def_stmt_info, loop))
 	    {
 	      cond_reduc_dt = dt;
-	      cond_reduc_def_stmt = def_stmt_info;
+	      cond_stmt_vinfo = def_stmt_info;
 	    }
 	}
     }
@@ -6454,7 +6455,6 @@  vectorizable_reduction (gimple *stmt, gi
 	}
       else if (cond_reduc_dt == vect_induction_def)
 	{
-	  stmt_vec_info cond_stmt_vinfo = vinfo_for_stmt (cond_reduc_def_stmt);
 	  tree base
 	    = STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED (cond_stmt_vinfo);
 	  tree step = STMT_VINFO_LOOP_PHI_EVOLUTION_PART (cond_stmt_vinfo);
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c	2018-07-24 10:23:35.380732018 +0100
+++ gcc/tree-vect-slp.c	2018-07-24 10:23:38.964700191 +0100
@@ -201,21 +201,23 @@  vect_free_oprnd_info (vec<slp_oprnd_info
 int
 vect_get_place_in_interleaving_chain (gimple *stmt, gimple *first_stmt)
 {
-  gimple *next_stmt = first_stmt;
+  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
+  stmt_vec_info first_stmt_info = vinfo_for_stmt (first_stmt);
+  stmt_vec_info next_stmt_info = first_stmt_info;
   int result = 0;
 
-  if (first_stmt != DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)))
+  if (first_stmt_info != DR_GROUP_FIRST_ELEMENT (stmt_info))
     return -1;
 
   do
     {
-      if (next_stmt == stmt)
+      if (next_stmt_info == stmt_info)
 	return result;
-      next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
-      if (next_stmt)
-	result += DR_GROUP_GAP (vinfo_for_stmt (next_stmt));
+      next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
+      if (next_stmt_info)
+	result += DR_GROUP_GAP (next_stmt_info);
     }
-  while (next_stmt);
+  while (next_stmt_info);
 
   return -1;
 }
@@ -3577,7 +3579,6 @@  vect_get_slp_vect_defs (slp_tree slp_nod
 vect_get_slp_defs (vec<tree> ops, slp_tree slp_node,
 		   vec<vec<tree> > *vec_oprnds)
 {
-  gimple *first_stmt;
   int number_of_vects = 0, i;
   unsigned int child_index = 0;
   HOST_WIDE_INT lhs_size_unit, rhs_size_unit;
@@ -3586,7 +3587,7 @@  vect_get_slp_defs (vec<tree> ops, slp_tr
   tree oprnd;
   bool vectorized_defs;
 
-  first_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[0];
+  stmt_vec_info first_stmt_info = SLP_TREE_SCALAR_STMTS (slp_node)[0];
   FOR_EACH_VEC_ELT (ops, i, oprnd)
     {
       /* For each operand we check if it has vectorized definitions in a child
@@ -3637,8 +3638,8 @@  vect_get_slp_defs (vec<tree> ops, slp_tr
                  vect_schedule_slp_instance (), fix it by replacing LHS with
                  RHS, if necessary.  See vect_get_smallest_scalar_type () for
                  details.  */
-              vect_get_smallest_scalar_type (first_stmt, &lhs_size_unit,
-                                             &rhs_size_unit);
+	      vect_get_smallest_scalar_type (first_stmt_info, &lhs_size_unit,
+					     &rhs_size_unit);
               if (rhs_size_unit != lhs_size_unit)
                 {
                   number_of_vects *= rhs_size_unit;
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2018-07-24 10:23:35.384731983 +0100
+++ gcc/tree-vect-stmts.c	2018-07-24 10:23:38.968700155 +0100
@@ -622,7 +622,6 @@  vect_mark_stmts_to_be_vectorized (loop_v
   unsigned int i;
   stmt_vec_info stmt_vinfo;
   basic_block bb;
-  gimple *phi;
   bool live_p;
   enum vect_relevant relevant;
 
@@ -636,27 +635,27 @@  vect_mark_stmts_to_be_vectorized (loop_v
       bb = bbs[i];
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  phi = gsi_stmt (si);
+	  stmt_vec_info phi_info = loop_vinfo->lookup_stmt (gsi_stmt (si));
 	  if (dump_enabled_p ())
 	    {
 	      dump_printf_loc (MSG_NOTE, vect_location, "init: phi relevant? ");
-	      dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
+	      dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi_info->stmt, 0);
 	    }
 
-	  if (vect_stmt_relevant_p (phi, loop_vinfo, &relevant, &live_p))
-	    vect_mark_relevant (&worklist, phi, relevant, live_p);
+	  if (vect_stmt_relevant_p (phi_info, loop_vinfo, &relevant, &live_p))
+	    vect_mark_relevant (&worklist, phi_info, relevant, live_p);
 	}
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	{
-	  stmt = gsi_stmt (si);
+	  stmt_vec_info stmt_info = loop_vinfo->lookup_stmt (gsi_stmt (si));
 	  if (dump_enabled_p ())
 	    {
 	      dump_printf_loc (MSG_NOTE, vect_location, "init: stmt relevant? ");
-	      dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
+	      dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt_info->stmt, 0);
 	    }
 
-	  if (vect_stmt_relevant_p (stmt, loop_vinfo, &relevant, &live_p))
-	    vect_mark_relevant (&worklist, stmt, relevant, live_p);
+	  if (vect_stmt_relevant_p (stmt_info, loop_vinfo, &relevant, &live_p))
+	    vect_mark_relevant (&worklist, stmt_info, relevant, live_p);
 	}
     }
 
@@ -1350,11 +1349,11 @@  vect_get_load_cost (stmt_vec_info stmt_i
 static void
 vect_init_vector_1 (gimple *stmt, gimple *new_stmt, gimple_stmt_iterator *gsi)
 {
+  stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
   if (gsi)
-    vect_finish_stmt_generation (stmt, new_stmt, gsi);
+    vect_finish_stmt_generation (stmt_vinfo, new_stmt, gsi);
   else
     {
-      stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt);
       loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
 
       if (loop_vinfo)
@@ -1404,6 +1403,7 @@  vect_init_vector_1 (gimple *stmt, gimple
 tree
 vect_init_vector (gimple *stmt, tree val, tree type, gimple_stmt_iterator *gsi)
 {
+  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   gimple *init_stmt;
   tree new_temp;
 
@@ -1427,7 +1427,7 @@  vect_init_vector (gimple *stmt, tree val
 		  new_temp = make_ssa_name (TREE_TYPE (type));
 		  init_stmt = gimple_build_assign (new_temp, COND_EXPR,
 						   val, true_val, false_val);
-		  vect_init_vector_1 (stmt, init_stmt, gsi);
+		  vect_init_vector_1 (stmt_info, init_stmt, gsi);
 		  val = new_temp;
 		}
 	    }
@@ -1443,7 +1443,7 @@  vect_init_vector (gimple *stmt, tree val
 							      val));
 	      else
 		init_stmt = gimple_build_assign (new_temp, NOP_EXPR, val);
-	      vect_init_vector_1 (stmt, init_stmt, gsi);
+	      vect_init_vector_1 (stmt_info, init_stmt, gsi);
 	      val = new_temp;
 	    }
 	}
@@ -1452,7 +1452,7 @@  vect_init_vector (gimple *stmt, tree val
 
   new_temp = vect_get_new_ssa_name (type, vect_simple_var, "cst_");
   init_stmt = gimple_build_assign  (new_temp, val);
-  vect_init_vector_1 (stmt, init_stmt, gsi);
+  vect_init_vector_1 (stmt_info, init_stmt, gsi);
   return new_temp;
 }
 
@@ -1690,6 +1690,7 @@  vect_get_vec_defs (tree op0, tree op1, g
 		   vec<tree> *vec_oprnds1,
 		   slp_tree slp_node)
 {
+  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   if (slp_node)
     {
       int nops = (op1 == NULL_TREE) ? 1 : 2;
@@ -1711,13 +1712,13 @@  vect_get_vec_defs (tree op0, tree op1, g
       tree vec_oprnd;
 
       vec_oprnds0->create (1);
-      vec_oprnd = vect_get_vec_def_for_operand (op0, stmt);
+      vec_oprnd = vect_get_vec_def_for_operand (op0, stmt_info);
       vec_oprnds0->quick_push (vec_oprnd);
 
       if (op1)
 	{
 	  vec_oprnds1->create (1);
-	  vec_oprnd = vect_get_vec_def_for_operand (op1, stmt);
+	  vec_oprnd = vect_get_vec_def_for_operand (op1, stmt_info);
 	  vec_oprnds1->quick_push (vec_oprnd);
 	}
     }
@@ -1760,12 +1761,13 @@  vect_finish_stmt_generation_1 (gimple *s
 stmt_vec_info
 vect_finish_replace_stmt (gimple *stmt, gimple *vec_stmt)
 {
-  gcc_assert (gimple_get_lhs (stmt) == gimple_get_lhs (vec_stmt));
+  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
+  gcc_assert (gimple_get_lhs (stmt_info->stmt) == gimple_get_lhs (vec_stmt));
 
-  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+  gimple_stmt_iterator gsi = gsi_for_stmt (stmt_info->stmt);
   gsi_replace (&gsi, vec_stmt, false);
 
-  return vect_finish_stmt_generation_1 (stmt, vec_stmt);
+  return vect_finish_stmt_generation_1 (stmt_info, vec_stmt);
 }
 
 /* Add VEC_STMT to the vectorized implementation of STMT and insert it
@@ -1775,7 +1777,8 @@  vect_finish_replace_stmt (gimple *stmt,
 vect_finish_stmt_generation (gimple *stmt, gimple *vec_stmt,
 			     gimple_stmt_iterator *gsi)
 {
-  gcc_assert (gimple_code (stmt) != GIMPLE_LABEL);
+  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
+  gcc_assert (gimple_code (stmt_info->stmt) != GIMPLE_LABEL);
 
   if (!gsi_end_p (*gsi)
       && gimple_has_mem_ops (vec_stmt))
@@ -1804,7 +1807,7 @@  vect_finish_stmt_generation (gimple *stm
 	}
     }
   gsi_insert_before (gsi, vec_stmt, GSI_SAME_STMT);
-  return vect_finish_stmt_generation_1 (stmt, vec_stmt);
+  return vect_finish_stmt_generation_1 (stmt_info, vec_stmt);
 }
 
 /* We want to vectorize a call to combined function CFN with function
@@ -9856,23 +9859,21 @@  vect_transform_stmt (gimple *stmt, gimpl
 void
 vect_remove_stores (gimple *first_stmt)
 {
-  gimple *next = first_stmt;
+  stmt_vec_info next_stmt_info = vinfo_for_stmt (first_stmt);
   gimple_stmt_iterator next_si;
 
-  while (next)
+  while (next_stmt_info)
     {
-      stmt_vec_info stmt_info = vinfo_for_stmt (next);
-
-      stmt_vec_info tmp = DR_GROUP_NEXT_ELEMENT (stmt_info);
-      if (is_pattern_stmt_p (stmt_info))
-	next = STMT_VINFO_RELATED_STMT (stmt_info);
+      stmt_vec_info tmp = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
+      if (is_pattern_stmt_p (next_stmt_info))
+	next_stmt_info = STMT_VINFO_RELATED_STMT (next_stmt_info);
       /* Free the attached stmt_vec_info and remove the stmt.  */
-      next_si = gsi_for_stmt (next);
-      unlink_stmt_vdef (next);
+      next_si = gsi_for_stmt (next_stmt_info->stmt);
+      unlink_stmt_vdef (next_stmt_info->stmt);
       gsi_remove (&next_si, true);
-      release_defs (next);
-      free_stmt_vec_info (next);
-      next = tmp;
+      release_defs (next_stmt_info->stmt);
+      free_stmt_vec_info (next_stmt_info);
+      next_stmt_info = tmp;
     }
 }