lib/CodeGen/AsmPrinter/Win64Exception.cpp

   1 //===-- CodeGen/AsmPrinter/Win64Exception.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 "Win64Exception.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/Support/Dwarf.h"
  33 #include "llvm/Support/ErrorHandling.h"
  34 #include "llvm/Support/FormattedStream.h"
  35 #include "llvm/Target/TargetFrameLowering.h"
  36 #include "llvm/Target/TargetLoweringObjectFile.h"
  37 #include "llvm/Target/TargetOptions.h"
  38 #include "llvm/Target/TargetRegisterInfo.h"
  39 using namespace llvm;
  40
  41 Win64Exception::Win64Exception(AsmPrinter *A)
  42   : EHStreamer(A), shouldEmitPersonality(false), shouldEmitLSDA(false),
  43     shouldEmitMoves(false) {}
  44
  45 Win64Exception::~Win64Exception() {}
  46
  47 /// endModule - Emit all exception information that should come after the
  48 /// content.
  49 void Win64Exception::endModule() {
  50 }
  51
  52 void Win64Exception::beginFunction(const MachineFunction *MF) {
  53   shouldEmitMoves = shouldEmitPersonality = shouldEmitLSDA = false;
  54
  55   // If any landing pads survive, we need an EH table.
  56   bool hasLandingPads = !MMI->getLandingPads().empty();
  57
  58   shouldEmitMoves = Asm->needsSEHMoves();
  59
  60   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
  61   unsigned PerEncoding = TLOF.getPersonalityEncoding();
  62   const Function *Per = MF->getMMI().getPersonality();
  63
  64   shouldEmitPersonality = hasLandingPads &&
  65     PerEncoding != dwarf::DW_EH_PE_omit && Per;
  66
  67   unsigned LSDAEncoding = TLOF.getLSDAEncoding();
  68   shouldEmitLSDA = shouldEmitPersonality &&
  69     LSDAEncoding != dwarf::DW_EH_PE_omit;
  70
  71
  72   // If this was an outlined handler, we need to define the label corresponding
  73   // to the offset of the parent frame relative to the stack pointer after the
  74   // prologue.
  75   const Function *F = MF->getFunction();
  76   const Function *ParentF = MMI->getWinEHParent(F);
  77   if (F != ParentF) {
  78     WinEHFuncInfo &FuncInfo = MMI->getWinEHFuncInfo(ParentF);
  79     auto I = FuncInfo.CatchHandlerParentFrameObjOffset.find(F);
  80     if (I != FuncInfo.CatchHandlerParentFrameObjOffset.end()) {
  81       MCSymbol *HandlerTypeParentFrameOffset =
  82           Asm->OutContext.getOrCreateParentFrameOffsetSymbol(
  83               GlobalValue::getRealLinkageName(F->getName()));
  84
  85       // Emit a symbol assignment.
  86       Asm->OutStreamer.EmitAssignment(
  87           HandlerTypeParentFrameOffset,
  88           MCConstantExpr::Create(I->second, Asm->OutContext));
  89     }
  90   }
  91
  92   if (!shouldEmitPersonality && !shouldEmitMoves)
  93     return;
  94
  95   Asm->OutStreamer.EmitWinCFIStartProc(Asm->CurrentFnSym);
  96
  97   if (!shouldEmitPersonality)
  98     return;
  99
 100   const MCSymbol *PersHandlerSym =
 101       TLOF.getCFIPersonalitySymbol(Per, *Asm->Mang, Asm->TM, MMI);
 102   Asm->OutStreamer.EmitWinEHHandler(PersHandlerSym, true, true);
 103 }
 104
 105 /// endFunction - Gather and emit post-function exception information.
 106 ///
 107 void Win64Exception::endFunction(const MachineFunction *MF) {
 108   if (!shouldEmitPersonality && !shouldEmitMoves)
 109     return;
 110
 111   // Map all labels and get rid of any dead landing pads.
 112   MMI->TidyLandingPads();
 113
 114   if (shouldEmitPersonality) {
 115     Asm->OutStreamer.PushSection();
 116
 117     // Emit an UNWIND_INFO struct describing the prologue.
 118     Asm->OutStreamer.EmitWinEHHandlerData();
 119
 120     // Emit the tables appropriate to the personality function in use. If we
 121     // don't recognize the personality, assume it uses an Itanium-style LSDA.
 122     EHPersonality Per = MMI->getPersonalityType();
 123     if (Per == EHPersonality::MSVC_Win64SEH)
 124       emitCSpecificHandlerTable();
 125     else if (Per == EHPersonality::MSVC_CXX)
 126       emitCXXFrameHandler3Table(MF);
 127     else
 128       emitExceptionTable();
 129
 130     Asm->OutStreamer.PopSection();
 131   }
 132   Asm->OutStreamer.EmitWinCFIEndProc();
 133 }
 134
 135 const MCExpr *Win64Exception::createImageRel32(const MCSymbol *Value) {
 136   if (!Value)
 137     return MCConstantExpr::Create(0, Asm->OutContext);
 138   return MCSymbolRefExpr::Create(Value, MCSymbolRefExpr::VK_COFF_IMGREL32,
 139                                  Asm->OutContext);
 140 }
 141
 142 const MCExpr *Win64Exception::createImageRel32(const GlobalValue *GV) {
 143   if (!GV)
 144     return MCConstantExpr::Create(0, Asm->OutContext);
 145   return createImageRel32(Asm->getSymbol(GV));
 146 }
 147
 148 /// Emit the language-specific data that __C_specific_handler expects.  This
 149 /// handler lives in the x64 Microsoft C runtime and allows catching or cleaning
 150 /// up after faults with __try, __except, and __finally.  The typeinfo values
 151 /// are not really RTTI data, but pointers to filter functions that return an
 152 /// integer (1, 0, or -1) indicating how to handle the exception. For __finally
 153 /// blocks and other cleanups, the landing pad label is zero, and the filter
 154 /// function is actually a cleanup handler with the same prototype.  A catch-all
 155 /// entry is modeled with a null filter function field and a non-zero landing
 156 /// pad label.
 157 ///
 158 /// Possible filter function return values:
 159 ///   EXCEPTION_EXECUTE_HANDLER (1):
 160 ///     Jump to the landing pad label after cleanups.
 161 ///   EXCEPTION_CONTINUE_SEARCH (0):
 162 ///     Continue searching this table or continue unwinding.
 163 ///   EXCEPTION_CONTINUE_EXECUTION (-1):
 164 ///     Resume execution at the trapping PC.
 165 ///
 166 /// Inferred table structure:
 167 ///   struct Table {
 168 ///     int NumEntries;
 169 ///     struct Entry {
 170 ///       imagerel32 LabelStart;
 171 ///       imagerel32 LabelEnd;
 172 ///       imagerel32 FilterOrFinally;  // One means catch-all.
 173 ///       imagerel32 LabelLPad;        // Zero means __finally.
 174 ///     } Entries[NumEntries];
 175 ///   };
 176 void Win64Exception::emitCSpecificHandlerTable() {
 177   const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
 178
 179   // Simplifying assumptions for first implementation:
 180   // - Cleanups are not implemented.
 181   // - Filters are not implemented.
 182
 183   // The Itanium LSDA table sorts similar landing pads together to simplify the
 184   // actions table, but we don't need that.
 185   SmallVector<const LandingPadInfo *, 64> LandingPads;
 186   LandingPads.reserve(PadInfos.size());
 187   for (const auto &LP : PadInfos)
 188     LandingPads.push_back(&LP);
 189
 190   // Compute label ranges for call sites as we would for the Itanium LSDA, but
 191   // use an all zero action table because we aren't using these actions.
 192   SmallVector<unsigned, 64> FirstActions;
 193   FirstActions.resize(LandingPads.size());
 194   SmallVector<CallSiteEntry, 64> CallSites;
 195   computeCallSiteTable(CallSites, LandingPads, FirstActions);
 196
 197   MCSymbol *EHFuncBeginSym = Asm->getFunctionBegin();
 198   MCSymbol *EHFuncEndSym = Asm->getFunctionEnd();
 199
 200   // Emit the number of table entries.
 201   unsigned NumEntries = 0;
 202   for (const CallSiteEntry &CSE : CallSites) {
 203     if (!CSE.LPad)
 204       continue; // Ignore gaps.
 205     for (int Selector : CSE.LPad->TypeIds) {
 206       // Ignore C++ filter clauses in SEH.
 207       // FIXME: Implement cleanup clauses.
 208       if (isCatchEHSelector(Selector))
 209         ++NumEntries;
 210     }
 211   }
 212   Asm->OutStreamer.EmitIntValue(NumEntries, 4);
 213
 214   // Emit the four-label records for each call site entry. The table has to be
 215   // sorted in layout order, and the call sites should already be sorted.
 216   for (const CallSiteEntry &CSE : CallSites) {
 217     // Ignore gaps. Unlike the Itanium model, unwinding through a frame without
 218     // an EH table entry will propagate the exception rather than terminating
 219     // the program.
 220     if (!CSE.LPad)
 221       continue;
 222     const LandingPadInfo *LPad = CSE.LPad;
 223
 224     // Compute the label range. We may reuse the function begin and end labels
 225     // rather than forming new ones.
 226     const MCExpr *Begin =
 227         createImageRel32(CSE.BeginLabel ? CSE.BeginLabel : EHFuncBeginSym);
 228     const MCExpr *End;
 229     if (CSE.EndLabel) {
 230       // The interval is half-open, so we have to add one to include the return
 231       // address of the last invoke in the range.
 232       End = MCBinaryExpr::CreateAdd(createImageRel32(CSE.EndLabel),
 233                                     MCConstantExpr::Create(1, Asm->OutContext),
 234                                     Asm->OutContext);
 235     } else {
 236       End = createImageRel32(EHFuncEndSym);
 237     }
 238
 239     // These aren't really type info globals, they are actually pointers to
 240     // filter functions ordered by selector. The zero selector is used for
 241     // cleanups, so slot zero corresponds to selector 1.
 242     const std::vector<const GlobalValue *> &SelectorToFilter = MMI->getTypeInfos();
 243
 244     // Do a parallel iteration across typeids and clause labels, skipping filter
 245     // clauses.
 246     size_t NextClauseLabel = 0;
 247     for (size_t I = 0, E = LPad->TypeIds.size(); I < E; ++I) {
 248       // AddLandingPadInfo stores the clauses in reverse, but there is a FIXME
 249       // to change that.
 250       int Selector = LPad->TypeIds[E - I - 1];
 251
 252       // Ignore C++ filter clauses in SEH.
 253       // FIXME: Implement cleanup clauses.
 254       if (!isCatchEHSelector(Selector))
 255         continue;
 256
 257       Asm->OutStreamer.EmitValue(Begin, 4);
 258       Asm->OutStreamer.EmitValue(End, 4);
 259       if (isCatchEHSelector(Selector)) {
 260         assert(unsigned(Selector - 1) < SelectorToFilter.size());
 261         const GlobalValue *TI = SelectorToFilter[Selector - 1];
 262         if (TI) // Emit the filter function pointer.
 263           Asm->OutStreamer.EmitValue(createImageRel32(Asm->getSymbol(TI)), 4);
 264         else  // Otherwise, this is a "catch i8* null", or catch all.
 265           Asm->OutStreamer.EmitIntValue(1, 4);
 266       }
 267       MCSymbol *ClauseLabel = LPad->ClauseLabels[NextClauseLabel++];
 268       Asm->OutStreamer.EmitValue(createImageRel32(ClauseLabel), 4);
 269     }
 270   }
 271 }
 272
 273 void Win64Exception::emitCXXFrameHandler3Table(const MachineFunction *MF) {
 274   const Function *F = MF->getFunction();
 275   const Function *ParentF = MMI->getWinEHParent(F);
 276   auto &OS = Asm->OutStreamer;
 277   WinEHFuncInfo &FuncInfo = MMI->getWinEHFuncInfo(ParentF);
 278
 279   StringRef ParentLinkageName =
 280       GlobalValue::getRealLinkageName(ParentF->getName());
 281
 282   MCSymbol *FuncInfoXData =
 283       Asm->OutContext.GetOrCreateSymbol(Twine("$cppxdata$", ParentLinkageName));
 284   OS.EmitValue(createImageRel32(FuncInfoXData), 4);
 285
 286   // The Itanium LSDA table sorts similar landing pads together to simplify the
 287   // actions table, but we don't need that.
 288   SmallVector<const LandingPadInfo *, 64> LandingPads;
 289   const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
 290   LandingPads.reserve(PadInfos.size());
 291   for (const auto &LP : PadInfos)
 292     LandingPads.push_back(&LP);
 293
 294   RangeMapType PadMap;
 295   computePadMap(LandingPads, PadMap);
 296
 297   // The end label of the previous invoke or nounwind try-range.
 298   MCSymbol *LastLabel = Asm->getFunctionBegin();
 299
 300   // Whether there is a potentially throwing instruction (currently this means
 301   // an ordinary call) between the end of the previous try-range and now.
 302   bool SawPotentiallyThrowing = false;
 303
 304   int LastEHState = -2;
 305
 306   // The parent function and the catch handlers contribute to the 'ip2state'
 307   // table.
 308   for (const auto &MBB : *MF) {
 309     for (const auto &MI : MBB) {
 310       if (!MI.isEHLabel()) {
 311         if (MI.isCall())
 312           SawPotentiallyThrowing |= !callToNoUnwindFunction(&MI);
 313         continue;
 314       }
 315
 316       // End of the previous try-range?
 317       MCSymbol *BeginLabel = MI.getOperand(0).getMCSymbol();
 318       if (BeginLabel == LastLabel)
 319         SawPotentiallyThrowing = false;
 320
 321       // Beginning of a new try-range?
 322       RangeMapType::const_iterator L = PadMap.find(BeginLabel);
 323       if (L == PadMap.end())
 324         // Nope, it was just some random label.
 325         continue;
 326
 327       const PadRange &P = L->second;
 328       const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
 329       assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
 330              "Inconsistent landing pad map!");
 331
 332       if (SawPotentiallyThrowing) {
 333         FuncInfo.IPToStateList.push_back(std::make_pair(LastLabel, -1));
 334         SawPotentiallyThrowing = false;
 335         LastEHState = -1;
 336       }
 337
 338       if (LandingPad->WinEHState != LastEHState)
 339         FuncInfo.IPToStateList.push_back(
 340             std::make_pair(BeginLabel, LandingPad->WinEHState));
 341       LastEHState = LandingPad->WinEHState;
 342       LastLabel = LandingPad->EndLabels[P.RangeIndex];
 343     }
 344   }
 345
 346   // Defer emission until we've visited the parent function and all the catch
 347   // handlers.
 348   if (ParentF == F || FuncInfo.CatchHandlerMaxState.count(F))
 349     ++FuncInfo.NumIPToStateFuncsVisited;
 350   if (FuncInfo.NumIPToStateFuncsVisited != FuncInfo.CatchHandlerMaxState.size())
 351     return;
 352
 353   MCSymbol *UnwindMapXData = nullptr;
 354   MCSymbol *TryBlockMapXData = nullptr;
 355   MCSymbol *IPToStateXData = nullptr;
 356   if (!FuncInfo.UnwindMap.empty())
 357     UnwindMapXData = Asm->OutContext.GetOrCreateSymbol(
 358         Twine("$stateUnwindMap$", ParentLinkageName));
 359   if (!FuncInfo.TryBlockMap.empty())
 360     TryBlockMapXData = Asm->OutContext.GetOrCreateSymbol(
 361         Twine("$tryMap$", ParentLinkageName));
 362   if (!FuncInfo.IPToStateList.empty())
 363     IPToStateXData = Asm->OutContext.GetOrCreateSymbol(
 364         Twine("$ip2state$", ParentLinkageName));
 365
 366   // FuncInfo {
 367   //   uint32_t           MagicNumber
 368   //   int32_t            MaxState;
 369   //   UnwindMapEntry    *UnwindMap;
 370   //   uint32_t           NumTryBlocks;
 371   //   TryBlockMapEntry  *TryBlockMap;
 372   //   uint32_t           IPMapEntries;
 373   //   IPToStateMapEntry *IPToStateMap;
 374   //   uint32_t           UnwindHelp; // (x64/ARM only)
 375   //   ESTypeList        *ESTypeList;
 376   //   int32_t            EHFlags;
 377   // }
 378   // EHFlags & 1 -> Synchronous exceptions only, no async exceptions.
 379   // EHFlags & 2 -> ???
 380   // EHFlags & 4 -> The function is noexcept(true), unwinding can't continue.
 381   OS.EmitLabel(FuncInfoXData);
 382   OS.EmitIntValue(0x19930522, 4);                      // MagicNumber
 383   OS.EmitIntValue(FuncInfo.UnwindMap.size(), 4);       // MaxState
 384   OS.EmitValue(createImageRel32(UnwindMapXData), 4);   // UnwindMap
 385   OS.EmitIntValue(FuncInfo.TryBlockMap.size(), 4);     // NumTryBlocks
 386   OS.EmitValue(createImageRel32(TryBlockMapXData), 4); // TryBlockMap
 387   OS.EmitIntValue(FuncInfo.IPToStateList.size(), 4);   // IPMapEntries
 388   OS.EmitValue(createImageRel32(IPToStateXData), 4);   // IPToStateMap
 389   OS.EmitIntValue(FuncInfo.UnwindHelpFrameOffset, 4);  // UnwindHelp
 390   OS.EmitIntValue(0, 4);                               // ESTypeList
 391   OS.EmitIntValue(1, 4);                               // EHFlags
 392
 393   // UnwindMapEntry {
 394   //   int32_t ToState;
 395   //   void  (*Action)();
 396   // };
 397   if (UnwindMapXData) {
 398     OS.EmitLabel(UnwindMapXData);
 399     for (const WinEHUnwindMapEntry &UME : FuncInfo.UnwindMap) {
 400       OS.EmitIntValue(UME.ToState, 4);                // ToState
 401       OS.EmitValue(createImageRel32(UME.Cleanup), 4); // Action
 402     }
 403   }
 404
 405   // TryBlockMap {
 406   //   int32_t      TryLow;
 407   //   int32_t      TryHigh;
 408   //   int32_t      CatchHigh;
 409   //   int32_t      NumCatches;
 410   //   HandlerType *HandlerArray;
 411   // };
 412   if (TryBlockMapXData) {
 413     OS.EmitLabel(TryBlockMapXData);
 414     SmallVector<MCSymbol *, 1> HandlerMaps;
 415     for (size_t I = 0, E = FuncInfo.TryBlockMap.size(); I != E; ++I) {
 416       WinEHTryBlockMapEntry &TBME = FuncInfo.TryBlockMap[I];
 417       MCSymbol *HandlerMapXData = nullptr;
 418
 419       if (!TBME.HandlerArray.empty())
 420         HandlerMapXData =
 421             Asm->OutContext.GetOrCreateSymbol(Twine("$handlerMap$")
 422                                                   .concat(Twine(I))
 423                                                   .concat("$")
 424                                                   .concat(ParentLinkageName));
 425
 426       HandlerMaps.push_back(HandlerMapXData);
 427
 428       int CatchHigh = -1;
 429       for (WinEHHandlerType &HT : TBME.HandlerArray)
 430         CatchHigh =
 431             std::max(CatchHigh, FuncInfo.CatchHandlerMaxState[HT.Handler]);
 432
 433       assert(TBME.TryLow <= TBME.TryHigh);
 434       assert(CatchHigh > TBME.TryHigh);
 435       OS.EmitIntValue(TBME.TryLow, 4);                    // TryLow
 436       OS.EmitIntValue(TBME.TryHigh, 4);                   // TryHigh
 437       OS.EmitIntValue(CatchHigh, 4);                      // CatchHigh
 438       OS.EmitIntValue(TBME.HandlerArray.size(), 4);       // NumCatches
 439       OS.EmitValue(createImageRel32(HandlerMapXData), 4); // HandlerArray
 440     }
 441
 442     for (size_t I = 0, E = FuncInfo.TryBlockMap.size(); I != E; ++I) {
 443       WinEHTryBlockMapEntry &TBME = FuncInfo.TryBlockMap[I];
 444       MCSymbol *HandlerMapXData = HandlerMaps[I];
 445       if (!HandlerMapXData)
 446         continue;
 447       // HandlerType {
 448       //   int32_t         Adjectives;
 449       //   TypeDescriptor *Type;
 450       //   int32_t         CatchObjOffset;
 451       //   void          (*Handler)();
 452       //   int32_t         ParentFrameOffset; // x64 only
 453       // };
 454       OS.EmitLabel(HandlerMapXData);
 455       for (const WinEHHandlerType &HT : TBME.HandlerArray) {
 456         MCSymbol *ParentFrameOffset =
 457             Asm->OutContext.getOrCreateParentFrameOffsetSymbol(
 458                 GlobalValue::getRealLinkageName(HT.Handler->getName()));
 459         const MCSymbolRefExpr *ParentFrameOffsetRef = MCSymbolRefExpr::Create(
 460             ParentFrameOffset, MCSymbolRefExpr::VK_None, Asm->OutContext);
 461
 462         // Get the frame escape label with the offset of the catch object. If
 463         // the index is -1, then there is no catch object, and we should emit an
 464         // offset of zero, indicating that no copy will occur.
 465         const MCExpr *FrameAllocOffsetRef = nullptr;
 466         if (HT.CatchObjRecoverIdx >= 0) {
 467           MCSymbol *FrameAllocOffset =
 468               Asm->OutContext.getOrCreateFrameAllocSymbol(
 469                   GlobalValue::getRealLinkageName(F->getName()),
 470                   HT.CatchObjRecoverIdx);
 471           FrameAllocOffsetRef = MCSymbolRefExpr::Create(
 472               FrameAllocOffset, MCSymbolRefExpr::VK_None, Asm->OutContext);
 473         } else {
 474           FrameAllocOffsetRef = MCConstantExpr::Create(0, Asm->OutContext);
 475         }
 476
 477         OS.EmitIntValue(HT.Adjectives, 4);                    // Adjectives
 478         OS.EmitValue(createImageRel32(HT.TypeDescriptor), 4); // Type
 479         OS.EmitValue(FrameAllocOffsetRef, 4);                 // CatchObjOffset
 480         OS.EmitValue(createImageRel32(HT.Handler), 4);        // Handler
 481         OS.EmitValue(ParentFrameOffsetRef, 4);                // ParentFrameOffset
 482       }
 483     }
 484   }
 485
 486   // IPToStateMapEntry {
 487   //   void   *IP;
 488   //   int32_t State;
 489   // };
 490   if (IPToStateXData) {
 491     OS.EmitLabel(IPToStateXData);
 492     for (auto &IPStatePair : FuncInfo.IPToStateList) {
 493       OS.EmitValue(createImageRel32(IPStatePair.first), 4); // IP
 494       OS.EmitIntValue(IPStatePair.second, 4);               // State
 495     }
 496   }
 497 }