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