1 //===-- llvm/CodeGen/DwarfCompileUnit.h - Dwarf Compile Unit ---*- 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 compile unit. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H 15 #define CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H 16 17 #include "DIE.h" 18 #include "llvm/ADT/DenseMap.h" 19 #include "llvm/ADT/OwningPtr.h" 20 #include "llvm/ADT/StringMap.h" 21 #include "llvm/DebugInfo.h" 22 23 namespace llvm { 24 25 class DwarfDebug; 26 class DwarfUnits; 27 class MachineLocation; 28 class MachineOperand; 29 class ConstantInt; 30 class ConstantFP; 31 class DbgVariable; 32 33 //===----------------------------------------------------------------------===// 34 /// CompileUnit - This dwarf writer support class manages information associated 35 /// with a source file. 36 class CompileUnit { 37 /// UniqueID - a numeric ID unique among all CUs in the module 38 /// 39 unsigned UniqueID; 40 41 /// Language - The DW_AT_language of the compile unit 42 /// 43 unsigned Language; 44 45 /// Die - Compile unit debug information entry. 46 /// 47 const OwningPtr<DIE> CUDie; 48 49 /// Asm - Target of Dwarf emission. 50 AsmPrinter *Asm; 51 52 // Holders for some common dwarf information. 53 DwarfDebug *DD; 54 DwarfUnits *DU; 55 56 /// IndexTyDie - An anonymous type for index type. Owned by CUDie. 57 DIE *IndexTyDie; 58 59 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton 60 /// variables to debug information entries. 61 DenseMap<const MDNode *, DIE *> MDNodeToDieMap; 62 63 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton 64 /// descriptors to debug information entries using a DIEEntry proxy. 65 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap; 66 67 /// GlobalNames - A map of globally visible named entities for this unit. 68 /// 69 StringMap<DIE*> GlobalNames; 70 71 /// GlobalTypes - A map of globally visible types for this unit. 72 /// 73 StringMap<DIE*> GlobalTypes; 74 75 /// AccelNames - A map of names for the name accelerator table. 76 /// 77 StringMap<std::vector<DIE*> > AccelNames; 78 StringMap<std::vector<DIE*> > AccelObjC; 79 StringMap<std::vector<DIE*> > AccelNamespace; 80 StringMap<std::vector<std::pair<DIE*, unsigned> > > AccelTypes; 81 82 /// DIEBlocks - A list of all the DIEBlocks in use. 83 std::vector<DIEBlock *> DIEBlocks; 84 85 /// ContainingTypeMap - This map is used to keep track of subprogram DIEs that 86 /// need DW_AT_containing_type attribute. This attribute points to a DIE that 87 /// corresponds to the MDNode mapped with the subprogram DIE. 88 DenseMap<DIE *, const MDNode *> ContainingTypeMap; 89 90 /// Offset of the CUDie from beginning of debug info section. 91 unsigned DebugInfoOffset; 92 93 /// getLowerBoundDefault - Return the default lower bound for an array. If the 94 /// DWARF version doesn't handle the language, return -1. 95 int64_t getDefaultLowerBound() const; 96 97 /// getOrCreateContextDIE - Get context owner's DIE. 98 DIE *getOrCreateContextDIE(DIDescriptor Context); 99 100 public: 101 CompileUnit(unsigned UID, unsigned L, DIE *D, AsmPrinter *A, DwarfDebug *DW, 102 DwarfUnits *); 103 ~CompileUnit(); 104 105 // Accessors. 106 unsigned getUniqueID() const { return UniqueID; } 107 unsigned getLanguage() const { return Language; } 108 DIE* getCUDie() const { return CUDie.get(); } 109 unsigned getDebugInfoOffset() const { return DebugInfoOffset; } 110 const StringMap<DIE*> &getGlobalNames() const { return GlobalNames; } 111 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; } 112 113 const StringMap<std::vector<DIE*> > &getAccelNames() const { 114 return AccelNames; 115 } 116 const StringMap<std::vector<DIE*> > &getAccelObjC() const { 117 return AccelObjC; 118 } 119 const StringMap<std::vector<DIE*> > &getAccelNamespace() const { 120 return AccelNamespace; 121 } 122 const StringMap<std::vector<std::pair<DIE*, unsigned > > > 123 &getAccelTypes() const { 124 return AccelTypes; 125 } 126 127 void setDebugInfoOffset(unsigned DbgInfoOff) { DebugInfoOffset = DbgInfoOff; } 128 /// hasContent - Return true if this compile unit has something to write out. 129 /// 130 bool hasContent() const { return !CUDie->getChildren().empty(); } 131 132 /// addGlobalName - Add a new global entity to the compile unit. 133 /// 134 void addGlobalName(StringRef Name, DIE *Die) { GlobalNames[Name] = Die; } 135 136 /// addGlobalType - Add a new global type to the compile unit. 137 /// 138 void addGlobalType(DIType Ty); 139 140 141 /// addAccelName - Add a new name to the name accelerator table. 142 void addAccelName(StringRef Name, DIE *Die) { 143 std::vector<DIE*> &DIEs = AccelNames[Name]; 144 DIEs.push_back(Die); 145 } 146 void addAccelObjC(StringRef Name, DIE *Die) { 147 std::vector<DIE*> &DIEs = AccelObjC[Name]; 148 DIEs.push_back(Die); 149 } 150 void addAccelNamespace(StringRef Name, DIE *Die) { 151 std::vector<DIE*> &DIEs = AccelNamespace[Name]; 152 DIEs.push_back(Die); 153 } 154 void addAccelType(StringRef Name, std::pair<DIE *, unsigned> Die) { 155 std::vector<std::pair<DIE*, unsigned > > &DIEs = AccelTypes[Name]; 156 DIEs.push_back(Die); 157 } 158 159 /// getDIE - Returns the debug information entry map slot for the 160 /// specified debug variable. 161 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); } 162 163 DIEBlock *getDIEBlock() { 164 return new (DIEValueAllocator) DIEBlock(); 165 } 166 167 /// insertDIE - Insert DIE into the map. 168 void insertDIE(const MDNode *N, DIE *D) { 169 MDNodeToDieMap.insert(std::make_pair(N, D)); 170 } 171 172 /// getDIEEntry - Returns the debug information entry for the specified 173 /// debug variable. 174 DIEEntry *getDIEEntry(const MDNode *N) { 175 DenseMap<const MDNode *, DIEEntry *>::iterator I = 176 MDNodeToDIEEntryMap.find(N); 177 if (I == MDNodeToDIEEntryMap.end()) 178 return NULL; 179 return I->second; 180 } 181 182 /// insertDIEEntry - Insert debug information entry into the map. 183 void insertDIEEntry(const MDNode *N, DIEEntry *E) { 184 MDNodeToDIEEntryMap.insert(std::make_pair(N, E)); 185 } 186 187 /// addDie - Adds or interns the DIE to the compile unit. 188 /// 189 void addDie(DIE *Buffer) { 190 this->CUDie->addChild(Buffer); 191 } 192 193 // getIndexTyDie - Get an anonymous type for index type. 194 DIE *getIndexTyDie() { 195 return IndexTyDie; 196 } 197 198 // setIndexTyDie - Set D as anonymous type for index which can be reused 199 // later. 200 void setIndexTyDie(DIE *D) { 201 IndexTyDie = D; 202 } 203 204 /// addFlag - Add a flag that is true to the DIE. 205 void addFlag(DIE *Die, unsigned Attribute); 206 207 /// addUInt - Add an unsigned integer attribute data and value. 208 /// 209 void addUInt(DIE *Die, unsigned Attribute, unsigned Form, uint64_t Integer); 210 211 /// addSInt - Add an signed integer attribute data and value. 212 /// 213 void addSInt(DIE *Die, unsigned Attribute, unsigned Form, int64_t Integer); 214 215 /// addString - Add a string attribute data and value. 216 /// 217 void addString(DIE *Die, unsigned Attribute, const StringRef Str); 218 219 /// addLocalString - Add a string attribute data and value. 220 /// 221 void addLocalString(DIE *Die, unsigned Attribute, const StringRef Str); 222 223 /// addLabel - Add a Dwarf label attribute data and value. 224 /// 225 void addLabel(DIE *Die, unsigned Attribute, unsigned Form, 226 const MCSymbol *Label); 227 228 /// addLabelAddress - Add a dwarf label attribute data and value using 229 /// either DW_FORM_addr or DW_FORM_GNU_addr_index. 230 /// 231 void addLabelAddress(DIE *Die, unsigned Attribute, MCSymbol *Label); 232 233 /// addOpAddress - Add a dwarf op address data and value using the 234 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index. 235 /// 236 void addOpAddress(DIE *Die, MCSymbol *Label); 237 238 /// addDelta - Add a label delta attribute data and value. 239 /// 240 void addDelta(DIE *Die, unsigned Attribute, unsigned Form, 241 const MCSymbol *Hi, const MCSymbol *Lo); 242 243 /// addDIEEntry - Add a DIE attribute data and value. 244 /// 245 void addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form, DIE *Entry); 246 247 /// addBlock - Add block data. 248 /// 249 void addBlock(DIE *Die, unsigned Attribute, unsigned Form, DIEBlock *Block); 250 251 /// addSourceLine - Add location information to specified debug information 252 /// entry. 253 void addSourceLine(DIE *Die, DIVariable V); 254 void addSourceLine(DIE *Die, DIGlobalVariable G); 255 void addSourceLine(DIE *Die, DISubprogram SP); 256 void addSourceLine(DIE *Die, DIType Ty); 257 void addSourceLine(DIE *Die, DINameSpace NS); 258 void addSourceLine(DIE *Die, DIObjCProperty Ty); 259 260 /// addAddress - Add an address attribute to a die based on the location 261 /// provided. 262 void addAddress(DIE *Die, unsigned Attribute, 263 const MachineLocation &Location); 264 265 /// addConstantValue - Add constant value entry in variable DIE. 266 bool addConstantValue(DIE *Die, const MachineOperand &MO, DIType Ty); 267 bool addConstantValue(DIE *Die, const ConstantInt *CI, bool Unsigned); 268 bool addConstantValue(DIE *Die, const APInt &Val, bool Unsigned); 269 270 /// addConstantFPValue - Add constant value entry in variable DIE. 271 bool addConstantFPValue(DIE *Die, const MachineOperand &MO); 272 bool addConstantFPValue(DIE *Die, const ConstantFP *CFP); 273 274 /// addTemplateParams - Add template parameters in buffer. 275 void addTemplateParams(DIE &Buffer, DIArray TParams); 276 277 /// addRegisterOp - Add register operand. 278 void addRegisterOp(DIE *TheDie, unsigned Reg); 279 280 /// addRegisterOffset - Add register offset. 281 void addRegisterOffset(DIE *TheDie, unsigned Reg, int64_t Offset); 282 283 /// addComplexAddress - Start with the address based on the location provided, 284 /// and generate the DWARF information necessary to find the actual variable 285 /// (navigating the extra location information encoded in the type) based on 286 /// the starting location. Add the DWARF information to the die. 287 /// 288 void addComplexAddress(DbgVariable *&DV, DIE *Die, unsigned Attribute, 289 const MachineLocation &Location); 290 291 // FIXME: Should be reformulated in terms of addComplexAddress. 292 /// addBlockByrefAddress - Start with the address based on the location 293 /// provided, and generate the DWARF information necessary to find the 294 /// actual Block variable (navigating the Block struct) based on the 295 /// starting location. Add the DWARF information to the die. Obsolete, 296 /// please use addComplexAddress instead. 297 /// 298 void addBlockByrefAddress(DbgVariable *&DV, DIE *Die, unsigned Attribute, 299 const MachineLocation &Location); 300 301 /// addVariableAddress - Add DW_AT_location attribute for a 302 /// DbgVariable based on provided MachineLocation. 303 void addVariableAddress(DbgVariable *&DV, DIE *Die, MachineLocation Location); 304 305 /// addToContextOwner - Add Die into the list of its context owner's children. 306 void addToContextOwner(DIE *Die, DIDescriptor Context); 307 308 /// addType - Add a new type attribute to the specified entity. This takes 309 /// and attribute parameter because DW_AT_friend attributes are also 310 /// type references. 311 void addType(DIE *Entity, DIType Ty, unsigned Attribute = dwarf::DW_AT_type); 312 313 /// getOrCreateNameSpace - Create a DIE for DINameSpace. 314 DIE *getOrCreateNameSpace(DINameSpace NS); 315 316 /// getOrCreateSubprogramDIE - Create new DIE using SP. 317 DIE *getOrCreateSubprogramDIE(DISubprogram SP); 318 319 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 320 /// given DIType. 321 DIE *getOrCreateTypeDIE(const MDNode *N); 322 323 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE 324 /// for the given DITemplateTypeParameter. 325 DIE *getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP); 326 327 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create 328 /// new DIE for the given DITemplateValueParameter. 329 DIE *getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TVP); 330 331 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 332 /// information entry. 333 DIEEntry *createDIEEntry(DIE *Entry); 334 335 /// createGlobalVariableDIE - create global variable DIE. 336 void createGlobalVariableDIE(const MDNode *N); 337 338 void addPubTypes(DISubprogram SP); 339 340 /// constructTypeDIE - Construct basic type die from DIBasicType. 341 void constructTypeDIE(DIE &Buffer, 342 DIBasicType BTy); 343 344 /// constructTypeDIE - Construct derived type die from DIDerivedType. 345 void constructTypeDIE(DIE &Buffer, 346 DIDerivedType DTy); 347 348 /// constructTypeDIE - Construct type DIE from DICompositeType. 349 void constructTypeDIE(DIE &Buffer, 350 DICompositeType CTy); 351 352 /// constructSubrangeDIE - Construct subrange DIE from DISubrange. 353 void constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy); 354 355 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 356 void constructArrayTypeDIE(DIE &Buffer, 357 DICompositeType *CTy); 358 359 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 360 DIE *constructEnumTypeDIE(DIEnumerator ETy); 361 362 /// constructContainingTypeDIEs - Construct DIEs for types that contain 363 /// vtables. 364 void constructContainingTypeDIEs(); 365 366 /// constructVariableDIE - Construct a DIE for the given DbgVariable. 367 DIE *constructVariableDIE(DbgVariable *DV, bool isScopeAbstract); 368 369 /// createMemberDIE - Create new member DIE. 370 DIE *createMemberDIE(DIDerivedType DT); 371 372 /// createStaticMemberDIE - Create new static data member DIE. 373 DIE *createStaticMemberDIE(DIDerivedType DT); 374 375 private: 376 377 // DIEValueAllocator - All DIEValues are allocated through this allocator. 378 BumpPtrAllocator DIEValueAllocator; 379 DIEInteger *DIEIntegerOne; 380 }; 381 382 } // end llvm namespace 383 #endif 384
