[SVE] Eliminate calls to default-false VectorType::get() from CodeGen

[efriedma]

llvm/lib/CodeGen/ValueTypes.cpp

166

I think I'd prefer to just let clang-format use its default formatting for this switch... as it is, the code doesn't fit into 80 columns.

[ctetreau]

rebase

[ctetreau]

llvm/lib/CodeGen/ValueTypes.cpp

166

Somebody clearly went to great lengths to format this switch nicely, I feel like this is the sort of thing clang-format on/off is for. I don't feel particularly strongly about it either way though.

[ctetreau]

catch straggler

[ctetreau]

rebase

[ctetreau]

address code reveiw issues

[ctetreau]

rebase

[ctetreau]

rebase

[c-rhodes]

llvm/lib/CodeGen/ValueTypes.cpp

332–337

I think you removed these by mistake when rebasing, causing test failures

[ctetreau]

fix rebase issue

[gchatelet]

LGTM but wait for other reviewers to approve.

[spatel]

That switch() seems like it deserves some kind of preprocessor/stringify magic, but since it's already a mess, I guess we shouldn't hold this up. LGTM.

llvm/lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::optimizeGatherScatterInst(Instruction *MemoryInst,
   Type *ScalarIndexTy = DL->getIndexType(Ops[0]->getType()->getScalarType());
 
   Value *NewAddr;
 
   // If the final index isn't a vector, emit a scalar GEP containing all ops
   // and a vector GEP with all zeroes final index.
   if (!Ops[FinalIndex]->getType()->isVectorTy()) {
     NewAddr = Builder.CreateGEP(Ops[0], makeArrayRef(Ops).drop_front());
-    Type *IndexTy = VectorType::get(ScalarIndexTy, NumElts);
+    auto *IndexTy = FixedVectorType::get(ScalarIndexTy, NumElts);
     NewAddr = Builder.CreateGEP(NewAddr, Constant::getNullValue(IndexTy));
   } else {
     Value *Base = Ops[0];
     Value *Index = Ops[FinalIndex];
 
     // Create a scalar GEP if there are more than 2 operands.
     if (Ops.size() != 2) {
       // Replace the last index with 0.
bool CodeGenPrepare::optimizeShuffleVectorInst(ShuffleVectorInst *SVI) {
   Type *NewType = TLI->shouldConvertSplatType(SVI);
   if (!NewType)
     return false;
 
   VectorType *SVIVecType = cast<VectorType>(SVI->getType());
   assert(!NewType->isVectorTy() && "Expected a scalar type!");
   assert(NewType->getScalarSizeInBits() == SVIVecType->getScalarSizeInBits() &&
          "Expected a type of the same size!");
-  Type *NewVecType = VectorType::get(NewType, SVIVecType->getNumElements());
+  auto *NewVecType =
+      FixedVectorType::get(NewType, SVIVecType->getNumElements());
 
   // Create a bitcast (shuffle (insert (bitcast(..))))
   IRBuilder<> Builder(SVI->getContext());
   Builder.SetInsertPoint(SVI);
   Value *BC1 = Builder.CreateBitCast(
       cast<Instruction>(SVI->getOperand(0))->getOperand(1), NewType);
   Value *Insert = Builder.CreateInsertElement(UndefValue::get(NewVecType), BC1,
                                               (uint64_t)0);

llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp

while (Size) {
     Size -= TySize;
   }
 
   return true;
 }
 
 static Type *getTypeForLLT(LLT Ty, LLVMContext &C) {
   if (Ty.isVector())
-    return VectorType::get(IntegerType::get(C, Ty.getScalarSizeInBits()),
+    return FixedVectorType::get(IntegerType::get(C, Ty.getScalarSizeInBits()),
                                 Ty.getNumElements());
   return IntegerType::get(C, Ty.getSizeInBits());
 }
 
 // Get a vectorized representation of the memset value operand, GISel edition.
 static Register getMemsetValue(Register Val, LLT Ty, MachineIRBuilder &MIB) {
   MachineRegisterInfo &MRI = *MIB.getMRI();
   unsigned NumBits = Ty.getScalarSizeInBits();
   auto ValVRegAndVal = getConstantVRegValWithLookThrough(Val, MRI);

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

if (auto *VT = dyn_cast<VectorType>(U.getType()))
     VectorWidth = VT->getNumElements();
 
   // We might need to splat the base pointer into a vector if the offsets
   // are vectors.
   if (VectorWidth && !PtrTy.isVector()) {
     BaseReg =
         MIRBuilder.buildSplatVector(LLT::vector(VectorWidth, PtrTy), BaseReg)
             .getReg(0);
-    PtrIRTy = VectorType::get(PtrIRTy, VectorWidth);
+    PtrIRTy = FixedVectorType::get(PtrIRTy, VectorWidth);
     PtrTy = getLLTForType(*PtrIRTy, *DL);
     OffsetIRTy = DL->getIntPtrType(PtrIRTy);
     OffsetTy = getLLTForType(*OffsetIRTy, *DL);
   }
 
   int64_t Offset = 0;
   for (gep_type_iterator GTI = gep_type_begin(&U), E = gep_type_end(&U);
        GTI != E; ++GTI) {

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

static SDValue getMemCmpLoad(const Value *PtrVal, MVT LoadVT,
                              SelectionDAGBuilder &Builder) {
   // Check to see if this load can be trivially constant folded, e.g. if the
   // input is from a string literal.
   if (const Constant *LoadInput = dyn_cast<Constant>(PtrVal)) {
     // Cast pointer to the type we really want to load.
     Type *LoadTy =
         Type::getIntNTy(PtrVal->getContext(), LoadVT.getScalarSizeInBits());
     if (LoadVT.isVector())
-      LoadTy = VectorType::get(LoadTy, LoadVT.getVectorNumElements());
+      LoadTy = FixedVectorType::get(LoadTy, LoadVT.getVectorNumElements());
 
     LoadInput = ConstantExpr::getBitCast(const_cast<Constant *>(LoadInput),
                                          PointerType::getUnqual(LoadTy));
 
     if (const Constant *LoadCst = ConstantFoldLoadFromConstPtr(
             const_cast<Constant *>(LoadInput), LoadTy, *Builder.DL))
       return Builder.getValue(LoadCst);
   }

llvm/lib/CodeGen/ValueTypes.cpp

std::string EVT::getEVTString() const {
   case MVT::exnref : return "exnref";
   }
 }
 
 /// getTypeForEVT - This method returns an LLVM type corresponding to the
 /// specified EVT.  For integer types, this returns an unsigned type.  Note
 /// that this will abort for types that cannot be represented.
 Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   switch (V.SimpleTy) {
   default:
     assert(isExtended() && "Type is not extended!");
     return LLVMTy;
   case MVT::isVoid:  return Type::getVoidTy(Context);
   case MVT::i1:      return Type::getInt1Ty(Context);
   case MVT::i8:      return Type::getInt8Ty(Context);
   case MVT::i16:     return Type::getInt16Ty(Context);
   case MVT::i32:     return Type::getInt32Ty(Context);
   case MVT::i64:     return Type::getInt64Ty(Context);
   case MVT::i128:    return IntegerType::get(Context, 128);
   case MVT::f16:     return Type::getHalfTy(Context);
   case MVT::bf16:     return Type::getBFloatTy(Context);
   case MVT::f32:     return Type::getFloatTy(Context);
   case MVT::f64:     return Type::getDoubleTy(Context);
   case MVT::f80:     return Type::getX86_FP80Ty(Context);
   case MVT::f128:    return Type::getFP128Ty(Context);
   case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
   case MVT::x86mmx:  return Type::getX86_MMXTy(Context);
-  case MVT::v1i1:    return VectorType::get(Type::getInt1Ty(Context), 1);
-  case MVT::v2i1:    return VectorType::get(Type::getInt1Ty(Context), 2);
-  case MVT::v4i1:    return VectorType::get(Type::getInt1Ty(Context), 4);
-  case MVT::v8i1:    return VectorType::get(Type::getInt1Ty(Context), 8);
-  case MVT::v16i1:   return VectorType::get(Type::getInt1Ty(Context), 16);
-  case MVT::v32i1:   return VectorType::get(Type::getInt1Ty(Context), 32);
-  case MVT::v64i1:   return VectorType::get(Type::getInt1Ty(Context), 64);
-  case MVT::v128i1:  return VectorType::get(Type::getInt1Ty(Context), 128);
-  case MVT::v256i1:  return VectorType::get(Type::getInt1Ty(Context), 256);
-  case MVT::v512i1:  return VectorType::get(Type::getInt1Ty(Context), 512);
-  case MVT::v1024i1: return VectorType::get(Type::getInt1Ty(Context), 1024);
-  case MVT::v1i8:    return VectorType::get(Type::getInt8Ty(Context), 1);
-  case MVT::v2i8:    return VectorType::get(Type::getInt8Ty(Context), 2);
-  case MVT::v4i8:    return VectorType::get(Type::getInt8Ty(Context), 4);
-  case MVT::v8i8:    return VectorType::get(Type::getInt8Ty(Context), 8);
-  case MVT::v16i8:   return VectorType::get(Type::getInt8Ty(Context), 16);
-  case MVT::v32i8:   return VectorType::get(Type::getInt8Ty(Context), 32);
-  case MVT::v64i8:   return VectorType::get(Type::getInt8Ty(Context), 64);
-  case MVT::v128i8:  return VectorType::get(Type::getInt8Ty(Context), 128);
-  case MVT::v256i8:  return VectorType::get(Type::getInt8Ty(Context), 256);
-  case MVT::v1i16:   return VectorType::get(Type::getInt16Ty(Context), 1);
-  case MVT::v2i16:   return VectorType::get(Type::getInt16Ty(Context), 2);
-  case MVT::v3i16:   return VectorType::get(Type::getInt16Ty(Context), 3);
-  case MVT::v4i16:   return VectorType::get(Type::getInt16Ty(Context), 4);
-  case MVT::v8i16:   return VectorType::get(Type::getInt16Ty(Context), 8);
-  case MVT::v16i16:  return VectorType::get(Type::getInt16Ty(Context), 16);
-  case MVT::v32i16:  return VectorType::get(Type::getInt16Ty(Context), 32);
-  case MVT::v64i16:  return VectorType::get(Type::getInt16Ty(Context), 64);
-  case MVT::v128i16: return VectorType::get(Type::getInt16Ty(Context), 128);
-  case MVT::v1i32:   return VectorType::get(Type::getInt32Ty(Context), 1);
-  case MVT::v2i32:   return VectorType::get(Type::getInt32Ty(Context), 2);
-  case MVT::v3i32:   return VectorType::get(Type::getInt32Ty(Context), 3);
-  case MVT::v4i32:   return VectorType::get(Type::getInt32Ty(Context), 4);
-  case MVT::v5i32:   return VectorType::get(Type::getInt32Ty(Context), 5);
-  case MVT::v8i32:   return VectorType::get(Type::getInt32Ty(Context), 8);
-  case MVT::v16i32:  return VectorType::get(Type::getInt32Ty(Context), 16);
-  case MVT::v32i32:  return VectorType::get(Type::getInt32Ty(Context), 32);
-  case MVT::v64i32:  return VectorType::get(Type::getInt32Ty(Context), 64);
-  case MVT::v128i32: return VectorType::get(Type::getInt32Ty(Context), 128);
-  case MVT::v256i32: return VectorType::get(Type::getInt32Ty(Context), 256);
-  case MVT::v512i32: return VectorType::get(Type::getInt32Ty(Context), 512);
-  case MVT::v1024i32:return VectorType::get(Type::getInt32Ty(Context), 1024);
-  case MVT::v2048i32:return VectorType::get(Type::getInt32Ty(Context), 2048);
-  case MVT::v1i64:   return VectorType::get(Type::getInt64Ty(Context), 1);
-  case MVT::v2i64:   return VectorType::get(Type::getInt64Ty(Context), 2);
-  case MVT::v4i64:   return VectorType::get(Type::getInt64Ty(Context), 4);
-  case MVT::v8i64:   return VectorType::get(Type::getInt64Ty(Context), 8);
-  case MVT::v16i64:  return VectorType::get(Type::getInt64Ty(Context), 16);
-  case MVT::v32i64:  return VectorType::get(Type::getInt64Ty(Context), 32);
-  case MVT::v1i128:  return VectorType::get(Type::getInt128Ty(Context), 1);
-  case MVT::v2f16:   return VectorType::get(Type::getHalfTy(Context), 2);
-  case MVT::v3f16:   return VectorType::get(Type::getHalfTy(Context), 3);
-  case MVT::v4f16:   return VectorType::get(Type::getHalfTy(Context), 4);
-  case MVT::v8f16:   return VectorType::get(Type::getHalfTy(Context), 8);
-  case MVT::v16f16:  return VectorType::get(Type::getHalfTy(Context), 16);
-  case MVT::v32f16:  return VectorType::get(Type::getHalfTy(Context), 32);
-  case MVT::v2bf16:  return VectorType::get(Type::getBFloatTy(Context), 2);
-  case MVT::v3bf16:  return VectorType::get(Type::getBFloatTy(Context), 3);
-  case MVT::v4bf16:  return VectorType::get(Type::getBFloatTy(Context), 4);
-  case MVT::v8bf16:  return VectorType::get(Type::getBFloatTy(Context), 8);
-  case MVT::v16bf16: return VectorType::get(Type::getBFloatTy(Context), 16);
-  case MVT::v32bf16: return VectorType::get(Type::getBFloatTy(Context), 32);
-  case MVT::v1f32:   return VectorType::get(Type::getFloatTy(Context), 1);
-  case MVT::v2f32:   return VectorType::get(Type::getFloatTy(Context), 2);
-  case MVT::v3f32:   return VectorType::get(Type::getFloatTy(Context), 3);
-  case MVT::v4f32:   return VectorType::get(Type::getFloatTy(Context), 4);
-  case MVT::v5f32:   return VectorType::get(Type::getFloatTy(Context), 5);
-  case MVT::v8f32:   return VectorType::get(Type::getFloatTy(Context), 8);
-  case MVT::v16f32:  return VectorType::get(Type::getFloatTy(Context), 16);
-  case MVT::v32f32:  return VectorType::get(Type::getFloatTy(Context), 32);
-  case MVT::v64f32:  return VectorType::get(Type::getFloatTy(Context), 64);
-  case MVT::v128f32: return VectorType::get(Type::getFloatTy(Context), 128);
-  case MVT::v256f32: return VectorType::get(Type::getFloatTy(Context), 256);
-  case MVT::v512f32: return VectorType::get(Type::getFloatTy(Context), 512);
-  case MVT::v1024f32:return VectorType::get(Type::getFloatTy(Context), 1024);
-  case MVT::v2048f32:return VectorType::get(Type::getFloatTy(Context), 2048);
-  case MVT::v1f64:   return VectorType::get(Type::getDoubleTy(Context), 1);
-  case MVT::v2f64:   return VectorType::get(Type::getDoubleTy(Context), 2);
-  case MVT::v4f64:   return VectorType::get(Type::getDoubleTy(Context), 4);
-  case MVT::v8f64:   return VectorType::get(Type::getDoubleTy(Context), 8);
-  case MVT::v16f64:  return VectorType::get(Type::getDoubleTy(Context), 16);
+  case MVT::v1i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 1);
+  case MVT::v2i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 2);
+  case MVT::v4i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 4);
+  case MVT::v8i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 8);
+  case MVT::v16i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 16);
+  case MVT::v32i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 32);
+  case MVT::v64i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 64);
+  case MVT::v128i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 128);
+  case MVT::v256i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 256);
+  case MVT::v512i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 512);
+  case MVT::v1024i1:
+    return FixedVectorType::get(Type::getInt1Ty(Context), 1024);
+  case MVT::v1i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 1);
+  case MVT::v2i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 2);
+  case MVT::v4i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 4);
+  case MVT::v8i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 8);
+  case MVT::v16i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 16);
+  case MVT::v32i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 32);
+  case MVT::v64i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 64);
+  case MVT::v128i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 128);
+  case MVT::v256i8:
+    return FixedVectorType::get(Type::getInt8Ty(Context), 256);
+  case MVT::v1i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 1);
+  case MVT::v2i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 2);
+  case MVT::v3i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 3);
+  case MVT::v4i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 4);
+  case MVT::v8i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 8);
+  case MVT::v16i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 16);
+  case MVT::v32i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 32);
+  case MVT::v64i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 64);
+  case MVT::v128i16:
+    return FixedVectorType::get(Type::getInt16Ty(Context), 128);
+  case MVT::v1i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 1);
+  case MVT::v2i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 2);
+  case MVT::v3i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 3);
+  case MVT::v4i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 4);
+  case MVT::v5i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 5);
+  case MVT::v8i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 8);
+  case MVT::v16i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 16);
+  case MVT::v32i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 32);
+  case MVT::v64i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 64);
+  case MVT::v128i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 128);
+  case MVT::v256i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 256);
+  case MVT::v512i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 512);
+  case MVT::v1024i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 1024);
+  case MVT::v2048i32:
+    return FixedVectorType::get(Type::getInt32Ty(Context), 2048);
+  case MVT::v1i64:
+    return FixedVectorType::get(Type::getInt64Ty(Context), 1);
+  case MVT::v2i64:
+    return FixedVectorType::get(Type::getInt64Ty(Context), 2);
+  case MVT::v4i64:
+    return FixedVectorType::get(Type::getInt64Ty(Context), 4);
+  case MVT::v8i64:
+    return FixedVectorType::get(Type::getInt64Ty(Context), 8);
+  case MVT::v16i64:
+    return FixedVectorType::get(Type::getInt64Ty(Context), 16);
+  case MVT::v32i64:
+    return FixedVectorType::get(Type::getInt64Ty(Context), 32);
+  case MVT::v1i128:
+    return FixedVectorType::get(Type::getInt128Ty(Context), 1);
+  case MVT::v2f16:
+    return FixedVectorType::get(Type::getHalfTy(Context), 2);
+  case MVT::v3f16:
+    return FixedVectorType::get(Type::getHalfTy(Context), 3);
+  case MVT::v4f16:
+    return FixedVectorType::get(Type::getHalfTy(Context), 4);
+  case MVT::v8f16:
+    return FixedVectorType::get(Type::getHalfTy(Context), 8);
+  case MVT::v16f16:
+    return FixedVectorType::get(Type::getHalfTy(Context), 16);
+  case MVT::v32f16:
+    return FixedVectorType::get(Type::getHalfTy(Context), 32);
+  case MVT::v1f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 1);
+  case MVT::v2f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 2);
+  case MVT::v3f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 3);
+  case MVT::v4f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 4);
+  case MVT::v5f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 5);
+  case MVT::v8f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 8);
+  case MVT::v16f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 16);
+  case MVT::v32f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 32);
+  case MVT::v64f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 64);
+  case MVT::v128f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 128);
+  case MVT::v256f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 256);
+  case MVT::v512f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 512);
+  case MVT::v1024f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 1024);
+  case MVT::v2048f32:
+    return FixedVectorType::get(Type::getFloatTy(Context), 2048);
+  case MVT::v1f64:
+    return FixedVectorType::get(Type::getDoubleTy(Context), 1);
+  case MVT::v2f64:
+    return FixedVectorType::get(Type::getDoubleTy(Context), 2);
+  case MVT::v4f64:
+    return FixedVectorType::get(Type::getDoubleTy(Context), 4);
+  case MVT::v8f64:
+    return FixedVectorType::get(Type::getDoubleTy(Context), 8);
+  case MVT::v16f64:
+    return FixedVectorType::get(Type::getDoubleTy(Context), 16);
   case MVT::nxv1i1:
-    return VectorType::get(Type::getInt1Ty(Context), 1, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt1Ty(Context), 1);
   case MVT::nxv2i1:
-    return VectorType::get(Type::getInt1Ty(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt1Ty(Context), 2);
   case MVT::nxv4i1:
-    return VectorType::get(Type::getInt1Ty(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt1Ty(Context), 4);
   case MVT::nxv8i1:
-    return VectorType::get(Type::getInt1Ty(Context), 8, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt1Ty(Context), 8);
   case MVT::nxv16i1:
-    return VectorType::get(Type::getInt1Ty(Context), 16, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt1Ty(Context), 16);
   case MVT::nxv32i1:
-    return VectorType::get(Type::getInt1Ty(Context), 32, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt1Ty(Context), 32);
   case MVT::nxv1i8:
-    return VectorType::get(Type::getInt8Ty(Context), 1, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt8Ty(Context), 1);
   case MVT::nxv2i8:
-    return VectorType::get(Type::getInt8Ty(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt8Ty(Context), 2);
   case MVT::nxv4i8:
-    return VectorType::get(Type::getInt8Ty(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt8Ty(Context), 4);
   case MVT::nxv8i8:
-    return VectorType::get(Type::getInt8Ty(Context), 8, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt8Ty(Context), 8);
   case MVT::nxv16i8:
-    return VectorType::get(Type::getInt8Ty(Context), 16, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt8Ty(Context), 16);
   case MVT::nxv32i8:
-    return VectorType::get(Type::getInt8Ty(Context), 32, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt8Ty(Context), 32);
   case MVT::nxv1i16:
-    return VectorType::get(Type::getInt16Ty(Context), 1, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt16Ty(Context), 1);
   case MVT::nxv2i16:
-    return VectorType::get(Type::getInt16Ty(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt16Ty(Context), 2);
   case MVT::nxv4i16:
-    return VectorType::get(Type::getInt16Ty(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt16Ty(Context), 4);
   case MVT::nxv8i16:
-    return VectorType::get(Type::getInt16Ty(Context), 8, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt16Ty(Context), 8);
   case MVT::nxv16i16:
-    return VectorType::get(Type::getInt16Ty(Context), 16, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt16Ty(Context), 16);
   case MVT::nxv32i16:
-    return VectorType::get(Type::getInt16Ty(Context), 32, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt16Ty(Context), 32);
   case MVT::nxv1i32:
-    return VectorType::get(Type::getInt32Ty(Context), 1, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt32Ty(Context), 1);
   case MVT::nxv2i32:
-    return VectorType::get(Type::getInt32Ty(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt32Ty(Context), 2);
   case MVT::nxv4i32:
-    return VectorType::get(Type::getInt32Ty(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt32Ty(Context), 4);
   case MVT::nxv8i32:
-    return VectorType::get(Type::getInt32Ty(Context), 8, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt32Ty(Context), 8);
   case MVT::nxv16i32:
-    return VectorType::get(Type::getInt32Ty(Context), 16,/*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt32Ty(Context), 16);
   case MVT::nxv32i32:
-    return VectorType::get(Type::getInt32Ty(Context), 32,/*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt32Ty(Context), 32);
   case MVT::nxv1i64:
-    return VectorType::get(Type::getInt64Ty(Context), 1, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt64Ty(Context), 1);
   case MVT::nxv2i64:
-    return VectorType::get(Type::getInt64Ty(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt64Ty(Context), 2);
   case MVT::nxv4i64:
-    return VectorType::get(Type::getInt64Ty(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt64Ty(Context), 4);
   case MVT::nxv8i64:
-    return VectorType::get(Type::getInt64Ty(Context), 8, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt64Ty(Context), 8);
   case MVT::nxv16i64:
-    return VectorType::get(Type::getInt64Ty(Context), 16, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt64Ty(Context), 16);
   case MVT::nxv32i64:
-    return VectorType::get(Type::getInt64Ty(Context), 32, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getInt64Ty(Context), 32);
   case MVT::nxv2f16:
-    return VectorType::get(Type::getHalfTy(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getHalfTy(Context), 2);
   case MVT::nxv4f16:
-    return VectorType::get(Type::getHalfTy(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getHalfTy(Context), 4);
   case MVT::nxv8f16:
-    return VectorType::get(Type::getHalfTy(Context), 8, /*Scalable=*/ true);
-  case MVT::nxv2bf16:
-    return VectorType::get(Type::getBFloatTy(Context), 2, /*Scalable=*/ true);
-  case MVT::nxv4bf16:
-    return VectorType::get(Type::getBFloatTy(Context), 4, /*Scalable=*/ true);
-  case MVT::nxv8bf16:
-    return VectorType::get(Type::getBFloatTy(Context), 8, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getHalfTy(Context), 8);
   case MVT::nxv1f32:
-    return VectorType::get(Type::getFloatTy(Context), 1, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getFloatTy(Context), 1);
   case MVT::nxv2f32:
-    return VectorType::get(Type::getFloatTy(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getFloatTy(Context), 2);
   case MVT::nxv4f32:
-    return VectorType::get(Type::getFloatTy(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getFloatTy(Context), 4);
   case MVT::nxv8f32:
-    return VectorType::get(Type::getFloatTy(Context), 8, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getFloatTy(Context), 8);
   case MVT::nxv16f32:
-    return VectorType::get(Type::getFloatTy(Context), 16, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getFloatTy(Context), 16);
   case MVT::nxv1f64:
-    return VectorType::get(Type::getDoubleTy(Context), 1, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getDoubleTy(Context), 1);
   case MVT::nxv2f64:
-    return VectorType::get(Type::getDoubleTy(Context), 2, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getDoubleTy(Context), 2);
   case MVT::nxv4f64:
-    return VectorType::get(Type::getDoubleTy(Context), 4, /*Scalable=*/ true);
+    return ScalableVectorType::get(Type::getDoubleTy(Context), 4);
   case MVT::nxv8f64:
-    return VectorType::get(Type::getDoubleTy(Context), 8, /*Scalable=*/ true);
-  case MVT::Metadata: return Type::getMetadataTy(Context);
+    return ScalableVectorType::get(Type::getDoubleTy(Context), 8);
+  case MVT::Metadata:
+    return Type::getMetadataTy(Context);
   }
 }
 
 /// Return the value type corresponding to the specified type.  This returns all
 /// pointers as MVT::iPTR.  If HandleUnknown is true, unknown types are returned
 /// as Other, otherwise they are invalid.
 MVT MVT::getVT(Type *Ty, bool HandleUnknown){
   switch (Ty->getTypeID()) {