RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-11 23:38:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[WinEH] Remove unused intrinsic llvm.x86.seh.restoreframe

Browse Source 
We can clean this up now that we have the X86 CATCHRET instruction to
restore the FP, SP, and BP.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@255677 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Kleckner 2015-12-15 21:41:34 +00:00
parent b46bb541f5
commit 08bfe00a19
4 changed files with 5 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/IR/IntrinsicsX86.td
View File

@ -25,11 +25,6 @@ let TargetPrefix = "x86" in {
// Marks the EH registration node created in LLVM IR prior to code generation.
def int_x86_seh_ehregnode : Intrinsic<[], [llvm_ptr_ty], []>;
// Restores the frame, base, and stack pointers as necessary after recovering
// from an exception. Any block resuming control flow in the parent function
// should call this before accessing any stack memory.
def int_x86_seh_restoreframe : Intrinsic<[], [], []>;
// Given a pointer to the end of an EH registration object, returns the true
// parent frame address that can be used with llvm.localrecover.
def int_x86_seh_recoverfp : Intrinsic<[llvm_ptr_ty],

67
lib/Target/X86/X86ISelLowering.cpp
View File

@ -16168,7 +16168,8 @@ static int getSEHRegistrationNodeSize(const Function *Fn) {
case EHPersonality::MSVC_CXX: return 16;
default: break;
}
report_fatal_error("can only recover FP for MSVC EH personality functions");
report_fatal_error(
"can only recover FP for 32-bit MSVC EH personality functions");
}
/// When the 32-bit MSVC runtime transfers control to us, either to an outlined
@ -17077,66 +17078,6 @@ static SDValue LowerREADCYCLECOUNTER(SDValue Op, const X86Subtarget *Subtarget,
return DAG.getMergeValues(Results, DL);
}
static SDValue LowerSEHRESTOREFRAME(SDValue Op, const X86Subtarget *Subtarget,
SelectionDAG &DAG) {
MachineFunction &MF = DAG.getMachineFunction();
const Function *Fn = MF.getFunction();
SDLoc dl(Op);
SDValue Chain = Op.getOperand(0);
assert(Subtarget->getFrameLowering()->hasFP(MF) &&
"using llvm.x86.seh.restoreframe requires a frame pointer");
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
MVT VT = TLI.getPointerTy(DAG.getDataLayout());
const X86RegisterInfo *RegInfo = Subtarget->getRegisterInfo();
unsigned FrameReg =
RegInfo->getPtrSizedFrameRegister(DAG.getMachineFunction());
unsigned SPReg = RegInfo->getStackRegister();
unsigned SlotSize = RegInfo->getSlotSize();
// Get incoming EBP.
SDValue IncomingEBP =
DAG.getCopyFromReg(Chain, dl, FrameReg, VT);
// SP is saved in the first field of every registration node, so load
// [EBP-RegNodeSize] into SP.
int RegNodeSize = getSEHRegistrationNodeSize(Fn);
SDValue SPAddr = DAG.getNode(ISD::ADD, dl, VT, IncomingEBP,
DAG.getConstant(-RegNodeSize, dl, VT));
SDValue NewSP =
DAG.getLoad(VT, dl, Chain, SPAddr, MachinePointerInfo(), false, false,
false, VT.getScalarSizeInBits() / 8);
Chain = DAG.getCopyToReg(Chain, dl, SPReg, NewSP);
if (!RegInfo->needsStackRealignment(MF)) {
// Adjust EBP to point back to the original frame position.
SDValue NewFP = recoverFramePointer(DAG, Fn, IncomingEBP);
Chain = DAG.getCopyToReg(Chain, dl, FrameReg, NewFP);
} else {
assert(RegInfo->hasBasePointer(MF) &&
"functions with Win32 EH must use frame or base pointer register");
// Reload the base pointer (ESI) with the adjusted incoming EBP.
SDValue NewBP = recoverFramePointer(DAG, Fn, IncomingEBP);
Chain = DAG.getCopyToReg(Chain, dl, RegInfo->getBaseRegister(), NewBP);
// Reload the spilled EBP value, now that the stack and base pointers are
// set up.
X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
X86FI->setHasSEHFramePtrSave(true);
int FI = MF.getFrameInfo()->CreateSpillStackObject(SlotSize, SlotSize);
X86FI->setSEHFramePtrSaveIndex(FI);
SDValue NewFP = DAG.getLoad(VT, dl, Chain, DAG.getFrameIndex(FI, VT),
MachinePointerInfo(), false, false, false,
VT.getScalarSizeInBits() / 8);
Chain = DAG.getCopyToReg(NewFP, dl, FrameReg, NewFP);
}
return Chain;
}
static SDValue MarkEHRegistrationNode(SDValue Op, SelectionDAG &DAG) {
MachineFunction &MF = DAG.getMachineFunction();
SDValue Chain = Op.getOperand(0);
@ -17198,9 +17139,7 @@ static SDValue LowerINTRINSIC_W_CHAIN(SDValue Op, const X86Subtarget *Subtarget,
const IntrinsicData* IntrData = getIntrinsicWithChain(IntNo);
if (!IntrData) {
if (IntNo == llvm::Intrinsic::x86_seh_restoreframe)
return LowerSEHRESTOREFRAME(Op, Subtarget, DAG);
else if (IntNo == llvm::Intrinsic::x86_seh_ehregnode)
if (IntNo == llvm::Intrinsic::x86_seh_ehregnode)
return MarkEHRegistrationNode(Op, DAG);
return SDValue();
}

4
lib/Target/X86/X86MachineFunctionInfo.h
View File

@ -84,8 +84,8 @@ class X86MachineFunctionInfo : public MachineFunctionInfo {
/// of pushes to pass function parameters.
bool HasPushSequences = false;
/// True if the function uses llvm.x86.seh.restoreframe, and it needed a spill
/// slot for the frame pointer.
/// True if the function recovers from an SEH exception, and therefore needs
/// to spill and restore the frame pointer.
bool HasSEHFramePtrSave = false;
/// The frame index of a stack object containing the original frame pointer

3
lib/Target/X86/X86WinEHState.cpp
View File

@ -87,7 +87,6 @@ private:
Function *FrameRecover = nullptr;
Function *FrameAddress = nullptr;
Function *FrameEscape = nullptr;
Function *RestoreFrame = nullptr;
// Per-function state
EHPersonality Personality = EHPersonality::Unknown;
@ -120,8 +119,6 @@ bool WinEHStatePass::doInitialization(Module &M) {
FrameEscape = Intrinsic::getDeclaration(TheModule, Intrinsic::localescape);
FrameRecover = Intrinsic::getDeclaration(TheModule, Intrinsic::localrecover);
FrameAddress = Intrinsic::getDeclaration(TheModule, Intrinsic::frameaddress);
RestoreFrame =
Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_restoreframe);
return false;
}