[SVE] Ignore scalable vectors in InterleavedLoadCombinePass

[david-arm]

Summary

I have changed the pass so that we ignore shuffle vectors with
scalable vector types, and replaced VectorType with FixedVectorType
in the rest of the pass. I couldn't think of an easy way to test
this change, since for scalable vectors we shouldn't be using
shufflevectors for interleaving. This change fixes up some
type size assert warnings I found in the following test:

CodeGen/AArch64/sve-intrinsics-int-arith-imm.ll

[ctetreau]

llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp

788–789

should just cast<>()

[ctetreau]

Looks good to me

llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp

public:
 
   /// Final shuffle-vector instruction
   ShuffleVectorInst *SVI;
 
   /// Information of the offset for each vector element
   ElementInfo *EI;
 
   /// Vector Type
-  VectorType *const VTy;
+  FixedVectorType *const VTy;
 
-  VectorInfo(VectorType *VTy)
+  VectorInfo(FixedVectorType *VTy)
       : BB(nullptr), PV(nullptr), LIs(), Is(), SVI(nullptr), VTy(VTy) {
     EI = new ElementInfo[VTy->getNumElements()];
   }
 
   virtual ~VectorInfo() { delete[] EI; }
 
   unsigned getDimension() const { return VTy->getNumElements(); }
 
public:
   /// \returns false if no sensible information can be gathered.
   static bool computeFromBCI(BitCastInst *BCI, VectorInfo &Result,
                              const DataLayout &DL) {
     Instruction *Op = dyn_cast<Instruction>(BCI->getOperand(0));
 
     if (!Op)
       return false;
 
-    VectorType *VTy = dyn_cast<VectorType>(Op->getType());
+    FixedVectorType *VTy = dyn_cast<FixedVectorType>(Op->getType());
     if (!VTy)
       return false;
 
     // We can only cast from large to smaller vectors
     if (Result.VTy->getNumElements() % VTy->getNumElements())
       return false;
 
     unsigned Factor = Result.VTy->getNumElements() / VTy->getNumElements();
public:
   /// Compute the left and the right side vector information and merge them by
   /// applying the shuffle operation. This function also ensures that the left
   /// and right side have compatible loads. This means that all loads are with
   /// in the same basic block and are based on the same pointer.
   ///
   /// \returns false if no sensible information can be gathered.
   static bool computeFromSVI(ShuffleVectorInst *SVI, VectorInfo &Result,
                              const DataLayout &DL) {
-    VectorType *ArgTy = dyn_cast<VectorType>(SVI->getOperand(0)->getType());
-    assert(ArgTy && "ShuffleVector Operand is not a VectorType");
+    FixedVectorType *ArgTy =
+        cast<FixedVectorType>(SVI->getOperand(0)->getType());
 
     // Compute the left hand vector information.
     VectorInfo LHS(ArgTy);
     if (!compute(SVI->getOperand(0), LHS, DL))
       LHS.BB = nullptr;
 
     // Compute the right hand vector information.
     VectorInfo RHS(ArgTy);
bool InterleavedLoadCombineImpl::combine(std::list<VectorInfo> &InterleavedLoad,
   }
 
   // All checks are done. Add instructions detectable by InterleavedAccessPass
   // The old instruction will are left dead.
   IRBuilder<> Builder(InsertionPoint);
   Type *ETy = InterleavedLoad.front().SVI->getType()->getElementType();
   unsigned ElementsPerSVI =
       InterleavedLoad.front().SVI->getType()->getNumElements();
-  VectorType *ILTy = VectorType::get(ETy, Factor * ElementsPerSVI);
+  FixedVectorType *ILTy = FixedVectorType::get(ETy, Factor * ElementsPerSVI);
 
   SmallVector<unsigned, 4> Indices;
   for (unsigned i = 0; i < Factor; i++)
     Indices.push_back(i);
   InterleavedCost = TTI.getInterleavedMemoryOpCost(
       Instruction::Load, ILTy, Factor, Indices, InsertionPoint->getAlignment(),
       InsertionPoint->getPointerAddressSpace());
 
bool InterleavedLoadCombineImpl::run() {
 
   // Start with the highest factor to avoid combining and recombining.
   for (unsigned Factor = MaxFactor; Factor >= 2; Factor--) {
     std::list<VectorInfo> Candidates;
 
     for (BasicBlock &BB : F) {
       for (Instruction &I : BB) {
         if (auto SVI = dyn_cast<ShuffleVectorInst>(&I)) {
+          // We don't support scalable vectors in this pass.
+          if (isa<ScalableVectorType>(SVI->getType()))
+            continue;
 
-          Candidates.emplace_back(SVI->getType());
+          Candidates.emplace_back(cast<FixedVectorType>(SVI->getType()));
 
           if (!VectorInfo::computeFromSVI(SVI, Candidates.back(), DL)) {
             Candidates.pop_back();
             continue;
           }
 
           if (!Candidates.back().isInterleaved(Factor, DL)) {
             Candidates.pop_back();