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