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 21namespace llvm { 22 23template <typename T> class SmallVectorImpl; 24struct LandingPadInfo; 25class MachineModuleInfo; 26class MachineMove; 27class MachineInstr; 28class MachineFunction; 29class MCAsmInfo; 30class MCExpr; 31class MCSymbol; 32class Function; 33class AsmPrinter; 34 35//===----------------------------------------------------------------------===// 36/// DwarfException - Emits Dwarf exception handling directives. 37/// 38class DwarfException { 39protected: 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 124public: 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 143class 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 158public: 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 177class 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; 189public: 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 208class 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 221public: 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 243