lib/CodeGen/AsmPrinter/DwarfException.h

   1 //===-- DwarfException.h - Dwarf Exception Framework -----------*- C++ -*--===//
   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 dwarf exception info into asm files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
  15 #define LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
  16
  17 #include "llvm/ADT/DenseMap.h"
  18 #include "llvm/CodeGen/AsmPrinter.h"
  19 #include <vector>
  20
  21 namespace llvm {
  22
  23 template <typename T> class SmallVectorImpl;
  24 struct LandingPadInfo;
  25 class MachineModuleInfo;
  26 class MachineMove;
  27 class MachineInstr;
  28 class MachineFunction;
  29 class MCAsmInfo;
  30 class MCExpr;
  31 class MCSymbol;
  32 class Function;
  33 class AsmPrinter;
  34
  35 //===----------------------------------------------------------------------===//
  36 /// DwarfException - Emits Dwarf exception handling directives.
  37 ///
  38 class DwarfException {
  39 protected:
  40   /// Asm - Target of Dwarf emission.
  41   AsmPrinter *Asm;
  42
  43   /// MMI - Collected machine module information.
  44   MachineModuleInfo *MMI;
  45
  46   /// EmitExceptionTable - Emit landing pads and actions.
  47   ///
  48   /// The general organization of the table is complex, but the basic concepts
  49   /// are easy.  First there is a header which describes the location and
  50   /// organization of the three components that follow.
  51   ///  1. The landing pad site information describes the range of code covered
  52   ///     by the try.  In our case it's an accumulation of the ranges covered
  53   ///     by the invokes in the try.  There is also a reference to the landing
  54   ///     pad that handles the exception once processed.  Finally an index into
  55   ///     the actions table.
  56   ///  2. The action table, in our case, is composed of pairs of type ids
  57   ///     and next action offset.  Starting with the action index from the
  58   ///     landing pad site, each type Id is checked for a match to the current
  59   ///     exception.  If it matches then the exception and type id are passed
  60   ///     on to the landing pad.  Otherwise the next action is looked up.  This
  61   ///     chain is terminated with a next action of zero.  If no type id is
  62   ///     found the frame is unwound and handling continues.
  63   ///  3. Type id table contains references to all the C++ typeinfo for all
  64   ///     catches in the function.  This tables is reversed indexed base 1.
  65
  66   /// SharedTypeIds - How many leading type ids two landing pads have in common.
  67   static unsigned SharedTypeIds(const LandingPadInfo *L,
  68                                 const LandingPadInfo *R);
  69
  70   /// PadLT - Order landing pads lexicographically by type id.
  71   static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R);
  72
  73   /// PadRange - Structure holding a try-range and the associated landing pad.
  74   struct PadRange {
  75     // The index of the landing pad.
  76     unsigned PadIndex;
  77     // The index of the begin and end labels in the landing pad's label lists.
  78     unsigned RangeIndex;
  79   };
  80
  81   typedef DenseMap<MCSymbol *, PadRange> RangeMapType;
  82
  83   /// ActionEntry - Structure describing an entry in the actions table.
  84   struct ActionEntry {
  85     int ValueForTypeID; // The value to write - may not be equal to the type id.
  86     int NextAction;
  87     unsigned Previous;
  88   };
  89
  90   /// CallSiteEntry - Structure describing an entry in the call-site table.
  91   struct CallSiteEntry {
  92     // The 'try-range' is BeginLabel .. EndLabel.
  93     MCSymbol *BeginLabel; // zero indicates the start of the function.
  94     MCSymbol *EndLabel;   // zero indicates the end of the function.
  95
  96     // The landing pad starts at PadLabel.
  97     MCSymbol *PadLabel;   // zero indicates that there is no landing pad.
  98     unsigned Action;
  99   };
 100
 101   /// ComputeActionsTable - Compute the actions table and gather the first
 102   /// action index for each landing pad site.
 103   unsigned ComputeActionsTable(const SmallVectorImpl<const LandingPadInfo*>&LPs,
 104                                SmallVectorImpl<ActionEntry> &Actions,
 105                                SmallVectorImpl<unsigned> &FirstActions);
 106
 107   /// CallToNoUnwindFunction - Return `true' if this is a call to a function
 108   /// marked `nounwind'. Return `false' otherwise.
 109   bool CallToNoUnwindFunction(const MachineInstr *MI);
 110
 111   /// ComputeCallSiteTable - Compute the call-site table.  The entry for an
 112   /// invoke has a try-range containing the call, a non-zero landing pad and an
 113   /// appropriate action.  The entry for an ordinary call has a try-range
 114   /// containing the call and zero for the landing pad and the action.  Calls
 115   /// marked 'nounwind' have no entry and must not be contained in the try-range
 116   /// of any entry - they form gaps in the table.  Entries must be ordered by
 117   /// try-range address.
 118   void ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
 119                             const RangeMapType &PadMap,
 120                             const SmallVectorImpl<const LandingPadInfo *> &LPs,
 121                             const SmallVectorImpl<unsigned> &FirstActions);
 122   void EmitExceptionTable();
 123
 124 public:
 125   //===--------------------------------------------------------------------===//
 126   // Main entry points.
 127   //
 128   DwarfException(AsmPrinter *A);
 129   virtual ~DwarfException();
 130
 131   /// EndModule - Emit all exception information that should come after the
 132   /// content.
 133   virtual void EndModule();
 134
 135   /// BeginFunction - Gather pre-function exception information.  Assumes being
 136   /// emitted immediately after the function entry point.
 137   virtual void BeginFunction(const MachineFunction *MF);
 138
 139   /// EndFunction - Gather and emit post-function exception information.
 140   virtual void EndFunction();
 141 };
 142
 143 class DwarfCFIException : public DwarfException {
 144   /// shouldEmitPersonality - Per-function flag to indicate if .cfi_personality
 145   /// should be emitted.
 146   bool shouldEmitPersonality;
 147
 148   /// shouldEmitLSDA - Per-function flag to indicate if .cfi_lsda
 149   /// should be emitted.
 150   bool shouldEmitLSDA;
 151
 152   /// shouldEmitMoves - Per-function flag to indicate if frame moves info
 153   /// should be emitted.
 154   bool shouldEmitMoves;
 155
 156   AsmPrinter::CFIMoveType moveTypeModule;
 157
 158 public:
 159   //===--------------------------------------------------------------------===//
 160   // Main entry points.
 161   //
 162   DwarfCFIException(AsmPrinter *A);
 163   virtual ~DwarfCFIException();
 164
 165   /// EndModule - Emit all exception information that should come after the
 166   /// content.
 167   virtual void EndModule();
 168
 169   /// BeginFunction - Gather pre-function exception information.  Assumes being
 170   /// emitted immediately after the function entry point.
 171   virtual void BeginFunction(const MachineFunction *MF);
 172
 173   /// EndFunction - Gather and emit post-function exception information.
 174   virtual void EndFunction();
 175 };
 176
 177 class ARMException : public DwarfException {
 178   /// shouldEmitTable - Per-function flag to indicate if EH tables should
 179   /// be emitted.
 180   bool shouldEmitTable;
 181
 182   /// shouldEmitMoves - Per-function flag to indicate if frame moves info
 183   /// should be emitted.
 184   bool shouldEmitMoves;
 185
 186   /// shouldEmitTableModule - Per-module flag to indicate if EH tables
 187   /// should be emitted.
 188   bool shouldEmitTableModule;
 189 public:
 190   //===--------------------------------------------------------------------===//
 191   // Main entry points.
 192   //
 193   ARMException(AsmPrinter *A);
 194   virtual ~ARMException();
 195
 196   /// EndModule - Emit all exception information that should come after the
 197   /// content.
 198   virtual void EndModule();
 199
 200   /// BeginFunction - Gather pre-function exception information.  Assumes being
 201   /// emitted immediately after the function entry point.
 202   virtual void BeginFunction(const MachineFunction *MF);
 203
 204   /// EndFunction - Gather and emit post-function exception information.
 205   virtual void EndFunction();
 206 };
 207
 208 class Win64Exception : public DwarfException {
 209   /// shouldEmitPersonality - Per-function flag to indicate if personality
 210   /// info should be emitted.
 211   bool shouldEmitPersonality;
 212
 213   /// shouldEmitLSDA - Per-function flag to indicate if the LSDA
 214   /// should be emitted.
 215   bool shouldEmitLSDA;
 216
 217   /// shouldEmitMoves - Per-function flag to indicate if frame moves info
 218   /// should be emitted.
 219   bool shouldEmitMoves;
 220
 221 public:
 222   //===--------------------------------------------------------------------===//
 223   // Main entry points.
 224   //
 225   Win64Exception(AsmPrinter *A);
 226   virtual ~Win64Exception();
 227
 228   /// EndModule - Emit all exception information that should come after the
 229   /// content.
 230   virtual void EndModule();
 231
 232   /// BeginFunction - Gather pre-function exception information.  Assumes being
 233   /// emitted immediately after the function entry point.
 234   virtual void BeginFunction(const MachineFunction *MF);
 235
 236   /// EndFunction - Gather and emit post-function exception information.
 237   virtual void EndFunction();
 238 };
 239
 240 } // End of namespace llvm
 241
 242 #endif