[RISCV] change rvv frame layout

[StephenFan]

Summary

This patch change the rvv frame layout that proposed in D94465. According to D94465, to eliminate the rvv frame index, create temp virtual register is needed. This virtual register should be scavenged by class RegsiterScavenger. If the machine function has other unused registers, there is no problem. But if there isn't unused registers, we need a emergency spill slot. Because of the emergency spill slot belongs to the scalar local variables field, to access emergency spill slot, we need a temp virtual register again. This makes the compiler report the "Incomplete scavenging after 2nd pass" error. So I change the rvv frame layout as follows:
if use sp or bp as base register:

|--------------------------------------|
|   arguments passed on the stack      |
|--------------------------------------|<--- fp
|   callee saved registers             |
|--------------------------------------|
|   rvv vector objects(local variables |
|   and outgoing arguments             |
|--------------------------------------|
|   realignment field                  |
|--------------------------------------|
|   scalar local variable(also contains|
|   emergency spill slot)              |
|--------------------------------------|<--- bp
|   variable-sized local variables     |
|--------------------------------------|<--- sp

if use fp as base register:

|--------------------------------------|
|   arguments passed on the stack      |
|--------------------------------------|<--- fp
|   callee saved registers             |
|--------------------------------------|
|   scalar local variable(also contains|
|   emergency spill slot)              |
|--------------------------------------|
|   rvv vector objects(local variables |
|   and outgoing arguments             |
|--------------------------------------|
|   variable-sized local variables     |
|--------------------------------------|<--- sp

[craig.topper]

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

652

This formatting looks weird.

665

Same here

[StephenFan]

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

652

Oh, Sorry, It was caused by clang-tidy, I will fix it right now,

[StephenFan]

address @criag.topper 's comment

[StephenFan]

add test cases that deleted incautious

[StephenFan]

In D97111#2576382, @StephenFan wrote:

address @criag.topper 's comment

Sorry, @craig.topper I typed your name wrong.

[rogfer01]

Hi @StephenFan. I wonder if we want to do this only when we index via sp.

My understanding is that the emergency slot will be close enough when we index via fp/bp in the previous layout. In the previous layout, when indexing a scalar via sp we have to cross the RVV part (which needs an extra register) to reach the scalar registers (where the emergency slot will be located). IIUC, your approach it fixes the sp case but complicates the fp/bp case to access the emergency slot because now we need to jump over RVV.

My suggestion means we want to have the RVV vectors as far from the frame pointer as possible (the one being used sp/fp/bp), so scalars are still straightforward to access even in the presence of RVV. This means different layouts when indexing with sp and when indexing with fp/bp. In summary: your new layout for sp but the previous one for fp/bp. Does this make sense?

[StephenFan]

In D97111#2576958, @rogfer01 wrote:

Hi @StephenFan. I wonder if we want to do this only when we index via sp.

My understanding is that the emergency slot will be close enough when we index via fp/bp in the previous layout. In the previous layout, when indexing a scalar via sp we have to cross the RVV part (which needs an extra register) to reach the scalar registers (where the emergency slot will be located). IIUC, your approach it fixes the sp case but complicates the fp/bp case to access the emergency slot because now we need to jump over RVV.

My suggestion means we want to have the RVV vectors as far from the frame pointer as possible (the one being used sp/fp/bp), so scalars are still straightforward to access even in the presence of RVV. This means different layouts when indexing with sp and when indexing with fp/bp. In summary: your new layout for sp but the previous one for fp/bp. Does this make sense?

Make sense to me. I didn't consider the case that needs fp to access the emergency spill slot. In my patch, It seems that make use of the bp register is necessary when variable-sized local variables and rvv stack objects exist at the same time. Because if uses fp to access the emergency spill slot needs an extra register. In the original patch, make use of the fp register is necessary when rvv stack objects exist. I prefer the current frame layout, Because it only needs a bp register when variable-sized local variables and rvv stack objects exist. Do you agree it?

[StephenFan]

In D97111#2577248, @StephenFan wrote:

In D97111#2576958, @rogfer01 wrote:

Hi @StephenFan. I wonder if we want to do this only when we index via sp.

My understanding is that the emergency slot will be close enough when we index via fp/bp in the previous layout. In the previous layout, when indexing a scalar via sp we have to cross the RVV part (which needs an extra register) to reach the scalar registers (where the emergency slot will be located). IIUC, your approach it fixes the sp case but complicates the fp/bp case to access the emergency slot because now we need to jump over RVV.

My suggestion means we want to have the RVV vectors as far from the frame pointer as possible (the one being used sp/fp/bp), so scalars are still straightforward to access even in the presence of RVV. This means different layouts when indexing with sp and when indexing with fp/bp. In summary: your new layout for sp but the previous one for fp/bp. Does this make sense?

Make sense to me. I didn't consider the case that needs fp to access the emergency spill slot. In my patch, It seems that make use of the bp register is necessary when variable-sized local variables and rvv stack objects exist at the same time. Because if uses fp to access the emergency spill slot needs an extra register. In the original patch, make use of the fp register is necessary when rvv stack objects exist. I prefer the current frame layout, Because it only needs a bp register when variable-sized local variables and rvv stack objects exist. Do you agree it?

Sorry, the last sentence is grammatically wrong. What I mean is " what about your opinion?"

[HsiangKai]

In D97111#2577248, @StephenFan wrote:

In D97111#2576958, @rogfer01 wrote:

Hi @StephenFan. I wonder if we want to do this only when we index via sp.

My understanding is that the emergency slot will be close enough when we index via fp/bp in the previous layout. In the previous layout, when indexing a scalar via sp we have to cross the RVV part (which needs an extra register) to reach the scalar registers (where the emergency slot will be located). IIUC, your approach it fixes the sp case but complicates the fp/bp case to access the emergency slot because now we need to jump over RVV.

My suggestion means we want to have the RVV vectors as far from the frame pointer as possible (the one being used sp/fp/bp), so scalars are still straightforward to access even in the presence of RVV. This means different layouts when indexing with sp and when indexing with fp/bp. In summary: your new layout for sp but the previous one for fp/bp. Does this make sense?

Make sense to me. I didn't consider the case that needs fp to access the emergency spill slot. In my patch, It seems that make use of the bp register is necessary when variable-sized local variables and rvv stack objects exist at the same time. Because if uses fp to access the emergency spill slot needs an extra register. In the original patch, make use of the fp register is necessary when rvv stack objects exist. I prefer the current frame layout, Because it only needs a bp register when variable-sized local variables and rvv stack objects exist. Do you agree it?

When it is necessary to have fp, the frame layout will look like as below.

|---------------------------------| <- frame pointer (fp)
| scalar callee-saved registers   |
|---------------------------------|
| scalar local variables          |
|---------------------------------|
| ///// realignment /////         |
|---------------------------------|
| scalar outgoing arguments       |
|---------------------------------|
| RVV local variables &&          |
| RVV outgoing arguments          |
|---------------------------------| <- end of frame (sp)

What do you mean "if uses fp to access the emergency spill slot needs an extra register"?

I agree with Roger. We only need to change the frame layout when accessing frame objects only using sp. That is, we should put RVV objects as far as 'base' as possible. The 'base' could be sp, fp or bp.

[StephenFan]

In D97111#2578131, @HsiangKai wrote:

In D97111#2577248, @StephenFan wrote:

In D97111#2576958, @rogfer01 wrote:

Hi @StephenFan. I wonder if we want to do this only when we index via sp.

My understanding is that the emergency slot will be close enough when we index via fp/bp in the previous layout. In the previous layout, when indexing a scalar via sp we have to cross the RVV part (which needs an extra register) to reach the scalar registers (where the emergency slot will be located). IIUC, your approach it fixes the sp case but complicates the fp/bp case to access the emergency slot because now we need to jump over RVV.

My suggestion means we want to have the RVV vectors as far from the frame pointer as possible (the one being used sp/fp/bp), so scalars are still straightforward to access even in the presence of RVV. This means different layouts when indexing with sp and when indexing with fp/bp. In summary: your new layout for sp but the previous one for fp/bp. Does this make sense?

Make sense to me. I didn't consider the case that needs fp to access the emergency spill slot. In my patch, It seems that make use of the bp register is necessary when variable-sized local variables and rvv stack objects exist at the same time. Because if uses fp to access the emergency spill slot needs an extra register. In the original patch, make use of the fp register is necessary when rvv stack objects exist. I prefer the current frame layout, Because it only needs a bp register when variable-sized local variables and rvv stack objects exist. Do you agree it?

When it is necessary to have fp, the frame layout will look like as below.

|---------------------------------| <- frame pointer (fp)
| scalar callee-saved registers   |
|---------------------------------|
| scalar local variables          |
|---------------------------------|
| ///// realignment /////         |
|---------------------------------|
| scalar outgoing arguments       |
|---------------------------------|
| RVV local variables &&          |
| RVV outgoing arguments          |
|---------------------------------| <- end of frame (sp)

What do you mean "if uses fp to access the emergency spill slot needs an extra register"?

I agree with Roger. We only need to change the frame layout when accessing frame objects only using sp. That is, we should put RVV objects as far as 'base' as possible. The 'base' could be sp, fp or bp.

What do you mean "if uses fp to access the emergency spill slot needs an extra register"?
Answer: In my patch, an extra register is needed when uses fp to access the emergency spill slot.

According to what @HsiangKai said, I realize that I misunderstood what @rogfer01 said before. Now, I also agree with @rogfer01 . And I will fix this patch.

[StephenFan]

address @HsiangKai and @rogfer01 's comments

[rogfer01]

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

652

In the drawing, can you put realignment between callee-saved registers and RVV objects?

Once we realign sp / bp as needed, we lay out the stack as if nothing happened, so the realignment if any, would act as padding below the RVV objects. As it stands now, it looks like the padding is between the scalars and the RVV objects, but this should not be the case given that the realignment is an unknown magnitude (hence the need to keep fp around)

I understand this means that MFI.getStackSize() does not account the realignment (it can't as it is unknown), perhaps we could state this somehow in the drawings? What do you think?

665

Ditto: realignment goes between callee-saved registers and RVV objects.

[jrtc27]

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

806–807

831

837

llvm/test/CodeGen/RISCV/rvv/allocate-lmul-2-4-8.ll

8–13

What's up with all the whitespace changes? Those should have been normalised.

[StephenFan]

Address @rogfer01 's comments.

[StephenFan]

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

652

I Agree with you.

[StephenFan]

Address @jrtc27 's comments

[StephenFan]

delete unnecessary white space

[rogfer01]

Can you add some tests for the cases with overaligned stuff and variable sized + rvv?

Something like this (feel free to improve if needed)

define void @rvv_vla(i64 %n, i64 %i) nounwind {
  %vla.addr = alloca i32, i64 %n

  %v1.addr = alloca <vscale x 1 x i64>
  %v1 = load volatile <vscale x 1 x i64>, <vscale x 1 x i64>* %v1.addr

  %v2.addr = alloca <vscale x 2 x i64>
  %v2 = load volatile <vscale x 2 x i64>, <vscale x 2 x i64>* %v2.addr

  %p = getelementptr i32, i32* %vla.addr, i64 %i
  %s = load volatile i32, i32* %p
  ret void
}

define void @rvv_overaligned(i64 %n, i64 %i) nounwind {
  %overaligned = alloca i32, align 64

  %v1.addr = alloca <vscale x 1 x i64>
  %v1 = load volatile <vscale x 1 x i64>, <vscale x 1 x i64>* %v1.addr

  %v2.addr = alloca <vscale x 2 x i64>
  %v2 = load volatile <vscale x 2 x i64>, <vscale x 2 x i64>* %v2.addr

  %s = load volatile i32, i32* %overaligned, align 64
  ret void
}

and a combined version of both.

[StephenFan]

Address @rogfer01 's comment. Add rvv-framelayout.ll test.

[StephenFan]

Delete white spaces.

[rogfer01]

Except for the minor comments above, LGTM.

llvm/test/CodeGen/RISCV/rvv/rvv-framelayout.ll

50 ↗

(On Diff #327752)

This test doesn't seem to be using %n or %i. My fault: I accidentally copy-pasted it in my earlier suggestion.

87 ↗

(On Diff #327752)

typo: rvv_val → rvv_vla

[StephenFan]

Address @rogfer01 's comment.

[StephenFan]

rebase

llvm/lib/Target/RISCV/RISCVFrameLowering.h

public:
   uint64_t getFirstSPAdjustAmount(const MachineFunction &MF) const;
 
   bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
   bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
 
   bool isSupportedStackID(TargetStackID::Value ID) const override;
   TargetStackID::Value getStackIDForScalableVectors() const override;
 
+  void processFunctionBeforeFrameIndicesReplaced(
+      MachineFunction &MF, RegScavenger *RS = nullptr) const override;
+
 protected:
   const RISCVSubtarget &STI;
 
 private:
   void determineFrameLayout(MachineFunction &MF) const;
   void adjustReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
                  const DebugLoc &DL, Register DestReg, Register SrcReg,
                  int64_t Val, MachineInstr::MIFlag Flag) const;
   void adjustStackForRVV(MachineFunction &MF, MachineBasicBlock &MBB,
                          MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
                          int64_t Amount) const;
   int64_t assignRVVStackObjectOffsets(MachineFrameInfo &MFI) const;
 };
 }
 #endif

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

if (!hasFP(MF)) {
       // Emit ".cfi_def_cfa_offset StackSize"
       unsigned CFIIndex = MF.addFrameInst(
           MCCFIInstruction::cfiDefCfaOffset(nullptr, MFI.getStackSize()));
       BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
           .addCFIIndex(CFIIndex);
     }
   }
 
+  if (RVVStackSize)
+    adjustStackForRVV(MF, MBB, MBBI, DL, -RVVStackSize);
+
   if (hasFP(MF)) {
     // Realign Stack
     const RISCVRegisterInfo *RI = STI.getRegisterInfo();
     if (RI->needsStackRealignment(MF)) {
       Align MaxAlignment = MFI.getMaxAlign();
 
       const RISCVInstrInfo *TII = STI.getInstrInfo();
       if (isInt<12>(-(int)MaxAlignment.value())) {
if (RI->needsStackRealignment(MF)) {
       // another base register BP to record SP after re-alignment. SP will
       // track the current stack after allocating variable sized objects.
       if (hasBP(MF)) {
         // move BP, SP
         TII->copyPhysReg(MBB, MBBI, DL, BPReg, SPReg, false);
       }
     }
   }
-
-  if (RVVStackSize)
-    adjustStackForRVV(MF, MBB, MBBI, DL, -RVVStackSize);
 }
 
 void RISCVFrameLowering::emitEpilogue(MachineFunction &MF,
                                       MachineBasicBlock &MBB) const {
   const RISCVRegisterInfo *RI = STI.getRegisterInfo();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
   Register FPReg = getFPReg(STI);
else
       Offset += StackOffset::getFixed(MFI.getStackSize());
   } else if (RI->needsStackRealignment(MF) && !MFI.isFixedObjectIndex(FI)) {
     // If the stack was realigned, the frame pointer is set in order to allow
     // SP to be restored, so we need another base register to record the stack
     // after realignment.
     if (hasBP(MF)) {
       FrameReg = RISCVABI::getBPReg();
       // |--------------------------| -- <-- FP
-      // | callee-saved registers   | |
-      // |--------------------------| | MFI.getStackSize()
-      // | scalar local variables   | |
-      // |--------------------------| --
-      // | Realignment              | |
+      // | callee-saved registers   | | <---------.
+      // |--------------------------| --          |
+      // | RVV objects              | |           |
+      // |--------------------------| --          |-- MFI.getStackSize()
+      // | realignment              | |           |
+      // |--------------------------| --          |
+      // | scalar local variables   | | <---------'
       // |--------------------------| -- <-- BP
-      // | RVV objects              | | RVFI->getRVVStackSize()
-      // |--------------------------| --
       // | VarSize objects          | |
       // |--------------------------| -- <-- SP
     } else {
       FrameReg = RISCV::X2;
-      // When using SP to access frame objects, we need to add RVV stack size.
-      //
       // |--------------------------| -- <-- FP
-      // | callee-saved registers   | |
-      // |--------------------------| | MFI.getStackSize()
-      // | scalar local variables   | |
-      // |--------------------------| --
-      // | Realignment              | |
-      // |--------------------------| --
-      // | RVV objects              | | RVFI->getRVVStackSize()
+      // | callee-saved registers   | | <---------.
+      // |--------------------------| --          |
+      // | RVV objects              | |           |
+      // |--------------------------| --          |-- MFI.getStackSize()
+      // | realignment              | |           |
+      // |--------------------------| --          |
+      // | scalar local variables   | | <---------'
       // |--------------------------| -- <-- SP
-      Offset += StackOffset::getScalable(RVFI->getRVVStackSize());
     }
     if (MFI.getStackID(FI) == TargetStackID::Default) {
       Offset += StackOffset::getFixed(MFI.getStackSize());
       if (FI < 0)
         Offset += StackOffset::getFixed(RVFI->getLibCallStackSize());
+    } else if (MFI.getStackID(FI) == TargetStackID::ScalableVector) {
+      Offset +=
+          StackOffset::get(MFI.getStackSize() - RVFI->getCalleeSavedStackSize(),
+                           RVFI->getRVVStackSize());
     }
   } else {
     FrameReg = RI->getFrameRegister(MF);
     if (hasFP(MF)) {
       Offset += StackOffset::getFixed(RVFI->getVarArgsSaveSize());
       if (FI >= 0)
         Offset -= StackOffset::getFixed(RVFI->getLibCallStackSize());
       // When using FP to access scalable vector objects, we need to minus
       // the frame size.
-      //
       // |--------------------------| -- <-- FP
-      // | callee-saved registers   | |
-      // |--------------------------| | MFI.getStackSize()
-      // | scalar local variables   | |
-      // |--------------------------| -- (Offset of RVV objects is from here.)
-      // | RVV objects              |
+      // | callee-saved registers   | |<--------.
+      // |--------------------------| --        |
+      // | RVV objects              | |         |-- MFI.getStackSize()
+      // |--------------------------| --        |
+      // | scalar local variables   | |<--------'
       // |--------------------------|
       // | VarSize objects          |
       // |--------------------------| <-- SP
       if (MFI.getStackID(FI) == TargetStackID::ScalableVector)
-        Offset -= StackOffset::getFixed(MFI.getStackSize());
+        Offset -= StackOffset::getFixed(RVFI->getCalleeSavedStackSize());
+      else if (MFI.getStackID(FI) == TargetStackID::Default)
+        Offset -= StackOffset::getScalable(RVFI->getRVVStackSize());
     } else {
       // When using SP to access frame objects, we need to add RVV stack size.
       //
       // |--------------------------| -- <-- FP
-      // | callee-saved registers   | |
-      // |--------------------------| | MFI.getStackSize()
-      // | scalar local variables   | |
-      // |--------------------------| --
-      // | RVV objects              | | RVFI->getRVVStackSize()
+      // | callee-saved registers   | |<--------.
+      // |--------------------------| --        |
+      // | RVV objects              | |         |-- MFI.getStackSize()
+      // |--------------------------| --        |
+      // | scalar local variables   | |<--------'
       // |--------------------------| -- <-- SP
-      Offset += StackOffset::getScalable(RVFI->getRVVStackSize());
       if (MFI.getStackID(FI) == TargetStackID::Default) {
         Offset += StackOffset::getFixed(MFI.getStackSize());
         if (FI < 0)
           Offset += StackOffset::getFixed(RVFI->getLibCallStackSize());
+      } else if (MFI.getStackID(FI) == TargetStackID::ScalableVector) {
+        Offset += StackOffset::get(MFI.getStackSize() -
+                                       RVFI->getCalleeSavedStackSize(),
+                                   RVFI->getRVVStackSize());
       }
     }
   }
 
   return Offset;
 }
 
 void RISCVFrameLowering::determineCalleeSaves(MachineFunction &MF,
RISCVFrameLowering::assignRVVStackObjectOffsets(MachineFrameInfo &MFI) const {
   return Offset;
 }
 
 void RISCVFrameLowering::processFunctionBeforeFrameFinalized(
     MachineFunction &MF, RegScavenger *RS) const {
   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const TargetRegisterClass *RC = &RISCV::GPRRegClass;
+
+  auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
+  int64_t RVVStackSize = assignRVVStackObjectOffsets(MFI);
+  RVFI->setRVVStackSize(RVVStackSize);
+
   // estimateStackSize has been observed to under-estimate the final stack
   // size, so give ourselves wiggle-room by checking for stack size
   // representable an 11-bit signed field rather than 12-bits.
   // FIXME: It may be possible to craft a function with a small stack that
   // still needs an emergency spill slot for branch relaxation. This case
   // would currently be missed.
-  if (!isInt<11>(MFI.estimateStackSize(MF))) {
+  if (!isInt<11>(MFI.estimateStackSize(MF)) || RVVStackSize != 0) {
     int RegScavFI = MFI.CreateStackObject(RegInfo->getSpillSize(*RC),
                                           RegInfo->getSpillAlign(*RC), false);
     RS->addScavengingFrameIndex(RegScavFI);
   }
+}
 
+void RISCVFrameLowering::processFunctionBeforeFrameIndicesReplaced(
+    MachineFunction &MF, RegScavenger *RS) const {
   auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
-  int64_t RVVStackSize = assignRVVStackObjectOffsets(MFI);
-  RVFI->setRVVStackSize(RVVStackSize);
+  const MachineFrameInfo &MFI = MF.getFrameInfo();
+  if (MFI.getCalleeSavedInfo().empty() || RVFI->useSaveRestoreLibCalls(MF)) {
+    RVFI->setCalleeSavedStackSize(0);
+    return;
+  }
+  int64_t MinOffset = std::numeric_limits<int64_t>::max();
+  int64_t MaxOffset = std::numeric_limits<int64_t>::min();
+  for (const auto &Info : MFI.getCalleeSavedInfo()) {
+    int FrameIdx = Info.getFrameIdx();
+    if (MFI.getStackID(FrameIdx) != TargetStackID::Default)
+      continue;
+    int64_t Offset = MFI.getObjectOffset(FrameIdx);
+    int64_t ObjSize = MFI.getObjectSize(FrameIdx);
+    MinOffset = std::min<int64_t>(Offset, MinOffset);
+    MaxOffset = std::max<int64_t>(Offset + ObjSize, MaxOffset);
+  }
+
+  unsigned Size = alignTo(MaxOffset - MinOffset, 16);
+  RVFI->setCalleeSavedStackSize(Size);
 }
 
 // Not preserve stack space within prologue for outgoing variables when the
 // function contains variable size objects and let eliminateCallFramePseudoInstr
 // preserve stack space for it.
 bool RISCVFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
   return !MF.getFrameInfo().hasVarSizedObjects();
 }

llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.h

private:
   int VarArgsSaveSize = 0;
   /// FrameIndex used for transferring values between 64-bit FPRs and a pair
   /// of 32-bit GPRs via the stack.
   int MoveF64FrameIndex = -1;
   /// Size of any opaque stack adjustment due to save/restore libcalls.
   unsigned LibCallStackSize = 0;
   /// Size of RVV stack.
   uint64_t RVVStackSize = 0;
+  /// Size of stack frame to save callee saved registers
+  unsigned CalleeSavedStackSize = 0;
 
 public:
   RISCVMachineFunctionInfo(const MachineFunction &MF) {}
 
   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
 
   unsigned getVarArgsSaveSize() const { return VarArgsSaveSize; }
bool useSaveRestoreLibCalls(const MachineFunction &MF) const {
     // We cannot use fixed locations for the callee saved spill slots if the
     // function uses a varargs save area.
     return MF.getSubtarget<RISCVSubtarget>().enableSaveRestore() &&
            VarArgsSaveSize == 0 && !MF.getFrameInfo().hasTailCall();
   }
 
   uint64_t getRVVStackSize() const { return RVVStackSize; }
   void setRVVStackSize(uint64_t Size) { RVVStackSize = Size; }
+
+  unsigned getCalleeSavedStackSize() const { return CalleeSavedStackSize; }
+  void setCalleeSavedStackSize(unsigned Size) { CalleeSavedStackSize = Size; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_RISCV_RISCVMACHINEFUNCTIONINFO_H

llvm/test/CodeGen/RISCV/rvv/access-fixed-objects-by-rvv.ll

 declare <vscale x 1 x i64> @llvm.riscv.vadd.nxv1i64.nxv1i64(
   <vscale x 1 x i64>,
   <vscale x 1 x i64>,
   i64);
 
 define <vscale x 1 x i64> @access_fixed_and_vector_objects(i64 *%val) {
 ; RV64IV-LABEL: access_fixed_and_vector_objects:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    addi sp, sp, -528
+; RV64IV-NEXT:    addi  sp, sp, -528
 ; RV64IV-NEXT:    .cfi_def_cfa_offset 528
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    addi a0, a0, 8
-; RV64IV-NEXT:    vl1re64.v v25, (a0)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    ld a0, 520(a0)
-; RV64IV-NEXT:    vl1re64.v v26, (sp)
-; RV64IV-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
-; RV64IV-NEXT:    vadd.vv v8, v25, v26
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    add sp, sp, a0
-; RV64IV-NEXT:    addi sp, sp, 528
+; RV64IV-NEXT:    csrr  a0, vlenb
+; RV64IV-NEXT:    sub sp, sp, a0
+; RV64IV-NEXT:    addi  a0, sp, 8
+; RV64IV-NEXT:    vl1re64.v v25, (a0)
+; RV64IV-NEXT:    ld  a0, 520(sp)
+; RV64IV-NEXT:    addi  a1, sp, 528
+; RV64IV-NEXT:    vl1re64.v v26, (a1)
+; RV64IV-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
+; RV64IV-NEXT:    vadd.vv v8, v25, v26
+; RV64IV-NEXT:    csrr  a0, vlenb
+; RV64IV-NEXT:    add sp, sp, a0
+; RV64IV-NEXT:    addi  sp, sp, 528
 ; RV64IV-NEXT:    ret
   %local = alloca i64
   %vector = alloca <vscale x 1 x i64>
   %array = alloca [64 x i64]
   %vptr = bitcast [64 x i64]* %array to <vscale x 1 x i64>*
   %v1 = load <vscale x 1 x i64>, <vscale x 1 x i64>* %vptr
   %v2 = load <vscale x 1 x i64>, <vscale x 1 x i64>* %vector
   %len = load i64, i64* %local
 
   %a = call <vscale x 1 x i64> @llvm.riscv.vadd.nxv1i64.nxv1i64(
     <vscale x 1 x i64> %v1,
     <vscale x 1 x i64> %v2,
     i64 %len)
 
   ret <vscale x 1 x i64> %a
 }

llvm/test/CodeGen/RISCV/rvv/allocate-lmul-2-4-8.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=riscv64 -mattr=+m,+experimental-v -verify-machineinstrs < %s \
 ; RUN:    | FileCheck %s
 
 define void @lmul1() nounwind {
 ; CHECK-LABEL: lmul1:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    add sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, 16
 ; CHECK-NEXT:    ret
   %v = alloca <vscale x 1 x i64>
   ret void
 }
 
 define void @lmul2() nounwind {
 ; CHECK-LABEL: lmul2:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    slli a0, a0, 1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    slli a0, a0, 1
-; CHECK-NEXT:    add sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, 16
 ; CHECK-NEXT:    ret
   %v = alloca <vscale x 2 x i64>
   ret void
 }
 
 define void @lmul4() nounwind {
 ; CHECK-LABEL: lmul4:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    slli a0, a0, 2
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %v = alloca <vscale x 4 x i64>
   ret void
 }
 
 define void @lmul8() nounwind {
 ; CHECK-LABEL: lmul8:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -64
-; CHECK-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 64
-; CHECK-NEXT:    andi sp, sp, -64
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    slli a0, a0, 3
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -64
-; CHECK-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 64
+; CHECK-NEXT:    addi sp, sp, -64
+; CHECK-NEXT:    sd ra, 56(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 48(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 64
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 3
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -64
+; CHECK-NEXT:    addi sp, s0, -64
+; CHECK-NEXT:    ld s0, 48(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 56(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 64
 ; CHECK-NEXT:    ret
   %v = alloca <vscale x 8 x i64>
   ret void
 }
 
 define void @lmul1_and_2() nounwind {
 ; CHECK-LABEL: lmul1_and_2:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 3
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 3
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    add sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 3
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 3
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, 16
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 1 x i64>
   %v2 = alloca <vscale x 2 x i64>
   ret void
 }
 
 define void @lmul2_and_4() nounwind {
 ; CHECK-LABEL: lmul2_and_4:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 6
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 6
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 2 x i64>
   %v2 = alloca <vscale x 4 x i64>
   ret void
 }
 
 define void @lmul1_and_4() nounwind {
 ; CHECK-LABEL: lmul1_and_4:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 5
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 5
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 1 x i64>
   %v2 = alloca <vscale x 4 x i64>
   ret void
 }
 
 define void @lmul2_and_1() nounwind {
 ; CHECK-LABEL: lmul2_and_1:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 3
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 3
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    add sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 3
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 3
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, 16
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 2 x i64>
   %v2 = alloca <vscale x 1 x i64>
   ret void
 }
 
 define void @lmul4_and_1() nounwind {
 ; CHECK-LABEL: lmul4_and_1:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 5
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 5
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 4 x i64>
   %v2 = alloca <vscale x 1 x i64>
   ret void
 }
 
 define void @lmul4_and_2() nounwind {
 ; CHECK-LABEL: lmul4_and_2:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 6
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 6
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 4 x i64>
   %v2 = alloca <vscale x 2 x i64>
   ret void
 }
 
 define void @lmul4_and_2_x2_0() nounwind {
 ; CHECK-LABEL: lmul4_and_2_x2_0:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 12
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 12
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 4 x i64>
   %v2 = alloca <vscale x 2 x i64>
   %v3 = alloca <vscale x 4 x i64>
   %v4 = alloca <vscale x 2 x i64>
   ret void
 }
 
 define void @lmul4_and_2_x2_1() nounwind {
 ; CHECK-LABEL: lmul4_and_2_x2_1:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 12
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 12
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 4 x i64>
   %v3 = alloca <vscale x 4 x i64>
   %v2 = alloca <vscale x 2 x i64>
   %v4 = alloca <vscale x 2 x i64>
   ret void
 }
 
 
 define void @gpr_and_lmul1_and_2() nounwind {
 ; CHECK-LABEL: gpr_and_lmul1_and_2:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -16
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 3
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi a0, zero, 3
-; CHECK-NEXT:    csrr a1, vlenb
-; CHECK-NEXT:    addi a2, zero, 3
-; CHECK-NEXT:    mul a1, a1, a2
-; CHECK-NEXT:    add a1, sp, a1
-; CHECK-NEXT:    sd a0, 8(a1)
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 3
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    add sp, sp, a0
-; CHECK-NEXT:    addi sp, sp, 16
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 3
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    addi a0, zero, 3
+; CHECK-NEXT:    sd a0, 8(sp)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 3
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, 16
 ; CHECK-NEXT:    ret
   %x1 = alloca i64
   %v1 = alloca <vscale x 1 x i64>
   %v2 = alloca <vscale x 2 x i64>
   store volatile i64 3, i64* %x1
   ret void
 }
 
 define void @gpr_and_lmul1_and_4() nounwind {
 ; CHECK-LABEL: gpr_and_lmul1_and_4:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -32
-; CHECK-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 32
-; CHECK-NEXT:    andi sp, sp, -32
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 5
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi a0, zero, 3
-; CHECK-NEXT:    csrr a1, vlenb
-; CHECK-NEXT:    addi a2, zero, 5
-; CHECK-NEXT:    mul a1, a1, a2
-; CHECK-NEXT:    add a1, sp, a1
-; CHECK-NEXT:    sd a0, 8(a1)
-; CHECK-NEXT:    addi sp, s0, -32
-; CHECK-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 5
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    addi a0, zero, 3
+; CHECK-NEXT:    sd a0, 8(sp)
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
 ; CHECK-NEXT:    ret
   %x1 = alloca i64
   %v1 = alloca <vscale x 1 x i64>
   %v2 = alloca <vscale x 4 x i64>
   store volatile i64 3, i64* %x1
   ret void
 }
 
 define void @lmul_1_2_4_8() nounwind {
 ; CHECK-LABEL: lmul_1_2_4_8:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -64
-; CHECK-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 64
-; CHECK-NEXT:    andi sp, sp, -64
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 15
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -64
-; CHECK-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 64
+; CHECK-NEXT:    addi sp, sp, -64
+; CHECK-NEXT:    sd ra, 56(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 48(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 64
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 15
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -64
+; CHECK-NEXT:    addi sp, s0, -64
+; CHECK-NEXT:    ld s0, 48(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 56(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 64
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 1 x i64>
   %v2 = alloca <vscale x 2 x i64>
   %v4 = alloca <vscale x 4 x i64>
   %v8 = alloca <vscale x 8 x i64>
   ret void
 }
 
 define void @lmul_1_2_4_8_x2_0() nounwind {
 ; CHECK-LABEL: lmul_1_2_4_8_x2_0:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -64
-; CHECK-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 64
-; CHECK-NEXT:    andi sp, sp, -64
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 30
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -64
-; CHECK-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 64
+; CHECK-NEXT:    addi sp, sp, -64
+; CHECK-NEXT:    sd ra, 56(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 48(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 64
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 30
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -64
+; CHECK-NEXT:    addi sp, s0, -64
+; CHECK-NEXT:    ld s0, 48(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 56(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 64
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 1 x i64>
   %v2 = alloca <vscale x 1 x i64>
   %v3 = alloca <vscale x 2 x i64>
   %v4 = alloca <vscale x 2 x i64>
   %v5 = alloca <vscale x 4 x i64>
   %v6 = alloca <vscale x 4 x i64>
   %v7 = alloca <vscale x 8 x i64>
   %v8 = alloca <vscale x 8 x i64>
   ret void
 }
 
 define void @lmul_1_2_4_8_x2_1() nounwind {
 ; CHECK-LABEL: lmul_1_2_4_8_x2_1:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -64
-; CHECK-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
-; CHECK-NEXT:    addi s0, sp, 64
-; CHECK-NEXT:    andi sp, sp, -64
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    addi a1, zero, 30
-; CHECK-NEXT:    mul a0, a0, a1
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    addi sp, s0, -64
-; CHECK-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
-; CHECK-NEXT:    addi sp, sp, 64
+; CHECK-NEXT:    addi sp, sp, -64
+; CHECK-NEXT:    sd ra, 56(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 48(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    addi s0, sp, 64
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    addi a1, zero, 30
+; CHECK-NEXT:    mul  a0, a0, a1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -64
+; CHECK-NEXT:    addi sp, s0, -64
+; CHECK-NEXT:    ld s0, 48(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 56(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 64
 ; CHECK-NEXT:    ret
   %v8 = alloca <vscale x 8 x i64>
   %v7 = alloca <vscale x 8 x i64>
   %v6 = alloca <vscale x 4 x i64>
   %v5 = alloca <vscale x 4 x i64>
   %v4 = alloca <vscale x 2 x i64>
   %v3 = alloca <vscale x 2 x i64>
   %v2 = alloca <vscale x 1 x i64>
   %v1 = alloca <vscale x 1 x i64>
   ret void
 }
 
 define void @masks() nounwind {
 ; CHECK-LABEL: masks:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    slli a0, a0, 2
-; CHECK-NEXT:    sub sp, sp, a0
-; CHECK-NEXT:    csrr a0, vlenb
-; CHECK-NEXT:    slli a0, a0, 2
-; CHECK-NEXT:    add sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, 16
 ; CHECK-NEXT:    ret
   %v1 = alloca <vscale x 1 x i1>
   %v2 = alloca <vscale x 2 x i1>
   %v4 = alloca <vscale x 4 x i1>
   %v8 = alloca <vscale x 8 x i1>
   ret void
 }

llvm/test/CodeGen/RISCV/rvv/localvar.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-v < %s \
 ; RUN:   | FileCheck %s -check-prefix=RV64IV
 
 define void @local_var_mf8() {
 ; RV64IV-LABEL: local_var_mf8:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    .cfi_def_cfa_offset 0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    vsetvli a0, zero, e8,mf8,ta,mu
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vle8.v v25, (a0)
-; RV64IV-NEXT:    vle8.v v25, (sp)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    add sp, sp, a0
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    .cfi_def_cfa_offset 0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    vsetvli  a0, zero, e8,mf8,ta,mu
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    add  a0, sp, a0
+; CHECK-NEXT:    vle8.v v25, (a0)
+; CHECK-NEXT:    vle8.v v25, (sp)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    ret
   %local0 = alloca <vscale x 1 x i8>
   %local1 = alloca <vscale x 1 x i8>
   load volatile <vscale x 1 x i8>, <vscale x 1 x i8>* %local0
   load volatile <vscale x 1 x i8>, <vscale x 1 x i8>* %local1
   ret void
 }
 
 define void @local_var_m1() {
 ; RV64IV-LABEL: local_var_m1:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    .cfi_def_cfa_offset 0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl1r.v v25, (a0)
-; RV64IV-NEXT:    vl1r.v v25, (sp)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    add sp, sp, a0
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    .cfi_def_cfa_offset 0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    add  a0, sp, a0
+; CHECK-NEXT:    vl1r.v v25, (a0)
+; CHECK-NEXT:    vl1r.v v25, (sp)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    ret
   %local0 = alloca <vscale x 8 x i8>
   %local1 = alloca <vscale x 8 x i8>
   load volatile <vscale x 8 x i8>, <vscale x 8 x i8>* %local0
   load volatile <vscale x 8 x i8>, <vscale x 8 x i8>* %local1
   ret void
 }
 
 define void @local_var_m2() {
 ; RV64IV-LABEL: local_var_m2:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    .cfi_def_cfa_offset 0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl2r.v v26, (a0)
-; RV64IV-NEXT:    vl2r.v v26, (sp)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    add sp, sp, a0
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    .cfi_def_cfa_offset 0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    add  a0, sp, a0
+; CHECK-NEXT:    vl2r.v v26, (a0)
+; CHECK-NEXT:    vl2r.v v26, (sp)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    ret
   %local0 = alloca <vscale x 16 x i8>
   %local1 = alloca <vscale x 16 x i8>
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %local0
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %local1
   ret void
 }
 
 define void @local_var_m4() {
 ; RV64IV-LABEL: local_var_m4:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    addi sp, sp, -32
-; RV64IV-NEXT:    .cfi_def_cfa_offset 32
-; RV64IV-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    .cfi_offset ra, -8
-; RV64IV-NEXT:    .cfi_offset s0, -16
-; RV64IV-NEXT:    addi s0, sp, 32
-; RV64IV-NEXT:    .cfi_def_cfa s0, 0
-; RV64IV-NEXT:    andi sp, sp, -32
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 3
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl4r.v v28, (a0)
-; RV64IV-NEXT:    vl4r.v v28, (sp)
-; RV64IV-NEXT:    addi sp, s0, -32
-; RV64IV-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    addi sp, sp, 32
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    addi sp, sp, -32
+; CHECK-NEXT:    .cfi_def_cfa_offset 32
+; CHECK-NEXT:    sd ra, 24(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 16(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    .cfi_offset ra, -8
+; CHECK-NEXT:    .cfi_offset s0, -16
+; CHECK-NEXT:    addi s0, sp, 32
+; CHECK-NEXT:    .cfi_def_cfa s0, 0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 3
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -32
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    add  a0, sp, a0
+; CHECK-NEXT:    addi a0, a0, 16
+; CHECK-NEXT:    vl4r.v v28, (a0)
+; CHECK-NEXT:    addi a0, sp, 16
+; CHECK-NEXT:    vl4r.v v28, (a0)
+; CHECK-NEXT:    addi sp, s0, -32
+; CHECK-NEXT:    ld s0, 16(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 24(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 32
+; CHECK-NEXT:    ret
   %local0 = alloca <vscale x 32 x i8>
   %local1 = alloca <vscale x 32 x i8>
   load volatile <vscale x 32 x i8>, <vscale x 32 x i8>* %local0
   load volatile <vscale x 32 x i8>, <vscale x 32 x i8>* %local1
   ret void
 }
 
 define void @local_var_m8() {
 ; RV64IV-LABEL: local_var_m8:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    addi sp, sp, -64
-; RV64IV-NEXT:    .cfi_def_cfa_offset 64
-; RV64IV-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    .cfi_offset ra, -8
-; RV64IV-NEXT:    .cfi_offset s0, -16
-; RV64IV-NEXT:    addi s0, sp, 64
-; RV64IV-NEXT:    .cfi_def_cfa s0, 0
-; RV64IV-NEXT:    andi sp, sp, -64
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 4
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 3
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl8r.v v8, (a0)
-; RV64IV-NEXT:    vl8r.v v8, (sp)
-; RV64IV-NEXT:    addi sp, s0, -64
-; RV64IV-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    addi sp, sp, 64
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    addi sp, sp, -64
+; CHECK-NEXT:    .cfi_def_cfa_offset 64
+; CHECK-NEXT:    sd ra, 56(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 48(sp)                      # 8-byte Folded Spill
+; CHECK-NEXT:    .cfi_offset ra, -8
+; CHECK-NEXT:    .cfi_offset s0, -16
+; CHECK-NEXT:    addi s0, sp, 64
+; CHECK-NEXT:    .cfi_def_cfa s0, 0
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 4
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    andi sp, sp, -64
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 3
+; CHECK-NEXT:    add  a0, sp, a0
+; CHECK-NEXT:    addi a0, a0, 48
+; CHECK-NEXT:    vl8r.v v8, (a0)
+; CHECK-NEXT:    addi a0, sp, 48
+; CHECK-NEXT:    vl8r.v v8, (a0)
+; CHECK-NEXT:    addi sp, s0, -64
+; CHECK-NEXT:    ld s0, 48(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 56(sp)                      # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 64
+; CHECK-NEXT:    ret
   %local0 = alloca <vscale x 64 x i8>
   %local1 = alloca <vscale x 64 x i8>
   load volatile <vscale x 64 x i8>, <vscale x 64 x i8>* %local0
   load volatile <vscale x 64 x i8>, <vscale x 64 x i8>* %local1
   ret void
 }
 
 define void @local_var_m2_mix_local_scalar() {
 ; RV64IV-LABEL: local_var_m2_mix_local_scalar:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    addi sp, sp, -16
-; RV64IV-NEXT:    .cfi_def_cfa_offset 16
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    lw a0, 12(a0)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl2r.v v26, (a0)
-; RV64IV-NEXT:    vl2r.v v26, (sp)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    lw a0, 8(a0)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    add sp, sp, a0
-; RV64IV-NEXT:    addi sp, sp, 16
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    sub  sp, sp, a0
+; CHECK-NEXT:    lw a0, 12(sp)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    add  a0, sp, a0
+; CHECK-NEXT:    addi a0, a0, 16
+; CHECK-NEXT:    vl2r.v v26, (a0)
+; CHECK-NEXT:    addi a0, sp, 16
+; CHECK-NEXT:    vl2r.v v26, (a0)
+; CHECK-NEXT:    lw a0, 8(sp)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    add  sp, sp, a0
+; CHECK-NEXT:    addi sp, sp, 16
+; CHECK-NEXT:    ret
   %local_scalar0 = alloca i32
   %local0 = alloca <vscale x 16 x i8>
   %local1 = alloca <vscale x 16 x i8>
   %local_scalar1 = alloca i32
   load volatile i32, i32* %local_scalar0
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %local0
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %local1
   load volatile i32, i32* %local_scalar1
   ret void
 }
 
 define void @local_var_m2_with_varsize_object(i64 %n) {
 ; RV64IV-LABEL: local_var_m2_with_varsize_object:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    addi sp, sp, -16
-; RV64IV-NEXT:    .cfi_def_cfa_offset 16
-; RV64IV-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    .cfi_offset ra, -8
-; RV64IV-NEXT:    .cfi_offset s0, -16
-; RV64IV-NEXT:    addi s0, sp, 16
-; RV64IV-NEXT:    .cfi_def_cfa s0, 0
-; RV64IV-NEXT:    csrr a1, vlenb
-; RV64IV-NEXT:    slli a1, a1, 2
-; RV64IV-NEXT:    sub sp, sp, a1
-; RV64IV-NEXT:    addi a0, a0, 15
-; RV64IV-NEXT:    andi a0, a0, -16
-; RV64IV-NEXT:    sub a0, sp, a0
-; RV64IV-NEXT:    mv sp, a0
-; RV64IV-NEXT:    csrr a1, vlenb
-; RV64IV-NEXT:    slli a1, a1, 1
-; RV64IV-NEXT:    sub a1, s0, a1
-; RV64IV-NEXT:    addi a1, a1, -16
-; RV64IV-NEXT:    call notdead@plt
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    sub a0, s0, a0
-; RV64IV-NEXT:    addi a0, a0, -16
-; RV64IV-NEXT:    vl2r.v v26, (a0)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    sub a0, s0, a0
-; RV64IV-NEXT:    addi a0, a0, -16
-; RV64IV-NEXT:    vl2r.v v26, (a0)
-; RV64IV-NEXT:    addi sp, s0, -16
-; RV64IV-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    addi sp, sp, 16
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    sd ra, 8(sp)                       # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 0(sp)                       # 8-byte Folded Spill
+; CHECK-NEXT:    .cfi_offset ra, -8
+; CHECK-NEXT:    .cfi_offset s0, -16
+; CHECK-NEXT:    addi s0, sp, 16
+; CHECK-NEXT:    .cfi_def_cfa s0, 0
+; CHECK-NEXT:    csrr a1, vlenb
+; CHECK-NEXT:    slli a1, a1, 2
+; CHECK-NEXT:    sub  sp, sp, a1
+; CHECK-NEXT:    addi a0, a0, 15
+; CHECK-NEXT:    andi a0, a0, -16
+; CHECK-NEXT:    sub  a0, sp, a0
+; CHECK-NEXT:    mv sp, a0
+; CHECK-NEXT:    csrr a1, vlenb
+; CHECK-NEXT:    slli a1, a1, 1
+; CHECK-NEXT:    sub  a1, s0, a1
+; CHECK-NEXT:    addi a1, a1, -16
+; CHECK-NEXT:    call notdead@plt
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    sub  a0, s0, a0
+; CHECK-NEXT:    addi a0, a0, -16
+; CHECK-NEXT:    vl2r.v v26, (a0)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 2
+; CHECK-NEXT:    sub  a0, s0, a0
+; CHECK-NEXT:    addi a0, a0, -16
+; CHECK-NEXT:    vl2r.v v26, (a0)
+; CHECK-NEXT:    addi sp, s0, -16
+; CHECK-NEXT:    ld s0, 0(sp)                       # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 8(sp)                       # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 16
+; CHECK-NEXT:    ret
   %1 = alloca i8, i64 %n
   %2 = alloca <vscale x 16 x i8>
   %3 = alloca <vscale x 16 x i8>
   call void @notdead(i8* %1, <vscale x 16 x i8>* %2)
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %2
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %3
   ret void
 }
 
 define void @local_var_m2_with_bp(i64 %n) {
 ; RV64IV-LABEL: local_var_m2_with_bp:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    addi sp, sp, -256
-; RV64IV-NEXT:    .cfi_def_cfa_offset 256
-; RV64IV-NEXT:    sd ra, 248(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    sd s0, 240(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    sd s1, 232(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    .cfi_offset ra, -8
-; RV64IV-NEXT:    .cfi_offset s0, -16
-; RV64IV-NEXT:    .cfi_offset s1, -24
-; RV64IV-NEXT:    addi s0, sp, 256
-; RV64IV-NEXT:    .cfi_def_cfa s0, 0
-; RV64IV-NEXT:    andi sp, sp, -128
-; RV64IV-NEXT:    mv s1, sp
-; RV64IV-NEXT:    csrr a1, vlenb
-; RV64IV-NEXT:    slli a1, a1, 2
-; RV64IV-NEXT:    sub sp, sp, a1
-; RV64IV-NEXT:    addi a0, a0, 15
-; RV64IV-NEXT:    andi a0, a0, -16
-; RV64IV-NEXT:    sub a0, sp, a0
-; RV64IV-NEXT:    mv sp, a0
-; RV64IV-NEXT:    addi a1, s1, 128
-; RV64IV-NEXT:    csrr a2, vlenb
-; RV64IV-NEXT:    slli a2, a2, 1
-; RV64IV-NEXT:    sub a2, s1, a2
-; RV64IV-NEXT:    mv a2, a2
-; RV64IV-NEXT:    call notdead2@plt
-; RV64IV-NEXT:    lw a0, 124(s1)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 1
-; RV64IV-NEXT:    sub a0, s1, a0
-; RV64IV-NEXT:    vl2r.v v26, (a0)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 2
-; RV64IV-NEXT:    sub a0, s1, a0
-; RV64IV-NEXT:    vl2r.v v26, (a0)
-; RV64IV-NEXT:    lw a0, 120(s1)
-; RV64IV-NEXT:    addi sp, s0, -256
-; RV64IV-NEXT:    ld s1, 232(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    ld s0, 240(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    ld ra, 248(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    addi sp, sp, 256
-; RV64IV-NEXT:    ret
+; CHECK-NEXT:    addi sp, sp, -256
+; CHECK-NEXT:    .cfi_def_cfa_offset 256
+; CHECK-NEXT:    sd ra, 248(sp)                     # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 240(sp)                     # 8-byte Folded Spill
+; CHECK-NEXT:    sd s1, 232(sp)                     # 8-byte Folded Spill
+; CHECK-NEXT:    .cfi_offset ra, -8
+; CHECK-NEXT:    .cfi_offset s0, -16
+; CHECK-NEXT:    .cfi_offset s1, -24
+; CHECK-NEXT:    addi s0, sp, 256
+; CHECK-NEXT:    .cfi_def_cfa s0, 0
+; CHECK-NEXT:    csrr a1, vlenb
+; CHECK-NEXT:    slli a1, a1, 2
+; CHECK-NEXT:    sub  sp, sp, a1
+; CHECK-NEXT:    andi sp, sp, -128
+; CHECK-NEXT:    mv s1, sp
+; CHECK-NEXT:    addi a0, a0, 15
+; CHECK-NEXT:    andi a0, a0, -16
+; CHECK-NEXT:    sub  a0, sp, a0
+; CHECK-NEXT:    mv sp, a0
+; CHECK-NEXT:    addi a1, s1, 128
+; CHECK-NEXT:    csrr a2, vlenb
+; CHECK-NEXT:    slli a2, a2, 1
+; CHECK-NEXT:    add  a2, s1, a2
+; CHECK-NEXT:    addi a2, a2, 224
+; CHECK-NEXT:    call notdead2@plt
+; CHECK-NEXT:    lw a0, 124(s1)
+; CHECK-NEXT:    csrr a0, vlenb
+; CHECK-NEXT:    slli a0, a0, 1
+; CHECK-NEXT:    add  a0, s1, a0
+; CHECK-NEXT:    addi a0, a0, 224
+; CHECK-NEXT:    vl2r.v v26, (a0)
+; CHECK-NEXT:    addi a0, s1, 224
+; CHECK-NEXT:    vl2r.v v26, (a0)
+; CHECK-NEXT:    lw a0, 120(s1)
+; CHECK-NEXT:    addi sp, s0, -256
+; CHECK-NEXT:    ld s1, 232(sp)                     # 8-byte Folded Reload
+; CHECK-NEXT:    ld s0, 240(sp)                     # 8-byte Folded Reload
+; CHECK-NEXT:    ld ra, 248(sp)                     # 8-byte Folded Reload
+; CHECK-NEXT:    addi sp, sp, 256
+; CHECK-NEXT:    ret
   %1 = alloca i8, i64 %n
   %2 = alloca i32, align 128
   %local_scalar0 = alloca i32
   %local0 = alloca <vscale x 16 x i8>
   %local1 = alloca <vscale x 16 x i8>
   %local_scalar1 = alloca i32
   call void @notdead2(i8* %1, i32* %2, <vscale x 16 x i8>* %local0)
   load volatile i32, i32* %local_scalar0
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %local0
   load volatile <vscale x 16 x i8>, <vscale x 16 x i8>* %local1
   load volatile i32, i32* %local_scalar1
   ret void
 }
 
 declare void @notdead(i8*, <vscale x 16 x i8>*)
 declare void @notdead2(i8*, i32*, <vscale x 16 x i8>*)

llvm/test/CodeGen/RISCV/rvv/memory-args.ll

%ret = call <vscale x 64 x i8> @llvm.riscv.vmacc.nxv64i8.nxv64i8(
                                   <vscale x 64 x i8> %arg1,
                                   <vscale x 64 x i8> %arg2, i64 1024)
   ret <vscale x 64 x i8> %ret
 }
 
 define <vscale x 64 x i8> @caller() {
 ; RV64IV-LABEL: caller:
 ; RV64IV:       # %bb.0:
-; RV64IV-NEXT:    addi sp, sp, -64
+; RV64IV-NEXT:    addi  sp, sp, -64
 ; RV64IV-NEXT:    .cfi_def_cfa_offset 64
-; RV64IV-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
-; RV64IV-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
+; RV64IV-NEXT:    sd  ra, 56(sp)                      # 8-byte Folded Spill
+; RV64IV-NEXT:    sd  s0, 48(sp)                      # 8-byte Folded Spill
 ; RV64IV-NEXT:    .cfi_offset ra, -8
 ; RV64IV-NEXT:    .cfi_offset s0, -16
-; RV64IV-NEXT:    addi s0, sp, 64
+; RV64IV-NEXT:    addi  s0, sp, 64
 ; RV64IV-NEXT:    .cfi_def_cfa s0, 0
-; RV64IV-NEXT:    andi sp, sp, -64
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 5
-; RV64IV-NEXT:    sub sp, sp, a0
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    addi a1, zero, 24
-; RV64IV-NEXT:    mul a0, a0, a1
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl8r.v v8, (a0)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 4
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl8r.v v16, (a0)
-; RV64IV-NEXT:    csrr a0, vlenb
-; RV64IV-NEXT:    slli a0, a0, 3
-; RV64IV-NEXT:    add a0, sp, a0
-; RV64IV-NEXT:    vl8r.v v24, (a0)
-; RV64IV-NEXT:    mv a0, sp
-; RV64IV-NEXT:    vs8r.v v24, (sp)
-; RV64IV-NEXT:    call callee@plt
-; RV64IV-NEXT:    addi sp, s0, -64
-; RV64IV-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
-; RV64IV-NEXT:    addi sp, sp, 64
+; RV64IV-NEXT:    csrr  a0, vlenb
+; RV64IV-NEXT:    slli  a0, a0, 5
+; RV64IV-NEXT:    sub sp, sp, a0
+; RV64IV-NEXT:    andi  sp, sp, -64
+; RV64IV-NEXT:    csrr  a0, vlenb
+; RV64IV-NEXT:    addi  a1, zero, 24
+; RV64IV-NEXT:    mul a0, a0, a1
+; RV64IV-NEXT:    add a0, sp, a0
+; RV64IV-NEXT:    addi  a0, a0, 48
+; RV64IV-NEXT:    vl8r.v  v8, (a0)
+; RV64IV-NEXT:    csrr  a0, vlenb
+; RV64IV-NEXT:    slli  a0, a0, 4
+; RV64IV-NEXT:    add a0, sp, a0
+; RV64IV-NEXT:    addi  a0, a0, 48
+; RV64IV-NEXT:    vl8r.v  v16, (a0)
+; RV64IV-NEXT:    csrr  a0, vlenb
+; RV64IV-NEXT:    slli  a0, a0, 3
+; RV64IV-NEXT:    add a0, sp, a0
+; RV64IV-NEXT:    addi  a0, a0, 48
+; RV64IV-NEXT:    vl8r.v  v24, (a0)
+; RV64IV-NEXT:    addi  a0, sp, 48
+; RV64IV-NEXT:    addi  a1, sp, 48
+; RV64IV-NEXT:    vs8r.v  v24, (a1)
+; RV64IV-NEXT:    call  callee@plt
+; RV64IV-NEXT:    addi  sp, s0, -64
+; RV64IV-NEXT:    ld  s0, 48(sp)                      # 8-byte Folded Reload
+; RV64IV-NEXT:    ld  ra, 56(sp)                      # 8-byte Folded Reload
+; RV64IV-NEXT:    addi  sp, sp, 64
 ; RV64IV-NEXT:    ret
   %local0 = alloca <vscale x 64 x i8>
   %local1 = alloca <vscale x 64 x i8>
   %local2 = alloca <vscale x 64 x i8>
   %arg0 = load volatile <vscale x 64 x i8>, <vscale x 64 x i8>* %local0
   %arg1 = load volatile <vscale x 64 x i8>, <vscale x 64 x i8>* %local1
   %arg2 = load volatile <vscale x 64 x i8>, <vscale x 64 x i8>* %local2
   %ret = call <vscale x 64 x i8> @callee(<vscale x 64 x i8> %arg0,
                                          <vscale x 64 x i8> %arg1,
                                          <vscale x 64 x i8> %arg2)
   ret <vscale x 64 x i8> %ret
 }

llvm/test/CodeGen/RISCV/rvv/rv32-spill-vector-csr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-v,+d -mattr=+d -O0 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O0 %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-v,+d -mattr=+d -O2 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O2 %s
 
 @.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 
 define <vscale x 1 x double> @foo(<vscale x 1 x double> %a, <vscale x 1 x double> %b, <vscale x 1 x double> %c, i32 %gvl) nounwind
 ; SPILL-O0-LABEL: foo:
 ; SPILL-O0:       # %bb.0:
-; SPILL-O0-NEXT:    addi sp, sp, -16
-; SPILL-O0-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    slli a1, a1, 1
-; SPILL-O0-NEXT:    sub sp, sp, a1
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    slli a1, a1, 1
-; SPILL-O0-NEXT:    add a1, sp, a1
-; SPILL-O0-NEXT:    sw a0, 8(a1) # 4-byte Folded Spill
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    add a1, sp, a1
-; SPILL-O0-NEXT:    vs1r.v v8, (a1) # Unknown-size Folded Spill
-; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
-; SPILL-O0-NEXT:    vfadd.vv v25, v8, v9
-; SPILL-O0-NEXT:    vs1r.v v25, (sp) # Unknown-size Folded Spill
-; SPILL-O0-NEXT:    lui a0, %hi(.L.str)
-; SPILL-O0-NEXT:    addi a0, a0, %lo(.L.str)
-; SPILL-O0-NEXT:    call puts@plt
-; SPILL-O0-NEXT:    vl1r.v v25, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    add a1, sp, a1
-; SPILL-O0-NEXT:    vl1r.v v8, (a1) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    # kill: def $x11 killed $x10
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    add a0, sp, a0
-; SPILL-O0-NEXT:    lw a0, 8(a0) # 4-byte Folded Reload
-; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
-; SPILL-O0-NEXT:    vfadd.vv v8, v8, v25
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    add sp, sp, a0
-; SPILL-O0-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
-; SPILL-O0-NEXT:    addi sp, sp, 16
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    sw  ra, 12(sp)                      # 4-byte Folded Spill
+; SPILL-O0-NEXT:    csrr  a1, vlenb
+; SPILL-O0-NEXT:    slli  a1, a1, 1
+; SPILL-O0-NEXT:    sub sp, sp, a1
+; SPILL-O0-NEXT:    sw  a0, 8(sp)                       # 4-byte Folded Spill
+; SPILL-O0-NEXT:    csrr  a1, vlenb
+; SPILL-O0-NEXT:    add a1, sp, a1
+; SPILL-O0-NEXT:    vs1r.v  v8, (a1)                        # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
+; SPILL-O0-NEXT:    vfadd.vv  v25, v8, v9
+; SPILL-O0-NEXT:    vs1r.v  v25, (sp)                       # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    lui a0, %hi(.L.str)
+; SPILL-O0-NEXT:    addi  a0, a0, %lo(.L.str)
+; SPILL-O0-NEXT:    call  puts@plt
+; SPILL-O0-NEXT:    vl1r.v  v25, (sp)                       # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a1, vlenb
+; SPILL-O0-NEXT:    add a1, sp, a1
+; SPILL-O0-NEXT:    vl1r.v  v8, (a1)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:                                            # kill: def $x11 killed $x10
+; SPILL-O0-NEXT:    lw  a0, 8(sp)                       # 4-byte Folded Reload
+; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
+; SPILL-O0-NEXT:    vfadd.vv  v8, v8, v25
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 1
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    lw  ra, 12(sp)                      # 4-byte Folded Reload
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: foo:
 ; SPILL-O2:       # %bb.0:
-; SPILL-O2-NEXT:    addi sp, sp, -16
-; SPILL-O2-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
-; SPILL-O2-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
-; SPILL-O2-NEXT:    csrr a1, vlenb
-; SPILL-O2-NEXT:    slli a1, a1, 1
-; SPILL-O2-NEXT:    sub sp, sp, a1
-; SPILL-O2-NEXT:    mv s0, a0
-; SPILL-O2-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
-; SPILL-O2-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
-; SPILL-O2-NEXT:    vfadd.vv v25, v8, v9
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    add a0, sp, a0
-; SPILL-O2-NEXT:    vs1r.v v25, (a0) # Unknown-size Folded Spill
-; SPILL-O2-NEXT:    lui a0, %hi(.L.str)
-; SPILL-O2-NEXT:    addi a0, a0, %lo(.L.str)
-; SPILL-O2-NEXT:    call puts@plt
-; SPILL-O2-NEXT:    vsetvli a0, s0, e64,m1,ta,mu
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    add a0, sp, a0
-; SPILL-O2-NEXT:    vl1r.v v25, (a0) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    vl1r.v v26, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    vfadd.vv v8, v26, v25
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 1
-; SPILL-O2-NEXT:    add sp, sp, a0
-; SPILL-O2-NEXT:    lw s0, 8(sp) # 4-byte Folded Reload
-; SPILL-O2-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
-; SPILL-O2-NEXT:    addi sp, sp, 16
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    sw  ra, 12(sp)                      # 4-byte Folded Spill
+; SPILL-O2-NEXT:    sw  s0, 8(sp)                       # 4-byte Folded Spill
+; SPILL-O2-NEXT:    csrr  a1, vlenb
+; SPILL-O2-NEXT:    slli  a1, a1, 1
+; SPILL-O2-NEXT:    sub sp, sp, a1
+; SPILL-O2-NEXT:    mv  s0, a0
+; SPILL-O2-NEXT:    vs1r.v  v8, (sp)                        # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
+; SPILL-O2-NEXT:    vfadd.vv  v25, v8, v9
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    add a0, sp, a0
+; SPILL-O2-NEXT:    vs1r.v  v25, (a0)                       # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    lui a0, %hi(.L.str)
+; SPILL-O2-NEXT:    addi  a0, a0, %lo(.L.str)
+; SPILL-O2-NEXT:    call  puts@plt
+; SPILL-O2-NEXT:    vsetvli a0, s0, e64,m1,ta,mu
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    add a0, sp, a0
+; SPILL-O2-NEXT:    vl1r.v  v25, (a0)                       # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    vl1r.v  v26, (sp)                       # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    vfadd.vv  v8, v26, v25
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 1
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    lw  s0, 8(sp)                       # 4-byte Folded Reload
+; SPILL-O2-NEXT:    lw  ra, 12(sp)                      # 4-byte Folded Reload
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 {
    %x = call <vscale x 1 x double> @llvm.riscv.vfadd.nxv1f64.nxv1f64(<vscale x 1 x double> %a, <vscale x 1 x double> %b, i32 %gvl)
    %call = call signext i32 @puts(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
    %z = call <vscale x 1 x double> @llvm.riscv.vfadd.nxv1f64.nxv1f64(<vscale x 1 x double> %a, <vscale x 1 x double> %x, i32 %gvl)
    ret <vscale x 1 x double> %z
 }
 
 declare <vscale x 1 x double> @llvm.riscv.vfadd.nxv1f64.nxv1f64(<vscale x 1 x double> %a, <vscale x 1 x double> %b, i32 %gvl)
 declare i32 @puts(i8*);

llvm/test/CodeGen/RISCV/rvv/rv32-spill-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-v -O0 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O0 %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-v -O2 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O2 %s
 
 define <vscale x 1 x i32> @spill_lmul_mf2(<vscale x 1 x i32> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_mf2:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs1r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl1r.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl1r.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_mf2:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs1r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl1r.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl1r.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 1 x i32> %va
 }
 
 define <vscale x 2 x i32> @spill_lmul_1(<vscale x 2 x i32> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_1:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs1r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl1r.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl1r.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_1:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs1r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl1r.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl1r.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 2 x i32> %va
 }
 
 define <vscale x 4 x i32> @spill_lmul_2(<vscale x 4 x i32> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_2:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs2r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 1
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs2r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl2re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl2re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 1
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_2:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 1
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs2r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 1
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs2r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl2re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 1
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl2re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 1
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 4 x i32> %va
 }
 
 define <vscale x 8 x i32> @spill_lmul_4(<vscale x 8 x i32> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_4:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 2
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs4r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 2
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs4r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl4re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 2
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl4re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 2
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_4:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 2
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs4r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 2
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs4r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl4re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 2
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl4re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 2
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 8 x i32> %va
 }
 
 define <vscale x 16 x i32> @spill_lmul_8(<vscale x 16 x i32> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_8:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 3
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs8r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 3
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs8r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl8re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 3
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl8re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 3
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_8:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 3
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs8r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 3
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs8r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl8re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 3
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl8re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 3
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 16 x i32> %va
 }

llvm/test/CodeGen/RISCV/rvv/rv64-spill-vector-csr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-v,+d -mattr=+d -O0 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O0 %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-v,+d -mattr=+d -O2 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O2 %s
 
 @.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 
 define <vscale x 1 x double> @foo(<vscale x 1 x double> %a, <vscale x 1 x double> %b, <vscale x 1 x double> %c, i64 %gvl) nounwind
 ; SPILL-O0-LABEL: foo:
 ; SPILL-O0:       # %bb.0:
-; SPILL-O0-NEXT:    addi sp, sp, -16
-; SPILL-O0-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    slli a1, a1, 1
-; SPILL-O0-NEXT:    sub sp, sp, a1
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    slli a1, a1, 1
-; SPILL-O0-NEXT:    add a1, sp, a1
-; SPILL-O0-NEXT:    sd a0, 0(a1) # 8-byte Folded Spill
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    add a1, sp, a1
-; SPILL-O0-NEXT:    vs1r.v v8, (a1) # Unknown-size Folded Spill
-; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
-; SPILL-O0-NEXT:    vfadd.vv v25, v8, v9
-; SPILL-O0-NEXT:    vs1r.v v25, (sp) # Unknown-size Folded Spill
-; SPILL-O0-NEXT:    lui a0, %hi(.L.str)
-; SPILL-O0-NEXT:    addi a0, a0, %lo(.L.str)
-; SPILL-O0-NEXT:    call puts@plt
-; SPILL-O0-NEXT:    vl1r.v v25, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a1, vlenb
-; SPILL-O0-NEXT:    add a1, sp, a1
-; SPILL-O0-NEXT:    vl1r.v v8, (a1) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    # kill: def $x11 killed $x10
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    add a0, sp, a0
-; SPILL-O0-NEXT:    ld a0, 0(a0) # 8-byte Folded Reload
-; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
-; SPILL-O0-NEXT:    vfadd.vv v8, v8, v25
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    add sp, sp, a0
-; SPILL-O0-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
-; SPILL-O0-NEXT:    addi sp, sp, 16
+; SPILL-O0-NEXT:    addi  sp, sp, -32
+; SPILL-O0-NEXT:    sd  ra, 24(sp)                      # 8-byte Folded Spill
+; SPILL-O0-NEXT:    csrr  a1, vlenb
+; SPILL-O0-NEXT:    slli  a1, a1, 1
+; SPILL-O0-NEXT:    sub sp, sp, a1
+; SPILL-O0-NEXT:    sd  a0, 16(sp)                      # 8-byte Folded Spill
+; SPILL-O0-NEXT:    csrr  a1, vlenb
+; SPILL-O0-NEXT:    add a1, sp, a1
+; SPILL-O0-NEXT:    addi  a1, a1, 16
+; SPILL-O0-NEXT:    vs1r.v  v8, (a1)                        # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
+; SPILL-O0-NEXT:    vfadd.vv  v25, v8, v9
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs1r.v  v25, (a0)                       # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    lui a0, %hi(.L.str)
+; SPILL-O0-NEXT:    addi  a0, a0, %lo(.L.str)
+; SPILL-O0-NEXT:    call  puts@plt
+; SPILL-O0-NEXT:    addi  a1, sp, 16
+; SPILL-O0-NEXT:    vl1r.v  v25, (a1)                       # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a1, vlenb
+; SPILL-O0-NEXT:    add a1, sp, a1
+; SPILL-O0-NEXT:    addi  a1, a1, 16
+; SPILL-O0-NEXT:    vl1r.v  v8, (a1)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:                                            # kill: def $x11 killed $x10
+; SPILL-O0-NEXT:    ld  a0, 16(sp)                      # 8-byte Folded Reload
+; SPILL-O0-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
+; SPILL-O0-NEXT:    vfadd.vv  v8, v8, v25
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 1
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    ld  ra, 24(sp)                      # 8-byte Folded Reload
+; SPILL-O0-NEXT:    addi  sp, sp, 32
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: foo:
 ; SPILL-O2:       # %bb.0:
-; SPILL-O2-NEXT:    addi sp, sp, -16
-; SPILL-O2-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
-; SPILL-O2-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
-; SPILL-O2-NEXT:    csrr a1, vlenb
-; SPILL-O2-NEXT:    slli a1, a1, 1
-; SPILL-O2-NEXT:    sub sp, sp, a1
-; SPILL-O2-NEXT:    mv s0, a0
-; SPILL-O2-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
-; SPILL-O2-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
-; SPILL-O2-NEXT:    vfadd.vv v25, v8, v9
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    add a0, sp, a0
-; SPILL-O2-NEXT:    vs1r.v v25, (a0) # Unknown-size Folded Spill
-; SPILL-O2-NEXT:    lui a0, %hi(.L.str)
-; SPILL-O2-NEXT:    addi a0, a0, %lo(.L.str)
-; SPILL-O2-NEXT:    call puts@plt
-; SPILL-O2-NEXT:    vsetvli a0, s0, e64,m1,ta,mu
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    add a0, sp, a0
-; SPILL-O2-NEXT:    vl1r.v v25, (a0) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    vl1r.v v26, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    vfadd.vv v8, v26, v25
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 1
-; SPILL-O2-NEXT:    add sp, sp, a0
-; SPILL-O2-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
-; SPILL-O2-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
-; SPILL-O2-NEXT:    addi sp, sp, 16
+; SPILL-O2-NEXT:    addi  sp, sp, -32
+; SPILL-O2-NEXT:    sd  ra, 24(sp)                      # 8-byte Folded Spill
+; SPILL-O2-NEXT:    sd  s0, 16(sp)                      # 8-byte Folded Spill
+; SPILL-O2-NEXT:    csrr  a1, vlenb
+; SPILL-O2-NEXT:    slli  a1, a1, 1
+; SPILL-O2-NEXT:    sub sp, sp, a1
+; SPILL-O2-NEXT:    mv  s0, a0
+; SPILL-O2-NEXT:    addi  a1, sp, 16
+; SPILL-O2-NEXT:    vs1r.v  v8, (a1)                        # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    vsetvli a0, a0, e64,m1,ta,mu
+; SPILL-O2-NEXT:    vfadd.vv  v25, v8, v9
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    add a0, sp, a0
+; SPILL-O2-NEXT:    addi  a0, a0, 16
+; SPILL-O2-NEXT:    vs1r.v  v25, (a0)                       # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    lui a0, %hi(.L.str)
+; SPILL-O2-NEXT:    addi  a0, a0, %lo(.L.str)
+; SPILL-O2-NEXT:    call  puts@plt
+; SPILL-O2-NEXT:    vsetvli a0, s0, e64,m1,ta,mu
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    add a0, sp, a0
+; SPILL-O2-NEXT:    addi  a0, a0, 16
+; SPILL-O2-NEXT:    vl1r.v  v25, (a0)                       # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl1r.v  v26, (a0)                       # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    vfadd.vv  v8, v26, v25
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 1
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    ld  s0, 16(sp)                      # 8-byte Folded Reload
+; SPILL-O2-NEXT:    ld  ra, 24(sp)                      # 8-byte Folded Reload
+; SPILL-O2-NEXT:    addi  sp, sp, 32
 ; SPILL-O2-NEXT:    ret
 {
    %x = call <vscale x 1 x double> @llvm.riscv.vfadd.nxv1f64.nxv1f64(<vscale x 1 x double> %a, <vscale x 1 x double> %b, i64 %gvl)
    %call = call signext i32 @puts(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
    %z = call <vscale x 1 x double> @llvm.riscv.vfadd.nxv1f64.nxv1f64(<vscale x 1 x double> %a, <vscale x 1 x double> %x, i64 %gvl)
    ret <vscale x 1 x double> %z
 }
 
 declare <vscale x 1 x double> @llvm.riscv.vfadd.nxv1f64.nxv1f64(<vscale x 1 x double> %a, <vscale x 1 x double> %b, i64 %gvl)
 declare i32 @puts(i8*);

llvm/test/CodeGen/RISCV/rvv/rv64-spill-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-v -O0 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O0 %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-v -O2 < %s \
 ; RUN:    | FileCheck --check-prefix=SPILL-O2 %s
 
 define <vscale x 1 x i64> @spill_lmul_1(<vscale x 1 x i64> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_1:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs1r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl1r.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl1r.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_1:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs1r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs1r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl1r.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl1r.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 1 x i64> %va
 }
 
 define <vscale x 2 x i64> @spill_lmul_2(<vscale x 2 x i64> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_2:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs2r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 1
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs2r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl2re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 1
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl2re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 1
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_2:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 1
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs2r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 1
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs2r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl2re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 1
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl2re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 1
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 2 x i64> %va
 }
 
 define <vscale x 4 x i64> @spill_lmul_4(<vscale x 4 x i64> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_4:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 2
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs4r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 2
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs4r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl4re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 2
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl4re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 2
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_4:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 2
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs4r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 2
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs4r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl4re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 2
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl4re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 2
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 4 x i64> %va
 }
 
 define <vscale x 8 x i64> @spill_lmul_8(<vscale x 8 x i64> %va) nounwind {
 ; SPILL-O0-LABEL: spill_lmul_8:
 ; SPILL-O0:       # %bb.0: # %entry
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 3
-; SPILL-O0-NEXT:    sub sp, sp, a0
-; SPILL-O0-NEXT:    vs8r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O0-NEXT:    addi  sp, sp, -16
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 3
+; SPILL-O0-NEXT:    sub sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vs8r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O0-NEXT:    #APP
 ; SPILL-O0-NEXT:    #NO_APP
-; SPILL-O0-NEXT:    vl8re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O0-NEXT:    csrr a0, vlenb
-; SPILL-O0-NEXT:    slli a0, a0, 3
-; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  a0, sp, 16
+; SPILL-O0-NEXT:    vl8re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O0-NEXT:    csrr  a0, vlenb
+; SPILL-O0-NEXT:    slli  a0, a0, 3
+; SPILL-O0-NEXT:    add sp, sp, a0
+; SPILL-O0-NEXT:    addi  sp, sp, 16
 ; SPILL-O0-NEXT:    ret
 ;
 ; SPILL-O2-LABEL: spill_lmul_8:
 ; SPILL-O2:       # %bb.0: # %entry
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 3
-; SPILL-O2-NEXT:    sub sp, sp, a0
-; SPILL-O2-NEXT:    vs8r.v v8, (sp) # Unknown-size Folded Spill
+; SPILL-O2-NEXT:    addi  sp, sp, -16
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 3
+; SPILL-O2-NEXT:    sub sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vs8r.v  v8, (a0)                        # Unknown-size Folded Spill
 ; SPILL-O2-NEXT:    #APP
 ; SPILL-O2-NEXT:    #NO_APP
-; SPILL-O2-NEXT:    vl8re8.v v8, (sp) # Unknown-size Folded Reload
-; SPILL-O2-NEXT:    csrr a0, vlenb
-; SPILL-O2-NEXT:    slli a0, a0, 3
-; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  a0, sp, 16
+; SPILL-O2-NEXT:    vl8re8.v  v8, (a0)                        # Unknown-size Folded Reload
+; SPILL-O2-NEXT:    csrr  a0, vlenb
+; SPILL-O2-NEXT:    slli  a0, a0, 3
+; SPILL-O2-NEXT:    add sp, sp, a0
+; SPILL-O2-NEXT:    addi  sp, sp, 16
 ; SPILL-O2-NEXT:    ret
 entry:
   call void asm sideeffect "",
   "~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
 
   ret <vscale x 8 x i64> %va
 }

llvm/test/CodeGen/RISCV/saverestore.ll

 ;
 ; RV64I-FP-SR-LABEL: callee_saved0:
 ; RV64I-FP-SR:         call t0, __riscv_save_5
 ; RV64I-FP-SR:         tail __riscv_restore_5
   %val = load [18 x i32], [18 x i32]* @var0
   store volatile [18 x i32] %val, [18 x i32]* @var0
   ret void
 }
-
-define void @callee_saved1() nounwind {
-; RV32I-LABEL: callee_saved1:
-; RV32I-NOT:     call t0, __riscv_save
-; RV32I-NOT:     tail __riscv_restore
-;
-; RV64I-LABEL: callee_saved1:
-; RV64I-NOT:     call t0, __riscv_save
-; RV64I-NOT:     tail __riscv_restore
-;
-; RV32I-SR-LABEL: callee_saved1:
-; RV32I-SR:         call t0, __riscv_save_11
-; RV32I-SR:         tail __riscv_restore_11
-;
-; RV64I-SR-LABEL: callee_saved1:
-; RV64I-SR:         call t0, __riscv_save_11
-; RV64I-SR:         tail __riscv_restore_11
-;
-; RV32I-FP-SR-LABEL: callee_saved1:
-; RV32I-FP-SR:         call t0, __riscv_save_11
-; RV32I-FP-SR:         tail __riscv_restore_11
-;
-; RV64I-FP-SR-LABEL: callee_saved1:
-; RV64I-FP-SR:         call t0, __riscv_save_11
-; RV64I-FP-SR:         tail __riscv_restore_11
-  %val = load [24 x i32], [24 x i32]* @var1
-  store volatile [24 x i32] %val, [24 x i32]* @var1
-  ret void
-}
-
-define void @callee_saved2() nounwind {
-; RV32I-LABEL: callee_saved2:
-; RV32I-NOT:     call t0, __riscv_save
-; RV32I-NOT:     tail __riscv_restore
-;
-; RV64I-LABEL: callee_saved2:
-; RV64I-NOT:     call t0, __riscv_save
-; RV64I-NOT:     tail __riscv_restore
-;
-; RV32I-SR-LABEL: callee_saved2:
-; RV32I-SR:         call t0, __riscv_save_12
-; RV32I-SR:         tail __riscv_restore_12
-;
-; RV64I-SR-LABEL: callee_saved2:
-; RV64I-SR:         call t0, __riscv_save_12
-; RV64I-SR:         tail __riscv_restore_12
-;
-; RV32I-FP-SR-LABEL: callee_saved2:
-; RV32I-FP-SR:         call t0, __riscv_save_12
-; RV32I-FP-SR:         tail __riscv_restore_12
-;
-; RV64I-FP-SR-LABEL: callee_saved2:
-; RV64I-FP-SR:         call t0, __riscv_save_12
-; RV64I-FP-SR:         tail __riscv_restore_12
-  %val = load [30 x i32], [30 x i32]* @var2
-  store volatile [30 x i32] %val, [30 x i32]* @var2
-  ret void
-}
-
-; Check that floating point callee saved registers are still manually saved and
-; restored.
-
-define void @callee_saved_fp() nounwind {
-; RV32I-LABEL: callee_saved_fp:
-; RV32I-NOT:     call t0, __riscv_save
-; RV32I-NOT:     tail __riscv_restore
-;
-; RV64I-LABEL: callee_saved_fp:
-; RV64I-NOT:     call t0, __riscv_save
-; RV64I-NOT:     tail __riscv_restore
-;
-; RV32I-SR-LABEL: callee_saved_fp:
-; RV32I-SR:         call t0, __riscv_save_7
-; RV32I-SR:         tail __riscv_restore_7
-;
-; RV64I-SR-LABEL: callee_saved_fp:
-; RV64I-SR:         call t0, __riscv_save_7
-; RV64I-SR:         tail __riscv_restore_7
-;
-; RV32I-FP-SR-LABEL: callee_saved_fp:
-; RV32I-FP-SR:         call t0, __riscv_save_7
-; RV32I-FP-SR-NEXT:    addi sp, sp, -16
-; RV32I-FP-SR-NEXT:    fsw fs0, 12(sp)
-; RV32I-FP-SR:         flw fs0, 12(sp)
-; RV32I-FP-SR-NEXT:    addi sp, sp, 16
-; RV32I-FP-SR-NEXT:    tail __riscv_restore_7
-;
-; RV64I-FP-SR-LABEL: callee_saved_fp:
-; RV64I-FP-SR:         call t0, __riscv_save_7
-; RV64I-FP-SR-NEXT:    addi sp, sp, -16
-; RV64I-FP-SR-NEXT:    fsd fs0, 8(sp)
-; RV64I-FP-SR:         fld fs0, 8(sp)
-; RV64I-FP-SR-NEXT:    addi sp, sp, 16
-; RV64I-FP-SR-NEXT:    tail __riscv_restore_7
-  call void asm sideeffect "", "~{f8},~{x9},~{x18},~{x19},~{x20},~{x21},~{x22}"()
-  ret void
-}
-
-; Check that preserving tail calls is preferred over save/restore
-
-declare i32 @tail_callee(i32 %i)
-
-define i32 @tail_call(i32 %i) nounwind {
-; RV32I-LABEL: tail_call:
-; RV32I-NOT:     call t0, __riscv_save
-; RV32I:         tail tail_callee
-; RV32I-NOT:     tail __riscv_restore
-;
-; RV64I-LABEL: tail_call:
-; RV64I-NOT:     call t0, __riscv_save
-; RV64I:         tail tail_callee
-; RV64I-NOT:     tail __riscv_restore
-;
-; RV32I-SR-LABEL: tail_call:
-; RV32I-SR-NOT:     call t0, __riscv_save
-; RV32I-SR:         tail tail_callee
-; RV32I-SR-NOT:     tail __riscv_restore
-;
-; RV64I-SR-LABEL: tail_call:
-; RV64I-SR-NOT:     call t0, __riscv_save
-; RV64I-SR:         tail tail_callee
-; RV64I-SR-NOT:     tail __riscv_restore
-;
-; RV32I-FP-SR-LABEL: tail_call:
-; RV32I-FP-SR-NOT:     call t0, __riscv_save
-; RV32I-FP-SR:         tail tail_callee
-; RV32I-FP-SR-NOT:     tail __riscv_restore
-;
-; RV64I-FP-SR-LABEL: tail_call:
-; RV64I-FP-SR-NOT:     call t0, __riscv_save
-; RV64I-FP-SR:         tail tail_callee
-; RV64I-FP-SR-NOT:     tail __riscv_restore
-entry:
-  %val = load [18 x i32], [18 x i32]* @var0
-  store volatile [18 x i32] %val, [18 x i32]* @var0
-  %r = tail call i32 @tail_callee(i32 %i)
-  ret i32 %r
-}
-
-; Check that functions with varargs do not use save/restore code
-
-declare void @llvm.va_start(i8*)
-declare void @llvm.va_end(i8*)
-
-define i32 @varargs(i8* %fmt, ...) nounwind {
-; RV32I-LABEL: varargs:
-; RV32I-NOT:     call t0, __riscv_save
-; RV32I-NOT:     tail __riscv_restore
-;
-; RV64I-LABEL: varargs:
-; RV64I-NOT:     call t0, __riscv_save
-; RV64I-NOT:     tail __riscv_restore
-;
-; RV32I-SR-LABEL: varargs:
-; RV32I-SR-NOT:     call t0, __riscv_save
-; RV32I-SR-NOT:     tail __riscv_restore
-;
-; RV64I-SR-LABEL: varargs:
-; RV64I-SR-NOT:     call t0, __riscv_save
-; RV64I-SR-NOT:     tail __riscv_restore
-;
-; RV32I-FP-SR-LABEL: varargs:
-; RV32I-FP-SR-NOT:     call t0, __riscv_save
-; RV32I-FP-SR-NOT:     tail __riscv_restore
-;
-; RV64I-FP-SR-LABEL: varargs:
-; RV64I-FP-SR-NOT:     call t0, __riscv_save
-; RV64I-FP-SR-NOT:     tail __riscv_restore
-  %va = alloca i8*, align 4
-  %1 = bitcast i8** %va to i8*
-  call void @llvm.va_start(i8* %1)
-  %argp.cur = load i8*, i8** %va, align 4
-  %argp.next = getelementptr inbounds i8, i8* %argp.cur, i32 4
-  store i8* %argp.next, i8** %va, align 4
-  %2 = bitcast i8* %argp.cur to i32*
-  %3 = load i32, i32* %2, align 4
-  call void @llvm.va_end(i8* %1)
-  ret i32 %3
-}
-
-define void @many_args(i32, i32, i32, i32, i32, i32, i32, i32, i32) nounwind {
-; RV32I-LABEL: many_args:
-; RV32I-NOT:     call t0, __riscv_save
-; RV32I-NOT:     tail __riscv_restore
-;
-; RV64I-LABEL: many_args:
-; RV64I-NOT:     call t0, __riscv_save
-; RV64I-NOT:     tail __riscv_restore
-;
-; RV32I-SR-LABEL: many_args:
-; RV32I-SR:         call t0, __riscv_save_5
-; RV32I-SR:         tail __riscv_restore_5
-;
-; RV64I-SR-LABEL: many_args:
-; RV64I-SR:         call t0, __riscv_save_5
-; RV64I-SR:         tail __riscv_restore_5
-;
-; RV32I-FP-SR-LABEL: many_args:
-; RV32I-FP-SR:         call t0, __riscv_save_5
-; RV32I-FP-SR:         tail __riscv_restore_5
-;
-; RV64I-FP-SR-LABEL: many_args:
-; RV64I-FP-SR:         call t0, __riscv_save_5
-; RV64I-FP-SR:         tail __riscv_restore_5
-entry:
-  %val = load [18 x i32], [18 x i32]* @var0
-  store volatile [18 x i32] %val, [18 x i32]* @var0
-  ret void
-}
-
-; Check that dynamic allocation calculations remain correct
-
-declare i8* @llvm.stacksave()
-declare void @llvm.stackrestore(i8*)
-declare void @notdead(i8*)
-
-define void @alloca(i32 %n) nounwind {
-; RV32I-LABEL: alloca:
-; RV32I-NOT:     call t0, __riscv_save
-; RV32I:         addi s0, sp, 16
-; RV32I:         addi sp, s0, -16
-; RV32I-NOT:     tail __riscv_restore
-;
-; RV64I-LABEL: alloca:
-; RV64I-NOT:     call t0, __riscv_save
-; RV64I:         addi s0, sp, 32
-; RV64I:         addi sp, s0, -32
-; RV64I-NOT:     tail __riscv_restore
-;
-; RV32I-SR-LABEL: alloca:
-; RV32I-SR:         call t0, __riscv_save_2
-; RV32I-SR:         addi s0, sp, 16
-; RV32I-SR:         addi sp, s0, -16
-; RV32I-SR:         tail __riscv_restore_2
-;
-; RV64I-SR-LABEL: alloca:
-; RV64I-SR:         call t0, __riscv_save_2
-; RV64I-SR:         addi s0, sp, 32
-; RV64I-SR:         addi sp, s0, -32
-; RV64I-SR:         tail __riscv_restore_2
-;
-; RV32I-FP-SR-LABEL: alloca:
-; RV32I-FP-SR:         call t0, __riscv_save_2
-; RV32I-FP-SR:         addi s0, sp, 16
-; RV32I-FP-SR:         addi sp, s0, -16
-; RV32I-FP-SR:         tail __riscv_restore_2
-;
-; RV64I-FP-SR-LABEL: alloca:
-; RV64I-FP-SR:         call t0, __riscv_save_2
-; RV64I-FP-SR:         addi s0, sp, 32
-; RV64I-FP-SR:         addi sp, s0, -32
-; RV64I-FP-SR:         tail __riscv_restore_2
-  %sp = call i8* @llvm.stacksave()
-  %addr = alloca i8, i32 %n
-  call void @notdead(i8* %addr)
-  call void @llvm.stackrestore(i8* %sp)
-  ret void
-}