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 48namespace llvm { 49 50class AsmPrinter; 51class ByteStreamer; 52class DIE; 53class DwarfCompileUnit; 54class DwarfExpression; 55class DwarfTypeUnit; 56class DwarfUnit; 57class LexicalScope; 58class MachineFunction; 59class MCSection; 60class MCSymbol; 61class 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. 67class DbgEntity { 68 const DINode *Entity; 69 const DILocation *InlinedAt; 70 DIE *TheDIE = nullptr; 71 unsigned SubclassID; 72 73public: 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. 116class 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 132public: 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. 233class DbgLabel : public DbgEntity { 234 const MCSymbol *Sym; /// Symbol before DBG_LABEL instruction. 235 236public: 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. 260class DbgCallSiteParam { 261private: 262 unsigned Register; ///< Parameter register at the callee entry point. 263 DbgValueLoc Value; ///< Corresponding location for the parameter value at 264 ///< the call site. 265public: 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. 276using ParamSet = SmallVector<DbgCallSiteParam, 4>; 277 278/// Helper used to pair up a symbol and its DWARF compile unit. 279struct 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. 287enum 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. 295class 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 381public: 382 enum class MinimizeAddrInV5 { 383 Default, 384 Disabled, 385 Ranges, 386 Expressions, 387 Form, 388 }; 389 390private: 391 /// Force the use of DW_AT_ranges even for single-entry range lists. 392 MinimizeAddrInV5 MinimizeAddr = MinimizeAddrInV5::Disabled; 393 394 /// DWARF5 Experimental Options 395 /// @{ 396 AccelTableKind TheAccelTableKind; 397 bool HasAppleExtensionAttributes; 398 bool HasSplitDwarf; 399 400 /// Whether to generate the DWARF v5 string offsets table. 401 /// It consists of a series of contributions, each preceded by a header. 402 /// The pre-DWARF v5 string offsets table for split dwarf is, in contrast, 403 /// a monolithic sequence of string offsets. 404 bool UseSegmentedStringOffsetsTable; 405 406 /// Enable production of call site parameters needed to print the debug entry 407 /// values. Useful for testing purposes when a debugger does not support the 408 /// feature yet. 409 bool EmitDebugEntryValues; 410 411 /// Separated Dwarf Variables 412 /// In general these will all be for bits that are left in the 413 /// original object file, rather than things that are meant 414 /// to be in the .dwo sections. 415 416 /// Holder for the skeleton information. 417 DwarfFile SkeletonHolder; 418 419 /// Store file names for type units under fission in a line table 420 /// header that will be emitted into debug_line.dwo. 421 // FIXME: replace this with a map from comp_dir to table so that we 422 // can emit multiple tables during LTO each of which uses directory 423 // 0, referencing the comp_dir of all the type units that use it. 424 MCDwarfDwoLineTable SplitTypeUnitFileTable; 425 /// @} 426 427 /// True iff there are multiple CUs in this module. 428 bool SingleCU; 429 bool IsDarwin; 430 431 /// Map for tracking Fortran deferred CHARACTER lengths. 432 DenseMap<const DIStringType *, unsigned> StringTypeLocMap; 433 434 AddressPool AddrPool; 435 436 /// Accelerator tables. 437 AccelTable<DWARF5AccelTableData> AccelDebugNames; 438 AccelTable<AppleAccelTableOffsetData> AccelNames; 439 AccelTable<AppleAccelTableOffsetData> AccelObjC; 440 AccelTable<AppleAccelTableOffsetData> AccelNamespace; 441 AccelTable<AppleAccelTableTypeData> AccelTypes; 442 443 /// Identify a debugger for "tuning" the debug info. 444 /// 445 /// The "tuning" should be used to set defaults for individual feature flags 446 /// in DwarfDebug; if a given feature has a more specific command-line option, 447 /// that option should take precedence over the tuning. 448 DebuggerKind DebuggerTuning = DebuggerKind::Default; 449 450 MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &); 451 452 const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() { 453 return InfoHolder.getUnits(); 454 } 455 456 using InlinedEntity = DbgValueHistoryMap::InlinedEntity; 457 458 void ensureAbstractEntityIsCreated(DwarfCompileUnit &CU, 459 const DINode *Node, 460 const MDNode *Scope); 461 void ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU, 462 const DINode *Node, 463 const MDNode *Scope); 464 465 DbgEntity *createConcreteEntity(DwarfCompileUnit &TheCU, 466 LexicalScope &Scope, 467 const DINode *Node, 468 const DILocation *Location, 469 const MCSymbol *Sym = nullptr); 470 471 /// Construct a DIE for this abstract scope. 472 void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope); 473 474 /// Construct a DIE for the subprogram definition \p SP and return it. 475 DIE &constructSubprogramDefinitionDIE(const DISubprogram *SP); 476 477 /// Construct DIEs for call site entries describing the calls in \p MF. 478 void constructCallSiteEntryDIEs(const DISubprogram &SP, DwarfCompileUnit &CU, 479 DIE &ScopeDIE, const MachineFunction &MF); 480 481 template <typename DataT> 482 void addAccelNameImpl(const DICompileUnit &CU, AccelTable<DataT> &AppleAccel, 483 StringRef Name, const DIE &Die); 484 485 void finishEntityDefinitions(); 486 487 void finishSubprogramDefinitions(); 488 489 /// Finish off debug information after all functions have been 490 /// processed. 491 void finalizeModuleInfo(); 492 493 /// Emit the debug info section. 494 void emitDebugInfo(); 495 496 /// Emit the abbreviation section. 497 void emitAbbreviations(); 498 499 /// Emit the string offsets table header. 500 void emitStringOffsetsTableHeader(); 501 502 /// Emit a specified accelerator table. 503 template <typename AccelTableT> 504 void emitAccel(AccelTableT &Accel, MCSection *Section, StringRef TableName); 505 506 /// Emit DWARF v5 accelerator table. 507 void emitAccelDebugNames(); 508 509 /// Emit visible names into a hashed accelerator table section. 510 void emitAccelNames(); 511 512 /// Emit objective C classes and categories into a hashed 513 /// accelerator table section. 514 void emitAccelObjC(); 515 516 /// Emit namespace dies into a hashed accelerator table. 517 void emitAccelNamespaces(); 518 519 /// Emit type dies into a hashed accelerator table. 520 void emitAccelTypes(); 521 522 /// Emit visible names and types into debug pubnames and pubtypes sections. 523 void emitDebugPubSections(); 524 525 void emitDebugPubSection(bool GnuStyle, StringRef Name, 526 DwarfCompileUnit *TheU, 527 const StringMap<const DIE *> &Globals); 528 529 /// Emit null-terminated strings into a debug str section. 530 void emitDebugStr(); 531 532 /// Emit variable locations into a debug loc section. 533 void emitDebugLoc(); 534 535 /// Emit variable locations into a debug loc dwo section. 536 void emitDebugLocDWO(); 537 538 void emitDebugLocImpl(MCSection *Sec); 539 540 /// Emit address ranges into a debug aranges section. 541 void emitDebugARanges(); 542 543 /// Emit address ranges into a debug ranges section. 544 void emitDebugRanges(); 545 void emitDebugRangesDWO(); 546 void emitDebugRangesImpl(const DwarfFile &Holder, MCSection *Section); 547 548 /// Emit macros into a debug macinfo section. 549 void emitDebugMacinfo(); 550 /// Emit macros into a debug macinfo.dwo section. 551 void emitDebugMacinfoDWO(); 552 void emitDebugMacinfoImpl(MCSection *Section); 553 void emitMacro(DIMacro &M); 554 void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U); 555 void emitMacroFileImpl(DIMacroFile &F, DwarfCompileUnit &U, 556 unsigned StartFile, unsigned EndFile, 557 StringRef (*MacroFormToString)(unsigned Form)); 558 void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U); 559 560 /// DWARF 5 Experimental Split Dwarf Emitters 561 562 /// Initialize common features of skeleton units. 563 void initSkeletonUnit(const DwarfUnit &U, DIE &Die, 564 std::unique_ptr<DwarfCompileUnit> NewU); 565 566 /// Construct the split debug info compile unit for the debug info section. 567 /// In DWARF v5, the skeleton unit DIE may have the following attributes: 568 /// DW_AT_addr_base, DW_AT_comp_dir, DW_AT_dwo_name, DW_AT_high_pc, 569 /// DW_AT_low_pc, DW_AT_ranges, DW_AT_stmt_list, and DW_AT_str_offsets_base. 570 /// Prior to DWARF v5 it may also have DW_AT_GNU_dwo_id. DW_AT_GNU_dwo_name 571 /// is used instead of DW_AT_dwo_name, Dw_AT_GNU_addr_base instead of 572 /// DW_AT_addr_base, and DW_AT_GNU_ranges_base instead of DW_AT_rnglists_base. 573 DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU); 574 575 /// Emit the debug info dwo section. 576 void emitDebugInfoDWO(); 577 578 /// Emit the debug abbrev dwo section. 579 void emitDebugAbbrevDWO(); 580 581 /// Emit the debug line dwo section. 582 void emitDebugLineDWO(); 583 584 /// Emit the dwo stringoffsets table header. 585 void emitStringOffsetsTableHeaderDWO(); 586 587 /// Emit the debug str dwo section. 588 void emitDebugStrDWO(); 589 590 /// Emit DWO addresses. 591 void emitDebugAddr(); 592 593 /// Flags to let the linker know we have emitted new style pubnames. Only 594 /// emit it here if we don't have a skeleton CU for split dwarf. 595 void addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const; 596 597 /// Create new DwarfCompileUnit for the given metadata node with tag 598 /// DW_TAG_compile_unit. 599 DwarfCompileUnit &getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit); 600 void finishUnitAttributes(const DICompileUnit *DIUnit, 601 DwarfCompileUnit &NewCU); 602 603 /// Construct imported_module or imported_declaration DIE. 604 void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU, 605 const DIImportedEntity *N); 606 607 /// Register a source line with debug info. Returns the unique 608 /// label that was emitted and which provides correspondence to the 609 /// source line list. 610 void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope, 611 unsigned Flags); 612 613 /// Populate LexicalScope entries with variables' info. 614 void collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP, 615 DenseSet<InlinedEntity> &ProcessedVars); 616 617 /// Build the location list for all DBG_VALUEs in the 618 /// function that describe the same variable. If the resulting 619 /// list has only one entry that is valid for entire variable's 620 /// scope return true. 621 bool buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc, 622 const DbgValueHistoryMap::Entries &Entries); 623 624 /// Collect variable information from the side table maintained by MF. 625 void collectVariableInfoFromMFTable(DwarfCompileUnit &TheCU, 626 DenseSet<InlinedEntity> &P); 627 628 /// Emit the reference to the section. 629 void emitSectionReference(const DwarfCompileUnit &CU); 630 631protected: 632 /// Gather pre-function debug information. 633 void beginFunctionImpl(const MachineFunction *MF) override; 634 635 /// Gather and emit post-function debug information. 636 void endFunctionImpl(const MachineFunction *MF) override; 637 638 void skippedNonDebugFunction() override; 639 640public: 641 //===--------------------------------------------------------------------===// 642 // Main entry points. 643 // 644 DwarfDebug(AsmPrinter *A); 645 646 ~DwarfDebug() override; 647 648 /// Emit all Dwarf sections that should come prior to the 649 /// content. 650 void beginModule(Module *M) override; 651 652 /// Emit all Dwarf sections that should come after the content. 653 void endModule() override; 654 655 /// Emits inital debug location directive. 656 DebugLoc emitInitialLocDirective(const MachineFunction &MF, unsigned CUID); 657 658 /// Process beginning of an instruction. 659 void beginInstruction(const MachineInstr *MI) override; 660 661 /// Perform an MD5 checksum of \p Identifier and return the lower 64 bits. 662 static uint64_t makeTypeSignature(StringRef Identifier); 663 664 /// Add a DIE to the set of types that we're going to pull into 665 /// type units. 666 void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, 667 DIE &Die, const DICompositeType *CTy); 668 669 class NonTypeUnitContext { 670 DwarfDebug *DD; 671 decltype(DwarfDebug::TypeUnitsUnderConstruction) TypeUnitsUnderConstruction; 672 bool AddrPoolUsed; 673 friend class DwarfDebug; 674 NonTypeUnitContext(DwarfDebug *DD); 675 public: 676 NonTypeUnitContext(NonTypeUnitContext&&) = default; 677 ~NonTypeUnitContext(); 678 }; 679 680 NonTypeUnitContext enterNonTypeUnitContext(); 681 682 /// Add a label so that arange data can be generated for it. 683 void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); } 684 685 /// For symbols that have a size designated (e.g. common symbols), 686 /// this tracks that size. 687 void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override { 688 SymSize[Sym] = Size; 689 } 690 691 /// Returns whether we should emit all DW_AT_[MIPS_]linkage_name. 692 /// If not, we still might emit certain cases. 693 bool useAllLinkageNames() const { return UseAllLinkageNames; } 694 695 /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the 696 /// standard DW_OP_form_tls_address opcode 697 bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; } 698 699 /// Returns whether to use the DWARF2 format for bitfields instyead of the 700 /// DWARF4 format. 701 bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; } 702 703 /// Returns whether to use inline strings. 704 bool useInlineStrings() const { return UseInlineStrings; } 705 706 /// Returns whether ranges section should be emitted. 707 bool useRangesSection() const { return UseRangesSection; } 708 709 /// Returns whether range encodings should be used for single entry range 710 /// lists. 711 bool alwaysUseRanges() const { 712 return MinimizeAddr == MinimizeAddrInV5::Ranges; 713 } 714 715 // Returns whether novel exprloc addrx+offset encodings should be used to 716 // reduce debug_addr size. 717 bool useAddrOffsetExpressions() const { 718 return MinimizeAddr == MinimizeAddrInV5::Expressions; 719 } 720 721 // Returns whether addrx+offset LLVM extension form should be used to reduce 722 // debug_addr size. 723 bool useAddrOffsetForm() const { 724 return MinimizeAddr == MinimizeAddrInV5::Form; 725 } 726 727 /// Returns whether to use sections as labels rather than temp symbols. 728 bool useSectionsAsReferences() const { 729 return UseSectionsAsReferences; 730 } 731 732 /// Returns whether .debug_loc section should be emitted. 733 bool useLocSection() const { return UseLocSection; } 734 735 /// Returns whether to generate DWARF v4 type units. 736 bool generateTypeUnits() const { return GenerateTypeUnits; } 737 738 // Experimental DWARF5 features. 739 740 /// Returns what kind (if any) of accelerator tables to emit. 741 AccelTableKind getAccelTableKind() const { return TheAccelTableKind; } 742 743 bool useAppleExtensionAttributes() const { 744 return HasAppleExtensionAttributes; 745 } 746 747 /// Returns whether or not to change the current debug info for the 748 /// split dwarf proposal support. 749 bool useSplitDwarf() const { return HasSplitDwarf; } 750 751 /// Returns whether to generate a string offsets table with (possibly shared) 752 /// contributions from each CU and type unit. This implies the use of 753 /// DW_FORM_strx* indirect references with DWARF v5 and beyond. Note that 754 /// DW_FORM_GNU_str_index is also an indirect reference, but it is used with 755 /// a pre-DWARF v5 implementation of split DWARF sections, which uses a 756 /// monolithic string offsets table. 757 bool useSegmentedStringOffsetsTable() const { 758 return UseSegmentedStringOffsetsTable; 759 } 760 761 bool emitDebugEntryValues() const { 762 return EmitDebugEntryValues; 763 } 764 765 bool useOpConvert() const { 766 return EnableOpConvert; 767 } 768 769 bool shareAcrossDWOCUs() const; 770 771 /// Returns the Dwarf Version. 772 uint16_t getDwarfVersion() const; 773 774 /// Returns a suitable DWARF form to represent a section offset, i.e. 775 /// * DW_FORM_sec_offset for DWARF version >= 4; 776 /// * DW_FORM_data8 for 64-bit DWARFv3; 777 /// * DW_FORM_data4 for 32-bit DWARFv3 and DWARFv2. 778 dwarf::Form getDwarfSectionOffsetForm() const; 779 780 /// Returns the previous CU that was being updated 781 const DwarfCompileUnit *getPrevCU() const { return PrevCU; } 782 void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; } 783 784 /// Returns the entries for the .debug_loc section. 785 const DebugLocStream &getDebugLocs() const { return DebugLocs; } 786 787 /// Emit an entry for the debug loc section. This can be used to 788 /// handle an entry that's going to be emitted into the debug loc section. 789 void emitDebugLocEntry(ByteStreamer &Streamer, 790 const DebugLocStream::Entry &Entry, 791 const DwarfCompileUnit *CU); 792 793 /// Emit the location for a debug loc entry, including the size header. 794 void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, 795 const DwarfCompileUnit *CU); 796 797 void addSubprogramNames(const DICompileUnit &CU, const DISubprogram *SP, 798 DIE &Die); 799 800 AddressPool &getAddressPool() { return AddrPool; } 801 802 void addAccelName(const DICompileUnit &CU, StringRef Name, const DIE &Die); 803 804 void addAccelObjC(const DICompileUnit &CU, StringRef Name, const DIE &Die); 805 806 void addAccelNamespace(const DICompileUnit &CU, StringRef Name, 807 const DIE &Die); 808 809 void addAccelType(const DICompileUnit &CU, StringRef Name, const DIE &Die, 810 char Flags); 811 812 const MachineFunction *getCurrentFunction() const { return CurFn; } 813 814 /// A helper function to check whether the DIE for a given Scope is 815 /// going to be null. 816 bool isLexicalScopeDIENull(LexicalScope *Scope); 817 818 /// Find the matching DwarfCompileUnit for the given CU DIE. 819 DwarfCompileUnit *lookupCU(const DIE *Die) { return CUDieMap.lookup(Die); } 820 const DwarfCompileUnit *lookupCU(const DIE *Die) const { 821 return CUDieMap.lookup(Die); 822 } 823 824 unsigned getStringTypeLoc(const DIStringType *ST) const { 825 return StringTypeLocMap.lookup(ST); 826 } 827 828 void addStringTypeLoc(const DIStringType *ST, unsigned Loc) { 829 assert(ST); 830 if (Loc) 831 StringTypeLocMap[ST] = Loc; 832 } 833 834 /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger. 835 /// 836 /// Returns whether we are "tuning" for a given debugger. 837 /// @{ 838 bool tuneForGDB() const { return DebuggerTuning == DebuggerKind::GDB; } 839 bool tuneForLLDB() const { return DebuggerTuning == DebuggerKind::LLDB; } 840 bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; } 841 bool tuneForDBX() const { return DebuggerTuning == DebuggerKind::DBX; } 842 /// @} 843 844 const MCSymbol *getSectionLabel(const MCSection *S); 845 void insertSectionLabel(const MCSymbol *S); 846 847 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, 848 const DbgValueLoc &Value, 849 DwarfExpression &DwarfExpr); 850 851 /// If the \p File has an MD5 checksum, return it as an MD5Result 852 /// allocated in the MCContext. 853 Optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const; 854}; 855 856} // end namespace llvm 857 858#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H 859