#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCWin64EH.h"
+#include "llvm/Support/COFF.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Target/TargetRegisterInfo.h"
+#include "llvm/Target/TargetSubtargetInfo.h"
using namespace llvm;
WinException::WinException(AsmPrinter *A) : EHStreamer(A) {
return;
}
- if (shouldEmitMoves || shouldEmitPersonality)
- Asm->OutStreamer->EmitWinCFIStartProc(Asm->CurrentFnSym);
-
- if (shouldEmitPersonality) {
- const MCSymbol *PersHandlerSym =
- TLOF.getCFIPersonalitySymbol(Per, *Asm->Mang, Asm->TM, MMI);
- Asm->OutStreamer->EmitWinEHHandler(PersHandlerSym, true, true);
- }
+ beginFunclet(MF->front(), Asm->CurrentFnSym);
}
/// endFunction - Gather and emit post-function exception information.
if (F->hasPersonalityFn())
Per = classifyEHPersonality(F->getPersonalityFn());
- // Get rid of any dead landing pads if we're not using a Windows EH scheme. In
- // Windows EH schemes, the landing pad is not actually reachable. It only
- // exists so that we can emit the right table data.
- if (!isMSVCEHPersonality(Per))
+ // Get rid of any dead landing pads if we're not using funclets. In funclet
+ // schemes, the landing pad is not actually reachable. It only exists so
+ // that we can emit the right table data.
+ if (!isFuncletEHPersonality(Per))
MMI->TidyLandingPads();
+ endFunclet();
+
+ // endFunclet will emit the necessary .xdata tables for x64 SEH.
+ if (Per == EHPersonality::MSVC_Win64SEH && MMI->hasEHFunclets())
+ return;
+
if (shouldEmitPersonality || shouldEmitLSDA) {
Asm->OutStreamer->PushSection();
- if (shouldEmitMoves || shouldEmitPersonality) {
- // Emit an UNWIND_INFO struct describing the prologue.
- Asm->OutStreamer->EmitWinEHHandlerData();
- } else {
- // Just switch sections to the right xdata section. This use of
- // CurrentFnSym assumes that we only emit the LSDA when ending the parent
- // function.
- MCSection *XData = WinEH::UnwindEmitter::getXDataSection(
- Asm->CurrentFnSym, Asm->OutContext);
- Asm->OutStreamer->SwitchSection(XData);
- }
+ // Just switch sections to the right xdata section. This use of CurrentFnSym
+ // assumes that we only emit the LSDA when ending the parent function.
+ MCSection *XData = WinEH::UnwindEmitter::getXDataSection(Asm->CurrentFnSym,
+ Asm->OutContext);
+ Asm->OutStreamer->SwitchSection(XData);
// Emit the tables appropriate to the personality function in use. If we
// don't recognize the personality, assume it uses an Itanium-style LSDA.
Asm->OutStreamer->PopSection();
}
+}
+/// Retreive the MCSymbol for a GlobalValue or MachineBasicBlock. GlobalValues
+/// are used in the old WinEH scheme, and they will be removed eventually.
+static MCSymbol *getMCSymbolForMBBOrGV(AsmPrinter *Asm, ValueOrMBB Handler) {
+ if (!Handler)
+ return nullptr;
+ if (Handler.is<const MachineBasicBlock *>()) {
+ auto *MBB = Handler.get<const MachineBasicBlock *>();
+ assert(MBB->isEHFuncletEntry());
+
+ // Give catches and cleanups a name based off of their parent function and
+ // their funclet entry block's number.
+ const MachineFunction *MF = MBB->getParent();
+ const Function *F = MF->getFunction();
+ StringRef FuncLinkageName = GlobalValue::getRealLinkageName(F->getName());
+ MCContext &Ctx = MF->getContext();
+ StringRef HandlerPrefix = MBB->isCleanupFuncletEntry() ? "dtor" : "catch";
+ return Ctx.getOrCreateSymbol("?" + HandlerPrefix + "$" +
+ Twine(MBB->getNumber()) + "@?0?" +
+ FuncLinkageName + "@4HA");
+ }
+ return Asm->getSymbol(cast<GlobalValue>(Handler.get<const Value *>()));
+}
+
+void WinException::beginFunclet(const MachineBasicBlock &MBB,
+ MCSymbol *Sym) {
+ CurrentFuncletEntry = &MBB;
+
+ const Function *F = Asm->MF->getFunction();
+ // If a symbol was not provided for the funclet, invent one.
+ if (!Sym) {
+ Sym = getMCSymbolForMBBOrGV(Asm, &MBB);
+
+ // Describe our funclet symbol as a function with internal linkage.
+ Asm->OutStreamer->BeginCOFFSymbolDef(Sym);
+ Asm->OutStreamer->EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC);
+ Asm->OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION
+ << COFF::SCT_COMPLEX_TYPE_SHIFT);
+ Asm->OutStreamer->EndCOFFSymbolDef();
+
+ // We want our funclet's entry point to be aligned such that no nops will be
+ // present after the label.
+ Asm->EmitAlignment(std::max(Asm->MF->getAlignment(), MBB.getAlignment()),
+ F);
+
+ // Now that we've emitted the alignment directive, point at our funclet.
+ Asm->OutStreamer->EmitLabel(Sym);
+ }
+
+ // Mark 'Sym' as starting our funclet.
if (shouldEmitMoves || shouldEmitPersonality)
+ Asm->OutStreamer->EmitWinCFIStartProc(Sym);
+
+ if (shouldEmitPersonality) {
+ const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
+ const Function *PerFn = nullptr;
+
+ // Determine which personality routine we are using for this funclet.
+ if (F->hasPersonalityFn())
+ PerFn = dyn_cast<Function>(F->getPersonalityFn()->stripPointerCasts());
+ const MCSymbol *PersHandlerSym =
+ TLOF.getCFIPersonalitySymbol(PerFn, *Asm->Mang, Asm->TM, MMI);
+
+ // Classify the personality routine so that we may reason about it.
+ EHPersonality Per = EHPersonality::Unknown;
+ if (F->hasPersonalityFn())
+ Per = classifyEHPersonality(F->getPersonalityFn());
+
+ // Do not emit a .seh_handler directive if it is a C++ cleanup funclet.
+ if (Per != EHPersonality::MSVC_CXX ||
+ !CurrentFuncletEntry->isCleanupFuncletEntry())
+ Asm->OutStreamer->EmitWinEHHandler(PersHandlerSym, true, true);
+ }
+}
+
+void WinException::endFunclet() {
+ // No funclet to process? Great, we have nothing to do.
+ if (!CurrentFuncletEntry)
+ return;
+
+ if (shouldEmitMoves || shouldEmitPersonality) {
+ const Function *F = Asm->MF->getFunction();
+ EHPersonality Per = EHPersonality::Unknown;
+ if (F->hasPersonalityFn())
+ Per = classifyEHPersonality(F->getPersonalityFn());
+
+ // The .seh_handlerdata directive implicitly switches section, push the
+ // current section so that we may return to it.
+ Asm->OutStreamer->PushSection();
+
+ // Emit an UNWIND_INFO struct describing the prologue.
+ Asm->OutStreamer->EmitWinEHHandlerData();
+
+ if (Per == EHPersonality::MSVC_CXX && shouldEmitPersonality &&
+ !CurrentFuncletEntry->isCleanupFuncletEntry()) {
+ // If this is a C++ catch funclet (or the parent function),
+ // emit a reference to the LSDA for the parent function.
+ StringRef FuncLinkageName = GlobalValue::getRealLinkageName(F->getName());
+ MCSymbol *FuncInfoXData = Asm->OutContext.getOrCreateSymbol(
+ Twine("$cppxdata$", FuncLinkageName));
+ Asm->OutStreamer->EmitValue(create32bitRef(FuncInfoXData), 4);
+ } else if (Per == EHPersonality::MSVC_Win64SEH && MMI->hasEHFunclets() &&
+ !CurrentFuncletEntry->isEHFuncletEntry()) {
+ // If this is the parent function in Win64 SEH, emit the LSDA immediately
+ // following .seh_handlerdata.
+ emitCSpecificHandlerTable(Asm->MF);
+ }
+
+ // Switch back to the previous section now that we are done writing to
+ // .xdata.
+ Asm->OutStreamer->PopSection();
+
+ // Emit a .seh_endproc directive to mark the end of the function.
Asm->OutStreamer->EmitWinCFIEndProc();
+ }
+
+ // Let's make sure we don't try to end the same funclet twice.
+ CurrentFuncletEntry = nullptr;
}
const MCExpr *WinException::create32bitRef(const MCSymbol *Value) {
return create32bitRef(MMI->getAddrLabelSymbol(cast<BasicBlock>(V)));
}
+const MCExpr *WinException::getLabelPlusOne(MCSymbol *Label) {
+ return MCBinaryExpr::createAdd(create32bitRef(Label),
+ MCConstantExpr::create(1, Asm->OutContext),
+ Asm->OutContext);
+}
+
+int WinException::getFrameIndexOffset(int FrameIndex) {
+ const TargetFrameLowering &TFI = *Asm->MF->getSubtarget().getFrameLowering();
+ unsigned UnusedReg;
+ if (Asm->MAI->usesWindowsCFI())
+ return TFI.getFrameIndexReferenceFromSP(*Asm->MF, FrameIndex, UnusedReg);
+ return TFI.getFrameIndexReference(*Asm->MF, FrameIndex, UnusedReg);
+}
+
+namespace {
+/// Information describing an invoke range.
+struct InvokeRange {
+ MCSymbol *BeginLabel = nullptr;
+ MCSymbol *EndLabel = nullptr;
+ int State = -1;
+
+ /// If we saw a potentially throwing call between this range and the last
+ /// range.
+ bool SawPotentiallyThrowing = false;
+};
+
+/// Iterator over the begin/end label pairs of invokes within a basic block.
+class InvokeLabelIterator {
+public:
+ InvokeLabelIterator(WinEHFuncInfo &EHInfo,
+ MachineBasicBlock::const_iterator MBBI,
+ MachineBasicBlock::const_iterator MBBIEnd)
+ : EHInfo(EHInfo), MBBI(MBBI), MBBIEnd(MBBIEnd) {
+ scan();
+ }
+
+ // Iterator methods.
+ bool operator==(const InvokeLabelIterator &o) const { return MBBI == o.MBBI; }
+ bool operator!=(const InvokeLabelIterator &o) const { return MBBI != o.MBBI; }
+ InvokeRange &operator*() { return CurRange; }
+ InvokeRange *operator->() { return &CurRange; }
+ InvokeLabelIterator &operator++() { return scan(); }
+
+private:
+ // Scan forward to find the next invoke range, or hit the end iterator.
+ InvokeLabelIterator &scan();
+
+ WinEHFuncInfo &EHInfo;
+ MachineBasicBlock::const_iterator MBBI;
+ MachineBasicBlock::const_iterator MBBIEnd;
+ InvokeRange CurRange;
+};
+} // end anonymous namespace
+
+/// Invoke label range iteration logic. Increment MBBI until we find the next
+/// EH_LABEL pair, and then update MBBI to point after the end label.
+InvokeLabelIterator &InvokeLabelIterator::scan() {
+ // Reset our state.
+ CurRange = InvokeRange{};
+
+ for (const MachineInstr &MI : make_range(MBBI, MBBIEnd)) {
+ // Remember if we had to cross a potentially throwing call instruction that
+ // must unwind to caller.
+ if (MI.isCall()) {
+ CurRange.SawPotentiallyThrowing |=
+ !EHStreamer::callToNoUnwindFunction(&MI);
+ continue;
+ }
+ // Find the next EH_LABEL instruction.
+ if (!MI.isEHLabel())
+ continue;
+
+ // If this is a begin label, break out with the state and end label.
+ // Otherwise this is probably a CFI EH_LABEL that we should continue past.
+ MCSymbol *Label = MI.getOperand(0).getMCSymbol();
+ auto StateAndEnd = EHInfo.InvokeToStateMap.find(Label);
+ if (StateAndEnd == EHInfo.InvokeToStateMap.end())
+ continue;
+ MBBI = MachineBasicBlock::const_iterator(&MI);
+ CurRange.BeginLabel = Label;
+ CurRange.EndLabel = StateAndEnd->second.second;
+ CurRange.State = StateAndEnd->second.first;
+ break;
+ }
+
+ // If we didn't find a begin label, we are done, return the end iterator.
+ if (!CurRange.BeginLabel) {
+ MBBI = MBBIEnd;
+ return *this;
+ }
+
+ // If this is a begin label, update MBBI to point past the end label.
+ for (; MBBI != MBBIEnd; ++MBBI)
+ if (MBBI->isEHLabel() &&
+ MBBI->getOperand(0).getMCSymbol() == CurRange.EndLabel)
+ break;
+ return *this;
+}
+
+/// Utility for making a range for all the invoke ranges.
+static iterator_range<InvokeLabelIterator>
+invoke_ranges(WinEHFuncInfo &EHInfo, const MachineBasicBlock &MBB) {
+ return make_range(InvokeLabelIterator(EHInfo, MBB.begin(), MBB.end()),
+ InvokeLabelIterator(EHInfo, MBB.end(), MBB.end()));
+}
+
/// Emit the language-specific data that __C_specific_handler expects. This
/// handler lives in the x64 Microsoft C runtime and allows catching or cleaning
/// up after faults with __try, __except, and __finally. The typeinfo values
/// imagerel32 LabelStart;
/// imagerel32 LabelEnd;
/// imagerel32 FilterOrFinally; // One means catch-all.
-/// imagerel32 LabelLPad; // Zero means __finally.
+/// imagerel32 ExceptOrNull; // Zero means __finally.
/// } Entries[NumEntries];
/// };
void WinException::emitCSpecificHandlerTable(const MachineFunction *MF) {
- const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
+ auto &OS = *Asm->OutStreamer;
+ MCContext &Ctx = Asm->OutContext;
WinEHFuncInfo &FuncInfo = MMI->getWinEHFuncInfo(MF->getFunction());
- if (!FuncInfo.SEHUnwindMap.empty())
- report_fatal_error("x64 SEH tables not yet implemented");
+ if (!FuncInfo.SEHUnwindMap.empty()) {
+ // Remember what state we were in the last time we found a begin try label.
+ // This allows us to coalesce many nearby invokes with the same state into
+ // one entry.
+ int LastEHState = -1;
+ MCSymbol *LastBeginLabel = nullptr;
+ MCSymbol *LastEndLabel = nullptr;
+
+ // Use the assembler to compute the number of table entries through label
+ // difference and division.
+ MCSymbol *TableBegin =
+ Ctx.createTempSymbol("lsda_begin", /*AlwaysAddSuffix=*/true);
+ MCSymbol *TableEnd =
+ Ctx.createTempSymbol("lsda_end", /*AlwaysAddSuffix=*/true);
+ const MCExpr *LabelDiff =
+ MCBinaryExpr::createSub(MCSymbolRefExpr::create(TableEnd, Ctx),
+ MCSymbolRefExpr::create(TableBegin, Ctx), Ctx);
+ const MCExpr *EntrySize = MCConstantExpr::create(16, Ctx);
+ const MCExpr *EntryCount =
+ MCBinaryExpr::createDiv(LabelDiff, EntrySize, Ctx);
+ OS.EmitValue(EntryCount, 4);
+
+ OS.EmitLabel(TableBegin);
+
+ // Iterate over all the invoke try ranges. Unlike MSVC, LLVM currently only
+ // models exceptions from invokes. LLVM also allows arbitrary reordering of
+ // the code, so our tables end up looking a bit different. Rather than
+ // trying to match MSVC's tables exactly, we emit a denormalized table. For
+ // each range of invokes in the same state, we emit table entries for all
+ // the actions that would be taken in that state. This means our tables are
+ // slightly bigger, which is OK.
+ for (const auto &MBB : *MF) {
+ // Break out before we enter into a finally funclet.
+ // FIXME: We need to emit separate EH tables for cleanups.
+ if (MBB.isEHFuncletEntry() && &MBB != MF->begin())
+ break;
+
+ for (InvokeRange &I : invoke_ranges(FuncInfo, MBB)) {
+ // If this invoke is in the same state as the last invoke and there were
+ // no non-throwing calls between it, extend the range to include both
+ // and continue.
+ if (!I.SawPotentiallyThrowing && I.State == LastEHState) {
+ LastEndLabel = I.EndLabel;
+ continue;
+ }
+
+ // If this invoke ends a previous one, emit all the actions for this
+ // state.
+ if (LastEHState != -1)
+ emitSEHActionsForRange(FuncInfo, LastBeginLabel, LastEndLabel,
+ LastEHState);
+
+ LastBeginLabel = I.BeginLabel;
+ LastEndLabel = I.EndLabel;
+ LastEHState = I.State;
+ }
+ }
+
+ if (LastEndLabel)
+ emitSEHActionsForRange(FuncInfo, LastBeginLabel, LastEndLabel,
+ LastEHState);
+
+ OS.EmitLabel(TableEnd);
+ return;
+ }
// Simplifying assumptions for first implementation:
// - Cleanups are not implemented.
// The Itanium LSDA table sorts similar landing pads together to simplify the
// actions table, but we don't need that.
+ const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
SmallVector<const LandingPadInfo *, 64> LandingPads;
LandingPads.reserve(PadInfos.size());
for (const auto &LP : PadInfos)
continue; // Ignore gaps.
NumEntries += CSE.LPad->SEHHandlers.size();
}
- Asm->OutStreamer->EmitIntValue(NumEntries, 4);
+ OS.EmitIntValue(NumEntries, 4);
// If there are no actions, we don't need to iterate again.
if (NumEntries == 0)
if (CSE.EndLabel) {
// The interval is half-open, so we have to add one to include the return
// address of the last invoke in the range.
- End = MCBinaryExpr::createAdd(create32bitRef(CSE.EndLabel),
- MCConstantExpr::create(1, Asm->OutContext),
- Asm->OutContext);
+ End = getLabelPlusOne(CSE.EndLabel);
} else {
End = create32bitRef(EHFuncEndSym);
}
// Emit an entry for each action.
for (SEHHandler Handler : LPad->SEHHandlers) {
- Asm->OutStreamer->EmitValue(Begin, 4);
- Asm->OutStreamer->EmitValue(End, 4);
+ OS.EmitValue(Begin, 4);
+ OS.EmitValue(End, 4);
// Emit the filter or finally function pointer, if present. Otherwise,
// emit '1' to indicate a catch-all.
const Function *F = Handler.FilterOrFinally;
if (F)
- Asm->OutStreamer->EmitValue(create32bitRef(Asm->getSymbol(F)), 4);
+ OS.EmitValue(create32bitRef(Asm->getSymbol(F)), 4);
else
- Asm->OutStreamer->EmitIntValue(1, 4);
+ OS.EmitIntValue(1, 4);
// Emit the recovery address, if present. Otherwise, this must be a
// finally.
const BlockAddress *BA = Handler.RecoverBA;
if (BA)
- Asm->OutStreamer->EmitValue(
+ OS.EmitValue(
create32bitRef(Asm->GetBlockAddressSymbol(BA)), 4);
else
- Asm->OutStreamer->EmitIntValue(0, 4);
+ OS.EmitIntValue(0, 4);
}
}
}
-/// Retreive the MCSymbol for a GlobalValue or MachineBasicBlock. GlobalValues
-/// are used in the old WinEH scheme, and they will be removed eventually.
-static MCSymbol *getMCSymbolForMBBOrGV(AsmPrinter *Asm, ValueOrMBB Handler) {
- if (!Handler)
- return nullptr;
- if (Handler.is<MachineBasicBlock *>())
- return Handler.get<MachineBasicBlock *>()->getSymbol();
- return Asm->getSymbol(cast<GlobalValue>(Handler.get<const Value *>()));
+void WinException::emitSEHActionsForRange(WinEHFuncInfo &FuncInfo,
+ MCSymbol *BeginLabel,
+ MCSymbol *EndLabel, int State) {
+ auto &OS = *Asm->OutStreamer;
+ MCContext &Ctx = Asm->OutContext;
+
+ assert(BeginLabel && EndLabel);
+ while (State != -1) {
+ // struct Entry {
+ // imagerel32 LabelStart;
+ // imagerel32 LabelEnd;
+ // imagerel32 FilterOrFinally; // One means catch-all.
+ // imagerel32 ExceptOrNull; // Zero means __finally.
+ // };
+ SEHUnwindMapEntry &UME = FuncInfo.SEHUnwindMap[State];
+ const MCExpr *FilterOrFinally;
+ const MCExpr *ExceptOrNull;
+ auto *Handler = UME.Handler.get<MachineBasicBlock *>();
+ if (UME.IsFinally) {
+ FilterOrFinally = create32bitRef(getMCSymbolForMBBOrGV(Asm, Handler));
+ ExceptOrNull = MCConstantExpr::create(0, Ctx);
+ } else {
+ // For an except, the filter can be 1 (catch-all) or a function
+ // label.
+ FilterOrFinally = UME.Filter ? create32bitRef(UME.Filter)
+ : MCConstantExpr::create(1, Ctx);
+ ExceptOrNull = create32bitRef(Handler->getSymbol());
+ }
+
+ OS.EmitValue(getLabelPlusOne(BeginLabel), 4);
+ OS.EmitValue(getLabelPlusOne(EndLabel), 4);
+ OS.EmitValue(FilterOrFinally, 4);
+ OS.EmitValue(ExceptOrNull, 4);
+
+ assert(UME.ToState < State && "states should decrease");
+ State = UME.ToState;
+ }
}
void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) {
StringRef FuncLinkageName = GlobalValue::getRealLinkageName(F->getName());
+ SmallVector<std::pair<const MCExpr *, int>, 4> IPToStateTable;
MCSymbol *FuncInfoXData = nullptr;
if (shouldEmitPersonality) {
+ // If we're 64-bit, emit a pointer to the C++ EH data, and build a map from
+ // IPs to state numbers.
FuncInfoXData =
Asm->OutContext.getOrCreateSymbol(Twine("$cppxdata$", FuncLinkageName));
- OS.EmitValue(create32bitRef(FuncInfoXData), 4);
-
- extendIP2StateTable(MF, FuncInfo);
+ computeIP2StateTable(MF, FuncInfo, IPToStateTable);
} else {
FuncInfoXData = Asm->OutContext.getOrCreateLSDASymbol(FuncLinkageName);
emitEHRegistrationOffsetLabel(FuncInfo, FuncLinkageName);
}
+ int UnwindHelpOffset = 0;
+ if (Asm->MAI->usesWindowsCFI())
+ UnwindHelpOffset = getFrameIndexOffset(FuncInfo.UnwindHelpFrameIdx);
+
MCSymbol *UnwindMapXData = nullptr;
MCSymbol *TryBlockMapXData = nullptr;
MCSymbol *IPToStateXData = nullptr;
if (!FuncInfo.TryBlockMap.empty())
TryBlockMapXData =
Asm->OutContext.getOrCreateSymbol(Twine("$tryMap$", FuncLinkageName));
- if (!FuncInfo.IPToStateList.empty())
+ if (!IPToStateTable.empty())
IPToStateXData =
Asm->OutContext.getOrCreateSymbol(Twine("$ip2state$", FuncLinkageName));
OS.EmitValue(create32bitRef(UnwindMapXData), 4); // UnwindMap
OS.EmitIntValue(FuncInfo.TryBlockMap.size(), 4); // NumTryBlocks
OS.EmitValue(create32bitRef(TryBlockMapXData), 4); // TryBlockMap
- OS.EmitIntValue(FuncInfo.IPToStateList.size(), 4); // IPMapEntries
+ OS.EmitIntValue(IPToStateTable.size(), 4); // IPMapEntries
OS.EmitValue(create32bitRef(IPToStateXData), 4); // IPToStateMap
if (Asm->MAI->usesWindowsCFI())
- OS.EmitIntValue(FuncInfo.UnwindHelpFrameOffset, 4); // UnwindHelp
+ OS.EmitIntValue(UnwindHelpOffset, 4); // UnwindHelp
OS.EmitIntValue(0, 4); // ESTypeList
OS.EmitIntValue(1, 4); // EHFlags
FuncLinkageName, HT.CatchObjRecoverIdx);
FrameAllocOffsetRef = MCSymbolRefExpr::create(
FrameAllocOffset, MCSymbolRefExpr::VK_None, Asm->OutContext);
- } else if (HT.CatchObj.FrameOffset != INT_MAX) {
- int Offset = HT.CatchObj.FrameOffset;
+ } else if (HT.CatchObj.FrameIndex != INT_MAX) {
+ int Offset = getFrameIndexOffset(HT.CatchObj.FrameIndex);
// For 32-bit, the catch object offset is relative to the end of the
// EH registration node. For 64-bit, it's relative to SP at the end of
// the prologue.
// };
if (IPToStateXData) {
OS.EmitLabel(IPToStateXData);
- for (auto &IPStatePair : FuncInfo.IPToStateList) {
- OS.EmitValue(create32bitRef(IPStatePair.first), 4); // IP
- OS.EmitIntValue(IPStatePair.second, 4); // State
+ for (auto &IPStatePair : IPToStateTable) {
+ OS.EmitValue(IPStatePair.first, 4); // IP
+ OS.EmitIntValue(IPStatePair.second, 4); // State
}
}
}
-void WinException::extendIP2StateTable(const MachineFunction *MF,
- WinEHFuncInfo &FuncInfo) {
- // The Itanium LSDA table sorts similar landing pads together to simplify the
- // actions table, but we don't need that.
- SmallVector<const LandingPadInfo *, 64> LandingPads;
- const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
- LandingPads.reserve(PadInfos.size());
- for (const auto &LP : PadInfos)
- LandingPads.push_back(&LP);
-
- RangeMapType PadMap;
- computePadMap(LandingPads, PadMap);
+void WinException::computeIP2StateTable(
+ const MachineFunction *MF, WinEHFuncInfo &FuncInfo,
+ SmallVectorImpl<std::pair<const MCExpr *, int>> &IPToStateTable) {
+ // Remember what state we were in the last time we found a begin try label.
+ // This allows us to coalesce many nearby invokes with the same state into one
+ // entry.
+ int LastEHState = -1;
+ MCSymbol *LastEndLabel = Asm->getFunctionBegin();
+ assert(LastEndLabel && "need local function start label");
+
+ // Indicate that all calls from the prologue to the first invoke unwind to
+ // caller. We handle this as a special case since other ranges starting at end
+ // labels need to use LtmpN+1.
+ IPToStateTable.push_back(std::make_pair(create32bitRef(LastEndLabel), -1));
- // The end label of the previous invoke or nounwind try-range.
- MCSymbol *LastLabel = Asm->getFunctionBegin();
-
- // Whether there is a potentially throwing instruction (currently this means
- // an ordinary call) between the end of the previous try-range and now.
- bool SawPotentiallyThrowing = false;
-
- int LastEHState = -2;
-
- // The parent function and the catch handlers contribute to the 'ip2state'
- // table.
-
- // Include ip2state entries for the beginning of the main function and
- // for catch handler functions.
- FuncInfo.IPToStateList.push_back(std::make_pair(LastLabel, -1));
- LastEHState = -1;
for (const auto &MBB : *MF) {
- for (const auto &MI : MBB) {
- if (!MI.isEHLabel()) {
- if (MI.isCall())
- SawPotentiallyThrowing |= !callToNoUnwindFunction(&MI);
- continue;
- }
-
- // End of the previous try-range?
- MCSymbol *BeginLabel = MI.getOperand(0).getMCSymbol();
- if (BeginLabel == LastLabel)
- SawPotentiallyThrowing = false;
-
- // Beginning of a new try-range?
- RangeMapType::const_iterator L = PadMap.find(BeginLabel);
- if (L == PadMap.end())
- // Nope, it was just some random label.
- continue;
-
- const PadRange &P = L->second;
- const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
- assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
- "Inconsistent landing pad map!");
-
- // FIXME: Should this be using FuncInfo.HandlerBaseState?
- if (SawPotentiallyThrowing && LastEHState != -1) {
- FuncInfo.IPToStateList.push_back(std::make_pair(LastLabel, -1));
- SawPotentiallyThrowing = false;
+ // FIXME: Do we need to emit entries for funclet base states?
+
+ for (InvokeRange &I : invoke_ranges(FuncInfo, MBB)) {
+ assert(I.BeginLabel && I.EndLabel);
+ // If there was a potentially throwing call between this begin label and
+ // the last end label, we need an extra base state entry to indicate that
+ // those calls unwind directly to the caller.
+ if (I.SawPotentiallyThrowing && LastEHState != -1) {
+ IPToStateTable.push_back(
+ std::make_pair(getLabelPlusOne(LastEndLabel), -1));
LastEHState = -1;
}
- if (LandingPad->WinEHState != LastEHState)
- FuncInfo.IPToStateList.push_back(
- std::make_pair(BeginLabel, LandingPad->WinEHState));
- LastEHState = LandingPad->WinEHState;
- LastLabel = LandingPad->EndLabels[P.RangeIndex];
+ // Emit an entry indicating that PCs after 'Label' have this EH state.
+ if (I.State != LastEHState)
+ IPToStateTable.push_back(
+ std::make_pair(getLabelPlusOne(I.BeginLabel), I.State));
+ LastEHState = I.State;
+ LastEndLabel = I.EndLabel;
}
}
+
+ if (LastEndLabel != Asm->getFunctionBegin()) {
+ // Indicate that all calls from the last invoke until the epilogue unwind to
+ // caller. This also ensures that we have at least one ip2state entry, if
+ // somehow all invokes were deleted during CodeGen.
+ IPToStateTable.push_back(std::make_pair(getLabelPlusOne(LastEndLabel), -1));
+ }
}
void WinException::emitEHRegistrationOffsetLabel(const WinEHFuncInfo &FuncInfo,
for (SEHUnwindMapEntry &UME : FuncInfo.SEHUnwindMap) {
MCSymbol *ExceptOrFinally =
UME.Handler.get<MachineBasicBlock *>()->getSymbol();
- OS.EmitIntValue(UME.ToState, 4); // ToState
+ // -1 is usually the base state for "unwind to caller", but for
+ // _except_handler4 it's -2. Do that replacement here if necessary.
+ int ToState = UME.ToState == -1 ? BaseState : UME.ToState;
+ OS.EmitIntValue(ToState, 4); // ToState
OS.EmitValue(create32bitRef(UME.Filter), 4); // Filter
OS.EmitValue(create32bitRef(ExceptOrFinally), 4); // Except/Finally
}
projects / oota-llvm.git / blobdiff