While we have already the accessor info_for_reduction, its result
is a plain stmt_vec_info. The following turns that into a class
for the purpose of changing accesses to reduction info to a new
set of accessors prefixed with VECT_REDUC_INFO and removes
the corresponding STMT_VINFO prefixed accessors where possible.
There is few reduction related things that are used by scalar
cycle detection and thus have to stay as-is for now and as
copies in future.
I've kept this separate to show the mass-replacement. Consider
it squashed with 2/4.
* tree-vectorizer.h (vect_reduc_info): New.
(create_info_for_reduction): Likewise.
(VECT_REDUC_INFO_TYPE): Likewise.
(VECT_REDUC_INFO_CODE): Likewise.
(VECT_REDUC_INFO_FN): Likewise.
(VECT_REDUC_INFO_SCALAR_RESULTS): Likewise.
(VECT_REDUC_INFO_INITIAL_VALUES): Likewise.
(VECT_REDUC_INFO_REUSED_ACCUMULATOR): Likewise.
(VECT_REDUC_INFO_INDUC_COND_INITIAL_VAL): Likewise.
(VECT_REDUC_INFO_EPILOGUE_ADJUSTMENT): Likewise.
(VECT_REDUC_INFO_FORCE_SINGLE_CYCLE): Likewise.
(VECT_REDUC_INFO_RESULT_POS): Likewise.
(VECT_REDUC_INFO_VECTYPE): Likewise.
(STMT_VINFO_VEC_INDUC_COND_INITIAL_VAL): Remove.
(STMT_VINFO_REDUC_EPILOGUE_ADJUSTMENT): Likewise.
(STMT_VINFO_FORCE_SINGLE_CYCLE): Likewise.
(STMT_VINFO_REDUC_FN): Likewise.
(STMT_VINFO_REDUC_VECTYPE): Likewise.
(vect_reusable_accumulator::reduc_info): Adjust.
(vect_reduc_type): Adjust.
* ...
* config/aarch64/aarch64.cc (aarch64_force_single_cycle):
Use VECT_REDUC_INFO_FORCE_SINGLE_CYCLE.
---
gcc/config/aarch64/aarch64.cc | 2 +-
gcc/tree-vect-loop.cc | 197 ++++++++++++++++++----------------
gcc/tree-vect-slp.cc | 8 +-
gcc/tree-vect-stmts.cc | 23 ++--
gcc/tree-vectorizer.cc | 10 +-
gcc/tree-vectorizer.h | 39 +++++--
6 files changed, 163 insertions(+), 116 deletions(-)
diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc
index c5110566215..1cdd5a26a83 100644
--- a/gcc/config/aarch64/aarch64.cc
+++ b/gcc/config/aarch64/aarch64.cc
@@ -17776,7 +17776,7 @@ aarch64_force_single_cycle (vec_info *vinfo,
stmt_vec_info stmt_info)
return false;
auto reduc_info = info_for_reduction (vinfo, stmt_info);
- return STMT_VINFO_FORCE_SINGLE_CYCLE (reduc_info);
+ return VECT_REDUC_INFO_FORCE_SINGLE_CYCLE (reduc_info);
}
/* COUNT, KIND and STMT_INFO are the same as for vector_costs::add_stmt_cost
diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc
index fafd24c132e..a0e77bdced6 100644
--- a/gcc/tree-vect-loop.cc
+++ b/gcc/tree-vect-loop.cc
@@ -4993,9 +4993,9 @@ vect_model_reduction_cost (loop_vec_info loop_vinfo,
static void
vect_emit_reduction_init_stmts (loop_vec_info loop_vinfo,
- stmt_vec_info reduc_info, gimple *seq)
+ vect_reduc_info reduc_info, gimple *seq)
{
- if (reduc_info->reused_accumulator)
+ if (VECT_REDUC_INFO_REUSED_ACCUMULATOR (reduc_info))
{
/* When reusing an accumulator from the main loop, we only need
initialization instructions if the main loop can be skipped.
@@ -5023,13 +5023,13 @@ vect_emit_reduction_init_stmts (loop_vec_info
loop_vinfo,
static void
get_initial_defs_for_reduction (loop_vec_info loop_vinfo,
- stmt_vec_info reduc_info,
+ vect_reduc_info reduc_info,
tree vector_type,
vec<tree> *vec_oprnds,
unsigned int number_of_vectors,
unsigned int group_size, tree neutral_op)
{
- vec<tree> &initial_values = reduc_info->reduc_initial_values;
+ vec<tree> &initial_values = VECT_REDUC_INFO_INITIAL_VALUES (reduc_info);
unsigned HOST_WIDE_INT nunits;
unsigned j, number_of_places_left_in_vector;
unsigned int i;
@@ -5138,8 +5138,8 @@ get_initial_defs_for_reduction (loop_vec_info loop_vinfo,
/* For a statement STMT_INFO taking part in a reduction operation return
the stmt_vec_info the meta information is stored on. */
-stmt_vec_info
-info_for_reduction (vec_info *vinfo, stmt_vec_info stmt_info)
+static vect_reduc_info
+info_for_reduction (vec_info *vinfo, stmt_vec_info stmt_info, bool create)
{
stmt_info = vect_orig_stmt (stmt_info);
gcc_assert (STMT_VINFO_REDUC_DEF (stmt_info));
@@ -5158,7 +5158,23 @@ info_for_reduction (vec_info *vinfo, stmt_vec_info
stmt_info)
if (info && STMT_VINFO_DEF_TYPE (info) == vect_double_reduction_def)
stmt_info = info;
}
- return stmt_info;
+ if (create)
+ stmt_info->is_reduc_info = true;
+ else
+ gcc_assert (stmt_info->is_reduc_info);
+ return vect_reduc_info (stmt_info);
+}
+
+vect_reduc_info
+info_for_reduction (vec_info *vinfo, stmt_vec_info stmt_info)
+{
+ return info_for_reduction (vinfo, stmt_info, false);
+}
+
+vect_reduc_info
+create_info_for_reduction (vec_info *vinfo, stmt_vec_info stmt_info)
+{
+ return info_for_reduction (vinfo, stmt_info, true);
}
/* See if LOOP_VINFO is an epilogue loop whose main loop had a reduction that
@@ -5167,16 +5183,16 @@ info_for_reduction (vec_info *vinfo, stmt_vec_info
stmt_info)
static bool
vect_find_reusable_accumulator (loop_vec_info loop_vinfo,
- stmt_vec_info reduc_info, tree vectype)
+ vect_reduc_info reduc_info, tree vectype)
{
loop_vec_info main_loop_vinfo = LOOP_VINFO_ORIG_LOOP_INFO (loop_vinfo);
if (!main_loop_vinfo)
return false;
- if (STMT_VINFO_REDUC_TYPE (reduc_info) != TREE_CODE_REDUCTION)
+ if (VECT_REDUC_INFO_TYPE (reduc_info) != TREE_CODE_REDUCTION)
return false;
- unsigned int num_phis = reduc_info->reduc_initial_values.length ();
+ unsigned int num_phis = VECT_REDUC_INFO_INITIAL_VALUES (reduc_info).length
();
auto_vec<tree, 16> main_loop_results (num_phis);
auto_vec<tree, 16> initial_values (num_phis);
if (edge main_loop_edge = loop_vinfo->main_loop_edge)
@@ -5184,7 +5200,7 @@ vect_find_reusable_accumulator (loop_vec_info loop_vinfo,
/* The epilogue loop can be entered either from the main loop or
from an earlier guard block. */
edge skip_edge = loop_vinfo->skip_main_loop_edge;
- for (tree incoming_value : reduc_info->reduc_initial_values)
+ for (tree incoming_value : VECT_REDUC_INFO_INITIAL_VALUES (reduc_info))
{
/* Look for:
@@ -5204,15 +5220,15 @@ vect_find_reusable_accumulator (loop_vec_info
loop_vinfo,
}
else
/* The main loop dominates the epilogue loop. */
- main_loop_results.splice (reduc_info->reduc_initial_values);
+ main_loop_results.splice (VECT_REDUC_INFO_INITIAL_VALUES (reduc_info));
/* See if the main loop has the kind of accumulator we need. */
vect_reusable_accumulator *accumulator
= main_loop_vinfo->reusable_accumulators.get (main_loop_results[0]);
if (!accumulator
- || num_phis != accumulator->reduc_info->reduc_scalar_results.length ()
+ || num_phis != VECT_REDUC_INFO_SCALAR_RESULTS
(accumulator->reduc_info).length ()
|| !std::equal (main_loop_results.begin (), main_loop_results.end (),
- accumulator->reduc_info->reduc_scalar_results.begin ()))
+ VECT_REDUC_INFO_SCALAR_RESULTS
(accumulator->reduc_info).begin ()))
return false;
/* Handle the case where we can reduce wider vectors to narrower ones. */
@@ -5230,7 +5246,7 @@ vect_find_reusable_accumulator (loop_vec_info loop_vinfo,
tree intermediate_vectype = get_related_vectype_for_scalar_type
(TYPE_MODE (vectype), TREE_TYPE (vectype), intermediate_nunits);
if (!intermediate_vectype
- || !directly_supported_p (STMT_VINFO_REDUC_CODE (reduc_info),
+ || !directly_supported_p (VECT_REDUC_INFO_CODE (reduc_info),
intermediate_vectype)
|| !can_vec_extract (TYPE_MODE (prev_vectype),
TYPE_MODE (intermediate_vectype)))
@@ -5249,7 +5265,7 @@ vect_find_reusable_accumulator (loop_vec_info loop_vinfo,
to select the correct adjustment, but in practice that shouldn't be
necessary.) */
tree main_adjustment
- = STMT_VINFO_REDUC_EPILOGUE_ADJUSTMENT (accumulator->reduc_info);
+ = VECT_REDUC_INFO_EPILOGUE_ADJUSTMENT (accumulator->reduc_info);
if (loop_vinfo->main_loop_edge && main_adjustment)
{
gcc_assert (num_phis == 1);
@@ -5258,14 +5274,14 @@ vect_find_reusable_accumulator (loop_vec_info
loop_vinfo,
initialize the accumulator with a neutral value instead. */
if (!operand_equal_p (initial_value, main_adjustment))
return false;
- code_helper code = STMT_VINFO_REDUC_CODE (reduc_info);
+ code_helper code = VECT_REDUC_INFO_CODE (reduc_info);
initial_values[0] = neutral_op_for_reduction (TREE_TYPE (initial_value),
code, initial_value);
}
- STMT_VINFO_REDUC_EPILOGUE_ADJUSTMENT (reduc_info) = main_adjustment;
- reduc_info->reduc_initial_values.truncate (0);
- reduc_info->reduc_initial_values.splice (initial_values);
- reduc_info->reused_accumulator = accumulator;
+ VECT_REDUC_INFO_EPILOGUE_ADJUSTMENT (reduc_info) = main_adjustment;
+ VECT_REDUC_INFO_INITIAL_VALUES (reduc_info).truncate (0);
+ VECT_REDUC_INFO_INITIAL_VALUES (reduc_info).splice (initial_values);
+ VECT_REDUC_INFO_REUSED_ACCUMULATOR (reduc_info) = accumulator;
return true;
}
@@ -5418,8 +5434,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
slp_instance slp_node_instance,
edge loop_exit)
{
- stmt_vec_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
- gcc_assert (reduc_info->is_reduc_info);
+ vect_reduc_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
/* For double reductions we need to get at the inner loop reduction
stmt which has the meta info attached. Our stmt_info is that of the
loop-closed PHI of the inner loop which we remember as
@@ -5432,8 +5447,8 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
(stmt_info->stmt, 0));
stmt_info = vect_stmt_to_vectorize (stmt_info);
}
- code_helper code = STMT_VINFO_REDUC_CODE (reduc_info);
- internal_fn reduc_fn = STMT_VINFO_REDUC_FN (reduc_info);
+ code_helper code = VECT_REDUC_INFO_CODE (reduc_info);
+ internal_fn reduc_fn = VECT_REDUC_INFO_FN (reduc_info);
tree vectype;
machine_mode mode;
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo), *outer_loop = NULL;
@@ -5453,7 +5468,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
gimple *use_stmt;
auto_vec<tree> reduc_inputs;
int j, i;
- vec<tree> &scalar_results = reduc_info->reduc_scalar_results;
+ vec<tree> &scalar_results = VECT_REDUC_INFO_SCALAR_RESULTS (reduc_info);
unsigned int k;
/* SLP reduction without reduction chain, e.g.,
# a1 = phi <a2, a0>
@@ -5473,7 +5488,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
gcc_assert (double_reduc);
}
- vectype = STMT_VINFO_REDUC_VECTYPE (reduc_info);
+ vectype = VECT_REDUC_INFO_VECTYPE (reduc_info);
gcc_assert (vectype);
mode = TYPE_MODE (vectype);
@@ -5481,12 +5496,12 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
tree adjustment_def = NULL;
/* Optimize: for induction condition reduction, if we can't use zero
for induc_val, use initial_def. */
- if (STMT_VINFO_REDUC_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
- induc_val = STMT_VINFO_VEC_INDUC_COND_INITIAL_VAL (reduc_info);
+ if (VECT_REDUC_INFO_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
+ induc_val = VECT_REDUC_INFO_INDUC_COND_INITIAL_VAL (reduc_info);
else if (double_reduc)
;
else
- adjustment_def = STMT_VINFO_REDUC_EPILOGUE_ADJUSTMENT (reduc_info);
+ adjustment_def = VECT_REDUC_INFO_EPILOGUE_ADJUSTMENT (reduc_info);
stmt_vec_info single_live_out_stmt[] = { stmt_info };
array_slice<const stmt_vec_info> live_out_stmts = single_live_out_stmt;
@@ -5507,7 +5522,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
PR92772: This algorithm is broken for architectures that support
masked vectors, but do not provide fold_extract_last. */
- if (STMT_VINFO_REDUC_TYPE (reduc_info) == COND_REDUCTION)
+ if (VECT_REDUC_INFO_TYPE (reduc_info) == COND_REDUCTION)
{
auto_vec<std::pair<tree, bool>, 2> ccompares;
slp_tree cond_node = slp_node_instance->root;
@@ -5738,7 +5753,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
the minor(?) benefit of making the epilogue loop's scalar result
independent of the main loop's scalar result. */
bool unify_with_main_loop_p = false;
- if (reduc_info->reused_accumulator
+ if (VECT_REDUC_INFO_REUSED_ACCUMULATOR (reduc_info)
&& loop_vinfo->skip_this_loop_edge
&& single_succ_p (exit_bb)
&& single_succ (exit_bb) == loop_vinfo->skip_this_loop_edge->dest)
@@ -5750,7 +5765,8 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
gphi *new_phi = create_phi_node (reduc_inputs[0], reduc_block);
add_phi_arg (new_phi, orig_reduc_input, single_succ_edge (exit_bb),
UNKNOWN_LOCATION);
- add_phi_arg (new_phi, reduc_info->reused_accumulator->reduc_input,
+ add_phi_arg (new_phi,
+ VECT_REDUC_INFO_REUSED_ACCUMULATOR (reduc_info)->reduc_input,
loop_vinfo->skip_this_loop_edge, UNKNOWN_LOCATION);
exit_gsi = gsi_after_labels (reduc_block);
}
@@ -5758,7 +5774,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
/* Shouldn't be used beyond this point. */
exit_bb = nullptr;
- if (STMT_VINFO_REDUC_TYPE (reduc_info) == COND_REDUCTION
+ if (VECT_REDUC_INFO_TYPE (reduc_info) == COND_REDUCTION
&& reduc_fn != IFN_LAST)
{
/* For condition reductions, we have a vector (REDUC_INPUTS 0) containing
@@ -5864,7 +5880,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
gsi_insert_seq_before (&exit_gsi, stmts, GSI_SAME_STMT);
scalar_results.safe_push (new_temp);
}
- else if (STMT_VINFO_REDUC_TYPE (reduc_info) == COND_REDUCTION
+ else if (VECT_REDUC_INFO_TYPE (reduc_info) == COND_REDUCTION
&& reduc_fn == IFN_LAST)
{
/* Condition reduction without supported IFN_REDUC_MAX. Generate
@@ -5957,7 +5973,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
new_temp = gimple_convert (&stmts, scalar_type, new_temp);
gsi_insert_seq_before (&exit_gsi, stmts, GSI_SAME_STMT);
- if ((STMT_VINFO_REDUC_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
+ if ((VECT_REDUC_INFO_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
&& induc_val)
{
/* Earlier we set the initial value to be a vector if induc_val
@@ -5968,7 +5984,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
epilog_stmt = gimple_build_assign (zcompare, EQ_EXPR,
new_temp, induc_val);
gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
- tree initial_def = reduc_info->reduc_initial_values[0];
+ tree initial_def = VECT_REDUC_INFO_INITIAL_VALUES (reduc_info)[0];
tmp = make_ssa_name (new_scalar_dest);
epilog_stmt = gimple_build_assign (tmp, COND_EXPR, zcompare,
initial_def, new_temp);
@@ -6019,7 +6035,8 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
for MIN and MAX reduction, for example. */
if (!neutral_op)
{
- tree scalar_value = reduc_info->reduc_initial_values[i];
+ tree scalar_value
+ = VECT_REDUC_INFO_INITIAL_VALUES (reduc_info)[i];
scalar_value = gimple_convert (&seq, TREE_TYPE (vectype),
scalar_value);
vector_identity = gimple_build_vector_from_val (&seq, vectype,
@@ -6244,7 +6261,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
gsi_insert_seq_before (&exit_gsi, stmts, GSI_SAME_STMT);
}
- if ((STMT_VINFO_REDUC_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
+ if ((VECT_REDUC_INFO_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
&& induc_val)
{
/* Earlier we set the initial value to be a vector if induc_val
@@ -6255,7 +6272,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
epilog_stmt = gimple_build_assign (zcompare, EQ_EXPR,
scalar_results[0], induc_val);
gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT);
- tree initial_def = reduc_info->reduc_initial_values[0];
+ tree initial_def = VECT_REDUC_INFO_INITIAL_VALUES (reduc_info)[0];
tree tmp = make_ssa_name (new_scalar_dest);
epilog_stmt = gimple_build_assign (tmp, COND_EXPR, zcompare,
initial_def, scalar_results[0]);
@@ -6298,7 +6315,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
}
/* Record this operation if it could be reused by the epilogue loop. */
- if (STMT_VINFO_REDUC_TYPE (reduc_info) == TREE_CODE_REDUCTION
+ if (VECT_REDUC_INFO_TYPE (reduc_info) == TREE_CODE_REDUCTION
&& reduc_inputs.length () == 1)
loop_vinfo->reusable_accumulators.put (scalar_results[0],
{ orig_reduc_input, reduc_info });
@@ -6797,13 +6814,13 @@ build_vect_cond_expr (code_helper code, tree vop[3],
tree mask,
static void
vect_reduction_update_partial_vector_usage (loop_vec_info loop_vinfo,
- stmt_vec_info reduc_info,
+ vect_reduc_info reduc_info,
slp_tree slp_node,
code_helper code, tree type,
tree vectype_in)
{
- enum vect_reduction_type reduc_type = STMT_VINFO_REDUC_TYPE (reduc_info);
- internal_fn reduc_fn = STMT_VINFO_REDUC_FN (reduc_info);
+ enum vect_reduction_type reduc_type = VECT_REDUC_INFO_TYPE (reduc_info);
+ internal_fn reduc_fn = VECT_REDUC_INFO_FN (reduc_info);
internal_fn cond_fn = get_conditional_internal_fn (code, type);
if (reduc_type != FOLD_LEFT_REDUCTION
@@ -6903,12 +6920,12 @@ vectorizable_lane_reducing (loop_vec_info loop_vinfo,
stmt_vec_info stmt_info,
|| STMT_VINFO_REDUC_IDX (stmt_info) < 0)
return false;
- stmt_vec_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
+ vect_reduc_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
/* Lane-reducing pattern inside any inner loop of LOOP_VINFO is not
recoginized. */
gcc_assert (!nested_in_vect_loop_p (LOOP_VINFO_LOOP (loop_vinfo),
stmt_info));
- gcc_assert (STMT_VINFO_REDUC_TYPE (reduc_info) == TREE_CODE_REDUCTION);
+ gcc_assert (VECT_REDUC_INFO_TYPE (reduc_info) == TREE_CODE_REDUCTION);
for (int i = 0; i < (int) gimple_num_ops (stmt) - 1; i++)
{
@@ -7067,8 +7084,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
return false;
/* The stmt we store reduction analysis meta on. */
- stmt_vec_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
- reduc_info->is_reduc_info = true;
+ vect_reduc_info reduc_info = create_info_for_reduction (loop_vinfo,
stmt_info);
if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_nested_cycle)
{
@@ -7144,7 +7160,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
slp_tree vdef_slp = slp_node_instance->root;
/* For double-reductions we start SLP analysis at the inner loop LC PHI
which is the def of the outer loop live stmt. */
- if (STMT_VINFO_DEF_TYPE (reduc_info) == vect_double_reduction_def)
+ if (STMT_VINFO_DEF_TYPE (reduc_info.fixme ()) == vect_double_reduction_def)
vdef_slp = SLP_TREE_CHILDREN (vdef_slp)[0];
while (reduc_def != PHI_RESULT (reduc_def_phi))
{
@@ -7291,7 +7307,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
which is defined by the loop-header-phi. */
tree vectype_out = SLP_TREE_VECTYPE (slp_for_stmt_info);
- STMT_VINFO_REDUC_VECTYPE (reduc_info) = vectype_out;
+ VECT_REDUC_INFO_VECTYPE (reduc_info) = vectype_out;
gimple_match_op op;
if (!gimple_extract_op (stmt_info->stmt, &op))
@@ -7384,7 +7400,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
}
enum vect_reduction_type reduction_type = STMT_VINFO_REDUC_TYPE (phi_info);
- STMT_VINFO_REDUC_TYPE (reduc_info) = reduction_type;
+ VECT_REDUC_INFO_TYPE (reduc_info) = reduction_type;
/* If we have a condition reduction, see if we can simplify it further. */
if (reduction_type == COND_REDUCTION)
{
@@ -7411,7 +7427,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"optimizing condition reduction with"
" FOLD_EXTRACT_LAST.\n");
- STMT_VINFO_REDUC_TYPE (reduc_info) = EXTRACT_LAST_REDUCTION;
+ VECT_REDUC_INFO_TYPE (reduc_info) = EXTRACT_LAST_REDUCTION;
}
else if (cond_reduc_dt == vect_induction_def)
{
@@ -7455,10 +7471,10 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
dump_printf_loc (MSG_NOTE, vect_location,
"condition expression based on "
"integer induction.\n");
- STMT_VINFO_REDUC_CODE (reduc_info) = cond_reduc_op_code;
- STMT_VINFO_VEC_INDUC_COND_INITIAL_VAL (reduc_info)
+ VECT_REDUC_INFO_CODE (reduc_info) = cond_reduc_op_code;
+ VECT_REDUC_INFO_INDUC_COND_INITIAL_VAL (reduc_info)
= cond_reduc_val;
- STMT_VINFO_REDUC_TYPE (reduc_info) = INTEGER_INDUC_COND_REDUCTION;
+ VECT_REDUC_INFO_TYPE (reduc_info) = INTEGER_INDUC_COND_REDUCTION;
}
}
else if (cond_reduc_dt == vect_constant_def)
@@ -7479,9 +7495,9 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
"condition expression based on "
"compile time constant.\n");
/* Record reduction code at analysis stage. */
- STMT_VINFO_REDUC_CODE (reduc_info)
+ VECT_REDUC_INFO_CODE (reduc_info)
= integer_onep (e) ? MAX_EXPR : MIN_EXPR;
- STMT_VINFO_REDUC_TYPE (reduc_info) = CONST_COND_REDUCTION;
+ VECT_REDUC_INFO_TYPE (reduc_info) = CONST_COND_REDUCTION;
}
}
}
@@ -7498,7 +7514,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
if (nested_cycle)
{
- gcc_assert (STMT_VINFO_DEF_TYPE (reduc_info)
+ gcc_assert (STMT_VINFO_DEF_TYPE (reduc_info.fixme ())
== vect_double_reduction_def);
double_reduc = true;
}
@@ -7548,9 +7564,9 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
orig_code = new_code != ERROR_MARK ? new_code : orig_code;
}
- STMT_VINFO_REDUC_CODE (reduc_info) = orig_code;
+ VECT_REDUC_INFO_CODE (reduc_info) = orig_code;
- reduction_type = STMT_VINFO_REDUC_TYPE (reduc_info);
+ reduction_type = VECT_REDUC_INFO_TYPE (reduc_info);
if (reduction_type == TREE_CODE_REDUCTION)
{
/* Check whether it's ok to change the order of the computation.
@@ -7590,7 +7606,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
"supported.\n");
return false;
}
- STMT_VINFO_REDUC_TYPE (reduc_info)
+ VECT_REDUC_INFO_TYPE (reduc_info)
= reduction_type = FOLD_LEFT_REDUCTION;
}
else if (!commutative_binary_op_p (orig_code, op.type)
@@ -7661,7 +7677,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
OPTIMIZE_FOR_SPEED))
reduc_fn = IFN_REDUC_MAX;
}
- STMT_VINFO_REDUC_FN (reduc_info) = reduc_fn;
+ VECT_REDUC_INFO_FN (reduc_info) = reduc_fn;
if (reduction_type != EXTRACT_LAST_REDUCTION
&& (!nested_cycle || double_reduc)
@@ -7874,7 +7890,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
dump_printf_loc (MSG_NOTE, vect_location,
"using single def-use cycle for reduction by reducing "
"multiple vectors to one in the loop body\n");
- STMT_VINFO_FORCE_SINGLE_CYCLE (reduc_info) = single_defuse_cycle;
+ VECT_REDUC_INFO_FORCE_SINGLE_CYCLE (reduc_info) = single_defuse_cycle;
/* For lane-reducing operation, the below processing related to single
defuse-cycle will be done in its own vectorizable function. One more
@@ -8015,13 +8031,12 @@ vect_transform_reduction (loop_vec_info loop_vinfo,
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
unsigned vec_num;
- stmt_vec_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
- gcc_assert (reduc_info->is_reduc_info);
+ vect_reduc_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
if (nested_in_vect_loop_p (loop, stmt_info))
{
loop = loop->inner;
- gcc_assert (STMT_VINFO_DEF_TYPE (reduc_info) ==
vect_double_reduction_def);
+ gcc_assert (STMT_VINFO_DEF_TYPE (reduc_info.fixme ()) ==
vect_double_reduction_def);
}
gimple_match_op op;
@@ -8068,10 +8083,10 @@ vect_transform_reduction (loop_vec_info loop_vinfo,
bool masked_loop_p = LOOP_VINFO_FULLY_MASKED_P (loop_vinfo);
- vect_reduction_type reduction_type = STMT_VINFO_REDUC_TYPE (reduc_info);
+ vect_reduction_type reduction_type = VECT_REDUC_INFO_TYPE (reduc_info);
if (reduction_type == FOLD_LEFT_REDUCTION)
{
- internal_fn reduc_fn = STMT_VINFO_REDUC_FN (reduc_info);
+ internal_fn reduc_fn = VECT_REDUC_INFO_FN (reduc_info);
gcc_assert (code.is_tree_code () || cond_fn_p);
return vectorize_fold_left_reduction
(loop_vinfo, stmt_info, gsi, slp_node,
@@ -8079,7 +8094,7 @@ vect_transform_reduction (loop_vec_info loop_vinfo,
reduc_index, masks, lens);
}
- bool single_defuse_cycle = STMT_VINFO_FORCE_SINGLE_CYCLE (reduc_info);
+ bool single_defuse_cycle = VECT_REDUC_INFO_FORCE_SINGLE_CYCLE (reduc_info);
bool lane_reducing = lane_reducing_op_p (code);
gcc_assert (single_defuse_cycle || lane_reducing);
@@ -8222,11 +8237,11 @@ vect_transform_reduction (loop_vec_info loop_vinfo,
{
/* Find suitable def-use cycles to generate vectorized statements
into, and reorder operands based on the selection. */
- unsigned curr_pos = reduc_info->reduc_result_pos;
+ unsigned curr_pos = VECT_REDUC_INFO_RESULT_POS (reduc_info);
unsigned next_pos = (curr_pos + effec_ncopies) % effec_reduc_ncopies;
gcc_assert (curr_pos < effec_reduc_ncopies);
- reduc_info->reduc_result_pos = next_pos;
+ VECT_REDUC_INFO_RESULT_POS (reduc_info) = next_pos;
if (curr_pos)
{
@@ -8367,11 +8382,10 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
nested_cycle = true;
}
- stmt_vec_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
- gcc_assert (reduc_info->is_reduc_info);
+ vect_reduc_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
- if (STMT_VINFO_REDUC_TYPE (reduc_info) == EXTRACT_LAST_REDUCTION
- || STMT_VINFO_REDUC_TYPE (reduc_info) == FOLD_LEFT_REDUCTION)
+ if (VECT_REDUC_INFO_TYPE (reduc_info) == EXTRACT_LAST_REDUCTION
+ || VECT_REDUC_INFO_TYPE (reduc_info) == FOLD_LEFT_REDUCTION)
/* Leave the scalar phi in place. */
return true;
@@ -8379,7 +8393,7 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
/* Check whether we should use a single PHI node and accumulate
vectors to one before the backedge. */
- if (STMT_VINFO_FORCE_SINGLE_CYCLE (reduc_info))
+ if (VECT_REDUC_INFO_FORCE_SINGLE_CYCLE (reduc_info))
vec_num = 1;
/* Create the destination vector */
@@ -8394,23 +8408,23 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
/* Optimize: if initial_def is for REDUC_MAX smaller than the base
and we can't use zero for induc_val, use initial_def. Similarly
for REDUC_MIN and initial_def larger than the base. */
- if (STMT_VINFO_REDUC_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
+ if (VECT_REDUC_INFO_TYPE (reduc_info) == INTEGER_INDUC_COND_REDUCTION)
{
gcc_assert (SLP_TREE_LANES (slp_node) == 1);
tree initial_def = vect_phi_initial_value (phi);
- reduc_info->reduc_initial_values.safe_push (initial_def);
- tree induc_val = STMT_VINFO_VEC_INDUC_COND_INITIAL_VAL (reduc_info);
+ VECT_REDUC_INFO_INITIAL_VALUES (reduc_info).safe_push (initial_def);
+ tree induc_val = VECT_REDUC_INFO_INDUC_COND_INITIAL_VAL (reduc_info);
if (TREE_CODE (initial_def) == INTEGER_CST
&& !integer_zerop (induc_val)
- && ((STMT_VINFO_REDUC_CODE (reduc_info) == MAX_EXPR
+ && ((VECT_REDUC_INFO_CODE (reduc_info) == MAX_EXPR
&& tree_int_cst_lt (initial_def, induc_val))
- || (STMT_VINFO_REDUC_CODE (reduc_info) == MIN_EXPR
+ || (VECT_REDUC_INFO_CODE (reduc_info) == MIN_EXPR
&& tree_int_cst_lt (induc_val, initial_def))))
{
induc_val = initial_def;
/* Communicate we used the initial_def to epilouge
generation. */
- STMT_VINFO_VEC_INDUC_COND_INITIAL_VAL (reduc_info) = NULL_TREE;
+ VECT_REDUC_INFO_INDUC_COND_INITIAL_VAL (reduc_info) = NULL_TREE;
}
vec_initial_defs.quick_push
(build_vector_from_val (vectype_out, induc_val));
@@ -8424,7 +8438,7 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
else
{
gcc_assert (slp_node == slp_node_instance->reduc_phis);
- vec<tree> &initial_values = reduc_info->reduc_initial_values;
+ vec<tree> &initial_values = VECT_REDUC_INFO_INITIAL_VALUES (reduc_info);
vec<stmt_vec_info> &stmts = SLP_TREE_SCALAR_STMTS (slp_node);
unsigned int num_phis = stmts.length ();
@@ -8442,7 +8456,7 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
{
tree initial_value
= (num_phis == 1 ? initial_values[0] : NULL_TREE);
- code_helper code = STMT_VINFO_REDUC_CODE (reduc_info);
+ code_helper code = VECT_REDUC_INFO_CODE (reduc_info);
tree neutral_op
= neutral_op_for_reduction (TREE_TYPE (vectype_out),
code, initial_value);
@@ -8452,11 +8466,11 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
requires to keep the initial value live across the loop. */
if (neutral_op
&& initial_values.length () == 1
- && !reduc_info->reused_accumulator
+ && !VECT_REDUC_INFO_REUSED_ACCUMULATOR (reduc_info)
&& STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def
&& !operand_equal_p (neutral_op, initial_values[0]))
{
- STMT_VINFO_REDUC_EPILOGUE_ADJUSTMENT (reduc_info)
+ VECT_REDUC_INFO_EPILOGUE_ADJUSTMENT (reduc_info)
= initial_values[0];
initial_values[0] = neutral_op;
}
@@ -8472,7 +8486,7 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
vec_initial_defs.quick_push (vec_initial_def);
}
- if (auto *accumulator = reduc_info->reused_accumulator)
+ if (auto *accumulator = VECT_REDUC_INFO_REUSED_ACCUMULATOR (reduc_info))
{
tree def = accumulator->reduc_input;
if (!useless_type_conversion_p (vectype_out, TREE_TYPE (def)))
@@ -8495,7 +8509,7 @@ vect_transform_cycle_phi (loop_vec_info loop_vinfo,
TYPE_VECTOR_SUBPARTS
(vectype_out));
def = vect_create_partial_epilog (def, rvectype,
- STMT_VINFO_REDUC_CODE
+ VECT_REDUC_INFO_CODE
(reduc_info),
&stmts);
}
@@ -10266,10 +10280,9 @@ vectorizable_live_operation (vec_info *vinfo,
stmt_vec_info stmt_info,
if (SLP_INSTANCE_KIND (slp_node_instance) == slp_inst_kind_reduc_group
&& slp_index != 0)
return true;
- stmt_vec_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
- gcc_assert (reduc_info->is_reduc_info);
- if (STMT_VINFO_REDUC_TYPE (reduc_info) == FOLD_LEFT_REDUCTION
- || STMT_VINFO_REDUC_TYPE (reduc_info) == EXTRACT_LAST_REDUCTION)
+ vect_reduc_info reduc_info = info_for_reduction (loop_vinfo, stmt_info);
+ if (VECT_REDUC_INFO_TYPE (reduc_info) == FOLD_LEFT_REDUCTION
+ || VECT_REDUC_INFO_TYPE (reduc_info) == EXTRACT_LAST_REDUCTION)
return true;
if (!LOOP_VINFO_EARLY_BREAKS (loop_vinfo)
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 86508e22f49..733f4ece724 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -6719,10 +6719,14 @@ vect_optimize_slp_pass::start_choosing_layouts ()
{
stmt_vec_info stmt_info
= SLP_TREE_REPRESENTATIVE (SLP_INSTANCE_TREE (instance));
- stmt_vec_info reduc_info = info_for_reduction (m_vinfo, stmt_info);
+ /* ??? vectorizable_reduction did not run yet, scalar cycle
+ detection sets reduc_code. Either that or SLP discovery
+ should create a reduction info. */
+ vect_reduc_info reduc_info
+ = create_info_for_reduction (m_vinfo, stmt_info);
if (needs_fold_left_reduction_p (TREE_TYPE
(gimple_get_lhs (stmt_info->stmt)),
- STMT_VINFO_REDUC_CODE (reduc_info)))
+ VECT_REDUC_INFO_CODE (reduc_info)))
{
unsigned int node_i = SLP_INSTANCE_TREE (instance)->vertex;
m_partitions[m_vertices[node_i].partition].layout = 0;
diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc
index 1545fab3647..2248b361e1c 100644
--- a/gcc/tree-vect-stmts.cc
+++ b/gcc/tree-vect-stmts.cc
@@ -11560,20 +11560,23 @@ vectorizable_condition (vec_info *vinfo,
if (code != COND_EXPR)
return false;
- stmt_vec_info reduc_info = NULL;
- int reduc_index = -1;
+ int reduc_index = STMT_VINFO_REDUC_IDX (stmt_info);
vect_reduction_type reduction_type = TREE_CODE_REDUCTION;
- bool for_reduction
- = STMT_VINFO_REDUC_DEF (vect_orig_stmt (stmt_info)) != NULL;
+ bool nested_cycle_p = false;
+ bool for_reduction = vect_is_reduction (stmt_info);
if (for_reduction)
{
if (SLP_TREE_LANES (slp_node) > 1)
return false;
- reduc_info = info_for_reduction (vinfo, stmt_info);
- reduction_type = STMT_VINFO_REDUC_TYPE (reduc_info);
- reduc_index = STMT_VINFO_REDUC_IDX (stmt_info);
- gcc_assert (reduction_type != EXTRACT_LAST_REDUCTION
- || reduc_index != -1);
+ /* ??? With a reduction path we do not get at the reduction info from
+ every stmt, use the conservative default setting then. */
+ if (STMT_VINFO_REDUC_DEF (vect_orig_stmt (stmt_info)))
+ {
+ vect_reduc_info reduc_info = info_for_reduction (vinfo, stmt_info);
+ reduction_type = VECT_REDUC_INFO_TYPE (reduc_info);
+ nested_cycle_p = nested_in_vect_loop_p (LOOP_VINFO_LOOP (loop_vinfo),
+ stmt_info);
+ }
}
else
{
@@ -11763,7 +11766,7 @@ vectorizable_condition (vec_info *vinfo,
vec_num, vectype, NULL);
}
/* Extra inactive lanes should be safe for vect_nested_cycle. */
- else if (STMT_VINFO_DEF_TYPE (reduc_info) != vect_nested_cycle)
+ else if (!nested_cycle_p)
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
diff --git a/gcc/tree-vectorizer.cc b/gcc/tree-vectorizer.cc
index 50985a64ba6..726383f487c 100644
--- a/gcc/tree-vectorizer.cc
+++ b/gcc/tree-vectorizer.cc
@@ -719,12 +719,20 @@ vec_info::new_stmt_vec_info (gimple *stmt)
STMT_VINFO_VECTORIZABLE (res) = true;
STMT_VINFO_REDUC_TYPE (res) = TREE_CODE_REDUCTION;
STMT_VINFO_REDUC_CODE (res) = ERROR_MARK;
- STMT_VINFO_REDUC_FN (res) = IFN_LAST;
STMT_VINFO_REDUC_IDX (res) = -1;
+ STMT_VINFO_REDUC_DEF (res) = NULL;
STMT_VINFO_SLP_VECT_ONLY (res) = false;
STMT_VINFO_SLP_VECT_ONLY_PATTERN (res) = false;
+
+ /* To be moved. */
+ res->reduc_epilogue_adjustment = NULL_TREE;
+ res->force_single_cycle = false;
+ res->reduc_fn = IFN_LAST;
res->reduc_initial_values = vNULL;
res->reduc_scalar_results = vNULL;
+ res->reduc_vectype = NULL_TREE;
+ res->induc_cond_initial_val = NULL_TREE;
+ res->reused_accumulator = NULL;
if (is_a <loop_vec_info> (this)
&& gimple_code (stmt) == GIMPLE_PHI
diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
index ad7500eb6c9..90d862f2987 100644
--- a/gcc/tree-vectorizer.h
+++ b/gcc/tree-vectorizer.h
@@ -814,6 +814,29 @@ typedef auto_vec<rgroup_controls> vec_loop_lens;
typedef auto_vec<std::pair<data_reference*, tree> > drs_init_vec;
+/* Abstraction around info on reductions which is still in stmt_vec_info
+ but will be duplicated or moved elsewhere. */
+class vect_reduc_info
+{
+public:
+ explicit vect_reduc_info (stmt_vec_info s) : i (s) {}
+ stmt_vec_info fixme () const { return i; }
+private:
+ stmt_vec_info i;
+};
+
+#define VECT_REDUC_INFO_TYPE(I) ((I).fixme ()->reduc_type)
+#define VECT_REDUC_INFO_CODE(I) ((I).fixme ()->reduc_code)
+#define VECT_REDUC_INFO_FN(I) ((I).fixme ()->reduc_fn)
+#define VECT_REDUC_INFO_SCALAR_RESULTS(I) ((I).fixme ()->reduc_scalar_results)
+#define VECT_REDUC_INFO_INITIAL_VALUES(I) ((I).fixme ()->reduc_initial_values)
+#define VECT_REDUC_INFO_REUSED_ACCUMULATOR(I) ((I).fixme
()->reused_accumulator)
+#define VECT_REDUC_INFO_INDUC_COND_INITIAL_VAL(I) ((I).fixme
()->induc_cond_initial_val)
+#define VECT_REDUC_INFO_EPILOGUE_ADJUSTMENT(I) ((I).fixme
()->reduc_epilogue_adjustment)
+#define VECT_REDUC_INFO_VECTYPE(I) ((I).fixme ()->reduc_vectype)
+#define VECT_REDUC_INFO_FORCE_SINGLE_CYCLE(I) ((I).fixme
()->force_single_cycle)
+#define VECT_REDUC_INFO_RESULT_POS(I) ((I).fixme ()->reduc_result_pos)
+
/* Information about a reduction accumulator from the main loop that could
conceivably be reused as the input to a reduction in an epilogue loop. */
struct vect_reusable_accumulator {
@@ -823,7 +846,7 @@ struct vect_reusable_accumulator {
/* The stmt_vec_info that describes the reduction (i.e. the one for
which is_reduc_info is true). */
- stmt_vec_info reduc_info;
+ vect_reduc_info reduc_info;
};
/*-----------------------------------------------------------------*/
@@ -1634,10 +1657,7 @@ struct gather_scatter_info {
#define STMT_VINFO_GATHER_SCATTER_P(S) (S)->gather_scatter_p
#define STMT_VINFO_STRIDED_P(S) (S)->strided_p
#define STMT_VINFO_SIMD_LANE_ACCESS_P(S) (S)->simd_lane_access_p
-#define STMT_VINFO_VEC_INDUC_COND_INITIAL_VAL(S) (S)->induc_cond_initial_val
-#define STMT_VINFO_REDUC_EPILOGUE_ADJUSTMENT(S) (S)->reduc_epilogue_adjustment
#define STMT_VINFO_REDUC_IDX(S) (S)->reduc_idx
-#define STMT_VINFO_FORCE_SINGLE_CYCLE(S) (S)->force_single_cycle
#define STMT_VINFO_DR_WRT_VEC_LOOP(S) (S)->dr_wrt_vec_loop
#define STMT_VINFO_DR_BASE_ADDRESS(S) (S)->dr_wrt_vec_loop.base_address
@@ -1667,12 +1687,10 @@ struct gather_scatter_info {
#define STMT_VINFO_MIN_NEG_DIST(S) (S)->min_neg_dist
#define STMT_VINFO_REDUC_TYPE(S) (S)->reduc_type
#define STMT_VINFO_REDUC_CODE(S) (S)->reduc_code
-#define STMT_VINFO_REDUC_FN(S) (S)->reduc_fn
#define STMT_VINFO_REDUC_DEF(S) (S)->reduc_def
-#define STMT_VINFO_REDUC_VECTYPE(S) (S)->reduc_vectype
-#define STMT_VINFO_REDUC_VECTYPE_IN(S) (S)->reduc_vectype_in
#define STMT_VINFO_SLP_VECT_ONLY(S) (S)->slp_vect_only_p
#define STMT_VINFO_SLP_VECT_ONLY_PATTERN(S) (S)->slp_vect_pattern_only_p
+#define STMT_VINFO_REDUC_VECTYPE_IN(S) (S)->reduc_vectype_in
#define DR_GROUP_FIRST_ELEMENT(S) \
(gcc_checking_assert ((S)->dr_aux.dr), (S)->first_element)
@@ -2656,7 +2674,8 @@ extern tree vect_gen_loop_len_mask (loop_vec_info,
gimple_stmt_iterator *,
unsigned int, tree, tree, unsigned int,
unsigned int);
extern gimple_seq vect_gen_len (tree, tree, tree, tree);
-extern stmt_vec_info info_for_reduction (vec_info *, stmt_vec_info);
+extern vect_reduc_info info_for_reduction (vec_info *, stmt_vec_info);
+extern vect_reduc_info create_info_for_reduction (vec_info *, stmt_vec_info);
extern bool reduction_fn_for_scalar_code (code_helper, internal_fn *);
/* Drive for loop transformation stage. */
@@ -2885,9 +2904,9 @@ vect_reduc_type (vec_info *vinfo, slp_tree node)
stmt_vec_info stmt_info = SLP_TREE_REPRESENTATIVE (node);
if (STMT_VINFO_REDUC_DEF (stmt_info))
{
- stmt_vec_info reduc_info
+ vect_reduc_info reduc_info
= info_for_reduction (loop_vinfo, stmt_info);
- return int (STMT_VINFO_REDUC_TYPE (reduc_info));
+ return int (VECT_REDUC_INFO_TYPE (reduc_info));
}
}
return -1;
--
2.43.0
