[RISCVGatherScatterLowering] Support broadcast base pointer

[reames]

Summary

A broadcast base pointer is the same as a scalar base pointer for GEP semantics (when there's at least one other vector operand). This is the form that SLP likes to emit, so we should handle it.

[craig.topper]

LGTM

llvm/lib/Target/RISCV/RISCVGatherScatterLowering.cpp

RISCVGatherScatterLowering::determineBaseAndStride(GetElementPtrInst *GEP,
 
   auto I = StridedAddrs.find(GEP);
   if (I != StridedAddrs.end())
     return I->second;
 
   SmallVector<Value *, 2> Ops(GEP->operands());
 
   // Base pointer needs to be a scalar.
-  if (Ops[0]->getType()->isVectorTy())
+  Value *ScalarBase = Ops[0];
+  if (ScalarBase->getType()->isVectorTy()) {
+    ScalarBase = getSplatValue(ScalarBase);
+    if (!ScalarBase)
       return std::make_pair(nullptr, nullptr);
+  }
 
   std::optional<unsigned> VecOperand;
   unsigned TypeScale = 0;
 
   // Look for a vector operand and scale.
   gep_type_iterator GTI = gep_type_begin(GEP);
   for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i, ++GTI) {
     if (!Ops[i]->getType()->isVectorTy())
RISCVGatherScatterLowering::determineBaseAndStride(GetElementPtrInst *GEP,
   if (Start) {
     assert(Stride);
     Builder.SetInsertPoint(GEP);
 
     // Replace the vector index with the scalar start and build a scalar GEP.
     Ops[*VecOperand] = Start;
     Type *SourceTy = GEP->getSourceElementType();
     Value *BasePtr =
-        Builder.CreateGEP(SourceTy, Ops[0], ArrayRef(Ops).drop_front());
+        Builder.CreateGEP(SourceTy, ScalarBase, ArrayRef(Ops).drop_front());
 
     // Convert stride to pointer size if needed.
     Type *IntPtrTy = DL->getIntPtrType(BasePtr->getType());
     assert(Stride->getType() == IntPtrTy && "Unexpected type");
 
     // Scale the stride by the size of the indexed type.
     if (TypeScale != 1)
       Stride = Builder.CreateMul(Stride, ConstantInt::get(IntPtrTy, TypeScale));
assert(BasePhi->getIncomingValue(IncrementingBlock) == Inc &&
          "Expected one operand of phi to be Inc");
 
   Builder.SetInsertPoint(GEP);
 
   // Replace the vector index with the scalar phi and build a scalar GEP.
   Ops[*VecOperand] = BasePhi;
   Type *SourceTy = GEP->getSourceElementType();
   Value *BasePtr =
-      Builder.CreateGEP(SourceTy, Ops[0], ArrayRef(Ops).drop_front());
+      Builder.CreateGEP(SourceTy, ScalarBase, ArrayRef(Ops).drop_front());
 
   // Final adjustments to stride should go in the start block.
   Builder.SetInsertPoint(
       BasePhi->getIncomingBlock(1 - IncrementingBlock)->getTerminator());
 
   // Convert stride to pointer size if needed.
   Type *IntPtrTy = DL->getIntPtrType(BasePtr->getType());
   assert(Stride->getType() == IntPtrTy && "Unexpected type");

llvm/test/CodeGen/RISCV/rvv/fixed-vectors-strided-load-store.ll

bb4:                                              ; preds = %bb4, %bb2
   %i13 = add nuw i64 %i5, 16
   %i14 = add <16 x i64> %i6, <i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16, i64 16>
   %i15 = icmp eq i64 %i13, %i
   br i1 %i15, label %bb16, label %bb4
 
 bb16:                                             ; preds = %bb4, %bb
   ret void
 }
+
+define <8 x i8> @broadcast_ptr_base(ptr %a) {
+; CHECK-LABEL: @broadcast_ptr_base(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = call <8 x i8> @llvm.riscv.masked.strided.load.v8i8.p0.i64(<8 x i8> poison, ptr [[A:%.*]], i64 64, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>)
+; CHECK-NEXT:    ret <8 x i8> [[TMP0]]
+;
+entry:
+  %0 = insertelement <8 x ptr> poison, ptr %a, i64 0
+  %1 = shufflevector <8 x ptr> %0, <8 x ptr> poison, <8 x i32> zeroinitializer
+  %2 = getelementptr i8, <8 x ptr> %1, <8 x i64> <i64 0, i64 64, i64 128, i64 192, i64 256, i64 320, i64 384, i64 448>
+  %3 = tail call <8 x i8> @llvm.masked.gather.v8i8.v8p0(<8 x ptr> %2, i32 1, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>, <8 x i8> poison)
+  ret <8 x i8> %3
+}
+
+declare <8 x i8> @llvm.masked.gather.v8i8.v8p0(<8 x ptr>, i32 immarg, <8 x i1>, <8 x i8>)