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 "DebugLocEntry.h"
18#include "DebugLocStream.h"
19#include "DwarfFile.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/DenseSet.h"
22#include "llvm/ADT/MapVector.h"
23#include "llvm/ADT/SetVector.h"
24#include "llvm/ADT/SmallPtrSet.h"
25#include "llvm/ADT/SmallVector.h"
26#include "llvm/ADT/StringMap.h"
27#include "llvm/ADT/StringRef.h"
28#include "llvm/BinaryFormat/Dwarf.h"
29#include "llvm/CodeGen/AccelTable.h"
30#include "llvm/CodeGen/DbgEntityHistoryCalculator.h"
31#include "llvm/CodeGen/DebugHandlerBase.h"
32#include "llvm/IR/DebugInfoMetadata.h"
33#include "llvm/IR/DebugLoc.h"
34#include "llvm/IR/Metadata.h"
35#include "llvm/MC/MCDwarf.h"
36#include "llvm/Support/Allocator.h"
37#include "llvm/Target/TargetOptions.h"
38#include <cassert>
39#include <cstdint>
40#include <limits>
41#include <memory>
42#include <utility>
43#include <variant>
44#include <vector>
45
46namespace llvm {
47
48class AsmPrinter;
49class ByteStreamer;
50class DIE;
51class DwarfCompileUnit;
52class DwarfExpression;
53class DwarfTypeUnit;
54class DwarfUnit;
55class GlobalVariable;
56class LexicalScope;
57class MachineFunction;
58class MCSection;
59class MCSymbol;
60class Module;
61
62//===----------------------------------------------------------------------===//
63/// This class is defined as the common parent of DbgVariable and DbgLabel
64/// such that it could levarage polymorphism to extract common code for
65/// DbgVariable and DbgLabel.
66class DbgEntity {
67public:
68 enum DbgEntityKind {
69 DbgVariableKind,
70 DbgLabelKind
71 };
72
73private:
74 const DINode *Entity;
75 const DILocation *InlinedAt;
76 DIE *TheDIE = nullptr;
77 const DbgEntityKind SubclassID;
78
79public:
80 DbgEntity(const DINode *N, const DILocation *IA, DbgEntityKind ID)
81 : Entity(N), InlinedAt(IA), SubclassID(ID) {}
82 virtual ~DbgEntity() = default;
83
84 /// Accessors.
85 /// @{
86 const DINode *getEntity() const { return Entity; }
87 const DILocation *getInlinedAt() const { return InlinedAt; }
88 DIE *getDIE() const { return TheDIE; }
89 DbgEntityKind getDbgEntityID() const { return SubclassID; }
90 /// @}
91
92 void setDIE(DIE &D) { TheDIE = &D; }
93
94 static bool classof(const DbgEntity *N) {
95 switch (N->getDbgEntityID()) {
96 case DbgVariableKind:
97 case DbgLabelKind:
98 return true;
99 }
100 llvm_unreachable("Invalid DbgEntityKind");
101 }
102};
103
104class DbgVariable;
105
106bool operator<(const struct FrameIndexExpr &LHS,
107 const struct FrameIndexExpr &RHS);
108bool operator<(const struct EntryValueInfo &LHS,
109 const struct EntryValueInfo &RHS);
110
111/// Proxy for one MMI entry.
112struct FrameIndexExpr {
113 int FI;
114 const DIExpression *Expr;
115
116 /// Operator enabling sorting based on fragment offset.
117 friend bool operator<(const FrameIndexExpr &LHS, const FrameIndexExpr &RHS);
118};
119
120/// Represents an entry-value location, or a fragment of one.
121struct EntryValueInfo {
122 MCRegister Reg;
123 const DIExpression &Expr;
124
125 /// Operator enabling sorting based on fragment offset.
126 friend bool operator<(const EntryValueInfo &LHS, const EntryValueInfo &RHS);
127};
128
129// Namespace for alternatives of a DbgVariable.
130namespace Loc {
131/// Single value location description.
132class Single {
133 std::unique_ptr<DbgValueLoc> ValueLoc;
134 const DIExpression *Expr;
135
136public:
137 explicit Single(DbgValueLoc ValueLoc);
138 explicit Single(const MachineInstr *DbgValue);
139 const DbgValueLoc &getValueLoc() const { return *ValueLoc; }
140 const DIExpression *getExpr() const { return Expr; }
141};
142/// Multi-value location description.
143class Multi {
144 /// Index of the entry list in DebugLocs.
145 unsigned DebugLocListIndex;
146 /// DW_OP_LLVM_tag_offset value from DebugLocs.
147 std::optional<uint8_t> DebugLocListTagOffset;
148
149public:
150 explicit Multi(unsigned DebugLocListIndex,
151 std::optional<uint8_t> DebugLocListTagOffset)
152 : DebugLocListIndex(DebugLocListIndex),
153 DebugLocListTagOffset(DebugLocListTagOffset) {}
154 unsigned getDebugLocListIndex() const { return DebugLocListIndex; }
155 std::optional<uint8_t> getDebugLocListTagOffset() const {
156 return DebugLocListTagOffset;
157 }
158};
159/// Single location defined by (potentially multiple) MMI entries.
160struct MMI {
161 std::set<FrameIndexExpr> FrameIndexExprs;
162
163public:
164 explicit MMI(const DIExpression *E, int FI) : FrameIndexExprs({{.FI: FI, .Expr: E}}) {
165 assert((!E || E->isValid()) && "Expected valid expression");
166 assert(FI != std::numeric_limits<int>::max() && "Expected valid index");
167 }
168 void addFrameIndexExpr(const DIExpression *Expr, int FI);
169 /// Get the FI entries, sorted by fragment offset.
170 const std::set<FrameIndexExpr> &getFrameIndexExprs() const;
171};
172/// Single location defined by (potentially multiple) EntryValueInfo.
173struct EntryValue {
174 std::set<EntryValueInfo> EntryValues;
175 explicit EntryValue(MCRegister Reg, const DIExpression &Expr) {
176 addExpr(Reg, Expr);
177 };
178 // Add the pair Reg, Expr to the list of entry values describing the variable.
179 // If multiple expressions are added, it is the callers responsibility to
180 // ensure they are all non-overlapping fragments.
181 void addExpr(MCRegister Reg, const DIExpression &Expr) {
182 std::optional<const DIExpression *> NonVariadicExpr =
183 DIExpression::convertToNonVariadicExpression(Expr: &Expr);
184 assert(NonVariadicExpr && *NonVariadicExpr);
185
186 EntryValues.insert(x: {.Reg: Reg, .Expr: **NonVariadicExpr});
187 }
188};
189/// Alias for the std::variant specialization base class of DbgVariable.
190using Variant = std::variant<std::monostate, Loc::Single, Loc::Multi, Loc::MMI,
191 Loc::EntryValue>;
192} // namespace Loc
193
194//===----------------------------------------------------------------------===//
195/// This class is used to track local variable information.
196///
197/// Variables that have been optimized out hold the \c monostate alternative.
198/// This is not distinguished from the case of a constructed \c DbgVariable
199/// which has not be initialized yet.
200///
201/// Variables can be created from allocas, in which case they're generated from
202/// the MMI table. Such variables hold the \c Loc::MMI alternative which can
203/// have multiple expressions and frame indices.
204///
205/// Variables can be created from the entry value of registers, in which case
206/// they're generated from the MMI table. Such variables hold the \c
207/// EntryValueLoc alternative which can either have a single expression or
208/// multiple *fragment* expressions.
209///
210/// Variables can be created from \c DBG_VALUE instructions. Those whose
211/// location changes over time hold a \c Loc::Multi alternative which uses \c
212/// DebugLocListIndex and (optionally) \c DebugLocListTagOffset, while those
213/// with a single location hold a \c Loc::Single alternative which use \c
214/// ValueLoc and (optionally) a single \c Expr.
215class DbgVariable : public DbgEntity, public Loc::Variant {
216
217public:
218 /// To workaround P2162R0 https://github.com/cplusplus/papers/issues/873 the
219 /// base class subobject needs to be passed directly to std::visit, so expose
220 /// it directly here.
221 Loc::Variant &asVariant() { return *static_cast<Loc::Variant *>(this); }
222 const Loc::Variant &asVariant() const {
223 return *static_cast<const Loc::Variant *>(this);
224 }
225 /// Member shorthand for std::holds_alternative
226 template <typename T> bool holds() const {
227 return std::holds_alternative<T>(*this);
228 }
229 /// Asserting, noexcept member alternative to std::get
230 template <typename T> auto &get() noexcept {
231 assert(holds<T>());
232 return *std::get_if<T>(this);
233 }
234 /// Asserting, noexcept member alternative to std::get
235 template <typename T> const auto &get() const noexcept {
236 assert(holds<T>());
237 return *std::get_if<T>(this);
238 }
239
240 /// Construct a DbgVariable.
241 ///
242 /// Creates a variable without any DW_AT_location.
243 DbgVariable(const DILocalVariable *V, const DILocation *IA)
244 : DbgEntity(V, IA, DbgVariableKind) {}
245
246 // Accessors.
247 const DILocalVariable *getVariable() const {
248 return cast<DILocalVariable>(Val: getEntity());
249 }
250
251 StringRef getName() const { return getVariable()->getName(); }
252
253 // Translate tag to proper Dwarf tag.
254 dwarf::Tag getTag() const {
255 // FIXME: Why don't we just infer this tag and store it all along?
256 if (getVariable()->isParameter())
257 return dwarf::DW_TAG_formal_parameter;
258
259 return dwarf::DW_TAG_variable;
260 }
261
262 /// Return true if DbgVariable is artificial.
263 bool isArtificial() const {
264 if (getVariable()->isArtificial())
265 return true;
266 if (getType()->isArtificial())
267 return true;
268 return false;
269 }
270
271 bool isObjectPointer() const {
272 if (getVariable()->isObjectPointer())
273 return true;
274 if (getType()->isObjectPointer())
275 return true;
276 return false;
277 }
278
279 const DIType *getType() const;
280
281 static bool classof(const DbgEntity *N) {
282 return N->getDbgEntityID() == DbgVariableKind;
283 }
284};
285
286//===----------------------------------------------------------------------===//
287/// This class is used to track label information.
288///
289/// Labels are collected from \c DBG_LABEL instructions.
290class DbgLabel : public DbgEntity {
291 const MCSymbol *Sym; /// Symbol before DBG_LABEL instruction.
292
293public:
294 /// We need MCSymbol information to generate DW_AT_low_pc.
295 DbgLabel(const DILabel *L, const DILocation *IA, const MCSymbol *Sym = nullptr)
296 : DbgEntity(L, IA, DbgLabelKind), Sym(Sym) {}
297
298 /// Accessors.
299 /// @{
300 const DILabel *getLabel() const { return cast<DILabel>(Val: getEntity()); }
301 const MCSymbol *getSymbol() const { return Sym; }
302
303 StringRef getName() const { return getLabel()->getName(); }
304 /// @}
305
306 /// Translate tag to proper Dwarf tag.
307 dwarf::Tag getTag() const {
308 return dwarf::DW_TAG_label;
309 }
310
311 static bool classof(const DbgEntity *N) {
312 return N->getDbgEntityID() == DbgLabelKind;
313 }
314};
315
316/// Used for tracking debug info about call site parameters.
317class DbgCallSiteParam {
318private:
319 unsigned Register; ///< Parameter register at the callee entry point.
320 DbgValueLoc Value; ///< Corresponding location for the parameter value at
321 ///< the call site.
322public:
323 DbgCallSiteParam(unsigned Reg, DbgValueLoc Val)
324 : Register(Reg), Value(Val) {
325 assert(Reg && "Parameter register cannot be undef");
326 }
327
328 unsigned getRegister() const { return Register; }
329 DbgValueLoc getValue() const { return Value; }
330};
331
332/// Collection used for storing debug call site parameters.
333using ParamSet = SmallVector<DbgCallSiteParam, 4>;
334
335/// Helper used to pair up a symbol and its DWARF compile unit.
336struct SymbolCU {
337 SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {}
338
339 const MCSymbol *Sym;
340 DwarfCompileUnit *CU;
341};
342
343/// The kind of accelerator tables we should emit.
344enum class AccelTableKind {
345 Default, ///< Platform default.
346 None, ///< None.
347 Apple, ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
348 Dwarf, ///< DWARF v5 .debug_names.
349};
350
351/// Collects and handles dwarf debug information.
352class DwarfDebug : public DebugHandlerBase {
353 /// All DIEValues are allocated through this allocator.
354 BumpPtrAllocator DIEValueAllocator;
355
356 /// Maps MDNode with its corresponding DwarfCompileUnit.
357 MapVector<const MDNode *, DwarfCompileUnit *> CUMap;
358
359 /// Maps a CU DIE with its corresponding DwarfCompileUnit.
360 DenseMap<const DIE *, DwarfCompileUnit *> CUDieMap;
361
362 /// List of all labels used in aranges generation.
363 std::vector<SymbolCU> ArangeLabels;
364
365 /// Size of each symbol emitted (for those symbols that have a specific size).
366 DenseMap<const MCSymbol *, uint64_t> SymSize;
367
368 /// Collection of abstract variables/labels.
369 SmallVector<std::unique_ptr<DbgEntity>, 64> ConcreteEntities;
370
371 /// Collection of DebugLocEntry. Stored in a linked list so that DIELocLists
372 /// can refer to them in spite of insertions into this list.
373 DebugLocStream DebugLocs;
374
375 /// This is a collection of subprogram MDNodes that are processed to
376 /// create DIEs.
377 SmallSetVector<const DISubprogram *, 16> ProcessedSPNodes;
378
379 /// Whether all functions of the module have been processed, so that it is
380 /// known which subprograms have abstract DIEs.
381 bool AllFunctionsProcessed = false;
382
383 /// Map function-local imported entities to their parent local scope
384 /// (either DILexicalBlock or DISubprogram) for a processed function
385 /// (including inlined subprograms).
386 using MDNodeSet = SetVector<const MDNode *, SmallVector<const MDNode *, 2>,
387 SmallPtrSet<const MDNode *, 2>>;
388 DenseMap<const DILocalScope *, MDNodeSet> LocalDeclsPerLS;
389
390 SmallDenseSet<const MachineInstr *> ForceIsStmtInstrs;
391
392 /// If nonnull, stores the current machine function we're processing.
393 const MachineFunction *CurFn = nullptr;
394
395 /// If nonnull, stores the CU in which the previous subprogram was contained.
396 const DwarfCompileUnit *PrevCU = nullptr;
397
398 /// As an optimization, there is no need to emit an entry in the directory
399 /// table for the same directory as DW_AT_comp_dir.
400 StringRef CompilationDir;
401
402 /// Holders for the various debug information flags that we might need to
403 /// have exposed. See accessor functions below for description.
404
405 /// Map from MDNodes for user-defined types to their type signatures. Also
406 /// used to keep track of which types we have emitted type units for.
407 DenseMap<const MDNode *, uint64_t> TypeSignatures;
408
409 DenseMap<const MCSection *, const MCSymbol *> SectionLabels;
410
411 SmallVector<
412 std::pair<std::unique_ptr<DwarfTypeUnit>, const DICompositeType *>, 1>
413 TypeUnitsUnderConstruction;
414
415 /// Symbol pointing to the current function's DWARF line table entries.
416 MCSymbol *FunctionLineTableLabel;
417
418 /// Used to set a uniqe ID for a Type Unit.
419 /// This counter represents number of DwarfTypeUnits created, not necessarily
420 /// number of type units that will be emitted.
421 unsigned NumTypeUnitsCreated = 0;
422
423 /// Whether to use the GNU TLS opcode (instead of the standard opcode).
424 bool UseGNUTLSOpcode;
425
426 /// Whether to use DWARF 2 bitfields (instead of the DWARF 4 format).
427 bool UseDWARF2Bitfields;
428
429 /// Whether to emit all linkage names, or just abstract subprograms.
430 bool UseAllLinkageNames;
431
432 /// Use inlined strings.
433 bool UseInlineStrings = false;
434
435 /// Allow emission of .debug_ranges section.
436 bool UseRangesSection = true;
437
438 /// True if the sections itself must be used as references and don't create
439 /// temp symbols inside DWARF sections.
440 bool UseSectionsAsReferences = false;
441
442 /// Allow emission of .debug_aranges section
443 bool UseARangesSection = false;
444
445 /// Generate DWARF v4 type units.
446 bool GenerateTypeUnits;
447
448 /// Emit a .debug_macro section instead of .debug_macinfo.
449 bool UseDebugMacroSection;
450
451 /// Avoid using DW_OP_convert due to consumer incompatibilities.
452 bool EnableOpConvert;
453
454public:
455 enum class MinimizeAddrInV5 {
456 Default,
457 Disabled,
458 Ranges,
459 Expressions,
460 Form,
461 };
462
463 enum class DWARF5AccelTableKind {
464 CU = 0,
465 TU = 1,
466 };
467
468private:
469 /// Instructions which should get is_stmt applied because they implement key
470 /// functionality for a source atom.
471 SmallDenseSet<const MachineInstr *> KeyInstructions;
472
473 /// Force the use of DW_AT_ranges even for single-entry range lists.
474 MinimizeAddrInV5 MinimizeAddr = MinimizeAddrInV5::Disabled;
475
476 /// DWARF5 Experimental Options
477 /// @{
478 AccelTableKind TheAccelTableKind;
479 bool HasAppleExtensionAttributes;
480 bool HasSplitDwarf;
481
482 /// Whether to generate the DWARF v5 string offsets table.
483 /// It consists of a series of contributions, each preceded by a header.
484 /// The pre-DWARF v5 string offsets table for split dwarf is, in contrast,
485 /// a monolithic sequence of string offsets.
486 bool UseSegmentedStringOffsetsTable;
487
488 /// Enable production of call site parameters needed to print the debug entry
489 /// values. Useful for testing purposes when a debugger does not support the
490 /// feature yet.
491 bool EmitDebugEntryValues;
492
493 /// Separated Dwarf Variables
494 /// In general these will all be for bits that are left in the
495 /// original object file, rather than things that are meant
496 /// to be in the .dwo sections.
497
498 /// Holder for the skeleton information.
499 DwarfFile SkeletonHolder;
500
501 /// Store file names for type units under fission in a line table
502 /// header that will be emitted into debug_line.dwo.
503 // FIXME: replace this with a map from comp_dir to table so that we
504 // can emit multiple tables during LTO each of which uses directory
505 // 0, referencing the comp_dir of all the type units that use it.
506 MCDwarfDwoLineTable SplitTypeUnitFileTable;
507 /// @}
508
509 /// True iff there are multiple CUs in this module.
510 bool SingleCU;
511 bool IsDarwin;
512
513 AddressPool AddrPool;
514
515 /// Accelerator tables.
516 DWARF5AccelTable AccelDebugNames;
517 DWARF5AccelTable AccelTypeUnitsDebugNames;
518 /// Used to hide which DWARF5AccelTable we are using now.
519 DWARF5AccelTable *CurrentDebugNames = &AccelDebugNames;
520 AccelTable<AppleAccelTableOffsetData> AccelNames;
521 AccelTable<AppleAccelTableOffsetData> AccelObjC;
522 AccelTable<AppleAccelTableOffsetData> AccelNamespace;
523 AccelTable<AppleAccelTableTypeData> AccelTypes;
524
525 /// Identify a debugger for "tuning" the debug info.
526 ///
527 /// The "tuning" should be used to set defaults for individual feature flags
528 /// in DwarfDebug; if a given feature has a more specific command-line option,
529 /// that option should take precedence over the tuning.
530 DebuggerKind DebuggerTuning = DebuggerKind::Default;
531
532 MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &);
533
534 using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
535
536 void ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU,
537 const DINode *Node,
538 const MDNode *Scope);
539
540 DbgEntity *createConcreteEntity(DwarfCompileUnit &TheCU,
541 LexicalScope &Scope,
542 const DINode *Node,
543 const DILocation *Location,
544 const MCSymbol *Sym = nullptr);
545
546 /// Construct a DIE for this abstract scope.
547 void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope);
548
549 /// Construct DIEs for call site entries describing the calls in \p MF.
550 void constructCallSiteEntryDIEs(const DISubprogram &SP, DwarfCompileUnit &CU,
551 DIE &ScopeDIE, const MachineFunction &MF);
552
553 template <typename DataT>
554 void addAccelNameImpl(const DwarfUnit &Unit,
555 const DICompileUnit::DebugNameTableKind NameTableKind,
556 AccelTable<DataT> &AppleAccel, StringRef Name,
557 const DIE &Die);
558
559 void finishEntityDefinitions();
560
561 void finishSubprogramDefinitions();
562
563 /// Finish off debug information after all functions have been
564 /// processed.
565 void finalizeModuleInfo();
566
567 /// Emit the debug info section.
568 void emitDebugInfo();
569
570 /// Emit the abbreviation section.
571 void emitAbbreviations();
572
573 /// Emit the string offsets table header.
574 void emitStringOffsetsTableHeader();
575
576 /// Emit a specified accelerator table.
577 template <typename AccelTableT>
578 void emitAccel(AccelTableT &Accel, MCSection *Section, StringRef TableName);
579
580 /// Emit DWARF v5 accelerator table.
581 void emitAccelDebugNames();
582
583 /// Emit visible names into a hashed accelerator table section.
584 void emitAccelNames();
585
586 /// Emit objective C classes and categories into a hashed
587 /// accelerator table section.
588 void emitAccelObjC();
589
590 /// Emit namespace dies into a hashed accelerator table.
591 void emitAccelNamespaces();
592
593 /// Emit type dies into a hashed accelerator table.
594 void emitAccelTypes();
595
596 /// Emit visible names and types into debug pubnames and pubtypes sections.
597 void emitDebugPubSections();
598
599 void emitDebugPubSection(bool GnuStyle, StringRef Name,
600 DwarfCompileUnit *TheU,
601 const StringMap<const DIE *> &Globals);
602
603 /// Emit null-terminated strings into a debug str section.
604 void emitDebugStr();
605
606 /// Emit variable locations into a debug loc section.
607 void emitDebugLoc();
608
609 /// Emit variable locations into a debug loc dwo section.
610 void emitDebugLocDWO();
611
612 void emitDebugLocImpl(MCSection *Sec);
613
614 /// Emit address ranges into a debug aranges section.
615 void emitDebugARanges();
616
617 /// Emit address ranges into a debug ranges section.
618 void emitDebugRanges();
619 void emitDebugRangesDWO();
620 void emitDebugRangesImpl(const DwarfFile &Holder, MCSection *Section);
621
622 /// Emit macros into a debug macinfo section.
623 void emitDebugMacinfo();
624 /// Emit macros into a debug macinfo.dwo section.
625 void emitDebugMacinfoDWO();
626 void emitDebugMacinfoImpl(MCSection *Section);
627 void emitMacro(DIMacro &M);
628 void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U);
629 void emitMacroFileImpl(DIMacroFile &F, DwarfCompileUnit &U,
630 unsigned StartFile, unsigned EndFile,
631 StringRef (*MacroFormToString)(unsigned Form));
632 void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U);
633
634 /// DWARF 5 Experimental Split Dwarf Emitters
635
636 /// Initialize common features of skeleton units.
637 void initSkeletonUnit(const DwarfUnit &U, DIE &Die,
638 std::unique_ptr<DwarfCompileUnit> NewU);
639
640 /// Construct the split debug info compile unit for the debug info section.
641 /// In DWARF v5, the skeleton unit DIE may have the following attributes:
642 /// DW_AT_addr_base, DW_AT_comp_dir, DW_AT_dwo_name, DW_AT_high_pc,
643 /// DW_AT_low_pc, DW_AT_ranges, DW_AT_stmt_list, and DW_AT_str_offsets_base.
644 /// Prior to DWARF v5 it may also have DW_AT_GNU_dwo_id. DW_AT_GNU_dwo_name
645 /// is used instead of DW_AT_dwo_name, Dw_AT_GNU_addr_base instead of
646 /// DW_AT_addr_base, and DW_AT_GNU_ranges_base instead of DW_AT_rnglists_base.
647 DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU);
648
649 /// Emit the debug info dwo section.
650 void emitDebugInfoDWO();
651
652 /// Emit the debug abbrev dwo section.
653 void emitDebugAbbrevDWO();
654
655 /// Emit the debug line dwo section.
656 void emitDebugLineDWO();
657
658 /// Emit the dwo stringoffsets table header.
659 void emitStringOffsetsTableHeaderDWO();
660
661 /// Emit the debug str dwo section.
662 void emitDebugStrDWO();
663
664 /// Emit DWO addresses.
665 void emitDebugAddr();
666
667 /// Flags to let the linker know we have emitted new style pubnames. Only
668 /// emit it here if we don't have a skeleton CU for split dwarf.
669 void addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const;
670
671 DwarfCompileUnit *getDwarfCompileUnit(const DICompileUnit *DIUnit);
672 /// Create new DwarfCompileUnit for the given metadata node with tag
673 /// DW_TAG_compile_unit.
674 DwarfCompileUnit &getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit);
675 void finishUnitAttributes(const DICompileUnit *DIUnit,
676 DwarfCompileUnit &NewCU);
677
678 /// Register a source line with debug info. Returns the unique
679 /// label that was emitted and which provides correspondence to the
680 /// source line list.
681 void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
682 unsigned Flags, StringRef Location = {});
683
684 /// Populate LexicalScope entries with variables' info.
685 void collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP,
686 DenseSet<InlinedEntity> &ProcessedVars);
687
688 /// Build the location list for all DBG_VALUEs in the
689 /// function that describe the same variable. If the resulting
690 /// list has only one entry that is valid for entire variable's
691 /// scope return true.
692 bool buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
693 const DbgValueHistoryMap::Entries &Entries);
694
695 /// Collect variable information from the side table maintained by MF.
696 void collectVariableInfoFromMFTable(DwarfCompileUnit &TheCU,
697 DenseSet<InlinedEntity> &P);
698
699 /// Emit the reference to the section.
700 void emitSectionReference(const DwarfCompileUnit &CU);
701
702 void findForceIsStmtInstrs(const MachineFunction *MF);
703
704 /// Compute instructions which should get is_stmt applied because they
705 /// implement key functionality for a source location atom, store results in
706 /// DwarfDebug::KeyInstructions.
707 void computeKeyInstructions(const MachineFunction *MF);
708
709protected:
710 /// Holder for the file specific debug information.
711 DwarfFile InfoHolder;
712 /// Gather pre-function debug information.
713 void beginFunctionImpl(const MachineFunction *MF) override;
714
715 /// Gather and emit post-function debug information.
716 void endFunctionImpl(const MachineFunction *MF) override;
717
718 /// Get Dwarf compile unit ID for line table.
719 unsigned getDwarfCompileUnitIDForLineTable(const DwarfCompileUnit &CU);
720
721 void skippedNonDebugFunction() override;
722
723 /// Target-specific debug info initialization at function start.
724 virtual void initializeTargetDebugInfo(const MachineFunction &MF) {}
725
726 /// Setters for target-specific DWARF configuration overrides.
727 /// Called from target DwarfDebug subclass constructors.
728 void setUseInlineStrings(bool V) { UseInlineStrings = V; }
729 void setUseRangesSection(bool V) { UseRangesSection = V; }
730 void setUseSectionsAsReferences(bool V) { UseSectionsAsReferences = V; }
731
732 /// Select \p DwarfVersion and (re)compute all state derived from it. Called
733 /// by the constructor; a target subclass may call it again to change the
734 /// version, which keeps the derived state consistent with the emitted one.
735 void applyDwarfVersion(unsigned DwarfVersion);
736
737 /// Whether to attach ranges/low_pc to the compile unit DIE in endModule.
738 virtual bool shouldAttachCompileUnitRanges() const { return true; }
739
740 /// Target-specific source line recording.
741 virtual void recordTargetSourceLine(const DebugLoc &DL, unsigned Flags);
742
743 /// Target-specific compile unit attribute finalization.
744 virtual void finishTargetUnitAttributes(const DICompileUnit &DIUnit,
745 DwarfCompileUnit &NewCU) {}
746
747 const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() {
748 return InfoHolder.getUnits();
749 }
750
751public:
752 //===--------------------------------------------------------------------===//
753 // Target hooks for debug info customization.
754 //
755
756 /// Whether the target requires resetting the base address in range/loc lists.
757 virtual bool shouldResetBaseAddress(const MCSection &Section) const {
758 return false;
759 }
760
761 /// Describes the storage kind of a debug variable for target hooks.
762 enum class VariableLocationKind { Global, Register, FrameIndex };
763
764 /// Extract target-specific address space information from a DIExpression.
765 /// Targets may strip address-space-encoding ops from the expression and
766 /// return the address space via \p TargetAddrSpace.
767 virtual const DIExpression *
768 adjustExpressionForTarget(const DIExpression *Expr,
769 std::optional<unsigned> &TargetAddrSpace) const {
770 return Expr;
771 }
772
773 /// Add target-specific attributes to a variable DIE (e.g.
774 /// DW_AT_address_class).
775 virtual void
776 addTargetVariableAttributes(DwarfCompileUnit &CU, DIE &Die,
777 std::optional<unsigned> TargetAddrSpace,
778 VariableLocationKind VarLocKind,
779 const GlobalVariable *GV = nullptr) const {}
780
781 //===--------------------------------------------------------------------===//
782 // Main entry points.
783 //
784 DwarfDebug(AsmPrinter *A);
785
786 ~DwarfDebug() override;
787
788 /// Emit all Dwarf sections that should come prior to the
789 /// content.
790 void beginModule(Module *M) override;
791
792 /// Emit all Dwarf sections that should come after the content.
793 void endModule() override;
794
795 /// Emits inital debug location directive. Returns instruction at which
796 /// the function prologue ends.
797 const MachineInstr *emitInitialLocDirective(const MachineFunction &MF,
798 unsigned CUID);
799
800 /// Process beginning of an instruction.
801 void beginInstruction(const MachineInstr *MI) override;
802
803 /// Process beginning of code alignment.
804 void beginCodeAlignment(const MachineBasicBlock &MBB) override;
805
806 /// Perform an MD5 checksum of \p Identifier and return the lower 64 bits.
807 static uint64_t makeTypeSignature(StringRef Identifier);
808
809 /// Add a DIE to the set of types that we're going to pull into
810 /// type units.
811 void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier,
812 DIE &Die, const DICompositeType *CTy);
813
814 /// Add a label so that arange data can be generated for it.
815 void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(x: SCU); }
816
817 /// For symbols that have a size designated (e.g. common symbols),
818 /// this tracks that size.
819 void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
820 SymSize[Sym] = Size;
821 }
822
823 /// Whether to emit .debug_pubnames / .debug_pubtypes. Default true;
824 virtual bool shouldEmitDwarfPubSections() const { return true; }
825
826 /// Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
827 /// If not, we still might emit certain cases.
828 bool useAllLinkageNames() const { return UseAllLinkageNames; }
829
830 /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the
831 /// standard DW_OP_form_tls_address opcode
832 bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; }
833
834 /// Returns whether to use the DWARF2 format for bitfields instyead of the
835 /// DWARF4 format.
836 bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; }
837
838 /// Returns whether to use inline strings.
839 bool useInlineStrings() const { return UseInlineStrings; }
840
841 /// Returns whether ranges section should be emitted.
842 bool useRangesSection() const { return UseRangesSection; }
843
844 /// Returns whether range encodings should be used for single entry range
845 /// lists.
846 bool alwaysUseRanges(const DwarfCompileUnit &) const;
847
848 // Returns whether novel exprloc addrx+offset encodings should be used to
849 // reduce debug_addr size.
850 bool useAddrOffsetExpressions() const {
851 return MinimizeAddr == MinimizeAddrInV5::Expressions;
852 }
853
854 // Returns whether addrx+offset LLVM extension form should be used to reduce
855 // debug_addr size.
856 bool useAddrOffsetForm() const {
857 return MinimizeAddr == MinimizeAddrInV5::Form;
858 }
859
860 /// Returns whether to use sections as labels rather than temp symbols.
861 bool useSectionsAsReferences() const {
862 return UseSectionsAsReferences;
863 }
864
865 /// Returns whether to generate DWARF v4 type units.
866 bool generateTypeUnits() const { return GenerateTypeUnits; }
867
868 // Experimental DWARF5 features.
869
870 /// Returns what kind (if any) of accelerator tables to emit.
871 AccelTableKind getAccelTableKind() const { return TheAccelTableKind; }
872
873 /// Seet TheAccelTableKind
874 void setTheAccelTableKind(AccelTableKind K) { TheAccelTableKind = K; };
875
876 bool useAppleExtensionAttributes() const {
877 return HasAppleExtensionAttributes;
878 }
879
880 /// Returns whether or not to change the current debug info for split DWARF.
881 bool useSplitDwarf() const { return HasSplitDwarf; }
882
883 /// Returns whether to generate a string offsets table with (possibly shared)
884 /// contributions from each CU and type unit. This implies the use of
885 /// DW_FORM_strx* indirect references with DWARF v5 and beyond. Note that
886 /// DW_FORM_GNU_str_index is also an indirect reference, but it is used with
887 /// a pre-DWARF v5 implementation of split DWARF sections, which uses a
888 /// monolithic string offsets table.
889 bool useSegmentedStringOffsetsTable() const {
890 return UseSegmentedStringOffsetsTable;
891 }
892
893 bool emitDebugEntryValues() const {
894 return EmitDebugEntryValues;
895 }
896
897 bool useOpConvert() const {
898 return EnableOpConvert;
899 }
900
901 bool shareAcrossDWOCUs() const;
902
903 /// Returns the Dwarf Version.
904 uint16_t getDwarfVersion() const;
905
906 /// Returns a suitable DWARF form to represent a section offset, i.e.
907 /// * DW_FORM_sec_offset for DWARF version >= 4;
908 /// * DW_FORM_data8 for 64-bit DWARFv3;
909 /// * DW_FORM_data4 for 32-bit DWARFv3 and DWARFv2.
910 dwarf::Form getDwarfSectionOffsetForm() const;
911
912 /// Returns the previous CU that was being updated
913 const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
914 void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }
915
916 /// Terminate the line table by adding the last range label.
917 void terminateLineTable(const DwarfCompileUnit *CU);
918
919 /// Returns the entries for the .debug_loc section.
920 const DebugLocStream &getDebugLocs() const { return DebugLocs; }
921
922 /// Emit an entry for the debug loc section. This can be used to
923 /// handle an entry that's going to be emitted into the debug loc section.
924 void emitDebugLocEntry(ByteStreamer &Streamer,
925 const DebugLocStream::Entry &Entry,
926 const DwarfCompileUnit *CU);
927
928 /// Emit the location for a debug loc entry, including the size header.
929 void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
930 const DwarfCompileUnit *CU);
931
932 void addSubprogramNames(const DwarfUnit &Unit,
933 const DICompileUnit::DebugNameTableKind NameTableKind,
934 const DISubprogram *SP, DIE &Die);
935
936 AddressPool &getAddressPool() { return AddrPool; }
937
938 void addAccelName(const DwarfUnit &Unit,
939 const DICompileUnit::DebugNameTableKind NameTableKind,
940 StringRef Name, const DIE &Die);
941
942 void addAccelObjC(const DwarfUnit &Unit,
943 const DICompileUnit::DebugNameTableKind NameTableKind,
944 StringRef Name, const DIE &Die);
945
946 void addAccelNamespace(const DwarfUnit &Unit,
947 const DICompileUnit::DebugNameTableKind NameTableKind,
948 StringRef Name, const DIE &Die);
949
950 void addAccelType(const DwarfUnit &Unit,
951 const DICompileUnit::DebugNameTableKind NameTableKind,
952 StringRef Name, const DIE &Die, char Flags);
953
954 const MachineFunction *getCurrentFunction() const { return CurFn; }
955
956 /// A helper function to check whether the DIE for a given Scope is
957 /// going to be null.
958 bool isLexicalScopeDIENull(LexicalScope *Scope);
959
960 /// Find the matching DwarfCompileUnit for the given CU DIE.
961 DwarfCompileUnit *lookupCU(const DIE *Die) { return CUDieMap.lookup(Val: Die); }
962 const DwarfCompileUnit *lookupCU(const DIE *Die) const {
963 return CUDieMap.lookup(Val: Die);
964 }
965
966 /// Find the matching DwarfCompileUnit for the given SP referenced from SrcCU.
967 DwarfCompileUnit &getOrCreateAbstractSubprogramCU(const DISubprogram *SP,
968 DwarfCompileUnit &SrcCU);
969
970 /// Returns whether all functions of the module have been processed, so that
971 /// abstract subprogram DIEs are not created for inlined subprograms anymore.
972 bool allFunctionsProcessed() const { return AllFunctionsProcessed; }
973
974 /// Returns whether a DIE for the function of \p SP has been constructed.
975 bool isProcessedSubprogram(const DISubprogram *SP) const {
976 return ProcessedSPNodes.contains(key: SP);
977 }
978
979 /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger.
980 ///
981 /// Returns whether we are "tuning" for a given debugger.
982 /// @{
983 bool tuneForGDB() const { return DebuggerTuning == DebuggerKind::GDB; }
984 bool tuneForLLDB() const { return DebuggerTuning == DebuggerKind::LLDB; }
985 bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; }
986 bool tuneForDBX() const { return DebuggerTuning == DebuggerKind::DBX; }
987 /// @}
988
989 const MCSymbol *getSectionLabel(const MCSection *S);
990 void insertSectionLabel(const MCSymbol *S);
991
992 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
993 const DbgValueLoc &Value,
994 DwarfExpression &DwarfExpr);
995
996 /// If the \p File has an MD5 checksum, return it as an MD5Result
997 /// allocated in the MCContext.
998 std::optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const;
999
1000 MDNodeSet &getLocalDeclsForScope(const DILocalScope *S) {
1001 return LocalDeclsPerLS[S];
1002 }
1003
1004 /// Sets the current DWARF5AccelTable to use.
1005 void setCurrentDWARF5AccelTable(const DWARF5AccelTableKind Kind) {
1006 switch (Kind) {
1007 case DWARF5AccelTableKind::CU:
1008 CurrentDebugNames = &AccelDebugNames;
1009 break;
1010 case DWARF5AccelTableKind::TU:
1011 CurrentDebugNames = &AccelTypeUnitsDebugNames;
1012 }
1013 }
1014 /// Returns either CU or TU DWARF5AccelTable.
1015 DWARF5AccelTable &getCurrentDWARF5AccelTable() { return *CurrentDebugNames; }
1016};
1017
1018} // end namespace llvm
1019
1020#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
1021