[RISCV] Add helper function to share some of the code for isel of vector load/store intrinsics.

[craig.topper]

Summary

Many of the operands are handled the same or in the same order
for all these intrinsics. Factor out the code for selecting and
pushing them into the Operands vector.

[HsiangKai]

LGTM.

[frasercrmck]

LGTM other than that nit.

llvm/lib/Target/RISCV/RISCVISelDAGToDAG.cpp

255–256

nit: having this function placed after its "load" uses but before its "store" uses is a little odd, and I think it's making the diff a little harder to read.

llvm/lib/Target/RISCV/RISCVISelDAGToDAG.h

template <unsigned Width> bool selectRVVSimm5(SDValue N, SDValue &Imm) {
     return selectRVVSimm5(N, Width, Imm);
   }
 
   bool selectRVVUimm5(SDValue N, unsigned Width, SDValue &Imm);
   template <unsigned Width> bool selectRVVUimm5(SDValue N, SDValue &Imm) {
     return selectRVVUimm5(N, Width, Imm);
   }
 
+  void addVectorLoadStoreOperands(SDNode *Node, unsigned SEWImm,
+                                  const SDLoc &DL, unsigned CurOp,
+                                  bool IsMasked, bool IsStridedOrIndexed,
+                                  SmallVectorImpl<SDValue> &Operands,
+                                  MVT *IndexVT = nullptr);
+
   void selectVLSEG(SDNode *Node, bool IsMasked, bool IsStrided);
   void selectVLSEGFF(SDNode *Node, bool IsMasked);
   void selectVLXSEG(SDNode *Node, bool IsMasked, bool IsOrdered);
   void selectVSSEG(SDNode *Node, bool IsMasked, bool IsStrided);
   void selectVSXSEG(SDNode *Node, bool IsMasked, bool IsOrdered);
 
 // Include the pieces autogenerated from the target description.
 #include "RISCVGenDAGISel.inc"

llvm/lib/Target/RISCV/RISCVISelDAGToDAG.cpp

case RISCVVLMUL::LMUL_1:
     return createM1Tuple(CurDAG, Regs, NF);
   case RISCVVLMUL::LMUL_2:
     return createM2Tuple(CurDAG, Regs, NF);
   case RISCVVLMUL::LMUL_4:
     return createM4Tuple(CurDAG, Regs, NF);
   }
 }
 
-void RISCVDAGToDAGISel::selectVLSEG(SDNode *Node, bool IsMasked,
-                                    bool IsStrided) {
-  SDLoc DL(Node);
-  unsigned NF = Node->getNumValues() - 1;
-  MVT VT = Node->getSimpleValueType(0);
-  unsigned ScalarSize = VT.getScalarSizeInBits();
-  MVT XLenVT = Subtarget->getXLenVT();
-  RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
-  SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
-
+void RISCVDAGToDAGISel::addVectorLoadStoreOperands(
+    SDNode *Node, unsigned SEWImm, const SDLoc &DL, unsigned CurOp,
+    bool IsMasked, bool IsStridedOrIndexed, SmallVectorImpl<SDValue> &Operands,
+    MVT *IndexVT) {
   SDValue Chain = Node->getOperand(0);
   SDValue Glue;
 
-  unsigned CurOp = 2;
-  SmallVector<SDValue, 8> Operands;
-  if (IsMasked) {
-    SmallVector<SDValue, 8> Regs(Node->op_begin() + CurOp,
-                                 Node->op_begin() + CurOp + NF);
-    SDValue MaskedOff = createTuple(*CurDAG, Regs, NF, LMUL);
-    Operands.push_back(MaskedOff);
-    CurOp += NF;
-  }
   SDValue Base;
   SelectBaseAddr(Node->getOperand(CurOp++), Base);
   Operands.push_back(Base); // Base pointer.
-  if (IsStrided)
-    Operands.push_back(Node->getOperand(CurOp++)); // Stride.
+
+  if (IsStridedOrIndexed) {
+    Operands.push_back(Node->getOperand(CurOp++)); // Index.
+    if (IndexVT)
+      *IndexVT = Operands.back()->getSimpleValueType(0);
+  }
+
   if (IsMasked) {
     // Mask needs to be copied to V0.
     SDValue Mask = Node->getOperand(CurOp++);
     Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
     Glue = Chain.getValue(1);
     Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
   }
   SDValue VL;
   selectVLOp(Node->getOperand(CurOp++), VL);
   Operands.push_back(VL);
+
+  MVT XLenVT = Subtarget->getXLenVT();
+  SDValue SEW = CurDAG->getTargetConstant(SEWImm, DL, XLenVT);
   Operands.push_back(SEW);
+
   Operands.push_back(Chain); // Chain.
   if (Glue)
     Operands.push_back(Glue);
+}
+
+void RISCVDAGToDAGISel::selectVLSEG(SDNode *Node, bool IsMasked,
+                                    bool IsStrided) {
+  SDLoc DL(Node);
+  unsigned NF = Node->getNumValues() - 1;
+  MVT VT = Node->getSimpleValueType(0);
+  unsigned ScalarSize = VT.getScalarSizeInBits();
+  RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
+
+  unsigned CurOp = 2;
+  SmallVector<SDValue, 8> Operands;
+  if (IsMasked) {
+    SmallVector<SDValue, 8> Regs(Node->op_begin() + CurOp,
+                                 Node->op_begin() + CurOp + NF);
+    SDValue MaskedOff = createTuple(*CurDAG, Regs, NF, LMUL);
+    Operands.push_back(MaskedOff);
+    CurOp += NF;
+  }
+
+  addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked, IsStrided,
+                             Operands);
+
   const RISCV::VLSEGPseudo *P =
       RISCV::getVLSEGPseudo(NF, IsMasked, IsStrided, /*FF*/ false, ScalarSize,
                             static_cast<unsigned>(LMUL));
   MachineSDNode *Load =
       CurDAG->getMachineNode(P->Pseudo, DL, MVT::Untyped, MVT::Other, Operands);
 
   if (auto *MemOp = dyn_cast<MemSDNode>(Node))
     CurDAG->setNodeMemRefs(Load, {MemOp->getMemOperand()});

 
 void RISCVDAGToDAGISel::selectVLSEGFF(SDNode *Node, bool IsMasked) {
   SDLoc DL(Node);
   unsigned NF = Node->getNumValues() - 2; // Do not count VL and Chain.
   MVT VT = Node->getSimpleValueType(0);
   MVT XLenVT = Subtarget->getXLenVT();
   unsigned ScalarSize = VT.getScalarSizeInBits();
   RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
-  SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
-
-  SDValue Chain = Node->getOperand(0);
-  SDValue Glue;
 
   unsigned CurOp = 2;
   SmallVector<SDValue, 7> Operands;
   if (IsMasked) {
     SmallVector<SDValue, 8> Regs(Node->op_begin() + CurOp,
                                  Node->op_begin() + CurOp + NF);
     SDValue MaskedOff = createTuple(*CurDAG, Regs, NF, LMUL);
     Operands.push_back(MaskedOff);
     CurOp += NF;
   }
-  SDValue Base;
-  SelectBaseAddr(Node->getOperand(CurOp++), Base);
-  Operands.push_back(Base); // Base pointer.
-  if (IsMasked) {
-    // Mask needs to be copied to V0.
-    SDValue Mask = Node->getOperand(CurOp++);
-    Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-    Glue = Chain.getValue(1);
-    Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-  }
-  SDValue VL;
-  selectVLOp(Node->getOperand(CurOp++), VL);
-  Operands.push_back(VL);
-  Operands.push_back(SEW);
-  Operands.push_back(Chain); // Chain.
-  if (Glue)
-    Operands.push_back(Glue);
+
+  addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked,
+                             /*IsStridedOrIndexed*/ false, Operands);
+
   const RISCV::VLSEGPseudo *P =
       RISCV::getVLSEGPseudo(NF, IsMasked, /*Strided*/ false, /*FF*/ true,
                             ScalarSize, static_cast<unsigned>(LMUL));
   MachineSDNode *Load = CurDAG->getMachineNode(P->Pseudo, DL, MVT::Untyped,
                                                MVT::Other, MVT::Glue, Operands);
   SDNode *ReadVL = CurDAG->getMachineNode(RISCV::PseudoReadVL, DL, XLenVT,
                                           /*Glue*/ SDValue(Load, 2));
 

 }
 
 void RISCVDAGToDAGISel::selectVLXSEG(SDNode *Node, bool IsMasked,
                                      bool IsOrdered) {
   SDLoc DL(Node);
   unsigned NF = Node->getNumValues() - 1;
   MVT VT = Node->getSimpleValueType(0);
   unsigned ScalarSize = VT.getScalarSizeInBits();
-  MVT XLenVT = Subtarget->getXLenVT();
   RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
-  SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
-
-  SDValue Chain = Node->getOperand(0);
-  SDValue Glue;
 
   unsigned CurOp = 2;
   SmallVector<SDValue, 8> Operands;
   if (IsMasked) {
     SmallVector<SDValue, 8> Regs(Node->op_begin() + CurOp,
                                  Node->op_begin() + CurOp + NF);
     SDValue MaskedOff = createTuple(*CurDAG, Regs, NF, LMUL);
     Operands.push_back(MaskedOff);
     CurOp += NF;
   }
-  SDValue Base;
-  SelectBaseAddr(Node->getOperand(CurOp++), Base);
-  Operands.push_back(Base); // Base pointer.
-  Operands.push_back(Node->getOperand(CurOp++)); // Index.
-  MVT IndexVT = Operands.back()->getSimpleValueType(0);
-  if (IsMasked) {
-    // Mask needs to be copied to V0.
-    SDValue Mask = Node->getOperand(CurOp++);
-    Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-    Glue = Chain.getValue(1);
-    Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-  }
-  SDValue VL;
-  selectVLOp(Node->getOperand(CurOp++), VL);
-  Operands.push_back(VL);
-  Operands.push_back(SEW);
-  Operands.push_back(Chain); // Chain.
-  if (Glue)
-    Operands.push_back(Glue);
+
+  MVT IndexVT;
+  addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked,
+                             /*IsStridedOrIndexed*/ true, Operands, &IndexVT);
 
   assert(VT.getVectorElementCount() == IndexVT.getVectorElementCount() &&
          "Element count mismatch");
 
   RISCVVLMUL IndexLMUL = RISCVTargetLowering::getLMUL(IndexVT);
   unsigned IndexScalarSize = IndexVT.getScalarSizeInBits();
   const RISCV::VLXSEGPseudo *P = RISCV::getVLXSEGPseudo(
       NF, IsMasked, IsOrdered, IndexScalarSize, static_cast<unsigned>(LMUL),
void RISCVDAGToDAGISel::selectVSSEG(SDNode *Node, bool IsMasked,
   SDLoc DL(Node);
   unsigned NF = Node->getNumOperands() - 4;
   if (IsStrided)
     NF--;
   if (IsMasked)
     NF--;
   MVT VT = Node->getOperand(2)->getSimpleValueType(0);
   unsigned ScalarSize = VT.getScalarSizeInBits();
-  MVT XLenVT = Subtarget->getXLenVT();
   RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
-  SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
   SmallVector<SDValue, 8> Regs(Node->op_begin() + 2, Node->op_begin() + 2 + NF);
   SDValue StoreVal = createTuple(*CurDAG, Regs, NF, LMUL);
 
-  SDValue Chain = Node->getOperand(0);
-  SDValue Glue;
-
   SmallVector<SDValue, 8> Operands;
   Operands.push_back(StoreVal);
   unsigned CurOp = 2 + NF;
-  SDValue Base;
-  SelectBaseAddr(Node->getOperand(CurOp++), Base);
-  Operands.push_back(Base); // Base pointer.
-  if (IsStrided)
-    Operands.push_back(Node->getOperand(CurOp++)); // Stride.
-  if (IsMasked) {
-    // Mask needs to be copied to V0.
-    SDValue Mask = Node->getOperand(CurOp++);
-    Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-    Glue = Chain.getValue(1);
-    Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-  }
-  SDValue VL;
-  selectVLOp(Node->getOperand(CurOp++), VL);
-  Operands.push_back(VL);
-  Operands.push_back(SEW);
-  Operands.push_back(Chain); // Chain.
-  if (Glue)
-    Operands.push_back(Glue);
+
+  addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked, IsStrided,
+                             Operands);
+
   const RISCV::VSSEGPseudo *P = RISCV::getVSSEGPseudo(
       NF, IsMasked, IsStrided, ScalarSize, static_cast<unsigned>(LMUL));
   MachineSDNode *Store =
       CurDAG->getMachineNode(P->Pseudo, DL, Node->getValueType(0), Operands);
 
   if (auto *MemOp = dyn_cast<MemSDNode>(Node))
     CurDAG->setNodeMemRefs(Store, {MemOp->getMemOperand()});
 
   ReplaceNode(Node, Store);
 }
 
 void RISCVDAGToDAGISel::selectVSXSEG(SDNode *Node, bool IsMasked,
                                      bool IsOrdered) {
   SDLoc DL(Node);
   unsigned NF = Node->getNumOperands() - 5;
   if (IsMasked)
     --NF;
   MVT VT = Node->getOperand(2)->getSimpleValueType(0);
   unsigned ScalarSize = VT.getScalarSizeInBits();
-  MVT XLenVT = Subtarget->getXLenVT();
   RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
-  SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
   SmallVector<SDValue, 8> Regs(Node->op_begin() + 2, Node->op_begin() + 2 + NF);
   SDValue StoreVal = createTuple(*CurDAG, Regs, NF, LMUL);
 
-  SDValue Chain = Node->getOperand(0);
-  SDValue Glue;
-
   SmallVector<SDValue, 8> Operands;
   Operands.push_back(StoreVal);
   unsigned CurOp = 2 + NF;
-  SDValue Base;
-  SelectBaseAddr(Node->getOperand(CurOp++), Base);
-  Operands.push_back(Base); // Base pointer.
-  Operands.push_back(Node->getOperand(CurOp++)); // Index.
-  MVT IndexVT = Operands.back()->getSimpleValueType(0);
-  if (IsMasked) {
-    // Mask needs to be copied to V0.
-    SDValue Mask = Node->getOperand(CurOp++);
-    Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-    Glue = Chain.getValue(1);
-    Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-  }
-  SDValue VL;
-  selectVLOp(Node->getOperand(CurOp++), VL);
-  Operands.push_back(VL);
-  Operands.push_back(SEW);
-  Operands.push_back(Chain); // Chain.
-  if (Glue)
-    Operands.push_back(Glue);
+
+  MVT IndexVT;
+  addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked,
+                             /*IsStridedOrIndexed*/ true, Operands, &IndexVT);
 
   assert(VT.getVectorElementCount() == IndexVT.getVectorElementCount() &&
          "Element count mismatch");
 
   RISCVVLMUL IndexLMUL = RISCVTargetLowering::getLMUL(IndexVT);
   unsigned IndexScalarSize = IndexVT.getScalarSizeInBits();
   const RISCV::VSXSEGPseudo *P = RISCV::getVSXSEGPseudo(
       NF, IsMasked, IsOrdered, IndexScalarSize, static_cast<unsigned>(LMUL),
case ISD::INTRINSIC_W_CHAIN: {
     case Intrinsic::riscv_vluxei_mask: {
       bool IsMasked = IntNo == Intrinsic::riscv_vloxei_mask ||
                       IntNo == Intrinsic::riscv_vluxei_mask;
       bool IsOrdered = IntNo == Intrinsic::riscv_vloxei ||
                        IntNo == Intrinsic::riscv_vloxei_mask;
 
       MVT VT = Node->getSimpleValueType(0);
       unsigned ScalarSize = VT.getScalarSizeInBits();
-      MVT XLenVT = Subtarget->getXLenVT();
-      SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
-
-      SDValue Chain = Node->getOperand(0);
-      SDValue Glue;
 
       unsigned CurOp = 2;
       SmallVector<SDValue, 8> Operands;
       if (IsMasked)
         Operands.push_back(Node->getOperand(CurOp++));
-      SDValue Base;
-      SelectBaseAddr(Node->getOperand(CurOp++), Base);
-      Operands.push_back(Base); // Base pointer.
-      Operands.push_back(Node->getOperand(CurOp++)); // Index.
-      MVT IndexVT = Operands.back()->getSimpleValueType(0);
-      if (IsMasked) {
-        // Mask needs to be copied to V0.
-        SDValue Mask = Node->getOperand(CurOp++);
-        Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-        Glue = Chain.getValue(1);
-        Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-      }
-      SDValue VL;
-      selectVLOp(Node->getOperand(CurOp++), VL);
-      Operands.push_back(VL);
-      Operands.push_back(SEW);
-      Operands.push_back(Chain); // Chain.
-      if (Glue)
-        Operands.push_back(Glue);
+
+      MVT IndexVT;
+      addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked,
+                                 /*IsStridedOrIndexed*/ true, Operands,
+                                 &IndexVT);
 
       assert(VT.getVectorElementCount() == IndexVT.getVectorElementCount() &&
              "Element count mismatch");
 
       RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
       RISCVVLMUL IndexLMUL = RISCVTargetLowering::getLMUL(IndexVT);
       unsigned IndexScalarSize = IndexVT.getScalarSizeInBits();
       const RISCV::VLX_VSXPseudo *P = RISCV::getVLXPseudo(
case ISD::INTRINSIC_W_CHAIN: {
     case Intrinsic::riscv_vlse_mask: {
       bool IsMasked = IntNo == Intrinsic::riscv_vle_mask ||
                       IntNo == Intrinsic::riscv_vlse_mask;
       bool IsStrided =
           IntNo == Intrinsic::riscv_vlse || IntNo == Intrinsic::riscv_vlse_mask;
 
       MVT VT = Node->getSimpleValueType(0);
       unsigned ScalarSize = VT.getScalarSizeInBits();
-      MVT XLenVT = Subtarget->getXLenVT();
       // VLE1 uses an SEW of 8.
       unsigned SEWImm = (IntNo == Intrinsic::riscv_vle1) ? 8 : ScalarSize;
-      SDValue SEW = CurDAG->getTargetConstant(SEWImm, DL, XLenVT);
-
-      SDValue Chain = Node->getOperand(0);
-      SDValue Glue;
 
       unsigned CurOp = 2;
       SmallVector<SDValue, 8> Operands;
       if (IsMasked)
         Operands.push_back(Node->getOperand(CurOp++));
-      SDValue Base;
-      SelectBaseAddr(Node->getOperand(CurOp++), Base);
-      Operands.push_back(Base); // Base pointer.
-      if (IsStrided)
-        Operands.push_back(Node->getOperand(CurOp++)); // Stride.
-      if (IsMasked) {
-        // Mask needs to be copied to V0.
-        SDValue Mask = Node->getOperand(CurOp++);
-        Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-        Glue = Chain.getValue(1);
-        Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-      }
-      SDValue VL;
-      selectVLOp(Node->getOperand(CurOp++), VL);
-      Operands.push_back(VL);
-      Operands.push_back(SEW);
-      Operands.push_back(Chain); // Chain.
-      if (Glue)
-        Operands.push_back(Glue);
+
+      addVectorLoadStoreOperands(Node, SEWImm, DL, CurOp, IsMasked, IsStrided,
+                                 Operands);
 
       RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
       const RISCV::VLEPseudo *P =
           RISCV::getVLEPseudo(IsMasked, IsStrided, /*FF*/ false, ScalarSize,
                               static_cast<unsigned>(LMUL));
       MachineSDNode *Load =
           CurDAG->getMachineNode(P->Pseudo, DL, Node->getVTList(), Operands);
 
       if (auto *MemOp = dyn_cast<MemSDNode>(Node))
         CurDAG->setNodeMemRefs(Load, {MemOp->getMemOperand()});
 
       ReplaceNode(Node, Load);
       return;
     }
     case Intrinsic::riscv_vleff:
     case Intrinsic::riscv_vleff_mask: {
       bool IsMasked = IntNo == Intrinsic::riscv_vleff_mask;
 
       MVT VT = Node->getSimpleValueType(0);
       unsigned ScalarSize = VT.getScalarSizeInBits();
-      MVT XLenVT = Subtarget->getXLenVT();
-      SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
-
-      SDValue Chain = Node->getOperand(0);
-      SDValue Glue;
 
       unsigned CurOp = 2;
       SmallVector<SDValue, 7> Operands;
       if (IsMasked)
         Operands.push_back(Node->getOperand(CurOp++));
-      SDValue Base;
-      SelectBaseAddr(Node->getOperand(CurOp++), Base);
-      Operands.push_back(Base); // Base pointer.
-      if (IsMasked) {
-        // Mask needs to be copied to V0.
-        SDValue Mask = Node->getOperand(CurOp++);
-        Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-        Glue = Chain.getValue(1);
-        Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-      }
-      SDValue VL;
-      selectVLOp(Node->getOperand(CurOp++), VL);
-      Operands.push_back(VL);
-      Operands.push_back(SEW);
-      Operands.push_back(Chain); // Chain.
-      if (Glue)
-        Operands.push_back(Glue);
+
+      addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked,
+                                 /*IsStridedOrIndexed*/ false, Operands);
 
       RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
       const RISCV::VLEPseudo *P =
           RISCV::getVLEPseudo(IsMasked, /*Strided*/ false, /*FF*/ true,
                               ScalarSize, static_cast<unsigned>(LMUL));
       MachineSDNode *Load =
           CurDAG->getMachineNode(P->Pseudo, DL, Node->getValueType(0),
                                  MVT::Other, MVT::Glue, Operands);
case ISD::INTRINSIC_VOID: {
     case Intrinsic::riscv_vsuxei_mask: {
       bool IsMasked = IntNo == Intrinsic::riscv_vsoxei_mask ||
                       IntNo == Intrinsic::riscv_vsuxei_mask;
       bool IsOrdered = IntNo == Intrinsic::riscv_vsoxei ||
                        IntNo == Intrinsic::riscv_vsoxei_mask;
 
       MVT VT = Node->getOperand(2)->getSimpleValueType(0);
       unsigned ScalarSize = VT.getScalarSizeInBits();
-      MVT XLenVT = Subtarget->getXLenVT();
-      SDValue SEW = CurDAG->getTargetConstant(ScalarSize, DL, XLenVT);
-
-      SDValue Chain = Node->getOperand(0);
-      SDValue Glue;
 
       unsigned CurOp = 2;
       SmallVector<SDValue, 8> Operands;
       Operands.push_back(Node->getOperand(CurOp++)); // Store value.
-      SDValue Base;
-      SelectBaseAddr(Node->getOperand(CurOp++), Base);
-      Operands.push_back(Base); // Base pointer.
-      Operands.push_back(Node->getOperand(CurOp++)); // Index.
-      MVT IndexVT = Operands.back()->getSimpleValueType(0);
-      if (IsMasked) {
-        // Mask needs to be copied to V0.
-        SDValue Mask = Node->getOperand(CurOp++);
-        Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-        Glue = Chain.getValue(1);
-        Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-      }
-      SDValue VL;
-      selectVLOp(Node->getOperand(CurOp++), VL);
-      Operands.push_back(VL);
-      Operands.push_back(SEW);
-      Operands.push_back(Node->getOperand(0)); // Chain.
-      if (Glue)
-        Operands.push_back(Glue);
+
+      MVT IndexVT;
+      addVectorLoadStoreOperands(Node, ScalarSize, DL, CurOp, IsMasked,
+                                 /*IsStridedOrIndexed*/ true, Operands,
+                                 &IndexVT);
 
       assert(VT.getVectorElementCount() == IndexVT.getVectorElementCount() &&
              "Element count mismatch");
 
       RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
       RISCVVLMUL IndexLMUL = RISCVTargetLowering::getLMUL(IndexVT);
       unsigned IndexScalarSize = IndexVT.getScalarSizeInBits();
       const RISCV::VLX_VSXPseudo *P = RISCV::getVSXPseudo(
case ISD::INTRINSIC_VOID: {
     case Intrinsic::riscv_vsse_mask: {
       bool IsMasked = IntNo == Intrinsic::riscv_vse_mask ||
                       IntNo == Intrinsic::riscv_vsse_mask;
       bool IsStrided =
           IntNo == Intrinsic::riscv_vsse || IntNo == Intrinsic::riscv_vsse_mask;
 
       MVT VT = Node->getOperand(2)->getSimpleValueType(0);
       unsigned ScalarSize = VT.getScalarSizeInBits();
-      MVT XLenVT = Subtarget->getXLenVT();
       // VSE1 uses an SEW of 8.
       unsigned SEWImm = (IntNo == Intrinsic::riscv_vse1) ? 8 : ScalarSize;
-      SDValue SEW = CurDAG->getTargetConstant(SEWImm, DL, XLenVT);
-
-      SDValue Chain = Node->getOperand(0);
-      SDValue Glue;
 
       unsigned CurOp = 2;
       SmallVector<SDValue, 8> Operands;
       Operands.push_back(Node->getOperand(CurOp++)); // Store value.
-      SDValue Base;
-      SelectBaseAddr(Node->getOperand(CurOp++), Base);
-      Operands.push_back(Base); // Base pointer.
-      if (IsStrided)
-        Operands.push_back(Node->getOperand(CurOp++)); // Stride.
-      if (IsMasked) {
-        // Mask needs to be copied to V0.
-        SDValue Mask = Node->getOperand(CurOp++);
-        Chain = CurDAG->getCopyToReg(Chain, DL, RISCV::V0, Mask, SDValue());
-        Glue = Chain.getValue(1);
-        Operands.push_back(CurDAG->getRegister(RISCV::V0, Mask.getValueType()));
-      }
-      SDValue VL;
-      selectVLOp(Node->getOperand(CurOp++), VL);
-      Operands.push_back(VL);
-      Operands.push_back(SEW);
-      Operands.push_back(Node->getOperand(0)); // Chain.
-      if (Glue)
-        Operands.push_back(Glue);
+
+      addVectorLoadStoreOperands(Node, SEWImm, DL, CurOp, IsMasked, IsStrided,
+                                 Operands);
 
       RISCVVLMUL LMUL = RISCVTargetLowering::getLMUL(VT);
       const RISCV::VSEPseudo *P = RISCV::getVSEPseudo(
           IsMasked, IsStrided, ScalarSize, static_cast<unsigned>(LMUL));
       MachineSDNode *Store =
           CurDAG->getMachineNode(P->Pseudo, DL, Node->getVTList(), Operands);
-
       if (auto *MemOp = dyn_cast<MemSDNode>(Node))
         CurDAG->setNodeMemRefs(Store, {MemOp->getMemOperand()});
 
       ReplaceNode(Node, Store);
       return;
     }
     }
     break;