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/IR/DataLayout.h"
  23 #include "llvm/IR/Mangler.h"
  24 #include "llvm/IR/Module.h"
  25 #include "llvm/MC/MCAsmInfo.h"
  26 #include "llvm/MC/MCContext.h"
  27 #include "llvm/MC/MCExpr.h"
  28 #include "llvm/MC/MCSection.h"
  29 #include "llvm/MC/MCStreamer.h"
  30 #include "llvm/MC/MCSymbol.h"
  31 #include "llvm/Support/Dwarf.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/FormattedStream.h"
  34 #include "llvm/Target/TargetFrameLowering.h"
  35 #include "llvm/Target/TargetLoweringObjectFile.h"
  36 #include "llvm/Target/TargetOptions.h"
  37 #include "llvm/Target/TargetRegisterInfo.h"
  38 using namespace llvm;
  39
  40 Win64Exception::Win64Exception(AsmPrinter *A)
  41   : EHStreamer(A), shouldEmitPersonality(false), shouldEmitLSDA(false),
  42     shouldEmitMoves(false) {}
  43
  44 Win64Exception::~Win64Exception() {}
  45
  46 /// endModule - Emit all exception information that should come after the
  47 /// content.
  48 void Win64Exception::endModule() {
  49 }
  50
  51 /// beginFunction - Gather pre-function exception information. Assumes it's
  52 /// being emitted immediately after the function entry point.
  53 void Win64Exception::beginFunction(const MachineFunction *MF) {
  54   shouldEmitMoves = shouldEmitPersonality = shouldEmitLSDA = false;
  55
  56   // If any landing pads survive, we need an EH table.
  57   bool hasLandingPads = !MMI->getLandingPads().empty();
  58
  59   shouldEmitMoves = Asm->needsSEHMoves();
  60
  61   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
  62   unsigned PerEncoding = TLOF.getPersonalityEncoding();
  63   const Function *Per = MMI->getPersonalities()[MMI->getPersonalityIndex()];
  64
  65   shouldEmitPersonality = hasLandingPads &&
  66     PerEncoding != dwarf::DW_EH_PE_omit && Per;
  67
  68   unsigned LSDAEncoding = TLOF.getLSDAEncoding();
  69   shouldEmitLSDA = shouldEmitPersonality &&
  70     LSDAEncoding != dwarf::DW_EH_PE_omit;
  71
  72   if (!shouldEmitPersonality && !shouldEmitMoves)
  73     return;
  74
  75   Asm->OutStreamer.EmitWinCFIStartProc(Asm->CurrentFnSym);
  76
  77   if (!shouldEmitPersonality)
  78     return;
  79
  80   const MCSymbol *PersHandlerSym =
  81       TLOF.getCFIPersonalitySymbol(Per, *Asm->Mang, Asm->TM, MMI);
  82   Asm->OutStreamer.EmitWinEHHandler(PersHandlerSym, true, true);
  83
  84   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("eh_func_begin",
  85                                                 Asm->getFunctionNumber()));
  86 }
  87
  88 /// endFunction - Gather and emit post-function exception information.
  89 ///
  90 void Win64Exception::endFunction(const MachineFunction *) {
  91   if (!shouldEmitPersonality && !shouldEmitMoves)
  92     return;
  93
  94   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("eh_func_end",
  95                                                 Asm->getFunctionNumber()));
  96
  97   // Map all labels and get rid of any dead landing pads.
  98   MMI->TidyLandingPads();
  99
 100   if (shouldEmitPersonality) {
 101     Asm->OutStreamer.PushSection();
 102
 103     // Emit an UNWIND_INFO struct describing the prologue.
 104     Asm->OutStreamer.EmitWinEHHandlerData();
 105
 106     // Emit either MSVC-compatible tables or the usual Itanium-style LSDA after
 107     // the UNWIND_INFO struct.
 108     if (Asm->MAI->getExceptionHandlingType() == ExceptionHandling::MSVC) {
 109       const Function *Per = MMI->getPersonalities()[MMI->getPersonalityIndex()];
 110       if (Per->getName() == "__C_specific_handler")
 111         emitCSpecificHandlerTable();
 112       else
 113         report_fatal_error(Twine("unexpected personality function: ") +
 114                            Per->getName());
 115     } else {
 116       emitExceptionTable();
 117     }
 118
 119     Asm->OutStreamer.PopSection();
 120   }
 121   Asm->OutStreamer.EmitWinCFIEndProc();
 122 }
 123
 124 const MCSymbolRefExpr *Win64Exception::createImageRel32(const MCSymbol *Value) {
 125   return MCSymbolRefExpr::Create(Value, MCSymbolRefExpr::VK_COFF_IMGREL32,
 126                                  Asm->OutContext);
 127 }
 128
 129 /// Emit the language-specific data that __C_specific_handler expects.  This
 130 /// handler lives in the x64 Microsoft C runtime and allows catching or cleaning
 131 /// up after faults with __try, __except, and __finally.  The typeinfo values
 132 /// are not really RTTI data, but pointers to filter functions that return an
 133 /// integer (1, 0, or -1) indicating how to handle the exception. For __finally
 134 /// blocks and other cleanups, the landing pad label is zero, and the filter
 135 /// function is actually a cleanup handler with the same prototype.  A catch-all
 136 /// entry is modeled with a null filter function field and a non-zero landing
 137 /// pad label.
 138 ///
 139 /// Possible filter function return values:
 140 ///   EXCEPTION_EXECUTE_HANDLER (1):
 141 ///     Jump to the landing pad label after cleanups.
 142 ///   EXCEPTION_CONTINUE_SEARCH (0):
 143 ///     Continue searching this table or continue unwinding.
 144 ///   EXCEPTION_CONTINUE_EXECUTION (-1):
 145 ///     Resume execution at the trapping PC.
 146 ///
 147 /// Inferred table structure:
 148 ///   struct Table {
 149 ///     int NumEntries;
 150 ///     struct Entry {
 151 ///       imagerel32 LabelStart;
 152 ///       imagerel32 LabelEnd;
 153 ///       imagerel32 FilterOrFinally;  // Zero means catch-all.
 154 ///       imagerel32 LabelLPad;        // Zero means __finally.
 155 ///     } Entries[NumEntries];
 156 ///   };
 157 void Win64Exception::emitCSpecificHandlerTable() {
 158   const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
 159
 160   // Simplifying assumptions for first implementation:
 161   // - Cleanups are not implemented.
 162   // - Filters are not implemented.
 163
 164   // The Itanium LSDA table sorts similar landing pads together to simplify the
 165   // actions table, but we don't need that.
 166   SmallVector<const LandingPadInfo *, 64> LandingPads;
 167   LandingPads.reserve(PadInfos.size());
 168   for (const auto &LP : PadInfos)
 169     LandingPads.push_back(&LP);
 170
 171   // Compute label ranges for call sites as we would for the Itanium LSDA, but
 172   // use an all zero action table because we aren't using these actions.
 173   SmallVector<unsigned, 64> FirstActions;
 174   FirstActions.resize(LandingPads.size());
 175   SmallVector<CallSiteEntry, 64> CallSites;
 176   computeCallSiteTable(CallSites, LandingPads, FirstActions);
 177
 178   MCSymbol *EHFuncBeginSym =
 179       Asm->GetTempSymbol("eh_func_begin", Asm->getFunctionNumber());
 180   MCSymbol *EHFuncEndSym =
 181       Asm->GetTempSymbol("eh_func_end", Asm->getFunctionNumber());
 182
 183   // Emit the number of table entries.
 184   unsigned NumEntries = 0;
 185   for (const CallSiteEntry &CSE : CallSites) {
 186     if (!CSE.LPad)
 187       continue; // Ignore gaps.
 188     for (int Selector : CSE.LPad->TypeIds) {
 189       // Ignore C++ filter clauses in SEH.
 190       // FIXME: Implement cleanup clauses.
 191       if (isCatchEHSelector(Selector))
 192         ++NumEntries;
 193     }
 194   }
 195   Asm->OutStreamer.EmitIntValue(NumEntries, 4);
 196
 197   // Emit the four-label records for each call site entry. The table has to be
 198   // sorted in layout order, and the call sites should already be sorted.
 199   for (const CallSiteEntry &CSE : CallSites) {
 200     // Ignore gaps. Unlike the Itanium model, unwinding through a frame without
 201     // an EH table entry will propagate the exception rather than terminating
 202     // the program.
 203     if (!CSE.LPad)
 204       continue;
 205     const LandingPadInfo *LPad = CSE.LPad;
 206
 207     // Compute the label range. We may reuse the function begin and end labels
 208     // rather than forming new ones.
 209     const MCExpr *Begin =
 210         createImageRel32(CSE.BeginLabel ? CSE.BeginLabel : EHFuncBeginSym);
 211     const MCExpr *End;
 212     if (CSE.EndLabel) {
 213       // The interval is half-open, so we have to add one to include the return
 214       // address of the last invoke in the range.
 215       End = MCBinaryExpr::CreateAdd(createImageRel32(CSE.EndLabel),
 216                                     MCConstantExpr::Create(1, Asm->OutContext),
 217                                     Asm->OutContext);
 218     } else {
 219       End = createImageRel32(EHFuncEndSym);
 220     }
 221
 222     // These aren't really type info globals, they are actually pointers to
 223     // filter functions ordered by selector. The zero selector is used for
 224     // cleanups, so slot zero corresponds to selector 1.
 225     const std::vector<const GlobalValue *> &SelectorToFilter = MMI->getTypeInfos();
 226
 227     // Do a parallel iteration across typeids and clause labels, skipping filter
 228     // clauses.
 229     assert(LPad->TypeIds.size() == LPad->ClauseLabels.size());
 230     for (size_t I = 0, E = LPad->TypeIds.size(); I < E; ++I) {
 231       // AddLandingPadInfo stores the clauses in reverse, but there is a FIXME
 232       // to change that.
 233       int Selector = LPad->TypeIds[E - I - 1];
 234       MCSymbol *ClauseLabel = LPad->ClauseLabels[I];
 235
 236       // Ignore C++ filter clauses in SEH.
 237       // FIXME: Implement cleanup clauses.
 238       if (!isCatchEHSelector(Selector))
 239         continue;
 240
 241       Asm->OutStreamer.EmitValue(Begin, 4);
 242       Asm->OutStreamer.EmitValue(End, 4);
 243       if (isCatchEHSelector(Selector)) {
 244         assert(unsigned(Selector - 1) < SelectorToFilter.size());
 245         const GlobalValue *TI = SelectorToFilter[Selector - 1];
 246         if (TI) // Emit the filter function pointer.
 247           Asm->OutStreamer.EmitValue(createImageRel32(Asm->getSymbol(TI)), 4);
 248         else  // Otherwise, this is a "catch i8* null", or catch all.
 249           Asm->OutStreamer.EmitIntValue(0, 4);
 250       }
 251       Asm->OutStreamer.EmitValue(createImageRel32(ClauseLabel), 4);
 252     }
 253   }
 254 }