fixup! Address review comments

Author: mshockwave

llvm/lib/CodeGen/InterleavedAccessPass.cpp

@@ -630,23 +630,41 @@ getVectorDeinterleaveFactor(IntrinsicInst *II,
   return true;
 }
 
-// Return nullptr if the value corresponds to a all-true mask. Otherwise,
-// return the value that is corresponded to a deinterleaved mask.
-static Value *getMask(Value *WideMask, unsigned Factor) {
+// Return the corresponded deinterleaved mask, or nullptr if there is no valid
+// mask.
+static Value *getMask(Value *WideMask, unsigned Factor,
+                      VectorType *LeafValueTy) {
+  Value *MaskVal = nullptr;
+
   using namespace llvm::PatternMatch;
   if (auto *IMI = dyn_cast<IntrinsicInst>(WideMask)) {
     SmallVector<Value *, 8> Operands;
     SmallVector<Instruction *, 8> DeadInsts;
     if (getVectorInterleaveFactor(IMI, Operands, DeadInsts)) {
       assert(!Operands.empty());
       if (Operands.size() == Factor && llvm::all_equal(Operands))
-        return Operands[0];
+        MaskVal = Operands[0];
     }
   }
-  if (match(WideMask, m_AllOnes()))
-    return WideMask;
 
-  return nullptr;
+  if (match(WideMask, m_AllOnes())) {
+    // Scale the vector length.
+    ElementCount OrigEC =
+        cast<VectorType>(WideMask->getType())->getElementCount();
+    MaskVal =
+        ConstantVector::getSplat(OrigEC.divideCoefficientBy(Factor),
+                                 cast<Constant>(WideMask)->getSplatValue());
+  }
+
+  if (MaskVal) {
+    // Check if the vector length of mask matches that of the leaf values.
+    auto *MaskTy = cast<VectorType>(MaskVal->getType());
+    if (!MaskTy->getElementType()->isIntegerTy(/*Bitwidth=*/1) ||
+        MaskTy->getElementCount() != LeafValueTy->getElementCount())
+      return nullptr;
+  }
+
+  return MaskVal;
 }
 
 bool InterleavedAccessImpl::lowerDeinterleaveIntrinsic(
@@ -668,7 +686,8 @@ bool InterleavedAccessImpl::lowerDeinterleaveIntrinsic(
       return false;
     // Check mask operand. Handle both all-true and interleaved mask.
     Value *WideMask = VPLoad->getOperand(1);
-    Value *Mask = getMask(WideMask, Factor);
+    Value *Mask = getMask(WideMask, Factor,
+                          cast<VectorType>(DeinterleaveValues[0]->getType()));
     if (!Mask)
       return false;
 
@@ -720,7 +739,8 @@ bool InterleavedAccessImpl::lowerInterleaveIntrinsic(
       return false;
 
     Value *WideMask = VPStore->getOperand(2);
-    Value *Mask = getMask(WideMask, Factor);
+    Value *Mask = getMask(WideMask, Factor,
+                          cast<VectorType>(InterleaveValues[0]->getType()));
     if (!Mask)
       return false;
 

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

@@ -22,6 +22,7 @@
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/MemoryLocation.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
@@ -22529,6 +22530,22 @@ bool RISCVTargetLowering::lowerInterleaveIntrinsicToStore(
   return true;
 }
 
+static bool isMultipleOfN(const Value *V, const DataLayout &DL, unsigned N) {
+  assert(N);
+  if (N == 1)
+    return true;
+
+  if (isPowerOf2_32(N)) {
+    KnownBits KB = llvm::computeKnownBits(V, DL);
+    return KB.countMinTrailingZeros() >= Log2_32(N);
+  } else {
+    using namespace PatternMatch;
+    // Right now we're only recognizing the simplest pattern.
+    uint64_t C;
+    return match(V, m_c_Mul(m_Value(), m_ConstantInt(C))) && C && C % N == 0;
+  }
+}
+
 /// Lower an interleaved vp.load into a vlsegN intrinsic.
 ///
 /// E.g. Lower an interleaved vp.load (Factor = 2):
@@ -22586,6 +22603,9 @@ bool RISCVTargetLowering::lowerDeinterleavedIntrinsicToVPLoad(
 
   IRBuilder<> Builder(Load);
   Value *WideEVL = Load->getArgOperand(2);
+  if (!isMultipleOfN(WideEVL, Load->getDataLayout(), Factor))
+    return false;
+
   auto *XLenTy = Type::getIntNTy(Load->getContext(), Subtarget.getXLen());
   Value *EVL = Builder.CreateZExtOrTrunc(
       Builder.CreateUDiv(WideEVL, ConstantInt::get(WideEVL->getType(), Factor)),
@@ -22740,6 +22760,9 @@ bool RISCVTargetLowering::lowerInterleavedIntrinsicToVPStore(
 
   IRBuilder<> Builder(Store);
   Value *WideEVL = Store->getArgOperand(3);
+  if (!isMultipleOfN(WideEVL, Store->getDataLayout(), Factor))
+    return false;
+
   auto *XLenTy = Type::getIntNTy(Store->getContext(), Subtarget.getXLen());
   Value *EVL = Builder.CreateZExtOrTrunc(
       Builder.CreateUDiv(WideEVL, ConstantInt::get(WideEVL->getType(), Factor)),