[clang] [llvm] [RISCV] QCI Interrupt Support (PR #129957)
Sam Elliott via cfe-commits
cfe-commits at lists.llvm.org
Wed Mar 5 17:20:37 PST 2025
https://github.com/lenary updated https://github.com/llvm/llvm-project/pull/129957
>From 984e265ce975e77f248d16d931022bcc1c6a3cca Mon Sep 17 00:00:00 2001
From: Sam Elliott <quic_aelliott at quicinc.com>
Date: Wed, 5 Mar 2025 11:44:03 -0800
Subject: [PATCH 1/2] [RISCV] QCI Interrupt Support
This change adds support for `qci-nest` and `qci-nonest` interrupt
attribute values. Both of these are machine-mode interrupts, which use
instructions in Xqciint to push and pop A- and T-registers (and a few
others) from the stack.
In particular:
- `qci-nonest` uses `qc.c.mienter` to save registers at the start of the
function, and uses `qc.c.mileaveret` to restore those registers and
return from the interrupt.
- `qci-nest` uses `qc.c.mienter.nest` to save registers at the start of
the function, and uses `qc.c.mileaveret` to restore those registers
and return from the interrupt.
- `qc.c.mienter` and `qc.c.mienter.nest` both push registers ra, s0
(fp), t0-t6, and a0-a10 onto the stack (as well as some CSRs for the
interrupt context). The difference between these is that
`qc.c.mienter.nest` re-enables M-mode interrupts.
- `qc.c.mileaveret` will restore the registers that were saved by
`qc.c.mienter(.nest)`, and return from the interrupt.
These work for both standard M-mode interrupts and the non-maskable
interrupt CSRs added by Xqciint.
The `qc.c.mienter`, `qc.c.mienter.nest` and `qc.c.mileaveret`
instructions are compatible with push and pop instructions, in as much
as they (mostly) only spill the A- and T-registers, so we can use the
`Zcmp` or `Xqccmp` instructions to spill the S-registers. This
combination (`qci-(no)nest` and `Xqccmp`/`Zcmp`) is not implemented in
this change.
The `qc.c.mienter(.nest)` instructions have a specific register storage
order so they preserve the frame pointer convention linked list past the
current interrupt handler and into the interrupted code and frames if
frame pointers are enabled.
Co-authored-by: Pankaj Gode <quic_pgode at quicinc.com>
---
clang/include/clang/Basic/Attr.td | 4 +-
clang/include/clang/Basic/AttrDocs.td | 14 +-
.../clang/Basic/DiagnosticSemaKinds.td | 5 +-
clang/lib/CodeGen/Targets/RISCV.cpp | 6 +
clang/lib/Sema/SemaRISCV.cpp | 21 +
clang/test/Sema/riscv-interrupt-attr-qci.c | 51 +
llvm/lib/Target/RISCV/RISCVFrameLowering.cpp | 131 +-
llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 20 +-
llvm/lib/Target/RISCV/RISCVISelLowering.h | 1 +
llvm/lib/Target/RISCV/RISCVInstrInfo.td | 2 +
llvm/lib/Target/RISCV/RISCVInstrInfoXqci.td | 27 +-
.../Target/RISCV/RISCVMachineFunctionInfo.cpp | 19 +
.../Target/RISCV/RISCVMachineFunctionInfo.h | 18 +-
.../CodeGen/RISCV/qci-interrupt-attr-fpr.ll | 2821 ++++++++++++++++
llvm/test/CodeGen/RISCV/qci-interrupt-attr.ll | 2927 +++++++++++++++++
15 files changed, 6036 insertions(+), 31 deletions(-)
create mode 100644 clang/test/Sema/riscv-interrupt-attr-qci.c
create mode 100644 llvm/test/CodeGen/RISCV/qci-interrupt-attr-fpr.ll
create mode 100644 llvm/test/CodeGen/RISCV/qci-interrupt-attr.ll
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..d7ac82c7a0006 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 the 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..94e8fa6a6c0c6 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<uint64_t>(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,23 @@ 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 +2143,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 +2214,11 @@ bool RISCVFrameLowering::canUseAsEpilogue(const MachineBasicBlock &MBB) const {
MachineBasicBlock *TmpMBB = const_cast<MachineBasicBlock *>(&MBB);
const auto *RVFI = MF->getInfo<RISCVMachineFunctionInfo>();
+ // Qe 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..ddf878466286a 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 StringRef 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
+}
+
+ at 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
+}
+
+ at 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
+}
>From c21c555a0b2fd409a85fd593625c87e474749d7b Mon Sep 17 00:00:00 2001
From: Sam Elliott <quic_aelliott at quicinc.com>
Date: Wed, 5 Mar 2025 17:20:20 -0800
Subject: [PATCH 2/2] fixup! [RISCV] QCI Interrupt Support
---
clang/include/clang/Basic/AttrDocs.td | 4 ++--
llvm/lib/Target/RISCV/RISCVFrameLowering.cpp | 7 +++----
llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 2 +-
3 files changed, 6 insertions(+), 7 deletions(-)
diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td
index d7ac82c7a0006..fdc58d1c92c0d 100644
--- a/clang/include/clang/Basic/AttrDocs.td
+++ b/clang/include/clang/Basic/AttrDocs.td
@@ -2832,8 +2832,8 @@ 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 the Qualcomm's Xqciint
-extension and are used for Machine-mode Interrupts and Machine-mode Non-maskable
+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
diff --git a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
index 94e8fa6a6c0c6..6b61a236cf570 100644
--- a/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVFrameLowering.cpp
@@ -412,7 +412,7 @@ void RISCVFrameLowering::determineFrameLayout(MachineFunction &MF) const {
// QCI Interrupts use at least 96 bytes of stack space
if (RVFI->useQCIInterrupt(MF))
- FrameSize = std::max<uint64_t>(FrameSize, QCIInterruptPushAmount);
+ FrameSize = std::max(FrameSize, QCIInterruptPushAmount);
// Get the alignment.
Align StackAlign = getStackAlign();
@@ -1981,9 +1981,8 @@ bool RISCVFrameLowering::spillCalleeSavedRegisters(
: RISCV::QC_C_MIENTER))
.setMIFlag(MachineInstr::FrameSetup);
- for (auto [Reg, _Offset] : FixedCSRFIQCIInterruptMap) {
+ 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
@@ -2214,7 +2213,7 @@ bool RISCVFrameLowering::canUseAsEpilogue(const MachineBasicBlock &MBB) const {
MachineBasicBlock *TmpMBB = const_cast<MachineBasicBlock *>(&MBB);
const auto *RVFI = MF->getInfo<RISCVMachineFunctionInfo>();
- // Qe do not want QC.C.MILEAVERET to be subject to shrink-wrapping - it must
+ // 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();
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index ddf878466286a..36d113a63cd1d 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -20831,7 +20831,7 @@ SDValue RISCVTargetLowering::LowerFormalArguments(
StringRef Kind =
MF.getFunction().getFnAttribute("interrupt").getValueAsString();
- constexpr StringRef SupportedInterruptKinds[] = {
+ constexpr StringLiteral SupportedInterruptKinds[] = {
"machine",
"supervisor",
"qci-nest",
More information about the cfe-commits
mailing list