LLVM 19.0.0git
DwarfDebug.h
Go to the documentation of this file.
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"
26#include "llvm/ADT/StringMap.h"
27#include "llvm/ADT/StringRef.h"
33#include "llvm/IR/DebugLoc.h"
34#include "llvm/IR/Metadata.h"
35#include "llvm/MC/MCDwarf.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:
70 };
71
72private:
73 const DINode *Entity;
74 const DILocation *InlinedAt;
75 DIE *TheDIE = nullptr;
76 const DbgEntityKind SubclassID;
77
78public:
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.
112 int FI;
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.
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.
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 =
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,
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.
243 : DbgEntity(V, IA, DbgVariableKind) {}
244
245 // Accessors.
247 return cast<DILocalVariable>(getEntity());
248 }
249
250 StringRef getName() const { return getVariable()->getName(); }
251
252 // Translate tag to proper Dwarf tag.
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 {
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.
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.
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:
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.
333
334/// Helper used to pair up a symbol and its DWARF compile unit.
335struct SymbolCU {
337
338 const MCSymbol *Sym;
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.
352 /// All DIEValues are allocated through this allocator.
353 BumpPtrAllocator DIEValueAllocator;
354
355 /// Maps MDNode with its corresponding DwarfCompileUnit.
357
358 /// Maps a CU DIE with its corresponding DwarfCompileUnit.
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).
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.
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).
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.
404
406
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,
453 Form,
454 };
455
457 CU = 0,
458 TU = 1,
459 };
460
461private:
462 /// Force the use of DW_AT_ranges even for single-entry range lists.
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.
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;
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
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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
923 return LocalDeclsPerLS[S];
924 }
925
926 /// Sets the current DWARF5AccelTable to use.
928 switch (Kind) {
930 CurrentDebugNames = &AccelDebugNames;
931 break;
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
aarch64 promote const
This file defines the StringMap class.
This file contains support for writing accelerator tables.
This file defines the BumpPtrAllocator interface.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
This file contains constants used for implementing Dwarf debug support.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
Machine Check Debug Module
unsigned Reg
This file implements a map that provides insertion order iteration.
This file contains the declarations for metadata subclasses.
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
Value * RHS
Value * LHS
Class recording the (high level) value of a variable.
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:202
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:85
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
Basic type, like 'int' or 'float'.
A structured debug information entry.
Definition: DIE.h:819
DWARF expression.
static std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)
If Expr is a valid single-location expression, i.e.
StringRef getName() const
A scope for locals.
Debug location.
Tagged DWARF-like metadata node.
String type, Fortran CHARACTER(n)
Subprogram description.
Base class for types.
StringRef getName() const
Used for tracking debug info about call site parameters.
Definition: DwarfDebug.h:316
unsigned getRegister() const
Definition: DwarfDebug.h:327
DbgCallSiteParam(unsigned Reg, DbgValueLoc Val)
Definition: DwarfDebug.h:322
DbgValueLoc getValue() const
Definition: DwarfDebug.h:328
This class is defined as the common parent of DbgVariable and DbgLabel such that it could levarage po...
Definition: DwarfDebug.h:65
virtual ~DbgEntity()=default
static bool classof(const DbgEntity *N)
Definition: DwarfDebug.h:93
const DINode * getEntity() const
Accessors.
Definition: DwarfDebug.h:85
DbgEntityKind getDbgEntityID() const
Definition: DwarfDebug.h:88
void setDIE(DIE &D)
Definition: DwarfDebug.h:91
DIE * getDIE() const
Definition: DwarfDebug.h:87
DbgEntity(const DINode *N, const DILocation *IA, DbgEntityKind ID)
Definition: DwarfDebug.h:79
const DILocation * getInlinedAt() const
Definition: DwarfDebug.h:86
This class is used to track label information.
Definition: DwarfDebug.h:289
dwarf::Tag getTag() const
Translate tag to proper Dwarf tag.
Definition: DwarfDebug.h:306
static bool classof(const DbgEntity *N)
Definition: DwarfDebug.h:310
DbgLabel(const DILabel *L, const DILocation *IA, const MCSymbol *Sym=nullptr)
Symbol before DBG_LABEL instruction.
Definition: DwarfDebug.h:294
StringRef getName() const
Definition: DwarfDebug.h:302
const MCSymbol * getSymbol() const
Definition: DwarfDebug.h:300
const DILabel * getLabel() const
Accessors.
Definition: DwarfDebug.h:299
SmallVector< Entry, 4 > Entries
std::pair< const DINode *, const DILocation * > InlinedEntity
The location of a single variable, composed of an expression and 0 or more DbgValueLocEntries.
This class is used to track local variable information.
Definition: DwarfDebug.h:214
const Loc::Variant & asVariant() const
Definition: DwarfDebug.h:221
bool isArtificial() const
Return true if DbgVariable is artificial.
Definition: DwarfDebug.h:262
dwarf::Tag getTag() const
Definition: DwarfDebug.h:253
bool isObjectPointer() const
Definition: DwarfDebug.h:270
const DILocalVariable * getVariable() const
Definition: DwarfDebug.h:246
DbgVariable(const DILocalVariable *V, const DILocation *IA)
Construct a DbgVariable.
Definition: DwarfDebug.h:242
auto & get() noexcept
Asserting, noexcept member alternative to std::get.
Definition: DwarfDebug.h:229
StringRef getName() const
Definition: DwarfDebug.h:250
const DIType * getType() const
Definition: DwarfDebug.cpp:230
const auto & get() const noexcept
Asserting, noexcept member alternative to std::get.
Definition: DwarfDebug.h:234
Loc::Variant & asVariant()
To workaround P2162R0 https://github.com/cplusplus/papers/issues/873 the base class subobject needs t...
Definition: DwarfDebug.h:220
static bool classof(const DbgEntity *N)
Definition: DwarfDebug.h:280
bool holds() const
Member shorthand for std::holds_alternative.
Definition: DwarfDebug.h:225
Base class for debug information backends.
Byte stream of .debug_loc entries.
A debug info location.
Definition: DebugLoc.h:33
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:202
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:351
bool useSegmentedStringOffsetsTable() const
Returns whether to generate a string offsets table with (possibly shared) contributions from each CU ...
Definition: DwarfDebug.h:814
MDNodeSet & getLocalDeclsForScope(const DILocalScope *S)
Definition: DwarfDebug.h:922
std::optional< MD5::MD5Result > getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
bool useGNUTLSOpcode() const
Returns whether to use DW_OP_GNU_push_tls_address, instead of the standard DW_OP_form_tls_address opc...
Definition: DwarfDebug.h:753
bool useAddrOffsetForm() const
Definition: DwarfDebug.h:777
const DwarfCompileUnit * getPrevCU() const
Returns the previous CU that was being updated.
Definition: DwarfDebug.h:838
void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override
For symbols that have a size designated (e.g.
Definition: DwarfDebug.h:743
bool emitDebugEntryValues() const
Definition: DwarfDebug.h:818
const DwarfCompileUnit * lookupCU(const DIE *Die) const
Definition: DwarfDebug.h:887
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
void emitDebugLocEntry(ByteStreamer &Streamer, const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU)
Emit an entry for the debug loc section.
void addAccelNamespace(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
void setCurrentDWARF5AccelTable(const DWARF5AccelTableKind Kind)
Sets the current DWARF5AccelTable to use.
Definition: DwarfDebug.h:927
bool alwaysUseRanges(const DwarfCompileUnit &) const
Returns whether range encodings should be used for single entry range lists.
void beginModule(Module *M) override
Emit all Dwarf sections that should come prior to the content.
void addSubprogramNames(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, const DISubprogram *SP, DIE &Die)
Definition: DwarfDebug.cpp:476
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:749
void insertSectionLabel(const MCSymbol *S)
void addAccelObjC(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
dwarf::Form getDwarfSectionOffsetForm() const
Returns a suitable DWARF form to represent a section offset, i.e.
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:800
void setPrevCU(const DwarfCompileUnit *PrevCU)
Definition: DwarfDebug.h:839
const MachineFunction * getCurrentFunction() const
Definition: DwarfDebug.h:879
void skippedNonDebugFunction() override
bool useInlineStrings() const
Returns whether to use inline strings.
Definition: DwarfDebug.h:760
void addArangeLabel(SymbolCU SCU)
Add a label so that arange data can be generated for it.
Definition: DwarfDebug.h:739
bool generateTypeUnits() const
Returns whether to generate DWARF v4 type units.
Definition: DwarfDebug.h:790
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
AddressPool & getAddressPool()
Definition: DwarfDebug.h:861
DWARF5AccelTable & getCurrentDWARF5AccelTable()
Returns either CU or TU DWARF5AccelTable.
Definition: DwarfDebug.h:937
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:782
const DebugLocStream & getDebugLocs() const
Returns the entries for the .debug_loc section.
Definition: DwarfDebug.h:845
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:537
bool useOpConvert() const
Definition: DwarfDebug.h:822
void terminateLineTable(const DwarfCompileUnit *CU)
Terminate the line table by adding the last range label.
~DwarfDebug() override
void endFunctionImpl(const MachineFunction *MF) override
Gather and emit post-function debug information.
void addStringTypeLoc(const DIStringType *ST, unsigned Loc)
Definition: DwarfDebug.h:895
void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry, const DwarfCompileUnit *CU)
Emit the location for a debug loc entry, including the size header.
DwarfCompileUnit * lookupCU(const DIE *Die)
Find the matching DwarfCompileUnit for the given CU DIE.
Definition: DwarfDebug.h:886
const MCSymbol * getSectionLabel(const MCSection *S)
static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT, const DbgValueLoc &Value, DwarfExpression &DwarfExpr)
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
Definition: DwarfDebug.h:806
bool useLocSection() const
Returns whether .debug_loc section should be emitted.
Definition: DwarfDebug.h:787
unsigned getDwarfCompileUnitIDForLineTable(const DwarfCompileUnit &CU)
Get Dwarf compile unit ID for line table.
void setTheAccelTableKind(AccelTableKind K)
Seet TheAccelTableKind.
Definition: DwarfDebug.h:798
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
Definition: DwarfDebug.h:757
DebugLoc emitInitialLocDirective(const MachineFunction &MF, unsigned CUID)
Emits inital debug location directive.
bool useAddrOffsetExpressions() const
Definition: DwarfDebug.h:771
bool useRangesSection() const
Returns whether ranges section should be emitted.
Definition: DwarfDebug.h:763
void addAccelName(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
unsigned getStringTypeLoc(const DIStringType *ST) const
Definition: DwarfDebug.h:891
bool isLexicalScopeDIENull(LexicalScope *Scope)
A helper function to check whether the DIE for a given Scope is going to be null.
Definition: DwarfDebug.cpp:513
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we're going to pull into type units.
void endModule() override
Emit all Dwarf sections that should come after the content.
void addAccelType(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die, char Flags)
void beginFunctionImpl(const MachineFunction *MF) override
Gather pre-function debug information.
AccelTableKind getAccelTableKind() const
Returns what kind (if any) of accelerator tables to emit.
Definition: DwarfDebug.h:795
static uint64_t makeTypeSignature(StringRef Identifier)
Perform an MD5 checksum of Identifier and return the lower 64 bits.
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
const SmallVectorImpl< std::unique_ptr< DwarfCompileUnit > > & getUnits()
Definition: DwarfFile.h:102
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:35
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:44
Multi-value location description.
Definition: DwarfDebug.h:142
Multi(unsigned DebugLocListIndex, std::optional< uint8_t > DebugLocListTagOffset)
Definition: DwarfDebug.h:149
unsigned getDebugLocListIndex() const
Definition: DwarfDebug.h:153
std::optional< uint8_t > getDebugLocListTagOffset() const
Definition: DwarfDebug.h:154
Single value location description.
Definition: DwarfDebug.h:131
const DbgValueLoc & getValueLoc() const
Definition: DwarfDebug.h:138
const DIExpression * getExpr() const
Definition: DwarfDebug.h:139
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:35
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
Representation of each machine instruction.
Definition: MachineInstr.h:69
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:36
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
A vector that has set insertion semantics.
Definition: SetVector.h:57
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:427
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:370
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
LLVM Value Representation.
Definition: Value.h:74
bool tuneForSCE() const
Definition: DwarfDebug.h:907
bool tuneForDBX() const
Definition: DwarfDebug.h:908
bool tuneForGDB() const
Definition: DwarfDebug.h:905
bool tuneForLLDB() const
Definition: DwarfDebug.h:906
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::variant< std::monostate, Loc::Single, Loc::Multi, Loc::MMI, Loc::EntryValue > Variant
Alias for the std::variant specialization base class of DbgVariable.
Definition: DwarfDebug.h:190
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:361
AccelTableKind
The kind of accelerator tables we should emit.
Definition: DwarfDebug.h:343
@ Apple
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
@ Dwarf
DWARF v5 .debug_names.
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:97
@ SCE
Tune debug info for SCE targets (e.g. PS4).
@ DBX
Tune debug info for dbx.
@ Default
No specific tuning requested.
@ GDB
Tune debug info for gdb.
@ LLDB
Tune debug info for lldb.
@ Default
The result values are uniform if and only if all operands are uniform.
#define N
Represents an entry-value location, or a fragment of one.
Definition: DwarfDebug.h:120
friend bool operator<(const EntryValueInfo &LHS, const EntryValueInfo &RHS)
Operator enabling sorting based on fragment offset.
const DIExpression & Expr
Definition: DwarfDebug.h:122
Proxy for one MMI entry.
Definition: DwarfDebug.h:111
const DIExpression * Expr
Definition: DwarfDebug.h:113
friend bool operator<(const FrameIndexExpr &LHS, const FrameIndexExpr &RHS)
Operator enabling sorting based on fragment offset.
Single location defined by (potentially multiple) EntryValueInfo.
Definition: DwarfDebug.h:172
void addExpr(MCRegister Reg, const DIExpression &Expr)
Definition: DwarfDebug.h:180
std::set< EntryValueInfo > EntryValues
Definition: DwarfDebug.h:173
EntryValue(MCRegister Reg, const DIExpression &Expr)
Definition: DwarfDebug.h:174
Single location defined by (potentially multiple) MMI entries.
Definition: DwarfDebug.h:159
void addFrameIndexExpr(const DIExpression *Expr, int FI)
Definition: DwarfDebug.cpp:296
std::set< FrameIndexExpr > FrameIndexExprs
Definition: DwarfDebug.h:160
const std::set< FrameIndexExpr > & getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
Definition: DwarfDebug.cpp:292
MMI(const DIExpression *E, int FI)
Definition: DwarfDebug.h:163
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:335
const MCSymbol * Sym
Definition: DwarfDebug.h:338
DwarfCompileUnit * CU
Definition: DwarfDebug.h:339
SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym)
Definition: DwarfDebug.h:336