Scalarizer: explicitly exclude scalable vectors

[nhaehnle]

Summary

They are unsupported and would previously crash, now we just skip them.

Hypothetically, one could consider "scalarizing" a <vscale x n x T> into
n copies of <vscale x 1 x T>. But (1) it's unclear how to do that
because insertelement etc. don't work with scalable vectors in the
required way, and (2) there is no user of such functionality.

[nikic]

LGTM

llvm/lib/Transforms/Scalar/Scalarizer.cpp

struct VectorLayout {
   VectorLayout() = default;
 
   // Return the alignment of element I.
   Align getElemAlign(unsigned I) {
     return commonAlignment(VecAlign, I * ElemSize);
   }
 
   // The type of the vector.
-  VectorType *VecTy = nullptr;
+  FixedVectorType *VecTy = nullptr;
 
   // The type of each element.
   Type *ElemTy = nullptr;
 
   // The alignment of the vector.
   Align VecAlign;
 
   // The size of each element.

 // Try to fill in Layout from Ty, returning true on success.  Alignment is
 // the alignment of the vector, or std::nullopt if the ABI default should be
 // used.
 Optional<VectorLayout>
 ScalarizerVisitor::getVectorLayout(Type *Ty, Align Alignment,
                                    const DataLayout &DL) {
   VectorLayout Layout;
   // Make sure we're dealing with a vector.
-  Layout.VecTy = dyn_cast<VectorType>(Ty);
+  Layout.VecTy = dyn_cast<FixedVectorType>(Ty);
   if (!Layout.VecTy)
     return std::nullopt;
   // Check that we're dealing with full-byte elements.
   Layout.ElemTy = Layout.VecTy->getElementType();
   if (!DL.typeSizeEqualsStoreSize(Layout.ElemTy))
     return std::nullopt;
   Layout.VecAlign = Alignment;
   Layout.ElemSize = DL.getTypeStoreSize(Layout.ElemTy);
   return Layout;
 }
 
 // Scalarize one-operand instruction I, using Split(Builder, X, Name)
 // to create an instruction like I with operand X and name Name.
 template<typename Splitter>
 bool ScalarizerVisitor::splitUnary(Instruction &I, const Splitter &Split) {
-  VectorType *VT = dyn_cast<VectorType>(I.getType());
+  auto *VT = dyn_cast<FixedVectorType>(I.getType());
   if (!VT)
     return false;
 
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   IRBuilder<> Builder(&I);
   Scatterer Op = scatter(&I, I.getOperand(0));
   assert(Op.size() == NumElems && "Mismatched unary operation");
   ValueVector Res;
   Res.resize(NumElems);
   for (unsigned Elem = 0; Elem < NumElems; ++Elem)
     Res[Elem] = Split(Builder, Op[Elem], I.getName() + ".i" + Twine(Elem));
   gather(&I, Res);
   return true;
 }
 
 // Scalarize two-operand instruction I, using Split(Builder, X, Y, Name)
 // to create an instruction like I with operands X and Y and name Name.
 template<typename Splitter>
 bool ScalarizerVisitor::splitBinary(Instruction &I, const Splitter &Split) {
-  VectorType *VT = dyn_cast<VectorType>(I.getType());
+  auto *VT = dyn_cast<FixedVectorType>(I.getType());
   if (!VT)
     return false;
 
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   IRBuilder<> Builder(&I);
   Scatterer VOp0 = scatter(&I, I.getOperand(0));
   Scatterer VOp1 = scatter(&I, I.getOperand(1));
   assert(VOp0.size() == NumElems && "Mismatched binary operation");
   assert(VOp1.size() == NumElems && "Mismatched binary operation");
   ValueVector Res;
   Res.resize(NumElems);
   for (unsigned Elem = 0; Elem < NumElems; ++Elem) {
static Function *getScalarIntrinsicDeclaration(Module *M,
                                                Intrinsic::ID ID,
                                                ArrayRef<Type*> Tys) {
   return Intrinsic::getDeclaration(M, ID, Tys);
 }
 
 /// If a call to a vector typed intrinsic function, split into a scalar call per
 /// element if possible for the intrinsic.
 bool ScalarizerVisitor::splitCall(CallInst &CI) {
-  VectorType *VT = dyn_cast<VectorType>(CI.getType());
+  auto *VT = dyn_cast<FixedVectorType>(CI.getType());
   if (!VT)
     return false;
 
   Function *F = CI.getCalledFunction();
   if (!F)
     return false;
 
   Intrinsic::ID ID = F->getIntrinsicID();
   if (ID == Intrinsic::not_intrinsic || !isTriviallyScalariable(ID))
     return false;
 
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   unsigned NumArgs = CI.arg_size();
 
   ValueVector ScalarOperands(NumArgs);
   SmallVector<Scatterer, 8> Scattered(NumArgs);
 
   Scattered.resize(NumArgs);
 
   SmallVector<llvm::Type *, 3> Tys;
Res[Elem] = Builder.CreateCall(NewIntrin, ScalarCallOps,
                                    CI.getName() + ".i" + Twine(Elem));
   }
 
   gather(&CI, Res);
   return true;
 }
 
 bool ScalarizerVisitor::visitSelectInst(SelectInst &SI) {
-  VectorType *VT = dyn_cast<VectorType>(SI.getType());
+  auto *VT = dyn_cast<FixedVectorType>(SI.getType());
   if (!VT)
     return false;
 
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   IRBuilder<> Builder(&SI);
   Scatterer VOp1 = scatter(&SI, SI.getOperand(1));
   Scatterer VOp2 = scatter(&SI, SI.getOperand(2));
   assert(VOp1.size() == NumElems && "Mismatched select");
   assert(VOp2.size() == NumElems && "Mismatched select");
   ValueVector Res;
   Res.resize(NumElems);
 
bool ScalarizerVisitor::visitUnaryOperator(UnaryOperator &UO) {
   return splitUnary(UO, UnarySplitter(UO));
 }
 
 bool ScalarizerVisitor::visitBinaryOperator(BinaryOperator &BO) {
   return splitBinary(BO, BinarySplitter(BO));
 }
 
 bool ScalarizerVisitor::visitGetElementPtrInst(GetElementPtrInst &GEPI) {
-  VectorType *VT = dyn_cast<VectorType>(GEPI.getType());
+  auto *VT = dyn_cast<FixedVectorType>(GEPI.getType());
   if (!VT)
     return false;
 
   IRBuilder<> Builder(&GEPI);
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   unsigned NumIndices = GEPI.getNumIndices();
 
   // The base pointer might be scalar even if it's a vector GEP. In those cases,
   // splat the pointer into a vector value, and scatter that vector.
   Value *Op0 = GEPI.getOperand(0);
   if (!Op0->getType()->isVectorTy())
     Op0 = Builder.CreateVectorSplat(NumElems, Op0);
   Scatterer Base = scatter(&GEPI, Op0);
if (GEPI.isInBounds())
       if (GetElementPtrInst *NewGEPI = dyn_cast<GetElementPtrInst>(Res[I]))
         NewGEPI->setIsInBounds();
   }
   gather(&GEPI, Res);
   return true;
 }
 
 bool ScalarizerVisitor::visitCastInst(CastInst &CI) {
-  VectorType *VT = dyn_cast<VectorType>(CI.getDestTy());
+  auto *VT = dyn_cast<FixedVectorType>(CI.getDestTy());
   if (!VT)
     return false;
 
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   IRBuilder<> Builder(&CI);
   Scatterer Op0 = scatter(&CI, CI.getOperand(0));
   assert(Op0.size() == NumElems && "Mismatched cast");
   ValueVector Res;
   Res.resize(NumElems);
   for (unsigned I = 0; I < NumElems; ++I)
     Res[I] = Builder.CreateCast(CI.getOpcode(), Op0[I], VT->getElementType(),
                                 CI.getName() + ".i" + Twine(I));
   gather(&CI, Res);
   return true;
 }
 
 bool ScalarizerVisitor::visitBitCastInst(BitCastInst &BCI) {
-  VectorType *DstVT = dyn_cast<VectorType>(BCI.getDestTy());
-  VectorType *SrcVT = dyn_cast<VectorType>(BCI.getSrcTy());
+  auto *DstVT = dyn_cast<FixedVectorType>(BCI.getDestTy());
+  auto *SrcVT = dyn_cast<FixedVectorType>(BCI.getSrcTy());
   if (!DstVT || !SrcVT)
     return false;
 
-  unsigned DstNumElems = cast<FixedVectorType>(DstVT)->getNumElements();
-  unsigned SrcNumElems = cast<FixedVectorType>(SrcVT)->getNumElements();
+  unsigned DstNumElems = DstVT->getNumElements();
+  unsigned SrcNumElems = SrcVT->getNumElements();
   IRBuilder<> Builder(&BCI);
   Scatterer Op0 = scatter(&BCI, BCI.getOperand(0));
   ValueVector Res;
   Res.resize(DstNumElems);
 
   if (DstNumElems == SrcNumElems) {
     for (unsigned I = 0; I < DstNumElems; ++I)
       Res[I] = Builder.CreateBitCast(Op0[I], DstVT->getElementType(),
for (unsigned ResI = 0; ResI < DstNumElems; ++ResI) {
                                         BCI.getName() + ".i" + Twine(ResI));
     }
   }
   gather(&BCI, Res);
   return true;
 }
 
 bool ScalarizerVisitor::visitInsertElementInst(InsertElementInst &IEI) {
-  VectorType *VT = dyn_cast<VectorType>(IEI.getType());
+  auto *VT = dyn_cast<FixedVectorType>(IEI.getType());
   if (!VT)
     return false;
 
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   IRBuilder<> Builder(&IEI);
   Scatterer Op0 = scatter(&IEI, IEI.getOperand(0));
   Value *NewElt = IEI.getOperand(1);
   Value *InsIdx = IEI.getOperand(2);
 
   ValueVector Res;
   Res.resize(NumElems);
 
if (auto *CI = dyn_cast<ConstantInt>(InsIdx)) {
     }
   }
 
   gather(&IEI, Res);
   return true;
 }
 
 bool ScalarizerVisitor::visitExtractElementInst(ExtractElementInst &EEI) {
-  VectorType *VT = dyn_cast<VectorType>(EEI.getOperand(0)->getType());
+  auto *VT = dyn_cast<FixedVectorType>(EEI.getOperand(0)->getType());
   if (!VT)
     return false;
 
-  unsigned NumSrcElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumSrcElems = VT->getNumElements();
   IRBuilder<> Builder(&EEI);
   Scatterer Op0 = scatter(&EEI, EEI.getOperand(0));
   Value *ExtIdx = EEI.getOperand(1);
 
   if (auto *CI = dyn_cast<ConstantInt>(ExtIdx)) {
     Value *Res = Op0[CI->getValue().getZExtValue()];
     replaceUses(&EEI, Res);
     return true;
for (unsigned I = 0; I < NumSrcElems; ++I) {
     Res = Builder.CreateSelect(ShouldExtract, Elt, Res,
                                EEI.getName() + ".upto" + Twine(I));
   }
   replaceUses(&EEI, Res);
   return true;
 }
 
 bool ScalarizerVisitor::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
-  VectorType *VT = dyn_cast<VectorType>(SVI.getType());
+  auto *VT = dyn_cast<FixedVectorType>(SVI.getType());
   if (!VT)
     return false;
 
-  unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
+  unsigned NumElems = VT->getNumElements();
   Scatterer Op0 = scatter(&SVI, SVI.getOperand(0));
   Scatterer Op1 = scatter(&SVI, SVI.getOperand(1));
   ValueVector Res;
   Res.resize(NumElems);
 
   for (unsigned I = 0; I < NumElems; ++I) {
     int Selector = SVI.getMaskValue(I);
     if (Selector < 0)
       Res[I] = UndefValue::get(VT->getElementType());
     else if (unsigned(Selector) < Op0.size())
       Res[I] = Op0[Selector];
     else
       Res[I] = Op1[Selector - Op0.size()];
   }
   gather(&SVI, Res);
   return true;
 }
 
 bool ScalarizerVisitor::visitPHINode(PHINode &PHI) {
-  VectorType *VT = dyn_cast<VectorType>(PHI.getType());
+  auto *VT = dyn_cast<FixedVectorType>(PHI.getType());
   if (!VT)
     return false;
 
   unsigned NumElems = cast<FixedVectorType>(VT)->getNumElements();
   IRBuilder<> Builder(&PHI);
   ValueVector Res;
   Res.resize(NumElems);
 
if (Gathered.empty() && Scattered.empty() && !Scalarized)
     return false;
   for (const auto &GMI : Gathered) {
     Instruction *Op = GMI.first;
     ValueVector &CV = *GMI.second;
     if (!Op->use_empty()) {
       // The value is still needed, so recreate it using a series of
       // InsertElements.
       Value *Res = PoisonValue::get(Op->getType());
-      if (auto *Ty = dyn_cast<VectorType>(Op->getType())) {
+      if (auto *Ty = dyn_cast<FixedVectorType>(Op->getType())) {
         BasicBlock *BB = Op->getParent();
-        unsigned Count = cast<FixedVectorType>(Ty)->getNumElements();
+        unsigned Count = Ty->getNumElements();
         IRBuilder<> Builder(Op);
         if (isa<PHINode>(Op))
           Builder.SetInsertPoint(BB, BB->getFirstInsertionPt());
         for (unsigned I = 0; I < Count; ++I)
           Res = Builder.CreateInsertElement(Res, CV[I], Builder.getInt32(I),
                                             Op->getName() + ".upto" + Twine(I));
         Res->takeName(Op);
       } else {

llvm/test/Transforms/Scalarizer/ignore-scalable-vectors.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt %s -passes=scalarizer -S -o - | FileCheck %s
+
+define <vscale x 1 x i32> @test1(<vscale x 1 x i32> %a, <vscale x 1 x i32> %b) {
+; CHECK-LABEL: @test1(
+; CHECK-NEXT:    [[R:%.*]] = add <vscale x 1 x i32> [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    ret <vscale x 1 x i32> [[R]]
+;
+  %r = add <vscale x 1 x i32> %a, %b
+  ret <vscale x 1 x i32> %r
+}