In its current implementation, the loop vectorizer requires the main
exit be the counting IV exit. With uncounted loops we no longer need
to have any counting IV exits. Furthermore, it is possible to have
reached this stage with malformed loops with no exits at all.
Consequently, we need an approach to handle malformed loops and some
logic to follow when choosing the main exit, when counting IV is no
longer a valid criterion.
For malformed loops, it is sufficient to return NULL, so that we can
reject such loops upon the function return.
In the case of multiple exits and no counting IV exit, we choose the
last one in the loop. This is done so that we continue to have an
empty effective latch.
As a consequence of allowing the main exit to no longer be associated
with IV counting, the old nomenclature of `LOOP_VINFO_IV_EXIT' and
`vec_loop_iv_exit' no longer fully cover the usage of such fields and
accessors. With that in mind, these are modified to replace "IV" for
"MAIN" for these.
gcc/ChangeLog:
* tree-vect-loop.cc (vec_init_loop_exit_info): Handle
multiple-exit uncounted loops.
* tree-vect-loop.cc (vec_init_loop_exit_info): Handle
ill-formed loops with no exits.
(vect_analyze_loop_form): Fix `failure_at' message.
---
gcc/tree-vect-data-refs.cc | 2 +-
gcc/tree-vect-loop-manip.cc | 34 ++++++++++-----------
gcc/tree-vect-loop.cc | 59 ++++++++++++++++++++++++-------------
gcc/tree-vectorizer.cc | 2 +-
gcc/tree-vectorizer.h | 26 ++++++++--------
5 files changed, 70 insertions(+), 53 deletions(-)
diff --git a/gcc/tree-vect-data-refs.cc b/gcc/tree-vect-data-refs.cc
index b35ba05fd08..154bf5ac1b6 100644
--- a/gcc/tree-vect-data-refs.cc
+++ b/gcc/tree-vect-data-refs.cc
@@ -2590,7 +2590,7 @@ vect_enhance_data_refs_alignment (loop_vec_info
loop_vinfo)
/* Check if we can possibly peel the loop. */
if (!vect_can_advance_ivs_p (loop_vinfo)
- || !slpeel_can_duplicate_loop_p (loop, LOOP_VINFO_IV_EXIT (loop_vinfo),
+ || !slpeel_can_duplicate_loop_p (loop, LOOP_VINFO_MAIN_EXIT (loop_vinfo),
loop_preheader_edge (loop))
|| loop->inner
/* We don't currently maintaing the LCSSA for prologue peeled inversed
diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc
index af3f3aff2cc..85a733d6408 100644
--- a/gcc/tree-vect-loop-manip.cc
+++ b/gcc/tree-vect-loop-manip.cc
@@ -545,7 +545,7 @@ vect_set_loop_controls_directly (class loop *loop,
loop_vec_info loop_vinfo,
tree index_before_incr, index_after_incr;
gimple_stmt_iterator incr_gsi;
bool insert_after;
- edge exit_e = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ edge exit_e = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
vect_iv_increment_position (exit_e, &incr_gsi, &insert_after);
if (LOOP_VINFO_USING_DECREMENTING_IV_P (loop_vinfo))
{
@@ -2906,7 +2906,7 @@ vect_gen_vector_loop_niters_mult_vf (loop_vec_info
loop_vinfo,
int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo).to_constant ();
tree type = TREE_TYPE (niters_vector);
tree tree_vf = build_int_cst (type, vf);
- basic_block exit_bb = LOOP_VINFO_IV_EXIT (loop_vinfo)->dest;
+ basic_block exit_bb = LOOP_VINFO_MAIN_EXIT (loop_vinfo)->dest;
gcc_assert (niters_vector_mult_vf_ptr != NULL);
tree niters_vector_mult_vf = fold_build2 (MULT_EXPR, type,
@@ -3333,19 +3333,19 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
use the original scalar loop as remaining epilogue if necessary. */
LOOP_VINFO_SCALAR_LOOP (epilogue_vinfo)
= LOOP_VINFO_SCALAR_LOOP (loop_vinfo);
- LOOP_VINFO_SCALAR_IV_EXIT (epilogue_vinfo)
- = LOOP_VINFO_SCALAR_IV_EXIT (loop_vinfo);
+ LOOP_VINFO_SCALAR_MAIN_EXIT (epilogue_vinfo)
+ = LOOP_VINFO_SCALAR_MAIN_EXIT (loop_vinfo);
}
if (prolog_peeling)
{
e = loop_preheader_edge (loop);
- edge exit_e = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ edge exit_e = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
gcc_checking_assert (slpeel_can_duplicate_loop_p (loop, exit_e, e)
&& !LOOP_VINFO_EARLY_BREAKS_VECT_PEELED
(loop_vinfo));
/* Peel prolog and put it on preheader edge of loop. */
- edge scalar_e = LOOP_VINFO_SCALAR_IV_EXIT (loop_vinfo);
+ edge scalar_e = LOOP_VINFO_SCALAR_MAIN_EXIT (loop_vinfo);
edge prolog_e = NULL;
prolog = slpeel_tree_duplicate_loop_to_edge_cfg (loop, exit_e,
scalar_loop, scalar_e,
@@ -3433,7 +3433,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
if (epilog_peeling)
{
- e = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ e = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
gcc_checking_assert (slpeel_can_duplicate_loop_p (loop, e, e));
/* Peel epilog and put it on exit edge of loop. If we are vectorizing
@@ -3443,7 +3443,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
If we are not vectorizing the epilog then we should use the scalar loop
as the transformations mentioned above make less or no sense when not
vectorizing. */
- edge scalar_e = LOOP_VINFO_SCALAR_IV_EXIT (loop_vinfo);
+ edge scalar_e = LOOP_VINFO_SCALAR_MAIN_EXIT (loop_vinfo);
epilog = vect_epilogues ? get_loop_copy (loop) : scalar_loop;
edge epilog_e = vect_epilogues ? e : scalar_e;
edge new_epilog_e = NULL;
@@ -3452,7 +3452,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
= slpeel_tree_duplicate_loop_to_edge_cfg (loop, e, epilog, epilog_e, e,
&new_epilog_e, true, &doms);
- LOOP_VINFO_EPILOGUE_IV_EXIT (loop_vinfo) = new_epilog_e;
+ LOOP_VINFO_EPILOGUE_MAIN_EXIT (loop_vinfo) = new_epilog_e;
gcc_assert (epilog);
gcc_assert (new_epilog_e);
epilog->force_vectorize = false;
@@ -3558,7 +3558,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
gcc_checking_assert (vect_can_advance_ivs_p (loop_vinfo));
update_e = skip_vector ? e : loop_preheader_edge (epilog);
if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo))
- update_e = single_succ_edge (LOOP_VINFO_IV_EXIT (loop_vinfo)->dest);
+ update_e = single_succ_edge (LOOP_VINFO_MAIN_EXIT (loop_vinfo)->dest);
/* If we have a peeled vector iteration, all exits are the same, leave it
and so the main exit needs to be treated the same as the alternative
@@ -3577,8 +3577,8 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
guard_cond = fold_build2 (EQ_EXPR, boolean_type_node,
niters, niters_vector_mult_vf);
- guard_bb = LOOP_VINFO_IV_EXIT (loop_vinfo)->dest;
- edge epilog_e = LOOP_VINFO_EPILOGUE_IV_EXIT (loop_vinfo);
+ guard_bb = LOOP_VINFO_MAIN_EXIT (loop_vinfo)->dest;
+ edge epilog_e = LOOP_VINFO_EPILOGUE_MAIN_EXIT (loop_vinfo);
guard_to = epilog_e->dest;
guard_e = slpeel_add_loop_guard (guard_bb, guard_cond, guard_to,
skip_vector ? anchor : guard_bb,
@@ -3587,7 +3587,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
doms.safe_push (guard_to);
if (vect_epilogues)
epilogue_vinfo->skip_this_loop_edge = guard_e;
- edge main_iv = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ edge main_iv = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
gphi_iterator gsi2 = gsi_start_phis (main_iv->dest);
for (gphi_iterator gsi = gsi_start_phis (guard_to);
!gsi_end_p (gsi); gsi_next (&gsi))
@@ -3667,8 +3667,8 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
{
epilog->aux = epilogue_vinfo;
LOOP_VINFO_LOOP (epilogue_vinfo) = epilog;
- LOOP_VINFO_IV_EXIT (epilogue_vinfo)
- = LOOP_VINFO_EPILOGUE_IV_EXIT (loop_vinfo);
+ LOOP_VINFO_MAIN_EXIT (epilogue_vinfo)
+ = LOOP_VINFO_EPILOGUE_MAIN_EXIT (loop_vinfo);
loop_constraint_clear (epilog, LOOP_C_INFINITE);
@@ -4310,7 +4310,7 @@ vect_loop_versioning (loop_vec_info loop_vinfo,
currently using. */
edge exit_edge;
if (loop_to_version == loop)
- exit_edge = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ exit_edge = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
else
exit_edge = single_exit (loop_to_version);
exit_edge->dest->count = preheader->count;
@@ -4404,7 +4404,7 @@ vect_loop_versioning (loop_vec_info loop_vinfo,
currently using. */
edge exit_edge;
if (loop_to_version == loop)
- exit_edge = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ exit_edge = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
else
exit_edge = single_exit (loop_to_version);
diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc
index 80a8ff644ac..6e55252c270 100644
--- a/gcc/tree-vect-loop.cc
+++ b/gcc/tree-vect-loop.cc
@@ -657,17 +657,24 @@ vec_init_loop_exit_info (class loop *loop)
/* Before we begin we must first determine which exit is the main one and
which are auxilary exits. */
auto_vec<edge> exits = get_loop_exit_edges (loop);
+ if (exits.length () == 0)
+ return NULL;
if (exits.length () == 1)
return exits[0];
- /* If we have multiple exits we only support counting IV at the moment.
+ /* If we have multiple exits, look for counting IV exit.
Analyze all exits and return the last one we can analyze. */
class tree_niter_desc niter_desc;
edge candidate = NULL;
for (edge exit : exits)
{
if (!get_loop_exit_condition (exit))
- continue;
+ {
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "Unhandled loop exit detected.\n");
+ return NULL;
+ }
if (number_of_iterations_exit_assumptions (loop, exit, &niter_desc, NULL)
&& !chrec_contains_undetermined (niter_desc.niter))
@@ -688,6 +695,17 @@ vec_init_loop_exit_info (class loop *loop)
}
}
+ /* If no exit is analyzable by scalar evolution, we return the last exit
+ under the assummption we are dealing with an uncounted loop. */
+ if (!candidate)
+ for (edge exit : exits)
+ if (single_pred_p (loop->latch)
+ && exit->src == single_pred (loop->latch))
+ {
+ candidate = exit;
+ break;
+ }
+
return candidate;
}
@@ -759,9 +777,9 @@ _loop_vec_info::_loop_vec_info (class loop *loop_in,
vec_info_shared *shared)
orig_loop_info (NULL),
epilogue_vinfo (NULL),
drs_advanced_by (NULL_TREE),
- vec_loop_iv_exit (NULL),
- vec_epilogue_loop_iv_exit (NULL),
- scalar_loop_iv_exit (NULL)
+ vec_loop_main_exit (NULL),
+ vec_epilogue_loop_main_exit (NULL),
+ scalar_loop_main_exit (NULL)
{
/* CHECKME: We want to visit all BBs before their successors (except for
latch blocks, for which this assertion wouldn't hold). In the simple
@@ -1437,8 +1455,7 @@ vect_analyze_loop_form (class loop *loop, gimple
*loop_vectorized_call,
if (!exit_e)
return opt_result::failure_at (vect_location,
"not vectorized:"
- " could not determine main exit from"
- " loop with multiple exits.\n");
+ " Infinite loop detected.\n");
if (loop_vectorized_call)
{
tree arg = gimple_call_arg (loop_vectorized_call, 1);
@@ -1692,7 +1709,7 @@ vect_create_loop_vinfo (class loop *loop, vec_info_shared
*shared,
for (; cond_id < info->conds.length (); cond_id ++)
LOOP_VINFO_LOOP_CONDS (loop_vinfo).safe_push (info->conds[cond_id]);
- LOOP_VINFO_IV_EXIT (loop_vinfo) = info->loop_exit;
+ LOOP_VINFO_MAIN_EXIT (loop_vinfo) = info->loop_exit;
/* Check to see if we're vectorizing multiple exits. */
LOOP_VINFO_EARLY_BREAKS (loop_vinfo)
@@ -2504,8 +2521,8 @@ start_over:
dump_printf_loc (MSG_NOTE, vect_location, "epilog loop required\n");
if (!vect_can_advance_ivs_p (loop_vinfo)
|| !slpeel_can_duplicate_loop_p (loop,
- LOOP_VINFO_IV_EXIT (loop_vinfo),
- LOOP_VINFO_IV_EXIT (loop_vinfo)))
+ LOOP_VINFO_MAIN_EXIT (loop_vinfo),
+ LOOP_VINFO_MAIN_EXIT (loop_vinfo)))
{
ok = opt_result::failure_at (vect_location,
"not vectorized: can't create required "
@@ -5409,7 +5426,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
/* Create an induction variable. */
gimple_stmt_iterator incr_gsi;
bool insert_after;
- vect_iv_increment_position (LOOP_VINFO_IV_EXIT (loop_vinfo),
+ vect_iv_increment_position (LOOP_VINFO_MAIN_EXIT (loop_vinfo),
&incr_gsi, &insert_after);
create_iv (series_vect, PLUS_EXPR, vec_step, NULL_TREE, loop, &incr_gsi,
insert_after, &indx_before_incr, &indx_after_incr);
@@ -5497,7 +5514,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
def = vect_get_slp_vect_def (slp_node, i);
tree new_def = copy_ssa_name (def);
phi = create_phi_node (new_def, exit_bb);
- if (LOOP_VINFO_IV_EXIT (loop_vinfo) == loop_exit)
+ if (LOOP_VINFO_MAIN_EXIT (loop_vinfo) == loop_exit)
SET_PHI_ARG_DEF (phi, loop_exit->dest_idx, def);
else
{
@@ -10140,7 +10157,7 @@ vectorizable_live_operation (vec_info *vinfo,
stmt_vec_info stmt_info,
|| !LOOP_VINFO_EARLY_BREAKS_VECT_PEELED (loop_vinfo))
vect_create_epilog_for_reduction (loop_vinfo, stmt_info, slp_node,
slp_node_instance,
- LOOP_VINFO_IV_EXIT (loop_vinfo));
+ LOOP_VINFO_MAIN_EXIT (loop_vinfo));
/* If early break we only have to materialize the reduction on the merge
block, but we have to find an alternate exit first. */
@@ -10149,7 +10166,7 @@ vectorizable_live_operation (vec_info *vinfo,
stmt_vec_info stmt_info,
slp_tree phis_node = slp_node_instance->reduc_phis;
stmt_info = SLP_TREE_REPRESENTATIVE (phis_node);
for (auto exit : get_loop_exit_edges (LOOP_VINFO_LOOP (loop_vinfo)))
- if (exit != LOOP_VINFO_IV_EXIT (loop_vinfo))
+ if (exit != LOOP_VINFO_MAIN_EXIT (loop_vinfo))
{
vect_create_epilog_for_reduction (loop_vinfo, stmt_info,
phis_node, slp_node_instance,
@@ -10159,7 +10176,7 @@ vectorizable_live_operation (vec_info *vinfo,
stmt_vec_info stmt_info,
if (LOOP_VINFO_EARLY_BREAKS_VECT_PEELED (loop_vinfo))
vect_create_epilog_for_reduction (loop_vinfo, stmt_info,
phis_node, slp_node_instance,
- LOOP_VINFO_IV_EXIT (loop_vinfo));
+ LOOP_VINFO_MAIN_EXIT
(loop_vinfo));
}
return true;
@@ -10298,7 +10315,7 @@ vectorizable_live_operation (vec_info *vinfo,
stmt_vec_info stmt_info,
in these cases for an early break we restart the iteration the vector
code
did. For the live values we want the value at the start of the
iteration
rather than at the end. */
- edge main_e = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ edge main_e = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
bool all_exits_as_early_p = LOOP_VINFO_EARLY_BREAKS_VECT_PEELED
(loop_vinfo);
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs)
if (!is_gimple_debug (use_stmt)
@@ -11059,7 +11076,7 @@ vect_transform_loop (loop_vec_info loop_vinfo, gimple
*loop_vectorized_call)
/* Make sure there exists a single-predecessor exit bb. Do this before
versioning. */
- edge e = LOOP_VINFO_IV_EXIT (loop_vinfo);
+ edge e = LOOP_VINFO_MAIN_EXIT (loop_vinfo);
if (! single_pred_p (e->dest) && !LOOP_VINFO_EARLY_BREAKS (loop_vinfo))
{
split_loop_exit_edge (e, true);
@@ -11085,7 +11102,7 @@ vect_transform_loop (loop_vec_info loop_vinfo, gimple
*loop_vectorized_call)
loop closed PHI nodes on the exit. */
if (LOOP_VINFO_SCALAR_LOOP (loop_vinfo))
{
- e = LOOP_VINFO_SCALAR_IV_EXIT (loop_vinfo);
+ e = LOOP_VINFO_SCALAR_MAIN_EXIT (loop_vinfo);
if (! single_pred_p (e->dest))
{
split_loop_exit_edge (e, true);
@@ -11117,7 +11134,7 @@ vect_transform_loop (loop_vec_info loop_vinfo, gimple
*loop_vectorized_call)
(LOOP_VINFO_SCALAR_LOOP_SCALING (loop_vinfo));
scale_loop_frequencies (LOOP_VINFO_SCALAR_LOOP (loop_vinfo),
LOOP_VINFO_SCALAR_LOOP_SCALING (loop_vinfo));
- LOOP_VINFO_SCALAR_IV_EXIT (loop_vinfo)->dest->count = preheader->count;
+ LOOP_VINFO_SCALAR_MAIN_EXIT (loop_vinfo)->dest->count = preheader->count;
}
if (niters_vector == NULL_TREE)
@@ -11247,7 +11264,7 @@ vect_transform_loop (loop_vec_info loop_vinfo, gimple
*loop_vectorized_call)
a zero NITERS becomes a nonzero NITERS_VECTOR. */
if (integer_onep (step_vector))
niters_no_overflow = true;
- vect_set_loop_condition (loop, LOOP_VINFO_IV_EXIT (loop_vinfo), loop_vinfo,
+ vect_set_loop_condition (loop, LOOP_VINFO_MAIN_EXIT (loop_vinfo), loop_vinfo,
niters_vector, step_vector, niters_vector_mult_vf,
!niters_no_overflow);
@@ -11326,7 +11343,7 @@ vect_transform_loop (loop_vec_info loop_vinfo, gimple
*loop_vectorized_call)
assumed_vf) - 1
: wi::udiv_floor (loop->nb_iterations_estimate + bias_for_assumed,
assumed_vf) - 1);
- scale_profile_for_vect_loop (loop, LOOP_VINFO_IV_EXIT (loop_vinfo),
+ scale_profile_for_vect_loop (loop, LOOP_VINFO_MAIN_EXIT (loop_vinfo),
assumed_vf, flat);
if (dump_enabled_p ())
diff --git a/gcc/tree-vectorizer.cc b/gcc/tree-vectorizer.cc
index e7a3f265048..938d9bdc762 100644
--- a/gcc/tree-vectorizer.cc
+++ b/gcc/tree-vectorizer.cc
@@ -965,7 +965,7 @@ set_uid_loop_bbs (loop_vec_info loop_vinfo, gimple
*loop_vectorized_call,
class loop *scalar_loop = get_loop (fun, tree_to_shwi (arg));
LOOP_VINFO_SCALAR_LOOP (loop_vinfo) = scalar_loop;
- LOOP_VINFO_SCALAR_IV_EXIT (loop_vinfo)
+ LOOP_VINFO_SCALAR_MAIN_EXIT (loop_vinfo)
= vec_init_loop_exit_info (scalar_loop);
gcc_checking_assert (vect_loop_vectorized_call (scalar_loop)
== loop_vectorized_call);
diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
index 0cd2242a63a..cedf4e0c164 100644
--- a/gcc/tree-vectorizer.h
+++ b/gcc/tree-vectorizer.h
@@ -1215,17 +1215,17 @@ public:
/* If this is an epilogue loop the DR advancement applied. */
tree drs_advanced_by;
- /* The controlling loop IV for the current loop when vectorizing. This IV
- controls the natural exits of the loop. */
- edge vec_loop_iv_exit;
+ /* The controlling loop exit for the current loop when vectorizing.
+ For counted loops, this IV controls the natural exits of the loop. */
+ edge vec_loop_main_exit;
- /* The controlling loop IV for the epilogue loop when vectorizing. This IV
- controls the natural exits of the loop. */
- edge vec_epilogue_loop_iv_exit;
+ /* The controlling loop exit for the epilogue loop when vectorizing.
+ For counted loops, this IV controls the natural exits of the loop. */
+ edge vec_epilogue_loop_main_exit;
- /* The controlling loop IV for the scalar loop being vectorized. This IV
- controls the natural exits of the loop. */
- edge scalar_loop_iv_exit;
+ /* The controlling loop exit for the scalar loop being vectorized.
+ For counted loops, this IV controls the natural exits of the loop. */
+ edge scalar_loop_main_exit;
/* Used to store the list of stores needing to be moved if doing early
break vectorization as they would violate the scalar loop semantics if
@@ -1248,9 +1248,9 @@ public:
/* Access Functions. */
#define LOOP_VINFO_LOOP(L) (L)->loop
-#define LOOP_VINFO_IV_EXIT(L) (L)->vec_loop_iv_exit
-#define LOOP_VINFO_EPILOGUE_IV_EXIT(L) (L)->vec_epilogue_loop_iv_exit
-#define LOOP_VINFO_SCALAR_IV_EXIT(L) (L)->scalar_loop_iv_exit
+#define LOOP_VINFO_MAIN_EXIT(L) (L)->vec_loop_main_exit
+#define LOOP_VINFO_EPILOGUE_MAIN_EXIT(L) (L)->vec_epilogue_loop_main_exit
+#define LOOP_VINFO_SCALAR_MAIN_EXIT(L) (L)->scalar_loop_main_exit
#define LOOP_VINFO_BBS(L) (L)->bbs
#define LOOP_VINFO_NBBS(L) (L)->nbbs
#define LOOP_VINFO_NITERSM1(L) (L)->num_itersm1
@@ -1305,7 +1305,7 @@ public:
#define LOOP_VINFO_EARLY_BREAKS(L) (L)->early_breaks
#define LOOP_VINFO_EARLY_BRK_STORES(L) (L)->early_break_stores
#define LOOP_VINFO_EARLY_BREAKS_VECT_PEELED(L) \
- ((single_pred ((L)->loop->latch) != (L)->vec_loop_iv_exit->src) \
+ ((single_pred ((L)->loop->latch) != (L)->vec_loop_main_exit->src) \
|| LOOP_VINFO_NITERS_UNCOUNTED_P (L))
#define LOOP_VINFO_EARLY_BREAKS_LIVE_IVS(L) \
(L)->early_break_live_ivs
--
2.43.0
