[SVE] Remove calls to isScalable from IR

[ctetreau]

rebase, fix permissions

[ctetreau]

While immediate feedback would be greatly appreciated, this commit won't actually build until D77587 is merged. I'll ping the thread when this happens if this commit hasn't been accepted yet.

[ctetreau]

llvm/lib/IR/Function.cpp

1358

I think this might not be correct

[efriedma]

llvm/lib/IR/Constants.cpp

230

This is a functional change, and not really related to the subject of this patch.

llvm/lib/IR/Function.cpp

1358

Yes, !VTy || !VTy->isScalable() is equivalent to !isa<ScalableVectorType>(Ty).

[ctetreau]

address code review issues

[ctetreau]

rebase

[ctetreau]

ping

[sdesmalen]

llvm/include/llvm/IR/PatternMatch.h

2176–2178

nit: now that we can use isa<ScalableVectorType>, it's probably better to write this as:

auto *DerefTy = PtrTy->getPointerElementType();
if (isa<ScalableVectorType>(DerefTy) &&
    DL.getTypeAllocSizeInBits(DerefTy).getKnownMinSize() == 8)

llvm/unittests/IR/VectorTypesTest.cpp

179

Shouldn't this be EXPECT_FALSE?

[ctetreau]

llvm/include/llvm/IR/PatternMatch.h

2176–2178

will do

llvm/unittests/IR/VectorTypesTest.cpp

179

yes, not sure what happened here...

[ctetreau]

address code review issues

[sdesmalen]

Okay thanks for fixing, LGTM!

[ctetreau]

rebase

llvm/include/llvm/IR/GetElementPtrTypeIterator.h

public:
 
     generic_gep_type_iterator& operator++() {   // Preincrement
       Type *Ty = getIndexedType();
       if (auto *ATy = dyn_cast<ArrayType>(Ty)) {
         CurTy = ATy->getElementType();
         NumElements = ATy->getNumElements();
       } else if (auto *VTy = dyn_cast<VectorType>(Ty)) {
         CurTy = VTy->getElementType();
-        if (VTy->isScalable())
+        if (isa<ScalableVectorType>(VTy))
           NumElements = Unbounded;
         else
           NumElements = VTy->getNumElements();
       } else
         CurTy = dyn_cast<StructType>(Ty);
       ++OpIt;
       return *this;
     }

llvm/include/llvm/IR/PatternMatch.h

public:
   VScaleVal_match(const DataLayout &DL) : DL(DL) {}
 
   template <typename ITy> bool match(ITy *V) {
     if (m_Intrinsic<Intrinsic::vscale>().match(V))
       return true;
 
     if (m_PtrToInt(m_OffsetGep(m_Zero(), m_SpecificInt(1))).match(V)) {
       Type *PtrTy = cast<Operator>(V)->getOperand(0)->getType();
-      auto *DerefTy = dyn_cast<VectorType>(PtrTy->getPointerElementType());
-      if (DerefTy && DerefTy->isScalable() &&
-          DL.getTypeAllocSizeInBits(DerefTy).getKnownMinSize() == 8)
+      auto *DerefTy =
+          dyn_cast<ScalableVectorType>(PtrTy->getPointerElementType());
+      if (DerefTy && DL.getTypeAllocSizeInBits(DerefTy).getKnownMinSize() == 8)
         return true;
     }
 
     return false;
   }
 };
 
 inline VScaleVal_match m_VScale(const DataLayout &DL) {
   return VScaleVal_match(DL);
 }
 
 } // end namespace PatternMatch
 } // end namespace llvm
 
 #endif // LLVM_IR_PATTERNMATCH_H

llvm/lib/IR/AsmWriter.cpp

 /// (if it has special chars in it). Print it out.
 static void PrintLLVMName(raw_ostream &OS, const Value *V) {
   PrintLLVMName(OS, V->getName(),
                 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
 }
 
 static void PrintShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef<int> Mask) {
   Out << ", <";
-  if (cast<VectorType>(Ty)->isScalable())
+  if (isa<ScalableVectorType>(Ty))
     Out << "vscale x ";
   Out << Mask.size() << " x i32> ";
   bool FirstElt = true;
   if (all_of(Mask, [](int Elt) { return Elt == 0; })) {
     Out << "zeroinitializer";
   } else if (all_of(Mask, [](int Elt) { return Elt == UndefMaskElem; })) {
     Out << "undef";
   } else {
case Type::ArrayTyID: {
     print(ATy->getElementType(), OS);
     OS << ']';
     return;
   }
   case Type::FixedVectorTyID:
   case Type::ScalableVectorTyID: {
     VectorType *PTy = cast<VectorType>(Ty);
     OS << "<";
-    if (PTy->isScalable())
+    if (isa<ScalableVectorType>(PTy))
       OS << "vscale x ";
     OS << PTy->getNumElements() << " x ";
     print(PTy->getElementType(), OS);
     OS << '>';
     return;
   }
   }
   llvm_unreachable("Invalid TypeID");

llvm/lib/IR/ConstantFold.cpp

 /// all simple integer or FP values.
 static Constant *BitCastConstantVector(Constant *CV, VectorType *DstTy) {
 
   if (CV->isAllOnesValue()) return Constant::getAllOnesValue(DstTy);
   if (CV->isNullValue()) return Constant::getNullValue(DstTy);
 
   // Do not iterate on scalable vector. The num of elements is unknown at
   // compile-time.
-  if (DstTy->isScalable())
+  if (isa<ScalableVectorType>(DstTy))
     return nullptr;
 
   // If this cast changes element count then we can't handle it here:
   // doing so requires endianness information.  This should be handled by
   // Analysis/ConstantFolding.cpp
   unsigned NumElts = DstTy->getNumElements();
   if (NumElts != cast<VectorType>(CV->getType())->getNumElements())
     return nullptr;
if (isa<UndefValue>(Idx))
     return UndefValue::get(Val->getType());
 
   ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
   if (!CIdx) return nullptr;
 
   // Do not iterate on scalable vector. The num of elements is unknown at
   // compile-time.
   VectorType *ValTy = cast<VectorType>(Val->getType());
-  if (ValTy->isScalable())
+  if (isa<ScalableVectorType>(ValTy))
     return nullptr;
 
   unsigned NumElts = cast<VectorType>(Val->getType())->getNumElements();
   if (CIdx->uge(NumElts))
     return UndefValue::get(Val->getType());
 
   SmallVector<Constant*, 16> Result;
   Result.reserve(NumElts);
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, V1VTy->isScalable()};
+  ElementCount MaskEltCount = {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(VectorType::get(EltTy, MaskNumElts));
   }
 
   // If the mask is all zeros this is a splat, no need to go through all
   // elements.
   if (all_of(Mask, [](int Elt) { return Elt == 0; }) &&
       !MaskEltCount.Scalable) {
     Type *Ty = IntegerType::get(V1->getContext(), 32);
     Constant *Elt =
         ConstantExpr::getExtractElement(V1, ConstantInt::get(Ty, 0));
     return ConstantVector::getSplat(MaskEltCount, Elt);
   }
   // Do not iterate on scalable vector. The num of elements is unknown at
   // compile-time.
-  if (V1VTy->isScalable())
+  if (isa<ScalableVectorType>(V1VTy))
     return nullptr;
 
   unsigned SrcNumElts = V1VTy->getNumElements();
 
   // Loop over the shuffle mask, evaluating each element.
   SmallVector<Constant*, 32> Result;
   for (unsigned i = 0; i != MaskNumElts; ++i) {
     int Elt = Mask[i];
Constant *llvm::ConstantFoldInsertValueInstruction(Constant *Agg,
   return ConstantArray::get(cast<ArrayType>(Agg->getType()), Result);
 }
 
 Constant *llvm::ConstantFoldUnaryInstruction(unsigned Opcode, Constant *C) {
   assert(Instruction::isUnaryOp(Opcode) && "Non-unary instruction detected");
 
   // Handle scalar UndefValue and scalable vector UndefValue. Fixed-length
   // vectors are always evaluated per element.
-  bool IsScalableVector = isa<VectorType>(C->getType()) &&
-                          cast<VectorType>(C->getType())->isScalable();
+  bool IsScalableVector = isa<ScalableVectorType>(C->getType());
   bool HasScalarUndefOrScalableVectorUndef =
       (!C->getType()->isVectorTy() || IsScalableVector) && isa<UndefValue>(C);
 
   if (HasScalarUndefOrScalableVectorUndef) {
     switch (static_cast<Instruction::UnaryOps>(Opcode)) {
     case Instruction::FNeg:
       return C; // -undef -> undef
     case Instruction::UnaryOpsEnd:
if (Identity) {
     if (C1 == Identity)
       return C2;
     if (C2 == Identity)
       return C1;
   }
 
   // Handle scalar UndefValue and scalable vector UndefValue. Fixed-length
   // vectors are always evaluated per element.
-  bool IsScalableVector = isa<VectorType>(C1->getType()) &&
-                          cast<VectorType>(C1->getType())->isScalable();
+  bool IsScalableVector = isa<ScalableVectorType>(C1->getType());
   bool HasScalarUndefOrScalableVectorUndef =
       (!C1->getType()->isVectorTy() || IsScalableVector) &&
       (isa<UndefValue>(C1) || isa<UndefValue>(C2));
   if (HasScalarUndefOrScalableVectorUndef) {
     switch (static_cast<Instruction::BinaryOps>(Opcode)) {
     case Instruction::Xor:
       if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
         // Handle undef ^ undef -> 0 special case. This is a common
if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
     if (Constant *C1Splat = C1->getSplatValue())
       if (Constant *C2Splat = C2->getSplatValue())
         return ConstantVector::getSplat(
             C1VTy->getElementCount(),
             ConstantExpr::getCompare(pred, C1Splat, C2Splat));
 
     // Do not iterate on scalable vector. The number of elements is unknown at
     // compile-time.
-    if (C1VTy->isScalable())
+    if (isa<ScalableVectorType>(C1VTy))
       return nullptr;
 
     // If we can constant fold the comparison of each element, constant fold
     // the whole vector comparison.
     SmallVector<Constant*, 4> ResElts;
     Type *Ty = IntegerType::get(C1->getContext(), 32);
     // Compare the elements, producing an i1 result or constant expr.
     for (unsigned i = 0, e = C1VTy->getNumElements(); i != e; ++i) {

llvm/lib/IR/Constants.cpp

bool Constant::isNotMinSignedValue() const {
 
   // It *may* contain INT_MIN, we can't tell.
   return false;
 }
 
 bool Constant::isFiniteNonZeroFP() const {
   if (auto *CFP = dyn_cast<ConstantFP>(this))
     return CFP->getValueAPF().isFiniteNonZero();
   auto *VTy = dyn_cast<VectorType>(getType());
   if (!VTy)
     return false;
   for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     if (!CFP || !CFP->getValueAPF().isFiniteNonZero())
       return false;
   }
   return true;
 }
 
 bool Constant::isNormalFP() const {
   if (auto *CFP = dyn_cast<ConstantFP>(this))
     return CFP->getValueAPF().isNormal();
-  auto *VTy = dyn_cast<VectorType>(getType());
+  auto *VTy = dyn_cast<FixedVectorType>(getType());
   if (!VTy)
     return false;
   for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     if (!CFP || !CFP->getValueAPF().isNormal())
       return false;
   }
   return true;
 }
 
 bool Constant::hasExactInverseFP() const {
   if (auto *CFP = dyn_cast<ConstantFP>(this))
     return CFP->getValueAPF().getExactInverse(nullptr);
-  auto *VTy = dyn_cast<VectorType>(getType());
+  auto *VTy = dyn_cast<FixedVectorType>(getType());
   if (!VTy)
     return false;
   for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     if (!CFP || !CFP->getValueAPF().getExactInverse(nullptr))
       return false;
   }
   return true;
 }
 
 bool Constant::isNaN() const {
   if (auto *CFP = dyn_cast<ConstantFP>(this))
     return CFP->isNaN();
-  auto *VTy = dyn_cast<VectorType>(getType());
+  auto *VTy = dyn_cast<FixedVectorType>(getType());
   if (!VTy)
     return false;
   for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
     auto *CFP = dyn_cast_or_null<ConstantFP>(this->getAggregateElement(i));
     if (!CFP || !CFP->isNaN())
       return false;
   }
   return true;
Constant *Constant::replaceUndefsWith(Constant *C, Constant *Replacement) {
   assert(C && Replacement && "Expected non-nullptr constant arguments");
   Type *Ty = C->getType();
   if (match(C, m_Undef())) {
     assert(Ty == Replacement->getType() && "Expected matching types");
     return Replacement;
   }
 
   // Don't know how to deal with this constant.
-  auto *VTy = dyn_cast<VectorType>(Ty);
+  auto *VTy = dyn_cast<FixedVectorType>(Ty);
   if (!VTy)
     return C;
 
   unsigned NumElts = VTy->getNumElements();
   SmallVector<Constant *, 32> NewC(NumElts);
   for (unsigned i = 0; i != NumElts; ++i) {
     Constant *EltC = C->getAggregateElement(i);
     assert((!EltC || EltC->getType() == Replacement->getType()) &&
assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) &&
          "Invalid shuffle vector constant expr operands!");
 
   if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask))
     return FC;          // Fold a few common cases.
 
   unsigned NElts = Mask.size();
   auto V1VTy = cast<VectorType>(V1->getType());
   Type *EltTy = V1VTy->getElementType();
-  bool TypeIsScalable = V1VTy->isScalable();
+  bool TypeIsScalable = isa<ScalableVectorType>(V1VTy);
   Type *ShufTy = VectorType::get(EltTy, NElts, TypeIsScalable);
 
   if (OnlyIfReducedTy == ShufTy)
     return nullptr;
 
   // Look up the constant in the table first to ensure uniqueness
   Constant *ArgVec[] = {V1, V2};
   ConstantExprKeyType Key(Instruction::ShuffleVector, ArgVec, 0, 0, None, Mask);

llvm/lib/IR/ConstantsContext.h

 };
 
 /// ShuffleVectorConstantExpr - This class is private to
 /// Constants.cpp, and is used behind the scenes to implement
 /// shufflevector constant exprs.
 class ShuffleVectorConstantExpr : public ConstantExpr {
 public:
   ShuffleVectorConstantExpr(Constant *C1, Constant *C2, ArrayRef<int> Mask)
-      : ConstantExpr(
-            VectorType::get(cast<VectorType>(C1->getType())->getElementType(),
-                            Mask.size(),
-                            cast<VectorType>(C1->getType())->isScalable()),
+      : ConstantExpr(VectorType::get(
+                         cast<VectorType>(C1->getType())->getElementType(),
+                         Mask.size(), isa<ScalableVectorType>(C1->getType())),
                      Instruction::ShuffleVector, &Op<0>(), 2) {
     assert(ShuffleVectorInst::isValidOperands(C1, C2, Mask) &&
            "Invalid shuffle vector instruction operands!");
     Op<0>() = C1;
     Op<1>() = C2;
     ShuffleMask.assign(Mask.begin(), Mask.end());
     ShuffleMaskForBitcode =
         ShuffleVectorInst::convertShuffleMaskForBitcode(Mask, getType());
   }

llvm/lib/IR/Function.cpp

if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
     Result += "f_" + getMangledTypeStr(FT->getReturnType());
     for (size_t i = 0; i < FT->getNumParams(); i++)
       Result += getMangledTypeStr(FT->getParamType(i));
     if (FT->isVarArg())
       Result += "vararg";
     // Ensure nested function types are distinguishable.
     Result += "f";
   } else if (VectorType* VTy = dyn_cast<VectorType>(Ty)) {
-    if (VTy->isScalable())
+    if (isa<ScalableVectorType>(VTy))
       Result += "nx";
     Result += "v" + utostr(VTy->getNumElements()) +
               getMangledTypeStr(VTy->getElementType());
   } else if (Ty) {
     switch (Ty->getTypeID()) {
     default: llvm_unreachable("Unhandled type");
     case Type::VoidTyID:      Result += "isVoid";   break;
     case Type::MetadataTyID:  Result += "Metadata"; break;
case IITDescriptor::Subdivide4Argument: {
       if (auto *VTy = dyn_cast<VectorType>(NewTy)) {
         int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
         NewTy = VectorType::getSubdividedVectorType(VTy, SubDivs);
         return Ty != NewTy;
       }
       return true;
     }
     case IITDescriptor::ScalableVecArgument: {
-      VectorType *VTy = dyn_cast<VectorType>(Ty);
-      if (!VTy || !VTy->isScalable())
+      if (!isa<ScalableVectorType>(Ty))
         return true;
-      return matchIntrinsicType(VTy, Infos, ArgTys, DeferredChecks,
+      return matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks,
                                 IsDeferredCheck);
     }
     case IITDescriptor::VecOfBitcastsToInt: {
       if (D.getArgumentNumber() >= ArgTys.size())
         return IsDeferredCheck || DeferCheck(Ty);
       auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
       auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
       if (!ThisArgVecTy || !ReferenceType)

llvm/lib/IR/Instructions.cpp

ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
   setName(Name);
 }
 
 ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                                      const Twine &Name,
                                      Instruction *InsertBefore)
     : Instruction(
           VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
-                          Mask.size(),
-                          cast<VectorType>(V1->getType())->isScalable()),
+                          Mask.size(), isa<ScalableVectorType>(V1->getType())),
           ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this),
           OperandTraits<ShuffleVectorInst>::operands(this), InsertBefore) {
   assert(isValidOperands(V1, V2, Mask) &&
          "Invalid shuffle vector instruction operands!");
   Op<0>() = V1;
   Op<1>() = V2;
   setShuffleMask(Mask);
   setName(Name);
 }
 
 ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                                      const Twine &Name, BasicBlock *InsertAtEnd)
     : Instruction(
           VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
-                          Mask.size(),
-                          cast<VectorType>(V1->getType())->isScalable()),
+                          Mask.size(), isa<ScalableVectorType>(V1->getType())),
           ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this),
           OperandTraits<ShuffleVectorInst>::operands(this), InsertAtEnd) {
   assert(isValidOperands(V1, V2, Mask) &&
          "Invalid shuffle vector instruction operands!");
 
   Op<0>() = V1;
   Op<1>() = V2;
   setShuffleMask(Mask);
if (!V1->getType()->isVectorTy() || V1->getType() != V2->getType())
     return false;
 
   // Make sure the mask elements make sense.
   int V1Size = cast<VectorType>(V1->getType())->getNumElements();
   for (int Elem : Mask)
     if (Elem != UndefMaskElem && Elem >= V1Size * 2)
       return false;
 
-  if (cast<VectorType>(V1->getType())->isScalable())
+  if (isa<ScalableVectorType>(V1->getType()))
     if ((Mask[0] != 0 && Mask[0] != UndefMaskElem) || !is_splat(Mask))
       return false;
 
   return true;
 }
 
 bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
                                         const Value *Mask) {
   // V1 and V2 must be vectors of the same type.
   if (!V1->getType()->isVectorTy() || V1->getType() != V2->getType())
     return false;
 
-  // Mask must be vector of i32.
+  // Mask must be vector of i32, and must be the same kind of vector as the
+  // input vectors
   auto *MaskTy = dyn_cast<VectorType>(Mask->getType());
   if (!MaskTy || !MaskTy->getElementType()->isIntegerTy(32) ||
-      MaskTy->isScalable() != cast<VectorType>(V1->getType())->isScalable())
+      isa<ScalableVectorType>(MaskTy) != isa<ScalableVectorType>(V1->getType()))
     return false;
 
   // Check to see if Mask is valid.
   if (isa<UndefValue>(Mask) || isa<ConstantAggregateZero>(Mask))
     return true;
 
   if (const auto *MV = dyn_cast<ConstantVector>(Mask)) {
     unsigned V1Size = cast<VectorType>(V1->getType())->getNumElements();

 
 void ShuffleVectorInst::setShuffleMask(ArrayRef<int> Mask) {
   ShuffleMask.assign(Mask.begin(), Mask.end());
   ShuffleMaskForBitcode = convertShuffleMaskForBitcode(Mask, getType());
 }
 Constant *ShuffleVectorInst::convertShuffleMaskForBitcode(ArrayRef<int> Mask,
                                                           Type *ResultTy) {
   Type *Int32Ty = Type::getInt32Ty(ResultTy->getContext());
-  if (cast<VectorType>(ResultTy)->isScalable()) {
+  if (isa<ScalableVectorType>(ResultTy)) {
     assert(is_splat(Mask) && "Unexpected shuffle");
     Type *VecTy = VectorType::get(Int32Ty, Mask.size(), true);
     if (Mask[0] == 0)
       return Constant::getNullValue(VecTy);
     return UndefValue::get(VecTy);
   }
   SmallVector<Constant *, 16> MaskConst;
   for (int Elem : Mask) {

llvm/lib/IR/Operator.cpp

for (gep_type_iterator GTI = gep_type_begin(this), GTE = gep_type_end(this);
        GTI != GTE; ++GTI) {
     ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
     if (!OpC)
       return false;
     if (OpC->isZero())
       continue;
 
     // Scalable vectors have are multiplied by a runtime constant.
-    if (auto *VecTy = dyn_cast<VectorType>(GTI.getIndexedType()))
-      if (VecTy->isScalable())
-        return false;
+    if (isa<ScalableVectorType>(GTI.getIndexedType()))
 
     // Handle a struct index, which adds its field offset to the pointer.
     if (StructType *STy = GTI.getStructTypeOrNull()) {
       unsigned ElementIdx = OpC->getZExtValue();
       const StructLayout *SL = DL.getStructLayout(STy);
       Offset += APInt(Offset.getBitWidth(), SL->getElementOffset(ElementIdx));
       continue;
     }

llvm/lib/IR/Type.cpp

 StringRef StructType::getName() const {
   assert(!isLiteral() && "Literal structs never have names");
   if (!SymbolTableEntry) return StringRef();
 
   return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
 }
 
 bool StructType::isValidElementType(Type *ElemTy) {
-  if (auto *VTy = dyn_cast<VectorType>(ElemTy))
-    return !VTy->isScalable();
   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
-         !ElemTy->isTokenTy();
+         !ElemTy->isTokenTy() && !isa<ScalableVectorType>(ElemTy);
 }
 
 bool StructType::isLayoutIdentical(StructType *Other) const {
   if (this == Other) return true;
 
   if (isPacked() != Other->isPacked())
     return false;
 
ArrayType *&Entry =
     pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
 
   if (!Entry)
     Entry = new (pImpl->Alloc) ArrayType(ElementType, NumElements);
   return Entry;
 }
 
 bool ArrayType::isValidElementType(Type *ElemTy) {
-  if (auto *VTy = dyn_cast<VectorType>(ElemTy))
-    return !VTy->isScalable();
   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
-         !ElemTy->isTokenTy();
+         !ElemTy->isTokenTy() && !isa<ScalableVectorType>(ElemTy);
 }
 
 //===----------------------------------------------------------------------===//
 //                          VectorType Implementation
 //===----------------------------------------------------------------------===//
 
 VectorType::VectorType(Type *ElType, ElementCount EC, Type::TypeID TID)
     : Type(ElType->getContext(), TID), ContainedType(ElType), EC(EC) {

llvm/lib/IR/Verifier.cpp

else
       AssertDI(false, "!dbg attachment of global variable must be a "
                       "DIGlobalVariableExpression");
   }
 
   // Scalable vectors cannot be global variables, since we don't know
   // the runtime size. If the global is a struct or an array containing
   // scalable vectors, that will be caught by the isValidElementType methods
   // in StructType or ArrayType instead.
-  if (auto *VTy = dyn_cast<VectorType>(GV.getValueType()))
-    Assert(!VTy->isScalable(), "Globals cannot contain scalable vectors", &GV);
+  Assert(!isa<ScalableVectorType>(GV.getValueType()),
+         "Globals cannot contain scalable vectors", &GV);
 
   if (!GV.hasInitializer()) {
     visitGlobalValue(GV);
     return;
   }
 
   // Walk any aggregate initializers looking for bitcasts between address spaces
   visitConstantExprsRecursively(GV.getInitializer());

llvm/unittests/IR/VectorTypesTest.cpp

TEST(VectorTypesTest, FixedLength) {
   LLVMContext Ctx;
 
   Type *Int16Ty = Type::getInt16Ty(Ctx);
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   Type *Int64Ty = Type::getInt64Ty(Ctx);
   Type *Float64Ty = Type::getDoubleTy(Ctx);
 
   VectorType *V8Int32Ty = VectorType::get(Int32Ty, 8);
-  ASSERT_FALSE(V8Int32Ty->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(V8Int32Ty));
   EXPECT_EQ(V8Int32Ty->getNumElements(), 8U);
   EXPECT_EQ(V8Int32Ty->getElementType()->getScalarSizeInBits(), 32U);
 
   VectorType *V8Int16Ty = VectorType::get(Int16Ty, {8, false});
-  ASSERT_FALSE(V8Int16Ty->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(V8Int16Ty));
   EXPECT_EQ(V8Int16Ty->getNumElements(), 8U);
   EXPECT_EQ(V8Int16Ty->getElementType()->getScalarSizeInBits(), 16U);
 
   ElementCount EltCnt(4, false);
   VectorType *V4Int64Ty = VectorType::get(Int64Ty, EltCnt);
-  ASSERT_FALSE(V4Int64Ty->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(V4Int64Ty));
   EXPECT_EQ(V4Int64Ty->getNumElements(), 4U);
   EXPECT_EQ(V4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *V2Int64Ty = VectorType::get(Int64Ty, EltCnt/2);
-  ASSERT_FALSE(V2Int64Ty->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(V2Int64Ty));
   EXPECT_EQ(V2Int64Ty->getNumElements(), 2U);
   EXPECT_EQ(V2Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *V8Int64Ty = VectorType::get(Int64Ty, EltCnt*2);
-  ASSERT_FALSE(V8Int64Ty->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(V8Int64Ty));
   EXPECT_EQ(V8Int64Ty->getNumElements(), 8U);
   EXPECT_EQ(V8Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *V4Float64Ty = VectorType::get(Float64Ty, EltCnt);
-  ASSERT_FALSE(V4Float64Ty->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(V4Float64Ty));
   EXPECT_EQ(V4Float64Ty->getNumElements(), 4U);
   EXPECT_EQ(V4Float64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *ExtTy = VectorType::getExtendedElementVectorType(V8Int16Ty);
   EXPECT_EQ(ExtTy, V8Int32Ty);
-  ASSERT_FALSE(ExtTy->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(ExtTy));
   EXPECT_EQ(ExtTy->getNumElements(), 8U);
   EXPECT_EQ(ExtTy->getElementType()->getScalarSizeInBits(), 32U);
 
   VectorType *TruncTy = VectorType::getTruncatedElementVectorType(V8Int32Ty);
   EXPECT_EQ(TruncTy, V8Int16Ty);
-  ASSERT_FALSE(TruncTy->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(TruncTy));
   EXPECT_EQ(TruncTy->getNumElements(), 8U);
   EXPECT_EQ(TruncTy->getElementType()->getScalarSizeInBits(), 16U);
 
   VectorType *HalvedTy = VectorType::getHalfElementsVectorType(V4Int64Ty);
   EXPECT_EQ(HalvedTy, V2Int64Ty);
-  ASSERT_FALSE(HalvedTy->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(HalvedTy));
   EXPECT_EQ(HalvedTy->getNumElements(), 2U);
   EXPECT_EQ(HalvedTy->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *DoubledTy = VectorType::getDoubleElementsVectorType(V4Int64Ty);
   EXPECT_EQ(DoubledTy, V8Int64Ty);
-  ASSERT_FALSE(DoubledTy->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(DoubledTy));
   EXPECT_EQ(DoubledTy->getNumElements(), 8U);
   EXPECT_EQ(DoubledTy->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *ConvTy = VectorType::getInteger(V4Float64Ty);
   EXPECT_EQ(ConvTy, V4Int64Ty);
-  ASSERT_FALSE(ConvTy->isScalable());
+  ASSERT_TRUE(isa<FixedVectorType>(ConvTy));
   EXPECT_EQ(ConvTy->getNumElements(), 4U);
   EXPECT_EQ(ConvTy->getElementType()->getScalarSizeInBits(), 64U);
 
   EltCnt = V8Int64Ty->getElementCount();
   EXPECT_EQ(EltCnt.Min, 8U);
   ASSERT_FALSE(EltCnt.Scalable);
 }
 
 TEST(VectorTypesTest, Scalable) {
   LLVMContext Ctx;
 
   Type *Int16Ty = Type::getInt16Ty(Ctx);
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   Type *Int64Ty = Type::getInt64Ty(Ctx);
   Type *Float64Ty = Type::getDoubleTy(Ctx);
 
   VectorType *ScV8Int32Ty = VectorType::get(Int32Ty, 8, true);
-  ASSERT_TRUE(ScV8Int32Ty->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ScV8Int32Ty));
   EXPECT_EQ(ScV8Int32Ty->getNumElements(), 8U);
   EXPECT_EQ(ScV8Int32Ty->getElementType()->getScalarSizeInBits(), 32U);
 
   VectorType *ScV8Int16Ty = VectorType::get(Int16Ty, {8, true});
-  ASSERT_TRUE(ScV8Int16Ty->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ScV8Int16Ty));
   EXPECT_EQ(ScV8Int16Ty->getNumElements(), 8U);
   EXPECT_EQ(ScV8Int16Ty->getElementType()->getScalarSizeInBits(), 16U);
 
   ElementCount EltCnt(4, true);
   VectorType *ScV4Int64Ty = VectorType::get(Int64Ty, EltCnt);
-  ASSERT_TRUE(ScV4Int64Ty->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ScV4Int64Ty));
   EXPECT_EQ(ScV4Int64Ty->getNumElements(), 4U);
   EXPECT_EQ(ScV4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *ScV2Int64Ty = VectorType::get(Int64Ty, EltCnt/2);
-  ASSERT_TRUE(ScV2Int64Ty->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ScV2Int64Ty));
   EXPECT_EQ(ScV2Int64Ty->getNumElements(), 2U);
   EXPECT_EQ(ScV2Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *ScV8Int64Ty = VectorType::get(Int64Ty, EltCnt*2);
-  ASSERT_TRUE(ScV8Int64Ty->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ScV8Int64Ty));
   EXPECT_EQ(ScV8Int64Ty->getNumElements(), 8U);
   EXPECT_EQ(ScV8Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *ScV4Float64Ty = VectorType::get(Float64Ty, EltCnt);
-  ASSERT_TRUE(ScV4Float64Ty->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ScV4Float64Ty));
   EXPECT_EQ(ScV4Float64Ty->getNumElements(), 4U);
   EXPECT_EQ(ScV4Float64Ty->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *ExtTy = VectorType::getExtendedElementVectorType(ScV8Int16Ty);
   EXPECT_EQ(ExtTy, ScV8Int32Ty);
-  ASSERT_TRUE(ExtTy->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ExtTy));
   EXPECT_EQ(ExtTy->getNumElements(), 8U);
   EXPECT_EQ(ExtTy->getElementType()->getScalarSizeInBits(), 32U);
 
   VectorType *TruncTy = VectorType::getTruncatedElementVectorType(ScV8Int32Ty);
   EXPECT_EQ(TruncTy, ScV8Int16Ty);
-  ASSERT_TRUE(TruncTy->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(TruncTy));
   EXPECT_EQ(TruncTy->getNumElements(), 8U);
   EXPECT_EQ(TruncTy->getElementType()->getScalarSizeInBits(), 16U);
 
   VectorType *HalvedTy = VectorType::getHalfElementsVectorType(ScV4Int64Ty);
   EXPECT_EQ(HalvedTy, ScV2Int64Ty);
-  ASSERT_TRUE(HalvedTy->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(HalvedTy));
   EXPECT_EQ(HalvedTy->getNumElements(), 2U);
   EXPECT_EQ(HalvedTy->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *DoubledTy = VectorType::getDoubleElementsVectorType(ScV4Int64Ty);
   EXPECT_EQ(DoubledTy, ScV8Int64Ty);
-  ASSERT_TRUE(DoubledTy->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(DoubledTy));
   EXPECT_EQ(DoubledTy->getNumElements(), 8U);
   EXPECT_EQ(DoubledTy->getElementType()->getScalarSizeInBits(), 64U);
 
   VectorType *ConvTy = VectorType::getInteger(ScV4Float64Ty);
   EXPECT_EQ(ConvTy, ScV4Int64Ty);
-  ASSERT_TRUE(ConvTy->isScalable());
+  ASSERT_TRUE(isa<ScalableVectorType>(ConvTy));
   EXPECT_EQ(ConvTy->getNumElements(), 4U);
   EXPECT_EQ(ConvTy->getElementType()->getScalarSizeInBits(), 64U);
 
   EltCnt = ScV8Int64Ty->getElementCount();
   EXPECT_EQ(EltCnt.Min, 8U);
   ASSERT_TRUE(EltCnt.Scalable);
 }
 
 TEST(VectorTypesTest, FixedLenComparisons) {
   LLVMContext Ctx;
   DataLayout DL("");
 
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   Type *Int64Ty = Type::getInt64Ty(Ctx);
 
   VectorType *V2Int32Ty = VectorType::get(Int32Ty, 2);
   VectorType *V4Int32Ty = VectorType::get(Int32Ty, 4);
 
   VectorType *V2Int64Ty = VectorType::get(Int64Ty, 2);
 
   TypeSize V2I32Len = V2Int32Ty->getPrimitiveSizeInBits();
   EXPECT_EQ(V2I32Len.getKnownMinSize(), 64U);
-  EXPECT_FALSE(V2I32Len.isScalable());
+  EXPECT_TRUE(V2I32Len.isScalable());
 
   EXPECT_LT(V2Int32Ty->getPrimitiveSizeInBits(),
             V4Int32Ty->getPrimitiveSizeInBits());
   EXPECT_GT(V2Int64Ty->getPrimitiveSizeInBits(),
             V2Int32Ty->getPrimitiveSizeInBits());
   EXPECT_EQ(V4Int32Ty->getPrimitiveSizeInBits(),
             V2Int64Ty->getPrimitiveSizeInBits());
   EXPECT_NE(V2Int32Ty->getPrimitiveSizeInBits(),