[20/46] Make *FIRST_ELEMENT and *NEXT_ELEMENT stmt_vec_infos

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

Commit Message

Richard Sandiford July 24, 2018, 10 a.m.
This patch changes {REDUC,DR}_GROUP_{FIRST,NEXT} element from a
gimple stmt to stmt_vec_info.


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

gcc/
	* tree-vectorizer.h (_stmt_vec_info::first_element): Change from
	a gimple stmt to a stmt_vec_info.
	(_stmt_vec_info::next_element): Likewise.
	* tree-vect-data-refs.c (vect_update_misalignment_for_peel)
	(vect_slp_analyze_and_verify_node_alignment)
	(vect_analyze_group_access_1, vect_analyze_group_access)
	(vect_small_gap_p, vect_prune_runtime_alias_test_list)
	(vect_create_data_ref_ptr, vect_record_grouped_load_vectors)
	(vect_supportable_dr_alignment): Update accordingly.
	* tree-vect-loop.c (vect_fixup_reduc_chain): Likewise.
	(vect_fixup_scalar_cycles_with_patterns, vect_is_slp_reduction)
	(vect_is_simple_reduction, vectorizable_reduction): Likewise.
	* tree-vect-patterns.c (vect_reassociating_reduction_p): Likewise.
	* tree-vect-slp.c (vect_build_slp_tree_1)
	(vect_attempt_slp_rearrange_stmts, vect_supported_load_permutation_p)
	(vect_split_slp_store_group, vect_analyze_slp_instance)
	(vect_analyze_slp, vect_transform_slp_perm_load): Likewise.
	* tree-vect-stmts.c (vect_model_store_cost, vect_model_load_cost)
	(get_group_load_store_type, get_load_store_type)
	(get_group_alias_ptr_type, vectorizable_store, vectorizable_load)
	(vect_transform_stmt, vect_remove_stores): Likewise.

Comments

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

> This patch changes {REDUC,DR}_GROUP_{FIRST,NEXT} element from a

> gimple stmt to stmt_vec_info.


OK.

>

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

>

> gcc/

>         * tree-vectorizer.h (_stmt_vec_info::first_element): Change from

>         a gimple stmt to a stmt_vec_info.

>         (_stmt_vec_info::next_element): Likewise.

>         * tree-vect-data-refs.c (vect_update_misalignment_for_peel)

>         (vect_slp_analyze_and_verify_node_alignment)

>         (vect_analyze_group_access_1, vect_analyze_group_access)

>         (vect_small_gap_p, vect_prune_runtime_alias_test_list)

>         (vect_create_data_ref_ptr, vect_record_grouped_load_vectors)

>         (vect_supportable_dr_alignment): Update accordingly.

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

>         (vect_fixup_scalar_cycles_with_patterns, vect_is_slp_reduction)

>         (vect_is_simple_reduction, vectorizable_reduction): Likewise.

>         * tree-vect-patterns.c (vect_reassociating_reduction_p): Likewise.

>         * tree-vect-slp.c (vect_build_slp_tree_1)

>         (vect_attempt_slp_rearrange_stmts, vect_supported_load_permutation_p)

>         (vect_split_slp_store_group, vect_analyze_slp_instance)

>         (vect_analyze_slp, vect_transform_slp_perm_load): Likewise.

>         * tree-vect-stmts.c (vect_model_store_cost, vect_model_load_cost)

>         (get_group_load_store_type, get_load_store_type)

>         (get_group_alias_ptr_type, vectorizable_store, vectorizable_load)

>         (vect_transform_stmt, vect_remove_stores): Likewise.

>

> Index: gcc/tree-vectorizer.h

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

> --- gcc/tree-vectorizer.h       2018-07-24 10:23:04.033010396 +0100

> +++ gcc/tree-vectorizer.h       2018-07-24 10:23:08.536970400 +0100

> @@ -871,9 +871,9 @@ struct _stmt_vec_info {

>

>    /* Interleaving and reduction chains info.  */

>    /* First element in the group.  */

> -  gimple *first_element;

> +  stmt_vec_info first_element;

>    /* Pointer to the next element in the group.  */

> -  gimple *next_element;

> +  stmt_vec_info next_element;

>    /* For data-refs, in case that two or more stmts share data-ref, this is the

>       pointer to the previously detected stmt with the same dr.  */

>    gimple *same_dr_stmt;

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

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

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

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

> @@ -1077,7 +1077,7 @@ vect_update_misalignment_for_peel (struc

>   /* For interleaved data accesses the step in the loop must be multiplied by

>       the size of the interleaving group.  */

>    if (STMT_VINFO_GROUPED_ACCESS (stmt_info))

> -    dr_size *= DR_GROUP_SIZE (vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info)));

> +    dr_size *= DR_GROUP_SIZE (DR_GROUP_FIRST_ELEMENT (stmt_info));

>    if (STMT_VINFO_GROUPED_ACCESS (peel_stmt_info))

>      dr_peel_size *= DR_GROUP_SIZE (peel_stmt_info);

>

> @@ -2370,12 +2370,11 @@ vect_slp_analyze_and_verify_node_alignme

>       the node is permuted in which case we start from the first

>       element in the group.  */

>    stmt_vec_info first_stmt_info = SLP_TREE_SCALAR_STMTS (node)[0];

> -  gimple *first_stmt = first_stmt_info->stmt;

>    data_reference_p first_dr = STMT_VINFO_DATA_REF (first_stmt_info);

>    if (SLP_TREE_LOAD_PERMUTATION (node).exists ())

> -    first_stmt = DR_GROUP_FIRST_ELEMENT (first_stmt_info);

> +    first_stmt_info = DR_GROUP_FIRST_ELEMENT (first_stmt_info);

>

> -  data_reference_p dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));

> +  data_reference_p dr = STMT_VINFO_DATA_REF (first_stmt_info);

>    vect_compute_data_ref_alignment (dr);

>    /* For creating the data-ref pointer we need alignment of the

>       first element anyway.  */

> @@ -2520,11 +2519,11 @@ vect_analyze_group_access_1 (struct data

>    if (DR_GROUP_FIRST_ELEMENT (stmt_info) == stmt_info)

>      {

>        /* First stmt in the interleaving chain. Check the chain.  */

> -      gimple *next = DR_GROUP_NEXT_ELEMENT (stmt_info);

> +      stmt_vec_info next = DR_GROUP_NEXT_ELEMENT (stmt_info);

>        struct data_reference *data_ref = dr;

>        unsigned int count = 1;

>        tree prev_init = DR_INIT (data_ref);

> -      gimple *prev = stmt_info;

> +      stmt_vec_info prev = stmt_info;

>        HOST_WIDE_INT diff, gaps = 0;

>

>        /* By construction, all group members have INTEGER_CST DR_INITs.  */

> @@ -2535,8 +2534,7 @@ vect_analyze_group_access_1 (struct data

>               stmt, and the rest get their vectorized loads from the first

>               one.  */

>            if (!tree_int_cst_compare (DR_INIT (data_ref),

> -                                     DR_INIT (STMT_VINFO_DATA_REF (

> -                                                  vinfo_for_stmt (next)))))

> +                                    DR_INIT (STMT_VINFO_DATA_REF (next))))

>              {

>                if (DR_IS_WRITE (data_ref))

>                  {

> @@ -2550,16 +2548,16 @@ vect_analyze_group_access_1 (struct data

>                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,

>                                  "Two or more load stmts share the same dr.\n");

>

> -              /* For load use the same data-ref load.  */

> -              DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next)) = prev;

> +             /* For load use the same data-ref load.  */

> +             DR_GROUP_SAME_DR_STMT (next) = prev;

>

> -              prev = next;

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

> -              continue;

> +             prev = next;

> +             next = DR_GROUP_NEXT_ELEMENT (next);

> +             continue;

>              }

>

> -          prev = next;

> -          data_ref = STMT_VINFO_DATA_REF (vinfo_for_stmt (next));

> +         prev = next;

> +         data_ref = STMT_VINFO_DATA_REF (next);

>

>           /* All group members have the same STEP by construction.  */

>           gcc_checking_assert (operand_equal_p (DR_STEP (data_ref), step, 0));

> @@ -2587,12 +2585,12 @@ vect_analyze_group_access_1 (struct data

>

>            /* Store the gap from the previous member of the group. If there is no

>               gap in the access, DR_GROUP_GAP is always 1.  */

> -          DR_GROUP_GAP (vinfo_for_stmt (next)) = diff;

> +         DR_GROUP_GAP (next) = diff;

>

> -          prev_init = DR_INIT (data_ref);

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

> -          /* Count the number of data-refs in the chain.  */

> -          count++;

> +         prev_init = DR_INIT (data_ref);

> +         next = DR_GROUP_NEXT_ELEMENT (next);

> +         /* Count the number of data-refs in the chain.  */

> +         count++;

>          }

>

>        if (groupsize == 0)

> @@ -2668,15 +2666,13 @@ vect_analyze_group_access (struct data_r

>    if (!vect_analyze_group_access_1 (dr))

>      {

>        /* Dissolve the group if present.  */

> -      gimple *next;

> -      gimple *stmt = DR_GROUP_FIRST_ELEMENT (vect_dr_stmt (dr));

> -      while (stmt)

> -       {

> -         stmt_vec_info vinfo = vinfo_for_stmt (stmt);

> -         next = DR_GROUP_NEXT_ELEMENT (vinfo);

> -         DR_GROUP_FIRST_ELEMENT (vinfo) = NULL;

> -         DR_GROUP_NEXT_ELEMENT (vinfo) = NULL;

> -         stmt = next;

> +      stmt_vec_info stmt_info = DR_GROUP_FIRST_ELEMENT (vect_dr_stmt (dr));

> +      while (stmt_info)

> +       {

> +         stmt_vec_info next = DR_GROUP_NEXT_ELEMENT (stmt_info);

> +         DR_GROUP_FIRST_ELEMENT (stmt_info) = NULL;

> +         DR_GROUP_NEXT_ELEMENT (stmt_info) = NULL;

> +         stmt_info = next;

>         }

>        return false;

>      }

> @@ -3281,7 +3277,7 @@ vect_small_gap_p (loop_vec_info loop_vin

>    HOST_WIDE_INT count

>      = estimated_poly_value (LOOP_VINFO_VECT_FACTOR (loop_vinfo));

>    if (DR_GROUP_FIRST_ELEMENT (stmt_info))

> -    count *= DR_GROUP_SIZE (vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info)));

> +    count *= DR_GROUP_SIZE (DR_GROUP_FIRST_ELEMENT (stmt_info));

>    return estimated_poly_value (gap) <= count * vect_get_scalar_dr_size (dr);

>  }

>

> @@ -3379,11 +3375,9 @@ vect_prune_runtime_alias_test_list (loop

>        int comp_res;

>        poly_uint64 lower_bound;

>        struct data_reference *dr_a, *dr_b;

> -      gimple *dr_group_first_a, *dr_group_first_b;

>        tree segment_length_a, segment_length_b;

>        unsigned HOST_WIDE_INT access_size_a, access_size_b;

>        unsigned int align_a, align_b;

> -      gimple *stmt_a, *stmt_b;

>

>        /* Ignore the alias if the VF we chose ended up being no greater

>          than the dependence distance.  */

> @@ -3409,15 +3403,15 @@ vect_prune_runtime_alias_test_list (loop

>         }

>

>        dr_a = DDR_A (ddr);

> -      stmt_a = vect_dr_stmt (DDR_A (ddr));

> +      stmt_vec_info stmt_info_a = vect_dr_stmt (DDR_A (ddr));

>

>        dr_b = DDR_B (ddr);

> -      stmt_b = vect_dr_stmt (DDR_B (ddr));

> +      stmt_vec_info stmt_info_b = vect_dr_stmt (DDR_B (ddr));

>

>        /* Skip the pair if inter-iteration dependencies are irrelevant

>          and intra-iteration dependencies are guaranteed to be honored.  */

>        if (ignore_step_p

> -         && (vect_preserves_scalar_order_p (stmt_a, stmt_b)

> +         && (vect_preserves_scalar_order_p (stmt_info_a, stmt_info_b)

>               || vectorizable_with_step_bound_p (dr_a, dr_b, &lower_bound)))

>         {

>           if (dump_enabled_p ())

> @@ -3468,18 +3462,18 @@ vect_prune_runtime_alias_test_list (loop

>           continue;

>         }

>

> -      dr_group_first_a = DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt_a));

> +      stmt_vec_info dr_group_first_a = DR_GROUP_FIRST_ELEMENT (stmt_info_a);

>        if (dr_group_first_a)

>         {

> -         stmt_a = dr_group_first_a;

> -         dr_a = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt_a));

> +         stmt_info_a = dr_group_first_a;

> +         dr_a = STMT_VINFO_DATA_REF (stmt_info_a);

>         }

>

> -      dr_group_first_b = DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt_b));

> +      stmt_vec_info dr_group_first_b = DR_GROUP_FIRST_ELEMENT (stmt_info_b);

>        if (dr_group_first_b)

>         {

> -         stmt_b = dr_group_first_b;

> -         dr_b = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt_b));

> +         stmt_info_b = dr_group_first_b;

> +         dr_b = STMT_VINFO_DATA_REF (stmt_info_b);

>         }

>

>        if (ignore_step_p)

> @@ -4734,10 +4728,9 @@ vect_create_data_ref_ptr (gimple *stmt,

>    /* Likewise for any of the data references in the stmt group.  */

>    else if (DR_GROUP_SIZE (stmt_info) > 1)

>      {

> -      gimple *orig_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +      stmt_vec_info sinfo = DR_GROUP_FIRST_ELEMENT (stmt_info);

>        do

>         {

> -         stmt_vec_info sinfo = vinfo_for_stmt (orig_stmt);

>           struct data_reference *sdr = STMT_VINFO_DATA_REF (sinfo);

>           if (!alias_sets_conflict_p (get_alias_set (aggr_type),

>                                       get_alias_set (DR_REF (sdr))))

> @@ -4745,9 +4738,9 @@ vect_create_data_ref_ptr (gimple *stmt,

>               need_ref_all = true;

>               break;

>             }

> -         orig_stmt = DR_GROUP_NEXT_ELEMENT (sinfo);

> +         sinfo = DR_GROUP_NEXT_ELEMENT (sinfo);

>         }

> -      while (orig_stmt);

> +      while (sinfo);

>      }

>    aggr_ptr_type = build_pointer_type_for_mode (aggr_type, ptr_mode,

>                                                need_ref_all);

> @@ -6345,19 +6338,18 @@ vect_record_grouped_load_vectors (gimple

>  {

>    stmt_vec_info stmt_info = vinfo_for_stmt (stmt);

>    vec_info *vinfo = stmt_info->vinfo;

> -  gimple *first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -  gimple *next_stmt;

> +  stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

>    unsigned int i, gap_count;

>    tree tmp_data_ref;

>

>    /* Put a permuted data-ref in the VECTORIZED_STMT field.

>       Since we scan the chain starting from it's first node, their order

>       corresponds the order of data-refs in RESULT_CHAIN.  */

> -  next_stmt = first_stmt;

> +  stmt_vec_info next_stmt_info = first_stmt_info;

>    gap_count = 1;

>    FOR_EACH_VEC_ELT (result_chain, i, tmp_data_ref)

>      {

> -      if (!next_stmt)

> +      if (!next_stmt_info)

>         break;

>

>        /* Skip the gaps.  Loads created for the gaps will be removed by dead

> @@ -6366,27 +6358,27 @@ vect_record_grouped_load_vectors (gimple

>         DR_GROUP_GAP is the number of steps in elements from the previous

>         access (if there is no gap DR_GROUP_GAP is 1).  We skip loads that

>         correspond to the gaps.  */

> -      if (next_stmt != first_stmt

> -          && gap_count < DR_GROUP_GAP (vinfo_for_stmt (next_stmt)))

> +      if (next_stmt_info != first_stmt_info

> +         && gap_count < DR_GROUP_GAP (next_stmt_info))

>        {

>          gap_count++;

>          continue;

>        }

>

> -      while (next_stmt)

> +      while (next_stmt_info)

>          {

>           stmt_vec_info new_stmt_info = vinfo->lookup_def (tmp_data_ref);

>           /* We assume that if VEC_STMT is not NULL, this is a case of multiple

>              copies, and we put the new vector statement in the first available

>              RELATED_STMT.  */

> -         if (!STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)))

> -           STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)) = new_stmt_info;

> +         if (!STMT_VINFO_VEC_STMT (next_stmt_info))

> +           STMT_VINFO_VEC_STMT (next_stmt_info) = new_stmt_info;

>           else

>              {

> -              if (!DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next_stmt)))

> +             if (!DR_GROUP_SAME_DR_STMT (next_stmt_info))

>                  {

>                   stmt_vec_info prev_stmt_info

> -                   = STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt));

> +                   = STMT_VINFO_VEC_STMT (next_stmt_info);

>                   stmt_vec_info rel_stmt_info

>                     = STMT_VINFO_RELATED_STMT (prev_stmt_info);

>                   while (rel_stmt_info)

> @@ -6399,12 +6391,12 @@ vect_record_grouped_load_vectors (gimple

>                  }

>              }

>

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

> +         next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

>           gap_count = 1;

> -         /* If NEXT_STMT accesses the same DR as the previous statement,

> +         /* If NEXT_STMT_INFO accesses the same DR as the previous statement,

>              put the same TMP_DATA_REF as its vectorized statement; otherwise

>              get the next data-ref from RESULT_CHAIN.  */

> -         if (!next_stmt || !DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next_stmt)))

> +         if (!next_stmt_info || !DR_GROUP_SAME_DR_STMT (next_stmt_info))

>             break;

>          }

>      }

> @@ -6545,8 +6537,8 @@ vect_supportable_dr_alignment (struct da

>           if (loop_vinfo

>               && STMT_SLP_TYPE (stmt_info)

>               && !multiple_p (LOOP_VINFO_VECT_FACTOR (loop_vinfo)

> -                             * DR_GROUP_SIZE (vinfo_for_stmt

> -                                           (DR_GROUP_FIRST_ELEMENT (stmt_info))),

> +                             * (DR_GROUP_SIZE

> +                                (DR_GROUP_FIRST_ELEMENT (stmt_info))),

>                               TYPE_VECTOR_SUBPARTS (vectype)))

>             ;

>           else if (!loop_vinfo

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

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

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

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

> @@ -661,14 +661,14 @@ vect_fixup_reduc_chain (gimple *stmt)

>    REDUC_GROUP_SIZE (firstp) = REDUC_GROUP_SIZE (stmt_info);

>    do

>      {

> -      stmtp = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt));

> +      stmtp = STMT_VINFO_RELATED_STMT (stmt_info);

>        REDUC_GROUP_FIRST_ELEMENT (stmtp) = firstp;

> -      stmt = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));

> -      if (stmt)

> +      stmt_info = REDUC_GROUP_NEXT_ELEMENT (stmt_info);

> +      if (stmt_info)

>         REDUC_GROUP_NEXT_ELEMENT (stmtp)

> -         = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt));

> +         = STMT_VINFO_RELATED_STMT (stmt_info);

>      }

> -  while (stmt);

> +  while (stmt_info);

>    STMT_VINFO_DEF_TYPE (stmtp) = vect_reduction_def;

>  }

>

> @@ -683,12 +683,12 @@ vect_fixup_scalar_cycles_with_patterns (

>    FOR_EACH_VEC_ELT (LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo), i, first)

>      if (STMT_VINFO_IN_PATTERN_P (vinfo_for_stmt (first)))

>        {

> -       gimple *next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first));

> +       stmt_vec_info next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first));

>         while (next)

>           {

> -           if (! STMT_VINFO_IN_PATTERN_P (vinfo_for_stmt (next)))

> +           if (! STMT_VINFO_IN_PATTERN_P (next))

>               break;

> -           next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next));

> +           next = REDUC_GROUP_NEXT_ELEMENT (next);

>           }

>         /* If not all stmt in the chain are patterns try to handle

>            the chain without patterns.  */

> @@ -2188,7 +2188,7 @@ vect_analyze_loop_2 (loop_vec_info loop_

>        vinfo = SLP_TREE_SCALAR_STMTS (SLP_INSTANCE_TREE (instance))[0];

>        if (! STMT_VINFO_GROUPED_ACCESS (vinfo))

>         continue;

> -      vinfo = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (vinfo));

> +      vinfo = DR_GROUP_FIRST_ELEMENT (vinfo);

>        unsigned int size = DR_GROUP_SIZE (vinfo);

>        tree vectype = STMT_VINFO_VECTYPE (vinfo);

>        if (! vect_store_lanes_supported (vectype, size, false)

> @@ -2198,7 +2198,7 @@ vect_analyze_loop_2 (loop_vec_info loop_

>        FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (instance), j, node)

>         {

>           vinfo = SLP_TREE_SCALAR_STMTS (node)[0];

> -         vinfo = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (vinfo));

> +         vinfo = DR_GROUP_FIRST_ELEMENT (vinfo);

>           bool single_element_p = !DR_GROUP_NEXT_ELEMENT (vinfo);

>           size = DR_GROUP_SIZE (vinfo);

>           vectype = STMT_VINFO_VECTYPE (vinfo);

> @@ -2527,7 +2527,7 @@ vect_is_slp_reduction (loop_vec_info loo

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

>    struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);

>    enum tree_code code;

> -  gimple *loop_use_stmt = NULL, *first, *next_stmt;

> +  gimple *loop_use_stmt = NULL;

>    stmt_vec_info use_stmt_info, current_stmt_info = NULL;

>    tree lhs;

>    imm_use_iterator imm_iter;

> @@ -2592,12 +2592,12 @@ vect_is_slp_reduction (loop_vec_info loo

>        use_stmt_info = loop_info->lookup_stmt (loop_use_stmt);

>        if (current_stmt_info)

>          {

> -         REDUC_GROUP_NEXT_ELEMENT (current_stmt_info) = loop_use_stmt;

> +         REDUC_GROUP_NEXT_ELEMENT (current_stmt_info) = use_stmt_info;

>            REDUC_GROUP_FIRST_ELEMENT (use_stmt_info)

>              = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);

>          }

>        else

> -       REDUC_GROUP_FIRST_ELEMENT (use_stmt_info) = loop_use_stmt;

> +       REDUC_GROUP_FIRST_ELEMENT (use_stmt_info) = use_stmt_info;

>

>        lhs = gimple_assign_lhs (loop_use_stmt);

>        current_stmt_info = use_stmt_info;

> @@ -2610,9 +2610,10 @@ vect_is_slp_reduction (loop_vec_info loo

>    /* Swap the operands, if needed, to make the reduction operand be the second

>       operand.  */

>    lhs = PHI_RESULT (phi);

> -  next_stmt = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);

> -  while (next_stmt)

> +  stmt_vec_info next_stmt_info = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);

> +  while (next_stmt_info)

>      {

> +      gassign *next_stmt = as_a <gassign *> (next_stmt_info->stmt);

>        if (gimple_assign_rhs2 (next_stmt) == lhs)

>         {

>           tree op = gimple_assign_rhs1 (next_stmt);

> @@ -2626,7 +2627,7 @@ vect_is_slp_reduction (loop_vec_info loo

>               && 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));

> +             next_stmt_info = REDUC_GROUP_NEXT_ELEMENT (next_stmt_info);

>               continue;

>             }

>

> @@ -2663,13 +2664,14 @@ vect_is_slp_reduction (loop_vec_info loo

>          }

>

>        lhs = gimple_assign_lhs (next_stmt);

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

> +      next_stmt_info = REDUC_GROUP_NEXT_ELEMENT (next_stmt_info);

>      }

>

>    /* Save the chain for further analysis in SLP detection.  */

> -  first = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);

> -  LOOP_VINFO_REDUCTION_CHAINS (loop_info).safe_push (first);

> -  REDUC_GROUP_SIZE (vinfo_for_stmt (first)) = size;

> +  stmt_vec_info first_stmt_info

> +    = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);

> +  LOOP_VINFO_REDUCTION_CHAINS (loop_info).safe_push (first_stmt_info);

> +  REDUC_GROUP_SIZE (first_stmt_info) = size;

>

>    return true;

>  }

> @@ -3254,12 +3256,12 @@ vect_is_simple_reduction (loop_vec_info

>      }

>

>    /* Dissolve group eventually half-built by vect_is_slp_reduction.  */

> -  gimple *first = REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (def_stmt));

> +  stmt_vec_info first = REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (def_stmt));

>    while (first)

>      {

> -      gimple *next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first));

> -      REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (first)) = NULL;

> -      REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first)) = NULL;

> +      stmt_vec_info next = REDUC_GROUP_NEXT_ELEMENT (first);

> +      REDUC_GROUP_FIRST_ELEMENT (first) = NULL;

> +      REDUC_GROUP_NEXT_ELEMENT (first) = NULL;

>        first = next;

>      }

>

> @@ -6130,7 +6132,8 @@ vectorizable_reduction (gimple *stmt, gi

>      }

>

>    if (REDUC_GROUP_FIRST_ELEMENT (stmt_info))

> -    gcc_assert (slp_node && REDUC_GROUP_FIRST_ELEMENT (stmt_info) == stmt);

> +    gcc_assert (slp_node

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

>

>    if (gimple_code (stmt) == GIMPLE_PHI)

>      {

> @@ -6784,8 +6787,8 @@ vectorizable_reduction (gimple *stmt, gi

>    tree neutral_op = NULL_TREE;

>    if (slp_node)

>      neutral_op = neutral_op_for_slp_reduction

> -                  (slp_node_instance->reduc_phis, code,

> -                   REDUC_GROUP_FIRST_ELEMENT (stmt_info) != NULL);

> +      (slp_node_instance->reduc_phis, code,

> +       REDUC_GROUP_FIRST_ELEMENT (stmt_info) != NULL_STMT_VEC_INFO);

>

>    if (double_reduc && reduction_type == FOLD_LEFT_REDUCTION)

>      {

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

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

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

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

> @@ -820,7 +820,7 @@ vect_reassociating_reduction_p (stmt_vec

>  {

>    return (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_reduction_def

>           ? STMT_VINFO_REDUC_TYPE (stmt_vinfo) != FOLD_LEFT_REDUCTION

> -         : REDUC_GROUP_FIRST_ELEMENT (stmt_vinfo) != NULL);

> +         : REDUC_GROUP_FIRST_ELEMENT (stmt_vinfo) != NULL_STMT_VEC_INFO);

>  }

>

>  /* As above, but also require it to have code CODE and to be a reduction

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

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

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

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

> @@ -712,7 +712,7 @@ vect_build_slp_tree_1 (vec_info *vinfo,

>    int icode;

>    machine_mode optab_op2_mode;

>    machine_mode vec_mode;

> -  gimple *first_load = NULL, *prev_first_load = NULL;

> +  stmt_vec_info first_load = NULL, prev_first_load = NULL;

>

>    /* For every stmt in NODE find its def stmt/s.  */

>    stmt_vec_info stmt_info;

> @@ -1692,8 +1692,7 @@ vect_attempt_slp_rearrange_stmts (slp_in

>    FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (slp_instn), i, node)

>      {

>        stmt_vec_info first_stmt_info = SLP_TREE_SCALAR_STMTS (node)[0];

> -      first_stmt_info

> -       = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (first_stmt_info));

> +      first_stmt_info = DR_GROUP_FIRST_ELEMENT (first_stmt_info);

>        /* But we have to keep those permutations that are required because

>           of handling of gaps.  */

>        if (known_eq (unrolling_factor, 1U)

> @@ -1717,7 +1716,6 @@ vect_supported_load_permutation_p (slp_i

>    unsigned int group_size = SLP_INSTANCE_GROUP_SIZE (slp_instn);

>    unsigned int i, j, k, next;

>    slp_tree node;

> -  gimple *next_load;

>

>    if (dump_enabled_p ())

>      {

> @@ -1766,26 +1764,25 @@ vect_supported_load_permutation_p (slp_i

>           if (!SLP_TREE_LOAD_PERMUTATION (node).exists ())

>             continue;

>           bool subchain_p = true;

> -          next_load = NULL;

> +         stmt_vec_info next_load_info = NULL;

>           stmt_vec_info load_info;

>           FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), j, load_info)

>             {

>               if (j != 0

> -                 && (next_load != load_info

> +                 && (next_load_info != load_info

>                       || DR_GROUP_GAP (load_info) != 1))

>                 {

>                   subchain_p = false;

>                   break;

>                 }

> -             next_load = DR_GROUP_NEXT_ELEMENT (load_info);

> +             next_load_info = DR_GROUP_NEXT_ELEMENT (load_info);

>             }

>           if (subchain_p)

>             SLP_TREE_LOAD_PERMUTATION (node).release ();

>           else

>             {

>               stmt_vec_info group_info = SLP_TREE_SCALAR_STMTS (node)[0];

> -             group_info

> -               = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (group_info));

> +             group_info = DR_GROUP_FIRST_ELEMENT (group_info);

>               unsigned HOST_WIDE_INT nunits;

>               unsigned k, maxk = 0;

>               FOR_EACH_VEC_ELT (SLP_TREE_LOAD_PERMUTATION (node), j, k)

> @@ -1868,33 +1865,33 @@ vect_find_last_scalar_stmt_in_slp (slp_t

>  vect_split_slp_store_group (gimple *first_stmt, unsigned group1_size)

>  {

>    stmt_vec_info first_vinfo = vinfo_for_stmt (first_stmt);

> -  gcc_assert (DR_GROUP_FIRST_ELEMENT (first_vinfo) == first_stmt);

> +  gcc_assert (DR_GROUP_FIRST_ELEMENT (first_vinfo) == first_vinfo);

>    gcc_assert (group1_size > 0);

>    int group2_size = DR_GROUP_SIZE (first_vinfo) - group1_size;

>    gcc_assert (group2_size > 0);

>    DR_GROUP_SIZE (first_vinfo) = group1_size;

>

> -  gimple *stmt = first_stmt;

> +  stmt_vec_info stmt_info = first_vinfo;

>    for (unsigned i = group1_size; i > 1; i--)

>      {

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

> -      gcc_assert (DR_GROUP_GAP (vinfo_for_stmt (stmt)) == 1);

> +      stmt_info = DR_GROUP_NEXT_ELEMENT (stmt_info);

> +      gcc_assert (DR_GROUP_GAP (stmt_info) == 1);

>      }

>    /* STMT is now the last element of the first group.  */

> -  gimple *group2 = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));

> -  DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt)) = 0;

> +  stmt_vec_info group2 = DR_GROUP_NEXT_ELEMENT (stmt_info);

> +  DR_GROUP_NEXT_ELEMENT (stmt_info) = 0;

>

> -  DR_GROUP_SIZE (vinfo_for_stmt (group2)) = group2_size;

> -  for (stmt = group2; stmt; stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt)))

> +  DR_GROUP_SIZE (group2) = group2_size;

> +  for (stmt_info = group2; stmt_info;

> +       stmt_info = DR_GROUP_NEXT_ELEMENT (stmt_info))

>      {

> -      DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) = group2;

> -      gcc_assert (DR_GROUP_GAP (vinfo_for_stmt (stmt)) == 1);

> +      DR_GROUP_FIRST_ELEMENT (stmt_info) = group2;

> +      gcc_assert (DR_GROUP_GAP (stmt_info) == 1);

>      }

>

>    /* For the second group, the DR_GROUP_GAP is that before the original group,

>       plus skipping over the first vector.  */

> -  DR_GROUP_GAP (vinfo_for_stmt (group2))

> -    = DR_GROUP_GAP (first_vinfo) + group1_size;

> +  DR_GROUP_GAP (group2) = DR_GROUP_GAP (first_vinfo) + group1_size;

>

>    /* DR_GROUP_GAP of the first group now has to skip over the second group too.  */

>    DR_GROUP_GAP (first_vinfo) += group2_size;

> @@ -1928,8 +1925,6 @@ vect_analyze_slp_instance (vec_info *vin

>    slp_tree node;

>    unsigned int group_size;

>    tree vectype, scalar_type = NULL_TREE;

> -  gimple *next;

> -  stmt_vec_info next_info;

>    unsigned int i;

>    vec<slp_tree> loads;

>    struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info);

> @@ -1970,34 +1965,32 @@ vect_analyze_slp_instance (vec_info *vin

>

>    /* Create a node (a root of the SLP tree) for the packed grouped stores.  */

>    scalar_stmts.create (group_size);

> -  next = stmt;

> +  stmt_vec_info next_info = stmt_info;

>    if (STMT_VINFO_GROUPED_ACCESS (stmt_info))

>      {

>        /* Collect the stores and store them in SLP_TREE_SCALAR_STMTS.  */

> -      while (next)

> +      while (next_info)

>          {

> -         next_info = vinfo_for_stmt (next);

>           if (STMT_VINFO_IN_PATTERN_P (next_info)

>               && STMT_VINFO_RELATED_STMT (next_info))

>             scalar_stmts.safe_push (STMT_VINFO_RELATED_STMT (next_info));

>           else

>             scalar_stmts.safe_push (next_info);

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

> +         next_info = DR_GROUP_NEXT_ELEMENT (next_info);

>          }

>      }

>    else if (!dr && REDUC_GROUP_FIRST_ELEMENT (stmt_info))

>      {

>        /* Collect the reduction stmts and store them in

>          SLP_TREE_SCALAR_STMTS.  */

> -      while (next)

> +      while (next_info)

>          {

> -         next_info = vinfo_for_stmt (next);

>           if (STMT_VINFO_IN_PATTERN_P (next_info)

>               && STMT_VINFO_RELATED_STMT (next_info))

>             scalar_stmts.safe_push (STMT_VINFO_RELATED_STMT (next_info));

>           else

>             scalar_stmts.safe_push (next_info);

> -          next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next));

> +         next_info = REDUC_GROUP_NEXT_ELEMENT (next_info);

>          }

>        /* Mark the first element of the reduction chain as reduction to properly

>          transform the node.  In the reduction analysis phase only the last

> @@ -2067,15 +2060,14 @@ vect_analyze_slp_instance (vec_info *vin

>           vec<unsigned> load_permutation;

>           int j;

>           stmt_vec_info load_info;

> -         gimple *first_stmt;

>           bool this_load_permuted = false;

>           load_permutation.create (group_size);

> -         first_stmt = DR_GROUP_FIRST_ELEMENT

> +         stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT

>             (SLP_TREE_SCALAR_STMTS (load_node)[0]);

>           FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (load_node), j, load_info)

>             {

>               int load_place = vect_get_place_in_interleaving_chain

> -               (load_info, first_stmt);

> +               (load_info, first_stmt_info);

>               gcc_assert (load_place != -1);

>               if (load_place != j)

>                 this_load_permuted = true;

> @@ -2086,8 +2078,8 @@ vect_analyze_slp_instance (vec_info *vin

>                  a gap either because the group is larger than the SLP

>                  group-size or because there is a gap between the groups.  */

>               && (known_eq (unrolling_factor, 1U)

> -                 || (group_size == DR_GROUP_SIZE (vinfo_for_stmt (first_stmt))

> -                     && DR_GROUP_GAP (vinfo_for_stmt (first_stmt)) == 0)))

> +                 || (group_size == DR_GROUP_SIZE (first_stmt_info)

> +                     && DR_GROUP_GAP (first_stmt_info) == 0)))

>             {

>               load_permutation.release ();

>               continue;

> @@ -2122,11 +2114,9 @@ vect_analyze_slp_instance (vec_info *vin

>           slp_tree load_node;

>           FOR_EACH_VEC_ELT (loads, i, load_node)

>             {

> -             gimple *first_stmt = DR_GROUP_FIRST_ELEMENT

> +             stmt_vec_info stmt_vinfo = DR_GROUP_FIRST_ELEMENT

>                 (SLP_TREE_SCALAR_STMTS (load_node)[0]);

> -             stmt_vec_info stmt_vinfo = vinfo_for_stmt (first_stmt);

> -                 /* Use SLP for strided accesses (or if we

> -                    can't load-lanes).  */

> +             /* Use SLP for strided accesses (or if we can't load-lanes).  */

>               if (STMT_VINFO_STRIDED_P (stmt_vinfo)

>                   || ! vect_load_lanes_supported

>                         (STMT_VINFO_VECTYPE (stmt_vinfo),

> @@ -2230,11 +2220,11 @@ vect_analyze_slp (vec_info *vinfo, unsig

>                                              max_tree_size))

>               {

>                 /* Dissolve reduction chain group.  */

> -               gimple *next, *stmt = first_element;

> +               gimple *stmt = first_element;

>                 while (stmt)

>                   {

>                     stmt_vec_info vinfo = vinfo_for_stmt (stmt);

> -                   next = REDUC_GROUP_NEXT_ELEMENT (vinfo);

> +                   stmt_vec_info next = REDUC_GROUP_NEXT_ELEMENT (vinfo);

>                     REDUC_GROUP_FIRST_ELEMENT (vinfo) = NULL;

>                     REDUC_GROUP_NEXT_ELEMENT (vinfo) = NULL;

>                     stmt = next;

> @@ -3698,7 +3688,7 @@ vect_transform_slp_perm_load (slp_tree n

>    if (!STMT_VINFO_GROUPED_ACCESS (stmt_info))

>      return false;

>

> -  stmt_info = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info));

> +  stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

>

>    mode = TYPE_MODE (vectype);

>

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

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

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

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

> @@ -978,7 +978,7 @@ vect_model_store_cost (stmt_vec_info stm

>                        stmt_vector_for_cost *cost_vec)

>  {

>    unsigned int inside_cost = 0, prologue_cost = 0;

> -  gimple *first_stmt = STMT_VINFO_STMT (stmt_info);

> +  stmt_vec_info first_stmt_info = stmt_info;

>    bool grouped_access_p = STMT_VINFO_GROUPED_ACCESS (stmt_info);

>

>    /* ???  Somehow we need to fix this at the callers.  */

> @@ -998,12 +998,12 @@ vect_model_store_cost (stmt_vec_info stm

>    /* Grouped stores update all elements in the group at once,

>       so we want the DR for the first statement.  */

>    if (!slp_node && grouped_access_p)

> -    first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +    first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

>

>    /* True if we should include any once-per-group costs as well as

>       the cost of the statement itself.  For SLP we only get called

>       once per group anyhow.  */

> -  bool first_stmt_p = (first_stmt == STMT_VINFO_STMT (stmt_info));

> +  bool first_stmt_p = (first_stmt_info == stmt_info);

>

>    /* We assume that the cost of a single store-lanes instruction is

>       equivalent to the cost of DR_GROUP_SIZE separate stores.  If a grouped

> @@ -1014,7 +1014,7 @@ vect_model_store_cost (stmt_vec_info stm

>      {

>        /* Uses a high and low interleave or shuffle operations for each

>          needed permute.  */

> -      int group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));

> +      int group_size = DR_GROUP_SIZE (first_stmt_info);

>        int nstmts = ncopies * ceil_log2 (group_size) * group_size;

>        inside_cost = record_stmt_cost (cost_vec, nstmts, vec_perm,

>                                       stmt_info, 0, vect_body);

> @@ -1122,7 +1122,6 @@ vect_model_load_cost (stmt_vec_info stmt

>                       slp_tree slp_node,

>                       stmt_vector_for_cost *cost_vec)

>  {

> -  gimple *first_stmt = STMT_VINFO_STMT (stmt_info);

>    unsigned int inside_cost = 0, prologue_cost = 0;

>    bool grouped_access_p = STMT_VINFO_GROUPED_ACCESS (stmt_info);

>

> @@ -1136,28 +1135,27 @@ vect_model_load_cost (stmt_vec_info stmt

>      {

>        /* If the load is permuted then the alignment is determined by

>          the first group element not by the first scalar stmt DR.  */

> -      gimple *stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -      stmt_vec_info stmt_info = vinfo_for_stmt (stmt);

> +      stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

>        /* Record the cost for the permutation.  */

>        unsigned n_perms;

>        unsigned assumed_nunits

> -       = vect_nunits_for_cost (STMT_VINFO_VECTYPE (stmt_info));

> +       = vect_nunits_for_cost (STMT_VINFO_VECTYPE (first_stmt_info));

>        unsigned slp_vf = (ncopies * assumed_nunits) / instance->group_size;

>        vect_transform_slp_perm_load (slp_node, vNULL, NULL,

>                                     slp_vf, instance, true,

>                                     &n_perms);

>        inside_cost += record_stmt_cost (cost_vec, n_perms, vec_perm,

> -                                      stmt_info, 0, vect_body);

> +                                      first_stmt_info, 0, vect_body);

>        /* And adjust the number of loads performed.  This handles

>          redundancies as well as loads that are later dead.  */

> -      auto_sbitmap perm (DR_GROUP_SIZE (stmt_info));

> +      auto_sbitmap perm (DR_GROUP_SIZE (first_stmt_info));

>        bitmap_clear (perm);

>        for (unsigned i = 0;

>            i < SLP_TREE_LOAD_PERMUTATION (slp_node).length (); ++i)

>         bitmap_set_bit (perm, SLP_TREE_LOAD_PERMUTATION (slp_node)[i]);

>        ncopies = 0;

>        bool load_seen = false;

> -      for (unsigned i = 0; i < DR_GROUP_SIZE (stmt_info); ++i)

> +      for (unsigned i = 0; i < DR_GROUP_SIZE (first_stmt_info); ++i)

>         {

>           if (i % assumed_nunits == 0)

>             {

> @@ -1171,19 +1169,21 @@ vect_model_load_cost (stmt_vec_info stmt

>        if (load_seen)

>         ncopies++;

>        gcc_assert (ncopies

> -                 <= (DR_GROUP_SIZE (stmt_info) - DR_GROUP_GAP (stmt_info)

> +                 <= (DR_GROUP_SIZE (first_stmt_info)

> +                     - DR_GROUP_GAP (first_stmt_info)

>                       + assumed_nunits - 1) / assumed_nunits);

>      }

>

>    /* Grouped loads read all elements in the group at once,

>       so we want the DR for the first statement.  */

> +  stmt_vec_info first_stmt_info = stmt_info;

>    if (!slp_node && grouped_access_p)

> -    first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +    first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

>

>    /* True if we should include any once-per-group costs as well as

>       the cost of the statement itself.  For SLP we only get called

>       once per group anyhow.  */

> -  bool first_stmt_p = (first_stmt == STMT_VINFO_STMT (stmt_info));

> +  bool first_stmt_p = (first_stmt_info == stmt_info);

>

>    /* We assume that the cost of a single load-lanes instruction is

>       equivalent to the cost of DR_GROUP_SIZE separate loads.  If a grouped

> @@ -1194,7 +1194,7 @@ vect_model_load_cost (stmt_vec_info stmt

>      {

>        /* Uses an even and odd extract operations or shuffle operations

>          for each needed permute.  */

> -      int group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));

> +      int group_size = DR_GROUP_SIZE (first_stmt_info);

>        int nstmts = ncopies * ceil_log2 (group_size) * group_size;

>        inside_cost += record_stmt_cost (cost_vec, nstmts, vec_perm,

>                                        stmt_info, 0, vect_body);

> @@ -2183,12 +2183,12 @@ get_group_load_store_type (gimple *stmt,

>    vec_info *vinfo = stmt_info->vinfo;

>    loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);

>    struct loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo) : NULL;

> -  gimple *first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -  data_reference *first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));

> -  unsigned int group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));

> -  bool single_element_p = (stmt == first_stmt

> +  stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +  data_reference *first_dr = STMT_VINFO_DATA_REF (first_stmt_info);

> +  unsigned int group_size = DR_GROUP_SIZE (first_stmt_info);

> +  bool single_element_p = (stmt_info == first_stmt_info

>                            && !DR_GROUP_NEXT_ELEMENT (stmt_info));

> -  unsigned HOST_WIDE_INT gap = DR_GROUP_GAP (vinfo_for_stmt (first_stmt));

> +  unsigned HOST_WIDE_INT gap = DR_GROUP_GAP (first_stmt_info);

>    poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (vectype);

>

>    /* True if the vectorized statements would access beyond the last

> @@ -2315,14 +2315,14 @@ get_group_load_store_type (gimple *stmt,

>         *memory_access_type = VMAT_GATHER_SCATTER;

>      }

>

> -  if (vls_type != VLS_LOAD && first_stmt == stmt)

> +  if (vls_type != VLS_LOAD && first_stmt_info == stmt_info)

>      {

>        /* STMT is the leader of the group. Check the operands of all the

>          stmts of the group.  */

> -      gimple *next_stmt = DR_GROUP_NEXT_ELEMENT (stmt_info);

> -      while (next_stmt)

> +      stmt_vec_info next_stmt_info = DR_GROUP_NEXT_ELEMENT (stmt_info);

> +      while (next_stmt_info)

>         {

> -         tree op = vect_get_store_rhs (next_stmt);

> +         tree op = vect_get_store_rhs (next_stmt_info);

>           enum vect_def_type dt;

>           if (!vect_is_simple_use (op, vinfo, &dt))

>             {

> @@ -2331,7 +2331,7 @@ get_group_load_store_type (gimple *stmt,

>                                  "use not simple.\n");

>               return false;

>             }

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

> +         next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

>         }

>      }

>

> @@ -2482,7 +2482,7 @@ get_load_store_type (gimple *stmt, tree

>       traditional behavior until that can be fixed.  */

>    if (*memory_access_type == VMAT_ELEMENTWISE

>        && !STMT_VINFO_STRIDED_P (stmt_info)

> -      && !(stmt == DR_GROUP_FIRST_ELEMENT (stmt_info)

> +      && !(stmt_info == DR_GROUP_FIRST_ELEMENT (stmt_info)

>            && !DR_GROUP_NEXT_ELEMENT (stmt_info)

>            && !pow2p_hwi (DR_GROUP_SIZE (stmt_info))))

>      {

> @@ -6195,13 +6195,13 @@ ensure_base_align (struct data_reference

>  get_group_alias_ptr_type (gimple *first_stmt)

>  {

>    struct data_reference *first_dr, *next_dr;

> -  gimple *next_stmt;

>

>    first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));

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

> -  while (next_stmt)

> +  stmt_vec_info next_stmt_info

> +    = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first_stmt));

> +  while (next_stmt_info)

>      {

> -      next_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (next_stmt));

> +      next_dr = STMT_VINFO_DATA_REF (next_stmt_info);

>        if (get_alias_set (DR_REF (first_dr))

>           != get_alias_set (DR_REF (next_dr)))

>         {

> @@ -6210,7 +6210,7 @@ get_group_alias_ptr_type (gimple *first_

>                              "conflicting alias set types.\n");

>           return ptr_type_node;

>         }

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

> +      next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

>      }

>    return reference_alias_ptr_type (DR_REF (first_dr));

>  }

> @@ -6248,7 +6248,7 @@ vectorizable_store (gimple *stmt, gimple

>    gimple *ptr_incr = NULL;

>    int ncopies;

>    int j;

> -  gimple *next_stmt, *first_stmt;

> +  stmt_vec_info first_stmt_info;

>    bool grouped_store;

>    unsigned int group_size, i;

>    vec<tree> oprnds = vNULL;

> @@ -6400,13 +6400,13 @@ vectorizable_store (gimple *stmt, gimple

>                    && (slp || memory_access_type != VMAT_CONTIGUOUS));

>    if (grouped_store)

>      {

> -      first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -      first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));

> -      group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));

> +      first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +      first_dr = STMT_VINFO_DATA_REF (first_stmt_info);

> +      group_size = DR_GROUP_SIZE (first_stmt_info);

>      }

>    else

>      {

> -      first_stmt = stmt;

> +      first_stmt_info = stmt_info;

>        first_dr = dr;

>        group_size = vec_num = 1;

>      }

> @@ -6584,10 +6584,7 @@ vectorizable_store (gimple *stmt, gimple

>      }

>

>    if (STMT_VINFO_GROUPED_ACCESS (stmt_info))

> -    {

> -      gimple *group_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -      DR_GROUP_STORE_COUNT (vinfo_for_stmt (group_stmt))++;

> -    }

> +    DR_GROUP_STORE_COUNT (DR_GROUP_FIRST_ELEMENT (stmt_info))++;

>

>    if (grouped_store)

>      {

> @@ -6596,8 +6593,8 @@ vectorizable_store (gimple *stmt, gimple

>

>        /* We vectorize all the stmts of the interleaving group when we

>          reach the last stmt in the group.  */

> -      if (DR_GROUP_STORE_COUNT (vinfo_for_stmt (first_stmt))

> -         < DR_GROUP_SIZE (vinfo_for_stmt (first_stmt))

> +      if (DR_GROUP_STORE_COUNT (first_stmt_info)

> +         < DR_GROUP_SIZE (first_stmt_info)

>           && !slp)

>         {

>           *vec_stmt = NULL;

> @@ -6610,17 +6607,18 @@ vectorizable_store (gimple *stmt, gimple

>            /* VEC_NUM is the number of vect stmts to be created for this

>               group.  */

>            vec_num = SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node);

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

> -         gcc_assert (DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (first_stmt)) == first_stmt);

> -          first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));

> -         op = vect_get_store_rhs (first_stmt);

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

> +         gcc_assert (DR_GROUP_FIRST_ELEMENT (first_stmt_info)

> +                     == first_stmt_info);

> +         first_dr = STMT_VINFO_DATA_REF (first_stmt_info);

> +         op = vect_get_store_rhs (first_stmt_info);

>          }

>        else

>          /* VEC_NUM is the number of vect stmts to be created for this

>             group.  */

>         vec_num = group_size;

>

> -      ref_type = get_group_alias_ptr_type (first_stmt);

> +      ref_type = get_group_alias_ptr_type (first_stmt_info);

>      }

>    else

>      ref_type = reference_alias_ptr_type (DR_REF (first_dr));

> @@ -6759,7 +6757,7 @@ vectorizable_store (gimple *stmt, gimple

>

>        prev_stmt_info = NULL;

>        alias_off = build_int_cst (ref_type, 0);

> -      next_stmt = first_stmt;

> +      stmt_vec_info next_stmt_info = first_stmt_info;

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

>         {

>           running_off = offvar;

> @@ -6780,7 +6778,7 @@ vectorizable_store (gimple *stmt, gimple

>           for (j = 0; j < ncopies; j++)

>             {

>               /* We've set op and dt above, from vect_get_store_rhs,

> -                and first_stmt == stmt.  */

> +                and first_stmt_info == stmt_info.  */

>               if (j == 0)

>                 {

>                   if (slp)

> @@ -6791,8 +6789,9 @@ vectorizable_store (gimple *stmt, gimple

>                     }

>                   else

>                     {

> -                     op = vect_get_store_rhs (next_stmt);

> -                     vec_oprnd = vect_get_vec_def_for_operand (op, next_stmt);

> +                     op = vect_get_store_rhs (next_stmt_info);

> +                     vec_oprnd = vect_get_vec_def_for_operand

> +                       (op, next_stmt_info);

>                     }

>                 }

>               else

> @@ -6866,7 +6865,7 @@ vectorizable_store (gimple *stmt, gimple

>                     }

>                 }

>             }

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

> +         next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

>           if (slp)

>             break;

>         }

> @@ -6985,19 +6984,20 @@ vectorizable_store (gimple *stmt, gimple

>

>                  If the store is not grouped, DR_GROUP_SIZE is 1, and DR_CHAIN and

>                  OPRNDS are of size 1.  */

> -             next_stmt = first_stmt;

> +             stmt_vec_info next_stmt_info = first_stmt_info;

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

>                 {

>                   /* Since gaps are not supported for interleaved stores,

>                      DR_GROUP_SIZE is the exact number of stmts in the chain.

> -                    Therefore, NEXT_STMT can't be NULL_TREE.  In case that

> -                    there is no interleaving, DR_GROUP_SIZE is 1, and only one

> -                    iteration of the loop will be executed.  */

> -                 op = vect_get_store_rhs (next_stmt);

> -                 vec_oprnd = vect_get_vec_def_for_operand (op, next_stmt);

> +                    Therefore, NEXT_STMT_INFO can't be NULL_TREE.  In case

> +                    that there is no interleaving, DR_GROUP_SIZE is 1,

> +                    and only one iteration of the loop will be executed.  */

> +                 op = vect_get_store_rhs (next_stmt_info);

> +                 vec_oprnd = vect_get_vec_def_for_operand

> +                   (op, next_stmt_info);

>                   dr_chain.quick_push (vec_oprnd);

>                   oprnds.quick_push (vec_oprnd);

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

> +                 next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

>                 }

>               if (mask)

>                 vec_mask = vect_get_vec_def_for_operand (mask, stmt,

> @@ -7029,7 +7029,7 @@ vectorizable_store (gimple *stmt, gimple

>             }

>           else

>             dataref_ptr

> -             = vect_create_data_ref_ptr (first_stmt, aggr_type,

> +             = vect_create_data_ref_ptr (first_stmt_info, aggr_type,

>                                           simd_lane_access_p ? loop : NULL,

>                                           offset, &dummy, gsi, &ptr_incr,

>                                           simd_lane_access_p, &inv_p,

> @@ -7132,7 +7132,7 @@ vectorizable_store (gimple *stmt, gimple

>                                         &result_chain);

>             }

>

> -         next_stmt = first_stmt;

> +         stmt_vec_info next_stmt_info = first_stmt_info;

>           for (i = 0; i < vec_num; i++)

>             {

>               unsigned align, misalign;

> @@ -7249,8 +7249,8 @@ vectorizable_store (gimple *stmt, gimple

>               if (slp)

>                 continue;

>

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

> -             if (!next_stmt)

> +             next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);

> +             if (!next_stmt_info)

>                 break;

>             }

>         }

> @@ -7423,7 +7423,7 @@ vectorizable_load (gimple *stmt, gimple_

>    gphi *phi = NULL;

>    vec<tree> dr_chain = vNULL;

>    bool grouped_load = false;

> -  gimple *first_stmt;

> +  stmt_vec_info first_stmt_info;

>    stmt_vec_info first_stmt_info_for_drptr = NULL;

>    bool inv_p;

>    bool compute_in_loop = false;

> @@ -7565,8 +7565,8 @@ vectorizable_load (gimple *stmt, gimple_

>        gcc_assert (!nested_in_vect_loop);

>        gcc_assert (!STMT_VINFO_GATHER_SCATTER_P (stmt_info));

>

> -      first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -      group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));

> +      first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +      group_size = DR_GROUP_SIZE (first_stmt_info);

>

>        if (slp && SLP_TREE_LOAD_PERMUTATION (slp_node).exists ())

>         slp_perm = true;

> @@ -7696,25 +7696,26 @@ vectorizable_load (gimple *stmt, gimple_

>

>        if (grouped_load)

>         {

> -         first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -         first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));

> +         first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +         first_dr = STMT_VINFO_DATA_REF (first_stmt_info);

>         }

>        else

>         {

> -         first_stmt = stmt;

> +         first_stmt_info = stmt_info;

>           first_dr = dr;

>         }

>        if (slp && grouped_load)

>         {

> -         group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));

> -         ref_type = get_group_alias_ptr_type (first_stmt);

> +         group_size = DR_GROUP_SIZE (first_stmt_info);

> +         ref_type = get_group_alias_ptr_type (first_stmt_info);

>         }

>        else

>         {

>           if (grouped_load)

>             cst_offset

>               = (tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (vectype)))

> -                * vect_get_place_in_interleaving_chain (stmt, first_stmt));

> +                * vect_get_place_in_interleaving_chain (stmt,

> +                                                        first_stmt_info));

>           group_size = 1;

>           ref_type = reference_alias_ptr_type (DR_REF (dr));

>         }

> @@ -7924,19 +7925,19 @@ vectorizable_load (gimple *stmt, gimple_

>

>    if (grouped_load)

>      {

> -      first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);

> -      group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));

> +      first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

> +      group_size = DR_GROUP_SIZE (first_stmt_info);

>        /* For SLP vectorization we directly vectorize a subchain

>           without permutation.  */

>        if (slp && ! SLP_TREE_LOAD_PERMUTATION (slp_node).exists ())

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

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

>        /* For BB vectorization always use the first stmt to base

>          the data ref pointer on.  */

>        if (bb_vinfo)

>         first_stmt_info_for_drptr = SLP_TREE_SCALAR_STMTS (slp_node)[0];

>

>        /* Check if the chain of loads is already vectorized.  */

> -      if (STMT_VINFO_VEC_STMT (vinfo_for_stmt (first_stmt))

> +      if (STMT_VINFO_VEC_STMT (first_stmt_info)

>           /* For SLP we would need to copy over SLP_TREE_VEC_STMTS.

>              ???  But we can only do so if there is exactly one

>              as we have no way to get at the rest.  Leave the CSE

> @@ -7950,7 +7951,7 @@ vectorizable_load (gimple *stmt, gimple_

>           *vec_stmt = STMT_VINFO_VEC_STMT (stmt_info);

>           return true;

>         }

> -      first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));

> +      first_dr = STMT_VINFO_DATA_REF (first_stmt_info);

>        group_gap_adj = 0;

>

>        /* VEC_NUM is the number of vect stmts to be created for this group.  */

> @@ -7979,11 +7980,11 @@ vectorizable_load (gimple *stmt, gimple_

>        else

>         vec_num = group_size;

>

> -      ref_type = get_group_alias_ptr_type (first_stmt);

> +      ref_type = get_group_alias_ptr_type (first_stmt_info);

>      }

>    else

>      {

> -      first_stmt = stmt;

> +      first_stmt_info = stmt_info;

>        first_dr = dr;

>        group_size = vec_num = 1;

>        group_gap_adj = 0;

> @@ -8120,7 +8121,7 @@ vectorizable_load (gimple *stmt, gimple_

>         || alignment_support_scheme == dr_explicit_realign)

>        && !compute_in_loop)

>      {

> -      msq = vect_setup_realignment (first_stmt, gsi, &realignment_token,

> +      msq = vect_setup_realignment (first_stmt_info, gsi, &realignment_token,

>                                     alignment_support_scheme, NULL_TREE,

>                                     &at_loop);

>        if (alignment_support_scheme == dr_explicit_realign_optimized)

> @@ -8184,7 +8185,7 @@ vectorizable_load (gimple *stmt, gimple_

>               inv_p = false;

>             }

>           else if (first_stmt_info_for_drptr

> -                  && first_stmt != first_stmt_info_for_drptr)

> +                  && first_stmt_info != first_stmt_info_for_drptr)

>             {

>               dataref_ptr

>                 = vect_create_data_ref_ptr (first_stmt_info_for_drptr,

> @@ -8209,7 +8210,7 @@ vectorizable_load (gimple *stmt, gimple_

>             }

>           else

>             dataref_ptr

> -             = vect_create_data_ref_ptr (first_stmt, aggr_type, at_loop,

> +             = vect_create_data_ref_ptr (first_stmt_info, aggr_type, at_loop,

>                                           offset, &dummy, gsi, &ptr_incr,

>                                           simd_lane_access_p, &inv_p,

>                                           byte_offset, bump);

> @@ -8388,7 +8389,7 @@ vectorizable_load (gimple *stmt, gimple_

>                     tree vs = size_int (TYPE_VECTOR_SUBPARTS (vectype));

>

>                     if (compute_in_loop)

> -                     msq = vect_setup_realignment (first_stmt, gsi,

> +                     msq = vect_setup_realignment (first_stmt_info, gsi,

>                                                     &realignment_token,

>                                                     dr_explicit_realign,

>                                                     dataref_ptr, NULL);

> @@ -9708,8 +9709,7 @@ vect_transform_stmt (gimple *stmt, gimpl

>              one are skipped, and there vec_stmt_info shouldn't be freed

>              meanwhile.  */

>           *grouped_store = true;

> -         stmt_vec_info group_info

> -           = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info));

> +         stmt_vec_info group_info = DR_GROUP_FIRST_ELEMENT (stmt_info);

>           if (DR_GROUP_STORE_COUNT (group_info) == DR_GROUP_SIZE (group_info))

>             is_store = true;

>         }

> @@ -9817,14 +9817,13 @@ vect_transform_stmt (gimple *stmt, gimpl

>  vect_remove_stores (gimple *first_stmt)

>  {

>    gimple *next = first_stmt;

> -  gimple *tmp;

>    gimple_stmt_iterator next_si;

>

>    while (next)

>      {

>        stmt_vec_info stmt_info = vinfo_for_stmt (next);

>

> -      tmp = DR_GROUP_NEXT_ELEMENT (stmt_info);

> +      stmt_vec_info tmp = DR_GROUP_NEXT_ELEMENT (stmt_info);

>        if (is_pattern_stmt_p (stmt_info))

>         next = STMT_VINFO_RELATED_STMT (stmt_info);

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

Patch

Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2018-07-24 10:23:04.033010396 +0100
+++ gcc/tree-vectorizer.h	2018-07-24 10:23:08.536970400 +0100
@@ -871,9 +871,9 @@  struct _stmt_vec_info {
 
   /* Interleaving and reduction chains info.  */
   /* First element in the group.  */
-  gimple *first_element;
+  stmt_vec_info first_element;
   /* Pointer to the next element in the group.  */
-  gimple *next_element;
+  stmt_vec_info next_element;
   /* For data-refs, in case that two or more stmts share data-ref, this is the
      pointer to the previously detected stmt with the same dr.  */
   gimple *same_dr_stmt;
Index: gcc/tree-vect-data-refs.c
===================================================================
--- gcc/tree-vect-data-refs.c	2018-07-24 10:23:04.029010432 +0100
+++ gcc/tree-vect-data-refs.c	2018-07-24 10:23:08.532970436 +0100
@@ -1077,7 +1077,7 @@  vect_update_misalignment_for_peel (struc
  /* For interleaved data accesses the step in the loop must be multiplied by
      the size of the interleaving group.  */
   if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
-    dr_size *= DR_GROUP_SIZE (vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info)));
+    dr_size *= DR_GROUP_SIZE (DR_GROUP_FIRST_ELEMENT (stmt_info));
   if (STMT_VINFO_GROUPED_ACCESS (peel_stmt_info))
     dr_peel_size *= DR_GROUP_SIZE (peel_stmt_info);
 
@@ -2370,12 +2370,11 @@  vect_slp_analyze_and_verify_node_alignme
      the node is permuted in which case we start from the first
      element in the group.  */
   stmt_vec_info first_stmt_info = SLP_TREE_SCALAR_STMTS (node)[0];
-  gimple *first_stmt = first_stmt_info->stmt;
   data_reference_p first_dr = STMT_VINFO_DATA_REF (first_stmt_info);
   if (SLP_TREE_LOAD_PERMUTATION (node).exists ())
-    first_stmt = DR_GROUP_FIRST_ELEMENT (first_stmt_info);
+    first_stmt_info = DR_GROUP_FIRST_ELEMENT (first_stmt_info);
 
-  data_reference_p dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));
+  data_reference_p dr = STMT_VINFO_DATA_REF (first_stmt_info);
   vect_compute_data_ref_alignment (dr);
   /* For creating the data-ref pointer we need alignment of the
      first element anyway.  */
@@ -2520,11 +2519,11 @@  vect_analyze_group_access_1 (struct data
   if (DR_GROUP_FIRST_ELEMENT (stmt_info) == stmt_info)
     {
       /* First stmt in the interleaving chain. Check the chain.  */
-      gimple *next = DR_GROUP_NEXT_ELEMENT (stmt_info);
+      stmt_vec_info next = DR_GROUP_NEXT_ELEMENT (stmt_info);
       struct data_reference *data_ref = dr;
       unsigned int count = 1;
       tree prev_init = DR_INIT (data_ref);
-      gimple *prev = stmt_info;
+      stmt_vec_info prev = stmt_info;
       HOST_WIDE_INT diff, gaps = 0;
 
       /* By construction, all group members have INTEGER_CST DR_INITs.  */
@@ -2535,8 +2534,7 @@  vect_analyze_group_access_1 (struct data
              stmt, and the rest get their vectorized loads from the first
              one.  */
           if (!tree_int_cst_compare (DR_INIT (data_ref),
-                                     DR_INIT (STMT_VINFO_DATA_REF (
-						   vinfo_for_stmt (next)))))
+				     DR_INIT (STMT_VINFO_DATA_REF (next))))
             {
               if (DR_IS_WRITE (data_ref))
                 {
@@ -2550,16 +2548,16 @@  vect_analyze_group_access_1 (struct data
 		dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
 				 "Two or more load stmts share the same dr.\n");
 
-              /* For load use the same data-ref load.  */
-              DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next)) = prev;
+	      /* For load use the same data-ref load.  */
+	      DR_GROUP_SAME_DR_STMT (next) = prev;
 
-              prev = next;
-              next = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next));
-              continue;
+	      prev = next;
+	      next = DR_GROUP_NEXT_ELEMENT (next);
+	      continue;
             }
 
-          prev = next;
-          data_ref = STMT_VINFO_DATA_REF (vinfo_for_stmt (next));
+	  prev = next;
+	  data_ref = STMT_VINFO_DATA_REF (next);
 
 	  /* All group members have the same STEP by construction.  */
 	  gcc_checking_assert (operand_equal_p (DR_STEP (data_ref), step, 0));
@@ -2587,12 +2585,12 @@  vect_analyze_group_access_1 (struct data
 
           /* Store the gap from the previous member of the group. If there is no
              gap in the access, DR_GROUP_GAP is always 1.  */
-          DR_GROUP_GAP (vinfo_for_stmt (next)) = diff;
+	  DR_GROUP_GAP (next) = diff;
 
-          prev_init = DR_INIT (data_ref);
-          next = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next));
-          /* Count the number of data-refs in the chain.  */
-          count++;
+	  prev_init = DR_INIT (data_ref);
+	  next = DR_GROUP_NEXT_ELEMENT (next);
+	  /* Count the number of data-refs in the chain.  */
+	  count++;
         }
 
       if (groupsize == 0)
@@ -2668,15 +2666,13 @@  vect_analyze_group_access (struct data_r
   if (!vect_analyze_group_access_1 (dr))
     {
       /* Dissolve the group if present.  */
-      gimple *next;
-      gimple *stmt = DR_GROUP_FIRST_ELEMENT (vect_dr_stmt (dr));
-      while (stmt)
-	{
-	  stmt_vec_info vinfo = vinfo_for_stmt (stmt);
-	  next = DR_GROUP_NEXT_ELEMENT (vinfo);
-	  DR_GROUP_FIRST_ELEMENT (vinfo) = NULL;
-	  DR_GROUP_NEXT_ELEMENT (vinfo) = NULL;
-	  stmt = next;
+      stmt_vec_info stmt_info = DR_GROUP_FIRST_ELEMENT (vect_dr_stmt (dr));
+      while (stmt_info)
+	{
+	  stmt_vec_info next = DR_GROUP_NEXT_ELEMENT (stmt_info);
+	  DR_GROUP_FIRST_ELEMENT (stmt_info) = NULL;
+	  DR_GROUP_NEXT_ELEMENT (stmt_info) = NULL;
+	  stmt_info = next;
 	}
       return false;
     }
@@ -3281,7 +3277,7 @@  vect_small_gap_p (loop_vec_info loop_vin
   HOST_WIDE_INT count
     = estimated_poly_value (LOOP_VINFO_VECT_FACTOR (loop_vinfo));
   if (DR_GROUP_FIRST_ELEMENT (stmt_info))
-    count *= DR_GROUP_SIZE (vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info)));
+    count *= DR_GROUP_SIZE (DR_GROUP_FIRST_ELEMENT (stmt_info));
   return estimated_poly_value (gap) <= count * vect_get_scalar_dr_size (dr);
 }
 
@@ -3379,11 +3375,9 @@  vect_prune_runtime_alias_test_list (loop
       int comp_res;
       poly_uint64 lower_bound;
       struct data_reference *dr_a, *dr_b;
-      gimple *dr_group_first_a, *dr_group_first_b;
       tree segment_length_a, segment_length_b;
       unsigned HOST_WIDE_INT access_size_a, access_size_b;
       unsigned int align_a, align_b;
-      gimple *stmt_a, *stmt_b;
 
       /* Ignore the alias if the VF we chose ended up being no greater
 	 than the dependence distance.  */
@@ -3409,15 +3403,15 @@  vect_prune_runtime_alias_test_list (loop
 	}
 
       dr_a = DDR_A (ddr);
-      stmt_a = vect_dr_stmt (DDR_A (ddr));
+      stmt_vec_info stmt_info_a = vect_dr_stmt (DDR_A (ddr));
 
       dr_b = DDR_B (ddr);
-      stmt_b = vect_dr_stmt (DDR_B (ddr));
+      stmt_vec_info stmt_info_b = vect_dr_stmt (DDR_B (ddr));
 
       /* Skip the pair if inter-iteration dependencies are irrelevant
 	 and intra-iteration dependencies are guaranteed to be honored.  */
       if (ignore_step_p
-	  && (vect_preserves_scalar_order_p (stmt_a, stmt_b)
+	  && (vect_preserves_scalar_order_p (stmt_info_a, stmt_info_b)
 	      || vectorizable_with_step_bound_p (dr_a, dr_b, &lower_bound)))
 	{
 	  if (dump_enabled_p ())
@@ -3468,18 +3462,18 @@  vect_prune_runtime_alias_test_list (loop
 	  continue;
 	}
 
-      dr_group_first_a = DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt_a));
+      stmt_vec_info dr_group_first_a = DR_GROUP_FIRST_ELEMENT (stmt_info_a);
       if (dr_group_first_a)
 	{
-	  stmt_a = dr_group_first_a;
-	  dr_a = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt_a));
+	  stmt_info_a = dr_group_first_a;
+	  dr_a = STMT_VINFO_DATA_REF (stmt_info_a);
 	}
 
-      dr_group_first_b = DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt_b));
+      stmt_vec_info dr_group_first_b = DR_GROUP_FIRST_ELEMENT (stmt_info_b);
       if (dr_group_first_b)
 	{
-	  stmt_b = dr_group_first_b;
-	  dr_b = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt_b));
+	  stmt_info_b = dr_group_first_b;
+	  dr_b = STMT_VINFO_DATA_REF (stmt_info_b);
 	}
 
       if (ignore_step_p)
@@ -4734,10 +4728,9 @@  vect_create_data_ref_ptr (gimple *stmt,
   /* Likewise for any of the data references in the stmt group.  */
   else if (DR_GROUP_SIZE (stmt_info) > 1)
     {
-      gimple *orig_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
+      stmt_vec_info sinfo = DR_GROUP_FIRST_ELEMENT (stmt_info);
       do
 	{
-	  stmt_vec_info sinfo = vinfo_for_stmt (orig_stmt);
 	  struct data_reference *sdr = STMT_VINFO_DATA_REF (sinfo);
 	  if (!alias_sets_conflict_p (get_alias_set (aggr_type),
 				      get_alias_set (DR_REF (sdr))))
@@ -4745,9 +4738,9 @@  vect_create_data_ref_ptr (gimple *stmt,
 	      need_ref_all = true;
 	      break;
 	    }
-	  orig_stmt = DR_GROUP_NEXT_ELEMENT (sinfo);
+	  sinfo = DR_GROUP_NEXT_ELEMENT (sinfo);
 	}
-      while (orig_stmt);
+      while (sinfo);
     }
   aggr_ptr_type = build_pointer_type_for_mode (aggr_type, ptr_mode,
 					       need_ref_all);
@@ -6345,19 +6338,18 @@  vect_record_grouped_load_vectors (gimple
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   vec_info *vinfo = stmt_info->vinfo;
-  gimple *first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-  gimple *next_stmt;
+  stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
   unsigned int i, gap_count;
   tree tmp_data_ref;
 
   /* Put a permuted data-ref in the VECTORIZED_STMT field.
      Since we scan the chain starting from it's first node, their order
      corresponds the order of data-refs in RESULT_CHAIN.  */
-  next_stmt = first_stmt;
+  stmt_vec_info next_stmt_info = first_stmt_info;
   gap_count = 1;
   FOR_EACH_VEC_ELT (result_chain, i, tmp_data_ref)
     {
-      if (!next_stmt)
+      if (!next_stmt_info)
 	break;
 
       /* Skip the gaps.  Loads created for the gaps will be removed by dead
@@ -6366,27 +6358,27 @@  vect_record_grouped_load_vectors (gimple
        DR_GROUP_GAP is the number of steps in elements from the previous
        access (if there is no gap DR_GROUP_GAP is 1).  We skip loads that
        correspond to the gaps.  */
-      if (next_stmt != first_stmt
-          && gap_count < DR_GROUP_GAP (vinfo_for_stmt (next_stmt)))
+      if (next_stmt_info != first_stmt_info
+	  && gap_count < DR_GROUP_GAP (next_stmt_info))
       {
         gap_count++;
         continue;
       }
 
-      while (next_stmt)
+      while (next_stmt_info)
         {
 	  stmt_vec_info new_stmt_info = vinfo->lookup_def (tmp_data_ref);
 	  /* We assume that if VEC_STMT is not NULL, this is a case of multiple
 	     copies, and we put the new vector statement in the first available
 	     RELATED_STMT.  */
-	  if (!STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)))
-	    STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt)) = new_stmt_info;
+	  if (!STMT_VINFO_VEC_STMT (next_stmt_info))
+	    STMT_VINFO_VEC_STMT (next_stmt_info) = new_stmt_info;
 	  else
             {
-              if (!DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next_stmt)))
+	      if (!DR_GROUP_SAME_DR_STMT (next_stmt_info))
                 {
 		  stmt_vec_info prev_stmt_info
-		    = STMT_VINFO_VEC_STMT (vinfo_for_stmt (next_stmt));
+		    = STMT_VINFO_VEC_STMT (next_stmt_info);
 		  stmt_vec_info rel_stmt_info
 		    = STMT_VINFO_RELATED_STMT (prev_stmt_info);
 		  while (rel_stmt_info)
@@ -6399,12 +6391,12 @@  vect_record_grouped_load_vectors (gimple
                 }
             }
 
-	  next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
+	  next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
 	  gap_count = 1;
-	  /* If NEXT_STMT accesses the same DR as the previous statement,
+	  /* If NEXT_STMT_INFO accesses the same DR as the previous statement,
 	     put the same TMP_DATA_REF as its vectorized statement; otherwise
 	     get the next data-ref from RESULT_CHAIN.  */
-	  if (!next_stmt || !DR_GROUP_SAME_DR_STMT (vinfo_for_stmt (next_stmt)))
+	  if (!next_stmt_info || !DR_GROUP_SAME_DR_STMT (next_stmt_info))
 	    break;
         }
     }
@@ -6545,8 +6537,8 @@  vect_supportable_dr_alignment (struct da
 	  if (loop_vinfo
 	      && STMT_SLP_TYPE (stmt_info)
 	      && !multiple_p (LOOP_VINFO_VECT_FACTOR (loop_vinfo)
-			      * DR_GROUP_SIZE (vinfo_for_stmt
-					    (DR_GROUP_FIRST_ELEMENT (stmt_info))),
+			      * (DR_GROUP_SIZE
+				 (DR_GROUP_FIRST_ELEMENT (stmt_info))),
 			      TYPE_VECTOR_SUBPARTS (vectype)))
 	    ;
 	  else if (!loop_vinfo
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c	2018-07-24 10:23:04.033010396 +0100
+++ gcc/tree-vect-loop.c	2018-07-24 10:23:08.532970436 +0100
@@ -661,14 +661,14 @@  vect_fixup_reduc_chain (gimple *stmt)
   REDUC_GROUP_SIZE (firstp) = REDUC_GROUP_SIZE (stmt_info);
   do
     {
-      stmtp = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt));
+      stmtp = STMT_VINFO_RELATED_STMT (stmt_info);
       REDUC_GROUP_FIRST_ELEMENT (stmtp) = firstp;
-      stmt = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));
-      if (stmt)
+      stmt_info = REDUC_GROUP_NEXT_ELEMENT (stmt_info);
+      if (stmt_info)
 	REDUC_GROUP_NEXT_ELEMENT (stmtp)
-	  = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt));
+	  = STMT_VINFO_RELATED_STMT (stmt_info);
     }
-  while (stmt);
+  while (stmt_info);
   STMT_VINFO_DEF_TYPE (stmtp) = vect_reduction_def;
 }
 
@@ -683,12 +683,12 @@  vect_fixup_scalar_cycles_with_patterns (
   FOR_EACH_VEC_ELT (LOOP_VINFO_REDUCTION_CHAINS (loop_vinfo), i, first)
     if (STMT_VINFO_IN_PATTERN_P (vinfo_for_stmt (first)))
       {
-	gimple *next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first));
+	stmt_vec_info next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first));
 	while (next)
 	  {
-	    if (! STMT_VINFO_IN_PATTERN_P (vinfo_for_stmt (next)))
+	    if (! STMT_VINFO_IN_PATTERN_P (next))
 	      break;
-	    next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next));
+	    next = REDUC_GROUP_NEXT_ELEMENT (next);
 	  }
 	/* If not all stmt in the chain are patterns try to handle
 	   the chain without patterns.  */
@@ -2188,7 +2188,7 @@  vect_analyze_loop_2 (loop_vec_info loop_
       vinfo = SLP_TREE_SCALAR_STMTS (SLP_INSTANCE_TREE (instance))[0];
       if (! STMT_VINFO_GROUPED_ACCESS (vinfo))
 	continue;
-      vinfo = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (vinfo));
+      vinfo = DR_GROUP_FIRST_ELEMENT (vinfo);
       unsigned int size = DR_GROUP_SIZE (vinfo);
       tree vectype = STMT_VINFO_VECTYPE (vinfo);
       if (! vect_store_lanes_supported (vectype, size, false)
@@ -2198,7 +2198,7 @@  vect_analyze_loop_2 (loop_vec_info loop_
       FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (instance), j, node)
 	{
 	  vinfo = SLP_TREE_SCALAR_STMTS (node)[0];
-	  vinfo = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (vinfo));
+	  vinfo = DR_GROUP_FIRST_ELEMENT (vinfo);
 	  bool single_element_p = !DR_GROUP_NEXT_ELEMENT (vinfo);
 	  size = DR_GROUP_SIZE (vinfo);
 	  vectype = STMT_VINFO_VECTYPE (vinfo);
@@ -2527,7 +2527,7 @@  vect_is_slp_reduction (loop_vec_info loo
   struct loop *loop = (gimple_bb (phi))->loop_father;
   struct loop *vect_loop = LOOP_VINFO_LOOP (loop_info);
   enum tree_code code;
-  gimple *loop_use_stmt = NULL, *first, *next_stmt;
+  gimple *loop_use_stmt = NULL;
   stmt_vec_info use_stmt_info, current_stmt_info = NULL;
   tree lhs;
   imm_use_iterator imm_iter;
@@ -2592,12 +2592,12 @@  vect_is_slp_reduction (loop_vec_info loo
       use_stmt_info = loop_info->lookup_stmt (loop_use_stmt);
       if (current_stmt_info)
         {
-	  REDUC_GROUP_NEXT_ELEMENT (current_stmt_info) = loop_use_stmt;
+	  REDUC_GROUP_NEXT_ELEMENT (current_stmt_info) = use_stmt_info;
           REDUC_GROUP_FIRST_ELEMENT (use_stmt_info)
             = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);
         }
       else
-	REDUC_GROUP_FIRST_ELEMENT (use_stmt_info) = loop_use_stmt;
+	REDUC_GROUP_FIRST_ELEMENT (use_stmt_info) = use_stmt_info;
 
       lhs = gimple_assign_lhs (loop_use_stmt);
       current_stmt_info = use_stmt_info;
@@ -2610,9 +2610,10 @@  vect_is_slp_reduction (loop_vec_info loo
   /* Swap the operands, if needed, to make the reduction operand be the second
      operand.  */
   lhs = PHI_RESULT (phi);
-  next_stmt = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);
-  while (next_stmt)
+  stmt_vec_info next_stmt_info = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);
+  while (next_stmt_info)
     {
+      gassign *next_stmt = as_a <gassign *> (next_stmt_info->stmt);
       if (gimple_assign_rhs2 (next_stmt) == lhs)
 	{
 	  tree op = gimple_assign_rhs1 (next_stmt);
@@ -2626,7 +2627,7 @@  vect_is_slp_reduction (loop_vec_info loo
 	      && 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));
+	      next_stmt_info = REDUC_GROUP_NEXT_ELEMENT (next_stmt_info);
  	      continue;
 	    }
 
@@ -2663,13 +2664,14 @@  vect_is_slp_reduction (loop_vec_info loo
         }
 
       lhs = gimple_assign_lhs (next_stmt);
-      next_stmt = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
+      next_stmt_info = REDUC_GROUP_NEXT_ELEMENT (next_stmt_info);
     }
 
   /* Save the chain for further analysis in SLP detection.  */
-  first = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);
-  LOOP_VINFO_REDUCTION_CHAINS (loop_info).safe_push (first);
-  REDUC_GROUP_SIZE (vinfo_for_stmt (first)) = size;
+  stmt_vec_info first_stmt_info
+    = REDUC_GROUP_FIRST_ELEMENT (current_stmt_info);
+  LOOP_VINFO_REDUCTION_CHAINS (loop_info).safe_push (first_stmt_info);
+  REDUC_GROUP_SIZE (first_stmt_info) = size;
 
   return true;
 }
@@ -3254,12 +3256,12 @@  vect_is_simple_reduction (loop_vec_info
     }
 
   /* Dissolve group eventually half-built by vect_is_slp_reduction.  */
-  gimple *first = REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (def_stmt));
+  stmt_vec_info first = REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (def_stmt));
   while (first)
     {
-      gimple *next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first));
-      REDUC_GROUP_FIRST_ELEMENT (vinfo_for_stmt (first)) = NULL;
-      REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first)) = NULL;
+      stmt_vec_info next = REDUC_GROUP_NEXT_ELEMENT (first);
+      REDUC_GROUP_FIRST_ELEMENT (first) = NULL;
+      REDUC_GROUP_NEXT_ELEMENT (first) = NULL;
       first = next;
     }
 
@@ -6130,7 +6132,8 @@  vectorizable_reduction (gimple *stmt, gi
     }
 
   if (REDUC_GROUP_FIRST_ELEMENT (stmt_info))
-    gcc_assert (slp_node && REDUC_GROUP_FIRST_ELEMENT (stmt_info) == stmt);
+    gcc_assert (slp_node
+		&& REDUC_GROUP_FIRST_ELEMENT (stmt_info) == stmt_info);
 
   if (gimple_code (stmt) == GIMPLE_PHI)
     {
@@ -6784,8 +6787,8 @@  vectorizable_reduction (gimple *stmt, gi
   tree neutral_op = NULL_TREE;
   if (slp_node)
     neutral_op = neutral_op_for_slp_reduction
-		   (slp_node_instance->reduc_phis, code,
-		    REDUC_GROUP_FIRST_ELEMENT (stmt_info) != NULL);
+      (slp_node_instance->reduc_phis, code,
+       REDUC_GROUP_FIRST_ELEMENT (stmt_info) != NULL_STMT_VEC_INFO);
 
   if (double_reduc && reduction_type == FOLD_LEFT_REDUCTION)
     {
Index: gcc/tree-vect-patterns.c
===================================================================
--- gcc/tree-vect-patterns.c	2018-07-24 10:22:57.277070390 +0100
+++ gcc/tree-vect-patterns.c	2018-07-24 10:23:08.536970400 +0100
@@ -820,7 +820,7 @@  vect_reassociating_reduction_p (stmt_vec
 {
   return (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_reduction_def
 	  ? STMT_VINFO_REDUC_TYPE (stmt_vinfo) != FOLD_LEFT_REDUCTION
-	  : REDUC_GROUP_FIRST_ELEMENT (stmt_vinfo) != NULL);
+	  : REDUC_GROUP_FIRST_ELEMENT (stmt_vinfo) != NULL_STMT_VEC_INFO);
 }
 
 /* As above, but also require it to have code CODE and to be a reduction
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c	2018-07-24 10:23:00.401042649 +0100
+++ gcc/tree-vect-slp.c	2018-07-24 10:23:08.536970400 +0100
@@ -712,7 +712,7 @@  vect_build_slp_tree_1 (vec_info *vinfo,
   int icode;
   machine_mode optab_op2_mode;
   machine_mode vec_mode;
-  gimple *first_load = NULL, *prev_first_load = NULL;
+  stmt_vec_info first_load = NULL, prev_first_load = NULL;
 
   /* For every stmt in NODE find its def stmt/s.  */
   stmt_vec_info stmt_info;
@@ -1692,8 +1692,7 @@  vect_attempt_slp_rearrange_stmts (slp_in
   FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (slp_instn), i, node)
     {
       stmt_vec_info first_stmt_info = SLP_TREE_SCALAR_STMTS (node)[0];
-      first_stmt_info
-	= vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (first_stmt_info));
+      first_stmt_info = DR_GROUP_FIRST_ELEMENT (first_stmt_info);
       /* But we have to keep those permutations that are required because
          of handling of gaps.  */
       if (known_eq (unrolling_factor, 1U)
@@ -1717,7 +1716,6 @@  vect_supported_load_permutation_p (slp_i
   unsigned int group_size = SLP_INSTANCE_GROUP_SIZE (slp_instn);
   unsigned int i, j, k, next;
   slp_tree node;
-  gimple *next_load;
 
   if (dump_enabled_p ())
     {
@@ -1766,26 +1764,25 @@  vect_supported_load_permutation_p (slp_i
 	  if (!SLP_TREE_LOAD_PERMUTATION (node).exists ())
 	    continue;
 	  bool subchain_p = true;
-          next_load = NULL;
+	  stmt_vec_info next_load_info = NULL;
 	  stmt_vec_info load_info;
 	  FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), j, load_info)
 	    {
 	      if (j != 0
-		  && (next_load != load_info
+		  && (next_load_info != load_info
 		      || DR_GROUP_GAP (load_info) != 1))
 		{
 		  subchain_p = false;
 		  break;
 		}
-	      next_load = DR_GROUP_NEXT_ELEMENT (load_info);
+	      next_load_info = DR_GROUP_NEXT_ELEMENT (load_info);
 	    }
 	  if (subchain_p)
 	    SLP_TREE_LOAD_PERMUTATION (node).release ();
 	  else
 	    {
 	      stmt_vec_info group_info = SLP_TREE_SCALAR_STMTS (node)[0];
-	      group_info
-		= vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (group_info));
+	      group_info = DR_GROUP_FIRST_ELEMENT (group_info);
 	      unsigned HOST_WIDE_INT nunits;
 	      unsigned k, maxk = 0;
 	      FOR_EACH_VEC_ELT (SLP_TREE_LOAD_PERMUTATION (node), j, k)
@@ -1868,33 +1865,33 @@  vect_find_last_scalar_stmt_in_slp (slp_t
 vect_split_slp_store_group (gimple *first_stmt, unsigned group1_size)
 {
   stmt_vec_info first_vinfo = vinfo_for_stmt (first_stmt);
-  gcc_assert (DR_GROUP_FIRST_ELEMENT (first_vinfo) == first_stmt);
+  gcc_assert (DR_GROUP_FIRST_ELEMENT (first_vinfo) == first_vinfo);
   gcc_assert (group1_size > 0);
   int group2_size = DR_GROUP_SIZE (first_vinfo) - group1_size;
   gcc_assert (group2_size > 0);
   DR_GROUP_SIZE (first_vinfo) = group1_size;
 
-  gimple *stmt = first_stmt;
+  stmt_vec_info stmt_info = first_vinfo;
   for (unsigned i = group1_size; i > 1; i--)
     {
-      stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));
-      gcc_assert (DR_GROUP_GAP (vinfo_for_stmt (stmt)) == 1);
+      stmt_info = DR_GROUP_NEXT_ELEMENT (stmt_info);
+      gcc_assert (DR_GROUP_GAP (stmt_info) == 1);
     }
   /* STMT is now the last element of the first group.  */
-  gimple *group2 = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt));
-  DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt)) = 0;
+  stmt_vec_info group2 = DR_GROUP_NEXT_ELEMENT (stmt_info);
+  DR_GROUP_NEXT_ELEMENT (stmt_info) = 0;
 
-  DR_GROUP_SIZE (vinfo_for_stmt (group2)) = group2_size;
-  for (stmt = group2; stmt; stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (stmt)))
+  DR_GROUP_SIZE (group2) = group2_size;
+  for (stmt_info = group2; stmt_info;
+       stmt_info = DR_GROUP_NEXT_ELEMENT (stmt_info))
     {
-      DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) = group2;
-      gcc_assert (DR_GROUP_GAP (vinfo_for_stmt (stmt)) == 1);
+      DR_GROUP_FIRST_ELEMENT (stmt_info) = group2;
+      gcc_assert (DR_GROUP_GAP (stmt_info) == 1);
     }
 
   /* For the second group, the DR_GROUP_GAP is that before the original group,
      plus skipping over the first vector.  */
-  DR_GROUP_GAP (vinfo_for_stmt (group2))
-    = DR_GROUP_GAP (first_vinfo) + group1_size;
+  DR_GROUP_GAP (group2) = DR_GROUP_GAP (first_vinfo) + group1_size;
 
   /* DR_GROUP_GAP of the first group now has to skip over the second group too.  */
   DR_GROUP_GAP (first_vinfo) += group2_size;
@@ -1928,8 +1925,6 @@  vect_analyze_slp_instance (vec_info *vin
   slp_tree node;
   unsigned int group_size;
   tree vectype, scalar_type = NULL_TREE;
-  gimple *next;
-  stmt_vec_info next_info;
   unsigned int i;
   vec<slp_tree> loads;
   struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info);
@@ -1970,34 +1965,32 @@  vect_analyze_slp_instance (vec_info *vin
 
   /* Create a node (a root of the SLP tree) for the packed grouped stores.  */
   scalar_stmts.create (group_size);
-  next = stmt;
+  stmt_vec_info next_info = stmt_info;
   if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
     {
       /* Collect the stores and store them in SLP_TREE_SCALAR_STMTS.  */
-      while (next)
+      while (next_info)
         {
-	  next_info = vinfo_for_stmt (next);
 	  if (STMT_VINFO_IN_PATTERN_P (next_info)
 	      && STMT_VINFO_RELATED_STMT (next_info))
 	    scalar_stmts.safe_push (STMT_VINFO_RELATED_STMT (next_info));
 	  else
 	    scalar_stmts.safe_push (next_info);
-          next = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next));
+	  next_info = DR_GROUP_NEXT_ELEMENT (next_info);
         }
     }
   else if (!dr && REDUC_GROUP_FIRST_ELEMENT (stmt_info))
     {
       /* Collect the reduction stmts and store them in
 	 SLP_TREE_SCALAR_STMTS.  */
-      while (next)
+      while (next_info)
         {
-	  next_info = vinfo_for_stmt (next);
 	  if (STMT_VINFO_IN_PATTERN_P (next_info)
 	      && STMT_VINFO_RELATED_STMT (next_info))
 	    scalar_stmts.safe_push (STMT_VINFO_RELATED_STMT (next_info));
 	  else
 	    scalar_stmts.safe_push (next_info);
-          next = REDUC_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next));
+	  next_info = REDUC_GROUP_NEXT_ELEMENT (next_info);
         }
       /* Mark the first element of the reduction chain as reduction to properly
 	 transform the node.  In the reduction analysis phase only the last
@@ -2067,15 +2060,14 @@  vect_analyze_slp_instance (vec_info *vin
 	  vec<unsigned> load_permutation;
 	  int j;
 	  stmt_vec_info load_info;
-	  gimple *first_stmt;
 	  bool this_load_permuted = false;
 	  load_permutation.create (group_size);
-	  first_stmt = DR_GROUP_FIRST_ELEMENT
+	  stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT
 	    (SLP_TREE_SCALAR_STMTS (load_node)[0]);
 	  FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (load_node), j, load_info)
 	    {
 	      int load_place = vect_get_place_in_interleaving_chain
-		(load_info, first_stmt);
+		(load_info, first_stmt_info);
 	      gcc_assert (load_place != -1);
 	      if (load_place != j)
 		this_load_permuted = true;
@@ -2086,8 +2078,8 @@  vect_analyze_slp_instance (vec_info *vin
 	         a gap either because the group is larger than the SLP
 		 group-size or because there is a gap between the groups.  */
 	      && (known_eq (unrolling_factor, 1U)
-		  || (group_size == DR_GROUP_SIZE (vinfo_for_stmt (first_stmt))
-		      && DR_GROUP_GAP (vinfo_for_stmt (first_stmt)) == 0)))
+		  || (group_size == DR_GROUP_SIZE (first_stmt_info)
+		      && DR_GROUP_GAP (first_stmt_info) == 0)))
 	    {
 	      load_permutation.release ();
 	      continue;
@@ -2122,11 +2114,9 @@  vect_analyze_slp_instance (vec_info *vin
 	  slp_tree load_node;
 	  FOR_EACH_VEC_ELT (loads, i, load_node)
 	    {
-	      gimple *first_stmt = DR_GROUP_FIRST_ELEMENT
+	      stmt_vec_info stmt_vinfo = DR_GROUP_FIRST_ELEMENT
 		(SLP_TREE_SCALAR_STMTS (load_node)[0]);
-	      stmt_vec_info stmt_vinfo = vinfo_for_stmt (first_stmt);
-		  /* Use SLP for strided accesses (or if we
-		     can't load-lanes).  */
+	      /* Use SLP for strided accesses (or if we can't load-lanes).  */
 	      if (STMT_VINFO_STRIDED_P (stmt_vinfo)
 		  || ! vect_load_lanes_supported
 			(STMT_VINFO_VECTYPE (stmt_vinfo),
@@ -2230,11 +2220,11 @@  vect_analyze_slp (vec_info *vinfo, unsig
 					     max_tree_size))
 	      {
 		/* Dissolve reduction chain group.  */
-		gimple *next, *stmt = first_element;
+		gimple *stmt = first_element;
 		while (stmt)
 		  {
 		    stmt_vec_info vinfo = vinfo_for_stmt (stmt);
-		    next = REDUC_GROUP_NEXT_ELEMENT (vinfo);
+		    stmt_vec_info next = REDUC_GROUP_NEXT_ELEMENT (vinfo);
 		    REDUC_GROUP_FIRST_ELEMENT (vinfo) = NULL;
 		    REDUC_GROUP_NEXT_ELEMENT (vinfo) = NULL;
 		    stmt = next;
@@ -3698,7 +3688,7 @@  vect_transform_slp_perm_load (slp_tree n
   if (!STMT_VINFO_GROUPED_ACCESS (stmt_info))
     return false;
 
-  stmt_info = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info));
+  stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
 
   mode = TYPE_MODE (vectype);
 
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c	2018-07-24 10:23:00.401042649 +0100
+++ gcc/tree-vect-stmts.c	2018-07-24 10:23:08.536970400 +0100
@@ -978,7 +978,7 @@  vect_model_store_cost (stmt_vec_info stm
 		       stmt_vector_for_cost *cost_vec)
 {
   unsigned int inside_cost = 0, prologue_cost = 0;
-  gimple *first_stmt = STMT_VINFO_STMT (stmt_info);
+  stmt_vec_info first_stmt_info = stmt_info;
   bool grouped_access_p = STMT_VINFO_GROUPED_ACCESS (stmt_info);
 
   /* ???  Somehow we need to fix this at the callers.  */
@@ -998,12 +998,12 @@  vect_model_store_cost (stmt_vec_info stm
   /* Grouped stores update all elements in the group at once,
      so we want the DR for the first statement.  */
   if (!slp_node && grouped_access_p)
-    first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
+    first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
 
   /* True if we should include any once-per-group costs as well as
      the cost of the statement itself.  For SLP we only get called
      once per group anyhow.  */
-  bool first_stmt_p = (first_stmt == STMT_VINFO_STMT (stmt_info));
+  bool first_stmt_p = (first_stmt_info == stmt_info);
 
   /* We assume that the cost of a single store-lanes instruction is
      equivalent to the cost of DR_GROUP_SIZE separate stores.  If a grouped
@@ -1014,7 +1014,7 @@  vect_model_store_cost (stmt_vec_info stm
     {
       /* Uses a high and low interleave or shuffle operations for each
 	 needed permute.  */
-      int group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));
+      int group_size = DR_GROUP_SIZE (first_stmt_info);
       int nstmts = ncopies * ceil_log2 (group_size) * group_size;
       inside_cost = record_stmt_cost (cost_vec, nstmts, vec_perm,
 				      stmt_info, 0, vect_body);
@@ -1122,7 +1122,6 @@  vect_model_load_cost (stmt_vec_info stmt
 		      slp_tree slp_node,
 		      stmt_vector_for_cost *cost_vec)
 {
-  gimple *first_stmt = STMT_VINFO_STMT (stmt_info);
   unsigned int inside_cost = 0, prologue_cost = 0;
   bool grouped_access_p = STMT_VINFO_GROUPED_ACCESS (stmt_info);
 
@@ -1136,28 +1135,27 @@  vect_model_load_cost (stmt_vec_info stmt
     {
       /* If the load is permuted then the alignment is determined by
 	 the first group element not by the first scalar stmt DR.  */
-      gimple *stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-      stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
+      stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
       /* Record the cost for the permutation.  */
       unsigned n_perms;
       unsigned assumed_nunits
-	= vect_nunits_for_cost (STMT_VINFO_VECTYPE (stmt_info));
+	= vect_nunits_for_cost (STMT_VINFO_VECTYPE (first_stmt_info));
       unsigned slp_vf = (ncopies * assumed_nunits) / instance->group_size; 
       vect_transform_slp_perm_load (slp_node, vNULL, NULL,
 				    slp_vf, instance, true,
 				    &n_perms);
       inside_cost += record_stmt_cost (cost_vec, n_perms, vec_perm,
-				       stmt_info, 0, vect_body);
+				       first_stmt_info, 0, vect_body);
       /* And adjust the number of loads performed.  This handles
 	 redundancies as well as loads that are later dead.  */
-      auto_sbitmap perm (DR_GROUP_SIZE (stmt_info));
+      auto_sbitmap perm (DR_GROUP_SIZE (first_stmt_info));
       bitmap_clear (perm);
       for (unsigned i = 0;
 	   i < SLP_TREE_LOAD_PERMUTATION (slp_node).length (); ++i)
 	bitmap_set_bit (perm, SLP_TREE_LOAD_PERMUTATION (slp_node)[i]);
       ncopies = 0;
       bool load_seen = false;
-      for (unsigned i = 0; i < DR_GROUP_SIZE (stmt_info); ++i)
+      for (unsigned i = 0; i < DR_GROUP_SIZE (first_stmt_info); ++i)
 	{
 	  if (i % assumed_nunits == 0)
 	    {
@@ -1171,19 +1169,21 @@  vect_model_load_cost (stmt_vec_info stmt
       if (load_seen)
 	ncopies++;
       gcc_assert (ncopies
-		  <= (DR_GROUP_SIZE (stmt_info) - DR_GROUP_GAP (stmt_info)
+		  <= (DR_GROUP_SIZE (first_stmt_info)
+		      - DR_GROUP_GAP (first_stmt_info)
 		      + assumed_nunits - 1) / assumed_nunits);
     }
 
   /* Grouped loads read all elements in the group at once,
      so we want the DR for the first statement.  */
+  stmt_vec_info first_stmt_info = stmt_info;
   if (!slp_node && grouped_access_p)
-    first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
+    first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
 
   /* True if we should include any once-per-group costs as well as
      the cost of the statement itself.  For SLP we only get called
      once per group anyhow.  */
-  bool first_stmt_p = (first_stmt == STMT_VINFO_STMT (stmt_info));
+  bool first_stmt_p = (first_stmt_info == stmt_info);
 
   /* We assume that the cost of a single load-lanes instruction is
      equivalent to the cost of DR_GROUP_SIZE separate loads.  If a grouped
@@ -1194,7 +1194,7 @@  vect_model_load_cost (stmt_vec_info stmt
     {
       /* Uses an even and odd extract operations or shuffle operations
 	 for each needed permute.  */
-      int group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));
+      int group_size = DR_GROUP_SIZE (first_stmt_info);
       int nstmts = ncopies * ceil_log2 (group_size) * group_size;
       inside_cost += record_stmt_cost (cost_vec, nstmts, vec_perm,
 				       stmt_info, 0, vect_body);
@@ -2183,12 +2183,12 @@  get_group_load_store_type (gimple *stmt,
   vec_info *vinfo = stmt_info->vinfo;
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
   struct loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo) : NULL;
-  gimple *first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-  data_reference *first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));
-  unsigned int group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));
-  bool single_element_p = (stmt == first_stmt
+  stmt_vec_info first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
+  data_reference *first_dr = STMT_VINFO_DATA_REF (first_stmt_info);
+  unsigned int group_size = DR_GROUP_SIZE (first_stmt_info);
+  bool single_element_p = (stmt_info == first_stmt_info
 			   && !DR_GROUP_NEXT_ELEMENT (stmt_info));
-  unsigned HOST_WIDE_INT gap = DR_GROUP_GAP (vinfo_for_stmt (first_stmt));
+  unsigned HOST_WIDE_INT gap = DR_GROUP_GAP (first_stmt_info);
   poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (vectype);
 
   /* True if the vectorized statements would access beyond the last
@@ -2315,14 +2315,14 @@  get_group_load_store_type (gimple *stmt,
 	*memory_access_type = VMAT_GATHER_SCATTER;
     }
 
-  if (vls_type != VLS_LOAD && first_stmt == stmt)
+  if (vls_type != VLS_LOAD && first_stmt_info == stmt_info)
     {
       /* STMT is the leader of the group. Check the operands of all the
 	 stmts of the group.  */
-      gimple *next_stmt = DR_GROUP_NEXT_ELEMENT (stmt_info);
-      while (next_stmt)
+      stmt_vec_info next_stmt_info = DR_GROUP_NEXT_ELEMENT (stmt_info);
+      while (next_stmt_info)
 	{
-	  tree op = vect_get_store_rhs (next_stmt);
+	  tree op = vect_get_store_rhs (next_stmt_info);
 	  enum vect_def_type dt;
 	  if (!vect_is_simple_use (op, vinfo, &dt))
 	    {
@@ -2331,7 +2331,7 @@  get_group_load_store_type (gimple *stmt,
 				 "use not simple.\n");
 	      return false;
 	    }
-	  next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
+	  next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
 	}
     }
 
@@ -2482,7 +2482,7 @@  get_load_store_type (gimple *stmt, tree
      traditional behavior until that can be fixed.  */
   if (*memory_access_type == VMAT_ELEMENTWISE
       && !STMT_VINFO_STRIDED_P (stmt_info)
-      && !(stmt == DR_GROUP_FIRST_ELEMENT (stmt_info)
+      && !(stmt_info == DR_GROUP_FIRST_ELEMENT (stmt_info)
 	   && !DR_GROUP_NEXT_ELEMENT (stmt_info)
 	   && !pow2p_hwi (DR_GROUP_SIZE (stmt_info))))
     {
@@ -6195,13 +6195,13 @@  ensure_base_align (struct data_reference
 get_group_alias_ptr_type (gimple *first_stmt)
 {
   struct data_reference *first_dr, *next_dr;
-  gimple *next_stmt;
 
   first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));
-  next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first_stmt));
-  while (next_stmt)
+  stmt_vec_info next_stmt_info
+    = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (first_stmt));
+  while (next_stmt_info)
     {
-      next_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (next_stmt));
+      next_dr = STMT_VINFO_DATA_REF (next_stmt_info);
       if (get_alias_set (DR_REF (first_dr))
 	  != get_alias_set (DR_REF (next_dr)))
 	{
@@ -6210,7 +6210,7 @@  get_group_alias_ptr_type (gimple *first_
 			     "conflicting alias set types.\n");
 	  return ptr_type_node;
 	}
-      next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
+      next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
     }
   return reference_alias_ptr_type (DR_REF (first_dr));
 }
@@ -6248,7 +6248,7 @@  vectorizable_store (gimple *stmt, gimple
   gimple *ptr_incr = NULL;
   int ncopies;
   int j;
-  gimple *next_stmt, *first_stmt;
+  stmt_vec_info first_stmt_info;
   bool grouped_store;
   unsigned int group_size, i;
   vec<tree> oprnds = vNULL;
@@ -6400,13 +6400,13 @@  vectorizable_store (gimple *stmt, gimple
 		   && (slp || memory_access_type != VMAT_CONTIGUOUS));
   if (grouped_store)
     {
-      first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-      first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));
-      group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));
+      first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
+      first_dr = STMT_VINFO_DATA_REF (first_stmt_info);
+      group_size = DR_GROUP_SIZE (first_stmt_info);
     }
   else
     {
-      first_stmt = stmt;
+      first_stmt_info = stmt_info;
       first_dr = dr;
       group_size = vec_num = 1;
     }
@@ -6584,10 +6584,7 @@  vectorizable_store (gimple *stmt, gimple
     }
 
   if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
-    {
-      gimple *group_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-      DR_GROUP_STORE_COUNT (vinfo_for_stmt (group_stmt))++;
-    }
+    DR_GROUP_STORE_COUNT (DR_GROUP_FIRST_ELEMENT (stmt_info))++;
 
   if (grouped_store)
     {
@@ -6596,8 +6593,8 @@  vectorizable_store (gimple *stmt, gimple
 
       /* We vectorize all the stmts of the interleaving group when we
 	 reach the last stmt in the group.  */
-      if (DR_GROUP_STORE_COUNT (vinfo_for_stmt (first_stmt))
-	  < DR_GROUP_SIZE (vinfo_for_stmt (first_stmt))
+      if (DR_GROUP_STORE_COUNT (first_stmt_info)
+	  < DR_GROUP_SIZE (first_stmt_info)
 	  && !slp)
 	{
 	  *vec_stmt = NULL;
@@ -6610,17 +6607,18 @@  vectorizable_store (gimple *stmt, gimple
           /* VEC_NUM is the number of vect stmts to be created for this 
              group.  */
           vec_num = SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node);
-          first_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[0]; 
-	  gcc_assert (DR_GROUP_FIRST_ELEMENT (vinfo_for_stmt (first_stmt)) == first_stmt);
-          first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));
-	  op = vect_get_store_rhs (first_stmt);
+	  first_stmt_info = SLP_TREE_SCALAR_STMTS (slp_node)[0];
+	  gcc_assert (DR_GROUP_FIRST_ELEMENT (first_stmt_info)
+		      == first_stmt_info);
+	  first_dr = STMT_VINFO_DATA_REF (first_stmt_info);
+	  op = vect_get_store_rhs (first_stmt_info);
         } 
       else
         /* VEC_NUM is the number of vect stmts to be created for this 
            group.  */
 	vec_num = group_size;
 
-      ref_type = get_group_alias_ptr_type (first_stmt);
+      ref_type = get_group_alias_ptr_type (first_stmt_info);
     }
   else
     ref_type = reference_alias_ptr_type (DR_REF (first_dr));
@@ -6759,7 +6757,7 @@  vectorizable_store (gimple *stmt, gimple
 
       prev_stmt_info = NULL;
       alias_off = build_int_cst (ref_type, 0);
-      next_stmt = first_stmt;
+      stmt_vec_info next_stmt_info = first_stmt_info;
       for (g = 0; g < group_size; g++)
 	{
 	  running_off = offvar;
@@ -6780,7 +6778,7 @@  vectorizable_store (gimple *stmt, gimple
 	  for (j = 0; j < ncopies; j++)
 	    {
 	      /* We've set op and dt above, from vect_get_store_rhs,
-		 and first_stmt == stmt.  */
+		 and first_stmt_info == stmt_info.  */
 	      if (j == 0)
 		{
 		  if (slp)
@@ -6791,8 +6789,9 @@  vectorizable_store (gimple *stmt, gimple
 		    }
 		  else
 		    {
-		      op = vect_get_store_rhs (next_stmt);
-		      vec_oprnd = vect_get_vec_def_for_operand (op, next_stmt);
+		      op = vect_get_store_rhs (next_stmt_info);
+		      vec_oprnd = vect_get_vec_def_for_operand
+			(op, next_stmt_info);
 		    }
 		}
 	      else
@@ -6866,7 +6865,7 @@  vectorizable_store (gimple *stmt, gimple
 		    }
 		}
 	    }
-	  next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
+	  next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
 	  if (slp)
 	    break;
 	}
@@ -6985,19 +6984,20 @@  vectorizable_store (gimple *stmt, gimple
 
 		 If the store is not grouped, DR_GROUP_SIZE is 1, and DR_CHAIN and
 		 OPRNDS are of size 1.  */
-	      next_stmt = first_stmt;
+	      stmt_vec_info next_stmt_info = first_stmt_info;
 	      for (i = 0; i < group_size; i++)
 		{
 		  /* Since gaps are not supported for interleaved stores,
 		     DR_GROUP_SIZE is the exact number of stmts in the chain.
-		     Therefore, NEXT_STMT can't be NULL_TREE.  In case that
-		     there is no interleaving, DR_GROUP_SIZE is 1, and only one
-		     iteration of the loop will be executed.  */
-		  op = vect_get_store_rhs (next_stmt);
-		  vec_oprnd = vect_get_vec_def_for_operand (op, next_stmt);
+		     Therefore, NEXT_STMT_INFO can't be NULL_TREE.  In case
+		     that there is no interleaving, DR_GROUP_SIZE is 1,
+		     and only one iteration of the loop will be executed.  */
+		  op = vect_get_store_rhs (next_stmt_info);
+		  vec_oprnd = vect_get_vec_def_for_operand
+		    (op, next_stmt_info);
 		  dr_chain.quick_push (vec_oprnd);
 		  oprnds.quick_push (vec_oprnd);
-		  next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
+		  next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
 		}
 	      if (mask)
 		vec_mask = vect_get_vec_def_for_operand (mask, stmt,
@@ -7029,7 +7029,7 @@  vectorizable_store (gimple *stmt, gimple
 	    }
 	  else
 	    dataref_ptr
-	      = vect_create_data_ref_ptr (first_stmt, aggr_type,
+	      = vect_create_data_ref_ptr (first_stmt_info, aggr_type,
 					  simd_lane_access_p ? loop : NULL,
 					  offset, &dummy, gsi, &ptr_incr,
 					  simd_lane_access_p, &inv_p,
@@ -7132,7 +7132,7 @@  vectorizable_store (gimple *stmt, gimple
 					&result_chain);
 	    }
 
-	  next_stmt = first_stmt;
+	  stmt_vec_info next_stmt_info = first_stmt_info;
 	  for (i = 0; i < vec_num; i++)
 	    {
 	      unsigned align, misalign;
@@ -7249,8 +7249,8 @@  vectorizable_store (gimple *stmt, gimple
 	      if (slp)
 		continue;
 
-	      next_stmt = DR_GROUP_NEXT_ELEMENT (vinfo_for_stmt (next_stmt));
-	      if (!next_stmt)
+	      next_stmt_info = DR_GROUP_NEXT_ELEMENT (next_stmt_info);
+	      if (!next_stmt_info)
 		break;
 	    }
 	}
@@ -7423,7 +7423,7 @@  vectorizable_load (gimple *stmt, gimple_
   gphi *phi = NULL;
   vec<tree> dr_chain = vNULL;
   bool grouped_load = false;
-  gimple *first_stmt;
+  stmt_vec_info first_stmt_info;
   stmt_vec_info first_stmt_info_for_drptr = NULL;
   bool inv_p;
   bool compute_in_loop = false;
@@ -7565,8 +7565,8 @@  vectorizable_load (gimple *stmt, gimple_
       gcc_assert (!nested_in_vect_loop);
       gcc_assert (!STMT_VINFO_GATHER_SCATTER_P (stmt_info));
 
-      first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-      group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));
+      first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
+      group_size = DR_GROUP_SIZE (first_stmt_info);
 
       if (slp && SLP_TREE_LOAD_PERMUTATION (slp_node).exists ())
 	slp_perm = true;
@@ -7696,25 +7696,26 @@  vectorizable_load (gimple *stmt, gimple_
 
       if (grouped_load)
 	{
-	  first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-	  first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));
+	  first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
+	  first_dr = STMT_VINFO_DATA_REF (first_stmt_info);
 	}
       else
 	{
-	  first_stmt = stmt;
+	  first_stmt_info = stmt_info;
 	  first_dr = dr;
 	}
       if (slp && grouped_load)
 	{
-	  group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));
-	  ref_type = get_group_alias_ptr_type (first_stmt);
+	  group_size = DR_GROUP_SIZE (first_stmt_info);
+	  ref_type = get_group_alias_ptr_type (first_stmt_info);
 	}
       else
 	{
 	  if (grouped_load)
 	    cst_offset
 	      = (tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (vectype)))
-		 * vect_get_place_in_interleaving_chain (stmt, first_stmt));
+		 * vect_get_place_in_interleaving_chain (stmt,
+							 first_stmt_info));
 	  group_size = 1;
 	  ref_type = reference_alias_ptr_type (DR_REF (dr));
 	}
@@ -7924,19 +7925,19 @@  vectorizable_load (gimple *stmt, gimple_
 
   if (grouped_load)
     {
-      first_stmt = DR_GROUP_FIRST_ELEMENT (stmt_info);
-      group_size = DR_GROUP_SIZE (vinfo_for_stmt (first_stmt));
+      first_stmt_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
+      group_size = DR_GROUP_SIZE (first_stmt_info);
       /* For SLP vectorization we directly vectorize a subchain
          without permutation.  */
       if (slp && ! SLP_TREE_LOAD_PERMUTATION (slp_node).exists ())
-	first_stmt = SLP_TREE_SCALAR_STMTS (slp_node)[0];
+	first_stmt_info = SLP_TREE_SCALAR_STMTS (slp_node)[0];
       /* For BB vectorization always use the first stmt to base
 	 the data ref pointer on.  */
       if (bb_vinfo)
 	first_stmt_info_for_drptr = SLP_TREE_SCALAR_STMTS (slp_node)[0];
 
       /* Check if the chain of loads is already vectorized.  */
-      if (STMT_VINFO_VEC_STMT (vinfo_for_stmt (first_stmt))
+      if (STMT_VINFO_VEC_STMT (first_stmt_info)
 	  /* For SLP we would need to copy over SLP_TREE_VEC_STMTS.
 	     ???  But we can only do so if there is exactly one
 	     as we have no way to get at the rest.  Leave the CSE
@@ -7950,7 +7951,7 @@  vectorizable_load (gimple *stmt, gimple_
 	  *vec_stmt = STMT_VINFO_VEC_STMT (stmt_info);
 	  return true;
 	}
-      first_dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt));
+      first_dr = STMT_VINFO_DATA_REF (first_stmt_info);
       group_gap_adj = 0;
 
       /* VEC_NUM is the number of vect stmts to be created for this group.  */
@@ -7979,11 +7980,11 @@  vectorizable_load (gimple *stmt, gimple_
       else
 	vec_num = group_size;
 
-      ref_type = get_group_alias_ptr_type (first_stmt);
+      ref_type = get_group_alias_ptr_type (first_stmt_info);
     }
   else
     {
-      first_stmt = stmt;
+      first_stmt_info = stmt_info;
       first_dr = dr;
       group_size = vec_num = 1;
       group_gap_adj = 0;
@@ -8120,7 +8121,7 @@  vectorizable_load (gimple *stmt, gimple_
        || alignment_support_scheme == dr_explicit_realign)
       && !compute_in_loop)
     {
-      msq = vect_setup_realignment (first_stmt, gsi, &realignment_token,
+      msq = vect_setup_realignment (first_stmt_info, gsi, &realignment_token,
 				    alignment_support_scheme, NULL_TREE,
 				    &at_loop);
       if (alignment_support_scheme == dr_explicit_realign_optimized)
@@ -8184,7 +8185,7 @@  vectorizable_load (gimple *stmt, gimple_
 	      inv_p = false;
 	    }
 	  else if (first_stmt_info_for_drptr
-		   && first_stmt != first_stmt_info_for_drptr)
+		   && first_stmt_info != first_stmt_info_for_drptr)
 	    {
 	      dataref_ptr
 		= vect_create_data_ref_ptr (first_stmt_info_for_drptr,
@@ -8209,7 +8210,7 @@  vectorizable_load (gimple *stmt, gimple_
 	    }
 	  else
 	    dataref_ptr
-	      = vect_create_data_ref_ptr (first_stmt, aggr_type, at_loop,
+	      = vect_create_data_ref_ptr (first_stmt_info, aggr_type, at_loop,
 					  offset, &dummy, gsi, &ptr_incr,
 					  simd_lane_access_p, &inv_p,
 					  byte_offset, bump);
@@ -8388,7 +8389,7 @@  vectorizable_load (gimple *stmt, gimple_
 		    tree vs = size_int (TYPE_VECTOR_SUBPARTS (vectype));
 
 		    if (compute_in_loop)
-		      msq = vect_setup_realignment (first_stmt, gsi,
+		      msq = vect_setup_realignment (first_stmt_info, gsi,
 						    &realignment_token,
 						    dr_explicit_realign,
 						    dataref_ptr, NULL);
@@ -9708,8 +9709,7 @@  vect_transform_stmt (gimple *stmt, gimpl
 	     one are skipped, and there vec_stmt_info shouldn't be freed
 	     meanwhile.  */
 	  *grouped_store = true;
-	  stmt_vec_info group_info
-	    = vinfo_for_stmt (DR_GROUP_FIRST_ELEMENT (stmt_info));
+	  stmt_vec_info group_info = DR_GROUP_FIRST_ELEMENT (stmt_info);
 	  if (DR_GROUP_STORE_COUNT (group_info) == DR_GROUP_SIZE (group_info))
 	    is_store = true;
 	}
@@ -9817,14 +9817,13 @@  vect_transform_stmt (gimple *stmt, gimpl
 vect_remove_stores (gimple *first_stmt)
 {
   gimple *next = first_stmt;
-  gimple *tmp;
   gimple_stmt_iterator next_si;
 
   while (next)
     {
       stmt_vec_info stmt_info = vinfo_for_stmt (next);
 
-      tmp = DR_GROUP_NEXT_ELEMENT (stmt_info);
+      stmt_vec_info tmp = DR_GROUP_NEXT_ELEMENT (stmt_info);
       if (is_pattern_stmt_p (stmt_info))
 	next = STMT_VINFO_RELATED_STMT (stmt_info);
       /* Free the attached stmt_vec_info and remove the stmt.  */