It gets more difficult to maintain this doesn't do any changes late
(see followups), so kill it.  We do have to retain re-setting of
LOOP_VINFO_PEELING_FOR_NITER though, since
vect_need_peeling_or_partial_vectors_p is incorrect for epilogues
when done during analysis.  We should fix this of course.

	* tree-vectorizer.h (vect_determine_partial_vectors_and_peeling):
	Remove.
	(vect_need_peeling_or_partial_vectors_p): Declare.
	* tree-vect-loop.cc (vect_determine_partial_vectors_and_peeling):
	Make static.
	(vect_need_peeling_or_partial_vectors_p): Export.
	* tree-vect-loop-manip.cc (vect_do_peeling): Do not call
	vect_determine_partial_vectors_and_peeling but instead
	re-compute LOOP_VINFO_PEELING_FOR_NITER using
	vect_need_peeling_or_partial_vectors_p.

This is a write-only parameter, it cannot be relied upon either.
So remove it.

	* tree-vectorizer.h (_loop_vec_info::epil_using_partial_vectors_p):
	Remove.
	(LOOP_VINFO_EPIL_USING_PARTIAL_VECTORS_P): Likewise.
	* tree-vect-loop.cc (_loop_vec_info::_loop_vec_info):
	Do not initialize epil_using_partial_vectors_p.
	(vect_determine_partial_vectors_and_peeling): Do not set it.

Consecutive load permutations like {0, 1, 2, 3} or {4, 5, 6, 7} in a
group of 8 only read a part of the group, leaving a gap.

For strided accesses we can elide the permutation and, instead of
accessing the whole group, use the number of SLP lanes.  This
effectively increases the vector size as we don't load gaps.  On top we
do not need to emit the permutes at all.

gcc/ChangeLog:

	* tree-vect-slp.cc (vect_load_perm_consecutive_p): New function.
	(vect_lower_load_permutations): Use.
	(vect_optimize_slp_pass::remove_redundant_permutations): Use.
	* tree-vect-stmts.cc (has_consecutive_load_permutation): New
	function that uses vect_load_perm_consecutive_p.
	(get_load_store_type): Use.
	(vectorizable_load): Reduce group size.
	* tree-vectorizer.h (struct vect_load_store_data): Add
	subchain_p.
	(vect_load_perm_consecutive_p): Declare.

gcc/testsuite/ChangeLog:

	* gcc.target/riscv/rvv/autovec/pr118019-2.c:

Similar to the signed/unsigned patch before this one relaxes the
gather/scatter restrictions on scale factors.  The basic idea is that a
natively unsupported scale factor can still be reached by emitting a
multiplication before the actual gather operation.  As before, we need
to make sure that there is no overflow when multiplying.

gcc/ChangeLog:

	* tree-vect-data-refs.cc (struct gather_scatter_config):
	Add scale.
	(vect_gather_scatter_get_configs): Try various scales.
	(vect_gather_scatter_fn_p): Add scale handling.
	(vect_check_gather_scatter): Add scale parameter.
	* tree-vect-stmts.cc (check_load_store_for_partial_vectors):
	Ditto.
	(vect_truncate_gather_scatter_offset): Ditto.
	(vect_use_grouped_gather): Ditto.
	(get_load_store_type): Ditto.
	(vectorizable_store): Scale offset if necessary.
	(vectorizable_load): Ditto.
	* tree-vectorizer.h (struct vect_load_store_data): Add
	supported_scale.
	(vect_gather_scatter_fn_p): Add argument.

This patch adjusts vect_gather_scatter_fn_p to always check an offset
type with swapped signedness (vs. the original offset argument).
If the target supports the gather/scatter with the new offset type as
well as the conversion of the offset we now emit an explicit offset
conversion before the actual gather/scatter.

The relaxation is only done for the IFN path of gather/scatter and the
general idea roughly looks like:

  - vect_gather_scatter_fn_p builds a list of all offset vector types
  that the target supports for the current vectype.  Then it goes
  through that list, trying direct support first and sign-swapped
  offset types next, taking precision requirements into account.
  If successful it sets supported_offset_vectype to the type that actually
  worked while offset_vectype_out is the type that was requested.
  - vect_check_gather_scatter works as before but uses the relaxed
  vect_gather_scatter_fn_p.
  - get_load_store_type sets ls_data->supported_offset_vectype if the
  requested type wasn't supported but another one was.
  - check_load_store_for_partial_vectors uses the
  supported_offset_vectype in order to validate what get_load_store_type
  determined.
  - vectorizable_load/store emit a conversion if
  ls_data->supported_offset_vectype is nonzero and cost it.

The offset type is either of pointer size (if we started with a signed
offset) or twice the size of the original offset (when that one was
unsigned).

gcc/ChangeLog:

	* tree-vect-data-refs.cc (struct gather_scatter_config): New
	struct to hold gather/scatter configurations.
	(vect_gather_scatter_which_ifn): New function to determine which
	IFN to use.
	(vect_gather_scatter_get_configs): New function to enumerate all
	target-supported configs.
	(vect_gather_scatter_fn_p): Rework to use
	vect_gather_scatter_get_configs and try sign-swapped offset.
	(vect_check_gather_scatter): Use new supported offset vectype
	argument.
	* tree-vect-stmts.cc (check_load_store_for_partial_vectors):
	Ditto.
	(vect_truncate_gather_scatter_offset): Ditto.
	(vect_use_grouped_gather): Ditto.
	(get_load_store_type): Ditto.
	(vectorizable_store): Convert to sign-swapped offset type if
	needed.
	(vectorizable_load): Ditto.
	* tree-vectorizer.h (struct vect_load_store_data): Add
	supported_offset_vectype.
	(vect_gather_scatter_fn_p): Add argument.

This patch fixes spelling errors in comments:
- "accomodate" -> "accommodate" in wide-int.h and value-range-storage.h
- "the the" -> "the" in tree-vectorizer.h

gcc/ChangeLog:

	* wide-int.h: Fix typo "accomodate" to "accommodate" in comment.
	* value-range-storage.h: Likewise.
	* tree-vectorizer.h (dr_set_safe_speculative_read_required):
	Fix duplicate "the the" to "the" in comment.

Signed-off-by: Osama Abdelkader <osama.abdelkader@gmail.com>

The following removes LOOP_VINFO_SLP_UNROLLING_FACTOR in favor of
using LOOP_VINFO_VECT_FACTOR directly now that there's no difference
between the two possible.

	* tree-vectorizer.h (_loop_vec_info::slp_unrolling_factor): Remove.
	(LOOP_VINFO_SLP_UNROLLING_FACTOR): Likewise.
	* tree-vect-loop.cc (_loop_vec_info::_loop_vec_info): Adjust.
	(vect_analyze_loop_2): Likewise.
	* tree-vect-slp.cc (vect_make_slp_decision): Set
	LOOP_VINFO_VECT_FACTOR directly.

Currently we mess up here in two places.  One is pattern recognition
which computes a mask-precision for a bool reduction PHI that's
inconsistent with that of the latch definition.  This is solved by
iterating the mask-precision computation.  The second is that the
reduction epilogue generation and the code querying support for it
isn't ready for mask inputs.  The following fixes this by falling
back to doing all the epilogue processing on a data type again, if
the target does not support a direct mask reduction.  For that we
utilize the newly added reduc_sbool_{and,ior,xor}_scal optabs
so we can go the direct IFN path on masks if the target supports
that.  In the future we can also implement an additional fallback
for IOR and AND reductions using a scalar cond-expr like
mask != 0 ? true : false, but the new optabs provide more information
to the target.

	PR tree-optimization/101639
	PR tree-optimization/103495
	* tree-vectorizer.h (vect_reduc_info_s): Add reduc_type_for_mask.
	(VECT_REDUC_INFO_VECTYPE_FOR_MASK): New.
	* tree-vect-patterns.cc (vect_determine_mask_precision):
	Return whether the mask precision changed.
	(vect_determine_precisions): Iterate mask precision computation
	for loop vectorization.
	* tree-vect-loop.cc (get_initial_defs_for_reduction): Properly
	convert non-mask initial values to a mask initial def for
	the reduction.
	(sbool_reduction_fn_for_fn): New function.
	(vect_create_epilog_for_reduction): For a mask input convert
	it to the vector type analysis decided to use.  Use a regular
	conversion for the final convert to the scalar code type.
	(vectorizable_reduction): Support mask reductions.  Verify
	we can compute a data vector from the mask result or a direct
	maks reduction is provided by the target.

	* gcc.dg/vect/vect-reduc-bool-1.c: New testcase.
	* gcc.dg/vect/vect-reduc-bool-2.c: Likewise.
	* gcc.dg/vect/vect-reduc-bool-3.c: Likewise.
	* gcc.dg/vect/vect-reduc-bool-4.c: Likewise.
	* gcc.dg/vect/vect-reduc-bool-5.c: Likewise.
	* gcc.dg/vect/vect-reduc-bool-6.c: Likewise.
	* gcc.dg/vect/vect-reduc-bool-7.c: Likewise.
	* gcc.dg/vect/vect-reduc-bool-8.c: Likewise.

The following removes REDUC_GROUP_* from the public vectorizer
interface and privatizes REDUC_GROUP_FIRST_ELEMENT which is now
only temporarily set during SLP discovery.

	* tree-vectorizer.h (REDUC_GROUP_FIRST_ELEMENT,
	REDUC_GROUP_NEXT_ELEMENT, REDUC_GROUP_SIZE): Remove.
	* tree-vect-slp.cc (REDUC_GROUP_FIRST_ELEMENT): Re-instantiate
	here.

This moves the setting of slp_perm, checking of basic-block SLP gaps, as
well as the final check for perm_ok to get_load_store_type.
Also, slp_perm is moved to ls_data.

gcc/ChangeLog:

	* tree-vect-stmts.cc (get_load_store_type): Add load-permutation
	checks and setting of slp_perm.
	(vectorizable_store): Remove perm_ok argument.
	(vectorizable_load): Ditto and replace slp_perm by ls.slp_perm.
	* tree-vectorizer.h (struct vect_load_store_data): Add slp_perm.