MachineModuleInfo.h revision 11d53c129fc9c2a4510605ec0a1696f58750af52
1//===-- llvm/CodeGen/MachineModuleInfo.h ------------------------*- 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// Collect meta information for a module. This information should be in a 11// neutral form that can be used by different debugging and exception handling 12// schemes. 13// 14// The organization of information is primarily clustered around the source 15// compile units. The main exception is source line correspondence where 16// inlining may interleave code from various compile units. 17// 18// The following information can be retrieved from the MachineModuleInfo. 19// 20// -- Source directories - Directories are uniqued based on their canonical 21// string and assigned a sequential numeric ID (base 1.) 22// -- Source files - Files are also uniqued based on their name and directory 23// ID. A file ID is sequential number (base 1.) 24// -- Source line correspondence - A vector of file ID, line#, column# triples. 25// A DEBUG_LOCATION instruction is generated by the DAG Legalizer 26// corresponding to each entry in the source line list. This allows a debug 27// emitter to generate labels referenced by debug information tables. 28// 29//===----------------------------------------------------------------------===// 30 31#ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H 32#define LLVM_CODEGEN_MACHINEMODULEINFO_H 33 34#include "llvm/Pass.h" 35#include "llvm/GlobalValue.h" 36#include "llvm/Metadata.h" 37#include "llvm/CodeGen/MachineLocation.h" 38#include "llvm/MC/MCContext.h" 39#include "llvm/Support/Dwarf.h" 40#include "llvm/Support/ValueHandle.h" 41#include "llvm/System/DataTypes.h" 42#include "llvm/ADT/DenseMap.h" 43#include "llvm/ADT/PointerIntPair.h" 44#include "llvm/ADT/SmallPtrSet.h" 45#include "llvm/ADT/SmallVector.h" 46 47namespace llvm { 48 49//===----------------------------------------------------------------------===// 50// Forward declarations. 51class Constant; 52class GlobalVariable; 53class MDNode; 54class MachineBasicBlock; 55class MachineFunction; 56class Module; 57class PointerType; 58class StructType; 59 60/// MachineModuleInfoImpl - This class can be derived from and used by targets 61/// to hold private target-specific information for each Module. Objects of 62/// type are accessed/created with MMI::getInfo and destroyed when the 63/// MachineModuleInfo is destroyed. 64class MachineModuleInfoImpl { 65public: 66 typedef PointerIntPair<MCSymbol*, 1, bool> StubValueTy; 67 virtual ~MachineModuleInfoImpl(); 68 typedef std::vector<std::pair<MCSymbol*, StubValueTy> > SymbolListTy; 69protected: 70 static SymbolListTy GetSortedStubs(const DenseMap<MCSymbol*, StubValueTy>&); 71}; 72 73 74 75//===----------------------------------------------------------------------===// 76/// LandingPadInfo - This structure is used to retain landing pad info for 77/// the current function. 78/// 79struct LandingPadInfo { 80 MachineBasicBlock *LandingPadBlock; // Landing pad block. 81 SmallVector<unsigned, 1> BeginLabels; // Labels prior to invoke. 82 SmallVector<unsigned, 1> EndLabels; // Labels after invoke. 83 unsigned LandingPadLabel; // Label at beginning of landing pad. 84 Function *Personality; // Personality function. 85 std::vector<int> TypeIds; // List of type ids (filters negative) 86 87 explicit LandingPadInfo(MachineBasicBlock *MBB) 88 : LandingPadBlock(MBB) 89 , LandingPadLabel(0) 90 , Personality(NULL) 91 {} 92}; 93 94//===----------------------------------------------------------------------===// 95/// MachineModuleInfo - This class contains meta information specific to a 96/// module. Queries can be made by different debugging and exception handling 97/// schemes and reformated for specific use. 98/// 99class MachineModuleInfo : public ImmutablePass { 100 /// Context - This is the MCContext used for the entire code generator. 101 MCContext Context; 102 103 /// ObjFileMMI - This is the object-file-format-specific implementation of 104 /// MachineModuleInfoImpl, which lets targets accumulate whatever info they 105 /// want. 106 MachineModuleInfoImpl *ObjFileMMI; 107 108 // LabelIDList - One entry per assigned label. Normally the entry is equal to 109 // the list index(+1). If the entry is zero then the label has been deleted. 110 // Any other value indicates the label has been deleted by is mapped to 111 // another label. 112 std::vector<unsigned> LabelIDList; 113 114 // FrameMoves - List of moves done by a function's prolog. Used to construct 115 // frame maps by debug and exception handling consumers. 116 std::vector<MachineMove> FrameMoves; 117 118 // LandingPads - List of LandingPadInfo describing the landing pad information 119 // in the current function. 120 std::vector<LandingPadInfo> LandingPads; 121 122 // Map of invoke call site index values to associated begin EH_LABEL for 123 // the current function. 124 DenseMap<unsigned, unsigned> CallSiteMap; 125 126 // The current call site index being processed, if any. 0 if none. 127 unsigned CurCallSite; 128 129 // TypeInfos - List of C++ TypeInfo used in the current function. 130 // 131 std::vector<GlobalVariable *> TypeInfos; 132 133 // FilterIds - List of typeids encoding filters used in the current function. 134 // 135 std::vector<unsigned> FilterIds; 136 137 // FilterEnds - List of the indices in FilterIds corresponding to filter 138 // terminators. 139 // 140 std::vector<unsigned> FilterEnds; 141 142 // Personalities - Vector of all personality functions ever seen. Used to emit 143 // common EH frames. 144 std::vector<Function *> Personalities; 145 146 /// UsedFunctions - The functions in the @llvm.used list in a more easily 147 /// searchable format. This does not include the functions in 148 /// llvm.compiler.used. 149 SmallPtrSet<const Function *, 32> UsedFunctions; 150 151 bool CallsEHReturn; 152 bool CallsUnwindInit; 153 154 /// DbgInfoAvailable - True if debugging information is available 155 /// in this module. 156 bool DbgInfoAvailable; 157 158public: 159 static char ID; // Pass identification, replacement for typeid 160 161 typedef std::pair<unsigned, TrackingVH<MDNode> > UnsignedAndMDNodePair; 162 typedef SmallVector< std::pair<TrackingVH<MDNode>, UnsignedAndMDNodePair>, 4> 163 VariableDbgInfoMapTy; 164 VariableDbgInfoMapTy VariableDbgInfo; 165 166 MachineModuleInfo(); // DUMMY CONSTRUCTOR, DO NOT CALL. 167 MachineModuleInfo(const MCAsmInfo &MAI); // Real constructor. 168 ~MachineModuleInfo(); 169 170 bool doInitialization(); 171 bool doFinalization(); 172 173 /// EndFunction - Discard function meta information. 174 /// 175 void EndFunction(); 176 177 const MCContext &getContext() const { return Context; } 178 MCContext &getContext() { return Context; } 179 180 /// getInfo - Keep track of various per-function pieces of information for 181 /// backends that would like to do so. 182 /// 183 template<typename Ty> 184 Ty &getObjFileInfo() { 185 if (ObjFileMMI == 0) 186 ObjFileMMI = new Ty(*this); 187 return *static_cast<Ty*>(ObjFileMMI); 188 } 189 190 template<typename Ty> 191 const Ty &getObjFileInfo() const { 192 return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>(); 193 } 194 195 /// AnalyzeModule - Scan the module for global debug information. 196 /// 197 void AnalyzeModule(Module &M); 198 199 /// hasDebugInfo - Returns true if valid debug info is present. 200 /// 201 bool hasDebugInfo() const { return DbgInfoAvailable; } 202 void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = true; } 203 204 bool callsEHReturn() const { return CallsEHReturn; } 205 void setCallsEHReturn(bool b) { CallsEHReturn = b; } 206 207 bool callsUnwindInit() const { return CallsUnwindInit; } 208 void setCallsUnwindInit(bool b) { CallsUnwindInit = b; } 209 210 /// NextLabelID - Return the next unique label id. 211 /// 212 unsigned NextLabelID() { 213 unsigned ID = (unsigned)LabelIDList.size() + 1; 214 LabelIDList.push_back(ID); 215 return ID; 216 } 217 218 /// InvalidateLabel - Inhibit use of the specified label # from 219 /// MachineModuleInfo, for example because the code was deleted. 220 void InvalidateLabel(unsigned LabelID) { 221 // Remap to zero to indicate deletion. 222 assert(0 < LabelID && LabelID <= LabelIDList.size() && 223 "Old label ID out of range."); 224 LabelIDList[LabelID - 1] = 0; 225 } 226 227 /// isLabelDeleted - Return true if the label was deleted. 228 /// FIXME: This should eventually be eliminated and use the 'is emitted' bit 229 /// on MCSymbol. 230 bool isLabelDeleted(unsigned LabelID) const { 231 assert(LabelID <= LabelIDList.size() && "Debug label ID out of range."); 232 return LabelID == 0 || LabelIDList[LabelID - 1] == 0; 233 } 234 235 /// getFrameMoves - Returns a reference to a list of moves done in the current 236 /// function's prologue. Used to construct frame maps for debug and exception 237 /// handling comsumers. 238 std::vector<MachineMove> &getFrameMoves() { return FrameMoves; } 239 240 //===-EH-----------------------------------------------------------------===// 241 242 /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the 243 /// specified MachineBasicBlock. 244 LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad); 245 246 /// addInvoke - Provide the begin and end labels of an invoke style call and 247 /// associate it with a try landing pad block. 248 void addInvoke(MachineBasicBlock *LandingPad, unsigned BeginLabel, 249 unsigned EndLabel); 250 251 /// addLandingPad - Add a new panding pad. Returns the label ID for the 252 /// landing pad entry. 253 unsigned addLandingPad(MachineBasicBlock *LandingPad); 254 255 /// addPersonality - Provide the personality function for the exception 256 /// information. 257 void addPersonality(MachineBasicBlock *LandingPad, Function *Personality); 258 259 /// getPersonalityIndex - Get index of the current personality function inside 260 /// Personalitites array 261 unsigned getPersonalityIndex() const; 262 263 /// getPersonalities - Return array of personality functions ever seen. 264 const std::vector<Function *>& getPersonalities() const { 265 return Personalities; 266 } 267 268 /// isUsedFunction - Return true if the functions in the llvm.used list. This 269 /// does not return true for things in llvm.compiler.used unless they are also 270 /// in llvm.used. 271 bool isUsedFunction(const Function *F) { 272 return UsedFunctions.count(F); 273 } 274 275 /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad. 276 /// 277 void addCatchTypeInfo(MachineBasicBlock *LandingPad, 278 std::vector<GlobalVariable *> &TyInfo); 279 280 /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad. 281 /// 282 void addFilterTypeInfo(MachineBasicBlock *LandingPad, 283 std::vector<GlobalVariable *> &TyInfo); 284 285 /// addCleanup - Add a cleanup action for a landing pad. 286 /// 287 void addCleanup(MachineBasicBlock *LandingPad); 288 289 /// getTypeIDFor - Return the type id for the specified typeinfo. This is 290 /// function wide. 291 unsigned getTypeIDFor(GlobalVariable *TI); 292 293 /// getFilterIDFor - Return the id of the filter encoded by TyIds. This is 294 /// function wide. 295 int getFilterIDFor(std::vector<unsigned> &TyIds); 296 297 /// TidyLandingPads - Remap landing pad labels and remove any deleted landing 298 /// pads. 299 void TidyLandingPads(); 300 301 /// getLandingPads - Return a reference to the landing pad info for the 302 /// current function. 303 const std::vector<LandingPadInfo> &getLandingPads() const { 304 return LandingPads; 305 } 306 307 /// setCallSiteBeginLabel - Map the begin label for a call site 308 void setCallSiteBeginLabel(unsigned BeginLabel, unsigned Site) { 309 CallSiteMap[BeginLabel] = Site; 310 } 311 312 /// getCallSiteBeginLabel - Get the call site number for a begin label 313 unsigned getCallSiteBeginLabel(unsigned BeginLabel) { 314 assert(CallSiteMap.count(BeginLabel) && 315 "Missing call site number for EH_LABEL!"); 316 return CallSiteMap[BeginLabel]; 317 } 318 319 /// setCurrentCallSite - Set the call site currently being processed. 320 void setCurrentCallSite(unsigned Site) { CurCallSite = Site; } 321 322 /// getCurrentCallSite - Get the call site currently being processed, if any. 323 /// return zero if none. 324 unsigned getCurrentCallSite(void) { return CurCallSite; } 325 326 /// getTypeInfos - Return a reference to the C++ typeinfo for the current 327 /// function. 328 const std::vector<GlobalVariable *> &getTypeInfos() const { 329 return TypeInfos; 330 } 331 332 /// getFilterIds - Return a reference to the typeids encoding filters used in 333 /// the current function. 334 const std::vector<unsigned> &getFilterIds() const { 335 return FilterIds; 336 } 337 338 /// getPersonality - Return a personality function if available. The presence 339 /// of one is required to emit exception handling info. 340 Function *getPersonality() const; 341 342 /// setVariableDbgInfo - Collect information used to emit debugging information 343 /// of a variable. 344 void setVariableDbgInfo(MDNode *N, unsigned Slot, MDNode *Scope) { 345 VariableDbgInfo.push_back(std::make_pair(N, std::make_pair(Slot, Scope))); 346 } 347 348 VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfo; } 349 350}; // End class MachineModuleInfo 351 352} // End llvm namespace 353 354#endif 355