DwarfException.h revision e99c6d49ea0f6f3b562af85580bdf18bd278b933
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 "DIE.h" 18#include "DwarfPrinter.h" 19#include "llvm/CodeGen/AsmPrinter.h" 20#include "llvm/ADT/DenseMap.h" 21#include <string> 22 23namespace llvm { 24 25struct LandingPadInfo; 26class MachineModuleInfo; 27class MCAsmInfo; 28class Timer; 29class raw_ostream; 30 31//===----------------------------------------------------------------------===// 32/// DwarfException - Emits Dwarf exception handling directives. 33/// 34class VISIBILITY_HIDDEN DwarfException : public Dwarf { 35 struct FunctionEHFrameInfo { 36 std::string FnName; 37 unsigned Number; 38 unsigned PersonalityIndex; 39 bool hasCalls; 40 bool hasLandingPads; 41 std::vector<MachineMove> Moves; 42 const Function * function; 43 44 FunctionEHFrameInfo(const std::string &FN, unsigned Num, unsigned P, 45 bool hC, bool hL, 46 const std::vector<MachineMove> &M, 47 const Function *f): 48 FnName(FN), Number(Num), PersonalityIndex(P), 49 hasCalls(hC), hasLandingPads(hL), Moves(M), function (f) { } 50 }; 51 52 std::vector<FunctionEHFrameInfo> EHFrames; 53 54 /// UsesLSDA - Indicates whether an FDE that uses the CIE at the given index 55 /// uses an LSDA. If so, then we need to encode that information in the CIE's 56 /// augmentation. 57 DenseMap<unsigned, bool> UsesLSDA; 58 59 /// shouldEmitTable - Per-function flag to indicate if EH tables should 60 /// be emitted. 61 bool shouldEmitTable; 62 63 /// shouldEmitMoves - Per-function flag to indicate if frame moves info 64 /// should be emitted. 65 bool shouldEmitMoves; 66 67 /// shouldEmitTableModule - Per-module flag to indicate if EH tables 68 /// should be emitted. 69 bool shouldEmitTableModule; 70 71 /// shouldEmitFrameModule - Per-module flag to indicate if frame moves 72 /// should be emitted. 73 bool shouldEmitMovesModule; 74 75 /// ExceptionTimer - Timer for the Dwarf exception writer. 76 Timer *ExceptionTimer; 77 78 unsigned SizeOfEncodedValue(unsigned Encoding); 79 80 /// EmitCIE - Emit a Common Information Entry (CIE). This holds information 81 /// that is shared among many Frame Description Entries. There is at least 82 /// one CIE in every non-empty .debug_frame section. 83 void EmitCIE(const Function *Personality, unsigned Index); 84 85 /// EmitFDE - Emit the Frame Description Entry (FDE) for the function. 86 void EmitFDE(const FunctionEHFrameInfo &EHFrameInfo); 87 88 /// EmitExceptionTable - Emit landing pads and actions. 89 /// 90 /// The general organization of the table is complex, but the basic concepts 91 /// are easy. First there is a header which describes the location and 92 /// organization of the three components that follow. 93 /// 1. The landing pad site information describes the range of code covered 94 /// by the try. In our case it's an accumulation of the ranges covered 95 /// by the invokes in the try. There is also a reference to the landing 96 /// pad that handles the exception once processed. Finally an index into 97 /// the actions table. 98 /// 2. The action table, in our case, is composed of pairs of type ids 99 /// and next action offset. Starting with the action index from the 100 /// landing pad site, each type Id is checked for a match to the current 101 /// exception. If it matches then the exception and type id are passed 102 /// on to the landing pad. Otherwise the next action is looked up. This 103 /// chain is terminated with a next action of zero. If no type id is 104 /// found the the frame is unwound and handling continues. 105 /// 3. Type id table contains references to all the C++ typeinfo for all 106 /// catches in the function. This tables is reversed indexed base 1. 107 108 /// SharedTypeIds - How many leading type ids two landing pads have in common. 109 static unsigned SharedTypeIds(const LandingPadInfo *L, 110 const LandingPadInfo *R); 111 112 /// PadLT - Order landing pads lexicographically by type id. 113 static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R); 114 115 struct KeyInfo { 116 static inline unsigned getEmptyKey() { return -1U; } 117 static inline unsigned getTombstoneKey() { return -2U; } 118 static unsigned getHashValue(const unsigned &Key) { return Key; } 119 static bool isEqual(unsigned LHS, unsigned RHS) { return LHS == RHS; } 120 static bool isPod() { return true; } 121 }; 122 123 /// PadRange - Structure holding a try-range and the associated landing pad. 124 struct PadRange { 125 // The index of the landing pad. 126 unsigned PadIndex; 127 // The index of the begin and end labels in the landing pad's label lists. 128 unsigned RangeIndex; 129 }; 130 131 typedef DenseMap<unsigned, PadRange, KeyInfo> RangeMapType; 132 133 /// ActionEntry - Structure describing an entry in the actions table. 134 struct ActionEntry { 135 int ValueForTypeID; // The value to write - may not be equal to the type id. 136 int NextAction; 137 struct ActionEntry *Previous; 138 }; 139 140 /// CallSiteEntry - Structure describing an entry in the call-site table. 141 struct CallSiteEntry { 142 // The 'try-range' is BeginLabel .. EndLabel. 143 unsigned BeginLabel; // zero indicates the start of the function. 144 unsigned EndLabel; // zero indicates the end of the function. 145 146 // The landing pad starts at PadLabel. 147 unsigned PadLabel; // zero indicates that there is no landing pad. 148 unsigned Action; 149 }; 150 151 /// ComputeActionsTable - Compute the actions table and gather the first 152 /// action index for each landing pad site. 153 unsigned ComputeActionsTable(const SmallVectorImpl<const LandingPadInfo*>&LPs, 154 SmallVectorImpl<ActionEntry> &Actions, 155 SmallVectorImpl<unsigned> &FirstActions); 156 157 /// ComputeCallSiteTable - Compute the call-site table. The entry for an 158 /// invoke has a try-range containing the call, a non-zero landing pad and an 159 /// appropriate action. The entry for an ordinary call has a try-range 160 /// containing the call and zero for the landing pad and the action. Calls 161 /// marked 'nounwind' have no entry and must not be contained in the try-range 162 /// of any entry - they form gaps in the table. Entries must be ordered by 163 /// try-range address. 164 void ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites, 165 const RangeMapType &PadMap, 166 const SmallVectorImpl<const LandingPadInfo *> &LPs, 167 const SmallVectorImpl<unsigned> &FirstActions); 168 void EmitExceptionTable(); 169 170public: 171 //===--------------------------------------------------------------------===// 172 // Main entry points. 173 // 174 DwarfException(raw_ostream &OS, AsmPrinter *A, const MCAsmInfo *T); 175 virtual ~DwarfException(); 176 177 /// BeginModule - Emit all exception information that should come prior to the 178 /// content. 179 void BeginModule(Module *m, MachineModuleInfo *mmi) { 180 this->M = m; 181 this->MMI = mmi; 182 } 183 184 /// EndModule - Emit all exception information that should come after the 185 /// content. 186 void EndModule(); 187 188 /// BeginFunction - Gather pre-function exception information. Assumes being 189 /// emitted immediately after the function entry point. 190 void BeginFunction(MachineFunction *MF); 191 192 /// EndFunction - Gather and emit post-function exception information. 193 void EndFunction(); 194}; 195 196} // End of namespace llvm 197 198#endif 199