[llvm] 264afb9 - [NFC][llvm] Make the contructors of `ElementCount` private.
Voss, Matthew via llvm-commits
llvm-commits at lists.llvm.org
Wed Aug 19 14:43:25 PDT 2020
Thanks!
Matthew
> -----Original Message-----
> From: Francesco Petrogalli <Francesco.Petrogalli at arm.com>
> Sent: Wednesday, August 19, 2020 2:42 PM
> To: Voss, Matthew <Matthew.Voss at sony.com>
> Cc: LLVM Commits <llvm-commits at lists.llvm.org>
> Subject: Re: [llvm] 264afb9 - [NFC][llvm] Make the contructors of
> `ElementCount` private.
>
> Fix pushed as https://github.com/llvm/llvm-
> project/commit/dac0b1d33088429cdaf795e81e8576288460c67d
>
> Thank you for confirming the fix via https://reviews.llvm.org/D86240
>
> Kind regards,
>
> Francesco
>
> On 8/19/20, 3:12 PM, "Voss, Matthew" <Matthew.Voss at sony.com> wrote:
>
> OK, sounds good. Just FYI, the patch didn't resolve the build issues.
>
> Thanks,
> Matthew
>
> > -----Original Message-----
> > From: Francesco Petrogalli <Francesco.Petrogalli at arm.com>
> > Sent: Wednesday, August 19, 2020 1:07 PM
> > To: Voss, Matthew <Matthew.Voss at sony.com>; Francesco Petrogalli
> > <llvmlistbot at llvm.org>
> > Cc: LLVM Commits <llvm-commits at lists.llvm.org>
> > Subject: Re: [llvm] 264afb9 - [NFC][llvm] Make the contructors of
> > `ElementCount` private.
> >
> > I reacted too quickly, sorry. Trying to find a new solution.
> >
> > Francesco
> >
> > On 8/19/20, 2:53 PM, "Voss, Matthew" <Matthew.Voss at sony.com> wrote:
> >
> > Will do. My phab username is ormris.
> >
> > Thanks,
> > Matthew
> >
> > > -----Original Message-----
> > > From: Francesco Petrogalli <Francesco.Petrogalli at arm.com>
> > > Sent: Wednesday, August 19, 2020 12:52 PM
> > > To: Voss, Matthew <Matthew.Voss at sony.com>; Francesco
> Petrogalli
> > > <llvmlistbot at llvm.org>
> > > Cc: LLVM Commits <llvm-commits at lists.llvm.org>
> > > Subject: Re: [llvm] 264afb9 - [NFC][llvm] Make the contructors
> of
> > > `ElementCount` private.
> > >
> > > Please try this for me on your CI. In the meantime, I'll
> create a
> > phab
> > > review and add you as a reviewer. What is your phab username?
> > >
> > > Kind regards,
> > >
> > > Francesco
> > >
> > > commit fe3498cb9fb1277824b8d3403e0bb099b6d688dd
> > > Author: Francesco Petrogalli <francesco.petrogalli at arm.com>
> > > Date: Wed Aug 19 19:50:24 2020 +0000
> > >
> > > [llvm] Do not delete default constructor of
> > `llvm::ElementCount`.
> > >
> > > diff --git a/llvm/include/llvm/Support/TypeSize.h
> > > b/llvm/include/llvm/Support/TypeSize.h
> > > index a95d388..2abc6a3 100644
> > > --- a/llvm/include/llvm/Support/TypeSize.h
> > > +++ b/llvm/include/llvm/Support/TypeSize.h
> > > @@ -35,10 +35,6 @@ private:
> > > ElementCount(unsigned Min, bool Scalable) : Min(Min),
> > > Scalable(Scalable) {}
> > >
> > > public:
> > > - /// No default constructor. Users should use one of the
> `get*`
> > > - /// static methods below, as they should always make a
> conscious
> > > - /// choice on the type of `ElementCount` they are
> requesting.
> > > - ElementCount() = delete;
> > > unsigned Min; // Minimum number of vector elements.
> > > bool Scalable; // If true, NumElements is a multiple of
> 'Min'
> > > determined
> > > // at runtime rather than compile time.
> > >
> > >
> > >
> > >
> > > On 8/19/20, 2:49 PM, "Voss, Matthew" <Matthew.Voss at sony.com>
> wrote:
> > >
> > > Sure. Sounds good.
> > >
> > > Matthew
> > >
> > > > -----Original Message-----
> > > > From: Francesco Petrogalli
> <Francesco.Petrogalli at arm.com>
> > > > Sent: Wednesday, August 19, 2020 12:48 PM
> > > > To: Voss, Matthew <Matthew.Voss at sony.com>; Francesco
> > Petrogalli
> > > > <llvmlistbot at llvm.org>
> > > > Cc: LLVM Commits <llvm-commits at lists.llvm.org>
> > > > Subject: Re: [llvm] 264afb9 - [NFC][llvm] Make the
> contructors
> > of
> > > > `ElementCount` private.
> > > >
> > > > I think I have to reactivate the default constructor of
> the
> > class
> > > > ElementCount to fix the kind of error you see in this
> CI.
> > > >
> > > > Unfortunately I don't have a way to reproduce this
> workflow.
> > Is it
> > > OK is I
> > > > send you a patch that you could verify?
> > > >
> > > > I will type it while I wait for your reply.
> > > >
> > > > Francesco
> > > >
> > > > On 8/19/20, 2:45 PM, "Voss, Matthew"
> <Matthew.Voss at sony.com>
> > wrote:
> > > >
> > > > Hi Francesco,
> > > >
> > > > This commit is causing build failures on the PS4
> windows
> > bot.
> > > Could
> > > > you take a look?
> > > >
> > > > If this failure persists for long enough, I'm going
> to
> > need to
> > > revert
> > > > it to unclog our CI and the buildbots.
> > > >
> > > > http://lab.llvm.org:8011/builders/llvm-clang-lld-
> x86_64-
> > scei-
> > > ps4-
> > > > windows10pro-fast/builds/34173
> > > >
> > > > Thanks,
> > > > Matthew
> > > >
> > > > > -----Original Message-----
> > > > > From: llvm-commits <llvm-commits-
> bounces at lists.llvm.org>
> > On
> > > Behalf
> > > > Of
> > > > > Francesco Petrogalli via llvm-commits
> > > > > Sent: Wednesday, August 19, 2020 9:27 AM
> > > > > To: llvm-commits at lists.llvm.org
> > > > > Subject: [llvm] 264afb9 - [NFC][llvm] Make the
> > contructors of
> > > > > `ElementCount` private.
> > > > >
> > > > >
> > > > > Author: Francesco Petrogalli
> > > > > Date: 2020-08-19T16:26:44Z
> > > > > New Revision:
> 264afb9e6aebc98c353644dd0700bec808501cab
> > > > >
> > > > > URL: https://github.com/llvm/llvm-
> > > > >
> project/commit/264afb9e6aebc98c353644dd0700bec808501cab
> > > > > DIFF: https://github.com/llvm/llvm-
> > > > >
> > project/commit/264afb9e6aebc98c353644dd0700bec808501cab.diff
> > > > >
> > > > > LOG: [NFC][llvm] Make the contructors of
> `ElementCount`
> > > private.
> > > > >
> > > > > Differential Revision:
> https://reviews.llvm.org/D86120
> > > > >
> > > > > Added:
> > > > >
> > > > >
> > > > > Modified:
> > > > > llvm/include/llvm/Analysis/VectorUtils.h
> > > > > llvm/include/llvm/IR/DerivedTypes.h
> > > > > llvm/include/llvm/IR/Intrinsics.h
> > > > > llvm/include/llvm/Support/MachineValueType.h
> > > > > llvm/include/llvm/Support/TypeSize.h
> > > > > llvm/lib/Analysis/VFABIDemangling.cpp
> > > > > llvm/lib/AsmParser/LLParser.cpp
> > > > >
> > llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
> > > > > llvm/lib/CodeGen/TargetLoweringBase.cpp
> > > > > llvm/lib/CodeGen/ValueTypes.cpp
> > > > > llvm/lib/IR/ConstantFold.cpp
> > > > > llvm/lib/IR/Constants.cpp
> > > > > llvm/lib/IR/IRBuilder.cpp
> > > > > llvm/lib/IR/Instructions.cpp
> > > > > llvm/lib/IR/Type.cpp
> > > > >
> llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
> > > > >
> llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
> > > > >
> llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
> > > > > llvm/unittests/Analysis/VectorUtilsTest.cpp
> > > > >
> llvm/unittests/CodeGen/ScalableVectorMVTsTest.cpp
> > > > > llvm/unittests/FuzzMutate/OperationsTest.cpp
> > > > > llvm/unittests/IR/ConstantsTest.cpp
> > > > > llvm/unittests/IR/PatternMatch.cpp
> > > > > llvm/unittests/IR/VectorTypesTest.cpp
> > > > > llvm/unittests/IR/VerifierTest.cpp
> > > > >
> > > > > Removed:
> > > > >
> > > > >
> > > > >
> > > > >
> > > >
> > >
> >
> ##########################################################################
> > > > > ######
> > > > > diff --git
> a/llvm/include/llvm/Analysis/VectorUtils.h
> > > > > b/llvm/include/llvm/Analysis/VectorUtils.h
> > > > > index a860652b2332..f77048d45d01 100644
> > > > > --- a/llvm/include/llvm/Analysis/VectorUtils.h
> > > > > +++ b/llvm/include/llvm/Analysis/VectorUtils.h
> > > > > @@ -99,7 +99,8 @@ struct VFShape {
> > > > > // Retrieve the VFShape that can be used to map
> a
> > (scalar)
> > > > function to
> > > > > itself,
> > > > > // with VF = 1.
> > > > > static VFShape getScalarShape(const CallInst
> &CI) {
> > > > > - return VFShape::get(CI, /*EC*/ {1, false},
> > > > /*HasGlobalPredicate*/
> > > > > false);
> > > > > + return VFShape::get(CI,
> ElementCount::getFixed(1),
> > > > > + /*HasGlobalPredicate*/
> false);
> > > > > }
> > > > >
> > > > > // Retrieve the basic vectorization shape of
> the
> > function,
> > > where
> > > > all @@
> > > > > -305,7 +306,7 @@ typedef unsigned ID; inline Type
> > > *ToVectorTy(Type
> > > > > *Scalar, unsigned VF, bool isScalable = false) {
> > > > > if (Scalar->isVoidTy() || VF == 1)
> > > > > return Scalar;
> > > > > - return VectorType::get(Scalar, {VF,
> isScalable});
> > > > > + return VectorType::get(Scalar,
> ElementCount::get(VF,
> > > > isScalable));
> > > > > }
> > > > >
> > > > > /// Identify if the intrinsic is trivially
> > vectorizable.
> > > > >
> > > > > diff --git a/llvm/include/llvm/IR/DerivedTypes.h
> > > > > b/llvm/include/llvm/IR/DerivedTypes.h
> > > > > index 843809909d7c..1837f6808f24 100644
> > > > > --- a/llvm/include/llvm/IR/DerivedTypes.h
> > > > > +++ b/llvm/include/llvm/IR/DerivedTypes.h
> > > > > @@ -446,7 +446,8 @@ class VectorType : public Type
> {
> > > > >
> > > > > static VectorType *get(Type *ElementType,
> unsigned
> > > NumElements,
> > > > > bool Scalable) {
> > > > > - return VectorType::get(ElementType,
> {NumElements,
> > > Scalable});
> > > > > + return VectorType::get(ElementType,
> > > > > +
> > ElementCount::get(NumElements,
> > > > Scalable));
> > > > > }
> > > > >
> > > > > static VectorType *get(Type *ElementType, const
> > VectorType
> > > > *Other) { @@
> > > > > -640,7 +641,7 @@ class ScalableVectorType : public
> > VectorType
> > > { };
> > > > >
> > > > > inline ElementCount VectorType::getElementCount()
> const
> > {
> > > > > - return ElementCount(ElementQuantity,
> > > > isa<ScalableVectorType>(this));
> > > > > + return ElementCount::get(ElementQuantity,
> > > > > + isa<ScalableVectorType>(this));
> > > > > }
> > > > >
> > > > > /// Class to represent pointers.
> > > > >
> > > > > diff --git a/llvm/include/llvm/IR/Intrinsics.h
> > > > > b/llvm/include/llvm/IR/Intrinsics.h
> > > > > index a9e6525e2f3d..3fc7c5a2ceb4 100644
> > > > > --- a/llvm/include/llvm/IR/Intrinsics.h
> > > > > +++ b/llvm/include/llvm/IR/Intrinsics.h
> > > > > @@ -134,7 +134,9 @@ namespace Intrinsic {
> > > > > unsigned Pointer_AddressSpace;
> > > > > unsigned Struct_NumElements;
> > > > > unsigned Argument_Info;
> > > > > - ElementCount Vector_Width;
> > > > > + // There is no default constructor in
> > `ElementCount`,
> > > so we
> > > > need
> > > > > + // to explicitly initialize this field with
> a
> > value.
> > > > > + ElementCount Vector_Width =
> > ElementCount::getFixed(0);
> > > > > };
> > > > >
> > > > > enum ArgKind {
> > > > > @@ -190,8 +192,7 @@ namespace Intrinsic {
> > > > > static IITDescriptor getVector(unsigned
> Width, bool
> > > IsScalable)
> > > > {
> > > > > IITDescriptor Result;
> > > > > Result.Kind = Vector;
> > > > > - Result.Vector_Width.Min = Width;
> > > > > - Result.Vector_Width.Scalable = IsScalable;
> > > > > + Result.Vector_Width =
> ElementCount::get(Width,
> > > IsScalable);
> > > > > return Result;
> > > > > }
> > > > > };
> > > > >
> > > > > diff --git
> > a/llvm/include/llvm/Support/MachineValueType.h
> > > > > b/llvm/include/llvm/Support/MachineValueType.h
> > > > > index 3bb8220e72e5..172d4fd8c275 100644
> > > > > --- a/llvm/include/llvm/Support/MachineValueType.h
> > > > > +++ b/llvm/include/llvm/Support/MachineValueType.h
> > > > > @@ -737,7 +737,7 @@ namespace llvm {
> > > > > }
> > > > >
> > > > > ElementCount getVectorElementCount() const {
> > > > > - return { getVectorNumElements(),
> > isScalableVector() };
> > > > > + return
> ElementCount::get(getVectorNumElements(),
> > > > > + isScalableVector());
> > > > > }
> > > > >
> > > > > /// Given a vector type, return the minimum
> number
> > of
> > > elements
> > > > it
> > > > > contains.
> > > > >
> > > > > diff --git a/llvm/include/llvm/Support/TypeSize.h
> > > > > b/llvm/include/llvm/Support/TypeSize.h
> > > > > index d5a3614155b8..a95d38863035 100644
> > > > > --- a/llvm/include/llvm/Support/TypeSize.h
> > > > > +++ b/llvm/include/llvm/Support/TypeSize.h
> > > > > @@ -26,16 +26,23 @@ namespace llvm {
> > > > > template <typename T> struct DenseMapInfo;
> > > > >
> > > > > class ElementCount {
> > > > > +private:
> > > > > + /// Prevent code from using initializer-list
> > contructors
> > > like
> > > > > + /// ElementCount EC = {<unsigned>, <bool>}. The
> > static
> > > `get*`
> > > > > + /// methods below are preferred, as users
> should
> > always
> > > make a
> > > > > + /// conscious choice on the type of
> `ElementCount`
> > they are
> > > > > + /// requesting.
> > > > > + ElementCount(unsigned Min, bool Scalable) :
> Min(Min),
> > > > > +Scalable(Scalable) {}
> > > > > +
> > > > > public:
> > > > > + /// No default constructor. Users should use
> one of
> > the
> > > `get*`
> > > > ///
> > > > > + static methods below, as they should always make
> a
> > conscious
> > > ///
> > > > > + choice on the type of `ElementCount` they are
> > requesting.
> > > > > + ElementCount() = delete;
> > > > > unsigned Min; // Minimum number of vector
> elements.
> > > > > bool Scalable; // If true, NumElements is a
> multiple
> > of
> > > 'Min'
> > > > > determined
> > > > > // at runtime rather than
> compile
> > time.
> > > > >
> > > > > - ElementCount() = default;
> > > > > -
> > > > > - ElementCount(unsigned Min, bool Scalable)
> > > > > - : Min(Min), Scalable(Scalable) {}
> > > > > -
> > > > > ElementCount operator*(unsigned RHS) {
> > > > > return { Min * RHS, Scalable };
> > > > > }
> > > > > @@ -54,7 +61,13 @@ class ElementCount {
> > > > > bool operator!=(unsigned RHS) const { return
> !(*this
> > ==
> > > RHS); }
> > > > >
> > > > > ElementCount NextPowerOf2() const {
> > > > > - return ElementCount(llvm::NextPowerOf2(Min),
> > Scalable);
> > > > > + return {(unsigned)llvm::NextPowerOf2(Min),
> > Scalable}; }
> > > > > +
> > > > > + static ElementCount getFixed(unsigned Min) {
> return
> > {Min,
> > > false};
> > > > }
> > > > > + static ElementCount getScalable(unsigned Min) {
> return
> > {Min,
> > > > true}; }
> > > > > + static ElementCount get(unsigned Min, bool
> Scalable) {
> > > > > + return {Min, Scalable};
> > > > > }
> > > > > };
> > > > >
> > > > > @@ -279,8 +292,12 @@ inline TypeSize
> alignTo(TypeSize
> > Size,
> > > uint64_t
> > > > > Align) { }
> > > > >
> > > > > template <> struct DenseMapInfo<ElementCount> {
> > > > > - static inline ElementCount getEmptyKey() {
> return
> > {~0U,
> > > true}; }
> > > > > - static inline ElementCount getTombstoneKey() {
> return
> > {~0U
> > > - 1,
> > > > false};
> > > > > }
> > > > > + static inline ElementCount getEmptyKey() {
> > > > > + return ElementCount::getScalable(~0U); }
> static
> > inline
> > > > > + ElementCount getTombstoneKey() {
> > > > > + return ElementCount::getFixed(~0U - 1); }
> > > > > static unsigned getHashValue(const
> ElementCount&
> > EltCnt) {
> > > > > if (EltCnt.Scalable)
> > > > > return (EltCnt.Min * 37U) - 1U;
> > > > >
> > > > > diff --git
> a/llvm/lib/Analysis/VFABIDemangling.cpp
> > > > > b/llvm/lib/Analysis/VFABIDemangling.cpp
> > > > > index 0192a216b2f7..56155b28132e 100644
> > > > > --- a/llvm/lib/Analysis/VFABIDemangling.cpp
> > > > > +++ b/llvm/lib/Analysis/VFABIDemangling.cpp
> > > > > @@ -310,7 +310,7 @@ ElementCount
> > > getECFromSignature(FunctionType
> > > > > *Signature) {
> > > > > if (auto *VTy = dyn_cast<VectorType>(Ty))
> > > > > return VTy->getElementCount();
> > > > >
> > > > > - return ElementCount(/*Min=*/1,
> /*Scalable=*/false);
> > > > > + return ElementCount::getFixed(/*Min=*/1);
> > > > > }
> > > > > } // namespace
> > > > >
> > > > >
> > > > > diff --git a/llvm/lib/AsmParser/LLParser.cpp
> > > > > b/llvm/lib/AsmParser/LLParser.cpp index
> > > 06e5709983ea..fec10b8605c2
> > > > 100644
> > > > > --- a/llvm/lib/AsmParser/LLParser.cpp
> > > > > +++ b/llvm/lib/AsmParser/LLParser.cpp
> > > > > @@ -7395,7 +7395,7 @@ int
> > > LLParser::ParseGetElementPtr(Instruction
> > > > *&Inst,
> > > > > PerFunctionState &PFS) {
> > > > > // All vector parameters should have the same
> vector
> > width.
> > > > > ElementCount GEPWidth = BaseType->isVectorTy()
> > > > > ?
> > cast<VectorType>(BaseType)-
> > > > > >getElementCount()
> > > > > - : ElementCount(0,
> false);
> > > > > + :
> > ElementCount::getFixed(0);
> > > > >
> > > > > while (EatIfPresent(lltok::comma)) {
> > > > > if (Lex.getKind() == lltok::MetadataVar) { @@
> -
> > 7408,7
> > > +7408,7
> > > > @@ int
> > > > > LLParser::ParseGetElementPtr(Instruction *&Inst,
> > > PerFunctionState
> > > > &PFS) {
> > > > >
> > > > > if (auto *ValVTy = dyn_cast<VectorType>(Val-
> > >getType()))
> > > {
> > > > > ElementCount ValNumEl = ValVTy-
> > >getElementCount();
> > > > > - if (GEPWidth != ElementCount(0, false) &&
> > GEPWidth !=
> > > > ValNumEl)
> > > > > + if (GEPWidth != ElementCount::getFixed(0)
> &&
> > GEPWidth
> > > !=
> > > > > + ValNumEl)
> > > > > return Error(EltLoc,
> > > > > "getelementptr vector index has a wrong
> > number of
> > > > elements");
> > > > > GEPWidth = ValNumEl;
> > > > >
> > > > > diff --git
> > > a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
> > > > >
> b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
> > > > > index fd1859afee43..80a2db2a6b24 100644
> > > > > ---
> > a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
> > > > > +++
> > b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
> > > > > @@ -729,15 +729,15 @@ static void
> > > getCopyToPartsVector(SelectionDAG
> > > > &DAG,
> > > > > const SDLoc &DL,
> > > > > assert(IntermediateVT.isScalableVector() ==
> > > > ValueVT.isScalableVector()
> > > > > &&
> > > > > "Mixing scalable and fixed vectors when
> > copying in
> > > > parts");
> > > > >
> > > > > - ElementCount DestEltCnt;
> > > > > + Optional<ElementCount> DestEltCnt;
> > > > >
> > > > > if (IntermediateVT.isVector())
> > > > > DestEltCnt =
> IntermediateVT.getVectorElementCount()
> > *
> > > > > NumIntermediates;
> > > > > else
> > > > > - DestEltCnt = ElementCount(NumIntermediates,
> false);
> > > > > + DestEltCnt =
> > ElementCount::getFixed(NumIntermediates);
> > > > >
> > > > > EVT BuiltVectorTy = EVT::getVectorVT(
> > > > > - *DAG.getContext(),
> > IntermediateVT.getScalarType(),
> > > > DestEltCnt);
> > > > > + *DAG.getContext(),
> > IntermediateVT.getScalarType(),
> > > > > + DestEltCnt.getValue());
> > > > > if (ValueVT != BuiltVectorTy) {
> > > > > if (SDValue Widened =
> widenVectorToPartType(DAG,
> > Val, DL,
> > > > > BuiltVectorTy))
> > > > > Val = Widened;
> > > > > @@ -3746,7 +3746,7 @@ void
> > > > SelectionDAGBuilder::visitGetElementPtr(const
> > > > > User &I) {
> > > > > bool IsVectorGEP = I.getType()->isVectorTy();
> > > > > ElementCount VectorElementCount =
> > > > > IsVectorGEP ?
> cast<VectorType>(I.getType())-
> > > > >getElementCount()
> > > > > - : ElementCount(0, false);
> > > > > + : ElementCount::getFixed(0);
> > > > >
> > > > > if (IsVectorGEP &&
> !N.getValueType().isVector()) {
> > > > > LLVMContext &Context = *DAG.getContext();
> > > > >
> > > > > diff --git
> a/llvm/lib/CodeGen/TargetLoweringBase.cpp
> > > > > b/llvm/lib/CodeGen/TargetLoweringBase.cpp
> > > > > index 63e55c9c47e3..868302abc999 100644
> > > > > --- a/llvm/lib/CodeGen/TargetLoweringBase.cpp
> > > > > +++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp
> > > > > @@ -866,7 +866,7 @@
> > > > TargetLoweringBase::getTypeConversion(LLVMContext
> > > > > &Context, EVT VT) const {
> > > > > if (NumElts == 1)
> > > > > return LegalizeKind(TypeScalarizeVector,
> EltVT);
> > > > >
> > > > > - if (VT.getVectorElementCount() ==
> ElementCount(1,
> > true))
> > > > > + if (VT.getVectorElementCount() ==
> > > ElementCount::getScalable(1))
> > > > > report_fatal_error("Cannot legalize this
> vector");
> > > > >
> > > > > // Try to widen vector elements until the
> element
> > type is a
> > > power
> > > > of
> > > > > two and
> > > > >
> > > > > diff --git a/llvm/lib/CodeGen/ValueTypes.cpp
> > > > > b/llvm/lib/CodeGen/ValueTypes.cpp index
> > > 57e26e8cb7a1..c3974519bfc6
> > > > 100644
> > > > > --- a/llvm/lib/CodeGen/ValueTypes.cpp
> > > > > +++ b/llvm/lib/CodeGen/ValueTypes.cpp
> > > > > @@ -49,8 +49,7 @@ EVT
> > EVT::getExtendedVectorVT(LLVMContext
> > > &Context,
> > > > EVT
> > > > > VT, unsigned NumElements,
> > > > >
> > > > > EVT EVT::getExtendedVectorVT(LLVMContext
> &Context, EVT
> > VT,
> > > > ElementCount
> > > > > EC) {
> > > > > EVT ResultVT;
> > > > > - ResultVT.LLVMTy =
> > > > > - VectorType::get(VT.getTypeForEVT(Context),
> > {EC.Min,
> > > > EC.Scalable});
> > > > > + ResultVT.LLVMTy =
> > > VectorType::get(VT.getTypeForEVT(Context), EC);
> > > > > assert(ResultVT.isExtended() && "Type is not
> > extended!");
> > > > > return ResultVT;
> > > > > }
> > > > >
> > > > > diff --git a/llvm/lib/IR/ConstantFold.cpp
> > > > b/llvm/lib/IR/ConstantFold.cpp
> > > > > index 2d3afca6d58c..e5c4250665e4 100644
> > > > > --- a/llvm/lib/IR/ConstantFold.cpp
> > > > > +++ b/llvm/lib/IR/ConstantFold.cpp
> > > > > @@ -919,7 +919,8 @@ Constant
> > > > >
> *llvm::ConstantFoldShuffleVectorInstruction(Constant
> > *V1,
> > > Constant
> > > > *V2,
> > > > >
> > > ArrayRef<int>
> > > > Mask)
> > > > > {
> > > > > auto *V1VTy = cast<VectorType>(V1->getType());
> > > > > unsigned MaskNumElts = Mask.size();
> > > > > - ElementCount MaskEltCount = {MaskNumElts,
> > > > > isa<ScalableVectorType>(V1VTy)};
> > > > > + auto MaskEltCount =
> > > > > + ElementCount::get(MaskNumElts,
> > > > isa<ScalableVectorType>(V1VTy));
> > > > > Type *EltTy = V1VTy->getElementType();
> > > > >
> > > > > // Undefined shuffle mask -> undefined value.
> > > > >
> > > > > diff --git a/llvm/lib/IR/Constants.cpp
> > > b/llvm/lib/IR/Constants.cpp
> > > > index
> > > > > cbbcca20ea51..b252ef71c8ee 100644
> > > > > --- a/llvm/lib/IR/Constants.cpp
> > > > > +++ b/llvm/lib/IR/Constants.cpp
> > > > > @@ -2245,7 +2245,7 @@ Constant
> > > *ConstantExpr::getGetElementPtr(Type
> > > > *Ty,
> > > > > Constant *C,
> > > > > unsigned AS = C->getType()-
> >getPointerAddressSpace();
> > > > > Type *ReqTy = DestTy->getPointerTo(AS);
> > > > >
> > > > > - ElementCount EltCount = {0, false};
> > > > > + auto EltCount = ElementCount::getFixed(0);
> > > > > if (VectorType *VecTy = dyn_cast<VectorType>(C-
> > >getType()))
> > > > > EltCount = VecTy->getElementCount();
> > > > > else
> > > > > @@ -2938,7 +2938,7 @@ Constant
> > > > *ConstantDataVector::getSplat(unsigned
> > > > > NumElts, Constant *V) {
> > > > > return getFP(V->getType(), Elts);
> > > > > }
> > > > > }
> > > > > - return ConstantVector::getSplat({NumElts,
> false}, V);
> > > > > + return
> > > ConstantVector::getSplat(ElementCount::getFixed(NumElts),
> > > > V);
> > > > > }
> > > > >
> > > > >
> > > > >
> > > > > diff --git a/llvm/lib/IR/IRBuilder.cpp
> > > b/llvm/lib/IR/IRBuilder.cpp
> > > > index
> > > > > f059f80ecec4..1de25c25cd05 100644
> > > > > --- a/llvm/lib/IR/IRBuilder.cpp
> > > > > +++ b/llvm/lib/IR/IRBuilder.cpp
> > > > > @@ -997,7 +997,7 @@ Value
> > > > *IRBuilderBase::CreateStripInvariantGroup(Value
> > > > > *Ptr) {
> > > > >
> > > > > Value *IRBuilderBase::CreateVectorSplat(unsigned
> > NumElts,
> > > Value *V,
> > > > > const
> Twine
> > &Name) {
> > > > > - ElementCount EC(NumElts, false);
> > > > > + auto EC = ElementCount::getFixed(NumElts);
> > > > > return CreateVectorSplat(EC, V, Name); }
> > > > >
> > > > >
> > > > > diff --git a/llvm/lib/IR/Instructions.cpp
> > > > b/llvm/lib/IR/Instructions.cpp
> > > > > index 2f17a0d73af4..7a3fbc367d1c 100644
> > > > > --- a/llvm/lib/IR/Instructions.cpp
> > > > > +++ b/llvm/lib/IR/Instructions.cpp
> > > > > @@ -3330,9 +3330,9 @@
> > > CastInst::castIsValid(Instruction::CastOps op,
> > > > Value
> > > > > *S, Type *DstTy) {
> > > > > // scalar types means that checking that vector
> > lengths
> > > match
> > > > also
> > > > > checks that
> > > > > // scalars are not being converted to vectors
> or
> > vectors to
> > > > scalars).
> > > > > ElementCount SrcEC = SrcIsVec ?
> > cast<VectorType>(SrcTy)-
> > > > > >getElementCount()
> > > > > - : ElementCount(0,
> > false);
> > > > > + :
> > ElementCount::getFixed(0);
> > > > > ElementCount DstEC = DstIsVec ?
> > cast<VectorType>(DstTy)-
> > > > > >getElementCount()
> > > > > - : ElementCount(0,
> > false);
> > > > > + :
> > ElementCount::getFixed(0);
> > > > >
> > > > > // Switch on the opcode provided
> > > > > switch (op) {
> > > > > @@ -3390,9 +3390,9 @@
> > > CastInst::castIsValid(Instruction::CastOps op,
> > > > Value
> > > > > *S, Type *DstTy) {
> > > > > if (SrcIsVec && DstIsVec)
> > > > > return SrcEC == DstEC;
> > > > > if (SrcIsVec)
> > > > > - return SrcEC == ElementCount(1, false);
> > > > > + return SrcEC == ElementCount::getFixed(1);
> > > > > if (DstIsVec)
> > > > > - return DstEC == ElementCount(1, false);
> > > > > + return DstEC == ElementCount::getFixed(1);
> > > > >
> > > > > return true;
> > > > > }
> > > > >
> > > > > diff --git a/llvm/lib/IR/Type.cpp
> > b/llvm/lib/IR/Type.cpp
> > > index
> > > > > d869a6e07cca..1cf0d1345ab3 100644
> > > > > --- a/llvm/lib/IR/Type.cpp
> > > > > +++ b/llvm/lib/IR/Type.cpp
> > > > > @@ -619,7 +619,7 @@ FixedVectorType
> > *FixedVectorType::get(Type
> > > > > *ElementType, unsigned NumElts) {
> > > > > "be
> an
> > integer,
> > > > floating
> > > > > point, or "
> > > > >
> "pointer
> > type.");
> > > > >
> > > > > - ElementCount EC(NumElts, false);
> > > > > + auto EC = ElementCount::getFixed(NumElts);
> > > > >
> > > > > LLVMContextImpl *pImpl = ElementType-
> > >getContext().pImpl;
> > > > > VectorType *&Entry = ElementType->getContext()
> @@ -
> > 641,7
> > > +641,7
> > > > @@
> > > > > ScalableVectorType *ScalableVectorType::get(Type
> > *ElementType,
> > > > > "be
> an
> > integer,
> > > > floating
> > > > > point, or "
> > > > >
> "pointer
> > type.");
> > > > >
> > > > > - ElementCount EC(MinNumElts, true);
> > > > > + auto EC =
> ElementCount::getScalable(MinNumElts);
> > > > >
> > > > > LLVMContextImpl *pImpl = ElementType-
> > >getContext().pImpl;
> > > > > VectorType *&Entry = ElementType->getContext()
> > > > >
> > > > > diff --git
> > a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
> > > > > b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
> > > > > index b37947495a43..6c7624304e90 100644
> > > > > ---
> a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
> > > > > +++
> b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
> > > > > @@ -11985,7 +11985,8 @@ static SDValue
> > > LowerSVEIntrinsicEXT(SDNode
> > > > *N,
> > > > > SelectionDAG &DAG) {
> > > > >
> > > > > unsigned ElemSize =
> > > VT.getVectorElementType().getSizeInBits() /
> > > > 8;
> > > > > unsigned ByteSize =
> > VT.getSizeInBits().getKnownMinSize() /
> > > 8;
> > > > > - EVT ByteVT = EVT::getVectorVT(Ctx, MVT::i8, {
> > ByteSize,
> > > true });
> > > > > + EVT ByteVT =
> > > > > + EVT::getVectorVT(Ctx, MVT::i8,
> > > > > + ElementCount::getScalable(ByteSize));
> > > > >
> > > > > // Convert everything to the domain of EXT (i.e
> > bytes).
> > > > > SDValue Op0 = DAG.getNode(ISD::BITCAST, dl,
> ByteVT,
> > N-
> > > > >getOperand(1));
> > > > >
> > > > > diff --git
> > a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
> > > > > b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
> > > > > index ee8289983687..90a8d4703d65 100644
> > > > > ---
> a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
> > > > > +++
> b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
> > > > > @@ -1804,10 +1804,10 @@ void
> > > > >
> InnerLoopVectorizer::createVectorIntOrFpInductionPHI(
> > > > > // FIXME: If the step is non-constant, we
> create the
> > vector
> > > splat
> > > > with
> > > > > // IRBuilder. IRBuilder can constant-
> fold the
> > > multiply,
> > > > but it
> > > > > doesn't
> > > > > // handle a constant vector splat.
> > > > > - Value *SplatVF =
> > > > > - isa<Constant>(Mul)
> > > > > - ? ConstantVector::getSplat({VF, false},
> > > > cast<Constant>(Mul))
> > > > > - : Builder.CreateVectorSplat(VF, Mul);
> > > > > + Value *SplatVF = isa<Constant>(Mul)
> > > > > + ?
> > > > >
> ConstantVector::getSplat(ElementCount::getFixed(VF),
> > > > > +
> > > > cast<Constant>(Mul))
> > > > > + :
> Builder.CreateVectorSplat(VF,
> > Mul);
> > > > > Builder.restoreIP(CurrIP);
> > > > >
> > > > > // We may need to add the step a number of
> times,
> > depending
> > > on
> > > > the
> > > > > unroll @@ -3399,7 +3399,8 @@ unsigned
> > > > >
> LoopVectorizationCostModel::getVectorCallCost(CallInst
> > *CI,
> > > > > // If we can't emit a vector call for this
> function,
> > then
> > > the
> > > > currently
> > > > > found
> > > > > // cost is the cost we need to return.
> > > > > NeedToScalarize = true;
> > > > > - VFShape Shape = VFShape::get(*CI, {VF, false},
> false
> > > > > /*HasGlobalPred*/);
> > > > > + VFShape Shape =
> > > > > + VFShape::get(*CI,
> ElementCount::getFixed(VF),
> > false
> > > > > + /*HasGlobalPred*/);
> > > > > Function *VecFunc =
> > > VFDatabase(*CI).getVectorizedFunction(Shape);
> > > > >
> > > > > if (!TLI || CI->isNoBuiltin() || !VecFunc) @@ -
> 3860,7
> > > +3861,7 @@
> > > > void
> > > > > InnerLoopVectorizer::fixReduction(PHINode *Phi) {
> > > > > // incoming scalar reduction.
> > > > > VectorStart = ReductionStartValue;
> > > > > } else {
> > > > > - Identity = ConstantVector::getSplat({VF,
> false},
> > Iden);
> > > > > + Identity =
> > > > ConstantVector::getSplat(ElementCount::getFixed(VF),
> > > > > + Iden);
> > > > >
> > > > > // This vector is the Identity vector where
> the
> > first
> > > element
> > > > is
> > > > > the
> > > > > // incoming scalar reduction.
> > > > > @@ -4541,8 +4542,8 @@ void
> > > > > InnerLoopVectorizer::widenCallInstruction(CallInst
> &I,
> > VPUser
> > > > > &ArgOperands,
> > > > > assert(VectorF && "Can't retrieve vector
> > intrinsic.");
> > > > > } else {
> > > > > // Use vector version of the function call.
> > > > > - const VFShape Shape =
> > > > > - VFShape::get(*CI, {VF, false} /*EC*/,
> false
> > > > /*HasGlobalPred*/);
> > > > > + const VFShape Shape = VFShape::get(*CI,
> > > > ElementCount::getFixed(VF),
> > > > > + false
> > > /*HasGlobalPred*/);
> > > > > #ifndef NDEBUG
> > > > >
> > assert(VFDatabase(*CI).getVectorizedFunction(Shape) !=
> > > > nullptr &&
> > > > > "Can't create vector function.");
> > > > >
> > > > > diff --git
> > a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
> > > > > b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
> > > > > index 6a5e8e25951c..6d8a12ab25ad 100644
> > > > > ---
> a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
> > > > > +++
> b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
> > > > > @@ -3029,7 +3029,7 @@ void
> > > BoUpSLP::buildTree_rec(ArrayRef<Value *>
> > > > VL,
> > > > > unsigned Depth,
> > > > > Intrinsic::ID ID =
> > getVectorIntrinsicIDForCall(CI,
> > > TLI);
> > > > >
> > > > > VFShape Shape = VFShape::get(
> > > > > - *CI, {static_cast<unsigned
> int>(VL.size()),
> > false
> > > > > /*Scalable*/},
> > > > > + *CI,
> > ElementCount::getFixed(static_cast<unsigned
> > > > > + int>(VL.size())),
> > > > > false /*HasGlobalPred*/);
> > > > > Function *VecFunc =
> > > > VFDatabase(*CI).getVectorizedFunction(Shape);
> > > > >
> > > > > @@ -3264,9 +3264,9 @@ getVectorCallCosts(CallInst
> *CI,
> > > VectorType
> > > > *VecTy,
> > > > > TargetTransformInfo *TTI,
> > > > > int IntrinsicCost =
> > > > > TTI->getIntrinsicInstrCost(CostAttrs,
> > > > TTI::TCK_RecipThroughput);
> > > > >
> > > > > - auto Shape =
> > > > > - VFShape::get(*CI,
> {static_cast<unsigned>(VecTy-
> > > > >getNumElements()),
> > > > > false},
> > > > > - false /*HasGlobalPred*/);
> > > > > + auto Shape = VFShape::get(*CI,
> > > > > ElementCount::getFixed(static_cast<unsigned>(
> > > > > + VecTy-
> > > >getNumElements())),
> > > > > + false
> /*HasGlobalPred*/);
> > > > > Function *VecFunc =
> > > VFDatabase(*CI).getVectorizedFunction(Shape);
> > > > > int LibCost = IntrinsicCost;
> > > > > if (!CI->isNoBuiltin() && VecFunc) {
> > > > > @@ -4553,9 +4553,10 @@ Value
> > *BoUpSLP::vectorizeTree(TreeEntry
> > > *E) {
> > > > >
> > > > > Function *CF;
> > > > > if (!UseIntrinsic) {
> > > > > - VFShape Shape = VFShape::get(
> > > > > - *CI, {static_cast<unsigned>(VecTy-
> > > >getNumElements()),
> > > > false},
> > > > > - false /*HasGlobalPred*/);
> > > > > + VFShape Shape =
> > > > > + VFShape::get(*CI,
> > > > > ElementCount::getFixed(static_cast<unsigned>(
> > > > > + VecTy-
> > >getNumElements())),
> > > > > + false
> /*HasGlobalPred*/);
> > > > > CF =
> > VFDatabase(*CI).getVectorizedFunction(Shape);
> > > > > } else {
> > > > > Type *Tys[] = {FixedVectorType::get(CI-
> > >getType(), E-
> > > > > >Scalars.size())};
> > > > >
> > > > > diff --git
> > a/llvm/unittests/Analysis/VectorUtilsTest.cpp
> > > > > b/llvm/unittests/Analysis/VectorUtilsTest.cpp
> > > > > index 731ebdfe16f5..c4e19c7fa810 100644
> > > > > --- a/llvm/unittests/Analysis/VectorUtilsTest.cpp
> > > > > +++ b/llvm/unittests/Analysis/VectorUtilsTest.cpp
> > > > > @@ -93,7 +93,8 @@ TEST_F(BasicTest, isSplat) {
> > > > > Value *SplatC = IRB.CreateVectorSplat(5,
> ScalarC);
> > > > > EXPECT_TRUE(isSplatValue(SplatC));
> > > > >
> > > > > - Value *SplatC_SVE =
> > IRB.CreateVectorSplat(ElementCount(5,
> > > true),
> > > > > ScalarC);
> > > > > + Value *SplatC_SVE =
> > > > > +
> > IRB.CreateVectorSplat(ElementCount::getScalable(5),
> > > ScalarC);
> > > > > EXPECT_TRUE(isSplatValue(SplatC_SVE));
> > > > >
> > > > > // FIXME: Constant splat analysis does not
> allow
> > undef
> > > elements.
> > > > > @@ -502,7 +503,7 @@ class VFShapeAPITest : public
> > > testing::Test {
> > > > > SmallVector<VFParameter, 8> &ExpectedParams =
> > > > Expected.Parameters;
> > > > >
> > > > > void buildShape(unsigned VF, bool IsScalable,
> bool
> > > HasGlobalPred)
> > > > {
> > > > > - Shape = VFShape::get(*CI, {VF, IsScalable},
> > > HasGlobalPred);
> > > > > + Shape = VFShape::get(*CI,
> ElementCount::get(VF,
> > > IsScalable),
> > > > > + HasGlobalPred);
> > > > > }
> > > > >
> > > > > bool validParams(ArrayRef<VFParameter>
> Parameters) {
> > > > >
> > > > > diff --git
> > > a/llvm/unittests/CodeGen/ScalableVectorMVTsTest.cpp
> > > > >
> b/llvm/unittests/CodeGen/ScalableVectorMVTsTest.cpp
> > > > > index 81c99163229a..f1c4a8bea1f5 100644
> > > > > ---
> a/llvm/unittests/CodeGen/ScalableVectorMVTsTest.cpp
> > > > > +++
> b/llvm/unittests/CodeGen/ScalableVectorMVTsTest.cpp
> > > > > @@ -49,12 +49,12 @@ TEST(ScalableVectorMVTsTest,
> > HelperFuncs)
> > > {
> > > > > ASSERT_TRUE(Vnx4i32.isScalableVector());
> > > > >
> > > > > // Create with separate llvm::ElementCount
> > > > > - auto EltCnt = ElementCount(2, true);
> > > > > + auto EltCnt = ElementCount::getScalable(2);
> > > > > EVT Vnx2i32 = EVT::getVectorVT(Ctx, MVT::i32,
> > EltCnt);
> > > > > ASSERT_TRUE(Vnx2i32.isScalableVector());
> > > > >
> > > > > // Create with inline llvm::ElementCount
> > > > > - EVT Vnx2i64 = EVT::getVectorVT(Ctx, MVT::i64,
> {2,
> > true});
> > > > > + EVT Vnx2i64 = EVT::getVectorVT(Ctx, MVT::i64,
> > > > > + ElementCount::getScalable(2));
> > > > > ASSERT_TRUE(Vnx2i64.isScalableVector());
> > > > >
> > > > > // Check that changing scalar types/element
> count
> > works @@
> > > -66,7
> > > > +66,7
> > > > > @@ TEST(ScalableVectorMVTsTest, HelperFuncs) {
> > > > > EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64,
> EltCnt /
> > 2),
> > > > MVT::nxv1i64);
> > > > >
> > > > > // Check that float->int conversion works
> > > > > - EVT Vnx2f64 = EVT::getVectorVT(Ctx, MVT::f64,
> {2,
> > true});
> > > > > + EVT Vnx2f64 = EVT::getVectorVT(Ctx, MVT::f64,
> > > > > + ElementCount::getScalable(2));
> > > > > EXPECT_EQ(Vnx2f64.changeTypeToInteger(),
> Vnx2i64);
> > > > >
> > > > > // Check fields inside llvm::ElementCount @@ -
> 77,7
> > +77,7 @@
> > > > > TEST(ScalableVectorMVTsTest, HelperFuncs) {
> > > > > // Check that fixed-length vector types aren't
> > scalable.
> > > > > EVT V8i32 = EVT::getVectorVT(Ctx, MVT::i32, 8);
> > > > > ASSERT_FALSE(V8i32.isScalableVector());
> > > > > - EVT V4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4,
> > false});
> > > > > + EVT V4f64 = EVT::getVectorVT(Ctx, MVT::f64,
> > > > > + ElementCount::getFixed(4));
> > > > > ASSERT_FALSE(V4f64.isScalableVector());
> > > > >
> > > > > // Check that llvm::ElementCount works for
> fixed-
> > length
> > > types.
> > > > > @@ -90,7 +90,8 @@ TEST(ScalableVectorMVTsTest,
> > > IRToVTTranslation) {
> > > > > LLVMContext Ctx;
> > > > >
> > > > > Type *Int64Ty = Type::getInt64Ty(Ctx);
> > > > > - VectorType *ScV8Int64Ty =
> VectorType::get(Int64Ty,
> > {8,
> > > true});
> > > > > + VectorType *ScV8Int64Ty =
> > > > > + VectorType::get(Int64Ty,
> > ElementCount::getScalable(8));
> > > > >
> > > > > // Check that we can map a scalable IR type to
> an MVT
> > > > > MVT Mnxv8i64 = MVT::getVT(ScV8Int64Ty); @@ -
> 110,7
> > +111,7 @@
> > > > > TEST(ScalableVectorMVTsTest, IRToVTTranslation) {
> > > > > TEST(ScalableVectorMVTsTest, VTToIRTranslation) {
> > > > > LLVMContext Ctx;
> > > > >
> > > > > - EVT Enxv4f64 = EVT::getVectorVT(Ctx, MVT::f64,
> {4,
> > true});
> > > > > + EVT Enxv4f64 = EVT::getVectorVT(Ctx, MVT::f64,
> > > > > + ElementCount::getScalable(4));
> > > > >
> > > > > Type *Ty = Enxv4f64.getTypeForEVT(Ctx);
> > > > > VectorType *ScV4Float64Ty =
> cast<VectorType>(Ty);
> > > > >
> > > > > diff --git
> > a/llvm/unittests/FuzzMutate/OperationsTest.cpp
> > > > > b/llvm/unittests/FuzzMutate/OperationsTest.cpp
> > > > > index c329d053dec9..4de3d43ba960 100644
> > > > > --- a/llvm/unittests/FuzzMutate/OperationsTest.cpp
> > > > > +++ b/llvm/unittests/FuzzMutate/OperationsTest.cpp
> > > > > @@ -92,8 +92,8 @@ TEST(OperationsTest,
> SourcePreds) {
> > > > > ConstantStruct::get(StructType::create(Ctx,
> > > "OpaqueStruct"));
> > > > > Constant *a =
> > > > > ConstantArray::get(ArrayType::get(i32-
> >getType(),
> > 2),
> > > {i32,
> > > > i32});
> > > > > - Constant *v8i8 = ConstantVector::getSplat({8,
> false},
> > i8);
> > > > > - Constant *v4f16 = ConstantVector::getSplat({4,
> > false},
> > > f16);
> > > > > + Constant *v8i8 =
> > > > ConstantVector::getSplat(ElementCount::getFixed(8),
> > > > > + i8); Constant *v4f16 =
> > > > > +
> ConstantVector::getSplat(ElementCount::getFixed(4),
> > f16);
> > > > > Constant *p0i32 =
> > > > >
> ConstantPointerNull::get(PointerType::get(i32-
> > > >getType(),
> > > > 0));
> > > > >
> > > > >
> > > > > diff --git a/llvm/unittests/IR/ConstantsTest.cpp
> > > > > b/llvm/unittests/IR/ConstantsTest.cpp
> > > > > index f1c1c86293c8..5fb2d2dfc7ac 100644
> > > > > --- a/llvm/unittests/IR/ConstantsTest.cpp
> > > > > +++ b/llvm/unittests/IR/ConstantsTest.cpp
> > > > > @@ -646,8 +646,8 @@ TEST(ConstantsTest,
> > > GetSplatValueRoundTrip) {
> > > > > Type *Int8Ty = Type::getInt8Ty(Context);
> > > > >
> > > > > for (unsigned Min : {1, 2, 8}) {
> > > > > - ElementCount ScalableEC = {Min, true};
> > > > > - ElementCount FixedEC = {Min, false};
> > > > > + auto ScalableEC =
> ElementCount::getScalable(Min);
> > > > > + auto FixedEC = ElementCount::getFixed(Min);
> > > > >
> > > > > for (auto EC : {ScalableEC, FixedEC}) {
> > > > > for (auto *Ty : {FloatTy, Int32Ty, Int8Ty})
> {
> > > > >
> > > > > diff --git a/llvm/unittests/IR/PatternMatch.cpp
> > > > > b/llvm/unittests/IR/PatternMatch.cpp
> > > > > index 8e6e48d05d37..97d8da5b07b4 100644
> > > > > --- a/llvm/unittests/IR/PatternMatch.cpp
> > > > > +++ b/llvm/unittests/IR/PatternMatch.cpp
> > > > > @@ -1445,8 +1445,8 @@ TEST_F(PatternMatchTest,
> > > > ConstantPredicateType) {
> > > > > EXPECT_TRUE(match(CF32Pi,
> > > > cstfp_pred_ty<always_true_pred<APFloat>>()));
> > > > > EXPECT_FALSE(match(CF32Pi,
> > > > > cstfp_pred_ty<always_false_pred<APFloat>>()));
> > > > >
> > > > > - ElementCount FixedEC(4, false);
> > > > > - ElementCount ScalableEC(4, true);
> > > > > + auto FixedEC = ElementCount::getFixed(4); auto
> > ScalableEC
> > > =
> > > > > + ElementCount::getScalable(4);
> > > > >
> > > > > // Vector splat
> > > > >
> > > > >
> > > > > diff --git
> a/llvm/unittests/IR/VectorTypesTest.cpp
> > > > > b/llvm/unittests/IR/VectorTypesTest.cpp
> > > > > index 0dbf15ee6fc0..b28e445c97a7 100644
> > > > > --- a/llvm/unittests/IR/VectorTypesTest.cpp
> > > > > +++ b/llvm/unittests/IR/VectorTypesTest.cpp
> > > > > @@ -59,13 +59,13 @@ TEST(VectorTypesTest,
> FixedLength) {
> > > > >
> > dyn_cast<FixedVectorType>(VectorType::get(Int32Ty,
> > > > V8Int32Ty));
> > > > > EXPECT_VTY_EQ(V8Int32Ty, V8Int32Ty2);
> > > > >
> > > > > - auto *V8Int16Ty =
> > > > > -
> > dyn_cast<FixedVectorType>(VectorType::get(Int16Ty, {8,
> > > > false}));
> > > > > + auto *V8Int16Ty = dyn_cast<FixedVectorType>(
> > > > > + VectorType::get(Int16Ty,
> > ElementCount::getFixed(8)));
> > > > > ASSERT_NE(nullptr, V8Int16Ty);
> > > > > EXPECT_EQ(V8Int16Ty->getNumElements(), 8U);
> > > > > EXPECT_EQ(V8Int16Ty->getElementType()-
> > > >getScalarSizeInBits(),
> > > > 16U);
> > > > >
> > > > > - ElementCount EltCnt(4, false);
> > > > > + auto EltCnt = ElementCount::getFixed(4);
> > > > > auto *V4Int64Ty =
> > > > dyn_cast<FixedVectorType>(VectorType::get(Int64Ty,
> > > > > EltCnt));
> > > > > ASSERT_NE(nullptr, V4Int64Ty);
> > > > > EXPECT_EQ(V4Int64Ty->getNumElements(), 4U); @@
> -
> > 153,13
> > > +153,13 @@
> > > > > TEST(VectorTypesTest, Scalable) {
> > > > >
> > dyn_cast<ScalableVectorType>(VectorType::get(Int32Ty,
> > > > > ScV8Int32Ty));
> > > > > EXPECT_VTY_EQ(ScV8Int32Ty, ScV8Int32Ty2);
> > > > >
> > > > > - auto *ScV8Int16Ty =
> > > > > -
> > dyn_cast<ScalableVectorType>(VectorType::get(Int16Ty,
> > > {8,
> > > > true}));
> > > > > + auto *ScV8Int16Ty =
> dyn_cast<ScalableVectorType>(
> > > > > + VectorType::get(Int16Ty,
> > > ElementCount::getScalable(8)));
> > > > > ASSERT_NE(nullptr, ScV8Int16Ty);
> > > > > EXPECT_EQ(ScV8Int16Ty->getMinNumElements(),
> 8U);
> > > > > EXPECT_EQ(ScV8Int16Ty->getElementType()-
> > > >getScalarSizeInBits(),
> > > > 16U);
> > > > >
> > > > > - ElementCount EltCnt(4, true);
> > > > > + auto EltCnt = ElementCount::getScalable(4);
> > > > > auto *ScV4Int64Ty =
> > > > >
> > dyn_cast<ScalableVectorType>(VectorType::get(Int64Ty,
> > > > EltCnt));
> > > > > ASSERT_NE(nullptr, ScV4Int64Ty);
> > > > > @@ -225,14 +225,15 @@ TEST(VectorTypesTest,
> > BaseVectorType) {
> > > > > Type *Int16Ty = Type::getInt16Ty(Ctx);
> > > > > Type *Int32Ty = Type::getInt32Ty(Ctx);
> > > > >
> > > > > - std::array<VectorType *, 8> VTys =
> > > {VectorType::get(Int16Ty, {4,
> > > > > true}),
> > > > > -
> > > VectorType::get(Int16Ty, {4,
> > > > > false}),
> > > > > -
> > > VectorType::get(Int16Ty, {2,
> > > > > true}),
> > > > > -
> > > VectorType::get(Int16Ty, {2,
> > > > > false}),
> > > > > -
> > > VectorType::get(Int32Ty, {4,
> > > > > true}),
> > > > > -
> > > VectorType::get(Int32Ty, {4,
> > > > > false}),
> > > > > -
> > > VectorType::get(Int32Ty, {2,
> > > > > true}),
> > > > > -
> > > VectorType::get(Int32Ty, {2,
> > > > > false})};
> > > > > + std::array<VectorType *, 8> VTys = {
> > > > > + VectorType::get(Int16Ty,
> > ElementCount::getScalable(4)),
> > > > > + VectorType::get(Int16Ty,
> > ElementCount::getFixed(4)),
> > > > > + VectorType::get(Int16Ty,
> > ElementCount::getScalable(2)),
> > > > > + VectorType::get(Int16Ty,
> > ElementCount::getFixed(2)),
> > > > > + VectorType::get(Int32Ty,
> > ElementCount::getScalable(4)),
> > > > > + VectorType::get(Int32Ty,
> > ElementCount::getFixed(4)),
> > > > > + VectorType::get(Int32Ty,
> > ElementCount::getScalable(2)),
> > > > > + VectorType::get(Int32Ty,
> > ElementCount::getFixed(2))};
> > > > >
> > > > > /*
> > > > > The comparison matrix is symmetric, so we
> only
> > check the
> > > upper
> > > > > triangle:
> > > > >
> > > > > diff --git a/llvm/unittests/IR/VerifierTest.cpp
> > > > > b/llvm/unittests/IR/VerifierTest.cpp
> > > > > index f6a6a6ec7128..174e3eea3cce 100644
> > > > > --- a/llvm/unittests/IR/VerifierTest.cpp
> > > > > +++ b/llvm/unittests/IR/VerifierTest.cpp
> > > > > @@ -57,7 +57,7 @@ TEST(VerifierTest, Freeze) {
> > > > > ConstantInt *CI = ConstantInt::get(ITy, 0);
> > > > >
> > > > > // Valid type : freeze(<2 x i32>)
> > > > > - Constant *CV = ConstantVector::getSplat({2,
> false},
> > CI);
> > > > > + Constant *CV =
> > > > ConstantVector::getSplat(ElementCount::getFixed(2),
> > > > > + CI);
> > > > > FreezeInst *FI_vec = new FreezeInst(CV);
> > > > > FI_vec->insertBefore(RI);
> > > > >
> > > > >
> > > > >
> > > > >
> > > > > _______________________________________________
> > > > > llvm-commits mailing list
> > > > > llvm-commits at lists.llvm.org
> > > > > https://lists.llvm.org/cgi-
> bin/mailman/listinfo/llvm-
> > commits
> > >
> >
>
More information about the llvm-commits
mailing list