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