[llvm] 264afb9 - [NFC][llvm] Make the contructors of `ElementCount` private.
Voss, Matthew via llvm-commits
llvm-commits at lists.llvm.org
Wed Aug 19 12:49:18 PDT 2020
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