diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
index 458747a1f7155..98b1af5d56535 100644
--- a/clang/include/clang/Basic/Attr.td
+++ b/clang/include/clang/Basic/Attr.td
@@ -2232,8 +2232,8 @@ def RISCVInterrupt : InheritableAttr, TargetSpecificAttr<TargetRISCV> {
   let Spellings = [GCC<"interrupt">];
   let Subjects = SubjectList<[Function]>;
   let Args = [EnumArgument<"Interrupt", "InterruptType", /*is_string=*/true,
-                           ["supervisor", "machine"],
-                           ["supervisor", "machine"],
+                           ["supervisor", "machine", "qci-nest", "qci-nonest"],
+                           ["supervisor", "machine", "qcinest", "qcinonest"],
                            1>];
   let ParseKind = "Interrupt";
   let Documentation = [RISCVInterruptDocs];
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index f44fad95423ee..fdc58d1c92c0d 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -2828,8 +2828,17 @@ targets. This attribute may be attached to a function definition and instructs
 the backend to generate appropriate function entry/exit code so that it can be
 used directly as an interrupt service routine.
 
-Permissible values for this parameter are ``supervisor`` and ``machine``. If
-there is no parameter, then it defaults to ``machine``.
+Permissible values for this parameter are ``supervisor``, ``machine``,
+``qci-nest`` and ``qci-nonest``. If there is no parameter, then it defaults to
+``machine``.
+
+The ``qci-nest`` and ``qci-nonest`` values require Qualcomm's Xqciint extension
+and are used for Machine-mode Interrupts and Machine-mode Non-maskable
+interrupts. These use the following instructions from Xqciint to save and
+restore interrupt state to the stack -- the ``qci-nest`` value will use
+``qc.c.mienter.nest`` and the ``qci-nonest`` value will use ``qc.c.mienter`` to
+begin the interrupt handler. Both of these will use ``qc.c.mileaveret`` to
+restore the state and return to the previous context.
 
 Repeated interrupt attribute on the same declaration will cause a warning
 to be emitted. In case of repeated declarations, the last one prevails.
@@ -2839,6 +2848,7 @@ https://gcc.gnu.org/onlinedocs/gcc/RISC-V-Function-Attributes.html
 https://riscv.org/specifications/privileged-isa/
 The RISC-V Instruction Set Manual Volume II: Privileged Architecture
 Version 1.10.
+https://github.com/quic/riscv-unified-db/releases/tag/Xqci-0.6
   }];
 }
 
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 0b121c04cd3c0..850aef10a7d5e 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -12624,8 +12624,9 @@ def err_riscv_builtin_requires_extension : Error<
 def err_riscv_builtin_invalid_lmul : Error<
   "LMUL argument must be in the range [0,3] or [5,7]">;
 def err_riscv_type_requires_extension : Error<
-  "RISC-V type %0 requires the '%1' extension"
->;
+  "RISC-V type %0 requires the '%1' extension">;
+def err_riscv_attribute_interrupt_requires_extension : Error<
+  "RISC-V interrupt attribute '%0' requires extension '%1'">;
 
 def err_std_source_location_impl_not_found : Error<
   "'std::source_location::__impl' was not found; it must be defined before '__builtin_source_location' is called">;
diff --git a/clang/lib/CodeGen/Targets/RISCV.cpp b/clang/lib/CodeGen/Targets/RISCV.cpp
index e350a3589dcaf..081ae8a403111 100644
--- a/clang/lib/CodeGen/Targets/RISCV.cpp
+++ b/clang/lib/CodeGen/Targets/RISCV.cpp
@@ -833,6 +833,12 @@ class RISCVTargetCodeGenInfo : public TargetCodeGenInfo {
     switch (Attr->getInterrupt()) {
     case RISCVInterruptAttr::supervisor: Kind = "supervisor"; break;
     case RISCVInterruptAttr::machine: Kind = "machine"; break;
+    case RISCVInterruptAttr::qcinest:
+      Kind = "qci-nest";
+      break;
+    case RISCVInterruptAttr::qcinonest:
+      Kind = "qci-nonest";
+      break;
     }
 
     Fn->addFnAttr("interrupt", Kind);
diff --git a/clang/lib/Sema/SemaRISCV.cpp b/clang/lib/Sema/SemaRISCV.cpp
index 8a5037d045125..47660319fa3af 100644
--- a/clang/lib/Sema/SemaRISCV.cpp
+++ b/clang/lib/Sema/SemaRISCV.cpp
@@ -12,6 +12,7 @@
 
 #include "clang/Sema/SemaRISCV.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/TargetBuiltins.h"
@@ -1475,6 +1476,26 @@ void SemaRISCV::handleInterruptAttr(Decl *D, const ParsedAttr &AL) {
     return;
   }
 
+  switch (Kind) {
+  default:
+    break;
+  case RISCVInterruptAttr::InterruptType::qcinest:
+  case RISCVInterruptAttr::InterruptType::qcinonest: {
+    const TargetInfo &TI = getASTContext().getTargetInfo();
+    llvm::StringMap<bool> FunctionFeatureMap;
+    getASTContext().getFunctionFeatureMap(FunctionFeatureMap,
+                                          dyn_cast<FunctionDecl>(D));
+
+    if (!TI.hasFeature("experimental-xqciint") &&
+        !FunctionFeatureMap.lookup("experimental-xqciint")) {
+      Diag(AL.getLoc(), diag::err_riscv_attribute_interrupt_requires_extension)
+          << Str << "Xqciint";
+      return;
+    }
+    break;
+  }
+  };
+
   D->addAttr(::new (getASTContext())
                  RISCVInterruptAttr(getASTContext(), AL, Kind));
 }
diff --git a/clang/test/Sema/riscv-interrupt-attr-qci.c b/clang/test/Sema/riscv-interrupt-attr-qci.c
new file mode 100644
index 0000000000000..bdac4e154bb3c
--- /dev/null
+++ b/clang/test/Sema/riscv-interrupt-attr-qci.c
@@ -0,0 +1,51 @@
+// RUN: %clang_cc1 -triple riscv32-unknown-elf -target-feature +experimental-xqciint -emit-llvm -DCHECK_IR < %s| FileCheck %s
+// RUN: %clang_cc1 %s -triple riscv32-unknown-elf -target-feature +experimental-xqciint -verify=enabled,both -fsyntax-only
+// RUN: %clang_cc1 %s -triple riscv32-unknown-elf -verify=disabled,both -fsyntax-only
+// RUN: %clang_cc1 %s -triple riscv32-unknown-elf -target-feature -experimental-xqciint -verify=disabled,both -fsyntax-only
+// RUN: %clang_cc1 %s -triple riscv64-unknown-elf -verify=disabled,both -fsyntax-only -DRV64
+
+#if defined(CHECK_IR)
+// Test for QCI extension's interrupt attribute support
+// CHECK-LABEL: @foo_nest_interrupt() #0
+// CHECK: ret void
+__attribute__((interrupt("qci-nest")))
+void foo_nest_interrupt(void) {}
+
+// CHECK-LABEL: @foo_nonnest_interrupt() #1
+// CHECK: ret void
+__attribute__((interrupt("qci-nonest")))
+void foo_nonnest_interrupt(void) {}
+
+// CHECK: attributes #0
+// CHECK: "interrupt"="qci-nest"
+// CHECK: attributes #1
+// CHECK: "interrupt"="qci-nonest"
+#else
+// Test for QCI extension's interrupt attribute support
+__attribute__((interrupt("qci-est"))) void foo_nest1(void) {} // both-warning {{'interrupt' attribute argument not supported: qci-est}}
+__attribute__((interrupt("qci-noest"))) void foo_nonest1(void) {} // both-warning {{'interrupt' attribute argument not supported: qci-noest}}
+__attribute__((interrupt(1))) void foo_nest2(void) {} // both-error {{expected string literal as argument of 'interrupt' attribute}}
+__attribute__((interrupt("qci-nest", "qci-nonest"))) void foo1(void) {} // both-error {{'interrupt' attribute takes no more than 1 argument}}
+__attribute__((interrupt("qci-nonest", "qci-nest"))) void foo2(void) {} // both-error {{'interrupt' attribute takes no more than 1 argument}}
+__attribute__((interrupt("", "qci-nonest"))) void foo3(void) {} // both-error {{'interrupt' attribute takes no more than 1 argument}}
+__attribute__((interrupt("", "qci-nest"))) void foo4(void) {} // both-error {{'interrupt' attribute takes no more than 1 argument}}
+__attribute__((interrupt("qci-nonest", 1))) void foo5(void) {} // both-error {{'interrupt' attribute takes no more than 1 argument}}
+__attribute__((interrupt("qci-nest", 1))) void foo6(void) {} // both-error {{'interrupt' attribute takes no more than 1 argument}}
+
+__attribute__((interrupt("qci-nest"))) void foo_nest(void) {} // disabled-error {{RISC-V interrupt attribute 'qci-nest' requires extension 'Xqciint'}}
+__attribute__((interrupt("qci-nonest"))) void foo_nonest(void) {} // disabled-error {{RISC-V interrupt attribute 'qci-nonest' requires extension 'Xqciint'}}
+
+// This tests the errors for the qci interrupts when using
+// `__attribute__((target(...)))` - but they fail on RV64, because you cannot
+// enable xqciint on rv64.
+#if __riscv_xlen == 32
+__attribute__((target("arch=+xqciint"))) __attribute__((interrupt("qci-nest"))) void foo_nest_xqciint(void) {}
+__attribute__((target("arch=+xqciint"))) __attribute__((interrupt("qci-nonest"))) void foo_nonest_xqciint(void) {}
+
+// The attribute order is important, the interrupt attribute must come after the
+// target attribute
+__attribute__((interrupt("qci-nest"))) __attribute__((target("arch=+xqciint"))) void foo_nest_xqciint2(void) {}  // disabled-error {{RISC-V interrupt attribute 'qci-nest' requires extension 'Xqciint'}}
+__attribute__((interrupt("qci-nonest"))) __attribute__((target("arch=+xqciint"))) void foo_nonest_xqciint2(void) {}  // disabled-error {{RISC-V interrupt attribute 'qci-nonest' requires extension 'Xqciint'}}
+#endif
+
+#endif
diff --git a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
index e14e6b5a77893..6b61a236cf570 100644
--- a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
@@ -121,6 +121,34 @@ static const MCPhysReg FixedCSRFIMap[] = {
     /*s8*/ RISCV::X24, /*s9*/ RISCV::X25, /*s10*/ RISCV::X26,
     /*s11*/ RISCV::X27};
 
+// The number of stack bytes allocated by `QC.C.MIENTER(.NEST)` and popped by
+// `QC.C.MILEAVERET`.
+static constexpr uint64_t QCIInterruptPushAmount = 96;
+
+static const std::pair<MCPhysReg, int8_t> FixedCSRFIQCIInterruptMap[] = {
+    /* -1 is a gap for mepc/qc.mnepc */
+    {/*fp*/ FPReg, -2},
+    /* -3 is a gap for mcause */
+    {/*ra*/ RAReg, -4},
+    /* -5 is reserved */
+    {/*t0*/ RISCV::X5, -6},
+    {/*t1*/ RISCV::X6, -7},
+    {/*t2*/ RISCV::X7, -8},
+    {/*a0*/ RISCV::X10, -9},
+    {/*a1*/ RISCV::X11, -10},
+    {/*a2*/ RISCV::X12, -11},
+    {/*a3*/ RISCV::X13, -12},
+    {/*a4*/ RISCV::X14, -13},
+    {/*a5*/ RISCV::X15, -14},
+    {/*a6*/ RISCV::X16, -15},
+    {/*a7*/ RISCV::X17, -16},
+    {/*t3*/ RISCV::X28, -17},
+    {/*t4*/ RISCV::X29, -18},
+    {/*t5*/ RISCV::X30, -19},
+    {/*t6*/ RISCV::X31, -20},
+    /* -21, -22, -23, -24 are reserved */
+};
+
 // For now we use x3, a.k.a gp, as pointer to shadow call stack.
 // User should not use x3 in their asm.
 static void emitSCSPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
@@ -382,6 +410,10 @@ void RISCVFrameLowering::determineFrameLayout(MachineFunction &MF) const {
   // Get the number of bytes to allocate from the FrameInfo.
   uint64_t FrameSize = MFI.getStackSize();
 
+  // QCI Interrupts use at least 96 bytes of stack space
+  if (RVFI->useQCIInterrupt(MF))
+    FrameSize = std::max(FrameSize, QCIInterruptPushAmount);
+
   // Get the alignment.
   Align StackAlign = getStackAlign();
 
@@ -463,6 +495,26 @@ getPushOrLibCallsSavedInfo(const MachineFunction &MF,
   return PushOrLibCallsCSI;
 }
 
+static SmallVector<CalleeSavedInfo, 8>
+getQCISavedInfo(const MachineFunction &MF,
+                const std::vector<CalleeSavedInfo> &CSI) {
+  auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
+
+  SmallVector<CalleeSavedInfo, 8> QCIInterruptCSI;
+  if (!RVFI->useQCIInterrupt(MF))
+    return QCIInterruptCSI;
+
+  for (const auto &CS : CSI) {
+    const auto *FII = llvm::find_if(FixedCSRFIQCIInterruptMap, [&](auto P) {
+      return P.first == CS.getReg();
+    });
+    if (FII != std::end(FixedCSRFIQCIInterruptMap))
+      QCIInterruptCSI.push_back(CS);
+  }
+
+  return QCIInterruptCSI;
+}
+
 void RISCVFrameLowering::allocateAndProbeStackForRVV(
     MachineFunction &MF, MachineBasicBlock &MBB,
     MachineBasicBlock::iterator MBBI, const DebugLoc &DL, int64_t Amount,
@@ -896,8 +948,16 @@ void RISCVFrameLowering::emitPrologue(MachineFunction &MF,
     RealStackSize = FirstSPAdjustAmount;
   }
 
-  if (RVFI->isPushable(MF) && FirstFrameSetup != MBB.end() &&
-      isPush(FirstFrameSetup->getOpcode())) {
+  if (RVFI->useQCIInterrupt(MF)) {
+    unsigned CFIIndex = MF.addFrameInst(
+        MCCFIInstruction::cfiDefCfaOffset(nullptr, QCIInterruptPushAmount));
+    BuildMI(MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
+        .addCFIIndex(CFIIndex)
+        .setMIFlag(MachineInstr::FrameSetup);
+
+    emitCFIForCSI<CFISaveRegisterEmitter>(MBB, MBBI, getQCISavedInfo(MF, CSI));
+  } else if (RVFI->isPushable(MF) && FirstFrameSetup != MBB.end() &&
+             isPush(FirstFrameSetup->getOpcode())) {
     // Use available stack adjustment in push instruction to allocate additional
     // stack space. Align the stack size down to a multiple of 16. This is
     // needed for RVE.
@@ -1247,7 +1307,7 @@ void RISCVFrameLowering::emitEpilogue(MachineFunction &MF,
 
   // Deallocate stack if StackSize isn't a zero yet
   if (StackSize != 0)
-    deallocateStack(MF, MBB, MBBI, DL, StackSize, 0);
+    deallocateStack(MF, MBB, MBBI, DL, StackSize, RealStackSize - StackSize);
 
   // Emit epilogue for shadow call stack.
   emitSCSEpilogue(MF, MBB, MBBI, DL);
@@ -1737,9 +1797,9 @@ RISCVFrameLowering::getFirstSPAdjustAmount(const MachineFunction &MF) const {
   const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
   uint64_t StackSize = getStackSizeWithRVVPadding(MF);
 
-  // Disable SplitSPAdjust if save-restore libcall is used. The callee-saved
-  // registers will be pushed by the save-restore libcalls, so we don't have to
-  // split the SP adjustment in this case.
+  // Disable SplitSPAdjust if save-restore libcall, push/pop or QCI interrupts
+  // are used. The callee-saved registers will be pushed by the save-restore
+  // libcalls, so we don't have to split the SP adjustment in this case.
   if (RVFI->getReservedSpillsSize())
     return 0;
 
@@ -1807,8 +1867,9 @@ bool RISCVFrameLowering::assignCalleeSavedSpillSlots(
     return true;
 
   auto *RVFI = MF.getInfo<RISCVMachineFunctionInfo>();
-
-  if (RVFI->isPushable(MF)) {
+  if (RVFI->useQCIInterrupt(MF)) {
+    RVFI->setQCIInterruptStackSize(QCIInterruptPushAmount);
+  } else if (RVFI->isPushable(MF)) {
     // Determine how many GPRs we need to push and save it to RVFI.
     unsigned PushedRegNum = getNumPushPopRegs(CSI);
     if (PushedRegNum) {
@@ -1825,8 +1886,20 @@ bool RISCVFrameLowering::assignCalleeSavedSpillSlots(
     const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg);
     unsigned Size = RegInfo->getSpillSize(*RC);
 
-    // This might need a fixed stack slot.
-    if (RVFI->useSaveRestoreLibCalls(MF) || RVFI->isPushable(MF)) {
+    if (RVFI->useQCIInterrupt(MF)) {
+      const auto *FFI = llvm::find_if(FixedCSRFIQCIInterruptMap, [&](auto P) {
+        return P.first == CS.getReg();
+      });
+      if (FFI != std::end(FixedCSRFIQCIInterruptMap)) {
+        int64_t Offset = FFI->second * (int64_t)Size;
+
+        int FrameIdx = MFI.CreateFixedSpillStackObject(Size, Offset);
+        assert(FrameIdx < 0);
+        CS.setFrameIdx(FrameIdx);
+        continue;
+      }
+      // TODO: QCI Interrupt + Push/Pop
+    } else if (RVFI->useSaveRestoreLibCalls(MF) || RVFI->isPushable(MF)) {
       const auto *FII = llvm::find_if(
           FixedCSRFIMap, [&](MCPhysReg P) { return P == CS.getReg(); });
       unsigned RegNum = std::distance(std::begin(FixedCSRFIMap), FII);
@@ -1862,7 +1935,12 @@ bool RISCVFrameLowering::assignCalleeSavedSpillSlots(
       MFI.setStackID(FrameIdx, TargetStackID::ScalableVector);
   }
 
-  if (RVFI->isPushable(MF)) {
+  if (RVFI->useQCIInterrupt(MF)) {
+    // Allocate a fixed object that covers the entire QCI stack allocation,
+    // because there are gaps which are reserved for future use.
+    MFI.CreateFixedSpillStackObject(
+        QCIInterruptPushAmount, -static_cast<int64_t>(QCIInterruptPushAmount));
+  } else if (RVFI->isPushable(MF)) {
     // Allocate a fixed object that covers all the registers that are pushed.
     if (unsigned PushedRegs = RVFI->getRVPushRegs()) {
       int64_t PushedRegsBytes =
@@ -1892,9 +1970,22 @@ bool RISCVFrameLowering::spillCalleeSavedRegisters(
   if (MI != MBB.end() && !MI->isDebugInstr())
     DL = MI->getDebugLoc();
 
-  // Emit CM.PUSH with base SPimm & evaluate Push stack
   RISCVMachineFunctionInfo *RVFI = MF->getInfo<RISCVMachineFunctionInfo>();
-  if (RVFI->isPushable(*MF)) {
+  if (RVFI->useQCIInterrupt(*MF)) {
+    // Emit QC.C.MIENTER(.NEST)
+    BuildMI(
+        MBB, MI, DL,
+        TII.get(RVFI->getInterruptStackKind(*MF) ==
+                        RISCVMachineFunctionInfo::InterruptStackKind::QCINest
+                    ? RISCV::QC_C_MIENTER_NEST
+                    : RISCV::QC_C_MIENTER))
+        .setMIFlag(MachineInstr::FrameSetup);
+
+    for (auto [Reg, _Offset] : FixedCSRFIQCIInterruptMap)
+      MBB.addLiveIn(Reg);
+    // TODO: Handle QCI Interrupt + Push/Pop
+  } else if (RVFI->isPushable(*MF)) {
+    // Emit CM.PUSH with base SPimm & evaluate Push stack
     unsigned PushedRegNum = RVFI->getRVPushRegs();
     if (PushedRegNum > 0) {
       // Use encoded number to represent registers to spill.
@@ -2051,7 +2142,13 @@ bool RISCVFrameLowering::restoreCalleeSavedRegisters(
   loadRegFromStackSlot(UnmanagedCSI);
 
   RISCVMachineFunctionInfo *RVFI = MF->getInfo<RISCVMachineFunctionInfo>();
-  if (RVFI->isPushable(*MF)) {
+  if (RVFI->useQCIInterrupt(*MF)) {
+    // Don't emit anything here because restoration is handled by
+    // QC.C.MILEAVERET which we already inserted to return.
+    assert(MI->getOpcode() == RISCV::QC_C_MILEAVERET &&
+           "Unexpected QCI Interrupt Return Instruction");
+    // TODO: Handle QCI + Push/Pop
+  } else if (RVFI->isPushable(*MF)) {
     unsigned PushedRegNum = RVFI->getRVPushRegs();
     if (PushedRegNum > 0) {
       unsigned Opcode = getPopOpcode(RVFI->getPushPopKind(*MF));
@@ -2116,6 +2213,11 @@ bool RISCVFrameLowering::canUseAsEpilogue(const MachineBasicBlock &MBB) const {
   MachineBasicBlock *TmpMBB = const_cast<MachineBasicBlock *>(&MBB);
   const auto *RVFI = MF->getInfo<RISCVMachineFunctionInfo>();
 
+  // We do not want QC.C.MILEAVERET to be subject to shrink-wrapping - it must
+  // come in the final block of its function as it both pops and returns.
+  if (RVFI->useQCIInterrupt(*MF))
+    return MBB.succ_empty();
+
   if (!RVFI->useSaveRestoreLibCalls(*MF))
     return true;
 
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index e59c0475a0021..36d113a63cd1d 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -20831,9 +20831,20 @@ SDValue RISCVTargetLowering::LowerFormalArguments(
     StringRef Kind =
       MF.getFunction().getFnAttribute("interrupt").getValueAsString();
 
-    if (!(Kind == "supervisor" || Kind == "machine"))
+    constexpr StringLiteral SupportedInterruptKinds[] = {
+        "machine",
+        "supervisor",
+        "qci-nest",
+        "qci-nonest",
+    };
+    if (llvm::find(SupportedInterruptKinds, Kind) ==
+        std::end(SupportedInterruptKinds))
       report_fatal_error(
         "Function interrupt attribute argument not supported!");
+
+    if ((Kind == "qci-nest" || Kind == "qci-nonest") &&
+        !Subtarget.hasVendorXqciint())
+      report_fatal_error("'qci-*' interrupt kinds require Xqciint extension");
   }
 
   EVT PtrVT = getPointerTy(DAG.getDataLayout());
@@ -21462,7 +21473,11 @@ RISCVTargetLowering::LowerReturn(SDValue Chain, CallingConv::ID CallConv,
 
     if (Kind == "supervisor")
       RetOpc = RISCVISD::SRET_GLUE;
-    else
+    else if (Kind == "qci-nest" || Kind == "qci-nonest") {
+      assert(STI.hasFeature(RISCV::FeatureVendorXqciint) &&
+             "Need Xqciint for qci-(no)nest");
+      RetOpc = RISCVISD::QC_C_MILEAVERET_GLUE;
+    } else
       RetOpc = RISCVISD::MRET_GLUE;
   }
 
@@ -21536,6 +21551,7 @@ const char *RISCVTargetLowering::getTargetNodeName(unsigned Opcode) const {
   NODE_NAME_CASE(RET_GLUE)
   NODE_NAME_CASE(SRET_GLUE)
   NODE_NAME_CASE(MRET_GLUE)
+  NODE_NAME_CASE(QC_C_MILEAVERET_GLUE)
   NODE_NAME_CASE(CALL)
   NODE_NAME_CASE(TAIL)
   NODE_NAME_CASE(SELECT_CC)
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.h b/llvm/lib/Target/RISCV/RISCVISelLowering.h
index 26b888653c81d..ffbc14a29006c 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.h
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.h
@@ -33,6 +33,7 @@ enum NodeType : unsigned {
   RET_GLUE,
   SRET_GLUE,
   MRET_GLUE,
+  QC_C_MILEAVERET_GLUE,
   CALL,
   TAIL,
   /// Select with condition operator - This selects between a true value and
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfo.td b/llvm/lib/Target/RISCV/RISCVInstrInfo.td
index a4e420ed8fcf3..5ce826b136832 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfo.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfo.td
@@ -66,6 +66,8 @@ def riscv_sret_glue : SDNode<"RISCVISD::SRET_GLUE", SDTNone,
                              [SDNPHasChain, SDNPOptInGlue]>;
 def riscv_mret_glue : SDNode<"RISCVISD::MRET_GLUE", SDTNone,
                              [SDNPHasChain, SDNPOptInGlue]>;
+def riscv_mileaveret_glue : SDNode<"RISCVISD::QC_C_MILEAVERET_GLUE", SDTNone,
+                                   [SDNPHasChain, SDNPOptInGlue]>;
 def riscv_selectcc  : SDNode<"RISCVISD::SELECT_CC", SDT_RISCVSelectCC>;
 def riscv_brcc      : SDNode<"RISCVISD::BR_CC", SDT_RISCVBrCC,
                              [SDNPHasChain]>;
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td b/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td
index 1f4bd60e7d4c8..0fb635ad1f9e8 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td
@@ -427,8 +427,8 @@ let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
   def QC_MVGEUI  : QCIMVCCI<0b111, "qc.mvgeui", uimm5>;
 } // Predicates = [HasVendorXqcicm, IsRV32]
 
-let Predicates = [HasVendorXqciint, IsRV32] in {
-  let hasSideEffects = 1, mayLoad = 0, mayStore = 0 in
+let Predicates = [HasVendorXqciint, IsRV32], hasSideEffects = 1 in {
+  let mayLoad = 0, mayStore = 0 in {
   def QC_C_DIR : RVInst16CI<0b000, 0b10, (outs GPRNoX0:$rd), (ins),
                             "qc.c.dir", "$rd"> {
     bits<5> rd;
@@ -445,19 +445,22 @@ let Predicates = [HasVendorXqciint, IsRV32] in {
   def QC_C_SETINT : QCIRVInst16CI_RS1<0b00010, "qc.c.setint">;
   def QC_C_CLRINT : QCIRVInst16CI_RS1<0b00011, "qc.c.clrint">;
 
-  let mayLoad = 0, mayStore = 0 in {
   def QC_C_DI     : QCIRVInst16CI_NONE<0b10110, "qc.c.di">;
   def QC_C_EI     : QCIRVInst16CI_NONE<0b10111, "qc.c.ei">;
-  } // mayLoad =0, mayStore = 0
+  } // mayLoad = 0, mayStore = 0
 
-  let mayLoad = 1, mayStore = 1 in {
+  let mayLoad = 0, mayStore = 1,
+    Uses = [X1, X2, X5, X6, X7, X8, X10, X11, X12, X13, X14, X15, X16, X17, X28, X29, X30, X31],
+    Defs = [X2] in {
   def QC_C_MIENTER      : QCIRVInst16CI_NONE<0b10000, "qc.c.mienter">;
   def QC_C_MIENTER_NEST : QCIRVInst16CI_NONE<0b10001, "qc.c.mienter.nest">;
-  } // mayLoad = 1, mayStore = 1
+  } // mayLoad = 1, mayStore = 1, Uses = [...], Defs = [...]
 
-  let mayLoad = 1, mayStore = 1, isReturn = 1, isTerminator = 1 in
+  let mayLoad = 1, mayStore = 0, isBarrier = 1, isReturn = 1, isTerminator = 1,
+    Uses = [X2],
+    Defs = [X1, X2, X5, X6, X7, X8, X10, X11, X12, X13, X14, X15, X16, X17, X28, X29, X30, X31] in
   def QC_C_MILEAVERET   : QCIRVInst16CI_NONE<0b10100, "qc.c.mileaveret">;
-} // Predicates = [HasVendorXqciint, IsRV32]
+} // Predicates = [HasVendorXqciint, IsRV32], hasSideEffects = 1
 
 let Predicates = [HasVendorXqcilo, IsRV32] in {
   def QC_E_LB    : QCIRVInstEILoad<0b101, 0b00, "qc.e.lb">;
@@ -528,3 +531,11 @@ let EmitPriority = 0 in {
                    (QC_E_SW GPR:$rs2, GPR:$rs1, 0)>;
 } // EmitPriority = 0
 } // Predicates = [HasVendorXqcilo, IsRV32]
+
+
+//===----------------------------------------------------------------------===//
+// Code Gen Patterns
+//===----------------------------------------------------------------------===//
+
+let Predicates = [HasVendorXqciint, IsRV32] in
+def : Pat<(riscv_mileaveret_glue), (QC_C_MILEAVERET)>;
diff --git a/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.cpp b/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.cpp
index a4b89a42f3574..a2fdbcc7f4d28 100644
--- a/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.cpp
+++ b/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.cpp
@@ -56,6 +56,25 @@ RISCVMachineFunctionInfo::RISCVMachineFunctionInfo(const Function &F,
   }
 }
 
+RISCVMachineFunctionInfo::InterruptStackKind
+RISCVMachineFunctionInfo::getInterruptStackKind(
+    const MachineFunction &MF) const {
+  if (!MF.getFunction().hasFnAttribute("interrupt"))
+    return InterruptStackKind::None;
+
+  assert(VarArgsSaveSize == 0 &&
+         "Interrupt functions should not having incoming varargs");
+
+  StringRef InterruptVal =
+      MF.getFunction().getFnAttribute("interrupt").getValueAsString();
+  if (InterruptVal == "qci-nest")
+    return InterruptStackKind::QCINest;
+  if (InterruptVal == "qci-nonest")
+    return InterruptStackKind::QCINoNest;
+
+  return InterruptStackKind::None;
+}
+
 void yaml::RISCVMachineFunctionInfo::mappingImpl(yaml::IO &YamlIO) {
   MappingTraits<RISCVMachineFunctionInfo>::mapping(YamlIO, *this);
 }
diff --git a/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.h b/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.h
index 94e9ad2a7e66b..f24355650ab22 100644
--- a/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.h
+++ b/llvm/lib/Target/RISCV/RISCVMachineFunctionInfo.h
@@ -75,6 +75,9 @@ class RISCVMachineFunctionInfo : public MachineFunctionInfo {
   unsigned RVPushStackSize = 0;
   unsigned RVPushRegs = 0;
 
+  /// Size of any opaque stack adjustment due to QCI Interrupt instructions.
+  unsigned QCIInterruptStackSize = 0;
+
   int64_t StackProbeSize = 0;
 
   /// Does it probe the stack for a dynamic allocation?
@@ -109,7 +112,7 @@ class RISCVMachineFunctionInfo : public MachineFunctionInfo {
   }
 
   unsigned getReservedSpillsSize() const {
-    return LibCallStackSize + RVPushStackSize;
+    return LibCallStackSize + RVPushStackSize + QCIInterruptStackSize;
   }
 
   unsigned getLibCallStackSize() const { return LibCallStackSize; }
@@ -150,6 +153,19 @@ class RISCVMachineFunctionInfo : public MachineFunctionInfo {
   unsigned getRVPushStackSize() const { return RVPushStackSize; }
   void setRVPushStackSize(unsigned Size) { RVPushStackSize = Size; }
 
+  enum class InterruptStackKind { None = 0, QCINest, QCINoNest };
+
+  InterruptStackKind getInterruptStackKind(const MachineFunction &MF) const;
+
+  bool useQCIInterrupt(const MachineFunction &MF) const {
+    InterruptStackKind Kind = getInterruptStackKind(MF);
+    return Kind == InterruptStackKind::QCINest ||
+           Kind == InterruptStackKind::QCINoNest;
+  }
+
+  unsigned getQCIInterruptStackSize() const { return QCIInterruptStackSize; }
+  void setQCIInterruptStackSize(unsigned Size) { QCIInterruptStackSize = Size; }
+
   void initializeBaseYamlFields(const yaml::RISCVMachineFunctionInfo &YamlMFI);
 
   void addSExt32Register(Register Reg);
diff --git a/llvm/test/CodeGen/RISCV/qci-interrupt-attr-fpr.ll b/llvm/test/CodeGen/RISCV/qci-interrupt-attr-fpr.ll
new file mode 100644
index 0000000000000..fc737928319b4
--- /dev/null
+++ b/llvm/test/CodeGen/RISCV/qci-interrupt-attr-fpr.ll
@@ -0,0 +1,2821 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+experimental-xqciint,+f -o - %s \
+; RUN:   -verify-machineinstrs | FileCheck --check-prefix=QCI-F %s
+
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+experimental-xqciint,+d -o - %s \
+; RUN:   -verify-machineinstrs | FileCheck --check-prefix=QCI-D %s
+
+;; This tests "interrupt"="qci-nest" and "interrupt"="qci-nonest" frame lowering
+;; including CFI information, and floating point registers. These tests should
+;; all lack `nounwind`.
+;;
+;; When `+save-restore` is enabled, the codegen should be identical as these
+;; calls are incompatible with the interrupt attribute because the restore is
+;; tail-called.
+
+declare void @use_i32(i32)
+
+define void @test_nest_asm() "interrupt"="qci-nest" {
+; QCI-F-LABEL: test_nest_asm:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter.nest
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 176
+; QCI-F-NEXT:    fsw ft0, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft1, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft2, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft3, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft4, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft5, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft6, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft7, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa0, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa1, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa2, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa3, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa4, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa5, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa6, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa7, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft8, 12(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft9, 8(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft10, 4(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft11, 0(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset ft0, -100
+; QCI-F-NEXT:    .cfi_offset ft1, -104
+; QCI-F-NEXT:    .cfi_offset ft2, -108
+; QCI-F-NEXT:    .cfi_offset ft3, -112
+; QCI-F-NEXT:    .cfi_offset ft4, -116
+; QCI-F-NEXT:    .cfi_offset ft5, -120
+; QCI-F-NEXT:    .cfi_offset ft6, -124
+; QCI-F-NEXT:    .cfi_offset ft7, -128
+; QCI-F-NEXT:    .cfi_offset fa0, -132
+; QCI-F-NEXT:    .cfi_offset fa1, -136
+; QCI-F-NEXT:    .cfi_offset fa2, -140
+; QCI-F-NEXT:    .cfi_offset fa3, -144
+; QCI-F-NEXT:    .cfi_offset fa4, -148
+; QCI-F-NEXT:    .cfi_offset fa5, -152
+; QCI-F-NEXT:    .cfi_offset fa6, -156
+; QCI-F-NEXT:    .cfi_offset fa7, -160
+; QCI-F-NEXT:    .cfi_offset ft8, -164
+; QCI-F-NEXT:    .cfi_offset ft9, -168
+; QCI-F-NEXT:    .cfi_offset ft10, -172
+; QCI-F-NEXT:    .cfi_offset ft11, -176
+; QCI-F-NEXT:    li a0, 1
+; QCI-F-NEXT:    #APP
+; QCI-F-NEXT:    # a0 <- a0
+; QCI-F-NEXT:    #NO_APP
+; QCI-F-NEXT:    call use_i32
+; QCI-F-NEXT:    flw ft0, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft1, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft2, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft3, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft4, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft5, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft6, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft7, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa0, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa1, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa2, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa3, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa4, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa5, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa6, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa7, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft8, 12(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft9, 8(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft10, 4(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft11, 0(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore ft0
+; QCI-F-NEXT:    .cfi_restore ft1
+; QCI-F-NEXT:    .cfi_restore ft2
+; QCI-F-NEXT:    .cfi_restore ft3
+; QCI-F-NEXT:    .cfi_restore ft4
+; QCI-F-NEXT:    .cfi_restore ft5
+; QCI-F-NEXT:    .cfi_restore ft6
+; QCI-F-NEXT:    .cfi_restore ft7
+; QCI-F-NEXT:    .cfi_restore fa0
+; QCI-F-NEXT:    .cfi_restore fa1
+; QCI-F-NEXT:    .cfi_restore fa2
+; QCI-F-NEXT:    .cfi_restore fa3
+; QCI-F-NEXT:    .cfi_restore fa4
+; QCI-F-NEXT:    .cfi_restore fa5
+; QCI-F-NEXT:    .cfi_restore fa6
+; QCI-F-NEXT:    .cfi_restore fa7
+; QCI-F-NEXT:    .cfi_restore ft8
+; QCI-F-NEXT:    .cfi_restore ft9
+; QCI-F-NEXT:    .cfi_restore ft10
+; QCI-F-NEXT:    .cfi_restore ft11
+; QCI-F-NEXT:    addi sp, sp, 80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_nest_asm:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter.nest
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -160
+; QCI-D-NEXT:    .cfi_def_cfa_offset 256
+; QCI-D-NEXT:    fsd ft0, 152(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft1, 144(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft2, 136(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft3, 128(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft4, 120(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft5, 112(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft6, 104(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft7, 96(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa0, 88(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa1, 80(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa2, 72(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa3, 64(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa4, 56(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa5, 48(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa6, 40(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa7, 32(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft8, 24(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft9, 16(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft10, 8(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft11, 0(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset ft0, -104
+; QCI-D-NEXT:    .cfi_offset ft1, -112
+; QCI-D-NEXT:    .cfi_offset ft2, -120
+; QCI-D-NEXT:    .cfi_offset ft3, -128
+; QCI-D-NEXT:    .cfi_offset ft4, -136
+; QCI-D-NEXT:    .cfi_offset ft5, -144
+; QCI-D-NEXT:    .cfi_offset ft6, -152
+; QCI-D-NEXT:    .cfi_offset ft7, -160
+; QCI-D-NEXT:    .cfi_offset fa0, -168
+; QCI-D-NEXT:    .cfi_offset fa1, -176
+; QCI-D-NEXT:    .cfi_offset fa2, -184
+; QCI-D-NEXT:    .cfi_offset fa3, -192
+; QCI-D-NEXT:    .cfi_offset fa4, -200
+; QCI-D-NEXT:    .cfi_offset fa5, -208
+; QCI-D-NEXT:    .cfi_offset fa6, -216
+; QCI-D-NEXT:    .cfi_offset fa7, -224
+; QCI-D-NEXT:    .cfi_offset ft8, -232
+; QCI-D-NEXT:    .cfi_offset ft9, -240
+; QCI-D-NEXT:    .cfi_offset ft10, -248
+; QCI-D-NEXT:    .cfi_offset ft11, -256
+; QCI-D-NEXT:    li a0, 1
+; QCI-D-NEXT:    #APP
+; QCI-D-NEXT:    # a0 <- a0
+; QCI-D-NEXT:    #NO_APP
+; QCI-D-NEXT:    call use_i32
+; QCI-D-NEXT:    fld ft0, 152(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft1, 144(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft2, 136(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft3, 128(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft4, 120(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft5, 112(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft6, 104(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft7, 96(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa0, 88(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa1, 80(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa2, 72(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa3, 64(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa4, 56(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa5, 48(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa6, 40(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa7, 32(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft8, 24(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft9, 16(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft10, 8(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft11, 0(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore ft0
+; QCI-D-NEXT:    .cfi_restore ft1
+; QCI-D-NEXT:    .cfi_restore ft2
+; QCI-D-NEXT:    .cfi_restore ft3
+; QCI-D-NEXT:    .cfi_restore ft4
+; QCI-D-NEXT:    .cfi_restore ft5
+; QCI-D-NEXT:    .cfi_restore ft6
+; QCI-D-NEXT:    .cfi_restore ft7
+; QCI-D-NEXT:    .cfi_restore fa0
+; QCI-D-NEXT:    .cfi_restore fa1
+; QCI-D-NEXT:    .cfi_restore fa2
+; QCI-D-NEXT:    .cfi_restore fa3
+; QCI-D-NEXT:    .cfi_restore fa4
+; QCI-D-NEXT:    .cfi_restore fa5
+; QCI-D-NEXT:    .cfi_restore fa6
+; QCI-D-NEXT:    .cfi_restore fa7
+; QCI-D-NEXT:    .cfi_restore ft8
+; QCI-D-NEXT:    .cfi_restore ft9
+; QCI-D-NEXT:    .cfi_restore ft10
+; QCI-D-NEXT:    .cfi_restore ft11
+; QCI-D-NEXT:    addi sp, sp, 160
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = call i32 asm sideeffect "/* $0 <- $1 */", "=r,r"(i32 1)
+  call void @use_i32(i32 %1)
+  ret void
+}
+
+define void @test_nonest_asm() "interrupt"="qci-nonest" {
+; QCI-F-LABEL: test_nonest_asm:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 176
+; QCI-F-NEXT:    fsw ft0, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft1, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft2, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft3, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft4, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft5, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft6, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft7, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa0, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa1, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa2, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa3, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa4, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa5, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa6, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa7, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft8, 12(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft9, 8(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft10, 4(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft11, 0(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset ft0, -100
+; QCI-F-NEXT:    .cfi_offset ft1, -104
+; QCI-F-NEXT:    .cfi_offset ft2, -108
+; QCI-F-NEXT:    .cfi_offset ft3, -112
+; QCI-F-NEXT:    .cfi_offset ft4, -116
+; QCI-F-NEXT:    .cfi_offset ft5, -120
+; QCI-F-NEXT:    .cfi_offset ft6, -124
+; QCI-F-NEXT:    .cfi_offset ft7, -128
+; QCI-F-NEXT:    .cfi_offset fa0, -132
+; QCI-F-NEXT:    .cfi_offset fa1, -136
+; QCI-F-NEXT:    .cfi_offset fa2, -140
+; QCI-F-NEXT:    .cfi_offset fa3, -144
+; QCI-F-NEXT:    .cfi_offset fa4, -148
+; QCI-F-NEXT:    .cfi_offset fa5, -152
+; QCI-F-NEXT:    .cfi_offset fa6, -156
+; QCI-F-NEXT:    .cfi_offset fa7, -160
+; QCI-F-NEXT:    .cfi_offset ft8, -164
+; QCI-F-NEXT:    .cfi_offset ft9, -168
+; QCI-F-NEXT:    .cfi_offset ft10, -172
+; QCI-F-NEXT:    .cfi_offset ft11, -176
+; QCI-F-NEXT:    li a0, 1
+; QCI-F-NEXT:    #APP
+; QCI-F-NEXT:    # a0 <- a0
+; QCI-F-NEXT:    #NO_APP
+; QCI-F-NEXT:    call use_i32
+; QCI-F-NEXT:    flw ft0, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft1, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft2, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft3, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft4, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft5, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft6, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft7, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa0, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa1, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa2, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa3, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa4, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa5, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa6, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa7, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft8, 12(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft9, 8(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft10, 4(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft11, 0(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore ft0
+; QCI-F-NEXT:    .cfi_restore ft1
+; QCI-F-NEXT:    .cfi_restore ft2
+; QCI-F-NEXT:    .cfi_restore ft3
+; QCI-F-NEXT:    .cfi_restore ft4
+; QCI-F-NEXT:    .cfi_restore ft5
+; QCI-F-NEXT:    .cfi_restore ft6
+; QCI-F-NEXT:    .cfi_restore ft7
+; QCI-F-NEXT:    .cfi_restore fa0
+; QCI-F-NEXT:    .cfi_restore fa1
+; QCI-F-NEXT:    .cfi_restore fa2
+; QCI-F-NEXT:    .cfi_restore fa3
+; QCI-F-NEXT:    .cfi_restore fa4
+; QCI-F-NEXT:    .cfi_restore fa5
+; QCI-F-NEXT:    .cfi_restore fa6
+; QCI-F-NEXT:    .cfi_restore fa7
+; QCI-F-NEXT:    .cfi_restore ft8
+; QCI-F-NEXT:    .cfi_restore ft9
+; QCI-F-NEXT:    .cfi_restore ft10
+; QCI-F-NEXT:    .cfi_restore ft11
+; QCI-F-NEXT:    addi sp, sp, 80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_nonest_asm:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -160
+; QCI-D-NEXT:    .cfi_def_cfa_offset 256
+; QCI-D-NEXT:    fsd ft0, 152(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft1, 144(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft2, 136(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft3, 128(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft4, 120(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft5, 112(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft6, 104(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft7, 96(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa0, 88(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa1, 80(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa2, 72(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa3, 64(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa4, 56(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa5, 48(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa6, 40(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa7, 32(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft8, 24(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft9, 16(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft10, 8(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft11, 0(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset ft0, -104
+; QCI-D-NEXT:    .cfi_offset ft1, -112
+; QCI-D-NEXT:    .cfi_offset ft2, -120
+; QCI-D-NEXT:    .cfi_offset ft3, -128
+; QCI-D-NEXT:    .cfi_offset ft4, -136
+; QCI-D-NEXT:    .cfi_offset ft5, -144
+; QCI-D-NEXT:    .cfi_offset ft6, -152
+; QCI-D-NEXT:    .cfi_offset ft7, -160
+; QCI-D-NEXT:    .cfi_offset fa0, -168
+; QCI-D-NEXT:    .cfi_offset fa1, -176
+; QCI-D-NEXT:    .cfi_offset fa2, -184
+; QCI-D-NEXT:    .cfi_offset fa3, -192
+; QCI-D-NEXT:    .cfi_offset fa4, -200
+; QCI-D-NEXT:    .cfi_offset fa5, -208
+; QCI-D-NEXT:    .cfi_offset fa6, -216
+; QCI-D-NEXT:    .cfi_offset fa7, -224
+; QCI-D-NEXT:    .cfi_offset ft8, -232
+; QCI-D-NEXT:    .cfi_offset ft9, -240
+; QCI-D-NEXT:    .cfi_offset ft10, -248
+; QCI-D-NEXT:    .cfi_offset ft11, -256
+; QCI-D-NEXT:    li a0, 1
+; QCI-D-NEXT:    #APP
+; QCI-D-NEXT:    # a0 <- a0
+; QCI-D-NEXT:    #NO_APP
+; QCI-D-NEXT:    call use_i32
+; QCI-D-NEXT:    fld ft0, 152(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft1, 144(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft2, 136(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft3, 128(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft4, 120(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft5, 112(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft6, 104(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft7, 96(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa0, 88(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa1, 80(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa2, 72(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa3, 64(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa4, 56(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa5, 48(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa6, 40(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa7, 32(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft8, 24(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft9, 16(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft10, 8(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft11, 0(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore ft0
+; QCI-D-NEXT:    .cfi_restore ft1
+; QCI-D-NEXT:    .cfi_restore ft2
+; QCI-D-NEXT:    .cfi_restore ft3
+; QCI-D-NEXT:    .cfi_restore ft4
+; QCI-D-NEXT:    .cfi_restore ft5
+; QCI-D-NEXT:    .cfi_restore ft6
+; QCI-D-NEXT:    .cfi_restore ft7
+; QCI-D-NEXT:    .cfi_restore fa0
+; QCI-D-NEXT:    .cfi_restore fa1
+; QCI-D-NEXT:    .cfi_restore fa2
+; QCI-D-NEXT:    .cfi_restore fa3
+; QCI-D-NEXT:    .cfi_restore fa4
+; QCI-D-NEXT:    .cfi_restore fa5
+; QCI-D-NEXT:    .cfi_restore fa6
+; QCI-D-NEXT:    .cfi_restore fa7
+; QCI-D-NEXT:    .cfi_restore ft8
+; QCI-D-NEXT:    .cfi_restore ft9
+; QCI-D-NEXT:    .cfi_restore ft10
+; QCI-D-NEXT:    .cfi_restore ft11
+; QCI-D-NEXT:    addi sp, sp, 160
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = call i32 asm sideeffect "/* $0 <- $1 */", "=r,r"(i32 1)
+  call void @use_i32(i32 %1)
+  ret void
+}
+
+declare float @function_with_one_stack_arg(i64, i64, i64, i64, float, float, float, float, float, float, float, float, i32, float)
+declare void @use_float(float)
+
+define void @test_nest_call() "interrupt"="qci-nest" {
+; QCI-F-LABEL: test_nest_call:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter.nest
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -96
+; QCI-F-NEXT:    .cfi_def_cfa_offset 192
+; QCI-F-NEXT:    fsw ft0, 92(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft1, 88(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft2, 84(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft3, 80(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft4, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft5, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft6, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft7, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa0, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa1, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa2, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa3, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa4, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa5, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa6, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa7, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft8, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft9, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft10, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft11, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset ft0, -100
+; QCI-F-NEXT:    .cfi_offset ft1, -104
+; QCI-F-NEXT:    .cfi_offset ft2, -108
+; QCI-F-NEXT:    .cfi_offset ft3, -112
+; QCI-F-NEXT:    .cfi_offset ft4, -116
+; QCI-F-NEXT:    .cfi_offset ft5, -120
+; QCI-F-NEXT:    .cfi_offset ft6, -124
+; QCI-F-NEXT:    .cfi_offset ft7, -128
+; QCI-F-NEXT:    .cfi_offset fa0, -132
+; QCI-F-NEXT:    .cfi_offset fa1, -136
+; QCI-F-NEXT:    .cfi_offset fa2, -140
+; QCI-F-NEXT:    .cfi_offset fa3, -144
+; QCI-F-NEXT:    .cfi_offset fa4, -148
+; QCI-F-NEXT:    .cfi_offset fa5, -152
+; QCI-F-NEXT:    .cfi_offset fa6, -156
+; QCI-F-NEXT:    .cfi_offset fa7, -160
+; QCI-F-NEXT:    .cfi_offset ft8, -164
+; QCI-F-NEXT:    .cfi_offset ft9, -168
+; QCI-F-NEXT:    .cfi_offset ft10, -172
+; QCI-F-NEXT:    .cfi_offset ft11, -176
+; QCI-F-NEXT:    lui a7, 266496
+; QCI-F-NEXT:    li t0, 5
+; QCI-F-NEXT:    lui a0, 260096
+; QCI-F-NEXT:    lui a2, 262144
+; QCI-F-NEXT:    lui a4, 263168
+; QCI-F-NEXT:    lui a5, 264192
+; QCI-F-NEXT:    lui a1, 264704
+; QCI-F-NEXT:    lui a6, 265216
+; QCI-F-NEXT:    fmv.w.x fa0, a0
+; QCI-F-NEXT:    lui t1, 265728
+; QCI-F-NEXT:    fmv.w.x fa1, a2
+; QCI-F-NEXT:    lui a3, 266240
+; QCI-F-NEXT:    fmv.w.x fa2, a4
+; QCI-F-NEXT:    li a0, 1
+; QCI-F-NEXT:    fmv.w.x fa3, a5
+; QCI-F-NEXT:    li a2, 2
+; QCI-F-NEXT:    fmv.w.x fa4, a1
+; QCI-F-NEXT:    li a4, 3
+; QCI-F-NEXT:    fmv.w.x fa5, a6
+; QCI-F-NEXT:    li a6, 4
+; QCI-F-NEXT:    fmv.w.x fa6, t1
+; QCI-F-NEXT:    fmv.w.x fa7, a3
+; QCI-F-NEXT:    sw t0, 0(sp)
+; QCI-F-NEXT:    sw a7, 4(sp)
+; QCI-F-NEXT:    li a1, 0
+; QCI-F-NEXT:    li a3, 0
+; QCI-F-NEXT:    li a5, 0
+; QCI-F-NEXT:    li a7, 0
+; QCI-F-NEXT:    call function_with_one_stack_arg
+; QCI-F-NEXT:    call use_float
+; QCI-F-NEXT:    flw ft0, 92(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft1, 88(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft2, 84(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft3, 80(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft4, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft5, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft6, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft7, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa0, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa1, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa2, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa3, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa4, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa5, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa6, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa7, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft8, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft9, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft10, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft11, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore ft0
+; QCI-F-NEXT:    .cfi_restore ft1
+; QCI-F-NEXT:    .cfi_restore ft2
+; QCI-F-NEXT:    .cfi_restore ft3
+; QCI-F-NEXT:    .cfi_restore ft4
+; QCI-F-NEXT:    .cfi_restore ft5
+; QCI-F-NEXT:    .cfi_restore ft6
+; QCI-F-NEXT:    .cfi_restore ft7
+; QCI-F-NEXT:    .cfi_restore fa0
+; QCI-F-NEXT:    .cfi_restore fa1
+; QCI-F-NEXT:    .cfi_restore fa2
+; QCI-F-NEXT:    .cfi_restore fa3
+; QCI-F-NEXT:    .cfi_restore fa4
+; QCI-F-NEXT:    .cfi_restore fa5
+; QCI-F-NEXT:    .cfi_restore fa6
+; QCI-F-NEXT:    .cfi_restore fa7
+; QCI-F-NEXT:    .cfi_restore ft8
+; QCI-F-NEXT:    .cfi_restore ft9
+; QCI-F-NEXT:    .cfi_restore ft10
+; QCI-F-NEXT:    .cfi_restore ft11
+; QCI-F-NEXT:    addi sp, sp, 96
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_nest_call:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter.nest
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -176
+; QCI-D-NEXT:    .cfi_def_cfa_offset 272
+; QCI-D-NEXT:    fsd ft0, 168(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft1, 160(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft2, 152(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft3, 144(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft4, 136(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft5, 128(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft6, 120(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft7, 112(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa0, 104(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa1, 96(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa2, 88(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa3, 80(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa4, 72(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa5, 64(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa6, 56(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa7, 48(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft8, 40(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft9, 32(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft10, 24(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft11, 16(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset ft0, -104
+; QCI-D-NEXT:    .cfi_offset ft1, -112
+; QCI-D-NEXT:    .cfi_offset ft2, -120
+; QCI-D-NEXT:    .cfi_offset ft3, -128
+; QCI-D-NEXT:    .cfi_offset ft4, -136
+; QCI-D-NEXT:    .cfi_offset ft5, -144
+; QCI-D-NEXT:    .cfi_offset ft6, -152
+; QCI-D-NEXT:    .cfi_offset ft7, -160
+; QCI-D-NEXT:    .cfi_offset fa0, -168
+; QCI-D-NEXT:    .cfi_offset fa1, -176
+; QCI-D-NEXT:    .cfi_offset fa2, -184
+; QCI-D-NEXT:    .cfi_offset fa3, -192
+; QCI-D-NEXT:    .cfi_offset fa4, -200
+; QCI-D-NEXT:    .cfi_offset fa5, -208
+; QCI-D-NEXT:    .cfi_offset fa6, -216
+; QCI-D-NEXT:    .cfi_offset fa7, -224
+; QCI-D-NEXT:    .cfi_offset ft8, -232
+; QCI-D-NEXT:    .cfi_offset ft9, -240
+; QCI-D-NEXT:    .cfi_offset ft10, -248
+; QCI-D-NEXT:    .cfi_offset ft11, -256
+; QCI-D-NEXT:    lui a7, 266496
+; QCI-D-NEXT:    li t0, 5
+; QCI-D-NEXT:    lui a0, 260096
+; QCI-D-NEXT:    lui a2, 262144
+; QCI-D-NEXT:    lui a4, 263168
+; QCI-D-NEXT:    lui a5, 264192
+; QCI-D-NEXT:    lui a1, 264704
+; QCI-D-NEXT:    lui a6, 265216
+; QCI-D-NEXT:    fmv.w.x fa0, a0
+; QCI-D-NEXT:    lui t1, 265728
+; QCI-D-NEXT:    fmv.w.x fa1, a2
+; QCI-D-NEXT:    lui a3, 266240
+; QCI-D-NEXT:    fmv.w.x fa2, a4
+; QCI-D-NEXT:    li a0, 1
+; QCI-D-NEXT:    fmv.w.x fa3, a5
+; QCI-D-NEXT:    li a2, 2
+; QCI-D-NEXT:    fmv.w.x fa4, a1
+; QCI-D-NEXT:    li a4, 3
+; QCI-D-NEXT:    fmv.w.x fa5, a6
+; QCI-D-NEXT:    li a6, 4
+; QCI-D-NEXT:    fmv.w.x fa6, t1
+; QCI-D-NEXT:    fmv.w.x fa7, a3
+; QCI-D-NEXT:    sw t0, 0(sp)
+; QCI-D-NEXT:    sw a7, 4(sp)
+; QCI-D-NEXT:    li a1, 0
+; QCI-D-NEXT:    li a3, 0
+; QCI-D-NEXT:    li a5, 0
+; QCI-D-NEXT:    li a7, 0
+; QCI-D-NEXT:    call function_with_one_stack_arg
+; QCI-D-NEXT:    call use_float
+; QCI-D-NEXT:    fld ft0, 168(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft1, 160(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft2, 152(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft3, 144(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft4, 136(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft5, 128(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft6, 120(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft7, 112(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa0, 104(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa1, 96(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa2, 88(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa3, 80(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa4, 72(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa5, 64(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa6, 56(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa7, 48(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft8, 40(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft9, 32(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft10, 24(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft11, 16(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore ft0
+; QCI-D-NEXT:    .cfi_restore ft1
+; QCI-D-NEXT:    .cfi_restore ft2
+; QCI-D-NEXT:    .cfi_restore ft3
+; QCI-D-NEXT:    .cfi_restore ft4
+; QCI-D-NEXT:    .cfi_restore ft5
+; QCI-D-NEXT:    .cfi_restore ft6
+; QCI-D-NEXT:    .cfi_restore ft7
+; QCI-D-NEXT:    .cfi_restore fa0
+; QCI-D-NEXT:    .cfi_restore fa1
+; QCI-D-NEXT:    .cfi_restore fa2
+; QCI-D-NEXT:    .cfi_restore fa3
+; QCI-D-NEXT:    .cfi_restore fa4
+; QCI-D-NEXT:    .cfi_restore fa5
+; QCI-D-NEXT:    .cfi_restore fa6
+; QCI-D-NEXT:    .cfi_restore fa7
+; QCI-D-NEXT:    .cfi_restore ft8
+; QCI-D-NEXT:    .cfi_restore ft9
+; QCI-D-NEXT:    .cfi_restore ft10
+; QCI-D-NEXT:    .cfi_restore ft11
+; QCI-D-NEXT:    addi sp, sp, 176
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = call float @function_with_one_stack_arg(i64 1, i64 2, i64 3, i64 4, float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, i32 5, float 9.0)
+  call void @use_float(float %1)
+  ret void
+}
+
+define void @test_nonest_call() "interrupt"="qci-nonest" {
+; QCI-F-LABEL: test_nonest_call:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -96
+; QCI-F-NEXT:    .cfi_def_cfa_offset 192
+; QCI-F-NEXT:    fsw ft0, 92(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft1, 88(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft2, 84(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft3, 80(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft4, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft5, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft6, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft7, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa0, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa1, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa2, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa3, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa4, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa5, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa6, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa7, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft8, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft9, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft10, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft11, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset ft0, -100
+; QCI-F-NEXT:    .cfi_offset ft1, -104
+; QCI-F-NEXT:    .cfi_offset ft2, -108
+; QCI-F-NEXT:    .cfi_offset ft3, -112
+; QCI-F-NEXT:    .cfi_offset ft4, -116
+; QCI-F-NEXT:    .cfi_offset ft5, -120
+; QCI-F-NEXT:    .cfi_offset ft6, -124
+; QCI-F-NEXT:    .cfi_offset ft7, -128
+; QCI-F-NEXT:    .cfi_offset fa0, -132
+; QCI-F-NEXT:    .cfi_offset fa1, -136
+; QCI-F-NEXT:    .cfi_offset fa2, -140
+; QCI-F-NEXT:    .cfi_offset fa3, -144
+; QCI-F-NEXT:    .cfi_offset fa4, -148
+; QCI-F-NEXT:    .cfi_offset fa5, -152
+; QCI-F-NEXT:    .cfi_offset fa6, -156
+; QCI-F-NEXT:    .cfi_offset fa7, -160
+; QCI-F-NEXT:    .cfi_offset ft8, -164
+; QCI-F-NEXT:    .cfi_offset ft9, -168
+; QCI-F-NEXT:    .cfi_offset ft10, -172
+; QCI-F-NEXT:    .cfi_offset ft11, -176
+; QCI-F-NEXT:    lui a7, 266496
+; QCI-F-NEXT:    li t0, 5
+; QCI-F-NEXT:    lui a0, 260096
+; QCI-F-NEXT:    lui a2, 262144
+; QCI-F-NEXT:    lui a4, 263168
+; QCI-F-NEXT:    lui a5, 264192
+; QCI-F-NEXT:    lui a1, 264704
+; QCI-F-NEXT:    lui a6, 265216
+; QCI-F-NEXT:    fmv.w.x fa0, a0
+; QCI-F-NEXT:    lui t1, 265728
+; QCI-F-NEXT:    fmv.w.x fa1, a2
+; QCI-F-NEXT:    lui a3, 266240
+; QCI-F-NEXT:    fmv.w.x fa2, a4
+; QCI-F-NEXT:    li a0, 1
+; QCI-F-NEXT:    fmv.w.x fa3, a5
+; QCI-F-NEXT:    li a2, 2
+; QCI-F-NEXT:    fmv.w.x fa4, a1
+; QCI-F-NEXT:    li a4, 3
+; QCI-F-NEXT:    fmv.w.x fa5, a6
+; QCI-F-NEXT:    li a6, 4
+; QCI-F-NEXT:    fmv.w.x fa6, t1
+; QCI-F-NEXT:    fmv.w.x fa7, a3
+; QCI-F-NEXT:    sw t0, 0(sp)
+; QCI-F-NEXT:    sw a7, 4(sp)
+; QCI-F-NEXT:    li a1, 0
+; QCI-F-NEXT:    li a3, 0
+; QCI-F-NEXT:    li a5, 0
+; QCI-F-NEXT:    li a7, 0
+; QCI-F-NEXT:    call function_with_one_stack_arg
+; QCI-F-NEXT:    call use_float
+; QCI-F-NEXT:    flw ft0, 92(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft1, 88(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft2, 84(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft3, 80(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft4, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft5, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft6, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft7, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa0, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa1, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa2, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa3, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa4, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa5, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa6, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa7, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft8, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft9, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft10, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft11, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore ft0
+; QCI-F-NEXT:    .cfi_restore ft1
+; QCI-F-NEXT:    .cfi_restore ft2
+; QCI-F-NEXT:    .cfi_restore ft3
+; QCI-F-NEXT:    .cfi_restore ft4
+; QCI-F-NEXT:    .cfi_restore ft5
+; QCI-F-NEXT:    .cfi_restore ft6
+; QCI-F-NEXT:    .cfi_restore ft7
+; QCI-F-NEXT:    .cfi_restore fa0
+; QCI-F-NEXT:    .cfi_restore fa1
+; QCI-F-NEXT:    .cfi_restore fa2
+; QCI-F-NEXT:    .cfi_restore fa3
+; QCI-F-NEXT:    .cfi_restore fa4
+; QCI-F-NEXT:    .cfi_restore fa5
+; QCI-F-NEXT:    .cfi_restore fa6
+; QCI-F-NEXT:    .cfi_restore fa7
+; QCI-F-NEXT:    .cfi_restore ft8
+; QCI-F-NEXT:    .cfi_restore ft9
+; QCI-F-NEXT:    .cfi_restore ft10
+; QCI-F-NEXT:    .cfi_restore ft11
+; QCI-F-NEXT:    addi sp, sp, 96
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_nonest_call:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -176
+; QCI-D-NEXT:    .cfi_def_cfa_offset 272
+; QCI-D-NEXT:    fsd ft0, 168(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft1, 160(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft2, 152(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft3, 144(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft4, 136(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft5, 128(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft6, 120(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft7, 112(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa0, 104(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa1, 96(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa2, 88(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa3, 80(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa4, 72(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa5, 64(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa6, 56(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa7, 48(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft8, 40(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft9, 32(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft10, 24(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft11, 16(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset ft0, -104
+; QCI-D-NEXT:    .cfi_offset ft1, -112
+; QCI-D-NEXT:    .cfi_offset ft2, -120
+; QCI-D-NEXT:    .cfi_offset ft3, -128
+; QCI-D-NEXT:    .cfi_offset ft4, -136
+; QCI-D-NEXT:    .cfi_offset ft5, -144
+; QCI-D-NEXT:    .cfi_offset ft6, -152
+; QCI-D-NEXT:    .cfi_offset ft7, -160
+; QCI-D-NEXT:    .cfi_offset fa0, -168
+; QCI-D-NEXT:    .cfi_offset fa1, -176
+; QCI-D-NEXT:    .cfi_offset fa2, -184
+; QCI-D-NEXT:    .cfi_offset fa3, -192
+; QCI-D-NEXT:    .cfi_offset fa4, -200
+; QCI-D-NEXT:    .cfi_offset fa5, -208
+; QCI-D-NEXT:    .cfi_offset fa6, -216
+; QCI-D-NEXT:    .cfi_offset fa7, -224
+; QCI-D-NEXT:    .cfi_offset ft8, -232
+; QCI-D-NEXT:    .cfi_offset ft9, -240
+; QCI-D-NEXT:    .cfi_offset ft10, -248
+; QCI-D-NEXT:    .cfi_offset ft11, -256
+; QCI-D-NEXT:    lui a7, 266496
+; QCI-D-NEXT:    li t0, 5
+; QCI-D-NEXT:    lui a0, 260096
+; QCI-D-NEXT:    lui a2, 262144
+; QCI-D-NEXT:    lui a4, 263168
+; QCI-D-NEXT:    lui a5, 264192
+; QCI-D-NEXT:    lui a1, 264704
+; QCI-D-NEXT:    lui a6, 265216
+; QCI-D-NEXT:    fmv.w.x fa0, a0
+; QCI-D-NEXT:    lui t1, 265728
+; QCI-D-NEXT:    fmv.w.x fa1, a2
+; QCI-D-NEXT:    lui a3, 266240
+; QCI-D-NEXT:    fmv.w.x fa2, a4
+; QCI-D-NEXT:    li a0, 1
+; QCI-D-NEXT:    fmv.w.x fa3, a5
+; QCI-D-NEXT:    li a2, 2
+; QCI-D-NEXT:    fmv.w.x fa4, a1
+; QCI-D-NEXT:    li a4, 3
+; QCI-D-NEXT:    fmv.w.x fa5, a6
+; QCI-D-NEXT:    li a6, 4
+; QCI-D-NEXT:    fmv.w.x fa6, t1
+; QCI-D-NEXT:    fmv.w.x fa7, a3
+; QCI-D-NEXT:    sw t0, 0(sp)
+; QCI-D-NEXT:    sw a7, 4(sp)
+; QCI-D-NEXT:    li a1, 0
+; QCI-D-NEXT:    li a3, 0
+; QCI-D-NEXT:    li a5, 0
+; QCI-D-NEXT:    li a7, 0
+; QCI-D-NEXT:    call function_with_one_stack_arg
+; QCI-D-NEXT:    call use_float
+; QCI-D-NEXT:    fld ft0, 168(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft1, 160(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft2, 152(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft3, 144(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft4, 136(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft5, 128(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft6, 120(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft7, 112(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa0, 104(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa1, 96(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa2, 88(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa3, 80(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa4, 72(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa5, 64(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa6, 56(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa7, 48(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft8, 40(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft9, 32(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft10, 24(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft11, 16(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore ft0
+; QCI-D-NEXT:    .cfi_restore ft1
+; QCI-D-NEXT:    .cfi_restore ft2
+; QCI-D-NEXT:    .cfi_restore ft3
+; QCI-D-NEXT:    .cfi_restore ft4
+; QCI-D-NEXT:    .cfi_restore ft5
+; QCI-D-NEXT:    .cfi_restore ft6
+; QCI-D-NEXT:    .cfi_restore ft7
+; QCI-D-NEXT:    .cfi_restore fa0
+; QCI-D-NEXT:    .cfi_restore fa1
+; QCI-D-NEXT:    .cfi_restore fa2
+; QCI-D-NEXT:    .cfi_restore fa3
+; QCI-D-NEXT:    .cfi_restore fa4
+; QCI-D-NEXT:    .cfi_restore fa5
+; QCI-D-NEXT:    .cfi_restore fa6
+; QCI-D-NEXT:    .cfi_restore fa7
+; QCI-D-NEXT:    .cfi_restore ft8
+; QCI-D-NEXT:    .cfi_restore ft9
+; QCI-D-NEXT:    .cfi_restore ft10
+; QCI-D-NEXT:    .cfi_restore ft11
+; QCI-D-NEXT:    addi sp, sp, 176
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = call float @function_with_one_stack_arg(i64 1, i64 2, i64 3, i64 4, float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, i32 5, float 9.0)
+  call void @use_float(float %1)
+  ret void
+}
+
+@var = global [32 x i32] zeroinitializer
+
+define void @test_spill_nest() "interrupt"="qci-nest" {
+; QCI-F-LABEL: test_spill_nest:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter.nest
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 176
+; QCI-F-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset s1, -100
+; QCI-F-NEXT:    .cfi_offset s2, -104
+; QCI-F-NEXT:    .cfi_offset s3, -108
+; QCI-F-NEXT:    .cfi_offset s4, -112
+; QCI-F-NEXT:    .cfi_offset s5, -116
+; QCI-F-NEXT:    .cfi_offset s6, -120
+; QCI-F-NEXT:    .cfi_offset s7, -124
+; QCI-F-NEXT:    .cfi_offset s8, -128
+; QCI-F-NEXT:    .cfi_offset s9, -132
+; QCI-F-NEXT:    .cfi_offset s10, -136
+; QCI-F-NEXT:    .cfi_offset s11, -140
+; QCI-F-NEXT:    lui t0, %hi(var)
+; QCI-F-NEXT:    lw a0, %lo(var)(t0)
+; QCI-F-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-F-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-F-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-F-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    addi a5, t0, %lo(var)
+; QCI-F-NEXT:    lw a0, 16(a5)
+; QCI-F-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 20(a5)
+; QCI-F-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw t4, 24(a5)
+; QCI-F-NEXT:    lw t5, 28(a5)
+; QCI-F-NEXT:    lw t6, 32(a5)
+; QCI-F-NEXT:    lw s2, 36(a5)
+; QCI-F-NEXT:    lw s3, 40(a5)
+; QCI-F-NEXT:    lw s4, 44(a5)
+; QCI-F-NEXT:    lw s5, 48(a5)
+; QCI-F-NEXT:    lw s6, 52(a5)
+; QCI-F-NEXT:    lw s7, 56(a5)
+; QCI-F-NEXT:    lw s8, 60(a5)
+; QCI-F-NEXT:    lw s9, 64(a5)
+; QCI-F-NEXT:    lw s10, 68(a5)
+; QCI-F-NEXT:    lw s11, 72(a5)
+; QCI-F-NEXT:    lw ra, 76(a5)
+; QCI-F-NEXT:    lw s1, 80(a5)
+; QCI-F-NEXT:    lw t3, 84(a5)
+; QCI-F-NEXT:    lw t2, 88(a5)
+; QCI-F-NEXT:    lw t1, 92(a5)
+; QCI-F-NEXT:    lw a7, 112(a5)
+; QCI-F-NEXT:    lw s0, 116(a5)
+; QCI-F-NEXT:    lw a3, 120(a5)
+; QCI-F-NEXT:    lw a0, 124(a5)
+; QCI-F-NEXT:    lw a6, 96(a5)
+; QCI-F-NEXT:    lw a4, 100(a5)
+; QCI-F-NEXT:    lw a2, 104(a5)
+; QCI-F-NEXT:    lw a1, 108(a5)
+; QCI-F-NEXT:    sw a0, 124(a5)
+; QCI-F-NEXT:    sw a3, 120(a5)
+; QCI-F-NEXT:    sw s0, 116(a5)
+; QCI-F-NEXT:    sw a7, 112(a5)
+; QCI-F-NEXT:    sw a1, 108(a5)
+; QCI-F-NEXT:    sw a2, 104(a5)
+; QCI-F-NEXT:    sw a4, 100(a5)
+; QCI-F-NEXT:    sw a6, 96(a5)
+; QCI-F-NEXT:    sw t1, 92(a5)
+; QCI-F-NEXT:    sw t2, 88(a5)
+; QCI-F-NEXT:    sw t3, 84(a5)
+; QCI-F-NEXT:    sw s1, 80(a5)
+; QCI-F-NEXT:    sw ra, 76(a5)
+; QCI-F-NEXT:    sw s11, 72(a5)
+; QCI-F-NEXT:    sw s10, 68(a5)
+; QCI-F-NEXT:    sw s9, 64(a5)
+; QCI-F-NEXT:    sw s8, 60(a5)
+; QCI-F-NEXT:    sw s7, 56(a5)
+; QCI-F-NEXT:    sw s6, 52(a5)
+; QCI-F-NEXT:    sw s5, 48(a5)
+; QCI-F-NEXT:    sw s4, 44(a5)
+; QCI-F-NEXT:    sw s3, 40(a5)
+; QCI-F-NEXT:    sw s2, 36(a5)
+; QCI-F-NEXT:    sw t6, 32(a5)
+; QCI-F-NEXT:    sw t5, 28(a5)
+; QCI-F-NEXT:    sw t4, 24(a5)
+; QCI-F-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 20(a5)
+; QCI-F-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 16(a5)
+; QCI-F-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-F-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-F-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-F-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var)(t0)
+; QCI-F-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore s1
+; QCI-F-NEXT:    .cfi_restore s2
+; QCI-F-NEXT:    .cfi_restore s3
+; QCI-F-NEXT:    .cfi_restore s4
+; QCI-F-NEXT:    .cfi_restore s5
+; QCI-F-NEXT:    .cfi_restore s6
+; QCI-F-NEXT:    .cfi_restore s7
+; QCI-F-NEXT:    .cfi_restore s8
+; QCI-F-NEXT:    .cfi_restore s9
+; QCI-F-NEXT:    .cfi_restore s10
+; QCI-F-NEXT:    .cfi_restore s11
+; QCI-F-NEXT:    addi sp, sp, 80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_spill_nest:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter.nest
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -80
+; QCI-D-NEXT:    .cfi_def_cfa_offset 176
+; QCI-D-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset s1, -100
+; QCI-D-NEXT:    .cfi_offset s2, -104
+; QCI-D-NEXT:    .cfi_offset s3, -108
+; QCI-D-NEXT:    .cfi_offset s4, -112
+; QCI-D-NEXT:    .cfi_offset s5, -116
+; QCI-D-NEXT:    .cfi_offset s6, -120
+; QCI-D-NEXT:    .cfi_offset s7, -124
+; QCI-D-NEXT:    .cfi_offset s8, -128
+; QCI-D-NEXT:    .cfi_offset s9, -132
+; QCI-D-NEXT:    .cfi_offset s10, -136
+; QCI-D-NEXT:    .cfi_offset s11, -140
+; QCI-D-NEXT:    lui t0, %hi(var)
+; QCI-D-NEXT:    lw a0, %lo(var)(t0)
+; QCI-D-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-D-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-D-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-D-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    addi a5, t0, %lo(var)
+; QCI-D-NEXT:    lw a0, 16(a5)
+; QCI-D-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 20(a5)
+; QCI-D-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw t4, 24(a5)
+; QCI-D-NEXT:    lw t5, 28(a5)
+; QCI-D-NEXT:    lw t6, 32(a5)
+; QCI-D-NEXT:    lw s2, 36(a5)
+; QCI-D-NEXT:    lw s3, 40(a5)
+; QCI-D-NEXT:    lw s4, 44(a5)
+; QCI-D-NEXT:    lw s5, 48(a5)
+; QCI-D-NEXT:    lw s6, 52(a5)
+; QCI-D-NEXT:    lw s7, 56(a5)
+; QCI-D-NEXT:    lw s8, 60(a5)
+; QCI-D-NEXT:    lw s9, 64(a5)
+; QCI-D-NEXT:    lw s10, 68(a5)
+; QCI-D-NEXT:    lw s11, 72(a5)
+; QCI-D-NEXT:    lw ra, 76(a5)
+; QCI-D-NEXT:    lw s1, 80(a5)
+; QCI-D-NEXT:    lw t3, 84(a5)
+; QCI-D-NEXT:    lw t2, 88(a5)
+; QCI-D-NEXT:    lw t1, 92(a5)
+; QCI-D-NEXT:    lw a7, 112(a5)
+; QCI-D-NEXT:    lw s0, 116(a5)
+; QCI-D-NEXT:    lw a3, 120(a5)
+; QCI-D-NEXT:    lw a0, 124(a5)
+; QCI-D-NEXT:    lw a6, 96(a5)
+; QCI-D-NEXT:    lw a4, 100(a5)
+; QCI-D-NEXT:    lw a2, 104(a5)
+; QCI-D-NEXT:    lw a1, 108(a5)
+; QCI-D-NEXT:    sw a0, 124(a5)
+; QCI-D-NEXT:    sw a3, 120(a5)
+; QCI-D-NEXT:    sw s0, 116(a5)
+; QCI-D-NEXT:    sw a7, 112(a5)
+; QCI-D-NEXT:    sw a1, 108(a5)
+; QCI-D-NEXT:    sw a2, 104(a5)
+; QCI-D-NEXT:    sw a4, 100(a5)
+; QCI-D-NEXT:    sw a6, 96(a5)
+; QCI-D-NEXT:    sw t1, 92(a5)
+; QCI-D-NEXT:    sw t2, 88(a5)
+; QCI-D-NEXT:    sw t3, 84(a5)
+; QCI-D-NEXT:    sw s1, 80(a5)
+; QCI-D-NEXT:    sw ra, 76(a5)
+; QCI-D-NEXT:    sw s11, 72(a5)
+; QCI-D-NEXT:    sw s10, 68(a5)
+; QCI-D-NEXT:    sw s9, 64(a5)
+; QCI-D-NEXT:    sw s8, 60(a5)
+; QCI-D-NEXT:    sw s7, 56(a5)
+; QCI-D-NEXT:    sw s6, 52(a5)
+; QCI-D-NEXT:    sw s5, 48(a5)
+; QCI-D-NEXT:    sw s4, 44(a5)
+; QCI-D-NEXT:    sw s3, 40(a5)
+; QCI-D-NEXT:    sw s2, 36(a5)
+; QCI-D-NEXT:    sw t6, 32(a5)
+; QCI-D-NEXT:    sw t5, 28(a5)
+; QCI-D-NEXT:    sw t4, 24(a5)
+; QCI-D-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 20(a5)
+; QCI-D-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 16(a5)
+; QCI-D-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-D-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-D-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-D-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var)(t0)
+; QCI-D-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore s1
+; QCI-D-NEXT:    .cfi_restore s2
+; QCI-D-NEXT:    .cfi_restore s3
+; QCI-D-NEXT:    .cfi_restore s4
+; QCI-D-NEXT:    .cfi_restore s5
+; QCI-D-NEXT:    .cfi_restore s6
+; QCI-D-NEXT:    .cfi_restore s7
+; QCI-D-NEXT:    .cfi_restore s8
+; QCI-D-NEXT:    .cfi_restore s9
+; QCI-D-NEXT:    .cfi_restore s10
+; QCI-D-NEXT:    .cfi_restore s11
+; QCI-D-NEXT:    addi sp, sp, 80
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
+
+define void @test_spill_nonest() "interrupt"="qci-nonest" {
+; QCI-F-LABEL: test_spill_nonest:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 176
+; QCI-F-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset s1, -100
+; QCI-F-NEXT:    .cfi_offset s2, -104
+; QCI-F-NEXT:    .cfi_offset s3, -108
+; QCI-F-NEXT:    .cfi_offset s4, -112
+; QCI-F-NEXT:    .cfi_offset s5, -116
+; QCI-F-NEXT:    .cfi_offset s6, -120
+; QCI-F-NEXT:    .cfi_offset s7, -124
+; QCI-F-NEXT:    .cfi_offset s8, -128
+; QCI-F-NEXT:    .cfi_offset s9, -132
+; QCI-F-NEXT:    .cfi_offset s10, -136
+; QCI-F-NEXT:    .cfi_offset s11, -140
+; QCI-F-NEXT:    lui t0, %hi(var)
+; QCI-F-NEXT:    lw a0, %lo(var)(t0)
+; QCI-F-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-F-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-F-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-F-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    addi a5, t0, %lo(var)
+; QCI-F-NEXT:    lw a0, 16(a5)
+; QCI-F-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 20(a5)
+; QCI-F-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw t4, 24(a5)
+; QCI-F-NEXT:    lw t5, 28(a5)
+; QCI-F-NEXT:    lw t6, 32(a5)
+; QCI-F-NEXT:    lw s2, 36(a5)
+; QCI-F-NEXT:    lw s3, 40(a5)
+; QCI-F-NEXT:    lw s4, 44(a5)
+; QCI-F-NEXT:    lw s5, 48(a5)
+; QCI-F-NEXT:    lw s6, 52(a5)
+; QCI-F-NEXT:    lw s7, 56(a5)
+; QCI-F-NEXT:    lw s8, 60(a5)
+; QCI-F-NEXT:    lw s9, 64(a5)
+; QCI-F-NEXT:    lw s10, 68(a5)
+; QCI-F-NEXT:    lw s11, 72(a5)
+; QCI-F-NEXT:    lw ra, 76(a5)
+; QCI-F-NEXT:    lw s1, 80(a5)
+; QCI-F-NEXT:    lw t3, 84(a5)
+; QCI-F-NEXT:    lw t2, 88(a5)
+; QCI-F-NEXT:    lw t1, 92(a5)
+; QCI-F-NEXT:    lw a7, 112(a5)
+; QCI-F-NEXT:    lw s0, 116(a5)
+; QCI-F-NEXT:    lw a3, 120(a5)
+; QCI-F-NEXT:    lw a0, 124(a5)
+; QCI-F-NEXT:    lw a6, 96(a5)
+; QCI-F-NEXT:    lw a4, 100(a5)
+; QCI-F-NEXT:    lw a2, 104(a5)
+; QCI-F-NEXT:    lw a1, 108(a5)
+; QCI-F-NEXT:    sw a0, 124(a5)
+; QCI-F-NEXT:    sw a3, 120(a5)
+; QCI-F-NEXT:    sw s0, 116(a5)
+; QCI-F-NEXT:    sw a7, 112(a5)
+; QCI-F-NEXT:    sw a1, 108(a5)
+; QCI-F-NEXT:    sw a2, 104(a5)
+; QCI-F-NEXT:    sw a4, 100(a5)
+; QCI-F-NEXT:    sw a6, 96(a5)
+; QCI-F-NEXT:    sw t1, 92(a5)
+; QCI-F-NEXT:    sw t2, 88(a5)
+; QCI-F-NEXT:    sw t3, 84(a5)
+; QCI-F-NEXT:    sw s1, 80(a5)
+; QCI-F-NEXT:    sw ra, 76(a5)
+; QCI-F-NEXT:    sw s11, 72(a5)
+; QCI-F-NEXT:    sw s10, 68(a5)
+; QCI-F-NEXT:    sw s9, 64(a5)
+; QCI-F-NEXT:    sw s8, 60(a5)
+; QCI-F-NEXT:    sw s7, 56(a5)
+; QCI-F-NEXT:    sw s6, 52(a5)
+; QCI-F-NEXT:    sw s5, 48(a5)
+; QCI-F-NEXT:    sw s4, 44(a5)
+; QCI-F-NEXT:    sw s3, 40(a5)
+; QCI-F-NEXT:    sw s2, 36(a5)
+; QCI-F-NEXT:    sw t6, 32(a5)
+; QCI-F-NEXT:    sw t5, 28(a5)
+; QCI-F-NEXT:    sw t4, 24(a5)
+; QCI-F-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 20(a5)
+; QCI-F-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 16(a5)
+; QCI-F-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-F-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-F-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-F-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var)(t0)
+; QCI-F-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore s1
+; QCI-F-NEXT:    .cfi_restore s2
+; QCI-F-NEXT:    .cfi_restore s3
+; QCI-F-NEXT:    .cfi_restore s4
+; QCI-F-NEXT:    .cfi_restore s5
+; QCI-F-NEXT:    .cfi_restore s6
+; QCI-F-NEXT:    .cfi_restore s7
+; QCI-F-NEXT:    .cfi_restore s8
+; QCI-F-NEXT:    .cfi_restore s9
+; QCI-F-NEXT:    .cfi_restore s10
+; QCI-F-NEXT:    .cfi_restore s11
+; QCI-F-NEXT:    addi sp, sp, 80
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_spill_nonest:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -80
+; QCI-D-NEXT:    .cfi_def_cfa_offset 176
+; QCI-D-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset s1, -100
+; QCI-D-NEXT:    .cfi_offset s2, -104
+; QCI-D-NEXT:    .cfi_offset s3, -108
+; QCI-D-NEXT:    .cfi_offset s4, -112
+; QCI-D-NEXT:    .cfi_offset s5, -116
+; QCI-D-NEXT:    .cfi_offset s6, -120
+; QCI-D-NEXT:    .cfi_offset s7, -124
+; QCI-D-NEXT:    .cfi_offset s8, -128
+; QCI-D-NEXT:    .cfi_offset s9, -132
+; QCI-D-NEXT:    .cfi_offset s10, -136
+; QCI-D-NEXT:    .cfi_offset s11, -140
+; QCI-D-NEXT:    lui t0, %hi(var)
+; QCI-D-NEXT:    lw a0, %lo(var)(t0)
+; QCI-D-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-D-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-D-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-D-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    addi a5, t0, %lo(var)
+; QCI-D-NEXT:    lw a0, 16(a5)
+; QCI-D-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 20(a5)
+; QCI-D-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw t4, 24(a5)
+; QCI-D-NEXT:    lw t5, 28(a5)
+; QCI-D-NEXT:    lw t6, 32(a5)
+; QCI-D-NEXT:    lw s2, 36(a5)
+; QCI-D-NEXT:    lw s3, 40(a5)
+; QCI-D-NEXT:    lw s4, 44(a5)
+; QCI-D-NEXT:    lw s5, 48(a5)
+; QCI-D-NEXT:    lw s6, 52(a5)
+; QCI-D-NEXT:    lw s7, 56(a5)
+; QCI-D-NEXT:    lw s8, 60(a5)
+; QCI-D-NEXT:    lw s9, 64(a5)
+; QCI-D-NEXT:    lw s10, 68(a5)
+; QCI-D-NEXT:    lw s11, 72(a5)
+; QCI-D-NEXT:    lw ra, 76(a5)
+; QCI-D-NEXT:    lw s1, 80(a5)
+; QCI-D-NEXT:    lw t3, 84(a5)
+; QCI-D-NEXT:    lw t2, 88(a5)
+; QCI-D-NEXT:    lw t1, 92(a5)
+; QCI-D-NEXT:    lw a7, 112(a5)
+; QCI-D-NEXT:    lw s0, 116(a5)
+; QCI-D-NEXT:    lw a3, 120(a5)
+; QCI-D-NEXT:    lw a0, 124(a5)
+; QCI-D-NEXT:    lw a6, 96(a5)
+; QCI-D-NEXT:    lw a4, 100(a5)
+; QCI-D-NEXT:    lw a2, 104(a5)
+; QCI-D-NEXT:    lw a1, 108(a5)
+; QCI-D-NEXT:    sw a0, 124(a5)
+; QCI-D-NEXT:    sw a3, 120(a5)
+; QCI-D-NEXT:    sw s0, 116(a5)
+; QCI-D-NEXT:    sw a7, 112(a5)
+; QCI-D-NEXT:    sw a1, 108(a5)
+; QCI-D-NEXT:    sw a2, 104(a5)
+; QCI-D-NEXT:    sw a4, 100(a5)
+; QCI-D-NEXT:    sw a6, 96(a5)
+; QCI-D-NEXT:    sw t1, 92(a5)
+; QCI-D-NEXT:    sw t2, 88(a5)
+; QCI-D-NEXT:    sw t3, 84(a5)
+; QCI-D-NEXT:    sw s1, 80(a5)
+; QCI-D-NEXT:    sw ra, 76(a5)
+; QCI-D-NEXT:    sw s11, 72(a5)
+; QCI-D-NEXT:    sw s10, 68(a5)
+; QCI-D-NEXT:    sw s9, 64(a5)
+; QCI-D-NEXT:    sw s8, 60(a5)
+; QCI-D-NEXT:    sw s7, 56(a5)
+; QCI-D-NEXT:    sw s6, 52(a5)
+; QCI-D-NEXT:    sw s5, 48(a5)
+; QCI-D-NEXT:    sw s4, 44(a5)
+; QCI-D-NEXT:    sw s3, 40(a5)
+; QCI-D-NEXT:    sw s2, 36(a5)
+; QCI-D-NEXT:    sw t6, 32(a5)
+; QCI-D-NEXT:    sw t5, 28(a5)
+; QCI-D-NEXT:    sw t4, 24(a5)
+; QCI-D-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 20(a5)
+; QCI-D-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 16(a5)
+; QCI-D-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-D-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-D-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-D-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var)(t0)
+; QCI-D-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore s1
+; QCI-D-NEXT:    .cfi_restore s2
+; QCI-D-NEXT:    .cfi_restore s3
+; QCI-D-NEXT:    .cfi_restore s4
+; QCI-D-NEXT:    .cfi_restore s5
+; QCI-D-NEXT:    .cfi_restore s6
+; QCI-D-NEXT:    .cfi_restore s7
+; QCI-D-NEXT:    .cfi_restore s8
+; QCI-D-NEXT:    .cfi_restore s9
+; QCI-D-NEXT:    .cfi_restore s10
+; QCI-D-NEXT:    .cfi_restore s11
+; QCI-D-NEXT:    addi sp, sp, 80
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
+
+define void @test_spill_call_nest() "interrupt"="qci-nest" {
+; QCI-F-LABEL: test_spill_call_nest:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter.nest
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -224
+; QCI-F-NEXT:    .cfi_def_cfa_offset 320
+; QCI-F-NEXT:    sw s1, 220(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s2, 216(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s3, 212(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s4, 208(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s5, 204(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s6, 200(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s7, 196(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s8, 192(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s9, 188(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s10, 184(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s11, 180(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft0, 176(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft1, 172(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft2, 168(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft3, 164(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft4, 160(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft5, 156(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft6, 152(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft7, 148(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa0, 144(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa1, 140(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa2, 136(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa3, 132(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa4, 128(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa5, 124(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa6, 120(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa7, 116(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft8, 112(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft9, 108(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft10, 104(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft11, 100(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset s1, -100
+; QCI-F-NEXT:    .cfi_offset s2, -104
+; QCI-F-NEXT:    .cfi_offset s3, -108
+; QCI-F-NEXT:    .cfi_offset s4, -112
+; QCI-F-NEXT:    .cfi_offset s5, -116
+; QCI-F-NEXT:    .cfi_offset s6, -120
+; QCI-F-NEXT:    .cfi_offset s7, -124
+; QCI-F-NEXT:    .cfi_offset s8, -128
+; QCI-F-NEXT:    .cfi_offset s9, -132
+; QCI-F-NEXT:    .cfi_offset s10, -136
+; QCI-F-NEXT:    .cfi_offset s11, -140
+; QCI-F-NEXT:    .cfi_offset ft0, -144
+; QCI-F-NEXT:    .cfi_offset ft1, -148
+; QCI-F-NEXT:    .cfi_offset ft2, -152
+; QCI-F-NEXT:    .cfi_offset ft3, -156
+; QCI-F-NEXT:    .cfi_offset ft4, -160
+; QCI-F-NEXT:    .cfi_offset ft5, -164
+; QCI-F-NEXT:    .cfi_offset ft6, -168
+; QCI-F-NEXT:    .cfi_offset ft7, -172
+; QCI-F-NEXT:    .cfi_offset fa0, -176
+; QCI-F-NEXT:    .cfi_offset fa1, -180
+; QCI-F-NEXT:    .cfi_offset fa2, -184
+; QCI-F-NEXT:    .cfi_offset fa3, -188
+; QCI-F-NEXT:    .cfi_offset fa4, -192
+; QCI-F-NEXT:    .cfi_offset fa5, -196
+; QCI-F-NEXT:    .cfi_offset fa6, -200
+; QCI-F-NEXT:    .cfi_offset fa7, -204
+; QCI-F-NEXT:    .cfi_offset ft8, -208
+; QCI-F-NEXT:    .cfi_offset ft9, -212
+; QCI-F-NEXT:    .cfi_offset ft10, -216
+; QCI-F-NEXT:    .cfi_offset ft11, -220
+; QCI-F-NEXT:    lui s0, %hi(var)
+; QCI-F-NEXT:    lw a0, %lo(var)(s0)
+; QCI-F-NEXT:    sw a0, 96(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-F-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-F-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-F-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    addi s1, s0, %lo(var)
+; QCI-F-NEXT:    lw a0, 16(s1)
+; QCI-F-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 20(s1)
+; QCI-F-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 24(s1)
+; QCI-F-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 28(s1)
+; QCI-F-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 32(s1)
+; QCI-F-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 36(s1)
+; QCI-F-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 40(s1)
+; QCI-F-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 44(s1)
+; QCI-F-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 48(s1)
+; QCI-F-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 52(s1)
+; QCI-F-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 56(s1)
+; QCI-F-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 60(s1)
+; QCI-F-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 64(s1)
+; QCI-F-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 68(s1)
+; QCI-F-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 72(s1)
+; QCI-F-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 76(s1)
+; QCI-F-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 80(s1)
+; QCI-F-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 84(s1)
+; QCI-F-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw s4, 88(s1)
+; QCI-F-NEXT:    lw s5, 92(s1)
+; QCI-F-NEXT:    lw s6, 96(s1)
+; QCI-F-NEXT:    lw s7, 100(s1)
+; QCI-F-NEXT:    lw s8, 104(s1)
+; QCI-F-NEXT:    lw s9, 108(s1)
+; QCI-F-NEXT:    lw s10, 112(s1)
+; QCI-F-NEXT:    lw s11, 116(s1)
+; QCI-F-NEXT:    lw s2, 120(s1)
+; QCI-F-NEXT:    lw s3, 124(s1)
+; QCI-F-NEXT:    lui a7, 266496
+; QCI-F-NEXT:    li t0, 5
+; QCI-F-NEXT:    lui a0, 260096
+; QCI-F-NEXT:    lui a2, 262144
+; QCI-F-NEXT:    lui a4, 263168
+; QCI-F-NEXT:    lui a5, 264192
+; QCI-F-NEXT:    lui a1, 264704
+; QCI-F-NEXT:    lui a6, 265216
+; QCI-F-NEXT:    fmv.w.x fa0, a0
+; QCI-F-NEXT:    lui t1, 265728
+; QCI-F-NEXT:    fmv.w.x fa1, a2
+; QCI-F-NEXT:    lui a3, 266240
+; QCI-F-NEXT:    fmv.w.x fa2, a4
+; QCI-F-NEXT:    li a0, 1
+; QCI-F-NEXT:    fmv.w.x fa3, a5
+; QCI-F-NEXT:    li a2, 2
+; QCI-F-NEXT:    fmv.w.x fa4, a1
+; QCI-F-NEXT:    li a4, 3
+; QCI-F-NEXT:    fmv.w.x fa5, a6
+; QCI-F-NEXT:    li a6, 4
+; QCI-F-NEXT:    fmv.w.x fa6, t1
+; QCI-F-NEXT:    fmv.w.x fa7, a3
+; QCI-F-NEXT:    sw t0, 0(sp)
+; QCI-F-NEXT:    sw a7, 4(sp)
+; QCI-F-NEXT:    li a1, 0
+; QCI-F-NEXT:    li a3, 0
+; QCI-F-NEXT:    li a5, 0
+; QCI-F-NEXT:    li a7, 0
+; QCI-F-NEXT:    call function_with_one_stack_arg
+; QCI-F-NEXT:    call use_float
+; QCI-F-NEXT:    sw s3, 124(s1)
+; QCI-F-NEXT:    sw s2, 120(s1)
+; QCI-F-NEXT:    sw s11, 116(s1)
+; QCI-F-NEXT:    sw s10, 112(s1)
+; QCI-F-NEXT:    sw s9, 108(s1)
+; QCI-F-NEXT:    sw s8, 104(s1)
+; QCI-F-NEXT:    sw s7, 100(s1)
+; QCI-F-NEXT:    sw s6, 96(s1)
+; QCI-F-NEXT:    sw s5, 92(s1)
+; QCI-F-NEXT:    sw s4, 88(s1)
+; QCI-F-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 84(s1)
+; QCI-F-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 80(s1)
+; QCI-F-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 76(s1)
+; QCI-F-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 72(s1)
+; QCI-F-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 68(s1)
+; QCI-F-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 64(s1)
+; QCI-F-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 60(s1)
+; QCI-F-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 56(s1)
+; QCI-F-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 52(s1)
+; QCI-F-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 48(s1)
+; QCI-F-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 44(s1)
+; QCI-F-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 40(s1)
+; QCI-F-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 36(s1)
+; QCI-F-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 32(s1)
+; QCI-F-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 28(s1)
+; QCI-F-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 24(s1)
+; QCI-F-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 20(s1)
+; QCI-F-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 16(s1)
+; QCI-F-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-F-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-F-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-F-NEXT:    lw a0, 96(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var)(s0)
+; QCI-F-NEXT:    lw s1, 220(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s2, 216(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s3, 212(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s4, 208(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s5, 204(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s6, 200(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s7, 196(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s8, 192(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s9, 188(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s10, 184(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s11, 180(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft0, 176(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft1, 172(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft2, 168(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft3, 164(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft4, 160(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft5, 156(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft6, 152(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft7, 148(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa0, 144(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa1, 140(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa2, 136(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa3, 132(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa4, 128(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa5, 124(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa6, 120(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa7, 116(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft8, 112(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft9, 108(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft10, 104(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft11, 100(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore s1
+; QCI-F-NEXT:    .cfi_restore s2
+; QCI-F-NEXT:    .cfi_restore s3
+; QCI-F-NEXT:    .cfi_restore s4
+; QCI-F-NEXT:    .cfi_restore s5
+; QCI-F-NEXT:    .cfi_restore s6
+; QCI-F-NEXT:    .cfi_restore s7
+; QCI-F-NEXT:    .cfi_restore s8
+; QCI-F-NEXT:    .cfi_restore s9
+; QCI-F-NEXT:    .cfi_restore s10
+; QCI-F-NEXT:    .cfi_restore s11
+; QCI-F-NEXT:    .cfi_restore ft0
+; QCI-F-NEXT:    .cfi_restore ft1
+; QCI-F-NEXT:    .cfi_restore ft2
+; QCI-F-NEXT:    .cfi_restore ft3
+; QCI-F-NEXT:    .cfi_restore ft4
+; QCI-F-NEXT:    .cfi_restore ft5
+; QCI-F-NEXT:    .cfi_restore ft6
+; QCI-F-NEXT:    .cfi_restore ft7
+; QCI-F-NEXT:    .cfi_restore fa0
+; QCI-F-NEXT:    .cfi_restore fa1
+; QCI-F-NEXT:    .cfi_restore fa2
+; QCI-F-NEXT:    .cfi_restore fa3
+; QCI-F-NEXT:    .cfi_restore fa4
+; QCI-F-NEXT:    .cfi_restore fa5
+; QCI-F-NEXT:    .cfi_restore fa6
+; QCI-F-NEXT:    .cfi_restore fa7
+; QCI-F-NEXT:    .cfi_restore ft8
+; QCI-F-NEXT:    .cfi_restore ft9
+; QCI-F-NEXT:    .cfi_restore ft10
+; QCI-F-NEXT:    .cfi_restore ft11
+; QCI-F-NEXT:    addi sp, sp, 224
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_spill_call_nest:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter.nest
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -304
+; QCI-D-NEXT:    .cfi_def_cfa_offset 400
+; QCI-D-NEXT:    sw s1, 300(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s2, 296(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s3, 292(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s4, 288(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s5, 284(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s6, 280(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s7, 276(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s8, 272(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s9, 268(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s10, 264(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s11, 260(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    fsd ft0, 248(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft1, 240(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft2, 232(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft3, 224(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft4, 216(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft5, 208(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft6, 200(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft7, 192(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa0, 184(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa1, 176(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa2, 168(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa3, 160(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa4, 152(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa5, 144(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa6, 136(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa7, 128(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft8, 120(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft9, 112(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft10, 104(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft11, 96(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset s1, -100
+; QCI-D-NEXT:    .cfi_offset s2, -104
+; QCI-D-NEXT:    .cfi_offset s3, -108
+; QCI-D-NEXT:    .cfi_offset s4, -112
+; QCI-D-NEXT:    .cfi_offset s5, -116
+; QCI-D-NEXT:    .cfi_offset s6, -120
+; QCI-D-NEXT:    .cfi_offset s7, -124
+; QCI-D-NEXT:    .cfi_offset s8, -128
+; QCI-D-NEXT:    .cfi_offset s9, -132
+; QCI-D-NEXT:    .cfi_offset s10, -136
+; QCI-D-NEXT:    .cfi_offset s11, -140
+; QCI-D-NEXT:    .cfi_offset ft0, -152
+; QCI-D-NEXT:    .cfi_offset ft1, -160
+; QCI-D-NEXT:    .cfi_offset ft2, -168
+; QCI-D-NEXT:    .cfi_offset ft3, -176
+; QCI-D-NEXT:    .cfi_offset ft4, -184
+; QCI-D-NEXT:    .cfi_offset ft5, -192
+; QCI-D-NEXT:    .cfi_offset ft6, -200
+; QCI-D-NEXT:    .cfi_offset ft7, -208
+; QCI-D-NEXT:    .cfi_offset fa0, -216
+; QCI-D-NEXT:    .cfi_offset fa1, -224
+; QCI-D-NEXT:    .cfi_offset fa2, -232
+; QCI-D-NEXT:    .cfi_offset fa3, -240
+; QCI-D-NEXT:    .cfi_offset fa4, -248
+; QCI-D-NEXT:    .cfi_offset fa5, -256
+; QCI-D-NEXT:    .cfi_offset fa6, -264
+; QCI-D-NEXT:    .cfi_offset fa7, -272
+; QCI-D-NEXT:    .cfi_offset ft8, -280
+; QCI-D-NEXT:    .cfi_offset ft9, -288
+; QCI-D-NEXT:    .cfi_offset ft10, -296
+; QCI-D-NEXT:    .cfi_offset ft11, -304
+; QCI-D-NEXT:    lui s0, %hi(var)
+; QCI-D-NEXT:    lw a0, %lo(var)(s0)
+; QCI-D-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-D-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-D-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-D-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    addi s1, s0, %lo(var)
+; QCI-D-NEXT:    lw a0, 16(s1)
+; QCI-D-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 20(s1)
+; QCI-D-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 24(s1)
+; QCI-D-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 28(s1)
+; QCI-D-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 32(s1)
+; QCI-D-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 36(s1)
+; QCI-D-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 40(s1)
+; QCI-D-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 44(s1)
+; QCI-D-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 48(s1)
+; QCI-D-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 52(s1)
+; QCI-D-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 56(s1)
+; QCI-D-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 60(s1)
+; QCI-D-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 64(s1)
+; QCI-D-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 68(s1)
+; QCI-D-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 72(s1)
+; QCI-D-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 76(s1)
+; QCI-D-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 80(s1)
+; QCI-D-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 84(s1)
+; QCI-D-NEXT:    sw a0, 8(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw s4, 88(s1)
+; QCI-D-NEXT:    lw s5, 92(s1)
+; QCI-D-NEXT:    lw s6, 96(s1)
+; QCI-D-NEXT:    lw s7, 100(s1)
+; QCI-D-NEXT:    lw s8, 104(s1)
+; QCI-D-NEXT:    lw s9, 108(s1)
+; QCI-D-NEXT:    lw s10, 112(s1)
+; QCI-D-NEXT:    lw s11, 116(s1)
+; QCI-D-NEXT:    lw s2, 120(s1)
+; QCI-D-NEXT:    lw s3, 124(s1)
+; QCI-D-NEXT:    lui a7, 266496
+; QCI-D-NEXT:    li t0, 5
+; QCI-D-NEXT:    lui a0, 260096
+; QCI-D-NEXT:    lui a2, 262144
+; QCI-D-NEXT:    lui a4, 263168
+; QCI-D-NEXT:    lui a5, 264192
+; QCI-D-NEXT:    lui a1, 264704
+; QCI-D-NEXT:    lui a6, 265216
+; QCI-D-NEXT:    fmv.w.x fa0, a0
+; QCI-D-NEXT:    lui t1, 265728
+; QCI-D-NEXT:    fmv.w.x fa1, a2
+; QCI-D-NEXT:    lui a3, 266240
+; QCI-D-NEXT:    fmv.w.x fa2, a4
+; QCI-D-NEXT:    li a0, 1
+; QCI-D-NEXT:    fmv.w.x fa3, a5
+; QCI-D-NEXT:    li a2, 2
+; QCI-D-NEXT:    fmv.w.x fa4, a1
+; QCI-D-NEXT:    li a4, 3
+; QCI-D-NEXT:    fmv.w.x fa5, a6
+; QCI-D-NEXT:    li a6, 4
+; QCI-D-NEXT:    fmv.w.x fa6, t1
+; QCI-D-NEXT:    fmv.w.x fa7, a3
+; QCI-D-NEXT:    sw t0, 0(sp)
+; QCI-D-NEXT:    sw a7, 4(sp)
+; QCI-D-NEXT:    li a1, 0
+; QCI-D-NEXT:    li a3, 0
+; QCI-D-NEXT:    li a5, 0
+; QCI-D-NEXT:    li a7, 0
+; QCI-D-NEXT:    call function_with_one_stack_arg
+; QCI-D-NEXT:    call use_float
+; QCI-D-NEXT:    sw s3, 124(s1)
+; QCI-D-NEXT:    sw s2, 120(s1)
+; QCI-D-NEXT:    sw s11, 116(s1)
+; QCI-D-NEXT:    sw s10, 112(s1)
+; QCI-D-NEXT:    sw s9, 108(s1)
+; QCI-D-NEXT:    sw s8, 104(s1)
+; QCI-D-NEXT:    sw s7, 100(s1)
+; QCI-D-NEXT:    sw s6, 96(s1)
+; QCI-D-NEXT:    sw s5, 92(s1)
+; QCI-D-NEXT:    sw s4, 88(s1)
+; QCI-D-NEXT:    lw a0, 8(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 84(s1)
+; QCI-D-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 80(s1)
+; QCI-D-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 76(s1)
+; QCI-D-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 72(s1)
+; QCI-D-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 68(s1)
+; QCI-D-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 64(s1)
+; QCI-D-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 60(s1)
+; QCI-D-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 56(s1)
+; QCI-D-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 52(s1)
+; QCI-D-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 48(s1)
+; QCI-D-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 44(s1)
+; QCI-D-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 40(s1)
+; QCI-D-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 36(s1)
+; QCI-D-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 32(s1)
+; QCI-D-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 28(s1)
+; QCI-D-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 24(s1)
+; QCI-D-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 20(s1)
+; QCI-D-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 16(s1)
+; QCI-D-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-D-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-D-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-D-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var)(s0)
+; QCI-D-NEXT:    lw s1, 300(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s2, 296(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s3, 292(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s4, 288(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s5, 284(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s6, 280(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s7, 276(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s8, 272(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s9, 268(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s10, 264(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s11, 260(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    fld ft0, 248(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft1, 240(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft2, 232(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft3, 224(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft4, 216(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft5, 208(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft6, 200(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft7, 192(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa0, 184(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa1, 176(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa2, 168(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa3, 160(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa4, 152(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa5, 144(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa6, 136(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa7, 128(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft8, 120(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft9, 112(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft10, 104(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft11, 96(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore s1
+; QCI-D-NEXT:    .cfi_restore s2
+; QCI-D-NEXT:    .cfi_restore s3
+; QCI-D-NEXT:    .cfi_restore s4
+; QCI-D-NEXT:    .cfi_restore s5
+; QCI-D-NEXT:    .cfi_restore s6
+; QCI-D-NEXT:    .cfi_restore s7
+; QCI-D-NEXT:    .cfi_restore s8
+; QCI-D-NEXT:    .cfi_restore s9
+; QCI-D-NEXT:    .cfi_restore s10
+; QCI-D-NEXT:    .cfi_restore s11
+; QCI-D-NEXT:    .cfi_restore ft0
+; QCI-D-NEXT:    .cfi_restore ft1
+; QCI-D-NEXT:    .cfi_restore ft2
+; QCI-D-NEXT:    .cfi_restore ft3
+; QCI-D-NEXT:    .cfi_restore ft4
+; QCI-D-NEXT:    .cfi_restore ft5
+; QCI-D-NEXT:    .cfi_restore ft6
+; QCI-D-NEXT:    .cfi_restore ft7
+; QCI-D-NEXT:    .cfi_restore fa0
+; QCI-D-NEXT:    .cfi_restore fa1
+; QCI-D-NEXT:    .cfi_restore fa2
+; QCI-D-NEXT:    .cfi_restore fa3
+; QCI-D-NEXT:    .cfi_restore fa4
+; QCI-D-NEXT:    .cfi_restore fa5
+; QCI-D-NEXT:    .cfi_restore fa6
+; QCI-D-NEXT:    .cfi_restore fa7
+; QCI-D-NEXT:    .cfi_restore ft8
+; QCI-D-NEXT:    .cfi_restore ft9
+; QCI-D-NEXT:    .cfi_restore ft10
+; QCI-D-NEXT:    .cfi_restore ft11
+; QCI-D-NEXT:    addi sp, sp, 304
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  %2 = call float @function_with_one_stack_arg(i64 1, i64 2, i64 3, i64 4, float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, i32 5, float 9.0)
+  call void @use_float(float %2)
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
+
+define void @test_spill_call_nonest() "interrupt"="qci-nonest" {
+; QCI-F-LABEL: test_spill_call_nonest:
+; QCI-F:       # %bb.0:
+; QCI-F-NEXT:    qc.c.mienter
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    .cfi_offset ra, -16
+; QCI-F-NEXT:    .cfi_offset t0, -24
+; QCI-F-NEXT:    .cfi_offset t1, -28
+; QCI-F-NEXT:    .cfi_offset t2, -32
+; QCI-F-NEXT:    .cfi_offset s0, -8
+; QCI-F-NEXT:    .cfi_offset a0, -36
+; QCI-F-NEXT:    .cfi_offset a1, -40
+; QCI-F-NEXT:    .cfi_offset a2, -44
+; QCI-F-NEXT:    .cfi_offset a3, -48
+; QCI-F-NEXT:    .cfi_offset a4, -52
+; QCI-F-NEXT:    .cfi_offset a5, -56
+; QCI-F-NEXT:    .cfi_offset a6, -60
+; QCI-F-NEXT:    .cfi_offset a7, -64
+; QCI-F-NEXT:    .cfi_offset t3, -68
+; QCI-F-NEXT:    .cfi_offset t4, -72
+; QCI-F-NEXT:    .cfi_offset t5, -76
+; QCI-F-NEXT:    .cfi_offset t6, -80
+; QCI-F-NEXT:    addi sp, sp, -224
+; QCI-F-NEXT:    .cfi_def_cfa_offset 320
+; QCI-F-NEXT:    sw s1, 220(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s2, 216(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s3, 212(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s4, 208(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s5, 204(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s6, 200(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s7, 196(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s8, 192(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s9, 188(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s10, 184(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    sw s11, 180(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft0, 176(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft1, 172(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft2, 168(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft3, 164(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft4, 160(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft5, 156(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft6, 152(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft7, 148(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa0, 144(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa1, 140(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa2, 136(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa3, 132(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa4, 128(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa5, 124(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa6, 120(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw fa7, 116(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft8, 112(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft9, 108(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft10, 104(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    fsw ft11, 100(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    .cfi_offset s1, -100
+; QCI-F-NEXT:    .cfi_offset s2, -104
+; QCI-F-NEXT:    .cfi_offset s3, -108
+; QCI-F-NEXT:    .cfi_offset s4, -112
+; QCI-F-NEXT:    .cfi_offset s5, -116
+; QCI-F-NEXT:    .cfi_offset s6, -120
+; QCI-F-NEXT:    .cfi_offset s7, -124
+; QCI-F-NEXT:    .cfi_offset s8, -128
+; QCI-F-NEXT:    .cfi_offset s9, -132
+; QCI-F-NEXT:    .cfi_offset s10, -136
+; QCI-F-NEXT:    .cfi_offset s11, -140
+; QCI-F-NEXT:    .cfi_offset ft0, -144
+; QCI-F-NEXT:    .cfi_offset ft1, -148
+; QCI-F-NEXT:    .cfi_offset ft2, -152
+; QCI-F-NEXT:    .cfi_offset ft3, -156
+; QCI-F-NEXT:    .cfi_offset ft4, -160
+; QCI-F-NEXT:    .cfi_offset ft5, -164
+; QCI-F-NEXT:    .cfi_offset ft6, -168
+; QCI-F-NEXT:    .cfi_offset ft7, -172
+; QCI-F-NEXT:    .cfi_offset fa0, -176
+; QCI-F-NEXT:    .cfi_offset fa1, -180
+; QCI-F-NEXT:    .cfi_offset fa2, -184
+; QCI-F-NEXT:    .cfi_offset fa3, -188
+; QCI-F-NEXT:    .cfi_offset fa4, -192
+; QCI-F-NEXT:    .cfi_offset fa5, -196
+; QCI-F-NEXT:    .cfi_offset fa6, -200
+; QCI-F-NEXT:    .cfi_offset fa7, -204
+; QCI-F-NEXT:    .cfi_offset ft8, -208
+; QCI-F-NEXT:    .cfi_offset ft9, -212
+; QCI-F-NEXT:    .cfi_offset ft10, -216
+; QCI-F-NEXT:    .cfi_offset ft11, -220
+; QCI-F-NEXT:    lui s0, %hi(var)
+; QCI-F-NEXT:    lw a0, %lo(var)(s0)
+; QCI-F-NEXT:    sw a0, 96(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-F-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-F-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-F-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    addi s1, s0, %lo(var)
+; QCI-F-NEXT:    lw a0, 16(s1)
+; QCI-F-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 20(s1)
+; QCI-F-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 24(s1)
+; QCI-F-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 28(s1)
+; QCI-F-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 32(s1)
+; QCI-F-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 36(s1)
+; QCI-F-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 40(s1)
+; QCI-F-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 44(s1)
+; QCI-F-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 48(s1)
+; QCI-F-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 52(s1)
+; QCI-F-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 56(s1)
+; QCI-F-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 60(s1)
+; QCI-F-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 64(s1)
+; QCI-F-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 68(s1)
+; QCI-F-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 72(s1)
+; QCI-F-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 76(s1)
+; QCI-F-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 80(s1)
+; QCI-F-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw a0, 84(s1)
+; QCI-F-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-F-NEXT:    lw s4, 88(s1)
+; QCI-F-NEXT:    lw s5, 92(s1)
+; QCI-F-NEXT:    lw s6, 96(s1)
+; QCI-F-NEXT:    lw s7, 100(s1)
+; QCI-F-NEXT:    lw s8, 104(s1)
+; QCI-F-NEXT:    lw s9, 108(s1)
+; QCI-F-NEXT:    lw s10, 112(s1)
+; QCI-F-NEXT:    lw s11, 116(s1)
+; QCI-F-NEXT:    lw s2, 120(s1)
+; QCI-F-NEXT:    lw s3, 124(s1)
+; QCI-F-NEXT:    lui a7, 266496
+; QCI-F-NEXT:    li t0, 5
+; QCI-F-NEXT:    lui a0, 260096
+; QCI-F-NEXT:    lui a2, 262144
+; QCI-F-NEXT:    lui a4, 263168
+; QCI-F-NEXT:    lui a5, 264192
+; QCI-F-NEXT:    lui a1, 264704
+; QCI-F-NEXT:    lui a6, 265216
+; QCI-F-NEXT:    fmv.w.x fa0, a0
+; QCI-F-NEXT:    lui t1, 265728
+; QCI-F-NEXT:    fmv.w.x fa1, a2
+; QCI-F-NEXT:    lui a3, 266240
+; QCI-F-NEXT:    fmv.w.x fa2, a4
+; QCI-F-NEXT:    li a0, 1
+; QCI-F-NEXT:    fmv.w.x fa3, a5
+; QCI-F-NEXT:    li a2, 2
+; QCI-F-NEXT:    fmv.w.x fa4, a1
+; QCI-F-NEXT:    li a4, 3
+; QCI-F-NEXT:    fmv.w.x fa5, a6
+; QCI-F-NEXT:    li a6, 4
+; QCI-F-NEXT:    fmv.w.x fa6, t1
+; QCI-F-NEXT:    fmv.w.x fa7, a3
+; QCI-F-NEXT:    sw t0, 0(sp)
+; QCI-F-NEXT:    sw a7, 4(sp)
+; QCI-F-NEXT:    li a1, 0
+; QCI-F-NEXT:    li a3, 0
+; QCI-F-NEXT:    li a5, 0
+; QCI-F-NEXT:    li a7, 0
+; QCI-F-NEXT:    call function_with_one_stack_arg
+; QCI-F-NEXT:    call use_float
+; QCI-F-NEXT:    sw s3, 124(s1)
+; QCI-F-NEXT:    sw s2, 120(s1)
+; QCI-F-NEXT:    sw s11, 116(s1)
+; QCI-F-NEXT:    sw s10, 112(s1)
+; QCI-F-NEXT:    sw s9, 108(s1)
+; QCI-F-NEXT:    sw s8, 104(s1)
+; QCI-F-NEXT:    sw s7, 100(s1)
+; QCI-F-NEXT:    sw s6, 96(s1)
+; QCI-F-NEXT:    sw s5, 92(s1)
+; QCI-F-NEXT:    sw s4, 88(s1)
+; QCI-F-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 84(s1)
+; QCI-F-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 80(s1)
+; QCI-F-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 76(s1)
+; QCI-F-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 72(s1)
+; QCI-F-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 68(s1)
+; QCI-F-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 64(s1)
+; QCI-F-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 60(s1)
+; QCI-F-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 56(s1)
+; QCI-F-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 52(s1)
+; QCI-F-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 48(s1)
+; QCI-F-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 44(s1)
+; QCI-F-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 40(s1)
+; QCI-F-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 36(s1)
+; QCI-F-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 32(s1)
+; QCI-F-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 28(s1)
+; QCI-F-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 24(s1)
+; QCI-F-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 20(s1)
+; QCI-F-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, 16(s1)
+; QCI-F-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-F-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-F-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-F-NEXT:    lw a0, 96(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    sw a0, %lo(var)(s0)
+; QCI-F-NEXT:    lw s1, 220(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s2, 216(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s3, 212(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s4, 208(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s5, 204(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s6, 200(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s7, 196(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s8, 192(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s9, 188(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s10, 184(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    lw s11, 180(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft0, 176(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft1, 172(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft2, 168(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft3, 164(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft4, 160(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft5, 156(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft6, 152(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft7, 148(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa0, 144(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa1, 140(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa2, 136(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa3, 132(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa4, 128(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa5, 124(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa6, 120(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw fa7, 116(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft8, 112(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft9, 108(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft10, 104(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    flw ft11, 100(sp) # 4-byte Folded Reload
+; QCI-F-NEXT:    .cfi_restore s1
+; QCI-F-NEXT:    .cfi_restore s2
+; QCI-F-NEXT:    .cfi_restore s3
+; QCI-F-NEXT:    .cfi_restore s4
+; QCI-F-NEXT:    .cfi_restore s5
+; QCI-F-NEXT:    .cfi_restore s6
+; QCI-F-NEXT:    .cfi_restore s7
+; QCI-F-NEXT:    .cfi_restore s8
+; QCI-F-NEXT:    .cfi_restore s9
+; QCI-F-NEXT:    .cfi_restore s10
+; QCI-F-NEXT:    .cfi_restore s11
+; QCI-F-NEXT:    .cfi_restore ft0
+; QCI-F-NEXT:    .cfi_restore ft1
+; QCI-F-NEXT:    .cfi_restore ft2
+; QCI-F-NEXT:    .cfi_restore ft3
+; QCI-F-NEXT:    .cfi_restore ft4
+; QCI-F-NEXT:    .cfi_restore ft5
+; QCI-F-NEXT:    .cfi_restore ft6
+; QCI-F-NEXT:    .cfi_restore ft7
+; QCI-F-NEXT:    .cfi_restore fa0
+; QCI-F-NEXT:    .cfi_restore fa1
+; QCI-F-NEXT:    .cfi_restore fa2
+; QCI-F-NEXT:    .cfi_restore fa3
+; QCI-F-NEXT:    .cfi_restore fa4
+; QCI-F-NEXT:    .cfi_restore fa5
+; QCI-F-NEXT:    .cfi_restore fa6
+; QCI-F-NEXT:    .cfi_restore fa7
+; QCI-F-NEXT:    .cfi_restore ft8
+; QCI-F-NEXT:    .cfi_restore ft9
+; QCI-F-NEXT:    .cfi_restore ft10
+; QCI-F-NEXT:    .cfi_restore ft11
+; QCI-F-NEXT:    addi sp, sp, 224
+; QCI-F-NEXT:    .cfi_def_cfa_offset 96
+; QCI-F-NEXT:    qc.c.mileaveret
+;
+; QCI-D-LABEL: test_spill_call_nonest:
+; QCI-D:       # %bb.0:
+; QCI-D-NEXT:    qc.c.mienter
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    .cfi_offset ra, -16
+; QCI-D-NEXT:    .cfi_offset t0, -24
+; QCI-D-NEXT:    .cfi_offset t1, -28
+; QCI-D-NEXT:    .cfi_offset t2, -32
+; QCI-D-NEXT:    .cfi_offset s0, -8
+; QCI-D-NEXT:    .cfi_offset a0, -36
+; QCI-D-NEXT:    .cfi_offset a1, -40
+; QCI-D-NEXT:    .cfi_offset a2, -44
+; QCI-D-NEXT:    .cfi_offset a3, -48
+; QCI-D-NEXT:    .cfi_offset a4, -52
+; QCI-D-NEXT:    .cfi_offset a5, -56
+; QCI-D-NEXT:    .cfi_offset a6, -60
+; QCI-D-NEXT:    .cfi_offset a7, -64
+; QCI-D-NEXT:    .cfi_offset t3, -68
+; QCI-D-NEXT:    .cfi_offset t4, -72
+; QCI-D-NEXT:    .cfi_offset t5, -76
+; QCI-D-NEXT:    .cfi_offset t6, -80
+; QCI-D-NEXT:    addi sp, sp, -304
+; QCI-D-NEXT:    .cfi_def_cfa_offset 400
+; QCI-D-NEXT:    sw s1, 300(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s2, 296(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s3, 292(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s4, 288(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s5, 284(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s6, 280(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s7, 276(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s8, 272(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s9, 268(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s10, 264(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    sw s11, 260(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    fsd ft0, 248(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft1, 240(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft2, 232(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft3, 224(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft4, 216(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft5, 208(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft6, 200(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft7, 192(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa0, 184(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa1, 176(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa2, 168(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa3, 160(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa4, 152(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa5, 144(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa6, 136(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd fa7, 128(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft8, 120(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft9, 112(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft10, 104(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    fsd ft11, 96(sp) # 8-byte Folded Spill
+; QCI-D-NEXT:    .cfi_offset s1, -100
+; QCI-D-NEXT:    .cfi_offset s2, -104
+; QCI-D-NEXT:    .cfi_offset s3, -108
+; QCI-D-NEXT:    .cfi_offset s4, -112
+; QCI-D-NEXT:    .cfi_offset s5, -116
+; QCI-D-NEXT:    .cfi_offset s6, -120
+; QCI-D-NEXT:    .cfi_offset s7, -124
+; QCI-D-NEXT:    .cfi_offset s8, -128
+; QCI-D-NEXT:    .cfi_offset s9, -132
+; QCI-D-NEXT:    .cfi_offset s10, -136
+; QCI-D-NEXT:    .cfi_offset s11, -140
+; QCI-D-NEXT:    .cfi_offset ft0, -152
+; QCI-D-NEXT:    .cfi_offset ft1, -160
+; QCI-D-NEXT:    .cfi_offset ft2, -168
+; QCI-D-NEXT:    .cfi_offset ft3, -176
+; QCI-D-NEXT:    .cfi_offset ft4, -184
+; QCI-D-NEXT:    .cfi_offset ft5, -192
+; QCI-D-NEXT:    .cfi_offset ft6, -200
+; QCI-D-NEXT:    .cfi_offset ft7, -208
+; QCI-D-NEXT:    .cfi_offset fa0, -216
+; QCI-D-NEXT:    .cfi_offset fa1, -224
+; QCI-D-NEXT:    .cfi_offset fa2, -232
+; QCI-D-NEXT:    .cfi_offset fa3, -240
+; QCI-D-NEXT:    .cfi_offset fa4, -248
+; QCI-D-NEXT:    .cfi_offset fa5, -256
+; QCI-D-NEXT:    .cfi_offset fa6, -264
+; QCI-D-NEXT:    .cfi_offset fa7, -272
+; QCI-D-NEXT:    .cfi_offset ft8, -280
+; QCI-D-NEXT:    .cfi_offset ft9, -288
+; QCI-D-NEXT:    .cfi_offset ft10, -296
+; QCI-D-NEXT:    .cfi_offset ft11, -304
+; QCI-D-NEXT:    lui s0, %hi(var)
+; QCI-D-NEXT:    lw a0, %lo(var)(s0)
+; QCI-D-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-D-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-D-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-D-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    addi s1, s0, %lo(var)
+; QCI-D-NEXT:    lw a0, 16(s1)
+; QCI-D-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 20(s1)
+; QCI-D-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 24(s1)
+; QCI-D-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 28(s1)
+; QCI-D-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 32(s1)
+; QCI-D-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 36(s1)
+; QCI-D-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 40(s1)
+; QCI-D-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 44(s1)
+; QCI-D-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 48(s1)
+; QCI-D-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 52(s1)
+; QCI-D-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 56(s1)
+; QCI-D-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 60(s1)
+; QCI-D-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 64(s1)
+; QCI-D-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 68(s1)
+; QCI-D-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 72(s1)
+; QCI-D-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 76(s1)
+; QCI-D-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 80(s1)
+; QCI-D-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw a0, 84(s1)
+; QCI-D-NEXT:    sw a0, 8(sp) # 4-byte Folded Spill
+; QCI-D-NEXT:    lw s4, 88(s1)
+; QCI-D-NEXT:    lw s5, 92(s1)
+; QCI-D-NEXT:    lw s6, 96(s1)
+; QCI-D-NEXT:    lw s7, 100(s1)
+; QCI-D-NEXT:    lw s8, 104(s1)
+; QCI-D-NEXT:    lw s9, 108(s1)
+; QCI-D-NEXT:    lw s10, 112(s1)
+; QCI-D-NEXT:    lw s11, 116(s1)
+; QCI-D-NEXT:    lw s2, 120(s1)
+; QCI-D-NEXT:    lw s3, 124(s1)
+; QCI-D-NEXT:    lui a7, 266496
+; QCI-D-NEXT:    li t0, 5
+; QCI-D-NEXT:    lui a0, 260096
+; QCI-D-NEXT:    lui a2, 262144
+; QCI-D-NEXT:    lui a4, 263168
+; QCI-D-NEXT:    lui a5, 264192
+; QCI-D-NEXT:    lui a1, 264704
+; QCI-D-NEXT:    lui a6, 265216
+; QCI-D-NEXT:    fmv.w.x fa0, a0
+; QCI-D-NEXT:    lui t1, 265728
+; QCI-D-NEXT:    fmv.w.x fa1, a2
+; QCI-D-NEXT:    lui a3, 266240
+; QCI-D-NEXT:    fmv.w.x fa2, a4
+; QCI-D-NEXT:    li a0, 1
+; QCI-D-NEXT:    fmv.w.x fa3, a5
+; QCI-D-NEXT:    li a2, 2
+; QCI-D-NEXT:    fmv.w.x fa4, a1
+; QCI-D-NEXT:    li a4, 3
+; QCI-D-NEXT:    fmv.w.x fa5, a6
+; QCI-D-NEXT:    li a6, 4
+; QCI-D-NEXT:    fmv.w.x fa6, t1
+; QCI-D-NEXT:    fmv.w.x fa7, a3
+; QCI-D-NEXT:    sw t0, 0(sp)
+; QCI-D-NEXT:    sw a7, 4(sp)
+; QCI-D-NEXT:    li a1, 0
+; QCI-D-NEXT:    li a3, 0
+; QCI-D-NEXT:    li a5, 0
+; QCI-D-NEXT:    li a7, 0
+; QCI-D-NEXT:    call function_with_one_stack_arg
+; QCI-D-NEXT:    call use_float
+; QCI-D-NEXT:    sw s3, 124(s1)
+; QCI-D-NEXT:    sw s2, 120(s1)
+; QCI-D-NEXT:    sw s11, 116(s1)
+; QCI-D-NEXT:    sw s10, 112(s1)
+; QCI-D-NEXT:    sw s9, 108(s1)
+; QCI-D-NEXT:    sw s8, 104(s1)
+; QCI-D-NEXT:    sw s7, 100(s1)
+; QCI-D-NEXT:    sw s6, 96(s1)
+; QCI-D-NEXT:    sw s5, 92(s1)
+; QCI-D-NEXT:    sw s4, 88(s1)
+; QCI-D-NEXT:    lw a0, 8(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 84(s1)
+; QCI-D-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 80(s1)
+; QCI-D-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 76(s1)
+; QCI-D-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 72(s1)
+; QCI-D-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 68(s1)
+; QCI-D-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 64(s1)
+; QCI-D-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 60(s1)
+; QCI-D-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 56(s1)
+; QCI-D-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 52(s1)
+; QCI-D-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 48(s1)
+; QCI-D-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 44(s1)
+; QCI-D-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 40(s1)
+; QCI-D-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 36(s1)
+; QCI-D-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 32(s1)
+; QCI-D-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 28(s1)
+; QCI-D-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 24(s1)
+; QCI-D-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 20(s1)
+; QCI-D-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, 16(s1)
+; QCI-D-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-D-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-D-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-D-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    sw a0, %lo(var)(s0)
+; QCI-D-NEXT:    lw s1, 300(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s2, 296(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s3, 292(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s4, 288(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s5, 284(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s6, 280(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s7, 276(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s8, 272(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s9, 268(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s10, 264(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    lw s11, 260(sp) # 4-byte Folded Reload
+; QCI-D-NEXT:    fld ft0, 248(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft1, 240(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft2, 232(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft3, 224(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft4, 216(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft5, 208(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft6, 200(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft7, 192(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa0, 184(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa1, 176(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa2, 168(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa3, 160(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa4, 152(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa5, 144(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa6, 136(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld fa7, 128(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft8, 120(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft9, 112(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft10, 104(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    fld ft11, 96(sp) # 8-byte Folded Reload
+; QCI-D-NEXT:    .cfi_restore s1
+; QCI-D-NEXT:    .cfi_restore s2
+; QCI-D-NEXT:    .cfi_restore s3
+; QCI-D-NEXT:    .cfi_restore s4
+; QCI-D-NEXT:    .cfi_restore s5
+; QCI-D-NEXT:    .cfi_restore s6
+; QCI-D-NEXT:    .cfi_restore s7
+; QCI-D-NEXT:    .cfi_restore s8
+; QCI-D-NEXT:    .cfi_restore s9
+; QCI-D-NEXT:    .cfi_restore s10
+; QCI-D-NEXT:    .cfi_restore s11
+; QCI-D-NEXT:    .cfi_restore ft0
+; QCI-D-NEXT:    .cfi_restore ft1
+; QCI-D-NEXT:    .cfi_restore ft2
+; QCI-D-NEXT:    .cfi_restore ft3
+; QCI-D-NEXT:    .cfi_restore ft4
+; QCI-D-NEXT:    .cfi_restore ft5
+; QCI-D-NEXT:    .cfi_restore ft6
+; QCI-D-NEXT:    .cfi_restore ft7
+; QCI-D-NEXT:    .cfi_restore fa0
+; QCI-D-NEXT:    .cfi_restore fa1
+; QCI-D-NEXT:    .cfi_restore fa2
+; QCI-D-NEXT:    .cfi_restore fa3
+; QCI-D-NEXT:    .cfi_restore fa4
+; QCI-D-NEXT:    .cfi_restore fa5
+; QCI-D-NEXT:    .cfi_restore fa6
+; QCI-D-NEXT:    .cfi_restore fa7
+; QCI-D-NEXT:    .cfi_restore ft8
+; QCI-D-NEXT:    .cfi_restore ft9
+; QCI-D-NEXT:    .cfi_restore ft10
+; QCI-D-NEXT:    .cfi_restore ft11
+; QCI-D-NEXT:    addi sp, sp, 304
+; QCI-D-NEXT:    .cfi_def_cfa_offset 96
+; QCI-D-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  %2 = call float @function_with_one_stack_arg(i64 1, i64 2, i64 3, i64 4, float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, i32 5, float 9.0)
+  call void @use_float(float %2)
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
diff --git a/llvm/test/CodeGen/RISCV/qci-interrupt-attr.ll b/llvm/test/CodeGen/RISCV/qci-interrupt-attr.ll
new file mode 100644
index 0000000000000..a6c90ae9e69c3
--- /dev/null
+++ b/llvm/test/CodeGen/RISCV/qci-interrupt-attr.ll
@@ -0,0 +1,2927 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+experimental-xqciint -o - %s \
+; RUN:   -verify-machineinstrs | FileCheck --check-prefix=QCI %s
+
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+experimental-xqciint,+save-restore \
+; RUN:   -o - %s -verify-machineinstrs \
+; RUN:   | FileCheck --check-prefix=QCI %s
+
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+experimental-xqciint -o - %s \
+; RUN:   -verify-machineinstrs -frame-pointer=all | FileCheck --check-prefix=QCI-FP %s
+
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+experimental-xqciint,+zcmp \
+; RUN:   -o - %s -verify-machineinstrs \
+; RUN:   | FileCheck --check-prefix=QCI-PUSH-POP %s
+
+;; This tests "interrupt"="qci-nest" and "interrupt"="qci-nonest" frame lowering.
+;; including CFI information. These tests should all lack `nounwind`.
+;;
+;; When `+save-restore` is enabled, the codegen should be identical as these
+;; calls are incompatible with the interrupt attribute because the restore is
+;; tail-called.
+
+define void @test_nest_empty() "interrupt"="qci-nest" {
+; QCI-LABEL: test_nest_empty:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter.nest
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nest_empty:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter.nest
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi s0, sp, 96
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nest_empty:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter.nest
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  ret void
+}
+
+define void @test_nonest_empty() "interrupt"="qci-nonest" {
+; QCI-LABEL: test_nonest_empty:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nonest_empty:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi s0, sp, 96
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nonest_empty:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  ret void
+}
+
+
+declare void @use_i32(i32)
+
+define void @test_nest_asm() "interrupt"="qci-nest" {
+; QCI-LABEL: test_nest_asm:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter.nest
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    li a0, 1
+; QCI-NEXT:    #APP
+; QCI-NEXT:    # a0 <- a0
+; QCI-NEXT:    #NO_APP
+; QCI-NEXT:    call use_i32
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nest_asm:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter.nest
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi s0, sp, 96
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    li a0, 1
+; QCI-FP-NEXT:    #APP
+; QCI-FP-NEXT:    # a0 <- a0
+; QCI-FP-NEXT:    #NO_APP
+; QCI-FP-NEXT:    call use_i32
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nest_asm:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter.nest
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    li a0, 1
+; QCI-PUSH-POP-NEXT:    #APP
+; QCI-PUSH-POP-NEXT:    # a0 <- a0
+; QCI-PUSH-POP-NEXT:    #NO_APP
+; QCI-PUSH-POP-NEXT:    call use_i32
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = call i32 asm sideeffect "/* $0 <- $1 */", "=r,r"(i32 1)
+  call void @use_i32(i32 %1)
+  ret void
+}
+
+define void @test_nonest_asm() "interrupt"="qci-nonest" {
+; QCI-LABEL: test_nonest_asm:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    li a0, 1
+; QCI-NEXT:    #APP
+; QCI-NEXT:    # a0 <- a0
+; QCI-NEXT:    #NO_APP
+; QCI-NEXT:    call use_i32
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nonest_asm:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi s0, sp, 96
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    li a0, 1
+; QCI-FP-NEXT:    #APP
+; QCI-FP-NEXT:    # a0 <- a0
+; QCI-FP-NEXT:    #NO_APP
+; QCI-FP-NEXT:    call use_i32
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nonest_asm:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    li a0, 1
+; QCI-PUSH-POP-NEXT:    #APP
+; QCI-PUSH-POP-NEXT:    # a0 <- a0
+; QCI-PUSH-POP-NEXT:    #NO_APP
+; QCI-PUSH-POP-NEXT:    call use_i32
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = call i32 asm sideeffect "/* $0 <- $1 */", "=r,r"(i32 1)
+  call void @use_i32(i32 %1)
+  ret void
+}
+
+declare i64 @function_with_one_stack_arg(i64, i64, i64, i64, i32)
+declare void @use_i64(i64)
+
+define void @test_nest_call() "interrupt"="qci-nest" {
+; QCI-LABEL: test_nest_call:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter.nest
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -16
+; QCI-NEXT:    .cfi_def_cfa_offset 112
+; QCI-NEXT:    li a0, 4
+; QCI-NEXT:    li a2, 1
+; QCI-NEXT:    li a4, 2
+; QCI-NEXT:    li a6, 3
+; QCI-NEXT:    sw a0, 0(sp)
+; QCI-NEXT:    li a0, 0
+; QCI-NEXT:    li a1, 0
+; QCI-NEXT:    li a3, 0
+; QCI-NEXT:    li a5, 0
+; QCI-NEXT:    li a7, 0
+; QCI-NEXT:    call function_with_one_stack_arg
+; QCI-NEXT:    call use_i64
+; QCI-NEXT:    addi sp, sp, 16
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nest_call:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter.nest
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-FP-NEXT:    addi s0, sp, 112
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    li a0, 4
+; QCI-FP-NEXT:    li a2, 1
+; QCI-FP-NEXT:    li a4, 2
+; QCI-FP-NEXT:    li a6, 3
+; QCI-FP-NEXT:    sw a0, 0(sp)
+; QCI-FP-NEXT:    li a0, 0
+; QCI-FP-NEXT:    li a1, 0
+; QCI-FP-NEXT:    li a3, 0
+; QCI-FP-NEXT:    li a5, 0
+; QCI-FP-NEXT:    li a7, 0
+; QCI-FP-NEXT:    call function_with_one_stack_arg
+; QCI-FP-NEXT:    call use_i64
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 112
+; QCI-FP-NEXT:    addi sp, sp, 16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nest_call:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter.nest
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-PUSH-POP-NEXT:    li a0, 4
+; QCI-PUSH-POP-NEXT:    li a2, 1
+; QCI-PUSH-POP-NEXT:    li a4, 2
+; QCI-PUSH-POP-NEXT:    li a6, 3
+; QCI-PUSH-POP-NEXT:    sw a0, 0(sp)
+; QCI-PUSH-POP-NEXT:    li a0, 0
+; QCI-PUSH-POP-NEXT:    li a1, 0
+; QCI-PUSH-POP-NEXT:    li a3, 0
+; QCI-PUSH-POP-NEXT:    li a5, 0
+; QCI-PUSH-POP-NEXT:    li a7, 0
+; QCI-PUSH-POP-NEXT:    call function_with_one_stack_arg
+; QCI-PUSH-POP-NEXT:    call use_i64
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = call i64 @function_with_one_stack_arg(i64 0, i64 1, i64 2, i64 3, i32 4)
+  call void @use_i64(i64 %1)
+  ret void
+}
+
+define void @test_nonest_call() "interrupt"="qci-nonest" {
+; QCI-LABEL: test_nonest_call:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -16
+; QCI-NEXT:    .cfi_def_cfa_offset 112
+; QCI-NEXT:    li a0, 4
+; QCI-NEXT:    li a2, 1
+; QCI-NEXT:    li a4, 2
+; QCI-NEXT:    li a6, 3
+; QCI-NEXT:    sw a0, 0(sp)
+; QCI-NEXT:    li a0, 0
+; QCI-NEXT:    li a1, 0
+; QCI-NEXT:    li a3, 0
+; QCI-NEXT:    li a5, 0
+; QCI-NEXT:    li a7, 0
+; QCI-NEXT:    call function_with_one_stack_arg
+; QCI-NEXT:    call use_i64
+; QCI-NEXT:    addi sp, sp, 16
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nonest_call:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-FP-NEXT:    addi s0, sp, 112
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    li a0, 4
+; QCI-FP-NEXT:    li a2, 1
+; QCI-FP-NEXT:    li a4, 2
+; QCI-FP-NEXT:    li a6, 3
+; QCI-FP-NEXT:    sw a0, 0(sp)
+; QCI-FP-NEXT:    li a0, 0
+; QCI-FP-NEXT:    li a1, 0
+; QCI-FP-NEXT:    li a3, 0
+; QCI-FP-NEXT:    li a5, 0
+; QCI-FP-NEXT:    li a7, 0
+; QCI-FP-NEXT:    call function_with_one_stack_arg
+; QCI-FP-NEXT:    call use_i64
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 112
+; QCI-FP-NEXT:    addi sp, sp, 16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nonest_call:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-PUSH-POP-NEXT:    li a0, 4
+; QCI-PUSH-POP-NEXT:    li a2, 1
+; QCI-PUSH-POP-NEXT:    li a4, 2
+; QCI-PUSH-POP-NEXT:    li a6, 3
+; QCI-PUSH-POP-NEXT:    sw a0, 0(sp)
+; QCI-PUSH-POP-NEXT:    li a0, 0
+; QCI-PUSH-POP-NEXT:    li a1, 0
+; QCI-PUSH-POP-NEXT:    li a3, 0
+; QCI-PUSH-POP-NEXT:    li a5, 0
+; QCI-PUSH-POP-NEXT:    li a7, 0
+; QCI-PUSH-POP-NEXT:    call function_with_one_stack_arg
+; QCI-PUSH-POP-NEXT:    call use_i64
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = call i64 @function_with_one_stack_arg(i64 0, i64 1, i64 2, i64 3, i32 4)
+  call void @use_i64(i64 %1)
+  ret void
+}
+
+@var = global [32 x i32] zeroinitializer
+
+define void @test_spill_nest() "interrupt"="qci-nest" {
+; QCI-LABEL: test_spill_nest:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter.nest
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -80
+; QCI-NEXT:    .cfi_def_cfa_offset 176
+; QCI-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-NEXT:    .cfi_offset s1, -100
+; QCI-NEXT:    .cfi_offset s2, -104
+; QCI-NEXT:    .cfi_offset s3, -108
+; QCI-NEXT:    .cfi_offset s4, -112
+; QCI-NEXT:    .cfi_offset s5, -116
+; QCI-NEXT:    .cfi_offset s6, -120
+; QCI-NEXT:    .cfi_offset s7, -124
+; QCI-NEXT:    .cfi_offset s8, -128
+; QCI-NEXT:    .cfi_offset s9, -132
+; QCI-NEXT:    .cfi_offset s10, -136
+; QCI-NEXT:    .cfi_offset s11, -140
+; QCI-NEXT:    lui t0, %hi(var)
+; QCI-NEXT:    lw a0, %lo(var)(t0)
+; QCI-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-NEXT:    addi a5, t0, %lo(var)
+; QCI-NEXT:    lw a0, 16(a5)
+; QCI-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 20(a5)
+; QCI-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw t4, 24(a5)
+; QCI-NEXT:    lw t5, 28(a5)
+; QCI-NEXT:    lw t6, 32(a5)
+; QCI-NEXT:    lw s2, 36(a5)
+; QCI-NEXT:    lw s3, 40(a5)
+; QCI-NEXT:    lw s4, 44(a5)
+; QCI-NEXT:    lw s5, 48(a5)
+; QCI-NEXT:    lw s6, 52(a5)
+; QCI-NEXT:    lw s7, 56(a5)
+; QCI-NEXT:    lw s8, 60(a5)
+; QCI-NEXT:    lw s9, 64(a5)
+; QCI-NEXT:    lw s10, 68(a5)
+; QCI-NEXT:    lw s11, 72(a5)
+; QCI-NEXT:    lw ra, 76(a5)
+; QCI-NEXT:    lw s1, 80(a5)
+; QCI-NEXT:    lw t3, 84(a5)
+; QCI-NEXT:    lw t2, 88(a5)
+; QCI-NEXT:    lw t1, 92(a5)
+; QCI-NEXT:    lw a7, 112(a5)
+; QCI-NEXT:    lw s0, 116(a5)
+; QCI-NEXT:    lw a3, 120(a5)
+; QCI-NEXT:    lw a0, 124(a5)
+; QCI-NEXT:    lw a6, 96(a5)
+; QCI-NEXT:    lw a4, 100(a5)
+; QCI-NEXT:    lw a2, 104(a5)
+; QCI-NEXT:    lw a1, 108(a5)
+; QCI-NEXT:    sw a0, 124(a5)
+; QCI-NEXT:    sw a3, 120(a5)
+; QCI-NEXT:    sw s0, 116(a5)
+; QCI-NEXT:    sw a7, 112(a5)
+; QCI-NEXT:    sw a1, 108(a5)
+; QCI-NEXT:    sw a2, 104(a5)
+; QCI-NEXT:    sw a4, 100(a5)
+; QCI-NEXT:    sw a6, 96(a5)
+; QCI-NEXT:    sw t1, 92(a5)
+; QCI-NEXT:    sw t2, 88(a5)
+; QCI-NEXT:    sw t3, 84(a5)
+; QCI-NEXT:    sw s1, 80(a5)
+; QCI-NEXT:    sw ra, 76(a5)
+; QCI-NEXT:    sw s11, 72(a5)
+; QCI-NEXT:    sw s10, 68(a5)
+; QCI-NEXT:    sw s9, 64(a5)
+; QCI-NEXT:    sw s8, 60(a5)
+; QCI-NEXT:    sw s7, 56(a5)
+; QCI-NEXT:    sw s6, 52(a5)
+; QCI-NEXT:    sw s5, 48(a5)
+; QCI-NEXT:    sw s4, 44(a5)
+; QCI-NEXT:    sw s3, 40(a5)
+; QCI-NEXT:    sw s2, 36(a5)
+; QCI-NEXT:    sw t6, 32(a5)
+; QCI-NEXT:    sw t5, 28(a5)
+; QCI-NEXT:    sw t4, 24(a5)
+; QCI-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 20(a5)
+; QCI-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 16(a5)
+; QCI-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var)(t0)
+; QCI-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-NEXT:    .cfi_restore s1
+; QCI-NEXT:    .cfi_restore s2
+; QCI-NEXT:    .cfi_restore s3
+; QCI-NEXT:    .cfi_restore s4
+; QCI-NEXT:    .cfi_restore s5
+; QCI-NEXT:    .cfi_restore s6
+; QCI-NEXT:    .cfi_restore s7
+; QCI-NEXT:    .cfi_restore s8
+; QCI-NEXT:    .cfi_restore s9
+; QCI-NEXT:    .cfi_restore s10
+; QCI-NEXT:    .cfi_restore s11
+; QCI-NEXT:    addi sp, sp, 80
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_spill_nest:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter.nest
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -80
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 176
+; QCI-FP-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    .cfi_offset s1, -100
+; QCI-FP-NEXT:    .cfi_offset s2, -104
+; QCI-FP-NEXT:    .cfi_offset s3, -108
+; QCI-FP-NEXT:    .cfi_offset s4, -112
+; QCI-FP-NEXT:    .cfi_offset s5, -116
+; QCI-FP-NEXT:    .cfi_offset s6, -120
+; QCI-FP-NEXT:    .cfi_offset s7, -124
+; QCI-FP-NEXT:    .cfi_offset s8, -128
+; QCI-FP-NEXT:    .cfi_offset s9, -132
+; QCI-FP-NEXT:    .cfi_offset s10, -136
+; QCI-FP-NEXT:    .cfi_offset s11, -140
+; QCI-FP-NEXT:    addi s0, sp, 176
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    lui t1, %hi(var)
+; QCI-FP-NEXT:    lw a0, %lo(var)(t1)
+; QCI-FP-NEXT:    sw a0, -144(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+4)(t1)
+; QCI-FP-NEXT:    sw a0, -148(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+8)(t1)
+; QCI-FP-NEXT:    sw a0, -152(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+12)(t1)
+; QCI-FP-NEXT:    sw a0, -156(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    addi a5, t1, %lo(var)
+; QCI-FP-NEXT:    lw a0, 16(a5)
+; QCI-FP-NEXT:    sw a0, -160(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 20(a5)
+; QCI-FP-NEXT:    sw a0, -164(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 24(a5)
+; QCI-FP-NEXT:    sw a0, -168(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw t5, 28(a5)
+; QCI-FP-NEXT:    lw t6, 32(a5)
+; QCI-FP-NEXT:    lw s2, 36(a5)
+; QCI-FP-NEXT:    lw s3, 40(a5)
+; QCI-FP-NEXT:    lw s4, 44(a5)
+; QCI-FP-NEXT:    lw s5, 48(a5)
+; QCI-FP-NEXT:    lw s6, 52(a5)
+; QCI-FP-NEXT:    lw s7, 56(a5)
+; QCI-FP-NEXT:    lw s8, 60(a5)
+; QCI-FP-NEXT:    lw s9, 64(a5)
+; QCI-FP-NEXT:    lw s10, 68(a5)
+; QCI-FP-NEXT:    lw s11, 72(a5)
+; QCI-FP-NEXT:    lw ra, 76(a5)
+; QCI-FP-NEXT:    lw t4, 80(a5)
+; QCI-FP-NEXT:    lw t3, 84(a5)
+; QCI-FP-NEXT:    lw t2, 88(a5)
+; QCI-FP-NEXT:    lw s1, 92(a5)
+; QCI-FP-NEXT:    lw t0, 112(a5)
+; QCI-FP-NEXT:    lw a4, 116(a5)
+; QCI-FP-NEXT:    lw a3, 120(a5)
+; QCI-FP-NEXT:    lw a0, 124(a5)
+; QCI-FP-NEXT:    lw a7, 96(a5)
+; QCI-FP-NEXT:    lw a6, 100(a5)
+; QCI-FP-NEXT:    lw a2, 104(a5)
+; QCI-FP-NEXT:    lw a1, 108(a5)
+; QCI-FP-NEXT:    sw a0, 124(a5)
+; QCI-FP-NEXT:    sw a3, 120(a5)
+; QCI-FP-NEXT:    sw a4, 116(a5)
+; QCI-FP-NEXT:    sw t0, 112(a5)
+; QCI-FP-NEXT:    sw a1, 108(a5)
+; QCI-FP-NEXT:    sw a2, 104(a5)
+; QCI-FP-NEXT:    sw a6, 100(a5)
+; QCI-FP-NEXT:    sw a7, 96(a5)
+; QCI-FP-NEXT:    sw s1, 92(a5)
+; QCI-FP-NEXT:    sw t2, 88(a5)
+; QCI-FP-NEXT:    sw t3, 84(a5)
+; QCI-FP-NEXT:    sw t4, 80(a5)
+; QCI-FP-NEXT:    sw ra, 76(a5)
+; QCI-FP-NEXT:    sw s11, 72(a5)
+; QCI-FP-NEXT:    sw s10, 68(a5)
+; QCI-FP-NEXT:    sw s9, 64(a5)
+; QCI-FP-NEXT:    sw s8, 60(a5)
+; QCI-FP-NEXT:    sw s7, 56(a5)
+; QCI-FP-NEXT:    sw s6, 52(a5)
+; QCI-FP-NEXT:    sw s5, 48(a5)
+; QCI-FP-NEXT:    sw s4, 44(a5)
+; QCI-FP-NEXT:    sw s3, 40(a5)
+; QCI-FP-NEXT:    sw s2, 36(a5)
+; QCI-FP-NEXT:    sw t6, 32(a5)
+; QCI-FP-NEXT:    sw t5, 28(a5)
+; QCI-FP-NEXT:    lw a0, -168(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 24(a5)
+; QCI-FP-NEXT:    lw a0, -164(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 20(a5)
+; QCI-FP-NEXT:    lw a0, -160(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 16(a5)
+; QCI-FP-NEXT:    lw a0, -156(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+12)(t1)
+; QCI-FP-NEXT:    lw a0, -152(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+8)(t1)
+; QCI-FP-NEXT:    lw a0, -148(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+4)(t1)
+; QCI-FP-NEXT:    lw a0, -144(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var)(t1)
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 176
+; QCI-FP-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    .cfi_restore s1
+; QCI-FP-NEXT:    .cfi_restore s2
+; QCI-FP-NEXT:    .cfi_restore s3
+; QCI-FP-NEXT:    .cfi_restore s4
+; QCI-FP-NEXT:    .cfi_restore s5
+; QCI-FP-NEXT:    .cfi_restore s6
+; QCI-FP-NEXT:    .cfi_restore s7
+; QCI-FP-NEXT:    .cfi_restore s8
+; QCI-FP-NEXT:    .cfi_restore s9
+; QCI-FP-NEXT:    .cfi_restore s10
+; QCI-FP-NEXT:    .cfi_restore s11
+; QCI-FP-NEXT:    addi sp, sp, 80
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_spill_nest:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter.nest
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -80
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 176
+; QCI-PUSH-POP-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    .cfi_offset s1, -100
+; QCI-PUSH-POP-NEXT:    .cfi_offset s2, -104
+; QCI-PUSH-POP-NEXT:    .cfi_offset s3, -108
+; QCI-PUSH-POP-NEXT:    .cfi_offset s4, -112
+; QCI-PUSH-POP-NEXT:    .cfi_offset s5, -116
+; QCI-PUSH-POP-NEXT:    .cfi_offset s6, -120
+; QCI-PUSH-POP-NEXT:    .cfi_offset s7, -124
+; QCI-PUSH-POP-NEXT:    .cfi_offset s8, -128
+; QCI-PUSH-POP-NEXT:    .cfi_offset s9, -132
+; QCI-PUSH-POP-NEXT:    .cfi_offset s10, -136
+; QCI-PUSH-POP-NEXT:    .cfi_offset s11, -140
+; QCI-PUSH-POP-NEXT:    lui t0, %hi(var)
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    addi a5, t0, %lo(var)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(a5)
+; QCI-PUSH-POP-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 20(a5)
+; QCI-PUSH-POP-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw t4, 24(a5)
+; QCI-PUSH-POP-NEXT:    lw t5, 28(a5)
+; QCI-PUSH-POP-NEXT:    lw t6, 32(a5)
+; QCI-PUSH-POP-NEXT:    lw s2, 36(a5)
+; QCI-PUSH-POP-NEXT:    lw s3, 40(a5)
+; QCI-PUSH-POP-NEXT:    lw s4, 44(a5)
+; QCI-PUSH-POP-NEXT:    lw s5, 48(a5)
+; QCI-PUSH-POP-NEXT:    lw s6, 52(a5)
+; QCI-PUSH-POP-NEXT:    lw s7, 56(a5)
+; QCI-PUSH-POP-NEXT:    lw s8, 60(a5)
+; QCI-PUSH-POP-NEXT:    lw s9, 64(a5)
+; QCI-PUSH-POP-NEXT:    lw s10, 68(a5)
+; QCI-PUSH-POP-NEXT:    lw s11, 72(a5)
+; QCI-PUSH-POP-NEXT:    lw ra, 76(a5)
+; QCI-PUSH-POP-NEXT:    lw s1, 80(a5)
+; QCI-PUSH-POP-NEXT:    lw t3, 84(a5)
+; QCI-PUSH-POP-NEXT:    lw t2, 88(a5)
+; QCI-PUSH-POP-NEXT:    lw t1, 92(a5)
+; QCI-PUSH-POP-NEXT:    lw a7, 112(a5)
+; QCI-PUSH-POP-NEXT:    lw s0, 116(a5)
+; QCI-PUSH-POP-NEXT:    lw a3, 120(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 124(a5)
+; QCI-PUSH-POP-NEXT:    lw a6, 96(a5)
+; QCI-PUSH-POP-NEXT:    lw a4, 100(a5)
+; QCI-PUSH-POP-NEXT:    lw a2, 104(a5)
+; QCI-PUSH-POP-NEXT:    lw a1, 108(a5)
+; QCI-PUSH-POP-NEXT:    sw a0, 124(a5)
+; QCI-PUSH-POP-NEXT:    sw a3, 120(a5)
+; QCI-PUSH-POP-NEXT:    sw s0, 116(a5)
+; QCI-PUSH-POP-NEXT:    sw a7, 112(a5)
+; QCI-PUSH-POP-NEXT:    sw a1, 108(a5)
+; QCI-PUSH-POP-NEXT:    sw a2, 104(a5)
+; QCI-PUSH-POP-NEXT:    sw a4, 100(a5)
+; QCI-PUSH-POP-NEXT:    sw a6, 96(a5)
+; QCI-PUSH-POP-NEXT:    sw t1, 92(a5)
+; QCI-PUSH-POP-NEXT:    sw t2, 88(a5)
+; QCI-PUSH-POP-NEXT:    sw t3, 84(a5)
+; QCI-PUSH-POP-NEXT:    sw s1, 80(a5)
+; QCI-PUSH-POP-NEXT:    sw ra, 76(a5)
+; QCI-PUSH-POP-NEXT:    sw s11, 72(a5)
+; QCI-PUSH-POP-NEXT:    sw s10, 68(a5)
+; QCI-PUSH-POP-NEXT:    sw s9, 64(a5)
+; QCI-PUSH-POP-NEXT:    sw s8, 60(a5)
+; QCI-PUSH-POP-NEXT:    sw s7, 56(a5)
+; QCI-PUSH-POP-NEXT:    sw s6, 52(a5)
+; QCI-PUSH-POP-NEXT:    sw s5, 48(a5)
+; QCI-PUSH-POP-NEXT:    sw s4, 44(a5)
+; QCI-PUSH-POP-NEXT:    sw s3, 40(a5)
+; QCI-PUSH-POP-NEXT:    sw s2, 36(a5)
+; QCI-PUSH-POP-NEXT:    sw t6, 32(a5)
+; QCI-PUSH-POP-NEXT:    sw t5, 28(a5)
+; QCI-PUSH-POP-NEXT:    sw t4, 24(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 20(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 16(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-PUSH-POP-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-PUSH-POP-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-PUSH-POP-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var)(t0)
+; QCI-PUSH-POP-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    .cfi_restore s1
+; QCI-PUSH-POP-NEXT:    .cfi_restore s2
+; QCI-PUSH-POP-NEXT:    .cfi_restore s3
+; QCI-PUSH-POP-NEXT:    .cfi_restore s4
+; QCI-PUSH-POP-NEXT:    .cfi_restore s5
+; QCI-PUSH-POP-NEXT:    .cfi_restore s6
+; QCI-PUSH-POP-NEXT:    .cfi_restore s7
+; QCI-PUSH-POP-NEXT:    .cfi_restore s8
+; QCI-PUSH-POP-NEXT:    .cfi_restore s9
+; QCI-PUSH-POP-NEXT:    .cfi_restore s10
+; QCI-PUSH-POP-NEXT:    .cfi_restore s11
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 80
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
+
+define void @test_spill_nonest() "interrupt"="qci-nonest" {
+; QCI-LABEL: test_spill_nonest:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -80
+; QCI-NEXT:    .cfi_def_cfa_offset 176
+; QCI-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-NEXT:    .cfi_offset s1, -100
+; QCI-NEXT:    .cfi_offset s2, -104
+; QCI-NEXT:    .cfi_offset s3, -108
+; QCI-NEXT:    .cfi_offset s4, -112
+; QCI-NEXT:    .cfi_offset s5, -116
+; QCI-NEXT:    .cfi_offset s6, -120
+; QCI-NEXT:    .cfi_offset s7, -124
+; QCI-NEXT:    .cfi_offset s8, -128
+; QCI-NEXT:    .cfi_offset s9, -132
+; QCI-NEXT:    .cfi_offset s10, -136
+; QCI-NEXT:    .cfi_offset s11, -140
+; QCI-NEXT:    lui t0, %hi(var)
+; QCI-NEXT:    lw a0, %lo(var)(t0)
+; QCI-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-NEXT:    addi a5, t0, %lo(var)
+; QCI-NEXT:    lw a0, 16(a5)
+; QCI-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 20(a5)
+; QCI-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw t4, 24(a5)
+; QCI-NEXT:    lw t5, 28(a5)
+; QCI-NEXT:    lw t6, 32(a5)
+; QCI-NEXT:    lw s2, 36(a5)
+; QCI-NEXT:    lw s3, 40(a5)
+; QCI-NEXT:    lw s4, 44(a5)
+; QCI-NEXT:    lw s5, 48(a5)
+; QCI-NEXT:    lw s6, 52(a5)
+; QCI-NEXT:    lw s7, 56(a5)
+; QCI-NEXT:    lw s8, 60(a5)
+; QCI-NEXT:    lw s9, 64(a5)
+; QCI-NEXT:    lw s10, 68(a5)
+; QCI-NEXT:    lw s11, 72(a5)
+; QCI-NEXT:    lw ra, 76(a5)
+; QCI-NEXT:    lw s1, 80(a5)
+; QCI-NEXT:    lw t3, 84(a5)
+; QCI-NEXT:    lw t2, 88(a5)
+; QCI-NEXT:    lw t1, 92(a5)
+; QCI-NEXT:    lw a7, 112(a5)
+; QCI-NEXT:    lw s0, 116(a5)
+; QCI-NEXT:    lw a3, 120(a5)
+; QCI-NEXT:    lw a0, 124(a5)
+; QCI-NEXT:    lw a6, 96(a5)
+; QCI-NEXT:    lw a4, 100(a5)
+; QCI-NEXT:    lw a2, 104(a5)
+; QCI-NEXT:    lw a1, 108(a5)
+; QCI-NEXT:    sw a0, 124(a5)
+; QCI-NEXT:    sw a3, 120(a5)
+; QCI-NEXT:    sw s0, 116(a5)
+; QCI-NEXT:    sw a7, 112(a5)
+; QCI-NEXT:    sw a1, 108(a5)
+; QCI-NEXT:    sw a2, 104(a5)
+; QCI-NEXT:    sw a4, 100(a5)
+; QCI-NEXT:    sw a6, 96(a5)
+; QCI-NEXT:    sw t1, 92(a5)
+; QCI-NEXT:    sw t2, 88(a5)
+; QCI-NEXT:    sw t3, 84(a5)
+; QCI-NEXT:    sw s1, 80(a5)
+; QCI-NEXT:    sw ra, 76(a5)
+; QCI-NEXT:    sw s11, 72(a5)
+; QCI-NEXT:    sw s10, 68(a5)
+; QCI-NEXT:    sw s9, 64(a5)
+; QCI-NEXT:    sw s8, 60(a5)
+; QCI-NEXT:    sw s7, 56(a5)
+; QCI-NEXT:    sw s6, 52(a5)
+; QCI-NEXT:    sw s5, 48(a5)
+; QCI-NEXT:    sw s4, 44(a5)
+; QCI-NEXT:    sw s3, 40(a5)
+; QCI-NEXT:    sw s2, 36(a5)
+; QCI-NEXT:    sw t6, 32(a5)
+; QCI-NEXT:    sw t5, 28(a5)
+; QCI-NEXT:    sw t4, 24(a5)
+; QCI-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 20(a5)
+; QCI-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 16(a5)
+; QCI-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var)(t0)
+; QCI-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-NEXT:    .cfi_restore s1
+; QCI-NEXT:    .cfi_restore s2
+; QCI-NEXT:    .cfi_restore s3
+; QCI-NEXT:    .cfi_restore s4
+; QCI-NEXT:    .cfi_restore s5
+; QCI-NEXT:    .cfi_restore s6
+; QCI-NEXT:    .cfi_restore s7
+; QCI-NEXT:    .cfi_restore s8
+; QCI-NEXT:    .cfi_restore s9
+; QCI-NEXT:    .cfi_restore s10
+; QCI-NEXT:    .cfi_restore s11
+; QCI-NEXT:    addi sp, sp, 80
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_spill_nonest:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -80
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 176
+; QCI-FP-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    .cfi_offset s1, -100
+; QCI-FP-NEXT:    .cfi_offset s2, -104
+; QCI-FP-NEXT:    .cfi_offset s3, -108
+; QCI-FP-NEXT:    .cfi_offset s4, -112
+; QCI-FP-NEXT:    .cfi_offset s5, -116
+; QCI-FP-NEXT:    .cfi_offset s6, -120
+; QCI-FP-NEXT:    .cfi_offset s7, -124
+; QCI-FP-NEXT:    .cfi_offset s8, -128
+; QCI-FP-NEXT:    .cfi_offset s9, -132
+; QCI-FP-NEXT:    .cfi_offset s10, -136
+; QCI-FP-NEXT:    .cfi_offset s11, -140
+; QCI-FP-NEXT:    addi s0, sp, 176
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    lui t1, %hi(var)
+; QCI-FP-NEXT:    lw a0, %lo(var)(t1)
+; QCI-FP-NEXT:    sw a0, -144(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+4)(t1)
+; QCI-FP-NEXT:    sw a0, -148(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+8)(t1)
+; QCI-FP-NEXT:    sw a0, -152(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+12)(t1)
+; QCI-FP-NEXT:    sw a0, -156(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    addi a5, t1, %lo(var)
+; QCI-FP-NEXT:    lw a0, 16(a5)
+; QCI-FP-NEXT:    sw a0, -160(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 20(a5)
+; QCI-FP-NEXT:    sw a0, -164(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 24(a5)
+; QCI-FP-NEXT:    sw a0, -168(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw t5, 28(a5)
+; QCI-FP-NEXT:    lw t6, 32(a5)
+; QCI-FP-NEXT:    lw s2, 36(a5)
+; QCI-FP-NEXT:    lw s3, 40(a5)
+; QCI-FP-NEXT:    lw s4, 44(a5)
+; QCI-FP-NEXT:    lw s5, 48(a5)
+; QCI-FP-NEXT:    lw s6, 52(a5)
+; QCI-FP-NEXT:    lw s7, 56(a5)
+; QCI-FP-NEXT:    lw s8, 60(a5)
+; QCI-FP-NEXT:    lw s9, 64(a5)
+; QCI-FP-NEXT:    lw s10, 68(a5)
+; QCI-FP-NEXT:    lw s11, 72(a5)
+; QCI-FP-NEXT:    lw ra, 76(a5)
+; QCI-FP-NEXT:    lw t4, 80(a5)
+; QCI-FP-NEXT:    lw t3, 84(a5)
+; QCI-FP-NEXT:    lw t2, 88(a5)
+; QCI-FP-NEXT:    lw s1, 92(a5)
+; QCI-FP-NEXT:    lw t0, 112(a5)
+; QCI-FP-NEXT:    lw a4, 116(a5)
+; QCI-FP-NEXT:    lw a3, 120(a5)
+; QCI-FP-NEXT:    lw a0, 124(a5)
+; QCI-FP-NEXT:    lw a7, 96(a5)
+; QCI-FP-NEXT:    lw a6, 100(a5)
+; QCI-FP-NEXT:    lw a2, 104(a5)
+; QCI-FP-NEXT:    lw a1, 108(a5)
+; QCI-FP-NEXT:    sw a0, 124(a5)
+; QCI-FP-NEXT:    sw a3, 120(a5)
+; QCI-FP-NEXT:    sw a4, 116(a5)
+; QCI-FP-NEXT:    sw t0, 112(a5)
+; QCI-FP-NEXT:    sw a1, 108(a5)
+; QCI-FP-NEXT:    sw a2, 104(a5)
+; QCI-FP-NEXT:    sw a6, 100(a5)
+; QCI-FP-NEXT:    sw a7, 96(a5)
+; QCI-FP-NEXT:    sw s1, 92(a5)
+; QCI-FP-NEXT:    sw t2, 88(a5)
+; QCI-FP-NEXT:    sw t3, 84(a5)
+; QCI-FP-NEXT:    sw t4, 80(a5)
+; QCI-FP-NEXT:    sw ra, 76(a5)
+; QCI-FP-NEXT:    sw s11, 72(a5)
+; QCI-FP-NEXT:    sw s10, 68(a5)
+; QCI-FP-NEXT:    sw s9, 64(a5)
+; QCI-FP-NEXT:    sw s8, 60(a5)
+; QCI-FP-NEXT:    sw s7, 56(a5)
+; QCI-FP-NEXT:    sw s6, 52(a5)
+; QCI-FP-NEXT:    sw s5, 48(a5)
+; QCI-FP-NEXT:    sw s4, 44(a5)
+; QCI-FP-NEXT:    sw s3, 40(a5)
+; QCI-FP-NEXT:    sw s2, 36(a5)
+; QCI-FP-NEXT:    sw t6, 32(a5)
+; QCI-FP-NEXT:    sw t5, 28(a5)
+; QCI-FP-NEXT:    lw a0, -168(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 24(a5)
+; QCI-FP-NEXT:    lw a0, -164(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 20(a5)
+; QCI-FP-NEXT:    lw a0, -160(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 16(a5)
+; QCI-FP-NEXT:    lw a0, -156(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+12)(t1)
+; QCI-FP-NEXT:    lw a0, -152(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+8)(t1)
+; QCI-FP-NEXT:    lw a0, -148(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+4)(t1)
+; QCI-FP-NEXT:    lw a0, -144(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var)(t1)
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 176
+; QCI-FP-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    .cfi_restore s1
+; QCI-FP-NEXT:    .cfi_restore s2
+; QCI-FP-NEXT:    .cfi_restore s3
+; QCI-FP-NEXT:    .cfi_restore s4
+; QCI-FP-NEXT:    .cfi_restore s5
+; QCI-FP-NEXT:    .cfi_restore s6
+; QCI-FP-NEXT:    .cfi_restore s7
+; QCI-FP-NEXT:    .cfi_restore s8
+; QCI-FP-NEXT:    .cfi_restore s9
+; QCI-FP-NEXT:    .cfi_restore s10
+; QCI-FP-NEXT:    .cfi_restore s11
+; QCI-FP-NEXT:    addi sp, sp, 80
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_spill_nonest:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -80
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 176
+; QCI-PUSH-POP-NEXT:    sw s1, 76(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s2, 72(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s3, 68(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s4, 64(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s5, 60(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s6, 56(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s7, 52(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s8, 48(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s9, 44(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s10, 40(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s11, 36(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    .cfi_offset s1, -100
+; QCI-PUSH-POP-NEXT:    .cfi_offset s2, -104
+; QCI-PUSH-POP-NEXT:    .cfi_offset s3, -108
+; QCI-PUSH-POP-NEXT:    .cfi_offset s4, -112
+; QCI-PUSH-POP-NEXT:    .cfi_offset s5, -116
+; QCI-PUSH-POP-NEXT:    .cfi_offset s6, -120
+; QCI-PUSH-POP-NEXT:    .cfi_offset s7, -124
+; QCI-PUSH-POP-NEXT:    .cfi_offset s8, -128
+; QCI-PUSH-POP-NEXT:    .cfi_offset s9, -132
+; QCI-PUSH-POP-NEXT:    .cfi_offset s10, -136
+; QCI-PUSH-POP-NEXT:    .cfi_offset s11, -140
+; QCI-PUSH-POP-NEXT:    lui t0, %hi(var)
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+4)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+8)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+12)(t0)
+; QCI-PUSH-POP-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    addi a5, t0, %lo(var)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(a5)
+; QCI-PUSH-POP-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 20(a5)
+; QCI-PUSH-POP-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw t4, 24(a5)
+; QCI-PUSH-POP-NEXT:    lw t5, 28(a5)
+; QCI-PUSH-POP-NEXT:    lw t6, 32(a5)
+; QCI-PUSH-POP-NEXT:    lw s2, 36(a5)
+; QCI-PUSH-POP-NEXT:    lw s3, 40(a5)
+; QCI-PUSH-POP-NEXT:    lw s4, 44(a5)
+; QCI-PUSH-POP-NEXT:    lw s5, 48(a5)
+; QCI-PUSH-POP-NEXT:    lw s6, 52(a5)
+; QCI-PUSH-POP-NEXT:    lw s7, 56(a5)
+; QCI-PUSH-POP-NEXT:    lw s8, 60(a5)
+; QCI-PUSH-POP-NEXT:    lw s9, 64(a5)
+; QCI-PUSH-POP-NEXT:    lw s10, 68(a5)
+; QCI-PUSH-POP-NEXT:    lw s11, 72(a5)
+; QCI-PUSH-POP-NEXT:    lw ra, 76(a5)
+; QCI-PUSH-POP-NEXT:    lw s1, 80(a5)
+; QCI-PUSH-POP-NEXT:    lw t3, 84(a5)
+; QCI-PUSH-POP-NEXT:    lw t2, 88(a5)
+; QCI-PUSH-POP-NEXT:    lw t1, 92(a5)
+; QCI-PUSH-POP-NEXT:    lw a7, 112(a5)
+; QCI-PUSH-POP-NEXT:    lw s0, 116(a5)
+; QCI-PUSH-POP-NEXT:    lw a3, 120(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 124(a5)
+; QCI-PUSH-POP-NEXT:    lw a6, 96(a5)
+; QCI-PUSH-POP-NEXT:    lw a4, 100(a5)
+; QCI-PUSH-POP-NEXT:    lw a2, 104(a5)
+; QCI-PUSH-POP-NEXT:    lw a1, 108(a5)
+; QCI-PUSH-POP-NEXT:    sw a0, 124(a5)
+; QCI-PUSH-POP-NEXT:    sw a3, 120(a5)
+; QCI-PUSH-POP-NEXT:    sw s0, 116(a5)
+; QCI-PUSH-POP-NEXT:    sw a7, 112(a5)
+; QCI-PUSH-POP-NEXT:    sw a1, 108(a5)
+; QCI-PUSH-POP-NEXT:    sw a2, 104(a5)
+; QCI-PUSH-POP-NEXT:    sw a4, 100(a5)
+; QCI-PUSH-POP-NEXT:    sw a6, 96(a5)
+; QCI-PUSH-POP-NEXT:    sw t1, 92(a5)
+; QCI-PUSH-POP-NEXT:    sw t2, 88(a5)
+; QCI-PUSH-POP-NEXT:    sw t3, 84(a5)
+; QCI-PUSH-POP-NEXT:    sw s1, 80(a5)
+; QCI-PUSH-POP-NEXT:    sw ra, 76(a5)
+; QCI-PUSH-POP-NEXT:    sw s11, 72(a5)
+; QCI-PUSH-POP-NEXT:    sw s10, 68(a5)
+; QCI-PUSH-POP-NEXT:    sw s9, 64(a5)
+; QCI-PUSH-POP-NEXT:    sw s8, 60(a5)
+; QCI-PUSH-POP-NEXT:    sw s7, 56(a5)
+; QCI-PUSH-POP-NEXT:    sw s6, 52(a5)
+; QCI-PUSH-POP-NEXT:    sw s5, 48(a5)
+; QCI-PUSH-POP-NEXT:    sw s4, 44(a5)
+; QCI-PUSH-POP-NEXT:    sw s3, 40(a5)
+; QCI-PUSH-POP-NEXT:    sw s2, 36(a5)
+; QCI-PUSH-POP-NEXT:    sw t6, 32(a5)
+; QCI-PUSH-POP-NEXT:    sw t5, 28(a5)
+; QCI-PUSH-POP-NEXT:    sw t4, 24(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 20(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 16(a5)
+; QCI-PUSH-POP-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+12)(t0)
+; QCI-PUSH-POP-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+8)(t0)
+; QCI-PUSH-POP-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+4)(t0)
+; QCI-PUSH-POP-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var)(t0)
+; QCI-PUSH-POP-NEXT:    lw s1, 76(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s2, 72(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s3, 68(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s4, 64(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s5, 60(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s6, 56(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s7, 52(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s8, 48(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s9, 44(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s10, 40(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s11, 36(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    .cfi_restore s1
+; QCI-PUSH-POP-NEXT:    .cfi_restore s2
+; QCI-PUSH-POP-NEXT:    .cfi_restore s3
+; QCI-PUSH-POP-NEXT:    .cfi_restore s4
+; QCI-PUSH-POP-NEXT:    .cfi_restore s5
+; QCI-PUSH-POP-NEXT:    .cfi_restore s6
+; QCI-PUSH-POP-NEXT:    .cfi_restore s7
+; QCI-PUSH-POP-NEXT:    .cfi_restore s8
+; QCI-PUSH-POP-NEXT:    .cfi_restore s9
+; QCI-PUSH-POP-NEXT:    .cfi_restore s10
+; QCI-PUSH-POP-NEXT:    .cfi_restore s11
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 80
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
+
+define void @test_spill_call_nest() "interrupt"="qci-nest" {
+; QCI-LABEL: test_spill_call_nest:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter.nest
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -144
+; QCI-NEXT:    .cfi_def_cfa_offset 240
+; QCI-NEXT:    sw s1, 140(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s2, 136(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s3, 132(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s4, 128(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s5, 124(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s6, 120(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s7, 116(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s8, 112(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s9, 108(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s10, 104(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s11, 100(sp) # 4-byte Folded Spill
+; QCI-NEXT:    .cfi_offset s1, -100
+; QCI-NEXT:    .cfi_offset s2, -104
+; QCI-NEXT:    .cfi_offset s3, -108
+; QCI-NEXT:    .cfi_offset s4, -112
+; QCI-NEXT:    .cfi_offset s5, -116
+; QCI-NEXT:    .cfi_offset s6, -120
+; QCI-NEXT:    .cfi_offset s7, -124
+; QCI-NEXT:    .cfi_offset s8, -128
+; QCI-NEXT:    .cfi_offset s9, -132
+; QCI-NEXT:    .cfi_offset s10, -136
+; QCI-NEXT:    .cfi_offset s11, -140
+; QCI-NEXT:    lui s0, %hi(var)
+; QCI-NEXT:    lw a0, %lo(var)(s0)
+; QCI-NEXT:    sw a0, 96(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-NEXT:    addi s1, s0, %lo(var)
+; QCI-NEXT:    lw a0, 16(s1)
+; QCI-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 20(s1)
+; QCI-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 24(s1)
+; QCI-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 28(s1)
+; QCI-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 32(s1)
+; QCI-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 36(s1)
+; QCI-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 40(s1)
+; QCI-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 44(s1)
+; QCI-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 48(s1)
+; QCI-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 52(s1)
+; QCI-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 56(s1)
+; QCI-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 60(s1)
+; QCI-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 64(s1)
+; QCI-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 68(s1)
+; QCI-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 72(s1)
+; QCI-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 76(s1)
+; QCI-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 80(s1)
+; QCI-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 84(s1)
+; QCI-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw s4, 88(s1)
+; QCI-NEXT:    lw s5, 92(s1)
+; QCI-NEXT:    lw s6, 96(s1)
+; QCI-NEXT:    lw s7, 100(s1)
+; QCI-NEXT:    lw s8, 104(s1)
+; QCI-NEXT:    lw s9, 108(s1)
+; QCI-NEXT:    lw s10, 112(s1)
+; QCI-NEXT:    lw s11, 116(s1)
+; QCI-NEXT:    lw s2, 120(s1)
+; QCI-NEXT:    lw s3, 124(s1)
+; QCI-NEXT:    li a0, 4
+; QCI-NEXT:    li a2, 1
+; QCI-NEXT:    li a4, 2
+; QCI-NEXT:    li a6, 3
+; QCI-NEXT:    sw a0, 0(sp)
+; QCI-NEXT:    li a0, 0
+; QCI-NEXT:    li a1, 0
+; QCI-NEXT:    li a3, 0
+; QCI-NEXT:    li a5, 0
+; QCI-NEXT:    li a7, 0
+; QCI-NEXT:    call function_with_one_stack_arg
+; QCI-NEXT:    call use_i64
+; QCI-NEXT:    sw s3, 124(s1)
+; QCI-NEXT:    sw s2, 120(s1)
+; QCI-NEXT:    sw s11, 116(s1)
+; QCI-NEXT:    sw s10, 112(s1)
+; QCI-NEXT:    sw s9, 108(s1)
+; QCI-NEXT:    sw s8, 104(s1)
+; QCI-NEXT:    sw s7, 100(s1)
+; QCI-NEXT:    sw s6, 96(s1)
+; QCI-NEXT:    sw s5, 92(s1)
+; QCI-NEXT:    sw s4, 88(s1)
+; QCI-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 84(s1)
+; QCI-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 80(s1)
+; QCI-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 76(s1)
+; QCI-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 72(s1)
+; QCI-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 68(s1)
+; QCI-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 64(s1)
+; QCI-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 60(s1)
+; QCI-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 56(s1)
+; QCI-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 52(s1)
+; QCI-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 48(s1)
+; QCI-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 44(s1)
+; QCI-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 40(s1)
+; QCI-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 36(s1)
+; QCI-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 32(s1)
+; QCI-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 28(s1)
+; QCI-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 24(s1)
+; QCI-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 20(s1)
+; QCI-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 16(s1)
+; QCI-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-NEXT:    lw a0, 96(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var)(s0)
+; QCI-NEXT:    lw s1, 140(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s2, 136(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s3, 132(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s4, 128(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s5, 124(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s6, 120(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s7, 116(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s8, 112(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s9, 108(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s10, 104(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s11, 100(sp) # 4-byte Folded Reload
+; QCI-NEXT:    .cfi_restore s1
+; QCI-NEXT:    .cfi_restore s2
+; QCI-NEXT:    .cfi_restore s3
+; QCI-NEXT:    .cfi_restore s4
+; QCI-NEXT:    .cfi_restore s5
+; QCI-NEXT:    .cfi_restore s6
+; QCI-NEXT:    .cfi_restore s7
+; QCI-NEXT:    .cfi_restore s8
+; QCI-NEXT:    .cfi_restore s9
+; QCI-NEXT:    .cfi_restore s10
+; QCI-NEXT:    .cfi_restore s11
+; QCI-NEXT:    addi sp, sp, 144
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_spill_call_nest:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter.nest
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -144
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 240
+; QCI-FP-NEXT:    sw s1, 140(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s2, 136(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s3, 132(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s4, 128(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s5, 124(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s6, 120(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s7, 116(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s8, 112(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s9, 108(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s10, 104(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s11, 100(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    .cfi_offset s1, -100
+; QCI-FP-NEXT:    .cfi_offset s2, -104
+; QCI-FP-NEXT:    .cfi_offset s3, -108
+; QCI-FP-NEXT:    .cfi_offset s4, -112
+; QCI-FP-NEXT:    .cfi_offset s5, -116
+; QCI-FP-NEXT:    .cfi_offset s6, -120
+; QCI-FP-NEXT:    .cfi_offset s7, -124
+; QCI-FP-NEXT:    .cfi_offset s8, -128
+; QCI-FP-NEXT:    .cfi_offset s9, -132
+; QCI-FP-NEXT:    .cfi_offset s10, -136
+; QCI-FP-NEXT:    .cfi_offset s11, -140
+; QCI-FP-NEXT:    addi s0, sp, 240
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    lui s6, %hi(var)
+; QCI-FP-NEXT:    lw a0, %lo(var)(s6)
+; QCI-FP-NEXT:    sw a0, -144(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+4)(s6)
+; QCI-FP-NEXT:    sw a0, -148(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+8)(s6)
+; QCI-FP-NEXT:    sw a0, -152(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+12)(s6)
+; QCI-FP-NEXT:    sw a0, -156(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    addi s1, s6, %lo(var)
+; QCI-FP-NEXT:    lw a0, 16(s1)
+; QCI-FP-NEXT:    sw a0, -160(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 20(s1)
+; QCI-FP-NEXT:    sw a0, -164(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 24(s1)
+; QCI-FP-NEXT:    sw a0, -168(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 28(s1)
+; QCI-FP-NEXT:    sw a0, -172(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 32(s1)
+; QCI-FP-NEXT:    sw a0, -176(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 36(s1)
+; QCI-FP-NEXT:    sw a0, -180(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 40(s1)
+; QCI-FP-NEXT:    sw a0, -184(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 44(s1)
+; QCI-FP-NEXT:    sw a0, -188(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 48(s1)
+; QCI-FP-NEXT:    sw a0, -192(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 52(s1)
+; QCI-FP-NEXT:    sw a0, -196(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 56(s1)
+; QCI-FP-NEXT:    sw a0, -200(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 60(s1)
+; QCI-FP-NEXT:    sw a0, -204(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 64(s1)
+; QCI-FP-NEXT:    sw a0, -208(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 68(s1)
+; QCI-FP-NEXT:    sw a0, -212(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 72(s1)
+; QCI-FP-NEXT:    sw a0, -216(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 76(s1)
+; QCI-FP-NEXT:    sw a0, -220(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 80(s1)
+; QCI-FP-NEXT:    sw a0, -224(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 84(s1)
+; QCI-FP-NEXT:    sw a0, -228(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 88(s1)
+; QCI-FP-NEXT:    sw a0, -232(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw s8, 92(s1)
+; QCI-FP-NEXT:    lw s9, 96(s1)
+; QCI-FP-NEXT:    lw s10, 100(s1)
+; QCI-FP-NEXT:    lw s11, 104(s1)
+; QCI-FP-NEXT:    lw s2, 108(s1)
+; QCI-FP-NEXT:    lw s3, 112(s1)
+; QCI-FP-NEXT:    lw s4, 116(s1)
+; QCI-FP-NEXT:    lw s5, 120(s1)
+; QCI-FP-NEXT:    lw s7, 124(s1)
+; QCI-FP-NEXT:    li a0, 4
+; QCI-FP-NEXT:    li a2, 1
+; QCI-FP-NEXT:    li a4, 2
+; QCI-FP-NEXT:    li a6, 3
+; QCI-FP-NEXT:    sw a0, 0(sp)
+; QCI-FP-NEXT:    li a0, 0
+; QCI-FP-NEXT:    li a1, 0
+; QCI-FP-NEXT:    li a3, 0
+; QCI-FP-NEXT:    li a5, 0
+; QCI-FP-NEXT:    li a7, 0
+; QCI-FP-NEXT:    call function_with_one_stack_arg
+; QCI-FP-NEXT:    call use_i64
+; QCI-FP-NEXT:    sw s7, 124(s1)
+; QCI-FP-NEXT:    sw s5, 120(s1)
+; QCI-FP-NEXT:    sw s4, 116(s1)
+; QCI-FP-NEXT:    sw s3, 112(s1)
+; QCI-FP-NEXT:    sw s2, 108(s1)
+; QCI-FP-NEXT:    sw s11, 104(s1)
+; QCI-FP-NEXT:    sw s10, 100(s1)
+; QCI-FP-NEXT:    sw s9, 96(s1)
+; QCI-FP-NEXT:    sw s8, 92(s1)
+; QCI-FP-NEXT:    lw a0, -232(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 88(s1)
+; QCI-FP-NEXT:    lw a0, -228(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 84(s1)
+; QCI-FP-NEXT:    lw a0, -224(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 80(s1)
+; QCI-FP-NEXT:    lw a0, -220(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 76(s1)
+; QCI-FP-NEXT:    lw a0, -216(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 72(s1)
+; QCI-FP-NEXT:    lw a0, -212(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 68(s1)
+; QCI-FP-NEXT:    lw a0, -208(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 64(s1)
+; QCI-FP-NEXT:    lw a0, -204(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 60(s1)
+; QCI-FP-NEXT:    lw a0, -200(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 56(s1)
+; QCI-FP-NEXT:    lw a0, -196(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 52(s1)
+; QCI-FP-NEXT:    lw a0, -192(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 48(s1)
+; QCI-FP-NEXT:    lw a0, -188(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 44(s1)
+; QCI-FP-NEXT:    lw a0, -184(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 40(s1)
+; QCI-FP-NEXT:    lw a0, -180(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 36(s1)
+; QCI-FP-NEXT:    lw a0, -176(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 32(s1)
+; QCI-FP-NEXT:    lw a0, -172(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 28(s1)
+; QCI-FP-NEXT:    lw a0, -168(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 24(s1)
+; QCI-FP-NEXT:    lw a0, -164(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 20(s1)
+; QCI-FP-NEXT:    lw a0, -160(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 16(s1)
+; QCI-FP-NEXT:    lw a0, -156(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+12)(s6)
+; QCI-FP-NEXT:    lw a0, -152(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+8)(s6)
+; QCI-FP-NEXT:    lw a0, -148(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+4)(s6)
+; QCI-FP-NEXT:    lw a0, -144(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var)(s6)
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 240
+; QCI-FP-NEXT:    lw s1, 140(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s2, 136(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s3, 132(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s4, 128(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s5, 124(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s6, 120(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s7, 116(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s8, 112(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s9, 108(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s10, 104(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s11, 100(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    .cfi_restore s1
+; QCI-FP-NEXT:    .cfi_restore s2
+; QCI-FP-NEXT:    .cfi_restore s3
+; QCI-FP-NEXT:    .cfi_restore s4
+; QCI-FP-NEXT:    .cfi_restore s5
+; QCI-FP-NEXT:    .cfi_restore s6
+; QCI-FP-NEXT:    .cfi_restore s7
+; QCI-FP-NEXT:    .cfi_restore s8
+; QCI-FP-NEXT:    .cfi_restore s9
+; QCI-FP-NEXT:    .cfi_restore s10
+; QCI-FP-NEXT:    .cfi_restore s11
+; QCI-FP-NEXT:    addi sp, sp, 144
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_spill_call_nest:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter.nest
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -144
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 240
+; QCI-PUSH-POP-NEXT:    sw s1, 140(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s2, 136(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s3, 132(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s4, 128(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s5, 124(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s6, 120(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s7, 116(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s8, 112(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s9, 108(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s10, 104(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s11, 100(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    .cfi_offset s1, -100
+; QCI-PUSH-POP-NEXT:    .cfi_offset s2, -104
+; QCI-PUSH-POP-NEXT:    .cfi_offset s3, -108
+; QCI-PUSH-POP-NEXT:    .cfi_offset s4, -112
+; QCI-PUSH-POP-NEXT:    .cfi_offset s5, -116
+; QCI-PUSH-POP-NEXT:    .cfi_offset s6, -120
+; QCI-PUSH-POP-NEXT:    .cfi_offset s7, -124
+; QCI-PUSH-POP-NEXT:    .cfi_offset s8, -128
+; QCI-PUSH-POP-NEXT:    .cfi_offset s9, -132
+; QCI-PUSH-POP-NEXT:    .cfi_offset s10, -136
+; QCI-PUSH-POP-NEXT:    .cfi_offset s11, -140
+; QCI-PUSH-POP-NEXT:    lui s0, %hi(var)
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 96(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    addi s1, s0, %lo(var)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 20(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 24(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 28(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 32(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 36(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 40(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 44(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 48(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 52(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 56(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 60(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 64(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 68(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 72(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 76(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 80(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 84(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw s4, 88(s1)
+; QCI-PUSH-POP-NEXT:    lw s5, 92(s1)
+; QCI-PUSH-POP-NEXT:    lw s6, 96(s1)
+; QCI-PUSH-POP-NEXT:    lw s7, 100(s1)
+; QCI-PUSH-POP-NEXT:    lw s8, 104(s1)
+; QCI-PUSH-POP-NEXT:    lw s9, 108(s1)
+; QCI-PUSH-POP-NEXT:    lw s10, 112(s1)
+; QCI-PUSH-POP-NEXT:    lw s11, 116(s1)
+; QCI-PUSH-POP-NEXT:    lw s2, 120(s1)
+; QCI-PUSH-POP-NEXT:    lw s3, 124(s1)
+; QCI-PUSH-POP-NEXT:    li a0, 4
+; QCI-PUSH-POP-NEXT:    li a2, 1
+; QCI-PUSH-POP-NEXT:    li a4, 2
+; QCI-PUSH-POP-NEXT:    li a6, 3
+; QCI-PUSH-POP-NEXT:    sw a0, 0(sp)
+; QCI-PUSH-POP-NEXT:    li a0, 0
+; QCI-PUSH-POP-NEXT:    li a1, 0
+; QCI-PUSH-POP-NEXT:    li a3, 0
+; QCI-PUSH-POP-NEXT:    li a5, 0
+; QCI-PUSH-POP-NEXT:    li a7, 0
+; QCI-PUSH-POP-NEXT:    call function_with_one_stack_arg
+; QCI-PUSH-POP-NEXT:    call use_i64
+; QCI-PUSH-POP-NEXT:    sw s3, 124(s1)
+; QCI-PUSH-POP-NEXT:    sw s2, 120(s1)
+; QCI-PUSH-POP-NEXT:    sw s11, 116(s1)
+; QCI-PUSH-POP-NEXT:    sw s10, 112(s1)
+; QCI-PUSH-POP-NEXT:    sw s9, 108(s1)
+; QCI-PUSH-POP-NEXT:    sw s8, 104(s1)
+; QCI-PUSH-POP-NEXT:    sw s7, 100(s1)
+; QCI-PUSH-POP-NEXT:    sw s6, 96(s1)
+; QCI-PUSH-POP-NEXT:    sw s5, 92(s1)
+; QCI-PUSH-POP-NEXT:    sw s4, 88(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 84(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 80(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 76(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 72(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 68(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 64(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 60(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 56(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 52(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 48(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 44(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 40(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 36(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 32(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 28(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 24(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 20(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 16(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-PUSH-POP-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-PUSH-POP-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-PUSH-POP-NEXT:    lw a0, 96(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var)(s0)
+; QCI-PUSH-POP-NEXT:    lw s1, 140(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s2, 136(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s3, 132(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s4, 128(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s5, 124(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s6, 120(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s7, 116(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s8, 112(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s9, 108(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s10, 104(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s11, 100(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    .cfi_restore s1
+; QCI-PUSH-POP-NEXT:    .cfi_restore s2
+; QCI-PUSH-POP-NEXT:    .cfi_restore s3
+; QCI-PUSH-POP-NEXT:    .cfi_restore s4
+; QCI-PUSH-POP-NEXT:    .cfi_restore s5
+; QCI-PUSH-POP-NEXT:    .cfi_restore s6
+; QCI-PUSH-POP-NEXT:    .cfi_restore s7
+; QCI-PUSH-POP-NEXT:    .cfi_restore s8
+; QCI-PUSH-POP-NEXT:    .cfi_restore s9
+; QCI-PUSH-POP-NEXT:    .cfi_restore s10
+; QCI-PUSH-POP-NEXT:    .cfi_restore s11
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 144
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  %2 = call i64 @function_with_one_stack_arg(i64 0, i64 1, i64 2, i64 3, i32 4)
+  call void @use_i64(i64 %2)
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
+
+define void @test_spill_call_nonest() "interrupt"="qci-nonest" {
+; QCI-LABEL: test_spill_call_nonest:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -144
+; QCI-NEXT:    .cfi_def_cfa_offset 240
+; QCI-NEXT:    sw s1, 140(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s2, 136(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s3, 132(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s4, 128(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s5, 124(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s6, 120(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s7, 116(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s8, 112(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s9, 108(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s10, 104(sp) # 4-byte Folded Spill
+; QCI-NEXT:    sw s11, 100(sp) # 4-byte Folded Spill
+; QCI-NEXT:    .cfi_offset s1, -100
+; QCI-NEXT:    .cfi_offset s2, -104
+; QCI-NEXT:    .cfi_offset s3, -108
+; QCI-NEXT:    .cfi_offset s4, -112
+; QCI-NEXT:    .cfi_offset s5, -116
+; QCI-NEXT:    .cfi_offset s6, -120
+; QCI-NEXT:    .cfi_offset s7, -124
+; QCI-NEXT:    .cfi_offset s8, -128
+; QCI-NEXT:    .cfi_offset s9, -132
+; QCI-NEXT:    .cfi_offset s10, -136
+; QCI-NEXT:    .cfi_offset s11, -140
+; QCI-NEXT:    lui s0, %hi(var)
+; QCI-NEXT:    lw a0, %lo(var)(s0)
+; QCI-NEXT:    sw a0, 96(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-NEXT:    addi s1, s0, %lo(var)
+; QCI-NEXT:    lw a0, 16(s1)
+; QCI-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 20(s1)
+; QCI-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 24(s1)
+; QCI-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 28(s1)
+; QCI-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 32(s1)
+; QCI-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 36(s1)
+; QCI-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 40(s1)
+; QCI-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 44(s1)
+; QCI-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 48(s1)
+; QCI-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 52(s1)
+; QCI-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 56(s1)
+; QCI-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 60(s1)
+; QCI-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 64(s1)
+; QCI-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 68(s1)
+; QCI-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 72(s1)
+; QCI-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 76(s1)
+; QCI-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 80(s1)
+; QCI-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw a0, 84(s1)
+; QCI-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-NEXT:    lw s4, 88(s1)
+; QCI-NEXT:    lw s5, 92(s1)
+; QCI-NEXT:    lw s6, 96(s1)
+; QCI-NEXT:    lw s7, 100(s1)
+; QCI-NEXT:    lw s8, 104(s1)
+; QCI-NEXT:    lw s9, 108(s1)
+; QCI-NEXT:    lw s10, 112(s1)
+; QCI-NEXT:    lw s11, 116(s1)
+; QCI-NEXT:    lw s2, 120(s1)
+; QCI-NEXT:    lw s3, 124(s1)
+; QCI-NEXT:    li a0, 4
+; QCI-NEXT:    li a2, 1
+; QCI-NEXT:    li a4, 2
+; QCI-NEXT:    li a6, 3
+; QCI-NEXT:    sw a0, 0(sp)
+; QCI-NEXT:    li a0, 0
+; QCI-NEXT:    li a1, 0
+; QCI-NEXT:    li a3, 0
+; QCI-NEXT:    li a5, 0
+; QCI-NEXT:    li a7, 0
+; QCI-NEXT:    call function_with_one_stack_arg
+; QCI-NEXT:    call use_i64
+; QCI-NEXT:    sw s3, 124(s1)
+; QCI-NEXT:    sw s2, 120(s1)
+; QCI-NEXT:    sw s11, 116(s1)
+; QCI-NEXT:    sw s10, 112(s1)
+; QCI-NEXT:    sw s9, 108(s1)
+; QCI-NEXT:    sw s8, 104(s1)
+; QCI-NEXT:    sw s7, 100(s1)
+; QCI-NEXT:    sw s6, 96(s1)
+; QCI-NEXT:    sw s5, 92(s1)
+; QCI-NEXT:    sw s4, 88(s1)
+; QCI-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 84(s1)
+; QCI-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 80(s1)
+; QCI-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 76(s1)
+; QCI-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 72(s1)
+; QCI-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 68(s1)
+; QCI-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 64(s1)
+; QCI-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 60(s1)
+; QCI-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 56(s1)
+; QCI-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 52(s1)
+; QCI-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 48(s1)
+; QCI-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 44(s1)
+; QCI-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 40(s1)
+; QCI-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 36(s1)
+; QCI-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 32(s1)
+; QCI-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 28(s1)
+; QCI-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 24(s1)
+; QCI-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 20(s1)
+; QCI-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, 16(s1)
+; QCI-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-NEXT:    lw a0, 96(sp) # 4-byte Folded Reload
+; QCI-NEXT:    sw a0, %lo(var)(s0)
+; QCI-NEXT:    lw s1, 140(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s2, 136(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s3, 132(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s4, 128(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s5, 124(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s6, 120(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s7, 116(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s8, 112(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s9, 108(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s10, 104(sp) # 4-byte Folded Reload
+; QCI-NEXT:    lw s11, 100(sp) # 4-byte Folded Reload
+; QCI-NEXT:    .cfi_restore s1
+; QCI-NEXT:    .cfi_restore s2
+; QCI-NEXT:    .cfi_restore s3
+; QCI-NEXT:    .cfi_restore s4
+; QCI-NEXT:    .cfi_restore s5
+; QCI-NEXT:    .cfi_restore s6
+; QCI-NEXT:    .cfi_restore s7
+; QCI-NEXT:    .cfi_restore s8
+; QCI-NEXT:    .cfi_restore s9
+; QCI-NEXT:    .cfi_restore s10
+; QCI-NEXT:    .cfi_restore s11
+; QCI-NEXT:    addi sp, sp, 144
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_spill_call_nonest:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -144
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 240
+; QCI-FP-NEXT:    sw s1, 140(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s2, 136(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s3, 132(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s4, 128(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s5, 124(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s6, 120(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s7, 116(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s8, 112(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s9, 108(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s10, 104(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    sw s11, 100(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    .cfi_offset s1, -100
+; QCI-FP-NEXT:    .cfi_offset s2, -104
+; QCI-FP-NEXT:    .cfi_offset s3, -108
+; QCI-FP-NEXT:    .cfi_offset s4, -112
+; QCI-FP-NEXT:    .cfi_offset s5, -116
+; QCI-FP-NEXT:    .cfi_offset s6, -120
+; QCI-FP-NEXT:    .cfi_offset s7, -124
+; QCI-FP-NEXT:    .cfi_offset s8, -128
+; QCI-FP-NEXT:    .cfi_offset s9, -132
+; QCI-FP-NEXT:    .cfi_offset s10, -136
+; QCI-FP-NEXT:    .cfi_offset s11, -140
+; QCI-FP-NEXT:    addi s0, sp, 240
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    lui s6, %hi(var)
+; QCI-FP-NEXT:    lw a0, %lo(var)(s6)
+; QCI-FP-NEXT:    sw a0, -144(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+4)(s6)
+; QCI-FP-NEXT:    sw a0, -148(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+8)(s6)
+; QCI-FP-NEXT:    sw a0, -152(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, %lo(var+12)(s6)
+; QCI-FP-NEXT:    sw a0, -156(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    addi s1, s6, %lo(var)
+; QCI-FP-NEXT:    lw a0, 16(s1)
+; QCI-FP-NEXT:    sw a0, -160(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 20(s1)
+; QCI-FP-NEXT:    sw a0, -164(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 24(s1)
+; QCI-FP-NEXT:    sw a0, -168(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 28(s1)
+; QCI-FP-NEXT:    sw a0, -172(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 32(s1)
+; QCI-FP-NEXT:    sw a0, -176(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 36(s1)
+; QCI-FP-NEXT:    sw a0, -180(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 40(s1)
+; QCI-FP-NEXT:    sw a0, -184(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 44(s1)
+; QCI-FP-NEXT:    sw a0, -188(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 48(s1)
+; QCI-FP-NEXT:    sw a0, -192(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 52(s1)
+; QCI-FP-NEXT:    sw a0, -196(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 56(s1)
+; QCI-FP-NEXT:    sw a0, -200(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 60(s1)
+; QCI-FP-NEXT:    sw a0, -204(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 64(s1)
+; QCI-FP-NEXT:    sw a0, -208(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 68(s1)
+; QCI-FP-NEXT:    sw a0, -212(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 72(s1)
+; QCI-FP-NEXT:    sw a0, -216(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 76(s1)
+; QCI-FP-NEXT:    sw a0, -220(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 80(s1)
+; QCI-FP-NEXT:    sw a0, -224(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 84(s1)
+; QCI-FP-NEXT:    sw a0, -228(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw a0, 88(s1)
+; QCI-FP-NEXT:    sw a0, -232(s0) # 4-byte Folded Spill
+; QCI-FP-NEXT:    lw s8, 92(s1)
+; QCI-FP-NEXT:    lw s9, 96(s1)
+; QCI-FP-NEXT:    lw s10, 100(s1)
+; QCI-FP-NEXT:    lw s11, 104(s1)
+; QCI-FP-NEXT:    lw s2, 108(s1)
+; QCI-FP-NEXT:    lw s3, 112(s1)
+; QCI-FP-NEXT:    lw s4, 116(s1)
+; QCI-FP-NEXT:    lw s5, 120(s1)
+; QCI-FP-NEXT:    lw s7, 124(s1)
+; QCI-FP-NEXT:    li a0, 4
+; QCI-FP-NEXT:    li a2, 1
+; QCI-FP-NEXT:    li a4, 2
+; QCI-FP-NEXT:    li a6, 3
+; QCI-FP-NEXT:    sw a0, 0(sp)
+; QCI-FP-NEXT:    li a0, 0
+; QCI-FP-NEXT:    li a1, 0
+; QCI-FP-NEXT:    li a3, 0
+; QCI-FP-NEXT:    li a5, 0
+; QCI-FP-NEXT:    li a7, 0
+; QCI-FP-NEXT:    call function_with_one_stack_arg
+; QCI-FP-NEXT:    call use_i64
+; QCI-FP-NEXT:    sw s7, 124(s1)
+; QCI-FP-NEXT:    sw s5, 120(s1)
+; QCI-FP-NEXT:    sw s4, 116(s1)
+; QCI-FP-NEXT:    sw s3, 112(s1)
+; QCI-FP-NEXT:    sw s2, 108(s1)
+; QCI-FP-NEXT:    sw s11, 104(s1)
+; QCI-FP-NEXT:    sw s10, 100(s1)
+; QCI-FP-NEXT:    sw s9, 96(s1)
+; QCI-FP-NEXT:    sw s8, 92(s1)
+; QCI-FP-NEXT:    lw a0, -232(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 88(s1)
+; QCI-FP-NEXT:    lw a0, -228(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 84(s1)
+; QCI-FP-NEXT:    lw a0, -224(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 80(s1)
+; QCI-FP-NEXT:    lw a0, -220(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 76(s1)
+; QCI-FP-NEXT:    lw a0, -216(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 72(s1)
+; QCI-FP-NEXT:    lw a0, -212(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 68(s1)
+; QCI-FP-NEXT:    lw a0, -208(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 64(s1)
+; QCI-FP-NEXT:    lw a0, -204(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 60(s1)
+; QCI-FP-NEXT:    lw a0, -200(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 56(s1)
+; QCI-FP-NEXT:    lw a0, -196(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 52(s1)
+; QCI-FP-NEXT:    lw a0, -192(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 48(s1)
+; QCI-FP-NEXT:    lw a0, -188(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 44(s1)
+; QCI-FP-NEXT:    lw a0, -184(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 40(s1)
+; QCI-FP-NEXT:    lw a0, -180(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 36(s1)
+; QCI-FP-NEXT:    lw a0, -176(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 32(s1)
+; QCI-FP-NEXT:    lw a0, -172(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 28(s1)
+; QCI-FP-NEXT:    lw a0, -168(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 24(s1)
+; QCI-FP-NEXT:    lw a0, -164(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 20(s1)
+; QCI-FP-NEXT:    lw a0, -160(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, 16(s1)
+; QCI-FP-NEXT:    lw a0, -156(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+12)(s6)
+; QCI-FP-NEXT:    lw a0, -152(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+8)(s6)
+; QCI-FP-NEXT:    lw a0, -148(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var+4)(s6)
+; QCI-FP-NEXT:    lw a0, -144(s0) # 4-byte Folded Reload
+; QCI-FP-NEXT:    sw a0, %lo(var)(s6)
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 240
+; QCI-FP-NEXT:    lw s1, 140(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s2, 136(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s3, 132(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s4, 128(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s5, 124(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s6, 120(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s7, 116(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s8, 112(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s9, 108(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s10, 104(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    lw s11, 100(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    .cfi_restore s1
+; QCI-FP-NEXT:    .cfi_restore s2
+; QCI-FP-NEXT:    .cfi_restore s3
+; QCI-FP-NEXT:    .cfi_restore s4
+; QCI-FP-NEXT:    .cfi_restore s5
+; QCI-FP-NEXT:    .cfi_restore s6
+; QCI-FP-NEXT:    .cfi_restore s7
+; QCI-FP-NEXT:    .cfi_restore s8
+; QCI-FP-NEXT:    .cfi_restore s9
+; QCI-FP-NEXT:    .cfi_restore s10
+; QCI-FP-NEXT:    .cfi_restore s11
+; QCI-FP-NEXT:    addi sp, sp, 144
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_spill_call_nonest:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -144
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 240
+; QCI-PUSH-POP-NEXT:    sw s1, 140(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s2, 136(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s3, 132(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s4, 128(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s5, 124(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s6, 120(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s7, 116(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s8, 112(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s9, 108(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s10, 104(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    sw s11, 100(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    .cfi_offset s1, -100
+; QCI-PUSH-POP-NEXT:    .cfi_offset s2, -104
+; QCI-PUSH-POP-NEXT:    .cfi_offset s3, -108
+; QCI-PUSH-POP-NEXT:    .cfi_offset s4, -112
+; QCI-PUSH-POP-NEXT:    .cfi_offset s5, -116
+; QCI-PUSH-POP-NEXT:    .cfi_offset s6, -120
+; QCI-PUSH-POP-NEXT:    .cfi_offset s7, -124
+; QCI-PUSH-POP-NEXT:    .cfi_offset s8, -128
+; QCI-PUSH-POP-NEXT:    .cfi_offset s9, -132
+; QCI-PUSH-POP-NEXT:    .cfi_offset s10, -136
+; QCI-PUSH-POP-NEXT:    .cfi_offset s11, -140
+; QCI-PUSH-POP-NEXT:    lui s0, %hi(var)
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 96(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+4)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 92(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+8)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 88(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, %lo(var+12)(s0)
+; QCI-PUSH-POP-NEXT:    sw a0, 84(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    addi s1, s0, %lo(var)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 80(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 20(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 76(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 24(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 72(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 28(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 68(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 32(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 64(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 36(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 60(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 40(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 56(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 44(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 52(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 48(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 48(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 52(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 44(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 56(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 40(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 60(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 36(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 64(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 32(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 68(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 28(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 72(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 24(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 76(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 20(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 80(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 16(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw a0, 84(s1)
+; QCI-PUSH-POP-NEXT:    sw a0, 12(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    lw s4, 88(s1)
+; QCI-PUSH-POP-NEXT:    lw s5, 92(s1)
+; QCI-PUSH-POP-NEXT:    lw s6, 96(s1)
+; QCI-PUSH-POP-NEXT:    lw s7, 100(s1)
+; QCI-PUSH-POP-NEXT:    lw s8, 104(s1)
+; QCI-PUSH-POP-NEXT:    lw s9, 108(s1)
+; QCI-PUSH-POP-NEXT:    lw s10, 112(s1)
+; QCI-PUSH-POP-NEXT:    lw s11, 116(s1)
+; QCI-PUSH-POP-NEXT:    lw s2, 120(s1)
+; QCI-PUSH-POP-NEXT:    lw s3, 124(s1)
+; QCI-PUSH-POP-NEXT:    li a0, 4
+; QCI-PUSH-POP-NEXT:    li a2, 1
+; QCI-PUSH-POP-NEXT:    li a4, 2
+; QCI-PUSH-POP-NEXT:    li a6, 3
+; QCI-PUSH-POP-NEXT:    sw a0, 0(sp)
+; QCI-PUSH-POP-NEXT:    li a0, 0
+; QCI-PUSH-POP-NEXT:    li a1, 0
+; QCI-PUSH-POP-NEXT:    li a3, 0
+; QCI-PUSH-POP-NEXT:    li a5, 0
+; QCI-PUSH-POP-NEXT:    li a7, 0
+; QCI-PUSH-POP-NEXT:    call function_with_one_stack_arg
+; QCI-PUSH-POP-NEXT:    call use_i64
+; QCI-PUSH-POP-NEXT:    sw s3, 124(s1)
+; QCI-PUSH-POP-NEXT:    sw s2, 120(s1)
+; QCI-PUSH-POP-NEXT:    sw s11, 116(s1)
+; QCI-PUSH-POP-NEXT:    sw s10, 112(s1)
+; QCI-PUSH-POP-NEXT:    sw s9, 108(s1)
+; QCI-PUSH-POP-NEXT:    sw s8, 104(s1)
+; QCI-PUSH-POP-NEXT:    sw s7, 100(s1)
+; QCI-PUSH-POP-NEXT:    sw s6, 96(s1)
+; QCI-PUSH-POP-NEXT:    sw s5, 92(s1)
+; QCI-PUSH-POP-NEXT:    sw s4, 88(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 12(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 84(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 16(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 80(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 20(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 76(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 24(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 72(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 28(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 68(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 32(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 64(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 36(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 60(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 40(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 56(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 44(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 52(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 48(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 48(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 52(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 44(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 56(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 40(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 60(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 36(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 64(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 32(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 68(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 28(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 72(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 24(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 76(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 20(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 80(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, 16(s1)
+; QCI-PUSH-POP-NEXT:    lw a0, 84(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+12)(s0)
+; QCI-PUSH-POP-NEXT:    lw a0, 88(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+8)(s0)
+; QCI-PUSH-POP-NEXT:    lw a0, 92(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var+4)(s0)
+; QCI-PUSH-POP-NEXT:    lw a0, 96(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    sw a0, %lo(var)(s0)
+; QCI-PUSH-POP-NEXT:    lw s1, 140(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s2, 136(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s3, 132(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s4, 128(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s5, 124(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s6, 120(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s7, 116(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s8, 112(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s9, 108(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s10, 104(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    lw s11, 100(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    .cfi_restore s1
+; QCI-PUSH-POP-NEXT:    .cfi_restore s2
+; QCI-PUSH-POP-NEXT:    .cfi_restore s3
+; QCI-PUSH-POP-NEXT:    .cfi_restore s4
+; QCI-PUSH-POP-NEXT:    .cfi_restore s5
+; QCI-PUSH-POP-NEXT:    .cfi_restore s6
+; QCI-PUSH-POP-NEXT:    .cfi_restore s7
+; QCI-PUSH-POP-NEXT:    .cfi_restore s8
+; QCI-PUSH-POP-NEXT:    .cfi_restore s9
+; QCI-PUSH-POP-NEXT:    .cfi_restore s10
+; QCI-PUSH-POP-NEXT:    .cfi_restore s11
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 144
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  %1 = load [32 x i32], ptr @var
+  %2 = call i64 @function_with_one_stack_arg(i64 0, i64 1, i64 2, i64 3, i32 4)
+  call void @use_i64(i64 %2)
+  store volatile [32 x i32] %1, ptr @var
+  ret void
+}
+
+define void @test_nest_explicit_s11() "interrupt"="qci-nest" {
+; QCI-LABEL: test_nest_explicit_s11:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter.nest
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -16
+; QCI-NEXT:    .cfi_def_cfa_offset 112
+; QCI-NEXT:    sw s11, 12(sp) # 4-byte Folded Spill
+; QCI-NEXT:    .cfi_offset s11, -100
+; QCI-NEXT:    #APP
+; QCI-NEXT:    li s4, 0
+; QCI-NEXT:    #NO_APP
+; QCI-NEXT:    lw s11, 12(sp) # 4-byte Folded Reload
+; QCI-NEXT:    .cfi_restore s11
+; QCI-NEXT:    addi sp, sp, 16
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nest_explicit_s11:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter.nest
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-FP-NEXT:    sw s11, 12(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    .cfi_offset s11, -100
+; QCI-FP-NEXT:    addi s0, sp, 112
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    #APP
+; QCI-FP-NEXT:    li s4, 0
+; QCI-FP-NEXT:    #NO_APP
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 112
+; QCI-FP-NEXT:    lw s11, 12(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    .cfi_restore s11
+; QCI-FP-NEXT:    addi sp, sp, 16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nest_explicit_s11:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter.nest
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-PUSH-POP-NEXT:    sw s11, 12(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    .cfi_offset s11, -100
+; QCI-PUSH-POP-NEXT:    #APP
+; QCI-PUSH-POP-NEXT:    li s4, 0
+; QCI-PUSH-POP-NEXT:    #NO_APP
+; QCI-PUSH-POP-NEXT:    lw s11, 12(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    .cfi_restore s11
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  tail call void asm sideeffect "li s4, 0", "~{s11}"()
+  ret void
+}
+
+define void @test_nonest_explicit_s11() "interrupt"="qci-nonest" {
+; QCI-LABEL: test_nonest_explicit_s11:
+; QCI:       # %bb.0:
+; QCI-NEXT:    qc.c.mienter
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    .cfi_offset ra, -16
+; QCI-NEXT:    .cfi_offset t0, -24
+; QCI-NEXT:    .cfi_offset t1, -28
+; QCI-NEXT:    .cfi_offset t2, -32
+; QCI-NEXT:    .cfi_offset s0, -8
+; QCI-NEXT:    .cfi_offset a0, -36
+; QCI-NEXT:    .cfi_offset a1, -40
+; QCI-NEXT:    .cfi_offset a2, -44
+; QCI-NEXT:    .cfi_offset a3, -48
+; QCI-NEXT:    .cfi_offset a4, -52
+; QCI-NEXT:    .cfi_offset a5, -56
+; QCI-NEXT:    .cfi_offset a6, -60
+; QCI-NEXT:    .cfi_offset a7, -64
+; QCI-NEXT:    .cfi_offset t3, -68
+; QCI-NEXT:    .cfi_offset t4, -72
+; QCI-NEXT:    .cfi_offset t5, -76
+; QCI-NEXT:    .cfi_offset t6, -80
+; QCI-NEXT:    addi sp, sp, -16
+; QCI-NEXT:    .cfi_def_cfa_offset 112
+; QCI-NEXT:    sw s11, 12(sp) # 4-byte Folded Spill
+; QCI-NEXT:    .cfi_offset s11, -100
+; QCI-NEXT:    #APP
+; QCI-NEXT:    li s11, 0
+; QCI-NEXT:    #NO_APP
+; QCI-NEXT:    lw s11, 12(sp) # 4-byte Folded Reload
+; QCI-NEXT:    .cfi_restore s11
+; QCI-NEXT:    addi sp, sp, 16
+; QCI-NEXT:    .cfi_def_cfa_offset 96
+; QCI-NEXT:    qc.c.mileaveret
+;
+; QCI-FP-LABEL: test_nonest_explicit_s11:
+; QCI-FP:       # %bb.0:
+; QCI-FP-NEXT:    qc.c.mienter
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    .cfi_offset ra, -16
+; QCI-FP-NEXT:    .cfi_offset t0, -24
+; QCI-FP-NEXT:    .cfi_offset t1, -28
+; QCI-FP-NEXT:    .cfi_offset t2, -32
+; QCI-FP-NEXT:    .cfi_offset s0, -8
+; QCI-FP-NEXT:    .cfi_offset a0, -36
+; QCI-FP-NEXT:    .cfi_offset a1, -40
+; QCI-FP-NEXT:    .cfi_offset a2, -44
+; QCI-FP-NEXT:    .cfi_offset a3, -48
+; QCI-FP-NEXT:    .cfi_offset a4, -52
+; QCI-FP-NEXT:    .cfi_offset a5, -56
+; QCI-FP-NEXT:    .cfi_offset a6, -60
+; QCI-FP-NEXT:    .cfi_offset a7, -64
+; QCI-FP-NEXT:    .cfi_offset t3, -68
+; QCI-FP-NEXT:    .cfi_offset t4, -72
+; QCI-FP-NEXT:    .cfi_offset t5, -76
+; QCI-FP-NEXT:    .cfi_offset t6, -80
+; QCI-FP-NEXT:    addi sp, sp, -16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-FP-NEXT:    sw s11, 12(sp) # 4-byte Folded Spill
+; QCI-FP-NEXT:    .cfi_offset s11, -100
+; QCI-FP-NEXT:    addi s0, sp, 112
+; QCI-FP-NEXT:    .cfi_def_cfa s0, 0
+; QCI-FP-NEXT:    #APP
+; QCI-FP-NEXT:    li s11, 0
+; QCI-FP-NEXT:    #NO_APP
+; QCI-FP-NEXT:    .cfi_def_cfa sp, 112
+; QCI-FP-NEXT:    lw s11, 12(sp) # 4-byte Folded Reload
+; QCI-FP-NEXT:    .cfi_restore s11
+; QCI-FP-NEXT:    addi sp, sp, 16
+; QCI-FP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-FP-NEXT:    qc.c.mileaveret
+;
+; QCI-PUSH-POP-LABEL: test_nonest_explicit_s11:
+; QCI-PUSH-POP:       # %bb.0:
+; QCI-PUSH-POP-NEXT:    qc.c.mienter
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    .cfi_offset ra, -16
+; QCI-PUSH-POP-NEXT:    .cfi_offset t0, -24
+; QCI-PUSH-POP-NEXT:    .cfi_offset t1, -28
+; QCI-PUSH-POP-NEXT:    .cfi_offset t2, -32
+; QCI-PUSH-POP-NEXT:    .cfi_offset s0, -8
+; QCI-PUSH-POP-NEXT:    .cfi_offset a0, -36
+; QCI-PUSH-POP-NEXT:    .cfi_offset a1, -40
+; QCI-PUSH-POP-NEXT:    .cfi_offset a2, -44
+; QCI-PUSH-POP-NEXT:    .cfi_offset a3, -48
+; QCI-PUSH-POP-NEXT:    .cfi_offset a4, -52
+; QCI-PUSH-POP-NEXT:    .cfi_offset a5, -56
+; QCI-PUSH-POP-NEXT:    .cfi_offset a6, -60
+; QCI-PUSH-POP-NEXT:    .cfi_offset a7, -64
+; QCI-PUSH-POP-NEXT:    .cfi_offset t3, -68
+; QCI-PUSH-POP-NEXT:    .cfi_offset t4, -72
+; QCI-PUSH-POP-NEXT:    .cfi_offset t5, -76
+; QCI-PUSH-POP-NEXT:    .cfi_offset t6, -80
+; QCI-PUSH-POP-NEXT:    addi sp, sp, -16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 112
+; QCI-PUSH-POP-NEXT:    sw s11, 12(sp) # 4-byte Folded Spill
+; QCI-PUSH-POP-NEXT:    .cfi_offset s11, -100
+; QCI-PUSH-POP-NEXT:    #APP
+; QCI-PUSH-POP-NEXT:    li s11, 0
+; QCI-PUSH-POP-NEXT:    #NO_APP
+; QCI-PUSH-POP-NEXT:    lw s11, 12(sp) # 4-byte Folded Reload
+; QCI-PUSH-POP-NEXT:    .cfi_restore s11
+; QCI-PUSH-POP-NEXT:    addi sp, sp, 16
+; QCI-PUSH-POP-NEXT:    .cfi_def_cfa_offset 96
+; QCI-PUSH-POP-NEXT:    qc.c.mileaveret
+  tail call void asm sideeffect "li s11, 0", "~{s11}"()
+  ret void
+}