[SVE] Remove calls to isScalable from Transforms

[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.

[efriedma]

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

593

This doesn't appear to be equivalent.

[ctetreau]

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

593

(NOT ((is vector) AND (is scalable))) => true for all values except scalable vectors
(is fixed width vector) => true only for fixed width vectors

I'll fix it

[ctetreau]

address code review issues

[ctetreau]

Catch straggler

[efriedma]

LGTM

[ctetreau]

catch straggler

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

static Instruction *combineLoadToOperationType(InstCombiner &IC, LoadInst &LI) {
 
   // Try to canonicalize loads which are only ever stored to operate over
   // integers instead of any other type. We only do this when the loaded type
   // is sized and has a size exactly the same as its store size and the store
   // size is a legal integer type.
   // Do not perform canonicalization if minmax pattern is found (to avoid
   // infinite loop).
   Type *Dummy;
-  if (!Ty->isIntegerTy() && Ty->isSized() &&
-      !(Ty->isVectorTy() && cast<VectorType>(Ty)->isScalable()) &&
+  if (!Ty->isIntegerTy() && Ty->isSized() && !isa<ScalableVectorType>(Ty) &&
       DL.isLegalInteger(DL.getTypeStoreSizeInBits(Ty)) &&
       DL.typeSizeEqualsStoreSize(Ty) && !DL.isNonIntegralPointerType(Ty) &&
       !isMinMaxWithLoads(
           peekThroughBitcast(LI.getPointerOperand(), /*OneUseOnly=*/true),
           Dummy)) {
     if (all_of(LI.users(), [&LI](User *U) {
           auto *SI = dyn_cast<StoreInst>(U);
           return SI && SI->getPointerOperand() != &LI &&

llvm/lib/Transforms/Instrumentation/PoisonChecking.cpp

if (isa<BinaryOperator>(I) && !I.getType()->isVectorTy())
     generatePoisonChecksForBinOp(I, Checks);
 
   // Handle non-binops seperately
   switch (I.getOpcode()) {
   default:
     break;
   case Instruction::ExtractElement: {
     Value *Vec = I.getOperand(0);
-    auto *VecVTy = cast<VectorType>(Vec->getType());
-    if (VecVTy->isScalable())
+    auto *VecVTy = dyn_cast<FixedVectorType>(Vec->getType());
+    if (!VecVTy)
       break;
     Value *Idx = I.getOperand(1);
     unsigned NumElts = VecVTy->getNumElements();
     Value *Check =
       B.CreateICmp(ICmpInst::ICMP_UGE, Idx,
                    ConstantInt::get(Idx->getType(), NumElts));
     Checks.push_back(Check);
     break;
   }
   case Instruction::InsertElement: {
     Value *Vec = I.getOperand(0);
-    auto *VecVTy = cast<VectorType>(Vec->getType());
-    if (VecVTy->isScalable())
+    auto *VecVTy = dyn_cast<FixedVectorType>(Vec->getType());
+    if (!VecVTy)
       break;
     Value *Idx = I.getOperand(2);
     unsigned NumElts = VecVTy->getNumElements();
     Value *Check =
       B.CreateICmp(ICmpInst::ICMP_UGE, Idx,
                    ConstantInt::get(Idx->getType(), NumElts));
     Checks.push_back(Check);
     break;

llvm/lib/Transforms/Scalar/SROA.cpp

bool SROA::runOnAlloca(AllocaInst &AI) {
   if (AI.use_empty()) {
     AI.eraseFromParent();
     return true;
   }
   const DataLayout &DL = AI.getModule()->getDataLayout();
 
   // Skip alloca forms that this analysis can't handle.
   auto *AT = AI.getAllocatedType();
-  if (AI.isArrayAllocation() || !AT->isSized() ||
-      (isa<VectorType>(AT) && cast<VectorType>(AT)->isScalable()) ||
+  if (AI.isArrayAllocation() || !AT->isSized() || isa<ScalableVectorType>(AT) ||
       DL.getTypeAllocSize(AT).getFixedSize() == 0)
     return false;
 
   bool Changed = false;
 
   // First, split any FCA loads and stores touching this alloca to promote
   // better splitting and promotion opportunities.
   AggLoadStoreRewriter AggRewriter(DL);
PreservedAnalyses SROA::runImpl(Function &F, DominatorTree &RunDT,
   C = &F.getContext();
   DT = &RunDT;
   AC = &RunAC;
 
   BasicBlock &EntryBB = F.getEntryBlock();
   for (BasicBlock::iterator I = EntryBB.begin(), E = std::prev(EntryBB.end());
        I != E; ++I) {
     if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) {
-      if (isa<VectorType>(AI->getAllocatedType()) &&
-          cast<VectorType>(AI->getAllocatedType())->isScalable()) {
+      if (isa<ScalableVectorType>(AI->getAllocatedType())) {
         if (isAllocaPromotable(AI))
           PromotableAllocas.push_back(AI);
       } else {
         Worklist.insert(AI);
       }
     }
   }