1 //===-- llvm/CodeGen/DwarfUnit.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 LLVM_LIB_CODEGEN_ASMPRINTER_DWARFUNIT_H 15 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFUNIT_H 16 17 #include "DwarfDebug.h" 18 #include "llvm/ADT/DenseMap.h" 19 #include "llvm/ADT/Optional.h" 20 #include "llvm/ADT/StringMap.h" 21 #include "llvm/CodeGen/AsmPrinter.h" 22 #include "llvm/CodeGen/DIE.h" 23 #include "llvm/IR/DIBuilder.h" 24 #include "llvm/IR/DebugInfo.h" 25 #include "llvm/MC/MCDwarf.h" 26 #include "llvm/MC/MCExpr.h" 27 #include "llvm/MC/MCSection.h" 28 29 namespace llvm { 30 31 class MachineLocation; 32 class MachineOperand; 33 class ConstantInt; 34 class ConstantFP; 35 class DbgVariable; 36 class DwarfCompileUnit; 37 38 // Data structure to hold a range for range lists. 39 class RangeSpan { 40 public: RangeSpan(MCSymbol * S,MCSymbol * E)41 RangeSpan(MCSymbol *S, MCSymbol *E) : Start(S), End(E) {} getStart()42 const MCSymbol *getStart() const { return Start; } getEnd()43 const MCSymbol *getEnd() const { return End; } setEnd(const MCSymbol * E)44 void setEnd(const MCSymbol *E) { End = E; } 45 46 private: 47 const MCSymbol *Start, *End; 48 }; 49 50 class RangeSpanList { 51 private: 52 // Index for locating within the debug_range section this particular span. 53 MCSymbol *RangeSym; 54 // List of ranges. 55 SmallVector<RangeSpan, 2> Ranges; 56 57 public: RangeSpanList(MCSymbol * Sym,SmallVector<RangeSpan,2> Ranges)58 RangeSpanList(MCSymbol *Sym, SmallVector<RangeSpan, 2> Ranges) 59 : RangeSym(Sym), Ranges(std::move(Ranges)) {} getSym()60 MCSymbol *getSym() const { return RangeSym; } getRanges()61 const SmallVectorImpl<RangeSpan> &getRanges() const { return Ranges; } addRange(RangeSpan Range)62 void addRange(RangeSpan Range) { Ranges.push_back(Range); } 63 }; 64 65 //===----------------------------------------------------------------------===// 66 /// Unit - This dwarf writer support class manages information associated 67 /// with a source file. 68 class DwarfUnit { 69 protected: 70 /// UniqueID - a numeric ID unique among all CUs in the module 71 unsigned UniqueID; 72 73 /// Node - MDNode for the compile unit. 74 DICompileUnit CUNode; 75 76 /// Unit debug information entry. 77 DIE UnitDie; 78 79 /// Offset of the UnitDie from beginning of debug info section. 80 unsigned DebugInfoOffset; 81 82 /// Asm - Target of Dwarf emission. 83 AsmPrinter *Asm; 84 85 // Holders for some common dwarf information. 86 DwarfDebug *DD; 87 DwarfFile *DU; 88 89 /// IndexTyDie - An anonymous type for index type. Owned by UnitDie. 90 DIE *IndexTyDie; 91 92 /// MDNodeToDieMap - Tracks the mapping of unit level debug information 93 /// variables to debug information entries. 94 DenseMap<const MDNode *, DIE *> MDNodeToDieMap; 95 96 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug information 97 /// descriptors to debug information entries using a DIEEntry proxy. 98 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap; 99 100 /// DIEBlocks - A list of all the DIEBlocks in use. 101 std::vector<DIEBlock *> DIEBlocks; 102 103 /// DIELocs - A list of all the DIELocs in use. 104 std::vector<DIELoc *> DIELocs; 105 106 /// ContainingTypeMap - This map is used to keep track of subprogram DIEs that 107 /// need DW_AT_containing_type attribute. This attribute points to a DIE that 108 /// corresponds to the MDNode mapped with the subprogram DIE. 109 DenseMap<DIE *, const MDNode *> ContainingTypeMap; 110 111 // DIEValueAllocator - All DIEValues are allocated through this allocator. 112 BumpPtrAllocator DIEValueAllocator; 113 114 // DIEIntegerOne - A preallocated DIEValue because 1 is used frequently. 115 DIEInteger *DIEIntegerOne; 116 117 /// The section this unit will be emitted in. 118 const MCSection *Section; 119 120 DwarfUnit(unsigned UID, dwarf::Tag, DICompileUnit CU, AsmPrinter *A, 121 DwarfDebug *DW, DwarfFile *DWU); 122 123 void initSection(const MCSection *Section); 124 125 /// Add a string attribute data and value. 126 void addLocalString(DIE &Die, dwarf::Attribute Attribute, StringRef Str); 127 128 void addIndexedString(DIE &Die, dwarf::Attribute Attribute, StringRef Str); 129 130 bool applySubprogramDefinitionAttributes(DISubprogram SP, DIE &SPDie); 131 132 public: 133 virtual ~DwarfUnit(); 134 getSection()135 const MCSection *getSection() const { 136 assert(Section); 137 return Section; 138 } 139 140 // Accessors. getAsmPrinter()141 AsmPrinter* getAsmPrinter() const { return Asm; } getUniqueID()142 unsigned getUniqueID() const { return UniqueID; } getLanguage()143 uint16_t getLanguage() const { return CUNode.getLanguage(); } getCUNode()144 DICompileUnit getCUNode() const { return CUNode; } getUnitDie()145 DIE &getUnitDie() { return UnitDie; } 146 getDebugInfoOffset()147 unsigned getDebugInfoOffset() const { return DebugInfoOffset; } setDebugInfoOffset(unsigned DbgInfoOff)148 void setDebugInfoOffset(unsigned DbgInfoOff) { DebugInfoOffset = DbgInfoOff; } 149 150 /// hasContent - Return true if this compile unit has something to write out. hasContent()151 bool hasContent() const { return !UnitDie.getChildren().empty(); } 152 153 /// getParentContextString - Get a string containing the language specific 154 /// context for a global name. 155 std::string getParentContextString(DIScope Context) const; 156 157 /// Add a new global name to the compile unit. addGlobalName(StringRef Name,DIE & Die,DIScope Context)158 virtual void addGlobalName(StringRef Name, DIE &Die, DIScope Context) {} 159 160 /// Add a new global type to the compile unit. addGlobalType(DIType Ty,const DIE & Die,DIScope Context)161 virtual void addGlobalType(DIType Ty, const DIE &Die, DIScope Context) {} 162 163 /// addAccelNamespace - Add a new name to the namespace accelerator table. 164 void addAccelNamespace(StringRef Name, const DIE &Die); 165 166 /// getDIE - Returns the debug information entry map slot for the 167 /// specified debug variable. We delegate the request to DwarfDebug 168 /// when the MDNode can be part of the type system, since DIEs for 169 /// the type system can be shared across CUs and the mappings are 170 /// kept in DwarfDebug. 171 DIE *getDIE(DIDescriptor D) const; 172 173 /// getDIELoc - Returns a fresh newly allocated DIELoc. getDIELoc()174 DIELoc *getDIELoc() { return new (DIEValueAllocator) DIELoc(); } 175 176 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug 177 /// when the MDNode can be part of the type system, since DIEs for 178 /// the type system can be shared across CUs and the mappings are 179 /// kept in DwarfDebug. 180 void insertDIE(DIDescriptor Desc, DIE *D); 181 182 /// addFlag - Add a flag that is true to the DIE. 183 void addFlag(DIE &Die, dwarf::Attribute Attribute); 184 185 /// addUInt - Add an unsigned integer attribute data and value. 186 void addUInt(DIE &Die, dwarf::Attribute Attribute, Optional<dwarf::Form> Form, 187 uint64_t Integer); 188 189 void addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer); 190 191 /// addSInt - Add an signed integer attribute data and value. 192 void addSInt(DIE &Die, dwarf::Attribute Attribute, Optional<dwarf::Form> Form, 193 int64_t Integer); 194 195 void addSInt(DIELoc &Die, Optional<dwarf::Form> Form, int64_t Integer); 196 197 /// addString - Add a string attribute data and value. 198 void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str); 199 200 /// addLabel - Add a Dwarf label attribute data and value. 201 void addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, 202 const MCSymbol *Label); 203 204 void addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label); 205 206 /// addSectionOffset - Add an offset into a section attribute data and value. 207 /// 208 void addSectionOffset(DIE &Die, dwarf::Attribute Attribute, uint64_t Integer); 209 210 /// addOpAddress - Add a dwarf op address data and value using the 211 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index. 212 void addOpAddress(DIELoc &Die, const MCSymbol *Label); 213 214 /// addLabelDelta - Add a label delta attribute data and value. 215 void addLabelDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, 216 const MCSymbol *Lo); 217 218 /// addDIEEntry - Add a DIE attribute data and value. 219 void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry); 220 221 /// addDIEEntry - Add a DIE attribute data and value. 222 void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIEEntry *Entry); 223 224 void addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type); 225 226 /// addBlock - Add block data. 227 void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Block); 228 229 /// addBlock - Add block data. 230 void addBlock(DIE &Die, dwarf::Attribute Attribute, DIEBlock *Block); 231 232 /// addSourceLine - Add location information to specified debug information 233 /// entry. 234 void addSourceLine(DIE &Die, unsigned Line, StringRef File, 235 StringRef Directory); 236 void addSourceLine(DIE &Die, DIVariable V); 237 void addSourceLine(DIE &Die, DIGlobalVariable G); 238 void addSourceLine(DIE &Die, DISubprogram SP); 239 void addSourceLine(DIE &Die, DIType Ty); 240 void addSourceLine(DIE &Die, DINameSpace NS); 241 void addSourceLine(DIE &Die, DIObjCProperty Ty); 242 243 /// addConstantValue - Add constant value entry in variable DIE. 244 void addConstantValue(DIE &Die, const MachineOperand &MO, DIType Ty); 245 void addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty); 246 void addConstantValue(DIE &Die, const APInt &Val, DIType Ty); 247 void addConstantValue(DIE &Die, const APInt &Val, bool Unsigned); 248 void addConstantValue(DIE &Die, bool Unsigned, uint64_t Val); 249 250 /// addConstantFPValue - Add constant value entry in variable DIE. 251 void addConstantFPValue(DIE &Die, const MachineOperand &MO); 252 void addConstantFPValue(DIE &Die, const ConstantFP *CFP); 253 254 /// addTemplateParams - Add template parameters in buffer. 255 void addTemplateParams(DIE &Buffer, DIArray TParams); 256 257 /// \brief Add register operand. 258 /// \returns false if the register does not exist, e.g., because it was never 259 /// materialized. 260 bool addRegisterOpPiece(DIELoc &TheDie, unsigned Reg, 261 unsigned SizeInBits = 0, unsigned OffsetInBits = 0); 262 263 /// \brief Add register offset. 264 /// \returns false if the register does not exist, e.g., because it was never 265 /// materialized. 266 bool addRegisterOffset(DIELoc &TheDie, unsigned Reg, int64_t Offset); 267 268 // FIXME: Should be reformulated in terms of addComplexAddress. 269 /// addBlockByrefAddress - Start with the address based on the location 270 /// provided, and generate the DWARF information necessary to find the 271 /// actual Block variable (navigating the Block struct) based on the 272 /// starting location. Add the DWARF information to the die. Obsolete, 273 /// please use addComplexAddress instead. 274 void addBlockByrefAddress(const DbgVariable &DV, DIE &Die, 275 dwarf::Attribute Attribute, 276 const MachineLocation &Location); 277 278 /// addType - Add a new type attribute to the specified entity. This takes 279 /// and attribute parameter because DW_AT_friend attributes are also 280 /// type references. 281 void addType(DIE &Entity, DIType Ty, 282 dwarf::Attribute Attribute = dwarf::DW_AT_type); 283 284 /// getOrCreateNameSpace - Create a DIE for DINameSpace. 285 DIE *getOrCreateNameSpace(DINameSpace NS); 286 287 /// getOrCreateSubprogramDIE - Create new DIE using SP. 288 DIE *getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal = false); 289 290 void applySubprogramAttributes(DISubprogram SP, DIE &SPDie, 291 bool Minimal = false); 292 293 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 294 /// given DIType. 295 DIE *getOrCreateTypeDIE(const MDNode *N); 296 297 /// getOrCreateContextDIE - Get context owner's DIE. 298 DIE *createTypeDIE(DICompositeType Ty); 299 300 /// getOrCreateContextDIE - Get context owner's DIE. 301 DIE *getOrCreateContextDIE(DIScope Context); 302 303 /// constructContainingTypeDIEs - Construct DIEs for types that contain 304 /// vtables. 305 void constructContainingTypeDIEs(); 306 307 /// constructSubprogramArguments - Construct function argument DIEs. 308 void constructSubprogramArguments(DIE &Buffer, DITypeArray Args); 309 310 /// Create a DIE with the given Tag, add the DIE to its parent, and 311 /// call insertDIE if MD is not null. 312 DIE &createAndAddDIE(unsigned Tag, DIE &Parent, 313 DIDescriptor N = DIDescriptor()); 314 315 /// Compute the size of a header for this unit, not including the initial 316 /// length field. getHeaderSize()317 virtual unsigned getHeaderSize() const { 318 return sizeof(int16_t) + // DWARF version number 319 sizeof(int32_t) + // Offset Into Abbrev. Section 320 sizeof(int8_t); // Pointer Size (in bytes) 321 } 322 323 /// Emit the header for this unit, not including the initial length field. 324 virtual void emitHeader(const MCSymbol *ASectionSym) const; 325 326 virtual DwarfCompileUnit &getCU() = 0; 327 328 /// constructTypeDIE - Construct type DIE from DICompositeType. 329 void constructTypeDIE(DIE &Buffer, DICompositeType CTy); 330 331 protected: 332 /// getOrCreateStaticMemberDIE - Create new static data member DIE. 333 DIE *getOrCreateStaticMemberDIE(DIDerivedType DT); 334 335 /// Look up the source ID with the given directory and source file names. If 336 /// none currently exists, create a new ID and insert it in the line table. 337 virtual unsigned getOrCreateSourceID(StringRef File, StringRef Directory) = 0; 338 339 /// resolve - Look in the DwarfDebug map for the MDNode that 340 /// corresponds to the reference. resolve(DIRef<T> Ref)341 template <typename T> T resolve(DIRef<T> Ref) const { 342 return DD->resolve(Ref); 343 } 344 345 private: 346 /// constructTypeDIE - Construct basic type die from DIBasicType. 347 void constructTypeDIE(DIE &Buffer, DIBasicType BTy); 348 349 /// constructTypeDIE - Construct derived type die from DIDerivedType. 350 void constructTypeDIE(DIE &Buffer, DIDerivedType DTy); 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, DICompositeType CTy); 357 358 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 359 void constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy); 360 361 /// constructMemberDIE - Construct member DIE from DIDerivedType. 362 void constructMemberDIE(DIE &Buffer, DIDerivedType DT); 363 364 /// constructTemplateTypeParameterDIE - Construct new DIE for the given 365 /// DITemplateTypeParameter. 366 void constructTemplateTypeParameterDIE(DIE &Buffer, 367 DITemplateTypeParameter TP); 368 369 /// constructTemplateValueParameterDIE - Construct new DIE for the given 370 /// DITemplateValueParameter. 371 void constructTemplateValueParameterDIE(DIE &Buffer, 372 DITemplateValueParameter TVP); 373 374 /// getLowerBoundDefault - Return the default lower bound for an array. If the 375 /// DWARF version doesn't handle the language, return -1. 376 int64_t getDefaultLowerBound() const; 377 378 /// getDIEEntry - Returns the debug information entry for the specified 379 /// debug variable. getDIEEntry(const MDNode * N)380 DIEEntry *getDIEEntry(const MDNode *N) const { 381 return MDNodeToDIEEntryMap.lookup(N); 382 } 383 384 /// insertDIEEntry - Insert debug information entry into the map. insertDIEEntry(const MDNode * N,DIEEntry * E)385 void insertDIEEntry(const MDNode *N, DIEEntry *E) { 386 MDNodeToDIEEntryMap.insert(std::make_pair(N, E)); 387 } 388 389 // getIndexTyDie - Get an anonymous type for index type. 390 DIE *getIndexTyDie(); 391 392 // setIndexTyDie - Set D as anonymous type for index which can be reused 393 // later. setIndexTyDie(DIE * D)394 void setIndexTyDie(DIE *D) { IndexTyDie = D; } 395 396 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 397 /// information entry. 398 DIEEntry *createDIEEntry(DIE &Entry); 399 400 /// If this is a named finished type then include it in the list of types for 401 /// the accelerator tables. 402 void updateAcceleratorTables(DIScope Context, DIType Ty, const DIE &TyDIE); 403 404 virtual bool isDwoUnit() const = 0; 405 }; 406 407 class DwarfTypeUnit : public DwarfUnit { 408 uint64_t TypeSignature; 409 const DIE *Ty; 410 DwarfCompileUnit &CU; 411 MCDwarfDwoLineTable *SplitLineTable; 412 413 unsigned getOrCreateSourceID(StringRef File, StringRef Directory) override; 414 bool isDwoUnit() const override; 415 416 public: 417 DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A, 418 DwarfDebug *DW, DwarfFile *DWU, 419 MCDwarfDwoLineTable *SplitLineTable = nullptr); 420 setTypeSignature(uint64_t Signature)421 void setTypeSignature(uint64_t Signature) { TypeSignature = Signature; } getTypeSignature()422 uint64_t getTypeSignature() const { return TypeSignature; } setType(const DIE * Ty)423 void setType(const DIE *Ty) { this->Ty = Ty; } 424 425 /// Emit the header for this unit, not including the initial length field. 426 void emitHeader(const MCSymbol *ASectionSym) const override; getHeaderSize()427 unsigned getHeaderSize() const override { 428 return DwarfUnit::getHeaderSize() + sizeof(uint64_t) + // Type Signature 429 sizeof(uint32_t); // Type DIE Offset 430 } 431 using DwarfUnit::initSection; getCU()432 DwarfCompileUnit &getCU() override { return CU; } 433 }; 434 } // end llvm namespace 435 #endif 436