[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:53:38 PDT 2020
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