1 //===- llvm/CodeGen/DwarfDebug.h - Dwarf Debug Framework --------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file contains support for writing dwarf debug info into asm files. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H 14 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H 15 16 #include "AddressPool.h" 17 #include "DebugLocStream.h" 18 #include "DebugLocEntry.h" 19 #include "DwarfFile.h" 20 #include "llvm/ADT/ArrayRef.h" 21 #include "llvm/ADT/DenseMap.h" 22 #include "llvm/ADT/DenseSet.h" 23 #include "llvm/ADT/MapVector.h" 24 #include "llvm/ADT/STLExtras.h" 25 #include "llvm/ADT/SetVector.h" 26 #include "llvm/ADT/SmallPtrSet.h" 27 #include "llvm/ADT/SmallVector.h" 28 #include "llvm/ADT/StringMap.h" 29 #include "llvm/ADT/StringRef.h" 30 #include "llvm/BinaryFormat/Dwarf.h" 31 #include "llvm/CodeGen/AccelTable.h" 32 #include "llvm/CodeGen/DbgEntityHistoryCalculator.h" 33 #include "llvm/CodeGen/DebugHandlerBase.h" 34 #include "llvm/CodeGen/MachineInstr.h" 35 #include "llvm/IR/DebugInfoMetadata.h" 36 #include "llvm/IR/DebugLoc.h" 37 #include "llvm/IR/Metadata.h" 38 #include "llvm/MC/MCDwarf.h" 39 #include "llvm/Support/Allocator.h" 40 #include "llvm/Target/TargetOptions.h" 41 #include <cassert> 42 #include <cstdint> 43 #include <limits> 44 #include <memory> 45 #include <utility> 46 #include <vector> 47 48 namespace llvm { 49 50 class AsmPrinter; 51 class ByteStreamer; 52 class DIE; 53 class DwarfCompileUnit; 54 class DwarfExpression; 55 class DwarfTypeUnit; 56 class DwarfUnit; 57 class LexicalScope; 58 class MachineFunction; 59 class MCSection; 60 class MCSymbol; 61 class Module; 62 63 //===----------------------------------------------------------------------===// 64 /// This class is defined as the common parent of DbgVariable and DbgLabel 65 /// such that it could levarage polymorphism to extract common code for 66 /// DbgVariable and DbgLabel. 67 class DbgEntity { 68 const DINode *Entity; 69 const DILocation *InlinedAt; 70 DIE *TheDIE = nullptr; 71 unsigned SubclassID; 72 73 public: 74 enum DbgEntityKind { 75 DbgVariableKind, 76 DbgLabelKind 77 }; 78 79 DbgEntity(const DINode *N, const DILocation *IA, unsigned ID) 80 : Entity(N), InlinedAt(IA), SubclassID(ID) {} 81 virtual ~DbgEntity() {} 82 83 /// Accessors. 84 /// @{ 85 const DINode *getEntity() const { return Entity; } 86 const DILocation *getInlinedAt() const { return InlinedAt; } 87 DIE *getDIE() const { return TheDIE; } 88 unsigned getDbgEntityID() const { return SubclassID; } 89 /// @} 90 91 void setDIE(DIE &D) { TheDIE = &D; } 92 93 static bool classof(const DbgEntity *N) { 94 switch (N->getDbgEntityID()) { 95 default: 96 return false; 97 case DbgVariableKind: 98 case DbgLabelKind: 99 return true; 100 } 101 } 102 }; 103 104 //===----------------------------------------------------------------------===// 105 /// This class is used to track local variable information. 106 /// 107 /// Variables can be created from allocas, in which case they're generated from 108 /// the MMI table. Such variables can have multiple expressions and frame 109 /// indices. 110 /// 111 /// Variables can be created from \c DBG_VALUE instructions. Those whose 112 /// location changes over time use \a DebugLocListIndex, while those with a 113 /// single location use \a ValueLoc and (optionally) a single entry of \a Expr. 114 /// 115 /// Variables that have been optimized out use none of these fields. 116 class DbgVariable : public DbgEntity { 117 /// Index of the entry list in DebugLocs. 118 unsigned DebugLocListIndex = ~0u; 119 /// DW_OP_LLVM_tag_offset value from DebugLocs. 120 Optional<uint8_t> DebugLocListTagOffset; 121 122 /// Single value location description. 123 std::unique_ptr<DbgValueLoc> ValueLoc = nullptr; 124 125 struct FrameIndexExpr { 126 int FI; 127 const DIExpression *Expr; 128 }; 129 mutable SmallVector<FrameIndexExpr, 1> 130 FrameIndexExprs; /// Frame index + expression. 131 132 public: 133 /// Construct a DbgVariable. 134 /// 135 /// Creates a variable without any DW_AT_location. Call \a initializeMMI() 136 /// for MMI entries, or \a initializeDbgValue() for DBG_VALUE instructions. 137 DbgVariable(const DILocalVariable *V, const DILocation *IA) 138 : DbgEntity(V, IA, DbgVariableKind) {} 139 140 /// Initialize from the MMI table. 141 void initializeMMI(const DIExpression *E, int FI) { 142 assert(FrameIndexExprs.empty() && "Already initialized?"); 143 assert(!ValueLoc.get() && "Already initialized?"); 144 145 assert((!E || E->isValid()) && "Expected valid expression"); 146 assert(FI != std::numeric_limits<int>::max() && "Expected valid index"); 147 148 FrameIndexExprs.push_back({FI, E}); 149 } 150 151 // Initialize variable's location. 152 void initializeDbgValue(DbgValueLoc Value) { 153 assert(FrameIndexExprs.empty() && "Already initialized?"); 154 assert(!ValueLoc && "Already initialized?"); 155 assert(!Value.getExpression()->isFragment() && "Fragments not supported."); 156 157 ValueLoc = std::make_unique<DbgValueLoc>(Value); 158 if (auto *E = ValueLoc->getExpression()) 159 if (E->getNumElements()) 160 FrameIndexExprs.push_back({0, E}); 161 } 162 163 /// Initialize from a DBG_VALUE instruction. 164 void initializeDbgValue(const MachineInstr *DbgValue); 165 166 // Accessors. 167 const DILocalVariable *getVariable() const { 168 return cast<DILocalVariable>(getEntity()); 169 } 170 171 const DIExpression *getSingleExpression() const { 172 assert(ValueLoc.get() && FrameIndexExprs.size() <= 1); 173 return FrameIndexExprs.size() ? FrameIndexExprs[0].Expr : nullptr; 174 } 175 176 void setDebugLocListIndex(unsigned O) { DebugLocListIndex = O; } 177 unsigned getDebugLocListIndex() const { return DebugLocListIndex; } 178 void setDebugLocListTagOffset(uint8_t O) { DebugLocListTagOffset = O; } 179 Optional<uint8_t> getDebugLocListTagOffset() const { return DebugLocListTagOffset; } 180 StringRef getName() const { return getVariable()->getName(); } 181 const DbgValueLoc *getValueLoc() const { return ValueLoc.get(); } 182 /// Get the FI entries, sorted by fragment offset. 183 ArrayRef<FrameIndexExpr> getFrameIndexExprs() const; 184 bool hasFrameIndexExprs() const { return !FrameIndexExprs.empty(); } 185 void addMMIEntry(const DbgVariable &V); 186 187 // Translate tag to proper Dwarf tag. 188 dwarf::Tag getTag() const { 189 // FIXME: Why don't we just infer this tag and store it all along? 190 if (getVariable()->isParameter()) 191 return dwarf::DW_TAG_formal_parameter; 192 193 return dwarf::DW_TAG_variable; 194 } 195 196 /// Return true if DbgVariable is artificial. 197 bool isArtificial() const { 198 if (getVariable()->isArtificial()) 199 return true; 200 if (getType()->isArtificial()) 201 return true; 202 return false; 203 } 204 205 bool isObjectPointer() const { 206 if (getVariable()->isObjectPointer()) 207 return true; 208 if (getType()->isObjectPointer()) 209 return true; 210 return false; 211 } 212 213 bool hasComplexAddress() const { 214 assert(ValueLoc.get() && "Expected DBG_VALUE, not MMI variable"); 215 assert((FrameIndexExprs.empty() || 216 (FrameIndexExprs.size() == 1 && 217 FrameIndexExprs[0].Expr->getNumElements())) && 218 "Invalid Expr for DBG_VALUE"); 219 return !FrameIndexExprs.empty(); 220 } 221 222 const DIType *getType() const; 223 224 static bool classof(const DbgEntity *N) { 225 return N->getDbgEntityID() == DbgVariableKind; 226 } 227 }; 228 229 //===----------------------------------------------------------------------===// 230 /// This class is used to track label information. 231 /// 232 /// Labels are collected from \c DBG_LABEL instructions. 233 class DbgLabel : public DbgEntity { 234 const MCSymbol *Sym; /// Symbol before DBG_LABEL instruction. 235 236 public: 237 /// We need MCSymbol information to generate DW_AT_low_pc. 238 DbgLabel(const DILabel *L, const DILocation *IA, const MCSymbol *Sym = nullptr) 239 : DbgEntity(L, IA, DbgLabelKind), Sym(Sym) {} 240 241 /// Accessors. 242 /// @{ 243 const DILabel *getLabel() const { return cast<DILabel>(getEntity()); } 244 const MCSymbol *getSymbol() const { return Sym; } 245 246 StringRef getName() const { return getLabel()->getName(); } 247 /// @} 248 249 /// Translate tag to proper Dwarf tag. 250 dwarf::Tag getTag() const { 251 return dwarf::DW_TAG_label; 252 } 253 254 static bool classof(const DbgEntity *N) { 255 return N->getDbgEntityID() == DbgLabelKind; 256 } 257 }; 258 259 /// Used for tracking debug info about call site parameters. 260 class DbgCallSiteParam { 261 private: 262 unsigned Register; ///< Parameter register at the callee entry point. 263 DbgValueLoc Value; ///< Corresponding location for the parameter value at 264 ///< the call site. 265 public: 266 DbgCallSiteParam(unsigned Reg, DbgValueLoc Val) 267 : Register(Reg), Value(Val) { 268 assert(Reg && "Parameter register cannot be undef"); 269 } 270 271 unsigned getRegister() const { return Register; } 272 DbgValueLoc getValue() const { return Value; } 273 }; 274 275 /// Collection used for storing debug call site parameters. 276 using ParamSet = SmallVector<DbgCallSiteParam, 4>; 277 278 /// Helper used to pair up a symbol and its DWARF compile unit. 279 struct SymbolCU { 280 SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {} 281 282 const MCSymbol *Sym; 283 DwarfCompileUnit *CU; 284 }; 285 286 /// The kind of accelerator tables we should emit. 287 enum class AccelTableKind { 288 Default, ///< Platform default. 289 None, ///< None. 290 Apple, ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc. 291 Dwarf, ///< DWARF v5 .debug_names. 292 }; 293 294 /// Collects and handles dwarf debug information. 295 class DwarfDebug : public DebugHandlerBase { 296 /// All DIEValues are allocated through this allocator. 297 BumpPtrAllocator DIEValueAllocator; 298 299 /// Maps MDNode with its corresponding DwarfCompileUnit. 300 MapVector<const MDNode *, DwarfCompileUnit *> CUMap; 301 302 /// Maps a CU DIE with its corresponding DwarfCompileUnit. 303 DenseMap<const DIE *, DwarfCompileUnit *> CUDieMap; 304 305 /// List of all labels used in aranges generation. 306 std::vector<SymbolCU> ArangeLabels; 307 308 /// Size of each symbol emitted (for those symbols that have a specific size). 309 DenseMap<const MCSymbol *, uint64_t> SymSize; 310 311 /// Collection of abstract variables/labels. 312 SmallVector<std::unique_ptr<DbgEntity>, 64> ConcreteEntities; 313 314 /// Collection of DebugLocEntry. Stored in a linked list so that DIELocLists 315 /// can refer to them in spite of insertions into this list. 316 DebugLocStream DebugLocs; 317 318 /// This is a collection of subprogram MDNodes that are processed to 319 /// create DIEs. 320 SetVector<const DISubprogram *, SmallVector<const DISubprogram *, 16>, 321 SmallPtrSet<const DISubprogram *, 16>> 322 ProcessedSPNodes; 323 324 /// If nonnull, stores the current machine function we're processing. 325 const MachineFunction *CurFn = nullptr; 326 327 /// If nonnull, stores the CU in which the previous subprogram was contained. 328 const DwarfCompileUnit *PrevCU = nullptr; 329 330 /// As an optimization, there is no need to emit an entry in the directory 331 /// table for the same directory as DW_AT_comp_dir. 332 StringRef CompilationDir; 333 334 /// Holder for the file specific debug information. 335 DwarfFile InfoHolder; 336 337 /// Holders for the various debug information flags that we might need to 338 /// have exposed. See accessor functions below for description. 339 340 /// Map from MDNodes for user-defined types to their type signatures. Also 341 /// used to keep track of which types we have emitted type units for. 342 DenseMap<const MDNode *, uint64_t> TypeSignatures; 343 344 DenseMap<const MCSection *, const MCSymbol *> SectionLabels; 345 346 SmallVector< 347 std::pair<std::unique_ptr<DwarfTypeUnit>, const DICompositeType *>, 1> 348 TypeUnitsUnderConstruction; 349 350 /// Whether to use the GNU TLS opcode (instead of the standard opcode). 351 bool UseGNUTLSOpcode; 352 353 /// Whether to use DWARF 2 bitfields (instead of the DWARF 4 format). 354 bool UseDWARF2Bitfields; 355 356 /// Whether to emit all linkage names, or just abstract subprograms. 357 bool UseAllLinkageNames; 358 359 /// Use inlined strings. 360 bool UseInlineStrings = false; 361 362 /// Allow emission of .debug_ranges section. 363 bool UseRangesSection = true; 364 365 /// True if the sections itself must be used as references and don't create 366 /// temp symbols inside DWARF sections. 367 bool UseSectionsAsReferences = false; 368 369 ///Allow emission of the .debug_loc section. 370 bool UseLocSection = true; 371 372 /// Generate DWARF v4 type units. 373 bool GenerateTypeUnits; 374 375 /// Emit a .debug_macro section instead of .debug_macinfo. 376 bool UseDebugMacroSection; 377 378 /// Avoid using DW_OP_convert due to consumer incompatibilities. 379 bool EnableOpConvert; 380 381 public: 382 enum class MinimizeAddrInV5 { 383 Default, 384 Disabled, 385 Ranges, 386 }; 387 388 private: 389 /// Force the use of DW_AT_ranges even for single-entry range lists. 390 MinimizeAddrInV5 MinimizeAddr = MinimizeAddrInV5::Disabled; 391 392 /// DWARF5 Experimental Options 393 /// @{ 394 AccelTableKind TheAccelTableKind; 395 bool HasAppleExtensionAttributes; 396 bool HasSplitDwarf; 397 398 /// Whether to generate the DWARF v5 string offsets table. 399 /// It consists of a series of contributions, each preceded by a header. 400 /// The pre-DWARF v5 string offsets table for split dwarf is, in contrast, 401 /// a monolithic sequence of string offsets. 402 bool UseSegmentedStringOffsetsTable; 403 404 /// Enable production of call site parameters needed to print the debug entry 405 /// values. Useful for testing purposes when a debugger does not support the 406 /// feature yet. 407 bool EmitDebugEntryValues; 408 409 /// Separated Dwarf Variables 410 /// In general these will all be for bits that are left in the 411 /// original object file, rather than things that are meant 412 /// to be in the .dwo sections. 413 414 /// Holder for the skeleton information. 415 DwarfFile SkeletonHolder; 416 417 /// Store file names for type units under fission in a line table 418 /// header that will be emitted into debug_line.dwo. 419 // FIXME: replace this with a map from comp_dir to table so that we 420 // can emit multiple tables during LTO each of which uses directory 421 // 0, referencing the comp_dir of all the type units that use it. 422 MCDwarfDwoLineTable SplitTypeUnitFileTable; 423 /// @} 424 425 /// True iff there are multiple CUs in this module. 426 bool SingleCU; 427 bool IsDarwin; 428 429 /// Map for tracking Fortran deferred CHARACTER lengths. 430 DenseMap<const DIStringType *, unsigned> StringTypeLocMap; 431 432 AddressPool AddrPool; 433 434 /// Accelerator tables. 435 AccelTable<DWARF5AccelTableData> AccelDebugNames; 436 AccelTable<AppleAccelTableOffsetData> AccelNames; 437 AccelTable<AppleAccelTableOffsetData> AccelObjC; 438 AccelTable<AppleAccelTableOffsetData> AccelNamespace; 439 AccelTable<AppleAccelTableTypeData> AccelTypes; 440 441 // Identify a debugger for "tuning" the debug info. 442 DebuggerKind DebuggerTuning = DebuggerKind::Default; 443 444 MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &); 445 446 const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() { 447 return InfoHolder.getUnits(); 448 } 449 450 using InlinedEntity = DbgValueHistoryMap::InlinedEntity; 451 452 void ensureAbstractEntityIsCreated(DwarfCompileUnit &CU, 453 const DINode *Node, 454 const MDNode *Scope); 455 void ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU, 456 const DINode *Node, 457 const MDNode *Scope); 458 459 DbgEntity *createConcreteEntity(DwarfCompileUnit &TheCU, 460 LexicalScope &Scope, 461 const DINode *Node, 462 const DILocation *Location, 463 const MCSymbol *Sym = nullptr); 464 465 /// Construct a DIE for this abstract scope. 466 void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope); 467 468 /// Construct a DIE for the subprogram definition \p SP and return it. 469 DIE &constructSubprogramDefinitionDIE(const DISubprogram *SP); 470 471 /// Construct DIEs for call site entries describing the calls in \p MF. 472 void constructCallSiteEntryDIEs(const DISubprogram &SP, DwarfCompileUnit &CU, 473 DIE &ScopeDIE, const MachineFunction &MF); 474 475 template <typename DataT> 476 void addAccelNameImpl(const DICompileUnit &CU, AccelTable<DataT> &AppleAccel, 477 StringRef Name, const DIE &Die); 478 479 void finishEntityDefinitions(); 480 481 void finishSubprogramDefinitions(); 482 483 /// Finish off debug information after all functions have been 484 /// processed. 485 void finalizeModuleInfo(); 486 487 /// Emit the debug info section. 488 void emitDebugInfo(); 489 490 /// Emit the abbreviation section. 491 void emitAbbreviations(); 492 493 /// Emit the string offsets table header. 494 void emitStringOffsetsTableHeader(); 495 496 /// Emit a specified accelerator table. 497 template <typename AccelTableT> 498 void emitAccel(AccelTableT &Accel, MCSection *Section, StringRef TableName); 499 500 /// Emit DWARF v5 accelerator table. 501 void emitAccelDebugNames(); 502 503 /// Emit visible names into a hashed accelerator table section. 504 void emitAccelNames(); 505 506 /// Emit objective C classes and categories into a hashed 507 /// accelerator table section. 508 void emitAccelObjC(); 509 510 /// Emit namespace dies into a hashed accelerator table. 511 void emitAccelNamespaces(); 512 513 /// Emit type dies into a hashed accelerator table. 514 void emitAccelTypes(); 515 516 /// Emit visible names and types into debug pubnames and pubtypes sections. 517 void emitDebugPubSections(); 518 519 void emitDebugPubSection(bool GnuStyle, StringRef Name, 520 DwarfCompileUnit *TheU, 521 const StringMap<const DIE *> &Globals); 522 523 /// Emit null-terminated strings into a debug str section. 524 void emitDebugStr(); 525 526 /// Emit variable locations into a debug loc section. 527 void emitDebugLoc(); 528 529 /// Emit variable locations into a debug loc dwo section. 530 void emitDebugLocDWO(); 531 532 void emitDebugLocImpl(MCSection *Sec); 533 534 /// Emit address ranges into a debug aranges section. 535 void emitDebugARanges(); 536 537 /// Emit address ranges into a debug ranges section. 538 void emitDebugRanges(); 539 void emitDebugRangesDWO(); 540 void emitDebugRangesImpl(const DwarfFile &Holder, MCSection *Section); 541 542 /// Emit macros into a debug macinfo section. 543 void emitDebugMacinfo(); 544 /// Emit macros into a debug macinfo.dwo section. 545 void emitDebugMacinfoDWO(); 546 void emitDebugMacinfoImpl(MCSection *Section); 547 void emitMacro(DIMacro &M); 548 void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U); 549 void emitMacroFileImpl(DIMacroFile &F, DwarfCompileUnit &U, 550 unsigned StartFile, unsigned EndFile, 551 StringRef (*MacroFormToString)(unsigned Form)); 552 void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U); 553 554 /// DWARF 5 Experimental Split Dwarf Emitters 555 556 /// Initialize common features of skeleton units. 557 void initSkeletonUnit(const DwarfUnit &U, DIE &Die, 558 std::unique_ptr<DwarfCompileUnit> NewU); 559 560 /// Construct the split debug info compile unit for the debug info section. 561 /// In DWARF v5, the skeleton unit DIE may have the following attributes: 562 /// DW_AT_addr_base, DW_AT_comp_dir, DW_AT_dwo_name, DW_AT_high_pc, 563 /// DW_AT_low_pc, DW_AT_ranges, DW_AT_stmt_list, and DW_AT_str_offsets_base. 564 /// Prior to DWARF v5 it may also have DW_AT_GNU_dwo_id. DW_AT_GNU_dwo_name 565 /// is used instead of DW_AT_dwo_name, Dw_AT_GNU_addr_base instead of 566 /// DW_AT_addr_base, and DW_AT_GNU_ranges_base instead of DW_AT_rnglists_base. 567 DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU); 568 569 /// Emit the debug info dwo section. 570 void emitDebugInfoDWO(); 571 572 /// Emit the debug abbrev dwo section. 573 void emitDebugAbbrevDWO(); 574 575 /// Emit the debug line dwo section. 576 void emitDebugLineDWO(); 577 578 /// Emit the dwo stringoffsets table header. 579 void emitStringOffsetsTableHeaderDWO(); 580 581 /// Emit the debug str dwo section. 582 void emitDebugStrDWO(); 583 584 /// Emit DWO addresses. 585 void emitDebugAddr(); 586 587 /// Flags to let the linker know we have emitted new style pubnames. Only 588 /// emit it here if we don't have a skeleton CU for split dwarf. 589 void addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const; 590 591 /// Create new DwarfCompileUnit for the given metadata node with tag 592 /// DW_TAG_compile_unit. 593 DwarfCompileUnit &getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit); 594 void finishUnitAttributes(const DICompileUnit *DIUnit, 595 DwarfCompileUnit &NewCU); 596 597 /// Construct imported_module or imported_declaration DIE. 598 void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU, 599 const DIImportedEntity *N); 600 601 /// Register a source line with debug info. Returns the unique 602 /// label that was emitted and which provides correspondence to the 603 /// source line list. 604 void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope, 605 unsigned Flags); 606 607 /// Populate LexicalScope entries with variables' info. 608 void collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP, 609 DenseSet<InlinedEntity> &ProcessedVars); 610 611 /// Build the location list for all DBG_VALUEs in the 612 /// function that describe the same variable. If the resulting 613 /// list has only one entry that is valid for entire variable's 614 /// scope return true. 615 bool buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc, 616 const DbgValueHistoryMap::Entries &Entries); 617 618 /// Collect variable information from the side table maintained by MF. 619 void collectVariableInfoFromMFTable(DwarfCompileUnit &TheCU, 620 DenseSet<InlinedEntity> &P); 621 622 /// Emit the reference to the section. 623 void emitSectionReference(const DwarfCompileUnit &CU); 624 625 protected: 626 /// Gather pre-function debug information. 627 void beginFunctionImpl(const MachineFunction *MF) override; 628 629 /// Gather and emit post-function debug information. 630 void endFunctionImpl(const MachineFunction *MF) override; 631 632 void skippedNonDebugFunction() override; 633 634 public: 635 //===--------------------------------------------------------------------===// 636 // Main entry points. 637 // 638 DwarfDebug(AsmPrinter *A); 639 640 ~DwarfDebug() override; 641 642 /// Emit all Dwarf sections that should come prior to the 643 /// content. 644 void beginModule(Module *M) override; 645 646 /// Emit all Dwarf sections that should come after the content. 647 void endModule() override; 648 649 /// Emits inital debug location directive. 650 DebugLoc emitInitialLocDirective(const MachineFunction &MF, unsigned CUID); 651 652 /// Process beginning of an instruction. 653 void beginInstruction(const MachineInstr *MI) override; 654 655 /// Perform an MD5 checksum of \p Identifier and return the lower 64 bits. 656 static uint64_t makeTypeSignature(StringRef Identifier); 657 658 /// Add a DIE to the set of types that we're going to pull into 659 /// type units. 660 void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, 661 DIE &Die, const DICompositeType *CTy); 662 663 class NonTypeUnitContext { 664 DwarfDebug *DD; 665 decltype(DwarfDebug::TypeUnitsUnderConstruction) TypeUnitsUnderConstruction; 666 bool AddrPoolUsed; 667 friend class DwarfDebug; 668 NonTypeUnitContext(DwarfDebug *DD); 669 public: 670 NonTypeUnitContext(NonTypeUnitContext&&) = default; 671 ~NonTypeUnitContext(); 672 }; 673 674 NonTypeUnitContext enterNonTypeUnitContext(); 675 676 /// Add a label so that arange data can be generated for it. 677 void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); } 678 679 /// For symbols that have a size designated (e.g. common symbols), 680 /// this tracks that size. 681 void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override { 682 SymSize[Sym] = Size; 683 } 684 685 /// Returns whether we should emit all DW_AT_[MIPS_]linkage_name. 686 /// If not, we still might emit certain cases. 687 bool useAllLinkageNames() const { return UseAllLinkageNames; } 688 689 /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the 690 /// standard DW_OP_form_tls_address opcode 691 bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; } 692 693 /// Returns whether to use the DWARF2 format for bitfields instyead of the 694 /// DWARF4 format. 695 bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; } 696 697 /// Returns whether to use inline strings. 698 bool useInlineStrings() const { return UseInlineStrings; } 699 700 /// Returns whether ranges section should be emitted. 701 bool useRangesSection() const { return UseRangesSection; } 702 703 /// Returns whether range encodings should be used for single entry range 704 /// lists. 705 bool alwaysUseRanges() const { 706 return MinimizeAddr == MinimizeAddrInV5::Ranges; 707 } 708 709 /// Returns whether to use sections as labels rather than temp symbols. 710 bool useSectionsAsReferences() const { 711 return UseSectionsAsReferences; 712 } 713 714 /// Returns whether .debug_loc section should be emitted. 715 bool useLocSection() const { return UseLocSection; } 716 717 /// Returns whether to generate DWARF v4 type units. 718 bool generateTypeUnits() const { return GenerateTypeUnits; } 719 720 // Experimental DWARF5 features. 721 722 /// Returns what kind (if any) of accelerator tables to emit. 723 AccelTableKind getAccelTableKind() const { return TheAccelTableKind; } 724 725 bool useAppleExtensionAttributes() const { 726 return HasAppleExtensionAttributes; 727 } 728 729 /// Returns whether or not to change the current debug info for the 730 /// split dwarf proposal support. 731 bool useSplitDwarf() const { return HasSplitDwarf; } 732 733 /// Returns whether to generate a string offsets table with (possibly shared) 734 /// contributions from each CU and type unit. This implies the use of 735 /// DW_FORM_strx* indirect references with DWARF v5 and beyond. Note that 736 /// DW_FORM_GNU_str_index is also an indirect reference, but it is used with 737 /// a pre-DWARF v5 implementation of split DWARF sections, which uses a 738 /// monolithic string offsets table. 739 bool useSegmentedStringOffsetsTable() const { 740 return UseSegmentedStringOffsetsTable; 741 } 742 743 bool emitDebugEntryValues() const { 744 return EmitDebugEntryValues; 745 } 746 747 bool useOpConvert() const { 748 return EnableOpConvert; 749 } 750 751 bool shareAcrossDWOCUs() const; 752 753 /// Returns the Dwarf Version. 754 uint16_t getDwarfVersion() const; 755 756 /// Returns a suitable DWARF form to represent a section offset, i.e. 757 /// * DW_FORM_sec_offset for DWARF version >= 4; 758 /// * DW_FORM_data8 for 64-bit DWARFv3; 759 /// * DW_FORM_data4 for 32-bit DWARFv3 and DWARFv2. 760 dwarf::Form getDwarfSectionOffsetForm() const; 761 762 /// Returns the previous CU that was being updated 763 const DwarfCompileUnit *getPrevCU() const { return PrevCU; } 764 void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; } 765 766 /// Returns the entries for the .debug_loc section. 767 const DebugLocStream &getDebugLocs() const { return DebugLocs; } 768 769 /// Emit an entry for the debug loc section. This can be used to 770 /// handle an entry that's going to be emitted into the debug loc section. 771 void emitDebugLocEntry(ByteStreamer &Streamer, 772 const DebugLocStream::Entry &Entry, 773 const DwarfCompileUnit *CU); 774 775 /// Emit the location for a debug loc entry, including the size header. 776 void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, 777 const DwarfCompileUnit *CU); 778 779 void addSubprogramNames(const DICompileUnit &CU, const DISubprogram *SP, 780 DIE &Die); 781 782 AddressPool &getAddressPool() { return AddrPool; } 783 784 void addAccelName(const DICompileUnit &CU, StringRef Name, const DIE &Die); 785 786 void addAccelObjC(const DICompileUnit &CU, StringRef Name, const DIE &Die); 787 788 void addAccelNamespace(const DICompileUnit &CU, StringRef Name, 789 const DIE &Die); 790 791 void addAccelType(const DICompileUnit &CU, StringRef Name, const DIE &Die, 792 char Flags); 793 794 const MachineFunction *getCurrentFunction() const { return CurFn; } 795 796 /// A helper function to check whether the DIE for a given Scope is 797 /// going to be null. 798 bool isLexicalScopeDIENull(LexicalScope *Scope); 799 800 /// Find the matching DwarfCompileUnit for the given CU DIE. 801 DwarfCompileUnit *lookupCU(const DIE *Die) { return CUDieMap.lookup(Die); } 802 const DwarfCompileUnit *lookupCU(const DIE *Die) const { 803 return CUDieMap.lookup(Die); 804 } 805 806 unsigned getStringTypeLoc(const DIStringType *ST) const { 807 return StringTypeLocMap.lookup(ST); 808 } 809 810 void addStringTypeLoc(const DIStringType *ST, unsigned Loc) { 811 assert(ST); 812 if (Loc) 813 StringTypeLocMap[ST] = Loc; 814 } 815 816 /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger. 817 /// 818 /// Returns whether we are "tuning" for a given debugger. 819 /// @{ 820 bool tuneForGDB() const { return DebuggerTuning == DebuggerKind::GDB; } 821 bool tuneForLLDB() const { return DebuggerTuning == DebuggerKind::LLDB; } 822 bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; } 823 /// @} 824 825 const MCSymbol *getSectionLabel(const MCSection *S); 826 void insertSectionLabel(const MCSymbol *S); 827 828 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, 829 const DbgValueLoc &Value, 830 DwarfExpression &DwarfExpr); 831 832 /// If the \p File has an MD5 checksum, return it as an MD5Result 833 /// allocated in the MCContext. 834 Optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const; 835 }; 836 837 } // end namespace llvm 838 839 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H 840