This is another patch in the series to remove the assumption that
all modes involved in vectorisation have to be the same size.
Rather than have the target provide a list of vector sizes,
it makes the target provide a list of vector "approaches",
with each approach represented by a mode.
A later patch will pass this mode to targetm.vectorize.related_mode
to get the vector mode for a given element mode. Until then, the modes
simply act as an alternative way of specifying the vector size.
2019-10-24 Richard Sandiford <richard.sandif...@arm.com>
gcc/
* target.h (vector_sizes, auto_vector_sizes): Delete.
(vector_modes, auto_vector_modes): New typedefs.
* target.def (autovectorize_vector_sizes): Replace with...
(autovectorize_vector_modes): ...this new hook.
* doc/tm.texi.in (TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES):
Replace with...
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): ...this new hook.
* doc/tm.texi: Regenerate.
* targhooks.h (default_autovectorize_vector_sizes): Delete.
(default_autovectorize_vector_modes): New function.
* targhooks.c (default_autovectorize_vector_sizes): Delete.
(default_autovectorize_vector_modes): New function.
* omp-general.c (omp_max_vf): Use autovectorize_vector_modes instead
of autovectorize_vector_sizes. Use the number of units in the mode
to calculate the maximum VF.
* omp-low.c (omp_clause_aligned_alignment): Use
autovectorize_vector_modes instead of autovectorize_vector_sizes.
Use a loop based on related_mode to iterate through all supported
vector modes for a given scalar mode.
* optabs-query.c (can_vec_mask_load_store_p): Use
autovectorize_vector_modes instead of autovectorize_vector_sizes.
* tree-vect-loop.c (vect_analyze_loop, vect_transform_loop): Likewise.
* tree-vect-slp.c (vect_slp_bb_region): Likewise.
* config/aarch64/aarch64.c (aarch64_autovectorize_vector_sizes):
Replace with...
(aarch64_autovectorize_vector_modes): ...this new function.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES): Delete.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): Define.
* config/arc/arc.c (arc_autovectorize_vector_sizes): Replace with...
(arc_autovectorize_vector_modes): ...this new function.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES): Delete.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): Define.
* config/arm/arm.c (arm_autovectorize_vector_sizes): Replace with...
(arm_autovectorize_vector_modes): ...this new function.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES): Delete.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): Define.
* config/i386/i386.c (ix86_autovectorize_vector_sizes): Replace with...
(ix86_autovectorize_vector_modes): ...this new function.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES): Delete.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): Define.
* config/mips/mips.c (mips_autovectorize_vector_sizes): Replace with...
(mips_autovectorize_vector_modes): ...this new function.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES): Delete.
(TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES): Define.
Index: gcc/target.h
===================================================================
--- gcc/target.h 2019-09-30 17:19:39.843166118 +0100
+++ gcc/target.h 2019-10-25 13:27:15.525762975 +0100
@@ -205,11 +205,11 @@ enum vect_cost_model_location {
class vec_perm_indices;
/* The type to use for lists of vector sizes. */
-typedef vec<poly_uint64> vector_sizes;
+typedef vec<machine_mode> vector_modes;
/* Same, but can be used to construct local lists that are
automatically freed. */
-typedef auto_vec<poly_uint64, 8> auto_vector_sizes;
+typedef auto_vec<machine_mode, 8> auto_vector_modes;
/* The target structure. This holds all the backend hooks. */
#define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME;
Index: gcc/target.def
===================================================================
--- gcc/target.def 2019-10-25 13:26:59.309877555 +0100
+++ gcc/target.def 2019-10-25 13:27:15.525762975 +0100
@@ -1894,20 +1894,28 @@ reached. The default is @var{mode} whic
/* Returns a mask of vector sizes to iterate over when auto-vectorizing
after processing the preferred one derived from preferred_simd_mode. */
DEFHOOK
-(autovectorize_vector_sizes,
- "If the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} is not\n\
-the only one that is worth considering, this hook should add all suitable\n\
-vector sizes to @var{sizes}, in order of decreasing preference. The first\n\
-one should be the size of @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}.\n\
-If @var{all} is true, add suitable vector sizes even when they are generally\n\
+(autovectorize_vector_modes,
+ "If using the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}\n\
+is not the only approach worth considering, this hook should add one mode to\n\
+@var{modes} for each useful alternative approach. These modes are then\n\
+passed to @code{TARGET_VECTORIZE_RELATED_MODE} to obtain the vector mode\n\
+for a given element mode.\n\
+\n\
+The modes returned in @var{modes} should use the smallest element mode\n\
+possible for the vectorization approach that they represent, preferring\n\
+integer modes over floating-poing modes in the event of a tie. The first\n\
+mode should be the @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} for its\n\
+element mode.\n\
+\n\
+If @var{all} is true, add suitable vector modes even when they are generally\n\
not expected to be worthwhile.\n\
\n\
The hook does not need to do anything if the vector returned by\n\
@code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} is the only one relevant\n\
for autovectorization. The default implementation does nothing.",
void,
- (vector_sizes *sizes, bool all),
- default_autovectorize_vector_sizes)
+ (vector_modes *modes, bool all),
+ default_autovectorize_vector_modes)
DEFHOOK
(related_mode,
Index: gcc/doc/tm.texi.in
===================================================================
--- gcc/doc/tm.texi.in 2019-10-25 13:26:59.009879675 +0100
+++ gcc/doc/tm.texi.in 2019-10-25 13:27:15.521763003 +0100
@@ -4179,7 +4179,7 @@ address; but often a machine-dependent
@hook TARGET_VECTORIZE_SPLIT_REDUCTION
-@hook TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
+@hook TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
@hook TARGET_VECTORIZE_RELATED_MODE
Index: gcc/doc/tm.texi
===================================================================
--- gcc/doc/tm.texi 2019-10-25 13:26:59.305877583 +0100
+++ gcc/doc/tm.texi 2019-10-25 13:27:15.521763003 +0100
@@ -6016,12 +6016,20 @@ against lower halves of vectors recursiv
reached. The default is @var{mode} which means no splitting.
@end deftypefn
-@deftypefn {Target Hook} void TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
(vector_sizes *@var{sizes}, bool @var{all})
-If the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} is not
-the only one that is worth considering, this hook should add all suitable
-vector sizes to @var{sizes}, in order of decreasing preference. The first
-one should be the size of @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}.
-If @var{all} is true, add suitable vector sizes even when they are generally
+@deftypefn {Target Hook} void TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
(vector_modes *@var{modes}, bool @var{all})
+If using the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}
+is not the only approach worth considering, this hook should add one mode to
+@var{modes} for each useful alternative approach. These modes are then
+passed to @code{TARGET_VECTORIZE_RELATED_MODE} to obtain the vector mode
+for a given element mode.
+
+The modes returned in @var{modes} should use the smallest element mode
+possible for the vectorization approach that they represent, preferring
+integer modes over floating-poing modes in the event of a tie. The first
+mode should be the @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} for its
+element mode.
+
+If @var{all} is true, add suitable vector modes even when they are generally
not expected to be worthwhile.
The hook does not need to do anything if the vector returned by
Index: gcc/targhooks.h
===================================================================
--- gcc/targhooks.h 2019-10-25 13:26:59.309877555 +0100
+++ gcc/targhooks.h 2019-10-25 13:27:15.525762975 +0100
@@ -113,7 +113,7 @@ default_builtin_support_vector_misalignm
int, bool);
extern machine_mode default_preferred_simd_mode (scalar_mode mode);
extern machine_mode default_split_reduction (machine_mode);
-extern void default_autovectorize_vector_sizes (vector_sizes *, bool);
+extern void default_autovectorize_vector_modes (vector_modes *, bool);
extern opt_machine_mode default_vectorize_related_mode (machine_mode,
scalar_mode,
poly_uint64);
Index: gcc/targhooks.c
===================================================================
--- gcc/targhooks.c 2019-10-25 13:26:59.309877555 +0100
+++ gcc/targhooks.c 2019-10-25 13:27:15.525762975 +0100
@@ -1299,11 +1299,10 @@ default_split_reduction (machine_mode mo
return mode;
}
-/* By default only the size derived from the preferred vector mode
- is tried. */
+/* By default only the preferred vector mode is tried. */
void
-default_autovectorize_vector_sizes (vector_sizes *, bool)
+default_autovectorize_vector_modes (vector_modes *, bool)
{
}
Index: gcc/omp-general.c
===================================================================
--- gcc/omp-general.c 2019-10-25 09:21:28.798326303 +0100
+++ gcc/omp-general.c 2019-10-25 13:27:15.521763003 +0100
@@ -508,13 +508,16 @@ omp_max_vf (void)
&& global_options_set.x_flag_tree_loop_vectorize))
return 1;
- auto_vector_sizes sizes;
- targetm.vectorize.autovectorize_vector_sizes (&sizes, true);
- if (!sizes.is_empty ())
+ auto_vector_modes modes;
+ targetm.vectorize.autovectorize_vector_modes (&modes, true);
+ if (!modes.is_empty ())
{
poly_uint64 vf = 0;
- for (unsigned int i = 0; i < sizes.length (); ++i)
- vf = ordered_max (vf, sizes[i]);
+ for (unsigned int i = 0; i < modes.length (); ++i)
+ /* The returned modes use the smallest element size (and thus
+ the largest nunits) for the vectorization approach that they
+ represent. */
+ vf = ordered_max (vf, GET_MODE_NUNITS (modes[i]));
return vf;
}
Index: gcc/omp-low.c
===================================================================
--- gcc/omp-low.c 2019-10-11 15:43:51.283513446 +0100
+++ gcc/omp-low.c 2019-10-25 13:27:15.525762975 +0100
@@ -3947,11 +3947,8 @@ omp_clause_aligned_alignment (tree claus
/* Otherwise return implementation defined alignment. */
unsigned int al = 1;
opt_scalar_mode mode_iter;
- auto_vector_sizes sizes;
- targetm.vectorize.autovectorize_vector_sizes (&sizes, true);
- poly_uint64 vs = 0;
- for (unsigned int i = 0; i < sizes.length (); ++i)
- vs = ordered_max (vs, sizes[i]);
+ auto_vector_modes modes;
+ targetm.vectorize.autovectorize_vector_modes (&modes, true);
static enum mode_class classes[]
= { MODE_INT, MODE_VECTOR_INT, MODE_FLOAT, MODE_VECTOR_FLOAT };
for (int i = 0; i < 4; i += 2)
@@ -3962,19 +3959,18 @@ omp_clause_aligned_alignment (tree claus
machine_mode vmode = targetm.vectorize.preferred_simd_mode (mode);
if (GET_MODE_CLASS (vmode) != classes[i + 1])
continue;
- while (maybe_ne (vs, 0U)
- && known_lt (GET_MODE_SIZE (vmode), vs)
- && GET_MODE_2XWIDER_MODE (vmode).exists ())
- vmode = GET_MODE_2XWIDER_MODE (vmode).require ();
+ machine_mode alt_vmode;
+ for (unsigned int j = 0; j < modes.length (); ++j)
+ if (related_vector_mode (modes[j], mode).exists (&alt_vmode)
+ && known_ge (GET_MODE_SIZE (alt_vmode), GET_MODE_SIZE (vmode)))
+ vmode = alt_vmode;
tree type = lang_hooks.types.type_for_mode (mode, 1);
if (type == NULL_TREE || TYPE_MODE (type) != mode)
continue;
- poly_uint64 nelts = exact_div (GET_MODE_SIZE (vmode),
- GET_MODE_SIZE (mode));
- type = build_vector_type (type, nelts);
- if (TYPE_MODE (type) != vmode)
- continue;
+ type = build_vector_type_for_mode (type, vmode);
+ /* The functions above are not allowed to return invalid modes. */
+ gcc_assert (TYPE_MODE (type) == vmode);
if (TYPE_ALIGN_UNIT (type) > al)
al = TYPE_ALIGN_UNIT (type);
}
Index: gcc/optabs-query.c
===================================================================
--- gcc/optabs-query.c 2019-10-25 13:26:59.305877583 +0100
+++ gcc/optabs-query.c 2019-10-25 13:27:15.525762975 +0100
@@ -589,11 +589,11 @@ can_vec_mask_load_store_p (machine_mode
&& convert_optab_handler (op, vmode, mask_mode) != CODE_FOR_nothing)
return true;
- auto_vector_sizes vector_sizes;
- targetm.vectorize.autovectorize_vector_sizes (&vector_sizes, true);
- for (unsigned int i = 0; i < vector_sizes.length (); ++i)
+ auto_vector_modes vector_modes;
+ targetm.vectorize.autovectorize_vector_modes (&vector_modes, true);
+ for (unsigned int i = 0; i < vector_modes.length (); ++i)
{
- poly_uint64 cur = vector_sizes[i];
+ poly_uint64 cur = GET_MODE_SIZE (vector_modes[i]);
poly_uint64 nunits;
if (!multiple_p (cur, GET_MODE_SIZE (smode), &nunits))
continue;
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c 2019-10-25 13:26:59.137878771 +0100
+++ gcc/tree-vect-loop.c 2019-10-25 13:27:15.525762975 +0100
@@ -2319,12 +2319,12 @@ vect_analyze_loop_2 (loop_vec_info loop_
vect_analyze_loop (class loop *loop, loop_vec_info orig_loop_vinfo,
vec_info_shared *shared)
{
- auto_vector_sizes vector_sizes;
+ auto_vector_modes vector_modes;
/* Autodetect first vector size we try. */
- targetm.vectorize.autovectorize_vector_sizes (&vector_sizes,
+ targetm.vectorize.autovectorize_vector_modes (&vector_modes,
loop->simdlen != 0);
- unsigned int next_size = 0;
+ unsigned int mode_i = 0;
DUMP_VECT_SCOPE ("analyze_loop_nest");
@@ -2343,7 +2343,7 @@ vect_analyze_loop (class loop *loop, loo
unsigned n_stmts = 0;
poly_uint64 autodetected_vector_size = 0;
opt_loop_vec_info first_loop_vinfo = opt_loop_vec_info::success (NULL);
- poly_uint64 next_vector_size = 0;
+ machine_mode next_vector_mode = VOIDmode;
while (1)
{
/* Check the CFG characteristics of the loop (nesting, entry/exit). */
@@ -2357,7 +2357,7 @@ vect_analyze_loop (class loop *loop, loo
gcc_checking_assert (first_loop_vinfo == NULL);
return loop_vinfo;
}
- loop_vinfo->vector_size = next_vector_size;
+ loop_vinfo->vector_size = GET_MODE_SIZE (next_vector_mode);
bool fatal = false;
@@ -2365,7 +2365,7 @@ vect_analyze_loop (class loop *loop, loo
LOOP_VINFO_ORIG_LOOP_INFO (loop_vinfo) = orig_loop_vinfo;
opt_result res = vect_analyze_loop_2 (loop_vinfo, fatal, &n_stmts);
- if (next_size == 0)
+ if (mode_i == 0)
autodetected_vector_size = loop_vinfo->vector_size;
if (res)
@@ -2399,11 +2399,12 @@ vect_analyze_loop (class loop *loop, loo
return opt_loop_vec_info::propagate_failure (res);
}
- if (next_size < vector_sizes.length ()
- && known_eq (vector_sizes[next_size], autodetected_vector_size))
- next_size += 1;
+ if (mode_i < vector_modes.length ()
+ && known_eq (GET_MODE_SIZE (vector_modes[mode_i]),
+ autodetected_vector_size))
+ mode_i += 1;
- if (next_size == vector_sizes.length ()
+ if (mode_i == vector_modes.length ()
|| known_eq (autodetected_vector_size, 0U))
{
if (first_loop_vinfo)
@@ -2423,15 +2424,11 @@ vect_analyze_loop (class loop *loop, loo
}
/* Try the next biggest vector size. */
- next_vector_size = vector_sizes[next_size++];
+ next_vector_mode = vector_modes[mode_i++];
if (dump_enabled_p ())
- {
- dump_printf_loc (MSG_NOTE, vect_location,
- "***** Re-trying analysis with "
- "vector size ");
- dump_dec (MSG_NOTE, next_vector_size);
- dump_printf (MSG_NOTE, "\n");
- }
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "***** Re-trying analysis with vector mode %s\n",
+ GET_MODE_NAME (next_vector_mode));
}
}
@@ -8277,9 +8274,9 @@ vect_transform_loop (loop_vec_info loop_
if (epilogue)
{
- auto_vector_sizes vector_sizes;
- targetm.vectorize.autovectorize_vector_sizes (&vector_sizes, false);
- unsigned int next_size = 0;
+ auto_vector_modes vector_modes;
+ targetm.vectorize.autovectorize_vector_modes (&vector_modes, false);
+ unsigned int next_i = 0;
/* Note LOOP_VINFO_NITERS_KNOWN_P and LOOP_VINFO_INT_NITERS work
on niters already ajusted for the iterations of the prologue. */
@@ -8295,18 +8292,20 @@ vect_transform_loop (loop_vec_info loop_
epilogue->any_upper_bound = true;
unsigned int ratio;
- while (next_size < vector_sizes.length ()
- && !(constant_multiple_p (loop_vinfo->vector_size,
- vector_sizes[next_size], &ratio)
+ while (next_i < vector_modes.length ()
+ && !(constant_multiple_p
+ (loop_vinfo->vector_size,
+ GET_MODE_SIZE (vector_modes[next_i]), &ratio)
&& eiters >= lowest_vf / ratio))
- next_size += 1;
+ next_i += 1;
}
else
- while (next_size < vector_sizes.length ()
- && maybe_lt (loop_vinfo->vector_size, vector_sizes[next_size]))
- next_size += 1;
+ while (next_i < vector_modes.length ()
+ && maybe_lt (loop_vinfo->vector_size,
+ GET_MODE_SIZE (vector_modes[next_i])))
+ next_i += 1;
- if (next_size == vector_sizes.length ())
+ if (next_i == vector_modes.length ())
epilogue = NULL;
}
Index: gcc/tree-vect-slp.c
===================================================================
--- gcc/tree-vect-slp.c 2019-10-25 13:26:59.141878743 +0100
+++ gcc/tree-vect-slp.c 2019-10-25 13:27:15.525762975 +0100
@@ -3087,12 +3087,12 @@ vect_slp_bb_region (gimple_stmt_iterator
unsigned int n_stmts)
{
bb_vec_info bb_vinfo;
- auto_vector_sizes vector_sizes;
+ auto_vector_modes vector_modes;
/* Autodetect first vector size we try. */
- poly_uint64 next_vector_size = 0;
- targetm.vectorize.autovectorize_vector_sizes (&vector_sizes, false);
- unsigned int next_size = 0;
+ machine_mode next_vector_mode = VOIDmode;
+ targetm.vectorize.autovectorize_vector_modes (&vector_modes, false);
+ unsigned int mode_i = 0;
vec_info_shared shared;
@@ -3109,7 +3109,7 @@ vect_slp_bb_region (gimple_stmt_iterator
bb_vinfo->shared->save_datarefs ();
else
bb_vinfo->shared->check_datarefs ();
- bb_vinfo->vector_size = next_vector_size;
+ bb_vinfo->vector_size = GET_MODE_SIZE (next_vector_mode);
if (vect_slp_analyze_bb_1 (bb_vinfo, n_stmts, fatal)
&& dbg_cnt (vect_slp))
@@ -3136,17 +3136,18 @@ vect_slp_bb_region (gimple_stmt_iterator
vectorized = true;
}
- if (next_size == 0)
+ if (mode_i == 0)
autodetected_vector_size = bb_vinfo->vector_size;
delete bb_vinfo;
- if (next_size < vector_sizes.length ()
- && known_eq (vector_sizes[next_size], autodetected_vector_size))
- next_size += 1;
+ if (mode_i < vector_modes.length ()
+ && known_eq (GET_MODE_SIZE (vector_modes[mode_i]),
+ autodetected_vector_size))
+ mode_i += 1;
if (vectorized
- || next_size == vector_sizes.length ()
+ || mode_i == vector_modes.length ()
|| known_eq (autodetected_vector_size, 0U)
/* If vect_slp_analyze_bb_1 signaled that analysis for all
vector sizes will fail do not bother iterating. */
@@ -3154,15 +3155,11 @@ vect_slp_bb_region (gimple_stmt_iterator
return vectorized;
/* Try the next biggest vector size. */
- next_vector_size = vector_sizes[next_size++];
+ next_vector_mode = vector_modes[mode_i++];
if (dump_enabled_p ())
- {
- dump_printf_loc (MSG_NOTE, vect_location,
- "***** Re-trying analysis with "
- "vector size ");
- dump_dec (MSG_NOTE, next_vector_size);
- dump_printf (MSG_NOTE, "\n");
- }
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "***** Re-trying analysis with vector mode %s\n",
+ GET_MODE_NAME (next_vector_mode));
}
}
Index: gcc/config/aarch64/aarch64.c
===================================================================
--- gcc/config/aarch64/aarch64.c 2019-10-25 13:26:59.177878488 +0100
+++ gcc/config/aarch64/aarch64.c 2019-10-25 13:27:15.505763118 +0100
@@ -15203,12 +15203,12 @@ aarch64_preferred_simd_mode (scalar_mode
/* Return a list of possible vector sizes for the vectorizer
to iterate over. */
static void
-aarch64_autovectorize_vector_sizes (vector_sizes *sizes, bool)
+aarch64_autovectorize_vector_modes (vector_modes *modes, bool)
{
if (TARGET_SVE)
- sizes->safe_push (BYTES_PER_SVE_VECTOR);
- sizes->safe_push (16);
- sizes->safe_push (8);
+ modes->safe_push (VNx16QImode);
+ modes->safe_push (V16QImode);
+ modes->safe_push (V8QImode);
}
/* Implement TARGET_MANGLE_TYPE. */
@@ -20915,9 +20915,9 @@ #define TARGET_VECTORIZE_BUILTINS
#define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
aarch64_builtin_vectorized_function
-#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
-#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
- aarch64_autovectorize_vector_sizes
+#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
+#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES \
+ aarch64_autovectorize_vector_modes
#undef TARGET_ATOMIC_ASSIGN_EXPAND_FENV
#define TARGET_ATOMIC_ASSIGN_EXPAND_FENV \
Index: gcc/config/arc/arc.c
===================================================================
--- gcc/config/arc/arc.c 2019-10-25 09:21:25.974346475 +0100
+++ gcc/config/arc/arc.c 2019-10-25 13:27:15.505763118 +0100
@@ -607,15 +607,15 @@ arc_preferred_simd_mode (scalar_mode mod
}
/* Implements target hook
- TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES. */
+ TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES. */
static void
-arc_autovectorize_vector_sizes (vector_sizes *sizes, bool)
+arc_autovectorize_vector_modes (vector_modes *modes, bool)
{
if (TARGET_PLUS_QMACW)
{
- sizes->quick_push (8);
- sizes->quick_push (4);
+ modes->quick_push (V4HImode);
+ modes->quick_push (V2HImode);
}
}
@@ -726,8 +726,8 @@ #define TARGET_VECTOR_MODE_SUPPORTED_P a
#undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
#define TARGET_VECTORIZE_PREFERRED_SIMD_MODE arc_preferred_simd_mode
-#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
-#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
arc_autovectorize_vector_sizes
+#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
+#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
arc_autovectorize_vector_modes
#undef TARGET_CAN_USE_DOLOOP_P
#define TARGET_CAN_USE_DOLOOP_P arc_can_use_doloop_p
Index: gcc/config/arm/arm.c
===================================================================
--- gcc/config/arm/arm.c 2019-10-23 11:29:47.933883742 +0100
+++ gcc/config/arm/arm.c 2019-10-25 13:27:15.513763059 +0100
@@ -289,7 +289,7 @@ static bool arm_builtin_support_vector_m
static void arm_conditional_register_usage (void);
static enum flt_eval_method arm_excess_precision (enum excess_precision_type);
static reg_class_t arm_preferred_rename_class (reg_class_t rclass);
-static void arm_autovectorize_vector_sizes (vector_sizes *, bool);
+static void arm_autovectorize_vector_modes (vector_modes *, bool);
static int arm_default_branch_cost (bool, bool);
static int arm_cortex_a5_branch_cost (bool, bool);
static int arm_cortex_m_branch_cost (bool, bool);
@@ -522,9 +522,9 @@ #define TARGET_VECTOR_MODE_SUPPORTED_P a
#define TARGET_ARRAY_MODE_SUPPORTED_P arm_array_mode_supported_p
#undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
#define TARGET_VECTORIZE_PREFERRED_SIMD_MODE arm_preferred_simd_mode
-#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
-#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
- arm_autovectorize_vector_sizes
+#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
+#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES \
+ arm_autovectorize_vector_modes
#undef TARGET_MACHINE_DEPENDENT_REORG
#define TARGET_MACHINE_DEPENDENT_REORG arm_reorg
@@ -29012,12 +29012,12 @@ arm_vector_alignment (const_tree type)
}
static void
-arm_autovectorize_vector_sizes (vector_sizes *sizes, bool)
+arm_autovectorize_vector_modes (vector_modes *modes, bool)
{
if (!TARGET_NEON_VECTORIZE_DOUBLE)
{
- sizes->safe_push (16);
- sizes->safe_push (8);
+ modes->safe_push (V16QImode);
+ modes->safe_push (V8QImode);
}
}
Index: gcc/config/i386/i386.c
===================================================================
--- gcc/config/i386/i386.c 2019-10-25 13:26:59.277877782 +0100
+++ gcc/config/i386/i386.c 2019-10-25 13:27:15.517763031 +0100
@@ -21387,35 +21387,35 @@ ix86_preferred_simd_mode (scalar_mode mo
256bit and 128bit vectors. */
static void
-ix86_autovectorize_vector_sizes (vector_sizes *sizes, bool all)
+ix86_autovectorize_vector_modes (vector_modes *modes, bool all)
{
if (TARGET_AVX512F && !TARGET_PREFER_AVX256)
{
- sizes->safe_push (64);
- sizes->safe_push (32);
- sizes->safe_push (16);
+ modes->safe_push (V64QImode);
+ modes->safe_push (V32QImode);
+ modes->safe_push (V16QImode);
}
else if (TARGET_AVX512F && all)
{
- sizes->safe_push (32);
- sizes->safe_push (16);
- sizes->safe_push (64);
+ modes->safe_push (V32QImode);
+ modes->safe_push (V16QImode);
+ modes->safe_push (V64QImode);
}
else if (TARGET_AVX && !TARGET_PREFER_AVX128)
{
- sizes->safe_push (32);
- sizes->safe_push (16);
+ modes->safe_push (V32QImode);
+ modes->safe_push (V16QImode);
}
else if (TARGET_AVX && all)
{
- sizes->safe_push (16);
- sizes->safe_push (32);
+ modes->safe_push (V16QImode);
+ modes->safe_push (V32QImode);
}
else if (TARGET_MMX_WITH_SSE)
- sizes->safe_push (16);
+ modes->safe_push (V16QImode);
if (TARGET_MMX_WITH_SSE)
- sizes->safe_push (8);
+ modes->safe_push (V8QImode);
}
/* Implemenation of targetm.vectorize.get_mask_mode. */
@@ -22954,9 +22954,9 @@ #define TARGET_VECTORIZE_PREFERRED_SIMD_
#undef TARGET_VECTORIZE_SPLIT_REDUCTION
#define TARGET_VECTORIZE_SPLIT_REDUCTION \
ix86_split_reduction
-#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
-#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
- ix86_autovectorize_vector_sizes
+#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
+#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES \
+ ix86_autovectorize_vector_modes
#undef TARGET_VECTORIZE_GET_MASK_MODE
#define TARGET_VECTORIZE_GET_MASK_MODE ix86_get_mask_mode
#undef TARGET_VECTORIZE_INIT_COST
Index: gcc/config/mips/mips.c
===================================================================
--- gcc/config/mips/mips.c 2019-10-17 14:22:54.903313423 +0100
+++ gcc/config/mips/mips.c 2019-10-25 13:27:15.517763031 +0100
@@ -13453,13 +13453,13 @@ mips_preferred_simd_mode (scalar_mode mo
return word_mode;
}
-/* Implement TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES. */
+/* Implement TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES. */
static void
-mips_autovectorize_vector_sizes (vector_sizes *sizes, bool)
+mips_autovectorize_vector_modes (vector_modes *modes, bool)
{
if (ISA_HAS_MSA)
- sizes->safe_push (16);
+ modes->safe_push (V16QImode);
}
/* Implement TARGET_INIT_LIBFUNCS. */
@@ -22694,9 +22694,9 @@ #define TARGET_SCALAR_MODE_SUPPORTED_P m
#undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
#define TARGET_VECTORIZE_PREFERRED_SIMD_MODE mips_preferred_simd_mode
-#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
-#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
- mips_autovectorize_vector_sizes
+#undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
+#define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES \
+ mips_autovectorize_vector_modes
#undef TARGET_INIT_BUILTINS
#define TARGET_INIT_BUILTINS mips_init_builtins
