Index: lib/Target/RISCV/RISCVCallingConv.td
===================================================================
--- lib/Target/RISCV/RISCVCallingConv.td
+++ lib/Target/RISCV/RISCVCallingConv.td
@@ -18,3 +18,31 @@
 
 // Needed for implementation of RISCVRegisterInfo::getNoPreservedMask()
 def CSR_NoRegs : CalleeSavedRegs<(add)>;
+
+// Interrupt handler needs to save/restore caller-saved registers
+// as callee-saved registers.
+def CSR_Interrupt : CalleeSavedRegs<(add X1,
+    (sequence "X%u", 5, 8),
+    (sequence "X%u", 10, 17),
+    (sequence "X%u", 28, 31))>;
+
+def CSR_X32_F32_Interrupt : CalleeSavedRegs<(add X1,
+    (sequence "X%u", 5, 8),
+    (sequence "X%u", 10, 17),
+    (sequence "X%u", 28, 31),
+    (sequence "F%u_32", 0, 7),
+    (sequence "F%u_32", 10, 17),
+    (sequence "F%u_32", 28, 31),
+    (sequence "F%u_32", 8, 9),
+    (sequence "F%u_32", 18, 27))>;
+
+def CSR_X32_F64_Interrupt : CalleeSavedRegs<(add X1,
+    (sequence "X%u", 5, 8),
+    (sequence "X%u", 10, 17),
+    (sequence "X%u", 28, 31),
+    (sequence "F%u_64", 0, 7),
+    (sequence "F%u_64", 10, 17),
+    (sequence "F%u_64", 28, 31),
+    (sequence "F%u_64", 8, 9),
+    (sequence "F%u_64", 18, 27))>;
+
Index: lib/Target/RISCV/RISCVFrameLowering.cpp
===================================================================
--- lib/Target/RISCV/RISCVFrameLowering.cpp
+++ lib/Target/RISCV/RISCVFrameLowering.cpp
@@ -212,6 +212,17 @@
     SavedRegs.set(RISCV::X1);
     SavedRegs.set(RISCV::X8);
   }
+
+  // If interrupt is enabled and there are calls, save all registers
+  // regardless whether they are used.
+  if (MF.getFunction().hasFnAttribute("interrupt")) {
+    MachineFrameInfo &MFI = MF.getFrameInfo();
+    if(MFI.hasCalls()) {
+      const MCPhysReg *CSRegs = MF.getRegInfo().getCalleeSavedRegs();
+      for (unsigned i = 0; CSRegs[i]; ++i)
+        SavedRegs.set(CSRegs[i]);
+    }
+  }
 }
 
 void RISCVFrameLowering::processFunctionBeforeFrameFinalized(
Index: lib/Target/RISCV/RISCVISelLowering.h
===================================================================
--- lib/Target/RISCV/RISCVISelLowering.h
+++ lib/Target/RISCV/RISCVISelLowering.h
@@ -25,6 +25,9 @@
 enum NodeType : unsigned {
   FIRST_NUMBER = ISD::BUILTIN_OP_END,
   RET_FLAG,
+  URET_FLAG,
+  SRET_FLAG,
+  MRET_FLAG,
   CALL,
   SELECT_CC,
   BuildPairF64,
Index: lib/Target/RISCV/RISCVISelLowering.cpp
===================================================================
--- lib/Target/RISCV/RISCVISelLowering.cpp
+++ lib/Target/RISCV/RISCVISelLowering.cpp
@@ -967,6 +967,21 @@
   }
 
   MachineFunction &MF = DAG.getMachineFunction();
+
+  const Function &Func = MF.getFunction();
+  if (Func.hasFnAttribute("interrupt")) {
+    if (!Func.arg_empty())
+      report_fatal_error(
+        "Functions with the interrupt attribute cannot have arguments!");
+
+    StringRef Kind =
+      MF.getFunction().getFnAttribute("interrupt").getValueAsString();
+
+    if (!(Kind == "user" || Kind == "supervisor" || Kind == "machine"))
+      report_fatal_error(
+        "Function interrupt attribute argument not supported!");
+  }
+
   EVT PtrVT = getPointerTy(DAG.getDataLayout());
   MVT XLenVT = Subtarget.getXLenVT();
   unsigned XLenInBytes = Subtarget.getXLen() / 8;
@@ -1515,6 +1530,28 @@
     RetOps.push_back(Glue);
   }
 
+  // Interrupt service routines use different return instructions.
+  const Function &Func = DAG.getMachineFunction().getFunction();
+  if (Func.hasFnAttribute("interrupt")) {
+    if (!Func.getReturnType()->isVoidTy())
+      report_fatal_error(
+          "Functions with the interrupt attribute must have void return type!");
+
+    MachineFunction &MF = DAG.getMachineFunction();
+    StringRef Kind =
+      MF.getFunction().getFnAttribute("interrupt").getValueAsString();
+
+    unsigned RetOpc;
+    if (Kind == "user")
+      RetOpc = RISCVISD::URET_FLAG;
+    else if (Kind == "supervisor")
+      RetOpc = RISCVISD::SRET_FLAG;
+    else
+      RetOpc = RISCVISD::MRET_FLAG;
+
+    return DAG.getNode(RetOpc, DL, MVT::Other, RetOps);
+  }
+
   return DAG.getNode(RISCVISD::RET_FLAG, DL, MVT::Other, RetOps);
 }
 
@@ -1524,6 +1561,12 @@
     break;
   case RISCVISD::RET_FLAG:
     return "RISCVISD::RET_FLAG";
+  case RISCVISD::URET_FLAG:
+    return "RISCVISD::URET_FLAG";
+  case RISCVISD::SRET_FLAG:
+    return "RISCVISD::SRET_FLAG";
+  case RISCVISD::MRET_FLAG:
+    return "RISCVISD::MRET_FLAG";
   case RISCVISD::CALL:
     return "RISCVISD::CALL";
   case RISCVISD::SELECT_CC:
Index: lib/Target/RISCV/RISCVInstrInfo.cpp
===================================================================
--- lib/Target/RISCV/RISCVInstrInfo.cpp
+++ lib/Target/RISCV/RISCVInstrInfo.cpp
@@ -118,7 +118,8 @@
   unsigned Opcode;
 
   if (RISCV::GPRRegClass.hasSubClassEq(RC))
-    Opcode = RISCV::SW;
+    Opcode = TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ?
+             RISCV::SW : RISCV::SD;
   else if (RISCV::FPR32RegClass.hasSubClassEq(RC))
     Opcode = RISCV::FSW;
   else if (RISCV::FPR64RegClass.hasSubClassEq(RC))
@@ -144,7 +145,8 @@
   unsigned Opcode;
 
   if (RISCV::GPRRegClass.hasSubClassEq(RC))
-    Opcode = RISCV::LW;
+    Opcode = TRI->getRegSizeInBits(RISCV::GPRRegClass) == 32 ?
+             RISCV::LW : RISCV::LD;
   else if (RISCV::FPR32RegClass.hasSubClassEq(RC))
     Opcode = RISCV::FLW;
   else if (RISCV::FPR64RegClass.hasSubClassEq(RC))
Index: lib/Target/RISCV/RISCVInstrInfo.td
===================================================================
--- lib/Target/RISCV/RISCVInstrInfo.td
+++ lib/Target/RISCV/RISCVInstrInfo.td
@@ -36,6 +36,12 @@
                           [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
 def RetFlag      : SDNode<"RISCVISD::RET_FLAG", SDTNone,
                           [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
+def URetFlag     : SDNode<"RISCVISD::URET_FLAG", SDTNone,
+                          [SDNPHasChain, SDNPOptInGlue]>;
+def SRetFlag     : SDNode<"RISCVISD::SRET_FLAG", SDTNone,
+                          [SDNPHasChain, SDNPOptInGlue]>;
+def MRetFlag     : SDNode<"RISCVISD::MRET_FLAG", SDTNone,
+                          [SDNPHasChain, SDNPOptInGlue]>;
 def SelectCC     : SDNode<"RISCVISD::SELECT_CC", SDT_RISCVSelectCC,
                           [SDNPInGlue]>;
 def Tail         : SDNode<"RISCVISD::TAIL", SDT_RISCVCall,
@@ -684,6 +690,10 @@
 
 def : Pat<(Call texternalsym:$func), (PseudoCALL texternalsym:$func)>;
 
+def : Pat<(URetFlag), (URET X0, X0)>;
+def : Pat<(SRetFlag), (SRET X0, X0)>;
+def : Pat<(MRetFlag), (MRET X0, X0)>;
+
 let isCall = 1, Defs = [X1] in
 def PseudoCALLIndirect : Pseudo<(outs), (ins GPR:$rs1), [(Call GPR:$rs1)]>,
                          PseudoInstExpansion<(JALR X1, GPR:$rs1, 0)>;
Index: lib/Target/RISCV/RISCVRegisterInfo.cpp
===================================================================
--- lib/Target/RISCV/RISCVRegisterInfo.cpp
+++ lib/Target/RISCV/RISCVRegisterInfo.cpp
@@ -33,6 +33,13 @@
 
 const MCPhysReg *
 RISCVRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
+  if (MF->getFunction().hasFnAttribute("interrupt")) {
+    if (MF->getSubtarget<RISCVSubtarget>().hasStdExtD())
+      return CSR_X32_F64_Interrupt_SaveList;
+    if (MF->getSubtarget<RISCVSubtarget>().hasStdExtF())
+      return CSR_X32_F32_Interrupt_SaveList;
+    return CSR_Interrupt_SaveList;
+  }
   return CSR_SaveList;
 }
 
@@ -108,7 +115,9 @@
 }
 
 const uint32_t *
-RISCVRegisterInfo::getCallPreservedMask(const MachineFunction & /*MF*/,
+RISCVRegisterInfo::getCallPreservedMask(const MachineFunction &MF,
                                         CallingConv::ID /*CC*/) const {
+  if (MF.getFunction().hasFnAttribute("interrupt"))
+    return CSR_Interrupt_RegMask;
   return CSR_RegMask;
 }
Index: lib/Target/RISCV/RISCVSubtarget.cpp
===================================================================
--- lib/Target/RISCV/RISCVSubtarget.cpp
+++ lib/Target/RISCV/RISCVSubtarget.cpp
@@ -46,3 +46,4 @@
     : RISCVGenSubtargetInfo(TT, CPU, FS),
       FrameLowering(initializeSubtargetDependencies(CPU, FS, TT.isArch64Bit())),
       InstrInfo(), RegInfo(getHwMode()), TLInfo(TM, *this) {}
+
Index: test/CodeGen/RISCV/interrupt-attr-args-error.ll
===================================================================
--- /dev/null
+++ test/CodeGen/RISCV/interrupt-attr-args-error.ll
@@ -0,0 +1,11 @@
+; RUN: not llc -mtriple riscv32-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s
+; RUN: not llc -mtriple riscv64-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s
+
+; CHECK: LLVM ERROR: Functions with the interrupt attribute cannot have arguments!
+define i32 @isr_user(i8 %n) #0 {
+  ret i32 0
+}
+
+attributes #0 = { "interrupt"="user" }
Index: test/CodeGen/RISCV/interrupt-attr-invalid.ll
===================================================================
--- /dev/null
+++ test/CodeGen/RISCV/interrupt-attr-invalid.ll
@@ -0,0 +1,11 @@
+; RUN: not llc -mtriple riscv32-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s
+; RUN: not llc -mtriple riscv64-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s
+
+; CHECK: LLVM ERROR: Function interrupt attribute argument not supported!
+define void @isr_user() #0 {
+  ret void
+}
+
+attributes #0 = { "interrupt"="foo" }
Index: test/CodeGen/RISCV/interrupt-attr-ret-error.ll
===================================================================
--- /dev/null
+++ test/CodeGen/RISCV/interrupt-attr-ret-error.ll
@@ -0,0 +1,12 @@
+; RUN: not llc -mtriple riscv32-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s
+; RUN: not llc -mtriple riscv64-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s
+
+; CHECK: LLVM ERROR: Functions with the interrupt attribute must have void return type!
+define i32 @isr1_user() #0 {
+  ret i32 0
+}
+
+
+attributes #0 = { "interrupt"="user" }
Index: test/CodeGen/RISCV/interrupt-attr.ll
===================================================================
--- /dev/null
+++ test/CodeGen/RISCV/interrupt-attr.ll
@@ -0,0 +1,549 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -mtriple riscv32-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s -check-prefix CHECK -check-prefix CHECK-RV32
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+f -o - %s \
+; RUN: 2>&1 | FileCheck %s -check-prefix CHECK -check-prefix CHECK-RV32-F
+; RUN: llc -mtriple riscv32-unknown-elf -mattr=+f,+d, -o - %s \
+; RUN: 2>&1 | FileCheck %s -check-prefix CHECK -check-prefix CHECK-RV32-FD
+
+; RUN: llc -mtriple riscv64-unknown-elf -o - %s \
+; RUN: 2>&1 | FileCheck %s -check-prefix CHECK \
+; RUN: -check-prefix CHECK-RET -check-prefix CHECK-RV64
+; RUN: llc -mtriple riscv64-unknown-elf -mattr=+f -o - %s \
+; RUN: 2>&1 | FileCheck %s -check-prefix CHECK \
+; RUN: -check-prefix CHECK-RET -check-prefix CHECK-RV64-F
+; RUN: llc -mtriple riscv64-unknown-elf -mattr=+f,+d, -o - %s \
+; RUN: 2>&1 | FileCheck %s -check-prefix CHECK \
+; RUN: -check-prefix CHECK-RET -check-prefix CHECK-RV64-FD
+
+define void @foo_user() #0 {
+; CHECK-LABEL: foo_user:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    uret
+  ret void
+}
+
+define void @foo_supervisor() #1 {
+; CHECK-LABEL: foo_supervisor:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    sret
+  ret void
+}
+
+define void @foo_machine() #2 {
+; CHECK-LABEL: foo_machine:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    mret
+  ret void
+}
+
+declare void @otherfoo(...)
+define void @foo() #2 {
+; CHECK-RV32-LABEL: foo:
+; CHECK-RV32:       # %bb.0:
+; CHECK-RV32-NEXT:    addi sp, sp, -80
+; CHECK-RV32-NEXT:    sw ra, 76(sp)
+; CHECK-RV32-NEXT:    sw t0, 72(sp)
+; CHECK-RV32-NEXT:    sw t1, 68(sp)
+; CHECK-RV32-NEXT:    sw t2, 64(sp)
+; CHECK-RV32-NEXT:    sw s0, 60(sp)
+; CHECK-RV32-NEXT:    sw a0, 56(sp)
+; CHECK-RV32-NEXT:    sw a1, 52(sp)
+; CHECK-RV32-NEXT:    sw a2, 48(sp)
+; CHECK-RV32-NEXT:    sw a3, 44(sp)
+; CHECK-RV32-NEXT:    sw a4, 40(sp)
+; CHECK-RV32-NEXT:    sw a5, 36(sp)
+; CHECK-RV32-NEXT:    sw a6, 32(sp)
+; CHECK-RV32-NEXT:    sw a7, 28(sp)
+; CHECK-RV32-NEXT:    sw t3, 24(sp)
+; CHECK-RV32-NEXT:    sw t4, 20(sp)
+; CHECK-RV32-NEXT:    sw t5, 16(sp)
+; CHECK-RV32-NEXT:    sw t6, 12(sp)
+; CHECK-RV32-NEXT:    call otherfoo
+; CHECK-RV32-NEXT:    lw t6, 12(sp)
+; CHECK-RV32-NEXT:    lw t5, 16(sp)
+; CHECK-RV32-NEXT:    lw t4, 20(sp)
+; CHECK-RV32-NEXT:    lw t3, 24(sp)
+; CHECK-RV32-NEXT:    lw a7, 28(sp)
+; CHECK-RV32-NEXT:    lw a6, 32(sp)
+; CHECK-RV32-NEXT:    lw a5, 36(sp)
+; CHECK-RV32-NEXT:    lw a4, 40(sp)
+; CHECK-RV32-NEXT:    lw a3, 44(sp)
+; CHECK-RV32-NEXT:    lw a2, 48(sp)
+; CHECK-RV32-NEXT:    lw a1, 52(sp)
+; CHECK-RV32-NEXT:    lw a0, 56(sp)
+; CHECK-RV32-NEXT:    lw s0, 60(sp)
+; CHECK-RV32-NEXT:    lw t2, 64(sp)
+; CHECK-RV32-NEXT:    lw t1, 68(sp)
+; CHECK-RV32-NEXT:    lw t0, 72(sp)
+; CHECK-RV32-NEXT:    lw ra, 76(sp)
+; CHECK-RV32-NEXT:    addi sp, sp, 80
+; CHECK-RV32-NEXT:    mret
+;
+; CHECK-RV32-F-LABEL: foo:
+; CHECK-RV32-F:       # %bb.0:
+; CHECK-RV32-F-NEXT:    addi sp, sp, -208
+; CHECK-RV32-F-NEXT:    sw ra, 204(sp)
+; CHECK-RV32-F-NEXT:    sw t0, 200(sp)
+; CHECK-RV32-F-NEXT:    sw t1, 196(sp)
+; CHECK-RV32-F-NEXT:    sw t2, 192(sp)
+; CHECK-RV32-F-NEXT:    sw s0, 188(sp)
+; CHECK-RV32-F-NEXT:    sw a0, 184(sp)
+; CHECK-RV32-F-NEXT:    sw a1, 180(sp)
+; CHECK-RV32-F-NEXT:    sw a2, 176(sp)
+; CHECK-RV32-F-NEXT:    sw a3, 172(sp)
+; CHECK-RV32-F-NEXT:    sw a4, 168(sp)
+; CHECK-RV32-F-NEXT:    sw a5, 164(sp)
+; CHECK-RV32-F-NEXT:    sw a6, 160(sp)
+; CHECK-RV32-F-NEXT:    sw a7, 156(sp)
+; CHECK-RV32-F-NEXT:    sw t3, 152(sp)
+; CHECK-RV32-F-NEXT:    sw t4, 148(sp)
+; CHECK-RV32-F-NEXT:    sw t5, 144(sp)
+; CHECK-RV32-F-NEXT:    sw t6, 140(sp)
+; CHECK-RV32-F-NEXT:    fsw ft0, 136(sp)
+; CHECK-RV32-F-NEXT:    fsw ft1, 132(sp)
+; CHECK-RV32-F-NEXT:    fsw ft2, 128(sp)
+; CHECK-RV32-F-NEXT:    fsw ft3, 124(sp)
+; CHECK-RV32-F-NEXT:    fsw ft4, 120(sp)
+; CHECK-RV32-F-NEXT:    fsw ft5, 116(sp)
+; CHECK-RV32-F-NEXT:    fsw ft6, 112(sp)
+; CHECK-RV32-F-NEXT:    fsw ft7, 108(sp)
+; CHECK-RV32-F-NEXT:    fsw fa0, 104(sp)
+; CHECK-RV32-F-NEXT:    fsw fa1, 100(sp)
+; CHECK-RV32-F-NEXT:    fsw fa2, 96(sp)
+; CHECK-RV32-F-NEXT:    fsw fa3, 92(sp)
+; CHECK-RV32-F-NEXT:    fsw fa4, 88(sp)
+; CHECK-RV32-F-NEXT:    fsw fa5, 84(sp)
+; CHECK-RV32-F-NEXT:    fsw fa6, 80(sp)
+; CHECK-RV32-F-NEXT:    fsw fa7, 76(sp)
+; CHECK-RV32-F-NEXT:    fsw ft8, 72(sp)
+; CHECK-RV32-F-NEXT:    fsw ft9, 68(sp)
+; CHECK-RV32-F-NEXT:    fsw ft10, 64(sp)
+; CHECK-RV32-F-NEXT:    fsw ft11, 60(sp)
+; CHECK-RV32-F-NEXT:    fsw fs0, 56(sp)
+; CHECK-RV32-F-NEXT:    fsw fs1, 52(sp)
+; CHECK-RV32-F-NEXT:    fsw fs2, 48(sp)
+; CHECK-RV32-F-NEXT:    fsw fs3, 44(sp)
+; CHECK-RV32-F-NEXT:    fsw fs4, 40(sp)
+; CHECK-RV32-F-NEXT:    fsw fs5, 36(sp)
+; CHECK-RV32-F-NEXT:    fsw fs6, 32(sp)
+; CHECK-RV32-F-NEXT:    fsw fs7, 28(sp)
+; CHECK-RV32-F-NEXT:    fsw fs8, 24(sp)
+; CHECK-RV32-F-NEXT:    fsw fs9, 20(sp)
+; CHECK-RV32-F-NEXT:    fsw fs10, 16(sp)
+; CHECK-RV32-F-NEXT:    fsw fs11, 12(sp)
+; CHECK-RV32-F-NEXT:    call otherfoo
+; CHECK-RV32-F-NEXT:    flw fs11, 12(sp)
+; CHECK-RV32-F-NEXT:    flw fs10, 16(sp)
+; CHECK-RV32-F-NEXT:    flw fs9, 20(sp)
+; CHECK-RV32-F-NEXT:    flw fs8, 24(sp)
+; CHECK-RV32-F-NEXT:    flw fs7, 28(sp)
+; CHECK-RV32-F-NEXT:    flw fs6, 32(sp)
+; CHECK-RV32-F-NEXT:    flw fs5, 36(sp)
+; CHECK-RV32-F-NEXT:    flw fs4, 40(sp)
+; CHECK-RV32-F-NEXT:    flw fs3, 44(sp)
+; CHECK-RV32-F-NEXT:    flw fs2, 48(sp)
+; CHECK-RV32-F-NEXT:    flw fs1, 52(sp)
+; CHECK-RV32-F-NEXT:    flw fs0, 56(sp)
+; CHECK-RV32-F-NEXT:    flw ft11, 60(sp)
+; CHECK-RV32-F-NEXT:    flw ft10, 64(sp)
+; CHECK-RV32-F-NEXT:    flw ft9, 68(sp)
+; CHECK-RV32-F-NEXT:    flw ft8, 72(sp)
+; CHECK-RV32-F-NEXT:    flw fa7, 76(sp)
+; CHECK-RV32-F-NEXT:    flw fa6, 80(sp)
+; CHECK-RV32-F-NEXT:    flw fa5, 84(sp)
+; CHECK-RV32-F-NEXT:    flw fa4, 88(sp)
+; CHECK-RV32-F-NEXT:    flw fa3, 92(sp)
+; CHECK-RV32-F-NEXT:    flw fa2, 96(sp)
+; CHECK-RV32-F-NEXT:    flw fa1, 100(sp)
+; CHECK-RV32-F-NEXT:    flw fa0, 104(sp)
+; CHECK-RV32-F-NEXT:    flw ft7, 108(sp)
+; CHECK-RV32-F-NEXT:    flw ft6, 112(sp)
+; CHECK-RV32-F-NEXT:    flw ft5, 116(sp)
+; CHECK-RV32-F-NEXT:    flw ft4, 120(sp)
+; CHECK-RV32-F-NEXT:    flw ft3, 124(sp)
+; CHECK-RV32-F-NEXT:    flw ft2, 128(sp)
+; CHECK-RV32-F-NEXT:    flw ft1, 132(sp)
+; CHECK-RV32-F-NEXT:    flw ft0, 136(sp)
+; CHECK-RV32-F-NEXT:    lw t6, 140(sp)
+; CHECK-RV32-F-NEXT:    lw t5, 144(sp)
+; CHECK-RV32-F-NEXT:    lw t4, 148(sp)
+; CHECK-RV32-F-NEXT:    lw t3, 152(sp)
+; CHECK-RV32-F-NEXT:    lw a7, 156(sp)
+; CHECK-RV32-F-NEXT:    lw a6, 160(sp)
+; CHECK-RV32-F-NEXT:    lw a5, 164(sp)
+; CHECK-RV32-F-NEXT:    lw a4, 168(sp)
+; CHECK-RV32-F-NEXT:    lw a3, 172(sp)
+; CHECK-RV32-F-NEXT:    lw a2, 176(sp)
+; CHECK-RV32-F-NEXT:    lw a1, 180(sp)
+; CHECK-RV32-F-NEXT:    lw a0, 184(sp)
+; CHECK-RV32-F-NEXT:    lw s0, 188(sp)
+; CHECK-RV32-F-NEXT:    lw t2, 192(sp)
+; CHECK-RV32-F-NEXT:    lw t1, 196(sp)
+; CHECK-RV32-F-NEXT:    lw t0, 200(sp)
+; CHECK-RV32-F-NEXT:    lw ra, 204(sp)
+; CHECK-RV32-F-NEXT:    addi sp, sp, 208
+; CHECK-RV32-F-NEXT:    mret
+;
+; CHECK-RV32-FD-LABEL: foo:
+; CHECK-RV32-FD:       # %bb.0:
+; CHECK-RV32-FD-NEXT:    addi sp, sp, -336
+; CHECK-RV32-FD-NEXT:    sw ra, 332(sp)
+; CHECK-RV32-FD-NEXT:    sw t0, 328(sp)
+; CHECK-RV32-FD-NEXT:    sw t1, 324(sp)
+; CHECK-RV32-FD-NEXT:    sw t2, 320(sp)
+; CHECK-RV32-FD-NEXT:    sw s0, 316(sp)
+; CHECK-RV32-FD-NEXT:    sw a0, 312(sp)
+; CHECK-RV32-FD-NEXT:    sw a1, 308(sp)
+; CHECK-RV32-FD-NEXT:    sw a2, 304(sp)
+; CHECK-RV32-FD-NEXT:    sw a3, 300(sp)
+; CHECK-RV32-FD-NEXT:    sw a4, 296(sp)
+; CHECK-RV32-FD-NEXT:    sw a5, 292(sp)
+; CHECK-RV32-FD-NEXT:    sw a6, 288(sp)
+; CHECK-RV32-FD-NEXT:    sw a7, 284(sp)
+; CHECK-RV32-FD-NEXT:    sw t3, 280(sp)
+; CHECK-RV32-FD-NEXT:    sw t4, 276(sp)
+; CHECK-RV32-FD-NEXT:    sw t5, 272(sp)
+; CHECK-RV32-FD-NEXT:    sw t6, 268(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft0, 256(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft1, 248(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft2, 240(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft3, 232(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft4, 224(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft5, 216(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft6, 208(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft7, 200(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa0, 192(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa1, 184(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa2, 176(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa3, 168(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa4, 160(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa5, 152(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa6, 144(sp)
+; CHECK-RV32-FD-NEXT:    fsd fa7, 136(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft8, 128(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft9, 120(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft10, 112(sp)
+; CHECK-RV32-FD-NEXT:    fsd ft11, 104(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs0, 96(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs1, 88(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs2, 80(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs3, 72(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs4, 64(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs5, 56(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs6, 48(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs7, 40(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs8, 32(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs9, 24(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs10, 16(sp)
+; CHECK-RV32-FD-NEXT:    fsd fs11, 8(sp)
+; CHECK-RV32-FD-NEXT:    call otherfoo
+; CHECK-RV32-FD-NEXT:    fld fs11, 8(sp)
+; CHECK-RV32-FD-NEXT:    fld fs10, 16(sp)
+; CHECK-RV32-FD-NEXT:    fld fs9, 24(sp)
+; CHECK-RV32-FD-NEXT:    fld fs8, 32(sp)
+; CHECK-RV32-FD-NEXT:    fld fs7, 40(sp)
+; CHECK-RV32-FD-NEXT:    fld fs6, 48(sp)
+; CHECK-RV32-FD-NEXT:    fld fs5, 56(sp)
+; CHECK-RV32-FD-NEXT:    fld fs4, 64(sp)
+; CHECK-RV32-FD-NEXT:    fld fs3, 72(sp)
+; CHECK-RV32-FD-NEXT:    fld fs2, 80(sp)
+; CHECK-RV32-FD-NEXT:    fld fs1, 88(sp)
+; CHECK-RV32-FD-NEXT:    fld fs0, 96(sp)
+; CHECK-RV32-FD-NEXT:    fld ft11, 104(sp)
+; CHECK-RV32-FD-NEXT:    fld ft10, 112(sp)
+; CHECK-RV32-FD-NEXT:    fld ft9, 120(sp)
+; CHECK-RV32-FD-NEXT:    fld ft8, 128(sp)
+; CHECK-RV32-FD-NEXT:    fld fa7, 136(sp)
+; CHECK-RV32-FD-NEXT:    fld fa6, 144(sp)
+; CHECK-RV32-FD-NEXT:    fld fa5, 152(sp)
+; CHECK-RV32-FD-NEXT:    fld fa4, 160(sp)
+; CHECK-RV32-FD-NEXT:    fld fa3, 168(sp)
+; CHECK-RV32-FD-NEXT:    fld fa2, 176(sp)
+; CHECK-RV32-FD-NEXT:    fld fa1, 184(sp)
+; CHECK-RV32-FD-NEXT:    fld fa0, 192(sp)
+; CHECK-RV32-FD-NEXT:    fld ft7, 200(sp)
+; CHECK-RV32-FD-NEXT:    fld ft6, 208(sp)
+; CHECK-RV32-FD-NEXT:    fld ft5, 216(sp)
+; CHECK-RV32-FD-NEXT:    fld ft4, 224(sp)
+; CHECK-RV32-FD-NEXT:    fld ft3, 232(sp)
+; CHECK-RV32-FD-NEXT:    fld ft2, 240(sp)
+; CHECK-RV32-FD-NEXT:    fld ft1, 248(sp)
+; CHECK-RV32-FD-NEXT:    fld ft0, 256(sp)
+; CHECK-RV32-FD-NEXT:    lw t6, 268(sp)
+; CHECK-RV32-FD-NEXT:    lw t5, 272(sp)
+; CHECK-RV32-FD-NEXT:    lw t4, 276(sp)
+; CHECK-RV32-FD-NEXT:    lw t3, 280(sp)
+; CHECK-RV32-FD-NEXT:    lw a7, 284(sp)
+; CHECK-RV32-FD-NEXT:    lw a6, 288(sp)
+; CHECK-RV32-FD-NEXT:    lw a5, 292(sp)
+; CHECK-RV32-FD-NEXT:    lw a4, 296(sp)
+; CHECK-RV32-FD-NEXT:    lw a3, 300(sp)
+; CHECK-RV32-FD-NEXT:    lw a2, 304(sp)
+; CHECK-RV32-FD-NEXT:    lw a1, 308(sp)
+; CHECK-RV32-FD-NEXT:    lw a0, 312(sp)
+; CHECK-RV32-FD-NEXT:    lw s0, 316(sp)
+; CHECK-RV32-FD-NEXT:    lw t2, 320(sp)
+; CHECK-RV32-FD-NEXT:    lw t1, 324(sp)
+; CHECK-RV32-FD-NEXT:    lw t0, 328(sp)
+; CHECK-RV32-FD-NEXT:    lw ra, 332(sp)
+; CHECK-RV32-FD-NEXT:    addi sp, sp, 336
+; CHECK-RV32-FD-NEXT:    mret
+;
+; CHECK-RV64-LABEL: foo:
+; CHECK-RV64:       # %bb.0:
+; CHECK-RV64-NEXT:    addi sp, sp, -144
+; CHECK-RV64-NEXT:    sd ra, 136(sp)
+; CHECK-RV64-NEXT:    sd t0, 128(sp)
+; CHECK-RV64-NEXT:    sd t1, 120(sp)
+; CHECK-RV64-NEXT:    sd t2, 112(sp)
+; CHECK-RV64-NEXT:    sd s0, 104(sp)
+; CHECK-RV64-NEXT:    sd a0, 96(sp)
+; CHECK-RV64-NEXT:    sd a1, 88(sp)
+; CHECK-RV64-NEXT:    sd a2, 80(sp)
+; CHECK-RV64-NEXT:    sd a3, 72(sp)
+; CHECK-RV64-NEXT:    sd a4, 64(sp)
+; CHECK-RV64-NEXT:    sd a5, 56(sp)
+; CHECK-RV64-NEXT:    sd a6, 48(sp)
+; CHECK-RV64-NEXT:    sd a7, 40(sp)
+; CHECK-RV64-NEXT:    sd t3, 32(sp)
+; CHECK-RV64-NEXT:    sd t4, 24(sp)
+; CHECK-RV64-NEXT:    sd t5, 16(sp)
+; CHECK-RV64-NEXT:    sd t6, 8(sp)
+; CHECK-RV64-NEXT:    call otherfoo
+; CHECK-RV64-NEXT:    ld t6, 8(sp)
+; CHECK-RV64-NEXT:    ld t5, 16(sp)
+; CHECK-RV64-NEXT:    ld t4, 24(sp)
+; CHECK-RV64-NEXT:    ld t3, 32(sp)
+; CHECK-RV64-NEXT:    ld a7, 40(sp)
+; CHECK-RV64-NEXT:    ld a6, 48(sp)
+; CHECK-RV64-NEXT:    ld a5, 56(sp)
+; CHECK-RV64-NEXT:    ld a4, 64(sp)
+; CHECK-RV64-NEXT:    ld a3, 72(sp)
+; CHECK-RV64-NEXT:    ld a2, 80(sp)
+; CHECK-RV64-NEXT:    ld a1, 88(sp)
+; CHECK-RV64-NEXT:    ld a0, 96(sp)
+; CHECK-RV64-NEXT:    ld s0, 104(sp)
+; CHECK-RV64-NEXT:    ld t2, 112(sp)
+; CHECK-RV64-NEXT:    ld t1, 120(sp)
+; CHECK-RV64-NEXT:    ld t0, 128(sp)
+; CHECK-RV64-NEXT:    ld ra, 136(sp)
+; CHECK-RV64-NEXT:    addi sp, sp, 144
+; CHECK-RV64-NEXT:    mret
+;
+; CHECK-RV64-F-LABEL: foo:
+; CHECK-RV64-F:       # %bb.0:
+; CHECK-RV64-F-NEXT:    addi sp, sp, -272
+; CHECK-RV64-F-NEXT:    sd ra, 264(sp)
+; CHECK-RV64-F-NEXT:    sd t0, 256(sp)
+; CHECK-RV64-F-NEXT:    sd t1, 248(sp)
+; CHECK-RV64-F-NEXT:    sd t2, 240(sp)
+; CHECK-RV64-F-NEXT:    sd s0, 232(sp)
+; CHECK-RV64-F-NEXT:    sd a0, 224(sp)
+; CHECK-RV64-F-NEXT:    sd a1, 216(sp)
+; CHECK-RV64-F-NEXT:    sd a2, 208(sp)
+; CHECK-RV64-F-NEXT:    sd a3, 200(sp)
+; CHECK-RV64-F-NEXT:    sd a4, 192(sp)
+; CHECK-RV64-F-NEXT:    sd a5, 184(sp)
+; CHECK-RV64-F-NEXT:    sd a6, 176(sp)
+; CHECK-RV64-F-NEXT:    sd a7, 168(sp)
+; CHECK-RV64-F-NEXT:    sd t3, 160(sp)
+; CHECK-RV64-F-NEXT:    sd t4, 152(sp)
+; CHECK-RV64-F-NEXT:    sd t5, 144(sp)
+; CHECK-RV64-F-NEXT:    sd t6, 136(sp)
+; CHECK-RV64-F-NEXT:    fsw ft0, 132(sp)
+; CHECK-RV64-F-NEXT:    fsw ft1, 128(sp)
+; CHECK-RV64-F-NEXT:    fsw ft2, 124(sp)
+; CHECK-RV64-F-NEXT:    fsw ft3, 120(sp)
+; CHECK-RV64-F-NEXT:    fsw ft4, 116(sp)
+; CHECK-RV64-F-NEXT:    fsw ft5, 112(sp)
+; CHECK-RV64-F-NEXT:    fsw ft6, 108(sp)
+; CHECK-RV64-F-NEXT:    fsw ft7, 104(sp)
+; CHECK-RV64-F-NEXT:    fsw fa0, 100(sp)
+; CHECK-RV64-F-NEXT:    fsw fa1, 96(sp)
+; CHECK-RV64-F-NEXT:    fsw fa2, 92(sp)
+; CHECK-RV64-F-NEXT:    fsw fa3, 88(sp)
+; CHECK-RV64-F-NEXT:    fsw fa4, 84(sp)
+; CHECK-RV64-F-NEXT:    fsw fa5, 80(sp)
+; CHECK-RV64-F-NEXT:    fsw fa6, 76(sp)
+; CHECK-RV64-F-NEXT:    fsw fa7, 72(sp)
+; CHECK-RV64-F-NEXT:    fsw ft8, 68(sp)
+; CHECK-RV64-F-NEXT:    fsw ft9, 64(sp)
+; CHECK-RV64-F-NEXT:    fsw ft10, 60(sp)
+; CHECK-RV64-F-NEXT:    fsw ft11, 56(sp)
+; CHECK-RV64-F-NEXT:    fsw fs0, 52(sp)
+; CHECK-RV64-F-NEXT:    fsw fs1, 48(sp)
+; CHECK-RV64-F-NEXT:    fsw fs2, 44(sp)
+; CHECK-RV64-F-NEXT:    fsw fs3, 40(sp)
+; CHECK-RV64-F-NEXT:    fsw fs4, 36(sp)
+; CHECK-RV64-F-NEXT:    fsw fs5, 32(sp)
+; CHECK-RV64-F-NEXT:    fsw fs6, 28(sp)
+; CHECK-RV64-F-NEXT:    fsw fs7, 24(sp)
+; CHECK-RV64-F-NEXT:    fsw fs8, 20(sp)
+; CHECK-RV64-F-NEXT:    fsw fs9, 16(sp)
+; CHECK-RV64-F-NEXT:    fsw fs10, 12(sp)
+; CHECK-RV64-F-NEXT:    fsw fs11, 8(sp)
+; CHECK-RV64-F-NEXT:    call otherfoo
+; CHECK-RV64-F-NEXT:    flw fs11, 8(sp)
+; CHECK-RV64-F-NEXT:    flw fs10, 12(sp)
+; CHECK-RV64-F-NEXT:    flw fs9, 16(sp)
+; CHECK-RV64-F-NEXT:    flw fs8, 20(sp)
+; CHECK-RV64-F-NEXT:    flw fs7, 24(sp)
+; CHECK-RV64-F-NEXT:    flw fs6, 28(sp)
+; CHECK-RV64-F-NEXT:    flw fs5, 32(sp)
+; CHECK-RV64-F-NEXT:    flw fs4, 36(sp)
+; CHECK-RV64-F-NEXT:    flw fs3, 40(sp)
+; CHECK-RV64-F-NEXT:    flw fs2, 44(sp)
+; CHECK-RV64-F-NEXT:    flw fs1, 48(sp)
+; CHECK-RV64-F-NEXT:    flw fs0, 52(sp)
+; CHECK-RV64-F-NEXT:    flw ft11, 56(sp)
+; CHECK-RV64-F-NEXT:    flw ft10, 60(sp)
+; CHECK-RV64-F-NEXT:    flw ft9, 64(sp)
+; CHECK-RV64-F-NEXT:    flw ft8, 68(sp)
+; CHECK-RV64-F-NEXT:    flw fa7, 72(sp)
+; CHECK-RV64-F-NEXT:    flw fa6, 76(sp)
+; CHECK-RV64-F-NEXT:    flw fa5, 80(sp)
+; CHECK-RV64-F-NEXT:    flw fa4, 84(sp)
+; CHECK-RV64-F-NEXT:    flw fa3, 88(sp)
+; CHECK-RV64-F-NEXT:    flw fa2, 92(sp)
+; CHECK-RV64-F-NEXT:    flw fa1, 96(sp)
+; CHECK-RV64-F-NEXT:    flw fa0, 100(sp)
+; CHECK-RV64-F-NEXT:    flw ft7, 104(sp)
+; CHECK-RV64-F-NEXT:    flw ft6, 108(sp)
+; CHECK-RV64-F-NEXT:    flw ft5, 112(sp)
+; CHECK-RV64-F-NEXT:    flw ft4, 116(sp)
+; CHECK-RV64-F-NEXT:    flw ft3, 120(sp)
+; CHECK-RV64-F-NEXT:    flw ft2, 124(sp)
+; CHECK-RV64-F-NEXT:    flw ft1, 128(sp)
+; CHECK-RV64-F-NEXT:    flw ft0, 132(sp)
+; CHECK-RV64-F-NEXT:    ld t6, 136(sp)
+; CHECK-RV64-F-NEXT:    ld t5, 144(sp)
+; CHECK-RV64-F-NEXT:    ld t4, 152(sp)
+; CHECK-RV64-F-NEXT:    ld t3, 160(sp)
+; CHECK-RV64-F-NEXT:    ld a7, 168(sp)
+; CHECK-RV64-F-NEXT:    ld a6, 176(sp)
+; CHECK-RV64-F-NEXT:    ld a5, 184(sp)
+; CHECK-RV64-F-NEXT:    ld a4, 192(sp)
+; CHECK-RV64-F-NEXT:    ld a3, 200(sp)
+; CHECK-RV64-F-NEXT:    ld a2, 208(sp)
+; CHECK-RV64-F-NEXT:    ld a1, 216(sp)
+; CHECK-RV64-F-NEXT:    ld a0, 224(sp)
+; CHECK-RV64-F-NEXT:    ld s0, 232(sp)
+; CHECK-RV64-F-NEXT:    ld t2, 240(sp)
+; CHECK-RV64-F-NEXT:    ld t1, 248(sp)
+; CHECK-RV64-F-NEXT:    ld t0, 256(sp)
+; CHECK-RV64-F-NEXT:    ld ra, 264(sp)
+; CHECK-RV64-F-NEXT:    addi sp, sp, 272
+; CHECK-RV64-F-NEXT:    mret
+;
+; CHECK-RV64-FD-LABEL: foo:
+; CHECK-RV64-FD:       # %bb.0:
+; CHECK-RV64-FD-NEXT:    addi sp, sp, -400
+; CHECK-RV64-FD-NEXT:    sd ra, 392(sp)
+; CHECK-RV64-FD-NEXT:    sd t0, 384(sp)
+; CHECK-RV64-FD-NEXT:    sd t1, 376(sp)
+; CHECK-RV64-FD-NEXT:    sd t2, 368(sp)
+; CHECK-RV64-FD-NEXT:    sd s0, 360(sp)
+; CHECK-RV64-FD-NEXT:    sd a0, 352(sp)
+; CHECK-RV64-FD-NEXT:    sd a1, 344(sp)
+; CHECK-RV64-FD-NEXT:    sd a2, 336(sp)
+; CHECK-RV64-FD-NEXT:    sd a3, 328(sp)
+; CHECK-RV64-FD-NEXT:    sd a4, 320(sp)
+; CHECK-RV64-FD-NEXT:    sd a5, 312(sp)
+; CHECK-RV64-FD-NEXT:    sd a6, 304(sp)
+; CHECK-RV64-FD-NEXT:    sd a7, 296(sp)
+; CHECK-RV64-FD-NEXT:    sd t3, 288(sp)
+; CHECK-RV64-FD-NEXT:    sd t4, 280(sp)
+; CHECK-RV64-FD-NEXT:    sd t5, 272(sp)
+; CHECK-RV64-FD-NEXT:    sd t6, 264(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft0, 256(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft1, 248(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft2, 240(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft3, 232(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft4, 224(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft5, 216(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft6, 208(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft7, 200(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa0, 192(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa1, 184(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa2, 176(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa3, 168(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa4, 160(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa5, 152(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa6, 144(sp)
+; CHECK-RV64-FD-NEXT:    fsd fa7, 136(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft8, 128(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft9, 120(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft10, 112(sp)
+; CHECK-RV64-FD-NEXT:    fsd ft11, 104(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs0, 96(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs1, 88(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs2, 80(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs3, 72(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs4, 64(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs5, 56(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs6, 48(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs7, 40(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs8, 32(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs9, 24(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs10, 16(sp)
+; CHECK-RV64-FD-NEXT:    fsd fs11, 8(sp)
+; CHECK-RV64-FD-NEXT:    call otherfoo
+; CHECK-RV64-FD-NEXT:    fld fs11, 8(sp)
+; CHECK-RV64-FD-NEXT:    fld fs10, 16(sp)
+; CHECK-RV64-FD-NEXT:    fld fs9, 24(sp)
+; CHECK-RV64-FD-NEXT:    fld fs8, 32(sp)
+; CHECK-RV64-FD-NEXT:    fld fs7, 40(sp)
+; CHECK-RV64-FD-NEXT:    fld fs6, 48(sp)
+; CHECK-RV64-FD-NEXT:    fld fs5, 56(sp)
+; CHECK-RV64-FD-NEXT:    fld fs4, 64(sp)
+; CHECK-RV64-FD-NEXT:    fld fs3, 72(sp)
+; CHECK-RV64-FD-NEXT:    fld fs2, 80(sp)
+; CHECK-RV64-FD-NEXT:    fld fs1, 88(sp)
+; CHECK-RV64-FD-NEXT:    fld fs0, 96(sp)
+; CHECK-RV64-FD-NEXT:    fld ft11, 104(sp)
+; CHECK-RV64-FD-NEXT:    fld ft10, 112(sp)
+; CHECK-RV64-FD-NEXT:    fld ft9, 120(sp)
+; CHECK-RV64-FD-NEXT:    fld ft8, 128(sp)
+; CHECK-RV64-FD-NEXT:    fld fa7, 136(sp)
+; CHECK-RV64-FD-NEXT:    fld fa6, 144(sp)
+; CHECK-RV64-FD-NEXT:    fld fa5, 152(sp)
+; CHECK-RV64-FD-NEXT:    fld fa4, 160(sp)
+; CHECK-RV64-FD-NEXT:    fld fa3, 168(sp)
+; CHECK-RV64-FD-NEXT:    fld fa2, 176(sp)
+; CHECK-RV64-FD-NEXT:    fld fa1, 184(sp)
+; CHECK-RV64-FD-NEXT:    fld fa0, 192(sp)
+; CHECK-RV64-FD-NEXT:    fld ft7, 200(sp)
+; CHECK-RV64-FD-NEXT:    fld ft6, 208(sp)
+; CHECK-RV64-FD-NEXT:    fld ft5, 216(sp)
+; CHECK-RV64-FD-NEXT:    fld ft4, 224(sp)
+; CHECK-RV64-FD-NEXT:    fld ft3, 232(sp)
+; CHECK-RV64-FD-NEXT:    fld ft2, 240(sp)
+; CHECK-RV64-FD-NEXT:    fld ft1, 248(sp)
+; CHECK-RV64-FD-NEXT:    fld ft0, 256(sp)
+; CHECK-RV64-FD-NEXT:    ld t6, 264(sp)
+; CHECK-RV64-FD-NEXT:    ld t5, 272(sp)
+; CHECK-RV64-FD-NEXT:    ld t4, 280(sp)
+; CHECK-RV64-FD-NEXT:    ld t3, 288(sp)
+; CHECK-RV64-FD-NEXT:    ld a7, 296(sp)
+; CHECK-RV64-FD-NEXT:    ld a6, 304(sp)
+; CHECK-RV64-FD-NEXT:    ld a5, 312(sp)
+; CHECK-RV64-FD-NEXT:    ld a4, 320(sp)
+; CHECK-RV64-FD-NEXT:    ld a3, 328(sp)
+; CHECK-RV64-FD-NEXT:    ld a2, 336(sp)
+; CHECK-RV64-FD-NEXT:    ld a1, 344(sp)
+; CHECK-RV64-FD-NEXT:    ld a0, 352(sp)
+; CHECK-RV64-FD-NEXT:    ld s0, 360(sp)
+; CHECK-RV64-FD-NEXT:    ld t2, 368(sp)
+; CHECK-RV64-FD-NEXT:    ld t1, 376(sp)
+; CHECK-RV64-FD-NEXT:    ld t0, 384(sp)
+; CHECK-RV64-FD-NEXT:    ld ra, 392(sp)
+; CHECK-RV64-FD-NEXT:    addi sp, sp, 400
+; CHECK-RV64-FD-NEXT:    mret
+  call void bitcast (void (...)* @otherfoo to void ()*)()
+  ret void
+}
+
+attributes #0 = { "interrupt"="user" }
+attributes #1 = { "interrupt"="supervisor" }
+attributes #2 = { "interrupt"="machine" }