[NFC][llvm] Make the constructors of `ElementCount` private.

[ctetreau]

llvm/include/llvm/IR/Intrinsics.h

137–139

use getFixed

llvm/include/llvm/Support/TypeSize.h

45–46

since this is now private, and nothing uses it, it should be deleted

llvm/lib/CodeGen/ValueTypes.cpp

52

this can just pass the input ElementCount to VectorType::get

[fpetrogalli]

Thank you for the code review @ctetreau.

Francesco

llvm/include/llvm/Support/TypeSize.h

45–46

I have anyway marked the default constructor as deleted. I have explained why in a comment in the sources.

[ctetreau]

Fix the typo, then this looks good to me.

llvm/include/llvm/IR/Intrinsics.h

137–139

NIT: TYPO: "There si no" -> "There is no"

[fpetrogalli]

Fix typo.

[david-arm]

llvm/lib/IR/ConstantFold.cpp

922–923

Just a thought for code like this - since we're now calling ElementCount::get that means we can now use the 'auto' keyword in such places. This might help reduce the character count and help to fit on one line?

[fpetrogalli]

Thank you for the review @david-arm.

llvm/lib/IR/ConstantFold.cpp

922–923

Good point! Done.

[david-arm]

LGTM!

[ftynse]

FYI, this broke MLIR build.

[fpetrogalli]

@ftynse @mehdi_amini @JDevlieghere - apologies for breaking your workflows, and thank you for acting so quickly. I started doing the revert myself as soon as I saw the bombing from buildbot but by the time I was ready to push my revert your fixes were already pouring in.

I believe this can now be considered resolved. The patch from @mehdi_amini at https://github.com/llvm/llvm-project/commit/a407ec9b6db1e29e9aa361819f499ad11038d2dd is making sure that all subprojects are happy.

Thank you for your help.

Francesco

[davezarzycki]

Why were static "get" methods preferred over simply marking the constructor explicit? For example, if the constructor is marked explicit, then this is what users see:

    llvm::ElementCount EC = {vector->getNumElements(), /*scalable*/ false};
                       ^    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/dave/s/n/llvm/include/llvm/Support/TypeSize.h:37:12: note: explicit constructor declared here
  explicit ElementCount(unsigned Min, bool Scalable) : Min(Min), Scalable(Scalable) {}
           ^
1 error generated.

[fpetrogalli]

In D86120#2228000, @davezarzycki wrote:

Why were static "get" methods preferred over simply marking the constructor explicit? For example, if the constructor is marked explicit, then this is what users see:

    llvm::ElementCount EC = {vector->getNumElements(), /*scalable*/ false};
                       ^    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/dave/s/n/llvm/include/llvm/Support/TypeSize.h:37:12: note: explicit constructor declared here
  explicit ElementCount(unsigned Min, bool Scalable) : Min(Min), Scalable(Scalable) {}
           ^
1 error generated.

Hi @davezarzycki ,

thank you for your comment. The idea of introducing get* methods was to make sure the users would make a conscious decision about whether they where setting up Fixed o Scalable instances of ElementCount. As for the general constructor you mention, we could have 1. allowed people to use initializer lists for ElementCount or alternatively 2. mark the constructor as explicit. With @ctetreau we decided to have an uniform approach, so we decided to allow building instances of ElementCount only via static methods. So, no real technical reason for not using "explicit", other than our preference.

Kind regards,

Francesco

llvm/include/llvm/Analysis/VectorUtils.h

void updateParam(VFParameter P) {
     assert(P.ParamPos < Parameters.size() && "Invalid parameter position.");
     Parameters[P.ParamPos] = P;
     assert(hasValidParameterList() && "Invalid parameter list");
   }
 
   // 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
   // parameters are mapped to VFParamKind::Vector with \p EC
   // lanes. Specifies whether the function has a Global Predicate
   // argument via \p HasGlobalPred.
   static VFShape get(const CallInst &CI, ElementCount EC, bool HasGlobalPred) {
     SmallVector<VFParameter, 8> Parameters;

 }
 
 /// A helper function for converting Scalar types to vector types.
 /// If the incoming type is void, we return void. If the VF is 1, we return
 /// the scalar type.
 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.
 /// This method returns true if the intrinsic's argument types are all scalars
 /// for the scalar form of the intrinsic and all vectors (or scalars handled by
 /// hasVectorInstrinsicScalarOpd) for the vector form of the intrinsic.
 bool isTriviallyVectorizable(Intrinsic::ID ID);
 

llvm/include/llvm/IR/DerivedTypes.h

#endif
 
   Type *getElementType() const { return ContainedType; }
 
   /// This static method is the primary way to construct an VectorType.
   static VectorType *get(Type *ElementType, ElementCount EC);
 
   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) {
     return VectorType::get(ElementType, Other->getElementCount());
   }
 
   /// This static method gets a VectorType with the same number of elements as
   /// the input type, and the element type is an integer type of the same width
public:
   uint64_t getMinNumElements() const { return ElementQuantity; }
 
   static bool classof(const Type *T) {
     return T->getTypeID() == ScalableVectorTyID;
   }
 };
 
 inline ElementCount VectorType::getElementCount() const {
-  return ElementCount(ElementQuantity, isa<ScalableVectorType>(this));
+  return ElementCount::get(ElementQuantity, isa<ScalableVectorType>(this));
 }
 
 /// Class to represent pointers.
 class PointerType : public Type {
   explicit PointerType(Type *ElType, unsigned AddrSpace);
 
   Type *PointeeTy;
 

llvm/include/llvm/IR/Intrinsics.h

struct IITDescriptor {
     } Kind;
 
     union {
       unsigned Integer_Width;
       unsigned Float_Width;
       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 {
       AK_Any,
       AK_AnyInteger,
       AK_AnyFloat,
       AK_AnyVector,
       AK_AnyPointer,
static IITDescriptor get(IITDescriptorKind K, unsigned short Hi,
       unsigned Field = Hi << 16 | Lo;
       IITDescriptor Result = {K, {Field}};
       return Result;
     }
 
     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;
     }
   };
 
   /// Return the IIT table descriptor for the specified intrinsic into an array
   /// of IITDescriptors.
   void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T);
 

llvm/include/llvm/Support/MachineValueType.h

unsigned getVectorNumElements() const {
       case nxv1i64:
       case nxv1f16:
       case nxv1f32:
       case nxv1f64: return 1;
       }
     }
 
     ElementCount getVectorElementCount() const {
-      return { getVectorNumElements(), isScalableVector() };
+      return ElementCount::get(getVectorNumElements(), isScalableVector());
     }
 
     /// Given a vector type, return the minimum number of elements it contains.
     unsigned getVectorMinNumElements() const {
       return getVectorElementCount().Min;
     }
 
     /// Returns the size of the specified MVT in bits.

llvm/include/llvm/Support/TypeSize.h

 #include <cstdint>
 #include <cassert>
 
 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 };
   }
   ElementCount operator/(unsigned RHS) {
     assert(Min % RHS == 0 && "Min is not a multiple of RHS.");
     return { Min / RHS, Scalable };
   }
 
   bool operator==(const ElementCount& RHS) const {
     return Min == RHS.Min && Scalable == RHS.Scalable;
   }
   bool operator!=(const ElementCount& RHS) const {
     return !(*this == RHS);
   }
   bool operator==(unsigned RHS) const { return Min == RHS && !Scalable; }
   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};
   }
 };
 
 // This class is used to represent the size of types. If the type is of fixed
 // size, it will represent the exact size. If the type is a scalable vector,
 // it will represent the known minimum size.
 class TypeSize {
   uint64_t MinSize;   // The known minimum size.

 /// Similar to the alignTo functions in MathExtras.h
 inline TypeSize alignTo(TypeSize Size, uint64_t Align) {
   assert(Align != 0u && "Align must be non-zero");
   return {(Size.getKnownMinSize() + Align - 1) / Align * Align,
           Size.isScalable()};
 }
 
 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;
 
     return EltCnt.Min * 37U;
   }
 
   static bool isEqual(const ElementCount& LHS, const ElementCount& RHS) {
     return LHS == RHS;
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_TypeSize_H

llvm/lib/Analysis/VFABIDemangling.cpp

assert(verifyAllVectorsHaveSameWidth(Signature) &&
          "Invalid vector signature.");
 
   if (auto *RetTy = dyn_cast<VectorType>(Signature->getReturnType()))
     return RetTy->getElementCount();
   for (auto *Ty : Signature->params())
     if (auto *VTy = dyn_cast<VectorType>(Ty))
       return VTy->getElementCount();
 
-  return ElementCount(/*Min=*/1, /*Scalable=*/false);
+  return ElementCount::getFixed(/*Min=*/1);
 }
 } // namespace
 
 // Format of the ABI name:
 // _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
 Optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName,
                                             const Module &M) {
   const StringRef OriginalName = MangledName;

llvm/lib/AsmParser/LLParser.cpp

return Error(ExplicitTypeLoc,
                  "explicit pointee type doesn't match operand's pointee type");
 
   SmallVector<Value*, 16> Indices;
   bool AteExtraComma = false;
   // GEP returns a vector of pointers if at least one of parameters is a vector.
   // 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) {
       AteExtraComma = true;
       break;
     }
     if (ParseTypeAndValue(Val, EltLoc, PFS)) return true;
     if (!Val->getType()->isIntOrIntVectorTy())
       return Error(EltLoc, "getelementptr index must be an integer");
 
     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;
     }
     Indices.push_back(Val);
   }
 
   SmallPtrSet<Type*, 4> Visited;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

static void getCopyToPartsVector(SelectionDAG &DAG, const SDLoc &DL,
 
   assert(NumRegs == NumParts && "Part count doesn't match vector breakdown!");
   NumParts = NumRegs; // Silence a compiler warning.
   assert(RegisterVT == PartVT && "Part type doesn't match vector breakdown!");
 
   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;
 
     Val = DAG.getNode(ISD::BITCAST, DL, BuiltVectorTy, Val);
   }
 
   // Split the vector into intermediate operands.
void SelectionDAGBuilder::visitGetElementPtr(const User &I) {
   SDLoc dl = getCurSDLoc();
   auto &TLI = DAG.getTargetLoweringInfo();
 
   // Normalize Vector GEP - all scalar operands should be converted to the
   // splat vector.
   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();
     EVT VT = EVT::getVectorVT(Context, N.getValueType(), VectorElementCount);
     if (VectorElementCount.Scalable)
       N = DAG.getSplatVector(VT, dl, N);
     else
       N = DAG.getSplatBuildVector(VT, dl, N);

llvm/lib/CodeGen/TargetLoweringBase.cpp

TargetLoweringBase::getTypeConversion(LLVMContext &Context, EVT VT) const {
   // Handle vector types.
   ElementCount NumElts = VT.getVectorElementCount();
   EVT EltVT = VT.getVectorElementType();
 
   // Vectors with only one element are always scalarized.
   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
   // promote it to a legal type later on, for example:
   // <3 x i8> -> <4 x i8> -> <4 x i32>
   if (EltVT.isInteger()) {
     // Vectors with a number of elements that is not a power of two are always
     // widened, for example <3 x i8> -> <4 x i8>.

llvm/lib/CodeGen/ValueTypes.cpp

EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
   ResultVT.LLVMTy =
       VectorType::get(VT.getTypeForEVT(Context), NumElements, IsScalable);
   assert(ResultVT.isExtended() && "Type is not extended!");
   return ResultVT;
 }
 
 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;
 }
 
 bool EVT::isExtendedFloatingPoint() const {
   assert(isExtended() && "Type is not extended!");
   return LLVMTy->isFPOrFPVectorTy();
 }

llvm/lib/IR/ConstantFold.cpp

Constant *llvm::ConstantFoldInsertElementInstruction(Constant *Val,
 
   return ConstantVector::get(Result);
 }
 
 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.
   if (all_of(Mask, [](int Elt) { return Elt == UndefMaskElem; })) {
     return UndefValue::get(FixedVectorType::get(EltTy, MaskNumElts));
   }
 
   // If the mask is all zeros this is a splat, no need to go through all

llvm/lib/IR/Constants.cpp

if (Constant *FC =
     return FC;          // Fold a few common cases.
 
   // Get the result type of the getelementptr!
   Type *DestTy = GetElementPtrInst::getIndexedType(Ty, Idxs);
   assert(DestTy && "GEP indices invalid!");
   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
     for (auto Idx : Idxs)
       if (VectorType *VecTy = dyn_cast<VectorType>(Idx->getType()))
         EltCount = VecTy->getElementCount();
 
   if (EltCount.Min != 0)
if (CFP->getType()->isFloatTy()) {
       return getFP(V->getType(), Elts);
     }
     if (CFP->getType()->isDoubleTy()) {
       SmallVector<uint64_t, 16> Elts(
           NumElts, CFP->getValueAPF().bitcastToAPInt().getLimitedValue());
       return getFP(V->getType(), Elts);
     }
   }
-  return ConstantVector::getSplat({NumElts, false}, V);
+  return ConstantVector::getSplat(ElementCount::getFixed(NumElts), V);
 }
 
 
 uint64_t ConstantDataSequential::getElementAsInteger(unsigned Elt) const {
   assert(isa<IntegerType>(getElementType()) &&
          "Accessor can only be used when element is an integer");
   const char *EltPtr = getElementPointer(Elt);
 

llvm/lib/IR/IRBuilder.cpp

Value *IRBuilderBase::CreateStripInvariantGroup(Value *Ptr) {
 
   if (PtrType != Int8PtrTy)
     return CreateBitCast(Fn, PtrType);
   return Fn;
 }
 
 Value *IRBuilderBase::CreateVectorSplat(unsigned NumElts, Value *V,
                                         const Twine &Name) {
-  ElementCount EC(NumElts, false);
+  auto EC = ElementCount::getFixed(NumElts);
   return CreateVectorSplat(EC, V, Name);
 }
 
 Value *IRBuilderBase::CreateVectorSplat(ElementCount EC, Value *V,
                                         const Twine &Name) {
   assert(EC.Min > 0 && "Cannot splat to an empty vector!");
 
   // First insert it into an undef vector so we can shuffle it.

llvm/lib/IR/Instructions.cpp

CastInst::castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
   bool DstIsVec = isa<VectorType>(DstTy);
   unsigned SrcScalarBitSize = SrcTy->getScalarSizeInBits();
   unsigned DstScalarBitSize = DstTy->getScalarSizeInBits();
 
   // If these are vector types, get the lengths of the vectors (using zero for
   // 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) {
   default: return false; // This is an input error
   case Instruction::Trunc:
     return SrcTy->isIntOrIntVectorTy() && DstTy->isIntOrIntVectorTy() &&
            SrcEC == DstEC && SrcScalarBitSize > DstScalarBitSize;
   case Instruction::ZExt:
case Instruction::BitCast: {
     // If both are pointers then the address spaces must match.
     if (SrcPtrTy->getAddressSpace() != DstPtrTy->getAddressSpace())
       return false;
 
     // A vector of pointers must have the same number of elements.
     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;
   }
   case Instruction::AddrSpaceCast: {
     PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
     if (!SrcPtrTy)
       return false;
 

llvm/lib/IR/Type.cpp

 //===----------------------------------------------------------------------===//
 
 FixedVectorType *FixedVectorType::get(Type *ElementType, unsigned NumElts) {
   assert(NumElts > 0 && "#Elements of a VectorType must be greater than 0");
   assert(isValidElementType(ElementType) && "Element type of a VectorType must "
                                             "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()
                            .pImpl->VectorTypes[std::make_pair(ElementType, EC)];
 
   if (!Entry)
     Entry = new (pImpl->Alloc) FixedVectorType(ElementType, NumElts);
   return cast<FixedVectorType>(Entry);
 }
 
 //===----------------------------------------------------------------------===//
 //                       ScalableVectorType Implementation
 //===----------------------------------------------------------------------===//
 
 ScalableVectorType *ScalableVectorType::get(Type *ElementType,
                                             unsigned MinNumElts) {
   assert(MinNumElts > 0 && "#Elements of a VectorType must be greater than 0");
   assert(isValidElementType(ElementType) && "Element type of a VectorType must "
                                             "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()
                            .pImpl->VectorTypes[std::make_pair(ElementType, EC)];
 
   if (!Entry)
     Entry = new (pImpl->Alloc) ScalableVectorType(ElementType, MinNumElts);
   return cast<ScalableVectorType>(Entry);

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

static SDValue LowerSVEIntrinsicEXT(SDNode *N, SelectionDAG &DAG) {
   assert(VT.isScalableVector() && "Expected a scalable vector.");
 
   // Current lowering only supports the SVE-ACLE types.
   if (VT.getSizeInBits().getKnownMinSize() != AArch64::SVEBitsPerBlock)
     return SDValue();
 
   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));
   SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, ByteVT, N->getOperand(2));
   SDValue Op2 = DAG.getNode(ISD::MUL, dl, MVT::i32, N->getOperand(3),
                             DAG.getConstant(ElemSize, dl, MVT::i32));
 
   SDValue EXT = DAG.getNode(AArch64ISD::EXT, dl, ByteVT, Op0, Op1, Op2);

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

void InnerLoopVectorizer::createVectorIntOrFpInductionPHI(
   Value *ConstVF = getSignedIntOrFpConstant(Step->getType(), VF);
   Value *Mul = addFastMathFlag(Builder.CreateBinOp(MulOp, Step, ConstVF));
 
   // Create a vector splat to use in the induction update.
   //
   // 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))
+  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
   // factor. The last of those goes into the PHI.
   PHINode *VecInd = PHINode::Create(SteppedStart->getType(), 2, "vec.ind",
                                     &*LoopVectorBody->getFirstInsertionPt());
   VecInd->setDebugLoc(EntryVal->getDebugLoc());
   Instruction *LastInduction = VecInd;
unsigned LoopVectorizationCostModel::getVectorCallCost(CallInst *CI,
   // packing the return values to a vector.
   unsigned ScalarizationCost = getScalarizationOverhead(CI, VF);
 
   unsigned Cost = ScalarCallCost * VF + ScalarizationCost;
 
   // 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)
     return Cost;
 
   // If the corresponding vector cost is cheaper, return its cost.
   unsigned VectorCallCost = TTI.getCallInstrCost(nullptr, RetTy, Tys,
                                                  TTI::TCK_RecipThroughput);
if (RK == RecurrenceDescriptor::RK_IntegerMinMax ||
     Constant *Iden = RecurrenceDescriptor::getRecurrenceIdentity(
         RK, VecTy->getScalarType());
     if (VF == 1 || IsInLoopReductionPhi) {
       Identity = Iden;
       // This vector is the Identity vector where the first element is the
       // 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.
       VectorStart =
         Builder.CreateInsertElement(Identity, ReductionStartValue, Zero);
     }
   }
 
if (UseVectorIntrinsic) {
       Type *TysForDecl[] = {CI->getType()};
       if (VF > 1)
         TysForDecl[0] =
             FixedVectorType::get(CI->getType()->getScalarType(), VF);
       VectorF = Intrinsic::getDeclaration(M, ID, TysForDecl);
       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.");
 #endif
         VectorF = VFDatabase(*CI).getVectorizedFunction(Shape);
     }
       SmallVector<OperandBundleDef, 1> OpBundles;
       CI->getOperandBundlesAsDefs(OpBundles);

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

switch (ShuffleOrOp) {
     }
     case Instruction::Call: {
       // Check if the calls are all to the same vectorizable intrinsic or
       // library function.
       CallInst *CI = cast<CallInst>(VL0);
       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);
 
       if (!VecFunc && !isTriviallyVectorizable(ID)) {
         BS.cancelScheduling(VL, VL0);
         newTreeEntry(VL, None /*not vectorized*/, S, UserTreeIdx,
                      ReuseShuffleIndicies);
         LLVM_DEBUG(dbgs() << "SLP: Non-vectorizable call.\n");
getVectorCallCosts(CallInst *CI, VectorType *VecTy, TargetTransformInfo *TTI,
                    TargetLibraryInfo *TLI) {
   Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, TLI);
 
   // Calculate the cost of the scalar and vector calls.
   IntrinsicCostAttributes CostAttrs(ID, *CI, VecTy->getNumElements());
   int IntrinsicCost =
     TTI->getIntrinsicInstrCost(CostAttrs, TTI::TCK_RecipThroughput);
 
-  auto Shape =
-      VFShape::get(*CI, {static_cast<unsigned>(VecTy->getNumElements()), false},
+  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) {
     // Calculate the cost of the vector library call.
     SmallVector<Type *, 4> VecTys;
     for (Use &Arg : CI->args())
       VecTys.push_back(
           FixedVectorType::get(Arg->getType(), VecTy->getNumElements()));
case Instruction::Call: {
 
         Value *OpVec = vectorizeTree(E->getOperand(j));
         LLVM_DEBUG(dbgs() << "SLP: OpVec[" << j << "]: " << *OpVec << "\n");
         OpVecs.push_back(OpVec);
       }
 
       Function *CF;
       if (!UseIntrinsic) {
-        VFShape Shape = VFShape::get(
-            *CI, {static_cast<unsigned>(VecTy->getNumElements()), false},
+        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())};
         CF = Intrinsic::getDeclaration(F->getParent(), ID, Tys);
       }
 
       SmallVector<OperandBundleDef, 1> OpBundles;
       CI->getOperandBundlesAsDefs(OpBundles);

llvm/unittests/Analysis/VectorUtilsTest.cpp

TEST_F(BasicTest, isSplat) {
 
   Constant *OtherScalarC = IRB.getInt8(-42);
   Constant *NonSplatC = ConstantVector::get({ScalarC, OtherScalarC});
   EXPECT_FALSE(isSplatValue(NonSplatC));
 
   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.
   Constant *SplatWithUndefC = ConstantVector::get({ScalarC, UndefScalar});
   EXPECT_FALSE(isSplatValue(SplatWithUndefC));
 }
 
 TEST_F(BasicTest, narrowShuffleMaskElts) {
protected:
   std::unique_ptr<Module> M;
   CallInst *CI;
   // Dummy shape with no parameters, overwritten by buildShape when invoked.
   VFShape Shape = {/*VF*/ 2, /*IsScalable*/ false, /*Parameters*/ {}};
   VFShape Expected;
   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) {
     Shape.Parameters =
         SmallVector<VFParameter, 8>(Parameters.begin(), Parameters.end());
     return Shape.hasValidParameterList();
   }
 };

llvm/unittests/CodeGen/ScalableVectorMVTsTest.cpp

 TEST(ScalableVectorMVTsTest, HelperFuncs) {
   LLVMContext Ctx;
 
   // Create with scalable flag
   EVT Vnx4i32 = EVT::getVectorVT(Ctx, MVT::i32, 4, /*Scalable=*/true);
   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
   EXPECT_EQ(Vnx2i32.widenIntegerVectorElementType(Ctx), Vnx2i64);
   EXPECT_EQ(Vnx4i32.getHalfNumVectorElementsVT(Ctx), Vnx2i32);
 
   // Check that overloaded '*' and '/' operators work
   EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64, EltCnt * 2), MVT::nxv4i64);
   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
   EltCnt = Vnx4i32.getVectorElementCount();
   EXPECT_EQ(EltCnt.Min, 4U);
   ASSERT_TRUE(EltCnt.Scalable);
 
   // 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.
   EltCnt = V8i32.getVectorElementCount();
   EXPECT_EQ(EltCnt.Min, 8U);
   ASSERT_FALSE(EltCnt.Scalable);
 }
 
 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);
   ASSERT_TRUE(Mnxv8i64.isScalableVector());
   ASSERT_EQ(ScV8Int64Ty->getElementCount(), Mnxv8i64.getVectorElementCount());
   ASSERT_EQ(MVT::getVT(ScV8Int64Ty->getElementType()),
             Mnxv8i64.getScalarType());
 
   // Check that we can map a scalable IR type to an EVT
   EVT Enxv8i64 = EVT::getEVT(ScV8Int64Ty);
   ASSERT_TRUE(Enxv8i64.isScalableVector());
   ASSERT_EQ(ScV8Int64Ty->getElementCount(), Enxv8i64.getVectorElementCount());
   ASSERT_EQ(EVT::getEVT(ScV8Int64Ty->getElementType()),
             Enxv8i64.getScalarType());
 }
 
 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);
   ASSERT_TRUE(isa<ScalableVectorType>(ScV4Float64Ty));
   ASSERT_EQ(Enxv4f64.getVectorElementCount(), ScV4Float64Ty->getElementCount());
   ASSERT_EQ(Enxv4f64.getScalarType().getTypeForEVT(Ctx),
             ScV4Float64Ty->getElementType());
 }

llvm/unittests/FuzzMutate/OperationsTest.cpp

Constant *i64 = ConstantInt::get(Type::getInt64Ty(Ctx),
                                    std::numeric_limits<uint64_t>::max());
   Constant *f16 = ConstantFP::getInfinity(Type::getHalfTy(Ctx));
   Constant *f32 = ConstantFP::get(Type::getFloatTy(Ctx), 0.0);
   Constant *f64 = ConstantFP::get(Type::getDoubleTy(Ctx), 123.45);
   Constant *s =
       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));
 
   auto OnlyI32 = onlyType(i32->getType());
   EXPECT_TRUE(OnlyI32.matches({}, i32));
   EXPECT_FALSE(OnlyI32.matches({}, i64));
   EXPECT_FALSE(OnlyI32.matches({}, p0i32));
   EXPECT_FALSE(OnlyI32.matches({}, a));

llvm/unittests/IR/ConstantsTest.cpp

 TEST(ConstantsTest, GetSplatValueRoundTrip) {
   LLVMContext Context;
 
   Type *FloatTy = Type::getFloatTy(Context);
   Type *Int32Ty = Type::getInt32Ty(Context);
   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}) {
         Constant *Zero = Constant::getNullValue(Ty);
         Constant *One = Constant::getAllOnesValue(Ty);
 
         for (auto *C : {Zero, One}) {
           Constant *Splat = ConstantVector::getSplat(EC, C);

llvm/unittests/IR/PatternMatch.cpp

TEST_F(PatternMatchTest, ConstantPredicateType) {
   EXPECT_TRUE(match(CF32Zero, cstfp_pred_ty<always_true_pred<APFloat>>()));
   EXPECT_FALSE(match(CF32Zero, cstfp_pred_ty<always_false_pred<APFloat>>()));
 
   EXPECT_FALSE(match(CF32Pi, cstfp_pred_ty<is_float_nan_pred>()));
   EXPECT_FALSE(match(CF32Pi, cstfp_pred_ty<is_float_zero_pred>()));
   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
 
   for (auto EC : {FixedEC, ScalableEC}) {
     // integer
 
     Constant *CSplatU32Max = ConstantVector::getSplat(EC, CU32Max);
     Constant *CSplatU32Zero = ConstantVector::getSplat(EC, CU32Zero);

llvm/unittests/IR/VectorTypesTest.cpp

TEST(VectorTypesTest, FixedLength) {
   EXPECT_VTY_NE(V8Int32Ty, V8Int8Ty);
   EXPECT_EQ(V8Int8Ty->getElementCount(), V8Int32Ty->getElementCount());
   EXPECT_EQ(V8Int8Ty->getElementType()->getScalarSizeInBits(), 8U);
 
   auto *V8Int32Ty2 =
       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);
   EXPECT_EQ(V4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   auto *V2Int64Ty =
       dyn_cast<FixedVectorType>(VectorType::get(Int64Ty, EltCnt / 2));
   ASSERT_NE(nullptr, V2Int64Ty);
TEST(VectorTypesTest, Scalable) {
   EXPECT_VTY_NE(ScV8Int32Ty, ScV8Int8Ty);
   EXPECT_EQ(ScV8Int8Ty->getElementCount(), ScV8Int32Ty->getElementCount());
   EXPECT_EQ(ScV8Int8Ty->getElementType()->getScalarSizeInBits(), 8U);
 
   auto *ScV8Int32Ty2 =
       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);
   EXPECT_EQ(ScV4Int64Ty->getMinNumElements(), 4U);
   EXPECT_EQ(ScV4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   auto *ScV2Int64Ty =
       dyn_cast<ScalableVectorType>(VectorType::get(Int64Ty, EltCnt / 2));

 }
 
 TEST(VectorTypesTest, BaseVectorType) {
   LLVMContext Ctx;
 
   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:
 
     (0,0) (0,1) (0,2) ... (0,7)
     (1,0) (1,1) (1,2)         .
     (2,0) (2,1) (2,2)         .
     .                 .       .

llvm/unittests/IR/VerifierTest.cpp

TEST(VerifierTest, Freeze) {
   Function *F = Function::Create(FTy, Function::ExternalLinkage, "foo", M);
   BasicBlock *Entry = BasicBlock::Create(C, "entry", F);
   ReturnInst *RI = ReturnInst::Create(C, Entry);
 
   IntegerType *ITy = IntegerType::get(C, 32);
   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);
 
   EXPECT_FALSE(verifyFunction(*F));
 
   FI_vec->eraseFromParent();
 
   // Valid type : freeze(float)