diff --git a/llvm/lib/Target/RISCV/RISCVCallingConv.td b/llvm/lib/Target/RISCV/RISCVCallingConv.td
--- a/llvm/lib/Target/RISCV/RISCVCallingConv.td
+++ b/llvm/lib/Target/RISCV/RISCVCallingConv.td
@@ -33,8 +33,8 @@
 
 // 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)>;
diff --git a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
--- a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
@@ -361,16 +361,23 @@
 
 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;
 }
 
@@ -567,7 +574,7 @@
   // 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.
@@ -721,7 +728,8 @@
       --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
@@ -1386,7 +1394,7 @@
   }
 
   // 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();
@@ -1416,7 +1424,7 @@
   // 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);
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp b/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp
--- a/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp
@@ -512,6 +512,18 @@
   }
 }
 
+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,
@@ -527,10 +539,18 @@
 
   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;
@@ -614,9 +634,10 @@
 
   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;
@@ -676,11 +697,19 @@
     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);
   }
 }
 
diff --git a/llvm/lib/Target/RISCV/RISCVRegisterInfo.td b/llvm/lib/Target/RISCV/RISCVRegisterInfo.td
--- a/llvm/lib/Target/RISCV/RISCVRegisterInfo.td
+++ b/llvm/lib/Target/RISCV/RISCVRegisterInfo.td
@@ -597,3 +597,8 @@
 // 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;
+}
diff --git a/llvm/test/CodeGen/RISCV/interrupt-attr-nocall.ll b/llvm/test/CodeGen/RISCV/interrupt-attr-nocall.ll
--- a/llvm/test/CodeGen/RISCV/interrupt-attr-nocall.ll
+++ b/llvm/test/CodeGen/RISCV/interrupt-attr-nocall.ll
@@ -412,55 +412,57 @@
 ;
 ; 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)
@@ -471,55 +473,57 @@
 ; 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:
@@ -654,7 +658,9 @@
 ; 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)
@@ -665,6 +671,8 @@
 ; 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
diff --git a/llvm/test/CodeGen/RISCV/interrupt-attr.ll b/llvm/test/CodeGen/RISCV/interrupt-attr.ll
--- a/llvm/test/CodeGen/RISCV/interrupt-attr.ll
+++ b/llvm/test/CodeGen/RISCV/interrupt-attr.ll
@@ -85,208 +85,216 @@
 ;
 ; 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:
@@ -330,208 +338,216 @@
 ;
 ; 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
@@ -636,8 +652,12 @@
 ; 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
@@ -742,8 +762,12 @@
 ; 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
@@ -890,8 +914,12 @@
 ; 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
@@ -996,8 +1024,12 @@
 ; 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