[RISCV] Add CSR RegisterClass and save/restore fcsr in interrupt

[wangpc]

Summary

We add a new RegisterClass to represent CSRs and modify
storeRegToStackSlot/loadRegFromStackSlot so that we can
save/restore these CSRs.

This is an alternative of D158396

[wangpc]

Fix wrong restore dst reg.

[wangpc]

Fix paste error.

[wangpc]

CSR restore should be ahead.

[Jim]

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

379–380

If we put FCSR at first in CSR_XLEN_F32_Interrupt/CSR_XLEN_F64_Interrupt, is it still need to depend on save or restore to determinate the order of CSR inserted.

577

Typo. IsRestore.

[wangpc]

Fix typo.

[wangpc]

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

379–380

Yes. We should save FCSR after saving t0 and restore it before restoring t0 since we are using t0 as a temporary register.

[wangpc]

Gentle ping. :-)

[craig.topper]

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

549

This seems tricky to me to hardcode a GPR in here. This makes the code only work in certain scenarios. Do other targets do anything like this?

[wangpc]

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

549

This seems tricky to me to hardcode a GPR in here.

We just need a GPR to store the value of CSRs.

This makes the code only work in certain scenarios.

I don't get it. This code is only for saving CSRs.

Do other targets do anything like this?

No, I haven't find any target doing this.

[craig.topper]

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

549

This seems tricky to me to hardcode a GPR in here.

We just need a GPR to store the value of CSRs.

This makes the code only work in certain scenarios.

I don't get it. This code is only for saving CSRs.

It only works in the prolog and epilogue where that GPR is available. loadRegFromStackSlot and storeRegToStackSlot are normally also used for spills and reloads, but that wouldn’t work if we ever needed that for CSRs.

llvm/lib/Target/RISCV/RISCVRegisterInfo.td

600

This overlaps with FRM and FFLAGS. Probably at least deserves a comment about why they aren’t subregs.

[asb]

Left a trivial comment. Not sure on this vs D158396 - the logic of the other patch does seem a bit easier to follow as you suggested in your comment there.

llvm/lib/Target/RISCV/RISCVCallingConv.td

34

We should probably mention fcsr in this comment (and the one for f64 below).

[zixuan-wu]

In D158492#4638197, @asb wrote:

Left a trivial comment. Not sure on this vs D158396 - the logic of the other patch does seem a bit easier to follow as you suggested in your comment there.

I think it's more consistent than D158396 if consider CSRs as callee-saved register in one consistent place and infra.

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

553

Probably it can refer to SPILL_CR like Pseudo in PPC target. Just use Pseudo here and expand later in eliminateFrameIndex where introduce internal virtual GPR, then it would be scavenged later

[wangpc]

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

553

Thanks, I'll have a try!

llvm/lib/Target/RISCV/RISCVCallingConv.td

 
 // Needed for implementation of RISCVRegisterInfo::getNoPreservedMask()
 def CSR_NoRegs : CalleeSavedRegs<(add)>;
 
 // Interrupt handler needs to save/restore all registers that are used,
 // both Caller and Callee saved registers.
 def CSR_Interrupt : CalleeSavedRegs<(add X1, (sequence "X%u", 3, 31))>;
 
 // Same as CSR_Interrupt, but including all 32-bit FP registers.
 def CSR_XLEN_F32_Interrupt: CalleeSavedRegs<(add CSR_Interrupt,
-                                             (sequence "F%u_F", 0, 31))>;
+                                             (sequence "F%u_F", 0, 31), FCSR)>;
 
 // Same as CSR_Interrupt, but including all 64-bit FP registers.
 def CSR_XLEN_F64_Interrupt: CalleeSavedRegs<(add CSR_Interrupt,
-                                             (sequence "F%u_D", 0, 31))>;
+                                             (sequence "F%u_D", 0, 31), FCSR)>;

llvm/lib/Target/RISCV/RISCVFrameLowering.cpp

 // Returns the register used to hold the frame pointer.
 static Register getFPReg(const RISCVSubtarget &STI) { return RISCV::X8; }
 
 // Returns the register used to hold the stack pointer.
 static Register getSPReg(const RISCVSubtarget &STI) { return RISCV::X2; }
 
 static SmallVector<CalleeSavedInfo, 8>
 getUnmanagedCSI(const MachineFunction &MF,
-                const std::vector<CalleeSavedInfo> &CSI) {
+                const std::vector<CalleeSavedInfo> &CSI,
+                bool IsRestore = false) {
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   SmallVector<CalleeSavedInfo, 8> NonLibcallCSI;
+  SmallVector<CalleeSavedInfo, 8> CSRs;
 
   for (auto &CS : CSI) {
+    if (RISCV::CSRRegClass.contains(CS.getReg())) {
+      CSRs.push_back(CS);
+      continue;
+    }
     int FI = CS.getFrameIdx();
     if (FI >= 0 && MFI.getStackID(FI) == TargetStackID::Default)
       NonLibcallCSI.push_back(CS);
   }
-
+  NonLibcallCSI.insert(IsRestore ? NonLibcallCSI.begin() : NonLibcallCSI.end(),
+                       CSRs.begin(), CSRs.end());
   return NonLibcallCSI;
 }
 
 void RISCVFrameLowering::adjustStackForRVV(MachineFunction &MF,
                                            MachineBasicBlock &MBB,
                                            MachineBasicBlock::iterator MBBI,
                                            const DebugLoc &DL, int64_t Amount,
                                            MachineInstr::MIFlag Flag) const {
void RISCVFrameLowering::emitPrologue(MachineFunction &MF,
   const auto &CSI = MFI.getCalleeSavedInfo();
 
   // The frame pointer is callee-saved, and code has been generated for us to
   // save it to the stack. We need to skip over the storing of callee-saved
   // registers as the frame pointer must be modified after it has been saved
   // to the stack, not before.
   // FIXME: assumes exactly one instruction is used to save each callee-saved
   // register.
-  std::advance(MBBI, getUnmanagedCSI(MF, CSI).size());
+  std::advance(MBBI, getUnmanagedCSI(MF, CSI, /*IsRestore*/ false).size());
 
   // Iterate over list of callee-saved registers and emit .cfi_offset
   // directives.
   for (const auto &Entry : CSI) {
     int FrameIdx = Entry.getFrameIdx();
     int64_t Offset;
     // Offsets for objects with fixed locations (IE: those saved by libcall) are
     // simply calculated from the frame index.
if (!MBB.empty()) {
 
     // If callee-saved registers are saved via libcall, place stack adjustment
     // before this call.
     while (MBBI != MBB.begin() &&
            std::prev(MBBI)->getFlag(MachineInstr::FrameDestroy))
       --MBBI;
   }
 
-  const auto &CSI = getUnmanagedCSI(MF, MFI.getCalleeSavedInfo());
+  const auto &CSI =
+      getUnmanagedCSI(MF, MFI.getCalleeSavedInfo(), /*IsRestore*/ true);
 
   // Skip to before the restores of callee-saved registers
   // FIXME: assumes exactly one instruction is used to restore each
   // callee-saved register.
   auto LastFrameDestroy = MBBI;
   if (!CSI.empty())
     LastFrameDestroy = std::prev(MBBI, CSI.size());
 
BuildMI(MBB, MI, DL, TII.get(RISCV::PseudoCALLReg), RISCV::X5)
         .setMIFlag(MachineInstr::FrameSetup);
 
     // Add registers spilled in libcall as liveins.
     for (auto &CS : CSI)
       MBB.addLiveIn(CS.getReg());
   }
 
   // Manually spill values not spilled by libcall & Push/Pop.
-  const auto &UnmanagedCSI = getUnmanagedCSI(*MF, CSI);
+  const auto &UnmanagedCSI = getUnmanagedCSI(*MF, CSI, /*IsRestore*/ false);
   for (auto &CS : UnmanagedCSI) {
     // Insert the spill to the stack frame.
     Register Reg = CS.getReg();
     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
     TII.storeRegToStackSlot(MBB, MI, Reg, !MBB.isLiveIn(Reg), CS.getFrameIdx(),
                             RC, TRI, Register());
   }
 
if (MI != MBB.end() && !MI->isDebugInstr())
     DL = MI->getDebugLoc();
 
   // Manually restore values not restored by libcall & Push/Pop.
   // Keep the same order as in the prologue. There is no need to reverse the
   // order in the epilogue. In addition, the return address will be restored
   // first in the epilogue. It increases the opportunity to avoid the
   // load-to-use data hazard between loading RA and return by RA.
   // loadRegFromStackSlot can insert multiple instructions.
-  const auto &UnmanagedCSI = getUnmanagedCSI(*MF, CSI);
+  const auto &UnmanagedCSI = getUnmanagedCSI(*MF, CSI, /*IsRestore*/ true);
   for (auto &CS : UnmanagedCSI) {
     Register Reg = CS.getReg();
     const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
     TII.loadRegFromStackSlot(MBB, MI, Reg, CS.getFrameIdx(), RC, TRI,
                              Register());
     assert(MI != MBB.begin() && "loadRegFromStackSlot didn't insert any code!");
   }
 

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

if (IsScalableVector) {
     }
   } else {
     BuildMI(MBB, MBBI, DL, get(Opc), DstReg)
         .addReg(SrcReg, getKillRegState(KillSrc))
         .addReg(SrcReg, getKillRegState(KillSrc));
   }
 }
 
+static unsigned getSysRegEncoding(Register Reg) {
+  StringRef RegName;
+  switch (Reg) {
+  case RISCV::FCSR:
+    RegName = "FCSR";
+    break;
+  default:
+    report_fatal_error("can't save/store this CSR!");
+  }
+  return RISCVSysReg::lookupSysRegByName(RegName)->Encoding;
+}
+
 void RISCVInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
                                          MachineBasicBlock::iterator I,
                                          Register SrcReg, bool IsKill, int FI,
                                          const TargetRegisterClass *RC,
                                          const TargetRegisterInfo *TRI,
                                          Register VReg) const {
   DebugLoc DL;
   if (I != MBB.end())
     DL = I->getDebugLoc();
 
   MachineFunction *MF = MBB.getParent();
   MachineFrameInfo &MFI = MF->getFrameInfo();
 
   unsigned Opcode;
   bool IsScalableVector = true;
-  if (RISCV::GPRRegClass.hasSubClassEq(RC)) {
-    Opcode = TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ?
-             RISCV::SW : RISCV::SD;
+  if (RISCV::GPRRegClass.hasSubClassEq(RC) ||
+      RISCV::CSRRegClass.hasSubClassEq(RC)) {
+    Opcode =
+        TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ? RISCV::SW : RISCV::SD;
     IsScalableVector = false;
+    if (RISCV::CSRRegClass.hasSubClassEq(RC)) {
+      BuildMI(MBB, I, DL, get(RISCV::CSRRS))
+          .addReg(RISCV::X5, RegState::Define)
+          .addImm(getSysRegEncoding(SrcReg))
+          .addReg(RISCV::X0);
+      SrcReg = RISCV::X5;
+    }
   } else if (RISCV::GPRPF64RegClass.hasSubClassEq(RC)) {
     Opcode = RISCV::PseudoRV32ZdinxSD;
     IsScalableVector = false;
   } else if (RISCV::FPR16RegClass.hasSubClassEq(RC)) {
     Opcode = RISCV::FSH;
     IsScalableVector = false;
   } else if (RISCV::FPR32RegClass.hasSubClassEq(RC)) {
     Opcode = RISCV::FSW;
void RISCVInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
   if (I != MBB.end())
     DL = I->getDebugLoc();
 
   MachineFunction *MF = MBB.getParent();
   MachineFrameInfo &MFI = MF->getFrameInfo();
 
   unsigned Opcode;
   bool IsScalableVector = true;
-  if (RISCV::GPRRegClass.hasSubClassEq(RC)) {
-    Opcode = TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ?
-             RISCV::LW : RISCV::LD;
+  bool IsCSR = RISCV::CSRRegClass.hasSubClassEq(RC);
+  if (RISCV::GPRRegClass.hasSubClassEq(RC) || IsCSR) {
+    Opcode =
+        TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ? RISCV::LW : RISCV::LD;
     IsScalableVector = false;
   } else if (RISCV::GPRPF64RegClass.hasSubClassEq(RC)) {
     Opcode = RISCV::PseudoRV32ZdinxLD;
     IsScalableVector = false;
   } else if (RISCV::FPR16RegClass.hasSubClassEq(RC)) {
     Opcode = RISCV::FLH;
     IsScalableVector = false;
   } else if (RISCV::FPR32RegClass.hasSubClassEq(RC)) {
if (IsScalableVector) {
     MFI.setStackID(FI, TargetStackID::ScalableVector);
     BuildMI(MBB, I, DL, get(Opcode), DstReg)
         .addFrameIndex(FI)
         .addMemOperand(MMO);
   } else {
     MachineMemOperand *MMO = MF->getMachineMemOperand(
         MachinePointerInfo::getFixedStack(*MF, FI), MachineMemOperand::MOLoad,
         MFI.getObjectSize(FI), MFI.getObjectAlign(FI));
+    Register CSR = DstReg;
+    if (IsCSR)
+      DstReg = RISCV::X5;
 
     BuildMI(MBB, I, DL, get(Opcode), DstReg)
         .addFrameIndex(FI)
         .addImm(0)
         .addMemOperand(MMO);
+    if (IsCSR)
+      BuildMI(MBB, I, DL, get(RISCV::CSRRW))
+          .addReg(RISCV::X0, RegState::Define)
+          .addImm(getSysRegEncoding(CSR))
+          .addReg(RISCV::X5);
   }
 }
 
 MachineInstr *RISCVInstrInfo::foldMemoryOperandImpl(
     MachineFunction &MF, MachineInstr &MI, ArrayRef<unsigned> Ops,
     MachineBasicBlock::iterator InsertPt, int FrameIndex, LiveIntervals *LIS,
     VirtRegMap *VRM) const {
   const MachineFrameInfo &MFI = MF.getFrameInfo();

llvm/lib/Target/RISCV/RISCVRegisterInfo.td

def "VRN" # nf # "M" # m: VReg<[untyped],
                                     !cast<RegisterTuples>("VN" # nf # "M" # m # "V0")),
                                     !mul(nf, m)>;
   }
 }
 
 // Special registers
 def FFLAGS : RISCVReg<0, "fflags">;
 def FRM    : RISCVReg<0, "frm">;
+def FCSR   : RISCVReg<0, "fcsr">;
+
+def CSR : RegisterClass<"RISCV", [XLenVT], 32, (add FCSR)> {
+  let RegInfos = XLenRI;
+}

llvm/test/CodeGen/RISCV/interrupt-attr-nocall.ll

 ; CHECK-RV32-NEXT:    lw t4, 8(sp) # 4-byte Folded Reload
 ; CHECK-RV32-NEXT:    lw t5, 4(sp) # 4-byte Folded Reload
 ; CHECK-RV32-NEXT:    lw t6, 0(sp) # 4-byte Folded Reload
 ; CHECK-RV32-NEXT:    addi sp, sp, 64
 ; CHECK-RV32-NEXT:    mret
 ;
 ; CHECK-RV32IF-LABEL: foo_double:
 ; CHECK-RV32IF:       # %bb.0:
-; CHECK-RV32IF-NEXT:    addi sp, sp, -192
-; CHECK-RV32IF-NEXT:    sw ra, 188(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw t0, 184(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw t1, 180(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw t2, 176(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a0, 172(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a1, 168(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a2, 164(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a3, 160(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a4, 156(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a5, 152(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a6, 148(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw a7, 144(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw t3, 140(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw t4, 136(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw t5, 132(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    sw t6, 128(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft0, 124(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft1, 120(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft2, 116(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft3, 112(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft4, 108(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft5, 104(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft6, 100(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft7, 96(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs0, 92(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs1, 88(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa0, 84(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa1, 80(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa2, 76(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa3, 72(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa4, 68(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa5, 64(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa6, 60(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fa7, 56(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs2, 52(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs3, 48(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs4, 44(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs5, 40(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs6, 36(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs7, 32(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs8, 28(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs9, 24(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs10, 20(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw fs11, 16(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft8, 12(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft9, 8(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft10, 4(sp) # 4-byte Folded Spill
-; CHECK-RV32IF-NEXT:    fsw ft11, 0(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    addi sp, sp, -208
+; CHECK-RV32IF-NEXT:    sw ra, 204(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw t0, 200(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw t1, 196(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw t2, 192(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a0, 188(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a1, 184(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a2, 180(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a3, 176(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a4, 172(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a5, 168(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a6, 164(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw a7, 160(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw t3, 156(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw t4, 152(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw t5, 148(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    sw t6, 144(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft0, 140(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft1, 136(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft2, 132(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft3, 128(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft4, 124(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft5, 120(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft6, 116(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft7, 112(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs0, 108(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs1, 104(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa0, 100(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa1, 96(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa2, 92(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa3, 88(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa4, 84(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa5, 80(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa6, 76(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fa7, 72(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs2, 68(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs3, 64(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs4, 60(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs5, 56(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs6, 52(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs7, 48(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs8, 44(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs9, 40(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs10, 36(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw fs11, 32(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft8, 28(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft9, 24(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft10, 20(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    fsw ft11, 16(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    frcsr t0
+; CHECK-RV32IF-NEXT:    sw t0, 12(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    lui a1, %hi(h)
 ; CHECK-RV32IF-NEXT:    lw a0, %lo(h)(a1)
 ; CHECK-RV32IF-NEXT:    lw a1, %lo(h+4)(a1)
 ; CHECK-RV32IF-NEXT:    lui a3, %hi(i)
 ; CHECK-RV32IF-NEXT:    lw a2, %lo(i)(a3)
 ; CHECK-RV32IF-NEXT:    lw a3, %lo(i+4)(a3)
 ; CHECK-RV32IF-NEXT:    call __adddf3@plt
 ; CHECK-RV32IF-NEXT:    lui a2, %hi(g)
 ; CHECK-RV32IF-NEXT:    sw a1, %lo(g+4)(a2)
 ; CHECK-RV32IF-NEXT:    sw a0, %lo(g)(a2)
-; CHECK-RV32IF-NEXT:    lw ra, 188(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw t0, 184(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw t1, 180(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw t2, 176(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a0, 172(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a1, 168(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a2, 164(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a3, 160(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a4, 156(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a5, 152(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a6, 148(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw a7, 144(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw t3, 140(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw t4, 136(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw t5, 132(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    lw t6, 128(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft0, 124(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft1, 120(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft2, 116(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft3, 112(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft4, 108(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft5, 104(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft6, 100(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft7, 96(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs0, 92(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs1, 88(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa0, 84(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa1, 80(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa2, 76(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa3, 72(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa4, 68(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa5, 64(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa6, 60(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fa7, 56(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs2, 52(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs3, 48(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs4, 44(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs5, 40(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs6, 36(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs7, 32(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs8, 28(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs9, 24(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs10, 20(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw fs11, 16(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft8, 12(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft9, 8(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft10, 4(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    flw ft11, 0(sp) # 4-byte Folded Reload
-; CHECK-RV32IF-NEXT:    addi sp, sp, 192
+; CHECK-RV32IF-NEXT:    lw t0, 12(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    fscsr t0
+; CHECK-RV32IF-NEXT:    lw ra, 204(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw t0, 200(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw t1, 196(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw t2, 192(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a0, 188(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a1, 184(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a2, 180(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a3, 176(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a4, 172(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a5, 168(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a6, 164(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw a7, 160(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw t3, 156(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw t4, 152(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw t5, 148(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    lw t6, 144(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft0, 140(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft1, 136(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft2, 132(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft3, 128(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft4, 124(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft5, 120(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft6, 116(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft7, 112(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs0, 108(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs1, 104(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa0, 100(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa1, 96(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa2, 92(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa3, 88(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa4, 84(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa5, 80(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa6, 76(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fa7, 72(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs2, 68(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs3, 64(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs4, 60(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs5, 56(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs6, 52(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs7, 48(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs8, 44(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs9, 40(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs10, 36(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw fs11, 32(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft8, 28(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft9, 24(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft10, 20(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    flw ft11, 16(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    addi sp, sp, 208
 ; CHECK-RV32IF-NEXT:    mret
 ;
 ; CHECK-RV32IFD-LABEL: foo_double:
 ; CHECK-RV32IFD:       # %bb.0:
 ; CHECK-RV32IFD-NEXT:    addi sp, sp, -32
 ; CHECK-RV32IFD-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
 ; CHECK-RV32IFD-NEXT:    fsd fa4, 16(sp) # 8-byte Folded Spill
 ; CHECK-RV32IFD-NEXT:    fsd fa5, 8(sp) # 8-byte Folded Spill

 ; CHECK-RV32IF-NEXT:    fsw fs8, 40(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    fsw fs9, 36(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    fsw fs10, 32(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    fsw fs11, 28(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    fsw ft8, 24(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    fsw ft9, 20(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    fsw ft10, 16(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    fsw ft11, 12(sp) # 4-byte Folded Spill
+; CHECK-RV32IF-NEXT:    frcsr t0
 ; CHECK-RV32IF-NEXT:    addi s0, sp, 208
+; CHECK-RV32IF-NEXT:    sw t0, 8(sp) # 4-byte Folded Spill
 ; CHECK-RV32IF-NEXT:    lui a1, %hi(h)
 ; CHECK-RV32IF-NEXT:    lw a0, %lo(h)(a1)
 ; CHECK-RV32IF-NEXT:    lw a1, %lo(h+4)(a1)
 ; CHECK-RV32IF-NEXT:    lui a3, %hi(i)
 ; CHECK-RV32IF-NEXT:    lw a2, %lo(i)(a3)
 ; CHECK-RV32IF-NEXT:    lw a3, %lo(i+4)(a3)
 ; CHECK-RV32IF-NEXT:    call __adddf3@plt
 ; CHECK-RV32IF-NEXT:    lui a2, %hi(g)
 ; CHECK-RV32IF-NEXT:    sw a1, %lo(g+4)(a2)
 ; CHECK-RV32IF-NEXT:    sw a0, %lo(g)(a2)
+; CHECK-RV32IF-NEXT:    lw t0, 8(sp) # 4-byte Folded Reload
+; CHECK-RV32IF-NEXT:    fscsr t0
 ; CHECK-RV32IF-NEXT:    lw ra, 204(sp) # 4-byte Folded Reload
 ; CHECK-RV32IF-NEXT:    lw t0, 200(sp) # 4-byte Folded Reload
 ; CHECK-RV32IF-NEXT:    lw t1, 196(sp) # 4-byte Folded Reload
 ; CHECK-RV32IF-NEXT:    lw t2, 192(sp) # 4-byte Folded Reload
 ; CHECK-RV32IF-NEXT:    lw s0, 188(sp) # 4-byte Folded Reload
 ; CHECK-RV32IF-NEXT:    lw a0, 184(sp) # 4-byte Folded Reload
 ; CHECK-RV32IF-NEXT:    lw a1, 180(sp) # 4-byte Folded Reload
 ; CHECK-RV32IF-NEXT:    lw a2, 176(sp) # 4-byte Folded Reload

llvm/test/CodeGen/RISCV/interrupt-attr.ll

 ; CHECK-RV32-NEXT:    lw t4, 8(sp) # 4-byte Folded Reload
 ; CHECK-RV32-NEXT:    lw t5, 4(sp) # 4-byte Folded Reload
 ; CHECK-RV32-NEXT:    lw t6, 0(sp) # 4-byte Folded Reload
 ; CHECK-RV32-NEXT:    addi sp, sp, 64
 ; CHECK-RV32-NEXT:    mret
 ;
 ; CHECK-RV32-F-LABEL: foo_with_call:
 ; CHECK-RV32-F:       # %bb.0:
-; CHECK-RV32-F-NEXT:    addi sp, sp, -192
-; CHECK-RV32-F-NEXT:    sw ra, 188(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw t0, 184(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw t1, 180(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw t2, 176(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a0, 172(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a1, 168(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a2, 164(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a3, 160(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a4, 156(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a5, 152(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a6, 148(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw a7, 144(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw t3, 140(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw t4, 136(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw t5, 132(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    sw t6, 128(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft0, 124(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft1, 120(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft2, 116(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft3, 112(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft4, 108(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft5, 104(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft6, 100(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft7, 96(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs0, 92(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs1, 88(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa0, 84(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa1, 80(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa2, 76(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa3, 72(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa4, 68(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa5, 64(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa6, 60(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fa7, 56(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs2, 52(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs3, 48(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs4, 44(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs5, 40(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs6, 36(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs7, 32(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs8, 28(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs9, 24(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs10, 20(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw fs11, 16(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft8, 12(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft9, 8(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft10, 4(sp) # 4-byte Folded Spill
-; CHECK-RV32-F-NEXT:    fsw ft11, 0(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    addi sp, sp, -208
+; CHECK-RV32-F-NEXT:    sw ra, 204(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw t0, 200(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw t1, 196(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw t2, 192(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a0, 188(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a1, 184(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a2, 180(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a3, 176(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a4, 172(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a5, 168(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a6, 164(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw a7, 160(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw t3, 156(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw t4, 152(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw t5, 148(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    sw t6, 144(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft0, 140(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft1, 136(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft2, 132(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft3, 128(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft4, 124(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft5, 120(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft6, 116(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft7, 112(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs0, 108(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs1, 104(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa0, 100(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa1, 96(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa2, 92(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa3, 88(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa4, 84(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa5, 80(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa6, 76(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fa7, 72(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs2, 68(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs3, 64(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs4, 60(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs5, 56(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs6, 52(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs7, 48(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs8, 44(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs9, 40(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs10, 36(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw fs11, 32(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft8, 28(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft9, 24(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft10, 20(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    fsw ft11, 16(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    frcsr t0
+; CHECK-RV32-F-NEXT:    sw t0, 12(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    call otherfoo@plt
-; CHECK-RV32-F-NEXT:    lw ra, 188(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw t0, 184(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw t1, 180(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw t2, 176(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a0, 172(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a1, 168(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a2, 164(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a3, 160(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a4, 156(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a5, 152(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a6, 148(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw a7, 144(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw t3, 140(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw t4, 136(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw t5, 132(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    lw t6, 128(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft0, 124(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft1, 120(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft2, 116(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft3, 112(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft4, 108(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft5, 104(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft6, 100(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft7, 96(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs0, 92(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs1, 88(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa0, 84(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa1, 80(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa2, 76(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa3, 72(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa4, 68(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa5, 64(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa6, 60(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fa7, 56(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs2, 52(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs3, 48(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs4, 44(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs5, 40(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs6, 36(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs7, 32(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs8, 28(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs9, 24(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs10, 20(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw fs11, 16(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft8, 12(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft9, 8(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft10, 4(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    flw ft11, 0(sp) # 4-byte Folded Reload
-; CHECK-RV32-F-NEXT:    addi sp, sp, 192
+; CHECK-RV32-F-NEXT:    lw t0, 12(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    fscsr t0
+; CHECK-RV32-F-NEXT:    lw ra, 204(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw t0, 200(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw t1, 196(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw t2, 192(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a0, 188(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a1, 184(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a2, 180(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a3, 176(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a4, 172(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a5, 168(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a6, 164(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw a7, 160(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw t3, 156(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw t4, 152(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw t5, 148(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    lw t6, 144(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft0, 140(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft1, 136(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft2, 132(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft3, 128(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft4, 124(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft5, 120(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft6, 116(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft7, 112(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs0, 108(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs1, 104(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa0, 100(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa1, 96(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa2, 92(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa3, 88(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa4, 84(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa5, 80(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa6, 76(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fa7, 72(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs2, 68(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs3, 64(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs4, 60(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs5, 56(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs6, 52(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs7, 48(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs8, 44(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs9, 40(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs10, 36(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw fs11, 32(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft8, 28(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft9, 24(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft10, 20(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    flw ft11, 16(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    addi sp, sp, 208
 ; CHECK-RV32-F-NEXT:    mret
 ;
 ; CHECK-RV32-FD-LABEL: foo_with_call:
 ; CHECK-RV32-FD:       # %bb.0:
-; CHECK-RV32-FD-NEXT:    addi sp, sp, -320
-; CHECK-RV32-FD-NEXT:    sw ra, 316(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw t0, 312(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw t1, 308(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw t2, 304(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a0, 300(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a1, 296(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a2, 292(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a3, 288(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a4, 284(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a5, 280(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a6, 276(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw a7, 272(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw t3, 268(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw t4, 264(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw t5, 260(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    sw t6, 256(sp) # 4-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft0, 248(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft1, 240(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft2, 232(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft3, 224(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft4, 216(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft5, 208(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft6, 200(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft7, 192(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs0, 184(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs1, 176(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa0, 168(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa1, 160(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa2, 152(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa3, 144(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa4, 136(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa5, 128(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa6, 120(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fa7, 112(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs2, 104(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs3, 96(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs4, 88(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs5, 80(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs6, 72(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs7, 64(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs8, 56(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs9, 48(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs10, 40(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd fs11, 32(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft8, 24(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft9, 16(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft10, 8(sp) # 8-byte Folded Spill
-; CHECK-RV32-FD-NEXT:    fsd ft11, 0(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    addi sp, sp, -336
+; CHECK-RV32-FD-NEXT:    sw ra, 332(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw t0, 328(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw t1, 324(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw t2, 320(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a0, 316(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a1, 312(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a2, 308(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a3, 304(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a4, 300(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a5, 296(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a6, 292(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw a7, 288(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw t3, 284(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw t4, 280(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw t5, 276(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    sw t6, 272(sp) # 4-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft0, 264(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft1, 256(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft2, 248(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft3, 240(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft4, 232(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft5, 224(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft6, 216(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft7, 208(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs0, 200(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs1, 192(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa0, 184(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa1, 176(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa2, 168(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa3, 160(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa4, 152(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa5, 144(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa6, 136(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fa7, 128(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs2, 120(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs3, 112(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs4, 104(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs5, 96(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs6, 88(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs7, 80(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs8, 72(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs9, 64(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs10, 56(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd fs11, 48(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft8, 40(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft9, 32(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft10, 24(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    fsd ft11, 16(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    frcsr t0
+; CHECK-RV32-FD-NEXT:    sw t0, 12(sp) # 4-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    call otherfoo@plt
-; CHECK-RV32-FD-NEXT:    lw ra, 316(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw t0, 312(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw t1, 308(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw t2, 304(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a0, 300(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a1, 296(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a2, 292(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a3, 288(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a4, 284(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a5, 280(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a6, 276(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw a7, 272(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw t3, 268(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw t4, 264(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw t5, 260(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    lw t6, 256(sp) # 4-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft0, 248(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft1, 240(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft2, 232(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft3, 224(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft4, 216(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft5, 208(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft6, 200(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft7, 192(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs0, 184(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs1, 176(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa0, 168(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa1, 160(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa2, 152(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa3, 144(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa4, 136(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa5, 128(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa6, 120(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fa7, 112(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs2, 104(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs3, 96(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs4, 88(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs5, 80(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs6, 72(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs7, 64(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs8, 56(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs9, 48(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs10, 40(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld fs11, 32(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft8, 24(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft9, 16(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft10, 8(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    fld ft11, 0(sp) # 8-byte Folded Reload
-; CHECK-RV32-FD-NEXT:    addi sp, sp, 320
+; CHECK-RV32-FD-NEXT:    lw t0, 12(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fscsr t0
+; CHECK-RV32-FD-NEXT:    lw ra, 332(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw t0, 328(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw t1, 324(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw t2, 320(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a0, 316(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a1, 312(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a2, 308(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a3, 304(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a4, 300(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a5, 296(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a6, 292(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw a7, 288(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw t3, 284(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw t4, 280(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw t5, 276(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    lw t6, 272(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft0, 264(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft1, 256(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft2, 248(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft3, 240(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft4, 232(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft5, 224(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft6, 216(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft7, 208(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs0, 200(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs1, 192(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa0, 184(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa1, 176(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa2, 168(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa3, 160(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa4, 152(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa5, 144(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa6, 136(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fa7, 128(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs2, 120(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs3, 112(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs4, 104(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs5, 96(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs6, 88(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs7, 80(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs8, 72(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs9, 64(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs10, 56(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld fs11, 48(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft8, 40(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft9, 32(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft10, 24(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fld ft11, 16(sp) # 8-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    addi sp, sp, 336
 ; CHECK-RV32-FD-NEXT:    mret
 ;
 ; CHECK-RV64-LABEL: foo_with_call:
 ; CHECK-RV64:       # %bb.0:
 ; CHECK-RV64-NEXT:    addi sp, sp, -128
 ; CHECK-RV64-NEXT:    sd ra, 120(sp) # 8-byte Folded Spill
 ; CHECK-RV64-NEXT:    sd t0, 112(sp) # 8-byte Folded Spill
 ; CHECK-RV64-NEXT:    sd t1, 104(sp) # 8-byte Folded Spill

 ; CHECK-RV64-NEXT:    ld t4, 16(sp) # 8-byte Folded Reload
 ; CHECK-RV64-NEXT:    ld t5, 8(sp) # 8-byte Folded Reload
 ; CHECK-RV64-NEXT:    ld t6, 0(sp) # 8-byte Folded Reload
 ; CHECK-RV64-NEXT:    addi sp, sp, 128
 ; CHECK-RV64-NEXT:    mret
 ;
 ; CHECK-RV64-F-LABEL: foo_with_call:
 ; CHECK-RV64-F:       # %bb.0:
-; CHECK-RV64-F-NEXT:    addi sp, sp, -256
-; CHECK-RV64-F-NEXT:    sd ra, 248(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd t0, 240(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd t1, 232(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd t2, 224(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a0, 216(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a1, 208(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a2, 200(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a3, 192(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a4, 184(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a5, 176(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a6, 168(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd a7, 160(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd t3, 152(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd t4, 144(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd t5, 136(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    sd t6, 128(sp) # 8-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft0, 124(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft1, 120(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft2, 116(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft3, 112(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft4, 108(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft5, 104(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft6, 100(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft7, 96(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs0, 92(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs1, 88(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa0, 84(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa1, 80(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa2, 76(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa3, 72(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa4, 68(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa5, 64(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa6, 60(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fa7, 56(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs2, 52(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs3, 48(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs4, 44(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs5, 40(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs6, 36(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs7, 32(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs8, 28(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs9, 24(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs10, 20(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw fs11, 16(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft8, 12(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft9, 8(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft10, 4(sp) # 4-byte Folded Spill
-; CHECK-RV64-F-NEXT:    fsw ft11, 0(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    addi sp, sp, -272
+; CHECK-RV64-F-NEXT:    sd ra, 264(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd t0, 256(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd t1, 248(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd t2, 240(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a0, 232(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a1, 224(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a2, 216(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a3, 208(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a4, 200(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a5, 192(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a6, 184(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd a7, 176(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd t3, 168(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd t4, 160(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd t5, 152(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    sd t6, 144(sp) # 8-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft0, 140(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft1, 136(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft2, 132(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft3, 128(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft4, 124(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft5, 120(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft6, 116(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft7, 112(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs0, 108(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs1, 104(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa0, 100(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa1, 96(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa2, 92(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa3, 88(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa4, 84(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa5, 80(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa6, 76(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fa7, 72(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs2, 68(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs3, 64(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs4, 60(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs5, 56(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs6, 52(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs7, 48(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs8, 44(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs9, 40(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs10, 36(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw fs11, 32(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft8, 28(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft9, 24(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft10, 20(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    fsw ft11, 16(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    frcsr t0
+; CHECK-RV64-F-NEXT:    sd t0, 8(sp) # 8-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    call otherfoo@plt
-; CHECK-RV64-F-NEXT:    ld ra, 248(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld t0, 240(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld t1, 232(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld t2, 224(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a0, 216(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a1, 208(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a2, 200(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a3, 192(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a4, 184(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a5, 176(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a6, 168(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld a7, 160(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld t3, 152(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld t4, 144(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld t5, 136(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    ld t6, 128(sp) # 8-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft0, 124(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft1, 120(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft2, 116(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft3, 112(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft4, 108(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft5, 104(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft6, 100(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft7, 96(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs0, 92(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs1, 88(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa0, 84(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa1, 80(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa2, 76(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa3, 72(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa4, 68(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa5, 64(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa6, 60(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fa7, 56(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs2, 52(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs3, 48(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs4, 44(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs5, 40(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs6, 36(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs7, 32(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs8, 28(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs9, 24(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs10, 20(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw fs11, 16(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft8, 12(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft9, 8(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft10, 4(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    flw ft11, 0(sp) # 4-byte Folded Reload
-; CHECK-RV64-F-NEXT:    addi sp, sp, 256
+; CHECK-RV64-F-NEXT:    ld t0, 8(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    fscsr t0
+; CHECK-RV64-F-NEXT:    ld ra, 264(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld t0, 256(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld t1, 248(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld t2, 240(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a0, 232(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a1, 224(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a2, 216(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a3, 208(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a4, 200(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a5, 192(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a6, 184(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld a7, 176(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld t3, 168(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld t4, 160(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld t5, 152(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    ld t6, 144(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft0, 140(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft1, 136(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft2, 132(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft3, 128(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft4, 124(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft5, 120(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft6, 116(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft7, 112(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs0, 108(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs1, 104(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa0, 100(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa1, 96(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa2, 92(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa3, 88(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa4, 84(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa5, 80(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa6, 76(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fa7, 72(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs2, 68(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs3, 64(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs4, 60(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs5, 56(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs6, 52(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs7, 48(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs8, 44(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs9, 40(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs10, 36(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw fs11, 32(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft8, 28(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft9, 24(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft10, 20(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    flw ft11, 16(sp) # 4-byte Folded Reload
+; CHECK-RV64-F-NEXT:    addi sp, sp, 272
 ; CHECK-RV64-F-NEXT:    mret
 ;
 ; CHECK-RV64-FD-LABEL: foo_with_call:
 ; CHECK-RV64-FD:       # %bb.0:
-; CHECK-RV64-FD-NEXT:    addi sp, sp, -384
-; CHECK-RV64-FD-NEXT:    sd ra, 376(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd t0, 368(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd t1, 360(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd t2, 352(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a0, 344(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a1, 336(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a2, 328(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a3, 320(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a4, 312(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a5, 304(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a6, 296(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd a7, 288(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd t3, 280(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd t4, 272(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd t5, 264(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    sd t6, 256(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft0, 248(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft1, 240(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft2, 232(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft3, 224(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft4, 216(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft5, 208(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft6, 200(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft7, 192(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs0, 184(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs1, 176(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa0, 168(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa1, 160(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa2, 152(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa3, 144(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa4, 136(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa5, 128(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa6, 120(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fa7, 112(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs2, 104(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs3, 96(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs4, 88(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs5, 80(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs6, 72(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs7, 64(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs8, 56(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs9, 48(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs10, 40(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd fs11, 32(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft8, 24(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft9, 16(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft10, 8(sp) # 8-byte Folded Spill
-; CHECK-RV64-FD-NEXT:    fsd ft11, 0(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    addi sp, sp, -400
+; CHECK-RV64-FD-NEXT:    sd ra, 392(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd t0, 384(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd t1, 376(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd t2, 368(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a0, 360(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a1, 352(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a2, 344(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a3, 336(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a4, 328(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a5, 320(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a6, 312(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd a7, 304(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd t3, 296(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd t4, 288(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd t5, 280(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    sd t6, 272(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft0, 264(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft1, 256(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft2, 248(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft3, 240(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft4, 232(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft5, 224(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft6, 216(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft7, 208(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs0, 200(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs1, 192(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa0, 184(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa1, 176(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa2, 168(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa3, 160(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa4, 152(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa5, 144(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa6, 136(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fa7, 128(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs2, 120(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs3, 112(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs4, 104(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs5, 96(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs6, 88(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs7, 80(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs8, 72(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs9, 64(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs10, 56(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd fs11, 48(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft8, 40(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft9, 32(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft10, 24(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    fsd ft11, 16(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    frcsr t0
+; CHECK-RV64-FD-NEXT:    sd t0, 8(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    call otherfoo@plt
-; CHECK-RV64-FD-NEXT:    ld ra, 376(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld t0, 368(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld t1, 360(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld t2, 352(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a0, 344(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a1, 336(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a2, 328(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a3, 320(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a4, 312(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a5, 304(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a6, 296(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld a7, 288(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld t3, 280(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld t4, 272(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld t5, 264(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    ld t6, 256(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft0, 248(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft1, 240(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft2, 232(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft3, 224(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft4, 216(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft5, 208(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft6, 200(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft7, 192(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs0, 184(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs1, 176(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa0, 168(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa1, 160(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa2, 152(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa3, 144(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa4, 136(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa5, 128(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa6, 120(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fa7, 112(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs2, 104(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs3, 96(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs4, 88(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs5, 80(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs6, 72(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs7, 64(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs8, 56(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs9, 48(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs10, 40(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld fs11, 32(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft8, 24(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft9, 16(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft10, 8(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    fld ft11, 0(sp) # 8-byte Folded Reload
-; CHECK-RV64-FD-NEXT:    addi sp, sp, 384
+; CHECK-RV64-FD-NEXT:    ld t0, 8(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fscsr t0
+; CHECK-RV64-FD-NEXT:    ld ra, 392(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld t0, 384(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld t1, 376(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld t2, 368(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a0, 360(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a1, 352(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a2, 344(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a3, 336(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a4, 328(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a5, 320(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a6, 312(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld a7, 304(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld t3, 296(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld t4, 288(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld t5, 280(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    ld t6, 272(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft0, 264(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft1, 256(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft2, 248(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft3, 240(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft4, 232(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft5, 224(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft6, 216(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft7, 208(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs0, 200(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs1, 192(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa0, 184(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa1, 176(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa2, 168(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa3, 160(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa4, 152(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa5, 144(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa6, 136(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fa7, 128(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs2, 120(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs3, 112(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs4, 104(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs5, 96(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs6, 88(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs7, 80(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs8, 72(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs9, 64(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs10, 56(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld fs11, 48(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft8, 40(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft9, 32(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft10, 24(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fld ft11, 16(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    addi sp, sp, 400
 ; CHECK-RV64-FD-NEXT:    mret
   %call = call i32 @otherfoo()
   ret void
 }
 
 ;
 ; Additionally check frame pointer and return address are properly saved.
 ;

 ; CHECK-RV32-F-NEXT:    fsw fs8, 40(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    fsw fs9, 36(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    fsw fs10, 32(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    fsw fs11, 28(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    fsw ft8, 24(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    fsw ft9, 20(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    fsw ft10, 16(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    fsw ft11, 12(sp) # 4-byte Folded Spill
+; CHECK-RV32-F-NEXT:    frcsr t0
 ; CHECK-RV32-F-NEXT:    addi s0, sp, 208
+; CHECK-RV32-F-NEXT:    sw t0, 8(sp) # 4-byte Folded Spill
 ; CHECK-RV32-F-NEXT:    call otherfoo@plt
+; CHECK-RV32-F-NEXT:    lw t0, 8(sp) # 4-byte Folded Reload
+; CHECK-RV32-F-NEXT:    fscsr t0
 ; CHECK-RV32-F-NEXT:    lw ra, 204(sp) # 4-byte Folded Reload
 ; CHECK-RV32-F-NEXT:    lw t0, 200(sp) # 4-byte Folded Reload
 ; CHECK-RV32-F-NEXT:    lw t1, 196(sp) # 4-byte Folded Reload
 ; CHECK-RV32-F-NEXT:    lw t2, 192(sp) # 4-byte Folded Reload
 ; CHECK-RV32-F-NEXT:    lw s0, 188(sp) # 4-byte Folded Reload
 ; CHECK-RV32-F-NEXT:    lw a0, 184(sp) # 4-byte Folded Reload
 ; CHECK-RV32-F-NEXT:    lw a1, 180(sp) # 4-byte Folded Reload
 ; CHECK-RV32-F-NEXT:    lw a2, 176(sp) # 4-byte Folded Reload

 ; CHECK-RV32-FD-NEXT:    fsd fs8, 64(sp) # 8-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    fsd fs9, 56(sp) # 8-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    fsd fs10, 48(sp) # 8-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    fsd fs11, 40(sp) # 8-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    fsd ft8, 32(sp) # 8-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    fsd ft9, 24(sp) # 8-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    fsd ft10, 16(sp) # 8-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    fsd ft11, 8(sp) # 8-byte Folded Spill
+; CHECK-RV32-FD-NEXT:    frcsr t0
 ; CHECK-RV32-FD-NEXT:    addi s0, sp, 336
+; CHECK-RV32-FD-NEXT:    sw t0, 4(sp) # 4-byte Folded Spill
 ; CHECK-RV32-FD-NEXT:    call otherfoo@plt
+; CHECK-RV32-FD-NEXT:    lw t0, 4(sp) # 4-byte Folded Reload
+; CHECK-RV32-FD-NEXT:    fscsr t0
 ; CHECK-RV32-FD-NEXT:    lw ra, 332(sp) # 4-byte Folded Reload
 ; CHECK-RV32-FD-NEXT:    lw t0, 328(sp) # 4-byte Folded Reload
 ; CHECK-RV32-FD-NEXT:    lw t1, 324(sp) # 4-byte Folded Reload
 ; CHECK-RV32-FD-NEXT:    lw t2, 320(sp) # 4-byte Folded Reload
 ; CHECK-RV32-FD-NEXT:    lw s0, 316(sp) # 4-byte Folded Reload
 ; CHECK-RV32-FD-NEXT:    lw a0, 312(sp) # 4-byte Folded Reload
 ; CHECK-RV32-FD-NEXT:    lw a1, 308(sp) # 4-byte Folded Reload
 ; CHECK-RV32-FD-NEXT:    lw a2, 304(sp) # 4-byte Folded Reload

 ; CHECK-RV64-F-NEXT:    fsw fs8, 36(sp) # 4-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    fsw fs9, 32(sp) # 4-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    fsw fs10, 28(sp) # 4-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    fsw fs11, 24(sp) # 4-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    fsw ft8, 20(sp) # 4-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    fsw ft9, 16(sp) # 4-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    fsw ft10, 12(sp) # 4-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    fsw ft11, 8(sp) # 4-byte Folded Spill
+; CHECK-RV64-F-NEXT:    frcsr t0
 ; CHECK-RV64-F-NEXT:    addi s0, sp, 272
+; CHECK-RV64-F-NEXT:    sd t0, 0(sp) # 8-byte Folded Spill
 ; CHECK-RV64-F-NEXT:    call otherfoo@plt
+; CHECK-RV64-F-NEXT:    ld t0, 0(sp) # 8-byte Folded Reload
+; CHECK-RV64-F-NEXT:    fscsr t0
 ; CHECK-RV64-F-NEXT:    ld ra, 264(sp) # 8-byte Folded Reload
 ; CHECK-RV64-F-NEXT:    ld t0, 256(sp) # 8-byte Folded Reload
 ; CHECK-RV64-F-NEXT:    ld t1, 248(sp) # 8-byte Folded Reload
 ; CHECK-RV64-F-NEXT:    ld t2, 240(sp) # 8-byte Folded Reload
 ; CHECK-RV64-F-NEXT:    ld s0, 232(sp) # 8-byte Folded Reload
 ; CHECK-RV64-F-NEXT:    ld a0, 224(sp) # 8-byte Folded Reload
 ; CHECK-RV64-F-NEXT:    ld a1, 216(sp) # 8-byte Folded Reload
 ; CHECK-RV64-F-NEXT:    ld a2, 208(sp) # 8-byte Folded Reload

 ; CHECK-RV64-FD-NEXT:    fsd fs8, 64(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    fsd fs9, 56(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    fsd fs10, 48(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    fsd fs11, 40(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    fsd ft8, 32(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    fsd ft9, 24(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    fsd ft10, 16(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    fsd ft11, 8(sp) # 8-byte Folded Spill
+; CHECK-RV64-FD-NEXT:    frcsr t0
 ; CHECK-RV64-FD-NEXT:    addi s0, sp, 400
+; CHECK-RV64-FD-NEXT:    sd t0, 0(sp) # 8-byte Folded Spill
 ; CHECK-RV64-FD-NEXT:    call otherfoo@plt
+; CHECK-RV64-FD-NEXT:    ld t0, 0(sp) # 8-byte Folded Reload
+; CHECK-RV64-FD-NEXT:    fscsr t0
 ; CHECK-RV64-FD-NEXT:    ld ra, 392(sp) # 8-byte Folded Reload
 ; CHECK-RV64-FD-NEXT:    ld t0, 384(sp) # 8-byte Folded Reload
 ; CHECK-RV64-FD-NEXT:    ld t1, 376(sp) # 8-byte Folded Reload
 ; CHECK-RV64-FD-NEXT:    ld t2, 368(sp) # 8-byte Folded Reload
 ; CHECK-RV64-FD-NEXT:    ld s0, 360(sp) # 8-byte Folded Reload
 ; CHECK-RV64-FD-NEXT:    ld a0, 352(sp) # 8-byte Folded Reload
 ; CHECK-RV64-FD-NEXT:    ld a1, 344(sp) # 8-byte Folded Reload
 ; CHECK-RV64-FD-NEXT:    ld a2, 336(sp) # 8-byte Folded Reload