- Change ToVectorTy to deal directly with ElementCount instances.
- VF == 1 replaced with VF.isScalar().
- VF > 1 and VF >=2 replaced with VF.isVector().
- VF <=1 is replaced with VF.isZero() || VF.isScalar().
- Replaced the uses of llvm::SmallSet<ElementCount, ...> with llvm::SmallSetVector<ElementCount, ...>. This avoids the need of an ordering function for the ElementCount class.
- Bits and pieces around printing the ElementCount to string streams.
To guarantee that this change is a NFC, VF.Min and asserts are used
in the following places:
- When it doesn't make sense to deal with the scalable property, for
a. When computing unrolling factors. b. When shuffle masks are built for fixed width vector types
In this cases, an
assert(!VF.Scalable && "<mgs>") has been added to make sure we don't
enter coepaths that don't make sense for scalable vectors.
- When there is a conscious decision to use FixedVectorType. These
uses of FixedVectorType will likely be removed in favour of
VectorType once the vectorizer is generic enough to deal with both
fixed vector types and scalable vector types.
- When dealing with building constants out of the value of VF, for
example when computing the vectorization step, or building vectors
of indices. These operation _make sense_ for scalable vectors too,
but changing the code in these places to be generic and make it work
for scalable vectors is to be submitted in a separate patch, as it is
a functional change.
- When building the potential VFs in VPlan. Making the VPlan generic
enough to handle scalable vectorization factors is a functional change
that needs a separate patch. See for example `void
LoopVectorizationPlanner::buildVPlans(unsigned MinVF, unsigned
- The class IntrinsicCostAttribute: this class still uses `unsigned
VF` as updating the field to use ElementCount woudl require changes
that could result in changing the behavior of the compiler. Will be done
in a separate patch.
- When dealing with user input for forcing the vectorization
factor. In this case, adding support for scalable vectorization is a
functional change that migh require changes at command line.
Note that in some places the idiom
unsigned VF = ... auto VTy = FixedVectorType::get(ScalarTy, VF)
has been replaced with
ElementCount VF = ... assert(!VF.Scalable && ...); auto VTy = VectorType::get(ScalarTy, VF)
The assertion guarantees that the new code is (at least in debug mode)
functionally equivalent to the old version. Notice that this change had been
possible because none of the methods that are specific to FixedVectorType
were used after the instantiation of VTy.