Index: include/llvm/Target/TargetFrameLowering.h
===================================================================
--- include/llvm/Target/TargetFrameLowering.h
+++ include/llvm/Target/TargetFrameLowering.h
@@ -161,9 +161,11 @@
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
   virtual void emitPrologue(MachineFunction &MF,
-                            MachineBasicBlock &MBB) const = 0;
+                            MachineBasicBlock &MBB,
+                            RegScavenger *RS = nullptr) const = 0;
   virtual void emitEpilogue(MachineFunction &MF,
-                            MachineBasicBlock &MBB) const = 0;
+                            MachineBasicBlock &MBB,
+                            RegScavenger *RS = nullptr) const = 0;
 
   /// Replace a StackProbe stub (if any) with the actual probe code inline
   virtual void inlineStackProbe(MachineFunction &MF,
Index: lib/CodeGen/PrologEpilogInserter.cpp
===================================================================
--- lib/CodeGen/PrologEpilogInserter.cpp
+++ lib/CodeGen/PrologEpilogInserter.cpp
@@ -124,7 +124,7 @@
   void replaceFrameIndices(MachineFunction &Fn);
   void replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &Fn,
                            int &SPAdj);
-  void insertPrologEpilogCode(MachineFunction &Fn);
+  void insertPrologEpilogCode(MachineFunction &Fn, RegScavenger *RS);
 };
 } // namespace
 
@@ -203,7 +203,7 @@
   // must be called before this function in order to set the AdjustsStack
   // and MaxCallFrameSize variables.
   if (!F->hasFnAttribute(Attribute::Naked))
-    insertPrologEpilogCode(Fn);
+    insertPrologEpilogCode(Fn, RS);
 
   // Replace all MO_FrameIndex operands with physical register references
   // and actual offsets.
@@ -965,16 +965,16 @@
 /// registers, insert spill code for these callee saved registers, then add
 /// prolog and epilog code to the function.
 ///
-void PEI::insertPrologEpilogCode(MachineFunction &Fn) {
+void PEI::insertPrologEpilogCode(MachineFunction &Fn, RegScavenger *RS) {
   const TargetFrameLowering &TFI = *Fn.getSubtarget().getFrameLowering();
 
   // Add prologue to the function...
   for (MachineBasicBlock *SaveBlock : SaveBlocks)
-    TFI.emitPrologue(Fn, *SaveBlock);
+    TFI.emitPrologue(Fn, *SaveBlock, RS);
 
   // Add epilogue to restore the callee-save registers in each exiting block.
   for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
-    TFI.emitEpilogue(Fn, *RestoreBlock);
+    TFI.emitEpilogue(Fn, *RestoreBlock, RS);
 
   for (MachineBasicBlock *SaveBlock : SaveBlocks)
     TFI.inlineStackProbe(Fn, *SaveBlock);
Index: lib/Target/AArch64/AArch64FrameLowering.h
===================================================================
--- lib/Target/AArch64/AArch64FrameLowering.h
+++ lib/Target/AArch64/AArch64FrameLowering.h
@@ -33,8 +33,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
 
Index: lib/Target/AArch64/AArch64FrameLowering.cpp
===================================================================
--- lib/Target/AArch64/AArch64FrameLowering.cpp
+++ lib/Target/AArch64/AArch64FrameLowering.cpp
@@ -405,7 +405,8 @@
 }
 
 void AArch64FrameLowering::emitPrologue(MachineFunction &MF,
-                                        MachineBasicBlock &MBB) const {
+                                        MachineBasicBlock &MBB,
+                                        RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.begin();
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   const Function *Fn = MF.getFunction();
@@ -642,7 +643,8 @@
 }
 
 void AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
-                                        MachineBasicBlock &MBB) const {
+                                        MachineBasicBlock &MBB,
+                                        RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const AArch64Subtarget &Subtarget = MF.getSubtarget<AArch64Subtarget>();
Index: lib/Target/AMDGPU/R600FrameLowering.h
===================================================================
--- lib/Target/AMDGPU/R600FrameLowering.h
+++ lib/Target/AMDGPU/R600FrameLowering.h
@@ -21,8 +21,10 @@
     AMDGPUFrameLowering(D, StackAl, LAO, TransAl) {}
   virtual ~R600FrameLowering();
 
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const {}
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const {}
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const {}
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const {}
 };
 
 }
Index: lib/Target/AMDGPU/SIFrameLowering.h
===================================================================
--- lib/Target/AMDGPU/SIFrameLowering.h
+++ lib/Target/AMDGPU/SIFrameLowering.h
@@ -26,9 +26,11 @@
   ~SIFrameLowering() override {}
 
   void emitPrologue(MachineFunction &MF,
-                    MachineBasicBlock &MBB) const override;
+                    MachineBasicBlock &MBB,
+                    RegScavenger *RS) const override;
   void emitEpilogue(MachineFunction &MF,
-                    MachineBasicBlock &MBB) const override;
+                    MachineBasicBlock &MBB,
+                    RegScavenger *RS) const override;
 
   void processFunctionBeforeFrameFinalized(
     MachineFunction &MF,
Index: lib/Target/AMDGPU/SIFrameLowering.cpp
===================================================================
--- lib/Target/AMDGPU/SIFrameLowering.cpp
+++ lib/Target/AMDGPU/SIFrameLowering.cpp
@@ -186,7 +186,8 @@
 }
 
 void SIFrameLowering::emitPrologue(MachineFunction &MF,
-                                   MachineBasicBlock &MBB) const {
+                                   MachineBasicBlock &MBB,
+                                   RegScavenger *RS) const {
   // Emit debugger prologue if "amdgpu-debugger-emit-prologue" attribute was
   // specified.
   const SISubtarget &ST = MF.getSubtarget<SISubtarget>();
@@ -333,7 +334,8 @@
 }
 
 void SIFrameLowering::emitEpilogue(MachineFunction &MF,
-                                   MachineBasicBlock &MBB) const {
+                                   MachineBasicBlock &MBB,
+                                   RegScavenger *RS) const {
 
 }
 
Index: lib/Target/ARM/ARMFrameLowering.h
===================================================================
--- lib/Target/ARM/ARMFrameLowering.h
+++ lib/Target/ARM/ARMFrameLowering.h
@@ -28,8 +28,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator MI,
Index: lib/Target/ARM/ARMFrameLowering.cpp
===================================================================
--- lib/Target/ARM/ARMFrameLowering.cpp
+++ lib/Target/ARM/ARMFrameLowering.cpp
@@ -285,7 +285,8 @@
 }
 
 void ARMFrameLowering::emitPrologue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.begin();
   MachineFrameInfo  &MFI = MF.getFrameInfo();
   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
@@ -693,7 +694,8 @@
 }
 
 void ARMFrameLowering::emitEpilogue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   MachineFrameInfo &MFI = MF.getFrameInfo();
   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
Index: lib/Target/ARM/Thumb1FrameLowering.h
===================================================================
--- lib/Target/ARM/Thumb1FrameLowering.h
+++ lib/Target/ARM/Thumb1FrameLowering.h
@@ -27,8 +27,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator MI,
Index: lib/Target/ARM/Thumb1FrameLowering.cpp
===================================================================
--- lib/Target/ARM/Thumb1FrameLowering.cpp
+++ lib/Target/ARM/Thumb1FrameLowering.cpp
@@ -83,7 +83,8 @@
 }
 
 void Thumb1FrameLowering::emitPrologue(MachineFunction &MF,
-                                       MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.begin();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
@@ -362,7 +363,8 @@
 }
 
 void Thumb1FrameLowering::emitEpilogue(MachineFunction &MF,
-                                   MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
   DebugLoc dl = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc();
   MachineFrameInfo &MFI = MF.getFrameInfo();
Index: lib/Target/AVR/AVRFrameLowering.h
===================================================================
--- lib/Target/AVR/AVRFrameLowering.h
+++ lib/Target/AVR/AVRFrameLowering.h
@@ -20,8 +20,10 @@
   explicit AVRFrameLowering();
 
 public:
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
   bool hasFP(const MachineFunction &MF) const override;
   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator MI,
Index: lib/Target/AVR/AVRFrameLowering.cpp
===================================================================
--- lib/Target/AVR/AVRFrameLowering.cpp
+++ lib/Target/AVR/AVRFrameLowering.cpp
@@ -51,7 +51,8 @@
 }
 
 void AVRFrameLowering::emitPrologue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.begin();
   CallingConv::ID CallConv = MF.getFunction()->getCallingConv();
   DebugLoc DL = (MBBI != MBB.end()) ? MBBI->getDebugLoc() : DebugLoc();
@@ -133,7 +134,8 @@
 }
 
 void AVRFrameLowering::emitEpilogue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   CallingConv::ID CallConv = MF.getFunction()->getCallingConv();
   bool isHandler = (CallConv == CallingConv::AVR_INTR ||
                     CallConv == CallingConv::AVR_SIGNAL);
Index: lib/Target/BPF/BPFFrameLowering.h
===================================================================
--- lib/Target/BPF/BPFFrameLowering.h
+++ lib/Target/BPF/BPFFrameLowering.h
@@ -24,8 +24,10 @@
   explicit BPFFrameLowering(const BPFSubtarget &sti)
       : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 8, 0) {}
 
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   bool hasFP(const MachineFunction &MF) const override;
   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
Index: lib/Target/BPF/BPFFrameLowering.cpp
===================================================================
--- lib/Target/BPF/BPFFrameLowering.cpp
+++ lib/Target/BPF/BPFFrameLowering.cpp
@@ -24,10 +24,12 @@
 bool BPFFrameLowering::hasFP(const MachineFunction &MF) const { return true; }
 
 void BPFFrameLowering::emitPrologue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {}
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {}
 
 void BPFFrameLowering::emitEpilogue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {}
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {}
 
 void BPFFrameLowering::determineCalleeSaves(MachineFunction &MF,
                                             BitVector &SavedRegs,
Index: lib/Target/Hexagon/HexagonFrameLowering.h
===================================================================
--- lib/Target/Hexagon/HexagonFrameLowering.h
+++ lib/Target/Hexagon/HexagonFrameLowering.h
@@ -27,10 +27,10 @@
   // All of the prolog/epilog functionality, including saving and restoring
   // callee-saved registers is handled in emitPrologue. This is to have the
   // logic for shrink-wrapping in one place.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const
-      override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const
-      override {}
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override {}
   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
       MachineBasicBlock::iterator MI, const std::vector<CalleeSavedInfo> &CSI,
       const TargetRegisterInfo *TRI) const override {
Index: lib/Target/Hexagon/HexagonFrameLowering.cpp
===================================================================
--- lib/Target/Hexagon/HexagonFrameLowering.cpp
+++ lib/Target/Hexagon/HexagonFrameLowering.cpp
@@ -454,7 +454,8 @@
 /// Normally, this work is distributed among various functions, but doing it
 /// in one place allows shrink-wrapping of the stack frame.
 void HexagonFrameLowering::emitPrologue(MachineFunction &MF,
-                                        MachineBasicBlock &MBB) const {
+                                        MachineBasicBlock &MBB,
+                                        RegScavenger *RS) const {
   auto &HST = MF.getSubtarget<HexagonSubtarget>();
   auto &HRI = *HST.getRegisterInfo();
 
Index: lib/Target/Lanai/LanaiFrameLowering.h
===================================================================
--- lib/Target/Lanai/LanaiFrameLowering.h
+++ lib/Target/Lanai/LanaiFrameLowering.h
@@ -39,9 +39,10 @@
 
   // emitProlog/emitEpilog - These methods insert prolog and epilog code into
   // the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
   MachineBasicBlock::iterator
   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
                                 MachineBasicBlock::iterator I) const override;
Index: lib/Target/Lanai/LanaiFrameLowering.cpp
===================================================================
--- lib/Target/Lanai/LanaiFrameLowering.cpp
+++ lib/Target/Lanai/LanaiFrameLowering.cpp
@@ -90,7 +90,8 @@
 //   add %sp,8,%fp          !generate new FP
 //   sub %sp,0x4,%sp        !allocate stack space (as needed)
 void LanaiFrameLowering::emitPrologue(MachineFunction &MF,
-                                      MachineBasicBlock &MBB) const {
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {
   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
 
   MachineFrameInfo &MFI = MF.getFrameInfo();
@@ -177,7 +178,8 @@
 // before RET and the delay slot filler will move RET such that these
 // instructions execute in the delay slots of the load to PC.
 void LanaiFrameLowering::emitEpilogue(MachineFunction & /*MF*/,
-                                      MachineBasicBlock &MBB) const {
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
   const LanaiInstrInfo &LII =
       *static_cast<const LanaiInstrInfo *>(STI.getInstrInfo());
Index: lib/Target/MSP430/MSP430FrameLowering.h
===================================================================
--- lib/Target/MSP430/MSP430FrameLowering.h
+++ lib/Target/MSP430/MSP430FrameLowering.h
@@ -27,8 +27,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS) const override;
 
   MachineBasicBlock::iterator
   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
Index: lib/Target/MSP430/MSP430FrameLowering.cpp
===================================================================
--- lib/Target/MSP430/MSP430FrameLowering.cpp
+++ lib/Target/MSP430/MSP430FrameLowering.cpp
@@ -39,7 +39,8 @@
 }
 
 void MSP430FrameLowering::emitPrologue(MachineFunction &MF,
-                                       MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
   MachineFrameInfo &MFI = MF.getFrameInfo();
   MSP430MachineFunctionInfo *MSP430FI = MF.getInfo<MSP430MachineFunctionInfo>();
@@ -105,7 +106,8 @@
 }
 
 void MSP430FrameLowering::emitEpilogue(MachineFunction &MF,
-                                       MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   MSP430MachineFunctionInfo *MSP430FI = MF.getInfo<MSP430MachineFunctionInfo>();
   const MSP430InstrInfo &TII =
Index: lib/Target/Mips/Mips16FrameLowering.h
===================================================================
--- lib/Target/Mips/Mips16FrameLowering.h
+++ lib/Target/Mips/Mips16FrameLowering.h
@@ -23,8 +23,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator MI,
Index: lib/Target/Mips/Mips16FrameLowering.cpp
===================================================================
--- lib/Target/Mips/Mips16FrameLowering.cpp
+++ lib/Target/Mips/Mips16FrameLowering.cpp
@@ -32,7 +32,8 @@
     : MipsFrameLowering(STI, STI.stackAlignment()) {}
 
 void Mips16FrameLowering::emitPrologue(MachineFunction &MF,
-                                       MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const Mips16InstrInfo &TII =
@@ -84,7 +85,8 @@
 }
 
 void Mips16FrameLowering::emitEpilogue(MachineFunction &MF,
-                                 MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const Mips16InstrInfo &TII =
Index: lib/Target/Mips/MipsSEFrameLowering.h
===================================================================
--- lib/Target/Mips/MipsSEFrameLowering.h
+++ lib/Target/Mips/MipsSEFrameLowering.h
@@ -24,8 +24,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   int getFrameIndexReference(const MachineFunction &MF, int FI,
                              unsigned &FrameReg) const override;
Index: lib/Target/Mips/MipsSEFrameLowering.cpp
===================================================================
--- lib/Target/Mips/MipsSEFrameLowering.cpp
+++ lib/Target/Mips/MipsSEFrameLowering.cpp
@@ -372,7 +372,8 @@
     : MipsFrameLowering(STI, STI.stackAlignment()) {}
 
 void MipsSEFrameLowering::emitPrologue(MachineFunction &MF,
-                                       MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
   MachineFrameInfo &MFI    = MF.getFrameInfo();
   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
@@ -662,7 +663,8 @@
 }
 
 void MipsSEFrameLowering::emitEpilogue(MachineFunction &MF,
-                                       MachineBasicBlock &MBB) const {
+                                       MachineBasicBlock &MBB,
+                                       RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
   MachineFrameInfo &MFI            = MF.getFrameInfo();
   MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
Index: lib/Target/NVPTX/NVPTXFrameLowering.h
===================================================================
--- lib/Target/NVPTX/NVPTXFrameLowering.h
+++ lib/Target/NVPTX/NVPTXFrameLowering.h
@@ -23,8 +23,10 @@
   explicit NVPTXFrameLowering();
 
   bool hasFP(const MachineFunction &MF) const override;
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   MachineBasicBlock::iterator
   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
Index: lib/Target/NVPTX/NVPTXFrameLowering.cpp
===================================================================
--- lib/Target/NVPTX/NVPTXFrameLowering.cpp
+++ lib/Target/NVPTX/NVPTXFrameLowering.cpp
@@ -31,7 +31,8 @@
 bool NVPTXFrameLowering::hasFP(const MachineFunction &MF) const { return true; }
 
 void NVPTXFrameLowering::emitPrologue(MachineFunction &MF,
-                                      MachineBasicBlock &MBB) const {
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {
   if (MF.getFrameInfo().hasStackObjects()) {
     assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
     MachineInstr *MI = &MBB.front();
@@ -65,7 +66,8 @@
 }
 
 void NVPTXFrameLowering::emitEpilogue(MachineFunction &MF,
-                                      MachineBasicBlock &MBB) const {}
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {}
 
 // This function eliminates ADJCALLSTACKDOWN,
 // ADJCALLSTACKUP pseudo instructions
Index: lib/Target/PowerPC/PPCFrameLowering.h
===================================================================
--- lib/Target/PowerPC/PPCFrameLowering.h
+++ lib/Target/PowerPC/PPCFrameLowering.h
@@ -82,8 +82,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   bool hasFP(const MachineFunction &MF) const override;
   bool needsFP(const MachineFunction &MF) const;
Index: lib/Target/PowerPC/PPCFrameLowering.cpp
===================================================================
--- lib/Target/PowerPC/PPCFrameLowering.cpp
+++ lib/Target/PowerPC/PPCFrameLowering.cpp
@@ -691,7 +691,8 @@
 }
 
 void PPCFrameLowering::emitPrologue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.begin();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   const PPCInstrInfo &TII =
@@ -1214,7 +1215,8 @@
 }
 
 void PPCFrameLowering::emitEpilogue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
   DebugLoc dl;
 
Index: lib/Target/Sparc/SparcFrameLowering.h
===================================================================
--- lib/Target/Sparc/SparcFrameLowering.h
+++ lib/Target/Sparc/SparcFrameLowering.h
@@ -26,8 +26,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   MachineBasicBlock::iterator
   eliminateCallFramePseudoInstr(MachineFunction &MF,
Index: lib/Target/Sparc/SparcFrameLowering.cpp
===================================================================
--- lib/Target/Sparc/SparcFrameLowering.cpp
+++ lib/Target/Sparc/SparcFrameLowering.cpp
@@ -83,7 +83,8 @@
 }
 
 void SparcFrameLowering::emitPrologue(MachineFunction &MF,
-                                      MachineBasicBlock &MBB) const {
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {
   SparcMachineFunctionInfo *FuncInfo = MF.getInfo<SparcMachineFunctionInfo>();
 
   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
@@ -200,7 +201,8 @@
 
 
 void SparcFrameLowering::emitEpilogue(MachineFunction &MF,
-                                  MachineBasicBlock &MBB) const {
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {
   SparcMachineFunctionInfo *FuncInfo = MF.getInfo<SparcMachineFunctionInfo>();
   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
   const SparcInstrInfo &TII =
Index: lib/Target/SystemZ/SystemZFrameLowering.h
===================================================================
--- lib/Target/SystemZ/SystemZFrameLowering.h
+++ lib/Target/SystemZ/SystemZFrameLowering.h
@@ -40,8 +40,10 @@
     override;
   void processFunctionBeforeFrameFinalized(MachineFunction &MF,
                                            RegScavenger *RS) const override;
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
   bool hasFP(const MachineFunction &MF) const override;
   int getFrameIndexReference(const MachineFunction &MF, int FI,
                              unsigned &FrameReg) const override;
Index: lib/Target/SystemZ/SystemZFrameLowering.cpp
===================================================================
--- lib/Target/SystemZ/SystemZFrameLowering.cpp
+++ lib/Target/SystemZ/SystemZFrameLowering.cpp
@@ -319,7 +319,8 @@
 }
 
 void SystemZFrameLowering::emitPrologue(MachineFunction &MF,
-                                        MachineBasicBlock &MBB) const {
+                                        MachineBasicBlock &MBB,
+                                        RegScavenger *RS) const {
   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
   MachineFrameInfo &MFFrame = MF.getFrameInfo();
   auto *ZII =
@@ -436,7 +437,8 @@
 }
 
 void SystemZFrameLowering::emitEpilogue(MachineFunction &MF,
-                                        MachineBasicBlock &MBB) const {
+                                        MachineBasicBlock &MBB,
+                                        RegScavenger *RS) const {
   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
   auto *ZII =
       static_cast<const SystemZInstrInfo *>(MF.getSubtarget().getInstrInfo());
Index: lib/Target/X86/X86FrameLowering.h
===================================================================
--- lib/Target/X86/X86FrameLowering.h
+++ lib/Target/X86/X86FrameLowering.h
@@ -64,8 +64,10 @@
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
-  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
-  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+  void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
+  void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB,
+                    RegScavenger *RS = nullptr) const override;
 
   void adjustForSegmentedStacks(MachineFunction &MF,
                                 MachineBasicBlock &PrologueMBB) const override;
Index: lib/Target/X86/X86FrameLowering.cpp
===================================================================
--- lib/Target/X86/X86FrameLowering.cpp
+++ lib/Target/X86/X86FrameLowering.cpp
@@ -904,7 +904,8 @@
 */
 
 void X86FrameLowering::emitPrologue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   assert(&STI == &MF.getSubtarget<X86Subtarget>() &&
          "MF used frame lowering for wrong subtarget");
   MachineBasicBlock::iterator MBBI = MBB.begin();
@@ -1485,7 +1486,8 @@
 }
 
 void X86FrameLowering::emitEpilogue(MachineFunction &MF,
-                                    MachineBasicBlock &MBB) const {
+                                    MachineBasicBlock &MBB,
+                                    RegScavenger *RS) const {
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
   MachineBasicBlock::iterator MBBI = MBB.getFirstTerminator();
Index: lib/Target/XCore/XCoreFrameLowering.h
===================================================================
--- lib/Target/XCore/XCoreFrameLowering.h
+++ lib/Target/XCore/XCoreFrameLowering.h
@@ -28,10 +28,11 @@
     /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
     /// the function.
     void emitPrologue(MachineFunction &MF,
-                      MachineBasicBlock &MBB) const override;
+                      MachineBasicBlock &MBB,
+                      RegScavenger *RS = nullptr) const override;
     void emitEpilogue(MachineFunction &MF,
-                      MachineBasicBlock &MBB) const override;
-
+                      MachineBasicBlock &MBB,
+                      RegScavenger *RS = nullptr) const override;
     bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator MI,
                                   const std::vector<CalleeSavedInfo> &CSI,
Index: lib/Target/XCore/XCoreFrameLowering.cpp
===================================================================
--- lib/Target/XCore/XCoreFrameLowering.cpp
+++ lib/Target/XCore/XCoreFrameLowering.cpp
@@ -221,7 +221,8 @@
 }
 
 void XCoreFrameLowering::emitPrologue(MachineFunction &MF,
-                                      MachineBasicBlock &MBB) const {
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {
   assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported");
   MachineBasicBlock::iterator MBBI = MBB.begin();
   MachineFrameInfo &MFI = MF.getFrameInfo();
@@ -341,7 +342,8 @@
 }
 
 void XCoreFrameLowering::emitEpilogue(MachineFunction &MF,
-                                     MachineBasicBlock &MBB) const {
+                                      MachineBasicBlock &MBB,
+                                      RegScavenger *RS) const {
   MachineFrameInfo &MFI = MF.getFrameInfo();
   MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr();
   const XCoreInstrInfo &TII = *MF.getSubtarget<XCoreSubtarget>().getInstrInfo();