Index: llvm/trunk/include/llvm/Target/TargetFrameLowering.h =================================================================== --- llvm/trunk/include/llvm/Target/TargetFrameLowering.h +++ llvm/trunk/include/llvm/Target/TargetFrameLowering.h @@ -246,19 +246,17 @@ virtual int getFrameIndexReference(const MachineFunction &MF, int FI, unsigned &FrameReg) const; - /// Same as above, except that the 'base register' will always be RSP, not - /// RBP on x86. This is generally used for emitting statepoint or EH tables - /// that use offsets from RSP. - /// If AllowSPAdjustment is true, the returned offset is only guaranteed - /// to be valid with respect to the value of SP at the end of the prologue. - /// TODO: This should really be a parameterizable choice. - virtual Optional - getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI, - unsigned &FrameReg, - bool AllowSPAdjustment) const { - // default to calling normal version, we override this on x86 only - llvm_unreachable("unimplemented for non-x86"); - return None; + /// Same as \c getFrameIndexReference, except that the stack pointer (as + /// opposed to the frame pointer) will be the preferred value for \p + /// FrameReg. This is generally used for emitting statepoint or EH tables that + /// use offsets from RSP. If \p IgnoreSPUpdates is true, the returned + /// offset is only guaranteed to be valid with respect to the value of SP at + /// the end of the prologue. + virtual int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, + unsigned &FrameReg, + bool IgnoreSPUpdates) const { + // Always safe to dispatch to getFrameIndexReference. + return getFrameIndexReference(MF, FI, FrameReg); } /// This method determines which of the registers reported by Index: llvm/trunk/lib/CodeGen/AsmPrinter/WinException.cpp =================================================================== --- llvm/trunk/lib/CodeGen/AsmPrinter/WinException.cpp +++ llvm/trunk/lib/CodeGen/AsmPrinter/WinException.cpp @@ -34,6 +34,7 @@ #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FormattedStream.h" #include "llvm/Target/TargetFrameLowering.h" +#include "llvm/Target/TargetLowering.h" #include "llvm/Target/TargetLoweringObjectFile.h" #include "llvm/Target/TargetOptions.h" #include "llvm/Target/TargetRegisterInfo.h" @@ -301,9 +302,17 @@ const WinEHFuncInfo &FuncInfo) { const TargetFrameLowering &TFI = *Asm->MF->getSubtarget().getFrameLowering(); unsigned UnusedReg; - if (Asm->MAI->usesWindowsCFI()) - return *TFI.getFrameIndexReferenceFromSP(*Asm->MF, FrameIndex, UnusedReg, - /*AllowSPAdjustment*/ true); + if (Asm->MAI->usesWindowsCFI()) { + int Offset = + TFI.getFrameIndexReferencePreferSP(*Asm->MF, FrameIndex, UnusedReg, + /*IgnoreSPUpdates*/ true); + assert(UnusedReg == + Asm->MF->getSubtarget() + .getTargetLowering() + ->getStackPointerRegisterToSaveRestore()); + return Offset; + } + // For 32-bit, offsets should be relative to the end of the EH registration // node. For 64-bit, it's relative to SP at the end of the prologue. assert(FuncInfo.EHRegNodeEndOffset != INT_MAX); Index: llvm/trunk/lib/CodeGen/PrologEpilogInserter.cpp =================================================================== --- llvm/trunk/lib/CodeGen/PrologEpilogInserter.cpp +++ llvm/trunk/lib/CodeGen/PrologEpilogInserter.cpp @@ -1094,17 +1094,8 @@ "DBG_VALUE machine instruction"); unsigned Reg; MachineOperand &Offset = MI->getOperand(i + 1); - int refOffset; - // First try to get an offset relative to SP. If that's not - // possible use whatever the target usually uses. - auto SPOffset = TFI->getFrameIndexReferenceFromSP( - Fn, MI->getOperand(i).getIndex(), Reg, /*AllowSPAdjustment*/ false); - if (SPOffset) - refOffset = *SPOffset; - else - refOffset = TFI->getFrameIndexReference( - Fn, MI->getOperand(i).getIndex(), Reg); - + int refOffset = TFI->getFrameIndexReferencePreferSP( + Fn, MI->getOperand(i).getIndex(), Reg, /*IgnoreSPUpdates*/ false); Offset.setImm(Offset.getImm() + refOffset); MI->getOperand(i).ChangeToRegister(Reg, false /*isDef*/); continue; Index: llvm/trunk/lib/Target/X86/X86FrameLowering.h =================================================================== --- llvm/trunk/lib/Target/X86/X86FrameLowering.h +++ llvm/trunk/lib/Target/X86/X86FrameLowering.h @@ -100,10 +100,9 @@ int getFrameIndexReference(const MachineFunction &MF, int FI, unsigned &FrameReg) const override; - Optional - getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI, - unsigned &FrameReg, - bool AllowSPAdjustment) const override; + int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, + unsigned &FrameReg, + bool IgnoreSPUpdates) const override; MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, Index: llvm/trunk/lib/Target/X86/X86FrameLowering.cpp =================================================================== --- llvm/trunk/lib/Target/X86/X86FrameLowering.cpp +++ llvm/trunk/lib/Target/X86/X86FrameLowering.cpp @@ -1433,12 +1433,10 @@ unsigned X86FrameLowering::getPSPSlotOffsetFromSP(const MachineFunction &MF) const { const WinEHFuncInfo &Info = *MF.getWinEHFuncInfo(); - // getFrameIndexReferenceFromSP has an out ref parameter for the stack - // pointer register; pass a dummy that we ignore unsigned SPReg; - int Offset = *getFrameIndexReferenceFromSP(MF, Info.PSPSymFrameIdx, SPReg, - /*AllowSPAdjustment*/ true); - assert(Offset >= 0); + int Offset = getFrameIndexReferencePreferSP(MF, Info.PSPSymFrameIdx, SPReg, + /*IgnoreSPUpdates*/ true); + assert(Offset >= 0 && SPReg == TRI->getStackRegister()); return static_cast(Offset); } @@ -1722,11 +1720,11 @@ return Offset + FPDelta; } -// Simplified from getFrameIndexReference keeping only StackPointer cases -Optional -X86FrameLowering::getFrameIndexReferenceFromSP(const MachineFunction &MF, - int FI, unsigned &FrameReg, - bool AllowSPAdjustment) const { +int +X86FrameLowering::getFrameIndexReferencePreferSP(const MachineFunction &MF, + int FI, unsigned &FrameReg, + bool IgnoreSPUpdates) const { + const MachineFrameInfo *MFI = MF.getFrameInfo(); // Does not include any dynamic realign. const uint64_t StackSize = MFI->getStackSize(); @@ -1765,14 +1763,14 @@ if (MFI->isFixedObjectIndex(FI) && TRI->needsStackRealignment(MF) && !STI.isTargetWin64()) - return None; + return getFrameIndexReference(MF, FI, FrameReg); // If !hasReservedCallFrame the function might have SP adjustement in the // body. So, even though the offset is statically known, it depends on where // we are in the function. const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering(); - if (!AllowSPAdjustment && !TFI->hasReservedCallFrame(MF)) - return None; + if (!IgnoreSPUpdates && !TFI->hasReservedCallFrame(MF)) + return getFrameIndexReference(MF, FI, FrameReg); // We don't handle tail calls, and shouldn't be seeing them either. assert(MF.getInfo()->getTCReturnAddrDelta() >= 0 &&