1//===-- CodeGen/AsmPrinter/WinException.cpp - Dwarf Exception Impl ------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains support for writing Win64 exception info into asm files. 11// 12//===----------------------------------------------------------------------===// 13 14#include "WinException.h" 15#include "llvm/ADT/SmallString.h" 16#include "llvm/ADT/StringExtras.h" 17#include "llvm/ADT/Twine.h" 18#include "llvm/CodeGen/AsmPrinter.h" 19#include "llvm/CodeGen/MachineFrameInfo.h" 20#include "llvm/CodeGen/MachineFunction.h" 21#include "llvm/CodeGen/MachineModuleInfo.h" 22#include "llvm/CodeGen/WinEHFuncInfo.h" 23#include "llvm/IR/DataLayout.h" 24#include "llvm/IR/Mangler.h" 25#include "llvm/IR/Module.h" 26#include "llvm/MC/MCAsmInfo.h" 27#include "llvm/MC/MCContext.h" 28#include "llvm/MC/MCExpr.h" 29#include "llvm/MC/MCSection.h" 30#include "llvm/MC/MCStreamer.h" 31#include "llvm/MC/MCSymbol.h" 32#include "llvm/MC/MCWin64EH.h" 33#include "llvm/Support/COFF.h" 34#include "llvm/Support/Dwarf.h" 35#include "llvm/Support/ErrorHandling.h" 36#include "llvm/Support/FormattedStream.h" 37#include "llvm/Target/TargetFrameLowering.h" 38#include "llvm/Target/TargetLoweringObjectFile.h" 39#include "llvm/Target/TargetOptions.h" 40#include "llvm/Target/TargetRegisterInfo.h" 41#include "llvm/Target/TargetSubtargetInfo.h" 42using namespace llvm; 43 44WinException::WinException(AsmPrinter *A) : EHStreamer(A) { 45 // MSVC's EH tables are always composed of 32-bit words. All known 64-bit 46 // platforms use an imagerel32 relocation to refer to symbols. 47 useImageRel32 = (A->getDataLayout().getPointerSizeInBits() == 64); 48} 49 50WinException::~WinException() {} 51 52/// endModule - Emit all exception information that should come after the 53/// content. 54void WinException::endModule() { 55 auto &OS = *Asm->OutStreamer; 56 const Module *M = MMI->getModule(); 57 for (const Function &F : *M) 58 if (F.hasFnAttribute("safeseh")) 59 OS.EmitCOFFSafeSEH(Asm->getSymbol(&F)); 60} 61 62void WinException::beginFunction(const MachineFunction *MF) { 63 shouldEmitMoves = shouldEmitPersonality = shouldEmitLSDA = false; 64 65 // If any landing pads survive, we need an EH table. 66 bool hasLandingPads = !MMI->getLandingPads().empty(); 67 bool hasEHFunclets = MMI->hasEHFunclets(); 68 69 const Function *F = MF->getFunction(); 70 71 shouldEmitMoves = Asm->needsSEHMoves(); 72 73 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 74 unsigned PerEncoding = TLOF.getPersonalityEncoding(); 75 const Function *Per = nullptr; 76 if (F->hasPersonalityFn()) 77 Per = dyn_cast<Function>(F->getPersonalityFn()->stripPointerCasts()); 78 79 bool forceEmitPersonality = 80 F->hasPersonalityFn() && !isNoOpWithoutInvoke(classifyEHPersonality(Per)) && 81 F->needsUnwindTableEntry(); 82 83 shouldEmitPersonality = 84 forceEmitPersonality || ((hasLandingPads || hasEHFunclets) && 85 PerEncoding != dwarf::DW_EH_PE_omit && Per); 86 87 unsigned LSDAEncoding = TLOF.getLSDAEncoding(); 88 shouldEmitLSDA = shouldEmitPersonality && 89 LSDAEncoding != dwarf::DW_EH_PE_omit; 90 91 // If we're not using CFI, we don't want the CFI or the personality, but we 92 // might want EH tables if we had EH pads. 93 if (!Asm->MAI->usesWindowsCFI()) { 94 shouldEmitLSDA = hasEHFunclets; 95 shouldEmitPersonality = false; 96 return; 97 } 98 99 beginFunclet(MF->front(), Asm->CurrentFnSym); 100} 101 102/// endFunction - Gather and emit post-function exception information. 103/// 104void WinException::endFunction(const MachineFunction *MF) { 105 if (!shouldEmitPersonality && !shouldEmitMoves && !shouldEmitLSDA) 106 return; 107 108 const Function *F = MF->getFunction(); 109 EHPersonality Per = EHPersonality::Unknown; 110 if (F->hasPersonalityFn()) 111 Per = classifyEHPersonality(F->getPersonalityFn()); 112 113 // Get rid of any dead landing pads if we're not using funclets. In funclet 114 // schemes, the landing pad is not actually reachable. It only exists so 115 // that we can emit the right table data. 116 if (!isFuncletEHPersonality(Per)) 117 MMI->TidyLandingPads(); 118 119 endFunclet(); 120 121 // endFunclet will emit the necessary .xdata tables for x64 SEH. 122 if (Per == EHPersonality::MSVC_Win64SEH && MMI->hasEHFunclets()) 123 return; 124 125 if (shouldEmitPersonality || shouldEmitLSDA) { 126 Asm->OutStreamer->PushSection(); 127 128 // Just switch sections to the right xdata section. This use of CurrentFnSym 129 // assumes that we only emit the LSDA when ending the parent function. 130 MCSection *XData = WinEH::UnwindEmitter::getXDataSection(Asm->CurrentFnSym, 131 Asm->OutContext); 132 Asm->OutStreamer->SwitchSection(XData); 133 134 // Emit the tables appropriate to the personality function in use. If we 135 // don't recognize the personality, assume it uses an Itanium-style LSDA. 136 if (Per == EHPersonality::MSVC_Win64SEH) 137 emitCSpecificHandlerTable(MF); 138 else if (Per == EHPersonality::MSVC_X86SEH) 139 emitExceptHandlerTable(MF); 140 else if (Per == EHPersonality::MSVC_CXX) 141 emitCXXFrameHandler3Table(MF); 142 else if (Per == EHPersonality::CoreCLR) 143 emitCLRExceptionTable(MF); 144 else 145 emitExceptionTable(); 146 147 Asm->OutStreamer->PopSection(); 148 } 149} 150 151/// Retreive the MCSymbol for a GlobalValue or MachineBasicBlock. 152static MCSymbol *getMCSymbolForMBB(AsmPrinter *Asm, 153 const MachineBasicBlock *MBB) { 154 if (!MBB) 155 return nullptr; 156 157 assert(MBB->isEHFuncletEntry()); 158 159 // Give catches and cleanups a name based off of their parent function and 160 // their funclet entry block's number. 161 const MachineFunction *MF = MBB->getParent(); 162 const Function *F = MF->getFunction(); 163 StringRef FuncLinkageName = GlobalValue::getRealLinkageName(F->getName()); 164 MCContext &Ctx = MF->getContext(); 165 StringRef HandlerPrefix = MBB->isCleanupFuncletEntry() ? "dtor" : "catch"; 166 return Ctx.getOrCreateSymbol("?" + HandlerPrefix + "$" + 167 Twine(MBB->getNumber()) + "@?0?" + 168 FuncLinkageName + "@4HA"); 169} 170 171void WinException::beginFunclet(const MachineBasicBlock &MBB, 172 MCSymbol *Sym) { 173 CurrentFuncletEntry = &MBB; 174 175 const Function *F = Asm->MF->getFunction(); 176 // If a symbol was not provided for the funclet, invent one. 177 if (!Sym) { 178 Sym = getMCSymbolForMBB(Asm, &MBB); 179 180 // Describe our funclet symbol as a function with internal linkage. 181 Asm->OutStreamer->BeginCOFFSymbolDef(Sym); 182 Asm->OutStreamer->EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC); 183 Asm->OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION 184 << COFF::SCT_COMPLEX_TYPE_SHIFT); 185 Asm->OutStreamer->EndCOFFSymbolDef(); 186 187 // We want our funclet's entry point to be aligned such that no nops will be 188 // present after the label. 189 Asm->EmitAlignment(std::max(Asm->MF->getAlignment(), MBB.getAlignment()), 190 F); 191 192 // Now that we've emitted the alignment directive, point at our funclet. 193 Asm->OutStreamer->EmitLabel(Sym); 194 } 195 196 // Mark 'Sym' as starting our funclet. 197 if (shouldEmitMoves || shouldEmitPersonality) 198 Asm->OutStreamer->EmitWinCFIStartProc(Sym); 199 200 if (shouldEmitPersonality) { 201 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 202 const Function *PerFn = nullptr; 203 204 // Determine which personality routine we are using for this funclet. 205 if (F->hasPersonalityFn()) 206 PerFn = dyn_cast<Function>(F->getPersonalityFn()->stripPointerCasts()); 207 const MCSymbol *PersHandlerSym = 208 TLOF.getCFIPersonalitySymbol(PerFn, *Asm->Mang, Asm->TM, MMI); 209 210 // Classify the personality routine so that we may reason about it. 211 EHPersonality Per = EHPersonality::Unknown; 212 if (F->hasPersonalityFn()) 213 Per = classifyEHPersonality(F->getPersonalityFn()); 214 215 // Do not emit a .seh_handler directive if it is a C++ cleanup funclet. 216 if (Per != EHPersonality::MSVC_CXX || 217 !CurrentFuncletEntry->isCleanupFuncletEntry()) 218 Asm->OutStreamer->EmitWinEHHandler(PersHandlerSym, true, true); 219 } 220} 221 222void WinException::endFunclet() { 223 // No funclet to process? Great, we have nothing to do. 224 if (!CurrentFuncletEntry) 225 return; 226 227 if (shouldEmitMoves || shouldEmitPersonality) { 228 const Function *F = Asm->MF->getFunction(); 229 EHPersonality Per = EHPersonality::Unknown; 230 if (F->hasPersonalityFn()) 231 Per = classifyEHPersonality(F->getPersonalityFn()); 232 233 // The .seh_handlerdata directive implicitly switches section, push the 234 // current section so that we may return to it. 235 Asm->OutStreamer->PushSection(); 236 237 // Emit an UNWIND_INFO struct describing the prologue. 238 Asm->OutStreamer->EmitWinEHHandlerData(); 239 240 if (Per == EHPersonality::MSVC_CXX && shouldEmitPersonality && 241 !CurrentFuncletEntry->isCleanupFuncletEntry()) { 242 // If this is a C++ catch funclet (or the parent function), 243 // emit a reference to the LSDA for the parent function. 244 StringRef FuncLinkageName = GlobalValue::getRealLinkageName(F->getName()); 245 MCSymbol *FuncInfoXData = Asm->OutContext.getOrCreateSymbol( 246 Twine("$cppxdata$", FuncLinkageName)); 247 Asm->OutStreamer->EmitValue(create32bitRef(FuncInfoXData), 4); 248 } else if (Per == EHPersonality::MSVC_Win64SEH && MMI->hasEHFunclets() && 249 !CurrentFuncletEntry->isEHFuncletEntry()) { 250 // If this is the parent function in Win64 SEH, emit the LSDA immediately 251 // following .seh_handlerdata. 252 emitCSpecificHandlerTable(Asm->MF); 253 } 254 255 // Switch back to the previous section now that we are done writing to 256 // .xdata. 257 Asm->OutStreamer->PopSection(); 258 259 // Emit a .seh_endproc directive to mark the end of the function. 260 Asm->OutStreamer->EmitWinCFIEndProc(); 261 } 262 263 // Let's make sure we don't try to end the same funclet twice. 264 CurrentFuncletEntry = nullptr; 265} 266 267const MCExpr *WinException::create32bitRef(const MCSymbol *Value) { 268 if (!Value) 269 return MCConstantExpr::create(0, Asm->OutContext); 270 return MCSymbolRefExpr::create(Value, useImageRel32 271 ? MCSymbolRefExpr::VK_COFF_IMGREL32 272 : MCSymbolRefExpr::VK_None, 273 Asm->OutContext); 274} 275 276const MCExpr *WinException::create32bitRef(const GlobalValue *GV) { 277 if (!GV) 278 return MCConstantExpr::create(0, Asm->OutContext); 279 return create32bitRef(Asm->getSymbol(GV)); 280} 281 282const MCExpr *WinException::getLabelPlusOne(const MCSymbol *Label) { 283 return MCBinaryExpr::createAdd(create32bitRef(Label), 284 MCConstantExpr::create(1, Asm->OutContext), 285 Asm->OutContext); 286} 287 288const MCExpr *WinException::getOffset(const MCSymbol *OffsetOf, 289 const MCSymbol *OffsetFrom) { 290 return MCBinaryExpr::createSub( 291 MCSymbolRefExpr::create(OffsetOf, Asm->OutContext), 292 MCSymbolRefExpr::create(OffsetFrom, Asm->OutContext), Asm->OutContext); 293} 294 295const MCExpr *WinException::getOffsetPlusOne(const MCSymbol *OffsetOf, 296 const MCSymbol *OffsetFrom) { 297 return MCBinaryExpr::createAdd(getOffset(OffsetOf, OffsetFrom), 298 MCConstantExpr::create(1, Asm->OutContext), 299 Asm->OutContext); 300} 301 302int WinException::getFrameIndexOffset(int FrameIndex, 303 const WinEHFuncInfo &FuncInfo) { 304 const TargetFrameLowering &TFI = *Asm->MF->getSubtarget().getFrameLowering(); 305 unsigned UnusedReg; 306 if (Asm->MAI->usesWindowsCFI()) 307 return TFI.getFrameIndexReferenceFromSP(*Asm->MF, FrameIndex, UnusedReg); 308 // For 32-bit, offsets should be relative to the end of the EH registration 309 // node. For 64-bit, it's relative to SP at the end of the prologue. 310 assert(FuncInfo.EHRegNodeEndOffset != INT_MAX); 311 int Offset = TFI.getFrameIndexReference(*Asm->MF, FrameIndex, UnusedReg); 312 Offset += FuncInfo.EHRegNodeEndOffset; 313 return Offset; 314} 315 316namespace { 317 318/// Top-level state used to represent unwind to caller 319const int NullState = -1; 320 321struct InvokeStateChange { 322 /// EH Label immediately after the last invoke in the previous state, or 323 /// nullptr if the previous state was the null state. 324 const MCSymbol *PreviousEndLabel; 325 326 /// EH label immediately before the first invoke in the new state, or nullptr 327 /// if the new state is the null state. 328 const MCSymbol *NewStartLabel; 329 330 /// State of the invoke following NewStartLabel, or NullState to indicate 331 /// the presence of calls which may unwind to caller. 332 int NewState; 333}; 334 335/// Iterator that reports all the invoke state changes in a range of machine 336/// basic blocks. Changes to the null state are reported whenever a call that 337/// may unwind to caller is encountered. The MBB range is expected to be an 338/// entire function or funclet, and the start and end of the range are treated 339/// as being in the NullState even if there's not an unwind-to-caller call 340/// before the first invoke or after the last one (i.e., the first state change 341/// reported is the first change to something other than NullState, and a 342/// change back to NullState is always reported at the end of iteration). 343class InvokeStateChangeIterator { 344 InvokeStateChangeIterator(const WinEHFuncInfo &EHInfo, 345 MachineFunction::const_iterator MFI, 346 MachineFunction::const_iterator MFE, 347 MachineBasicBlock::const_iterator MBBI, 348 int BaseState) 349 : EHInfo(EHInfo), MFI(MFI), MFE(MFE), MBBI(MBBI), BaseState(BaseState) { 350 LastStateChange.PreviousEndLabel = nullptr; 351 LastStateChange.NewStartLabel = nullptr; 352 LastStateChange.NewState = BaseState; 353 scan(); 354 } 355 356public: 357 static iterator_range<InvokeStateChangeIterator> 358 range(const WinEHFuncInfo &EHInfo, MachineFunction::const_iterator Begin, 359 MachineFunction::const_iterator End, int BaseState = NullState) { 360 // Reject empty ranges to simplify bookkeeping by ensuring that we can get 361 // the end of the last block. 362 assert(Begin != End); 363 auto BlockBegin = Begin->begin(); 364 auto BlockEnd = std::prev(End)->end(); 365 return make_range( 366 InvokeStateChangeIterator(EHInfo, Begin, End, BlockBegin, BaseState), 367 InvokeStateChangeIterator(EHInfo, End, End, BlockEnd, BaseState)); 368 } 369 370 // Iterator methods. 371 bool operator==(const InvokeStateChangeIterator &O) const { 372 assert(BaseState == O.BaseState); 373 // Must be visiting same block. 374 if (MFI != O.MFI) 375 return false; 376 // Must be visiting same isntr. 377 if (MBBI != O.MBBI) 378 return false; 379 // At end of block/instr iteration, we can still have two distinct states: 380 // one to report the final EndLabel, and another indicating the end of the 381 // state change iteration. Check for CurrentEndLabel equality to 382 // distinguish these. 383 return CurrentEndLabel == O.CurrentEndLabel; 384 } 385 386 bool operator!=(const InvokeStateChangeIterator &O) const { 387 return !operator==(O); 388 } 389 InvokeStateChange &operator*() { return LastStateChange; } 390 InvokeStateChange *operator->() { return &LastStateChange; } 391 InvokeStateChangeIterator &operator++() { return scan(); } 392 393private: 394 InvokeStateChangeIterator &scan(); 395 396 const WinEHFuncInfo &EHInfo; 397 const MCSymbol *CurrentEndLabel = nullptr; 398 MachineFunction::const_iterator MFI; 399 MachineFunction::const_iterator MFE; 400 MachineBasicBlock::const_iterator MBBI; 401 InvokeStateChange LastStateChange; 402 bool VisitingInvoke = false; 403 int BaseState; 404}; 405 406} // end anonymous namespace 407 408InvokeStateChangeIterator &InvokeStateChangeIterator::scan() { 409 bool IsNewBlock = false; 410 for (; MFI != MFE; ++MFI, IsNewBlock = true) { 411 if (IsNewBlock) 412 MBBI = MFI->begin(); 413 for (auto MBBE = MFI->end(); MBBI != MBBE; ++MBBI) { 414 const MachineInstr &MI = *MBBI; 415 if (!VisitingInvoke && LastStateChange.NewState != BaseState && 416 MI.isCall() && !EHStreamer::callToNoUnwindFunction(&MI)) { 417 // Indicate a change of state to the null state. We don't have 418 // start/end EH labels handy but the caller won't expect them for 419 // null state regions. 420 LastStateChange.PreviousEndLabel = CurrentEndLabel; 421 LastStateChange.NewStartLabel = nullptr; 422 LastStateChange.NewState = BaseState; 423 CurrentEndLabel = nullptr; 424 // Don't re-visit this instr on the next scan 425 ++MBBI; 426 return *this; 427 } 428 429 // All other state changes are at EH labels before/after invokes. 430 if (!MI.isEHLabel()) 431 continue; 432 MCSymbol *Label = MI.getOperand(0).getMCSymbol(); 433 if (Label == CurrentEndLabel) { 434 VisitingInvoke = false; 435 continue; 436 } 437 auto InvokeMapIter = EHInfo.LabelToStateMap.find(Label); 438 // Ignore EH labels that aren't the ones inserted before an invoke 439 if (InvokeMapIter == EHInfo.LabelToStateMap.end()) 440 continue; 441 auto &StateAndEnd = InvokeMapIter->second; 442 int NewState = StateAndEnd.first; 443 // Keep track of the fact that we're between EH start/end labels so 444 // we know not to treat the inoke we'll see as unwinding to caller. 445 VisitingInvoke = true; 446 if (NewState == LastStateChange.NewState) { 447 // The state isn't actually changing here. Record the new end and 448 // keep going. 449 CurrentEndLabel = StateAndEnd.second; 450 continue; 451 } 452 // Found a state change to report 453 LastStateChange.PreviousEndLabel = CurrentEndLabel; 454 LastStateChange.NewStartLabel = Label; 455 LastStateChange.NewState = NewState; 456 // Start keeping track of the new current end 457 CurrentEndLabel = StateAndEnd.second; 458 // Don't re-visit this instr on the next scan 459 ++MBBI; 460 return *this; 461 } 462 } 463 // Iteration hit the end of the block range. 464 if (LastStateChange.NewState != BaseState) { 465 // Report the end of the last new state 466 LastStateChange.PreviousEndLabel = CurrentEndLabel; 467 LastStateChange.NewStartLabel = nullptr; 468 LastStateChange.NewState = BaseState; 469 // Leave CurrentEndLabel non-null to distinguish this state from end. 470 assert(CurrentEndLabel != nullptr); 471 return *this; 472 } 473 // We've reported all state changes and hit the end state. 474 CurrentEndLabel = nullptr; 475 return *this; 476} 477 478/// Emit the language-specific data that __C_specific_handler expects. This 479/// handler lives in the x64 Microsoft C runtime and allows catching or cleaning 480/// up after faults with __try, __except, and __finally. The typeinfo values 481/// are not really RTTI data, but pointers to filter functions that return an 482/// integer (1, 0, or -1) indicating how to handle the exception. For __finally 483/// blocks and other cleanups, the landing pad label is zero, and the filter 484/// function is actually a cleanup handler with the same prototype. A catch-all 485/// entry is modeled with a null filter function field and a non-zero landing 486/// pad label. 487/// 488/// Possible filter function return values: 489/// EXCEPTION_EXECUTE_HANDLER (1): 490/// Jump to the landing pad label after cleanups. 491/// EXCEPTION_CONTINUE_SEARCH (0): 492/// Continue searching this table or continue unwinding. 493/// EXCEPTION_CONTINUE_EXECUTION (-1): 494/// Resume execution at the trapping PC. 495/// 496/// Inferred table structure: 497/// struct Table { 498/// int NumEntries; 499/// struct Entry { 500/// imagerel32 LabelStart; 501/// imagerel32 LabelEnd; 502/// imagerel32 FilterOrFinally; // One means catch-all. 503/// imagerel32 LabelLPad; // Zero means __finally. 504/// } Entries[NumEntries]; 505/// }; 506void WinException::emitCSpecificHandlerTable(const MachineFunction *MF) { 507 auto &OS = *Asm->OutStreamer; 508 MCContext &Ctx = Asm->OutContext; 509 const WinEHFuncInfo &FuncInfo = *MF->getWinEHFuncInfo(); 510 511 bool VerboseAsm = OS.isVerboseAsm(); 512 auto AddComment = [&](const Twine &Comment) { 513 if (VerboseAsm) 514 OS.AddComment(Comment); 515 }; 516 517 // Emit a label assignment with the SEH frame offset so we can use it for 518 // llvm.x86.seh.recoverfp. 519 StringRef FLinkageName = 520 GlobalValue::getRealLinkageName(MF->getFunction()->getName()); 521 MCSymbol *ParentFrameOffset = 522 Ctx.getOrCreateParentFrameOffsetSymbol(FLinkageName); 523 const MCExpr *MCOffset = 524 MCConstantExpr::create(FuncInfo.SEHSetFrameOffset, Ctx); 525 Asm->OutStreamer->EmitAssignment(ParentFrameOffset, MCOffset); 526 527 // Use the assembler to compute the number of table entries through label 528 // difference and division. 529 MCSymbol *TableBegin = 530 Ctx.createTempSymbol("lsda_begin", /*AlwaysAddSuffix=*/true); 531 MCSymbol *TableEnd = 532 Ctx.createTempSymbol("lsda_end", /*AlwaysAddSuffix=*/true); 533 const MCExpr *LabelDiff = getOffset(TableEnd, TableBegin); 534 const MCExpr *EntrySize = MCConstantExpr::create(16, Ctx); 535 const MCExpr *EntryCount = MCBinaryExpr::createDiv(LabelDiff, EntrySize, Ctx); 536 AddComment("Number of call sites"); 537 OS.EmitValue(EntryCount, 4); 538 539 OS.EmitLabel(TableBegin); 540 541 // Iterate over all the invoke try ranges. Unlike MSVC, LLVM currently only 542 // models exceptions from invokes. LLVM also allows arbitrary reordering of 543 // the code, so our tables end up looking a bit different. Rather than 544 // trying to match MSVC's tables exactly, we emit a denormalized table. For 545 // each range of invokes in the same state, we emit table entries for all 546 // the actions that would be taken in that state. This means our tables are 547 // slightly bigger, which is OK. 548 const MCSymbol *LastStartLabel = nullptr; 549 int LastEHState = -1; 550 // Break out before we enter into a finally funclet. 551 // FIXME: We need to emit separate EH tables for cleanups. 552 MachineFunction::const_iterator End = MF->end(); 553 MachineFunction::const_iterator Stop = std::next(MF->begin()); 554 while (Stop != End && !Stop->isEHFuncletEntry()) 555 ++Stop; 556 for (const auto &StateChange : 557 InvokeStateChangeIterator::range(FuncInfo, MF->begin(), Stop)) { 558 // Emit all the actions for the state we just transitioned out of 559 // if it was not the null state 560 if (LastEHState != -1) 561 emitSEHActionsForRange(FuncInfo, LastStartLabel, 562 StateChange.PreviousEndLabel, LastEHState); 563 LastStartLabel = StateChange.NewStartLabel; 564 LastEHState = StateChange.NewState; 565 } 566 567 OS.EmitLabel(TableEnd); 568} 569 570void WinException::emitSEHActionsForRange(const WinEHFuncInfo &FuncInfo, 571 const MCSymbol *BeginLabel, 572 const MCSymbol *EndLabel, int State) { 573 auto &OS = *Asm->OutStreamer; 574 MCContext &Ctx = Asm->OutContext; 575 576 bool VerboseAsm = OS.isVerboseAsm(); 577 auto AddComment = [&](const Twine &Comment) { 578 if (VerboseAsm) 579 OS.AddComment(Comment); 580 }; 581 582 assert(BeginLabel && EndLabel); 583 while (State != -1) { 584 const SEHUnwindMapEntry &UME = FuncInfo.SEHUnwindMap[State]; 585 const MCExpr *FilterOrFinally; 586 const MCExpr *ExceptOrNull; 587 auto *Handler = UME.Handler.get<MachineBasicBlock *>(); 588 if (UME.IsFinally) { 589 FilterOrFinally = create32bitRef(getMCSymbolForMBB(Asm, Handler)); 590 ExceptOrNull = MCConstantExpr::create(0, Ctx); 591 } else { 592 // For an except, the filter can be 1 (catch-all) or a function 593 // label. 594 FilterOrFinally = UME.Filter ? create32bitRef(UME.Filter) 595 : MCConstantExpr::create(1, Ctx); 596 ExceptOrNull = create32bitRef(Handler->getSymbol()); 597 } 598 599 AddComment("LabelStart"); 600 OS.EmitValue(getLabelPlusOne(BeginLabel), 4); 601 AddComment("LabelEnd"); 602 OS.EmitValue(getLabelPlusOne(EndLabel), 4); 603 AddComment(UME.IsFinally ? "FinallyFunclet" : UME.Filter ? "FilterFunction" 604 : "CatchAll"); 605 OS.EmitValue(FilterOrFinally, 4); 606 AddComment(UME.IsFinally ? "Null" : "ExceptionHandler"); 607 OS.EmitValue(ExceptOrNull, 4); 608 609 assert(UME.ToState < State && "states should decrease"); 610 State = UME.ToState; 611 } 612} 613 614void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) { 615 const Function *F = MF->getFunction(); 616 auto &OS = *Asm->OutStreamer; 617 const WinEHFuncInfo &FuncInfo = *MF->getWinEHFuncInfo(); 618 619 StringRef FuncLinkageName = GlobalValue::getRealLinkageName(F->getName()); 620 621 SmallVector<std::pair<const MCExpr *, int>, 4> IPToStateTable; 622 MCSymbol *FuncInfoXData = nullptr; 623 if (shouldEmitPersonality) { 624 // If we're 64-bit, emit a pointer to the C++ EH data, and build a map from 625 // IPs to state numbers. 626 FuncInfoXData = 627 Asm->OutContext.getOrCreateSymbol(Twine("$cppxdata$", FuncLinkageName)); 628 computeIP2StateTable(MF, FuncInfo, IPToStateTable); 629 } else { 630 FuncInfoXData = Asm->OutContext.getOrCreateLSDASymbol(FuncLinkageName); 631 } 632 633 int UnwindHelpOffset = 0; 634 if (Asm->MAI->usesWindowsCFI()) 635 UnwindHelpOffset = 636 getFrameIndexOffset(FuncInfo.UnwindHelpFrameIdx, FuncInfo); 637 638 MCSymbol *UnwindMapXData = nullptr; 639 MCSymbol *TryBlockMapXData = nullptr; 640 MCSymbol *IPToStateXData = nullptr; 641 if (!FuncInfo.CxxUnwindMap.empty()) 642 UnwindMapXData = Asm->OutContext.getOrCreateSymbol( 643 Twine("$stateUnwindMap$", FuncLinkageName)); 644 if (!FuncInfo.TryBlockMap.empty()) 645 TryBlockMapXData = 646 Asm->OutContext.getOrCreateSymbol(Twine("$tryMap$", FuncLinkageName)); 647 if (!IPToStateTable.empty()) 648 IPToStateXData = 649 Asm->OutContext.getOrCreateSymbol(Twine("$ip2state$", FuncLinkageName)); 650 651 bool VerboseAsm = OS.isVerboseAsm(); 652 auto AddComment = [&](const Twine &Comment) { 653 if (VerboseAsm) 654 OS.AddComment(Comment); 655 }; 656 657 // FuncInfo { 658 // uint32_t MagicNumber 659 // int32_t MaxState; 660 // UnwindMapEntry *UnwindMap; 661 // uint32_t NumTryBlocks; 662 // TryBlockMapEntry *TryBlockMap; 663 // uint32_t IPMapEntries; // always 0 for x86 664 // IPToStateMapEntry *IPToStateMap; // always 0 for x86 665 // uint32_t UnwindHelp; // non-x86 only 666 // ESTypeList *ESTypeList; 667 // int32_t EHFlags; 668 // } 669 // EHFlags & 1 -> Synchronous exceptions only, no async exceptions. 670 // EHFlags & 2 -> ??? 671 // EHFlags & 4 -> The function is noexcept(true), unwinding can't continue. 672 OS.EmitValueToAlignment(4); 673 OS.EmitLabel(FuncInfoXData); 674 675 AddComment("MagicNumber"); 676 OS.EmitIntValue(0x19930522, 4); 677 678 AddComment("MaxState"); 679 OS.EmitIntValue(FuncInfo.CxxUnwindMap.size(), 4); 680 681 AddComment("UnwindMap"); 682 OS.EmitValue(create32bitRef(UnwindMapXData), 4); 683 684 AddComment("NumTryBlocks"); 685 OS.EmitIntValue(FuncInfo.TryBlockMap.size(), 4); 686 687 AddComment("TryBlockMap"); 688 OS.EmitValue(create32bitRef(TryBlockMapXData), 4); 689 690 AddComment("IPMapEntries"); 691 OS.EmitIntValue(IPToStateTable.size(), 4); 692 693 AddComment("IPToStateXData"); 694 OS.EmitValue(create32bitRef(IPToStateXData), 4); 695 696 if (Asm->MAI->usesWindowsCFI()) { 697 AddComment("UnwindHelp"); 698 OS.EmitIntValue(UnwindHelpOffset, 4); 699 } 700 701 AddComment("ESTypeList"); 702 OS.EmitIntValue(0, 4); 703 704 AddComment("EHFlags"); 705 OS.EmitIntValue(1, 4); 706 707 // UnwindMapEntry { 708 // int32_t ToState; 709 // void (*Action)(); 710 // }; 711 if (UnwindMapXData) { 712 OS.EmitLabel(UnwindMapXData); 713 for (const CxxUnwindMapEntry &UME : FuncInfo.CxxUnwindMap) { 714 MCSymbol *CleanupSym = 715 getMCSymbolForMBB(Asm, UME.Cleanup.dyn_cast<MachineBasicBlock *>()); 716 AddComment("ToState"); 717 OS.EmitIntValue(UME.ToState, 4); 718 719 AddComment("Action"); 720 OS.EmitValue(create32bitRef(CleanupSym), 4); 721 } 722 } 723 724 // TryBlockMap { 725 // int32_t TryLow; 726 // int32_t TryHigh; 727 // int32_t CatchHigh; 728 // int32_t NumCatches; 729 // HandlerType *HandlerArray; 730 // }; 731 if (TryBlockMapXData) { 732 OS.EmitLabel(TryBlockMapXData); 733 SmallVector<MCSymbol *, 1> HandlerMaps; 734 for (size_t I = 0, E = FuncInfo.TryBlockMap.size(); I != E; ++I) { 735 const WinEHTryBlockMapEntry &TBME = FuncInfo.TryBlockMap[I]; 736 737 MCSymbol *HandlerMapXData = nullptr; 738 if (!TBME.HandlerArray.empty()) 739 HandlerMapXData = 740 Asm->OutContext.getOrCreateSymbol(Twine("$handlerMap$") 741 .concat(Twine(I)) 742 .concat("$") 743 .concat(FuncLinkageName)); 744 HandlerMaps.push_back(HandlerMapXData); 745 746 // TBMEs should form intervals. 747 assert(0 <= TBME.TryLow && "bad trymap interval"); 748 assert(TBME.TryLow <= TBME.TryHigh && "bad trymap interval"); 749 assert(TBME.TryHigh < TBME.CatchHigh && "bad trymap interval"); 750 assert(TBME.CatchHigh < int(FuncInfo.CxxUnwindMap.size()) && 751 "bad trymap interval"); 752 753 AddComment("TryLow"); 754 OS.EmitIntValue(TBME.TryLow, 4); 755 756 AddComment("TryHigh"); 757 OS.EmitIntValue(TBME.TryHigh, 4); 758 759 AddComment("CatchHigh"); 760 OS.EmitIntValue(TBME.CatchHigh, 4); 761 762 AddComment("NumCatches"); 763 OS.EmitIntValue(TBME.HandlerArray.size(), 4); 764 765 AddComment("HandlerArray"); 766 OS.EmitValue(create32bitRef(HandlerMapXData), 4); 767 } 768 769 // All funclets use the same parent frame offset currently. 770 unsigned ParentFrameOffset = 0; 771 if (shouldEmitPersonality) { 772 const TargetFrameLowering *TFI = MF->getSubtarget().getFrameLowering(); 773 ParentFrameOffset = TFI->getWinEHParentFrameOffset(*MF); 774 } 775 776 for (size_t I = 0, E = FuncInfo.TryBlockMap.size(); I != E; ++I) { 777 const WinEHTryBlockMapEntry &TBME = FuncInfo.TryBlockMap[I]; 778 MCSymbol *HandlerMapXData = HandlerMaps[I]; 779 if (!HandlerMapXData) 780 continue; 781 // HandlerType { 782 // int32_t Adjectives; 783 // TypeDescriptor *Type; 784 // int32_t CatchObjOffset; 785 // void (*Handler)(); 786 // int32_t ParentFrameOffset; // x64 only 787 // }; 788 OS.EmitLabel(HandlerMapXData); 789 for (const WinEHHandlerType &HT : TBME.HandlerArray) { 790 // Get the frame escape label with the offset of the catch object. If 791 // the index is INT_MAX, then there is no catch object, and we should 792 // emit an offset of zero, indicating that no copy will occur. 793 const MCExpr *FrameAllocOffsetRef = nullptr; 794 if (HT.CatchObj.FrameIndex != INT_MAX) { 795 int Offset = getFrameIndexOffset(HT.CatchObj.FrameIndex, FuncInfo); 796 FrameAllocOffsetRef = MCConstantExpr::create(Offset, Asm->OutContext); 797 } else { 798 FrameAllocOffsetRef = MCConstantExpr::create(0, Asm->OutContext); 799 } 800 801 MCSymbol *HandlerSym = 802 getMCSymbolForMBB(Asm, HT.Handler.dyn_cast<MachineBasicBlock *>()); 803 804 AddComment("Adjectives"); 805 OS.EmitIntValue(HT.Adjectives, 4); 806 807 AddComment("Type"); 808 OS.EmitValue(create32bitRef(HT.TypeDescriptor), 4); 809 810 AddComment("CatchObjOffset"); 811 OS.EmitValue(FrameAllocOffsetRef, 4); 812 813 AddComment("Handler"); 814 OS.EmitValue(create32bitRef(HandlerSym), 4); 815 816 if (shouldEmitPersonality) { 817 AddComment("ParentFrameOffset"); 818 OS.EmitIntValue(ParentFrameOffset, 4); 819 } 820 } 821 } 822 } 823 824 // IPToStateMapEntry { 825 // void *IP; 826 // int32_t State; 827 // }; 828 if (IPToStateXData) { 829 OS.EmitLabel(IPToStateXData); 830 for (auto &IPStatePair : IPToStateTable) { 831 AddComment("IP"); 832 OS.EmitValue(IPStatePair.first, 4); 833 AddComment("ToState"); 834 OS.EmitIntValue(IPStatePair.second, 4); 835 } 836 } 837} 838 839void WinException::computeIP2StateTable( 840 const MachineFunction *MF, const WinEHFuncInfo &FuncInfo, 841 SmallVectorImpl<std::pair<const MCExpr *, int>> &IPToStateTable) { 842 843 for (MachineFunction::const_iterator FuncletStart = MF->begin(), 844 FuncletEnd = MF->begin(), 845 End = MF->end(); 846 FuncletStart != End; FuncletStart = FuncletEnd) { 847 // Find the end of the funclet 848 while (++FuncletEnd != End) { 849 if (FuncletEnd->isEHFuncletEntry()) { 850 break; 851 } 852 } 853 854 // Don't emit ip2state entries for cleanup funclets. Any interesting 855 // exceptional actions in cleanups must be handled in a separate IR 856 // function. 857 if (FuncletStart->isCleanupFuncletEntry()) 858 continue; 859 860 MCSymbol *StartLabel; 861 int BaseState; 862 if (FuncletStart == MF->begin()) { 863 BaseState = NullState; 864 StartLabel = Asm->getFunctionBegin(); 865 } else { 866 auto *FuncletPad = 867 cast<FuncletPadInst>(FuncletStart->getBasicBlock()->getFirstNonPHI()); 868 assert(FuncInfo.FuncletBaseStateMap.count(FuncletPad) != 0); 869 BaseState = FuncInfo.FuncletBaseStateMap.find(FuncletPad)->second; 870 StartLabel = getMCSymbolForMBB(Asm, &*FuncletStart); 871 } 872 assert(StartLabel && "need local function start label"); 873 IPToStateTable.push_back( 874 std::make_pair(create32bitRef(StartLabel), BaseState)); 875 876 for (const auto &StateChange : InvokeStateChangeIterator::range( 877 FuncInfo, FuncletStart, FuncletEnd, BaseState)) { 878 // Compute the label to report as the start of this entry; use the EH 879 // start label for the invoke if we have one, otherwise (this is a call 880 // which may unwind to our caller and does not have an EH start label, so) 881 // use the previous end label. 882 const MCSymbol *ChangeLabel = StateChange.NewStartLabel; 883 if (!ChangeLabel) 884 ChangeLabel = StateChange.PreviousEndLabel; 885 // Emit an entry indicating that PCs after 'Label' have this EH state. 886 IPToStateTable.push_back( 887 std::make_pair(getLabelPlusOne(ChangeLabel), StateChange.NewState)); 888 // FIXME: assert that NewState is between CatchLow and CatchHigh. 889 } 890 } 891} 892 893void WinException::emitEHRegistrationOffsetLabel(const WinEHFuncInfo &FuncInfo, 894 StringRef FLinkageName) { 895 // Outlined helpers called by the EH runtime need to know the offset of the EH 896 // registration in order to recover the parent frame pointer. Now that we know 897 // we've code generated the parent, we can emit the label assignment that 898 // those helpers use to get the offset of the registration node. 899 MCContext &Ctx = Asm->OutContext; 900 MCSymbol *ParentFrameOffset = 901 Ctx.getOrCreateParentFrameOffsetSymbol(FLinkageName); 902 unsigned UnusedReg; 903 const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering(); 904 int64_t Offset = TFI->getFrameIndexReference( 905 *Asm->MF, FuncInfo.EHRegNodeFrameIndex, UnusedReg); 906 const MCExpr *MCOffset = MCConstantExpr::create(Offset, Ctx); 907 Asm->OutStreamer->EmitAssignment(ParentFrameOffset, MCOffset); 908} 909 910/// Emit the language-specific data that _except_handler3 and 4 expect. This is 911/// functionally equivalent to the __C_specific_handler table, except it is 912/// indexed by state number instead of IP. 913void WinException::emitExceptHandlerTable(const MachineFunction *MF) { 914 MCStreamer &OS = *Asm->OutStreamer; 915 const Function *F = MF->getFunction(); 916 StringRef FLinkageName = GlobalValue::getRealLinkageName(F->getName()); 917 918 bool VerboseAsm = OS.isVerboseAsm(); 919 auto AddComment = [&](const Twine &Comment) { 920 if (VerboseAsm) 921 OS.AddComment(Comment); 922 }; 923 924 const WinEHFuncInfo &FuncInfo = *MF->getWinEHFuncInfo(); 925 emitEHRegistrationOffsetLabel(FuncInfo, FLinkageName); 926 927 // Emit the __ehtable label that we use for llvm.x86.seh.lsda. 928 MCSymbol *LSDALabel = Asm->OutContext.getOrCreateLSDASymbol(FLinkageName); 929 OS.EmitValueToAlignment(4); 930 OS.EmitLabel(LSDALabel); 931 932 const Function *Per = 933 dyn_cast<Function>(F->getPersonalityFn()->stripPointerCasts()); 934 StringRef PerName = Per->getName(); 935 int BaseState = -1; 936 if (PerName == "_except_handler4") { 937 // The LSDA for _except_handler4 starts with this struct, followed by the 938 // scope table: 939 // 940 // struct EH4ScopeTable { 941 // int32_t GSCookieOffset; 942 // int32_t GSCookieXOROffset; 943 // int32_t EHCookieOffset; 944 // int32_t EHCookieXOROffset; 945 // ScopeTableEntry ScopeRecord[]; 946 // }; 947 // 948 // Only the EHCookieOffset field appears to vary, and it appears to be the 949 // offset from the final saved SP value to the retaddr. 950 AddComment("GSCookieOffset"); 951 OS.EmitIntValue(-2, 4); 952 AddComment("GSCookieXOROffset"); 953 OS.EmitIntValue(0, 4); 954 // FIXME: Calculate. 955 AddComment("EHCookieOffset"); 956 OS.EmitIntValue(9999, 4); 957 AddComment("EHCookieXOROffset"); 958 OS.EmitIntValue(0, 4); 959 BaseState = -2; 960 } 961 962 assert(!FuncInfo.SEHUnwindMap.empty()); 963 for (const SEHUnwindMapEntry &UME : FuncInfo.SEHUnwindMap) { 964 auto *Handler = UME.Handler.get<MachineBasicBlock *>(); 965 const MCSymbol *ExceptOrFinally = 966 UME.IsFinally ? getMCSymbolForMBB(Asm, Handler) : Handler->getSymbol(); 967 // -1 is usually the base state for "unwind to caller", but for 968 // _except_handler4 it's -2. Do that replacement here if necessary. 969 int ToState = UME.ToState == -1 ? BaseState : UME.ToState; 970 AddComment("ToState"); 971 OS.EmitIntValue(ToState, 4); 972 AddComment(UME.IsFinally ? "Null" : "FilterFunction"); 973 OS.EmitValue(create32bitRef(UME.Filter), 4); 974 AddComment(UME.IsFinally ? "FinallyFunclet" : "ExceptionHandler"); 975 OS.EmitValue(create32bitRef(ExceptOrFinally), 4); 976 } 977} 978 979static int getTryRank(const WinEHFuncInfo &FuncInfo, int State) { 980 int Rank = 0; 981 while (State != -1) { 982 ++Rank; 983 State = FuncInfo.ClrEHUnwindMap[State].TryParentState; 984 } 985 return Rank; 986} 987 988static int getTryAncestor(const WinEHFuncInfo &FuncInfo, int Left, int Right) { 989 int LeftRank = getTryRank(FuncInfo, Left); 990 int RightRank = getTryRank(FuncInfo, Right); 991 992 while (LeftRank < RightRank) { 993 Right = FuncInfo.ClrEHUnwindMap[Right].TryParentState; 994 --RightRank; 995 } 996 997 while (RightRank < LeftRank) { 998 Left = FuncInfo.ClrEHUnwindMap[Left].TryParentState; 999 --LeftRank; 1000 } 1001 1002 while (Left != Right) { 1003 Left = FuncInfo.ClrEHUnwindMap[Left].TryParentState; 1004 Right = FuncInfo.ClrEHUnwindMap[Right].TryParentState; 1005 } 1006 1007 return Left; 1008} 1009 1010void WinException::emitCLRExceptionTable(const MachineFunction *MF) { 1011 // CLR EH "states" are really just IDs that identify handlers/funclets; 1012 // states, handlers, and funclets all have 1:1 mappings between them, and a 1013 // handler/funclet's "state" is its index in the ClrEHUnwindMap. 1014 MCStreamer &OS = *Asm->OutStreamer; 1015 const WinEHFuncInfo &FuncInfo = *MF->getWinEHFuncInfo(); 1016 MCSymbol *FuncBeginSym = Asm->getFunctionBegin(); 1017 MCSymbol *FuncEndSym = Asm->getFunctionEnd(); 1018 1019 // A ClrClause describes a protected region. 1020 struct ClrClause { 1021 const MCSymbol *StartLabel; // Start of protected region 1022 const MCSymbol *EndLabel; // End of protected region 1023 int State; // Index of handler protecting the protected region 1024 int EnclosingState; // Index of funclet enclosing the protected region 1025 }; 1026 SmallVector<ClrClause, 8> Clauses; 1027 1028 // Build a map from handler MBBs to their corresponding states (i.e. their 1029 // indices in the ClrEHUnwindMap). 1030 int NumStates = FuncInfo.ClrEHUnwindMap.size(); 1031 assert(NumStates > 0 && "Don't need exception table!"); 1032 DenseMap<const MachineBasicBlock *, int> HandlerStates; 1033 for (int State = 0; State < NumStates; ++State) { 1034 MachineBasicBlock *HandlerBlock = 1035 FuncInfo.ClrEHUnwindMap[State].Handler.get<MachineBasicBlock *>(); 1036 HandlerStates[HandlerBlock] = State; 1037 // Use this loop through all handlers to verify our assumption (used in 1038 // the MinEnclosingState computation) that enclosing funclets have lower 1039 // state numbers than their enclosed funclets. 1040 assert(FuncInfo.ClrEHUnwindMap[State].HandlerParentState < State && 1041 "ill-formed state numbering"); 1042 } 1043 // Map the main function to the NullState. 1044 HandlerStates[&MF->front()] = NullState; 1045 1046 // Write out a sentinel indicating the end of the standard (Windows) xdata 1047 // and the start of the additional (CLR) info. 1048 OS.EmitIntValue(0xffffffff, 4); 1049 // Write out the number of funclets 1050 OS.EmitIntValue(NumStates, 4); 1051 1052 // Walk the machine blocks/instrs, computing and emitting a few things: 1053 // 1. Emit a list of the offsets to each handler entry, in lexical order. 1054 // 2. Compute a map (EndSymbolMap) from each funclet to the symbol at its end. 1055 // 3. Compute the list of ClrClauses, in the required order (inner before 1056 // outer, earlier before later; the order by which a forward scan with 1057 // early termination will find the innermost enclosing clause covering 1058 // a given address). 1059 // 4. A map (MinClauseMap) from each handler index to the index of the 1060 // outermost funclet/function which contains a try clause targeting the 1061 // key handler. This will be used to determine IsDuplicate-ness when 1062 // emitting ClrClauses. The NullState value is used to indicate that the 1063 // top-level function contains a try clause targeting the key handler. 1064 // HandlerStack is a stack of (PendingStartLabel, PendingState) pairs for 1065 // try regions we entered before entering the PendingState try but which 1066 // we haven't yet exited. 1067 SmallVector<std::pair<const MCSymbol *, int>, 4> HandlerStack; 1068 // EndSymbolMap and MinClauseMap are maps described above. 1069 std::unique_ptr<MCSymbol *[]> EndSymbolMap(new MCSymbol *[NumStates]); 1070 SmallVector<int, 4> MinClauseMap((size_t)NumStates, NumStates); 1071 1072 // Visit the root function and each funclet. 1073 for (MachineFunction::const_iterator FuncletStart = MF->begin(), 1074 FuncletEnd = MF->begin(), 1075 End = MF->end(); 1076 FuncletStart != End; FuncletStart = FuncletEnd) { 1077 int FuncletState = HandlerStates[&*FuncletStart]; 1078 // Find the end of the funclet 1079 MCSymbol *EndSymbol = FuncEndSym; 1080 while (++FuncletEnd != End) { 1081 if (FuncletEnd->isEHFuncletEntry()) { 1082 EndSymbol = getMCSymbolForMBB(Asm, &*FuncletEnd); 1083 break; 1084 } 1085 } 1086 // Emit the function/funclet end and, if this is a funclet (and not the 1087 // root function), record it in the EndSymbolMap. 1088 OS.EmitValue(getOffset(EndSymbol, FuncBeginSym), 4); 1089 if (FuncletState != NullState) { 1090 // Record the end of the handler. 1091 EndSymbolMap[FuncletState] = EndSymbol; 1092 } 1093 1094 // Walk the state changes in this function/funclet and compute its clauses. 1095 // Funclets always start in the null state. 1096 const MCSymbol *CurrentStartLabel = nullptr; 1097 int CurrentState = NullState; 1098 assert(HandlerStack.empty()); 1099 for (const auto &StateChange : 1100 InvokeStateChangeIterator::range(FuncInfo, FuncletStart, FuncletEnd)) { 1101 // Close any try regions we're not still under 1102 int StillPendingState = 1103 getTryAncestor(FuncInfo, CurrentState, StateChange.NewState); 1104 while (CurrentState != StillPendingState) { 1105 assert(CurrentState != NullState && 1106 "Failed to find still-pending state!"); 1107 // Close the pending clause 1108 Clauses.push_back({CurrentStartLabel, StateChange.PreviousEndLabel, 1109 CurrentState, FuncletState}); 1110 // Now the next-outer try region is current 1111 CurrentState = FuncInfo.ClrEHUnwindMap[CurrentState].TryParentState; 1112 // Pop the new start label from the handler stack if we've exited all 1113 // inner try regions of the corresponding try region. 1114 if (HandlerStack.back().second == CurrentState) 1115 CurrentStartLabel = HandlerStack.pop_back_val().first; 1116 } 1117 1118 if (StateChange.NewState != CurrentState) { 1119 // For each clause we're starting, update the MinClauseMap so we can 1120 // know which is the topmost funclet containing a clause targeting 1121 // it. 1122 for (int EnteredState = StateChange.NewState; 1123 EnteredState != CurrentState; 1124 EnteredState = 1125 FuncInfo.ClrEHUnwindMap[EnteredState].TryParentState) { 1126 int &MinEnclosingState = MinClauseMap[EnteredState]; 1127 if (FuncletState < MinEnclosingState) 1128 MinEnclosingState = FuncletState; 1129 } 1130 // Save the previous current start/label on the stack and update to 1131 // the newly-current start/state. 1132 HandlerStack.emplace_back(CurrentStartLabel, CurrentState); 1133 CurrentStartLabel = StateChange.NewStartLabel; 1134 CurrentState = StateChange.NewState; 1135 } 1136 } 1137 assert(HandlerStack.empty()); 1138 } 1139 1140 // Now emit the clause info, starting with the number of clauses. 1141 OS.EmitIntValue(Clauses.size(), 4); 1142 for (ClrClause &Clause : Clauses) { 1143 // Emit a CORINFO_EH_CLAUSE : 1144 /* 1145 struct CORINFO_EH_CLAUSE 1146 { 1147 CORINFO_EH_CLAUSE_FLAGS Flags; // actually a CorExceptionFlag 1148 DWORD TryOffset; 1149 DWORD TryLength; // actually TryEndOffset 1150 DWORD HandlerOffset; 1151 DWORD HandlerLength; // actually HandlerEndOffset 1152 union 1153 { 1154 DWORD ClassToken; // use for catch clauses 1155 DWORD FilterOffset; // use for filter clauses 1156 }; 1157 }; 1158 1159 enum CORINFO_EH_CLAUSE_FLAGS 1160 { 1161 CORINFO_EH_CLAUSE_NONE = 0, 1162 CORINFO_EH_CLAUSE_FILTER = 0x0001, // This clause is for a filter 1163 CORINFO_EH_CLAUSE_FINALLY = 0x0002, // This clause is a finally clause 1164 CORINFO_EH_CLAUSE_FAULT = 0x0004, // This clause is a fault clause 1165 }; 1166 typedef enum CorExceptionFlag 1167 { 1168 COR_ILEXCEPTION_CLAUSE_NONE, 1169 COR_ILEXCEPTION_CLAUSE_FILTER = 0x0001, // This is a filter clause 1170 COR_ILEXCEPTION_CLAUSE_FINALLY = 0x0002, // This is a finally clause 1171 COR_ILEXCEPTION_CLAUSE_FAULT = 0x0004, // This is a fault clause 1172 COR_ILEXCEPTION_CLAUSE_DUPLICATED = 0x0008, // duplicated clause. This 1173 // clause was duplicated 1174 // to a funclet which was 1175 // pulled out of line 1176 } CorExceptionFlag; 1177 */ 1178 // Add 1 to the start/end of the EH clause; the IP associated with a 1179 // call when the runtime does its scan is the IP of the next instruction 1180 // (the one to which control will return after the call), so we need 1181 // to add 1 to the end of the clause to cover that offset. We also add 1182 // 1 to the start of the clause to make sure that the ranges reported 1183 // for all clauses are disjoint. Note that we'll need some additional 1184 // logic when machine traps are supported, since in that case the IP 1185 // that the runtime uses is the offset of the faulting instruction 1186 // itself; if such an instruction immediately follows a call but the 1187 // two belong to different clauses, we'll need to insert a nop between 1188 // them so the runtime can distinguish the point to which the call will 1189 // return from the point at which the fault occurs. 1190 1191 const MCExpr *ClauseBegin = 1192 getOffsetPlusOne(Clause.StartLabel, FuncBeginSym); 1193 const MCExpr *ClauseEnd = getOffsetPlusOne(Clause.EndLabel, FuncBeginSym); 1194 1195 const ClrEHUnwindMapEntry &Entry = FuncInfo.ClrEHUnwindMap[Clause.State]; 1196 MachineBasicBlock *HandlerBlock = Entry.Handler.get<MachineBasicBlock *>(); 1197 MCSymbol *BeginSym = getMCSymbolForMBB(Asm, HandlerBlock); 1198 const MCExpr *HandlerBegin = getOffset(BeginSym, FuncBeginSym); 1199 MCSymbol *EndSym = EndSymbolMap[Clause.State]; 1200 const MCExpr *HandlerEnd = getOffset(EndSym, FuncBeginSym); 1201 1202 uint32_t Flags = 0; 1203 switch (Entry.HandlerType) { 1204 case ClrHandlerType::Catch: 1205 // Leaving bits 0-2 clear indicates catch. 1206 break; 1207 case ClrHandlerType::Filter: 1208 Flags |= 1; 1209 break; 1210 case ClrHandlerType::Finally: 1211 Flags |= 2; 1212 break; 1213 case ClrHandlerType::Fault: 1214 Flags |= 4; 1215 break; 1216 } 1217 if (Clause.EnclosingState != MinClauseMap[Clause.State]) { 1218 // This is a "duplicate" clause; the handler needs to be entered from a 1219 // frame above the one holding the invoke. 1220 assert(Clause.EnclosingState > MinClauseMap[Clause.State]); 1221 Flags |= 8; 1222 } 1223 OS.EmitIntValue(Flags, 4); 1224 1225 // Write the clause start/end 1226 OS.EmitValue(ClauseBegin, 4); 1227 OS.EmitValue(ClauseEnd, 4); 1228 1229 // Write out the handler start/end 1230 OS.EmitValue(HandlerBegin, 4); 1231 OS.EmitValue(HandlerEnd, 4); 1232 1233 // Write out the type token or filter offset 1234 assert(Entry.HandlerType != ClrHandlerType::Filter && "NYI: filters"); 1235 OS.EmitIntValue(Entry.TypeToken, 4); 1236 } 1237} 1238