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