LLVM  7.0.0svn
DwarfDebug.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/DwarfDebug.h - Dwarf Debug Framework --------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for writing dwarf debug info into asm files.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
15 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
16 
17 #include "AddressPool.h"
19 #include "DebugHandlerBase.h"
20 #include "DebugLocStream.h"
21 #include "DwarfFile.h"
22 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/DenseSet.h"
25 #include "llvm/ADT/MapVector.h"
26 #include "llvm/ADT/STLExtras.h"
27 #include "llvm/ADT/SetVector.h"
28 #include "llvm/ADT/SmallPtrSet.h"
29 #include "llvm/ADT/SmallVector.h"
30 #include "llvm/ADT/StringMap.h"
31 #include "llvm/ADT/StringRef.h"
36 #include "llvm/IR/DebugLoc.h"
37 #include "llvm/IR/Metadata.h"
38 #include "llvm/MC/MCDwarf.h"
39 #include "llvm/Support/Allocator.h"
41 #include <cassert>
42 #include <cstdint>
43 #include <limits>
44 #include <memory>
45 #include <utility>
46 #include <vector>
47 
48 namespace llvm {
49 
50 class AsmPrinter;
51 class ByteStreamer;
52 class DebugLocEntry;
53 class DIE;
54 class DwarfCompileUnit;
55 class DwarfTypeUnit;
56 class DwarfUnit;
57 class LexicalScope;
58 class MachineFunction;
59 class MCSection;
60 class MCSymbol;
61 class MDNode;
62 class Module;
63 
64 //===----------------------------------------------------------------------===//
65 /// This class is used to track local variable information.
66 ///
67 /// Variables can be created from allocas, in which case they're generated from
68 /// the MMI table. Such variables can have multiple expressions and frame
69 /// indices.
70 ///
71 /// Variables can be created from \c DBG_VALUE instructions. Those whose
72 /// location changes over time use \a DebugLocListIndex, while those with a
73 /// single instruction use \a MInsn and (optionally) a single entry of \a Expr.
74 ///
75 /// Variables that have been optimized out use none of these fields.
76 class DbgVariable {
77  const DILocalVariable *Var; /// Variable Descriptor.
78  const DILocation *IA; /// Inlined at location.
79  DIE *TheDIE = nullptr; /// Variable DIE.
80  unsigned DebugLocListIndex = ~0u; /// Offset in DebugLocs.
81  const MachineInstr *MInsn = nullptr; /// DBG_VALUE instruction.
82 
83  struct FrameIndexExpr {
84  int FI;
85  const DIExpression *Expr;
86  };
88  FrameIndexExprs; /// Frame index + expression.
89 
90 public:
91  /// Construct a DbgVariable.
92  ///
93  /// Creates a variable without any DW_AT_location. Call \a initializeMMI()
94  /// for MMI entries, or \a initializeDbgValue() for DBG_VALUE instructions.
95  DbgVariable(const DILocalVariable *V, const DILocation *IA)
96  : Var(V), IA(IA) {}
97 
98  /// Initialize from the MMI table.
99  void initializeMMI(const DIExpression *E, int FI) {
100  assert(FrameIndexExprs.empty() && "Already initialized?");
101  assert(!MInsn && "Already initialized?");
102 
103  assert((!E || E->isValid()) && "Expected valid expression");
104  assert(FI != std::numeric_limits<int>::max() && "Expected valid index");
105 
106  FrameIndexExprs.push_back({FI, E});
107  }
108 
109  /// Initialize from a DBG_VALUE instruction.
110  void initializeDbgValue(const MachineInstr *DbgValue) {
111  assert(FrameIndexExprs.empty() && "Already initialized?");
112  assert(!MInsn && "Already initialized?");
113 
114  assert(Var == DbgValue->getDebugVariable() && "Wrong variable");
115  assert(IA == DbgValue->getDebugLoc()->getInlinedAt() && "Wrong inlined-at");
116 
117  MInsn = DbgValue;
118  if (auto *E = DbgValue->getDebugExpression())
119  if (E->getNumElements())
120  FrameIndexExprs.push_back({0, E});
121  }
122 
123  // Accessors.
124  const DILocalVariable *getVariable() const { return Var; }
125  const DILocation *getInlinedAt() const { return IA; }
126 
128  assert(MInsn && FrameIndexExprs.size() <= 1);
129  return FrameIndexExprs.size() ? FrameIndexExprs[0].Expr : nullptr;
130  }
131 
132  void setDIE(DIE &D) { TheDIE = &D; }
133  DIE *getDIE() const { return TheDIE; }
134  void setDebugLocListIndex(unsigned O) { DebugLocListIndex = O; }
135  unsigned getDebugLocListIndex() const { return DebugLocListIndex; }
136  StringRef getName() const { return Var->getName(); }
137  const MachineInstr *getMInsn() const { return MInsn; }
138  /// Get the FI entries, sorted by fragment offset.
140  bool hasFrameIndexExprs() const { return !FrameIndexExprs.empty(); }
141  void addMMIEntry(const DbgVariable &V);
142 
143  // Translate tag to proper Dwarf tag.
144  dwarf::Tag getTag() const {
145  // FIXME: Why don't we just infer this tag and store it all along?
146  if (Var->isParameter())
147  return dwarf::DW_TAG_formal_parameter;
148 
149  return dwarf::DW_TAG_variable;
150  }
151 
152  /// Return true if DbgVariable is artificial.
153  bool isArtificial() const {
154  if (Var->isArtificial())
155  return true;
156  if (getType()->isArtificial())
157  return true;
158  return false;
159  }
160 
161  bool isObjectPointer() const {
162  if (Var->isObjectPointer())
163  return true;
164  if (getType()->isObjectPointer())
165  return true;
166  return false;
167  }
168 
169  bool hasComplexAddress() const {
170  assert(MInsn && "Expected DBG_VALUE, not MMI variable");
171  assert((FrameIndexExprs.empty() ||
172  (FrameIndexExprs.size() == 1 &&
173  FrameIndexExprs[0].Expr->getNumElements())) &&
174  "Invalid Expr for DBG_VALUE");
175  return !FrameIndexExprs.empty();
176  }
177 
178  bool isBlockByrefVariable() const;
179  const DIType *getType() const;
180 
181 private:
182  template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
183  return Ref.resolve();
184  }
185 };
186 
187 /// Helper used to pair up a symbol and its DWARF compile unit.
188 struct SymbolCU {
189  SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {}
190 
191  const MCSymbol *Sym;
193 };
194 
195 /// The kind of accelerator tables we should emit.
196 enum class AccelTableKind {
197  Default, ///< Platform default.
198  None, ///< None.
199  Apple, ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
200  Dwarf, ///< DWARF v5 .debug_names.
201 };
202 
203 /// Collects and handles dwarf debug information.
204 class DwarfDebug : public DebugHandlerBase {
205  /// All DIEValues are allocated through this allocator.
206  BumpPtrAllocator DIEValueAllocator;
207 
208  /// Maps MDNode with its corresponding DwarfCompileUnit.
210 
211  /// Maps a CU DIE with its corresponding DwarfCompileUnit.
213 
214  /// List of all labels used in aranges generation.
215  std::vector<SymbolCU> ArangeLabels;
216 
217  /// Size of each symbol emitted (for those symbols that have a specific size).
219 
220  /// Collection of abstract variables.
221  SmallVector<std::unique_ptr<DbgVariable>, 64> ConcreteVariables;
222 
223  /// Collection of DebugLocEntry. Stored in a linked list so that DIELocLists
224  /// can refer to them in spite of insertions into this list.
225  DebugLocStream DebugLocs;
226 
227  /// This is a collection of subprogram MDNodes that are processed to
228  /// create DIEs.
231  ProcessedSPNodes;
232 
233  /// If nonnull, stores the current machine function we're processing.
234  const MachineFunction *CurFn = nullptr;
235 
236  /// If nonnull, stores the CU in which the previous subprogram was contained.
237  const DwarfCompileUnit *PrevCU;
238 
239  /// As an optimization, there is no need to emit an entry in the directory
240  /// table for the same directory as DW_AT_comp_dir.
241  StringRef CompilationDir;
242 
243  /// Holder for the file specific debug information.
244  DwarfFile InfoHolder;
245 
246  /// Holders for the various debug information flags that we might need to
247  /// have exposed. See accessor functions below for description.
248 
249  /// Map from MDNodes for user-defined types to their type signatures. Also
250  /// used to keep track of which types we have emitted type units for.
251  DenseMap<const MDNode *, uint64_t> TypeSignatures;
252 
253  SmallVector<
254  std::pair<std::unique_ptr<DwarfTypeUnit>, const DICompositeType *>, 1>
255  TypeUnitsUnderConstruction;
256 
257  /// Whether to use the GNU TLS opcode (instead of the standard opcode).
258  bool UseGNUTLSOpcode;
259 
260  /// Whether to use DWARF 2 bitfields (instead of the DWARF 4 format).
261  bool UseDWARF2Bitfields;
262 
263  /// Whether to emit all linkage names, or just abstract subprograms.
264  bool UseAllLinkageNames;
265 
266  /// Use inlined strings.
267  bool UseInlineStrings = false;
268 
269  /// Whether to emit DWARF pub sections or not.
270  bool UsePubSections = true;
271 
272  /// Allow emission of .debug_ranges section.
273  bool UseRangesSection = true;
274 
275  /// True if the sections itself must be used as references and don't create
276  /// temp symbols inside DWARF sections.
277  bool UseSectionsAsReferences = false;
278 
279  ///Allow emission of the .debug_loc section.
280  bool UseLocSection = true;
281 
282  /// DWARF5 Experimental Options
283  /// @{
284  AccelTableKind TheAccelTableKind;
285  bool HasAppleExtensionAttributes;
286  bool HasSplitDwarf;
287 
288  /// Whether to generate the DWARF v5 string offsets table.
289  /// It consists of a series of contributions, each preceded by a header.
290  /// The pre-DWARF v5 string offsets table for split dwarf is, in contrast,
291  /// a monolithic sequence of string offsets.
292  bool UseSegmentedStringOffsetsTable;
293 
294  /// Separated Dwarf Variables
295  /// In general these will all be for bits that are left in the
296  /// original object file, rather than things that are meant
297  /// to be in the .dwo sections.
298 
299  /// Holder for the skeleton information.
300  DwarfFile SkeletonHolder;
301 
302  /// Store file names for type units under fission in a line table
303  /// header that will be emitted into debug_line.dwo.
304  // FIXME: replace this with a map from comp_dir to table so that we
305  // can emit multiple tables during LTO each of which uses directory
306  // 0, referencing the comp_dir of all the type units that use it.
307  MCDwarfDwoLineTable SplitTypeUnitFileTable;
308  /// @}
309 
310  /// True iff there are multiple CUs in this module.
311  bool SingleCU;
312  bool IsDarwin;
313 
314  AddressPool AddrPool;
315 
316  /// Accelerator tables.
317  AccelTable<DWARF5AccelTableData> AccelDebugNames;
322 
323  // Identify a debugger for "tuning" the debug info.
324  DebuggerKind DebuggerTuning = DebuggerKind::Default;
325 
326  MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &);
327 
329  return InfoHolder.getUnits();
330  }
331 
332  using InlinedVariable = DbgValueHistoryMap::InlinedVariable;
333 
334  void ensureAbstractVariableIsCreated(DwarfCompileUnit &CU, InlinedVariable IV,
335  const MDNode *Scope);
336  void ensureAbstractVariableIsCreatedIfScoped(DwarfCompileUnit &CU, InlinedVariable IV,
337  const MDNode *Scope);
338 
339  DbgVariable *createConcreteVariable(DwarfCompileUnit &TheCU,
340  LexicalScope &Scope, InlinedVariable IV);
341 
342  /// Construct a DIE for this abstract scope.
343  void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope);
344 
345  /// Helper function to add a name to the .debug_names table, using the
346  /// appropriate string pool.
347  void addAccelDebugName(StringRef Name, const DIE &Die);
348 
349  void finishVariableDefinitions();
350 
351  void finishSubprogramDefinitions();
352 
353  /// Finish off debug information after all functions have been
354  /// processed.
355  void finalizeModuleInfo();
356 
357  /// Emit the debug info section.
358  void emitDebugInfo();
359 
360  /// Emit the abbreviation section.
361  void emitAbbreviations();
362 
363  /// Emit the string offsets table header.
364  void emitStringOffsetsTableHeader();
365 
366  /// Emit a specified accelerator table.
367  template <typename AccelTableT>
368  void emitAccel(AccelTableT &Accel, MCSection *Section, StringRef TableName);
369 
370  /// Emit DWARF v5 accelerator table.
371  void emitAccelDebugNames();
372 
373  /// Emit visible names into a hashed accelerator table section.
374  void emitAccelNames();
375 
376  /// Emit objective C classes and categories into a hashed
377  /// accelerator table section.
378  void emitAccelObjC();
379 
380  /// Emit namespace dies into a hashed accelerator table.
381  void emitAccelNamespaces();
382 
383  /// Emit type dies into a hashed accelerator table.
384  void emitAccelTypes();
385 
386  /// Emit visible names and types into debug pubnames and pubtypes sections.
387  void emitDebugPubSections();
388 
389  void emitDebugPubSection(bool GnuStyle, StringRef Name,
390  DwarfCompileUnit *TheU,
391  const StringMap<const DIE *> &Globals);
392 
393  /// Emit null-terminated strings into a debug str section.
394  void emitDebugStr();
395 
396  /// Emit variable locations into a debug loc section.
397  void emitDebugLoc();
398 
399  /// Emit variable locations into a debug loc dwo section.
400  void emitDebugLocDWO();
401 
402  /// Emit address ranges into a debug aranges section.
403  void emitDebugARanges();
404 
405  /// Emit address ranges into a debug ranges section.
406  void emitDebugRanges();
407 
408  /// Emit range lists into a DWARF v5 debug rnglists section.
409  void emitDebugRnglists();
410 
411  /// Emit macros into a debug macinfo section.
412  void emitDebugMacinfo();
413  void emitMacro(DIMacro &M);
414  void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U);
415  void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U);
416 
417  /// DWARF 5 Experimental Split Dwarf Emitters
418 
419  /// Initialize common features of skeleton units.
420  void initSkeletonUnit(const DwarfUnit &U, DIE &Die,
421  std::unique_ptr<DwarfCompileUnit> NewU);
422 
423  /// Construct the split debug info compile unit for the debug info
424  /// section.
425  DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU);
426 
427  /// Emit the debug info dwo section.
428  void emitDebugInfoDWO();
429 
430  /// Emit the debug abbrev dwo section.
431  void emitDebugAbbrevDWO();
432 
433  /// Emit the debug line dwo section.
434  void emitDebugLineDWO();
435 
436  /// Emit the dwo stringoffsets table header.
437  void emitStringOffsetsTableHeaderDWO();
438 
439  /// Emit the debug str dwo section.
440  void emitDebugStrDWO();
441 
442  /// Flags to let the linker know we have emitted new style pubnames. Only
443  /// emit it here if we don't have a skeleton CU for split dwarf.
444  void addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const;
445 
446  /// Create new DwarfCompileUnit for the given metadata node with tag
447  /// DW_TAG_compile_unit.
448  DwarfCompileUnit &getOrCreateDwarfCompileUnit(const DICompileUnit *DIUnit);
449 
450  /// Construct imported_module or imported_declaration DIE.
451  void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
452  const DIImportedEntity *N);
453 
454  /// Register a source line with debug info. Returns the unique
455  /// label that was emitted and which provides correspondence to the
456  /// source line list.
457  void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
458  unsigned Flags);
459 
460  /// Populate LexicalScope entries with variables' info.
461  void collectVariableInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP,
462  DenseSet<InlinedVariable> &ProcessedVars);
463 
464  /// Build the location list for all DBG_VALUEs in the
465  /// function that describe the same variable.
466  void buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
467  const DbgValueHistoryMap::InstrRanges &Ranges);
468 
469  /// Collect variable information from the side table maintained by MF.
470  void collectVariableInfoFromMFTable(DwarfCompileUnit &TheCU,
472 
473  /// Emit the reference to the section.
474  void emitSectionReference(const DwarfCompileUnit &CU);
475 
476 protected:
477  /// Gather pre-function debug information.
478  void beginFunctionImpl(const MachineFunction *MF) override;
479 
480  /// Gather and emit post-function debug information.
481  void endFunctionImpl(const MachineFunction *MF) override;
482 
483  void skippedNonDebugFunction() override;
484 
485 public:
486  //===--------------------------------------------------------------------===//
487  // Main entry points.
488  //
489  DwarfDebug(AsmPrinter *A, Module *M);
490 
491  ~DwarfDebug() override;
492 
493  /// Emit all Dwarf sections that should come prior to the
494  /// content.
495  void beginModule();
496 
497  /// Emit all Dwarf sections that should come after the content.
498  void endModule() override;
499 
500  /// Process beginning of an instruction.
501  void beginInstruction(const MachineInstr *MI) override;
502 
503  /// Perform an MD5 checksum of \p Identifier and return the lower 64 bits.
504  static uint64_t makeTypeSignature(StringRef Identifier);
505 
506  /// Add a DIE to the set of types that we're going to pull into
507  /// type units.
508  void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier,
509  DIE &Die, const DICompositeType *CTy);
510 
511  /// Add a label so that arange data can be generated for it.
512  void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); }
513 
514  /// For symbols that have a size designated (e.g. common symbols),
515  /// this tracks that size.
516  void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
517  SymSize[Sym] = Size;
518  }
519 
520  /// Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
521  /// If not, we still might emit certain cases.
522  bool useAllLinkageNames() const { return UseAllLinkageNames; }
523 
524  /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the
525  /// standard DW_OP_form_tls_address opcode
526  bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; }
527 
528  /// Returns whether to use the DWARF2 format for bitfields instyead of the
529  /// DWARF4 format.
530  bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; }
531 
532  /// Returns whether to use inline strings.
533  bool useInlineStrings() const { return UseInlineStrings; }
534 
535  /// Returns whether GNU pub sections should be emitted.
536  bool usePubSections() const { return UsePubSections; }
537 
538  /// Returns whether ranges section should be emitted.
539  bool useRangesSection() const { return UseRangesSection; }
540 
541  /// Returns whether to use sections as labels rather than temp symbols.
542  bool useSectionsAsReferences() const {
543  return UseSectionsAsReferences;
544  }
545 
546  /// Returns whether .debug_loc section should be emitted.
547  bool useLocSection() const { return UseLocSection; }
548 
549  // Experimental DWARF5 features.
550 
551  /// Returns what kind (if any) of accelerator tables to emit.
552  AccelTableKind getAccelTableKind() const { return TheAccelTableKind; }
553 
555  return HasAppleExtensionAttributes;
556  }
557 
558  /// Returns whether or not to change the current debug info for the
559  /// split dwarf proposal support.
560  bool useSplitDwarf() const { return HasSplitDwarf; }
561 
562  /// Returns whether to generate a string offsets table with (possibly shared)
563  /// contributions from each CU and type unit. This implies the use of
564  /// DW_FORM_strx* indirect references with DWARF v5 and beyond. Note that
565  /// DW_FORM_GNU_str_index is also an indirect reference, but it is used with
566  /// a pre-DWARF v5 implementation of split DWARF sections, which uses a
567  /// monolithic string offsets table.
569  return UseSegmentedStringOffsetsTable;
570  }
571 
572  bool shareAcrossDWOCUs() const;
573 
574  /// Returns the Dwarf Version.
575  uint16_t getDwarfVersion() const;
576 
577  /// Returns the previous CU that was being updated
578  const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
579  void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }
580 
581  /// Returns the entries for the .debug_loc section.
582  const DebugLocStream &getDebugLocs() const { return DebugLocs; }
583 
584  /// Emit an entry for the debug loc section. This can be used to
585  /// handle an entry that's going to be emitted into the debug loc section.
586  void emitDebugLocEntry(ByteStreamer &Streamer,
587  const DebugLocStream::Entry &Entry);
588 
589  /// Emit the location for a debug loc entry, including the size header.
590  void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry);
591 
592  /// Find the MDNode for the given reference.
593  template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
594  return Ref.resolve();
595  }
596 
597  void addSubprogramNames(const DISubprogram *SP, DIE &Die);
598 
599  AddressPool &getAddressPool() { return AddrPool; }
600 
601  void addAccelName(StringRef Name, const DIE &Die);
602 
603  void addAccelObjC(StringRef Name, const DIE &Die);
604 
605  void addAccelNamespace(StringRef Name, const DIE &Die);
606 
607  void addAccelType(StringRef Name, const DIE &Die, char Flags);
608 
609  const MachineFunction *getCurrentFunction() const { return CurFn; }
610 
611  /// A helper function to check whether the DIE for a given Scope is
612  /// going to be null.
613  bool isLexicalScopeDIENull(LexicalScope *Scope);
614 
615  /// Find the matching DwarfCompileUnit for the given CU DIE.
616  DwarfCompileUnit *lookupCU(const DIE *Die) { return CUDieMap.lookup(Die); }
617  const DwarfCompileUnit *lookupCU(const DIE *Die) const {
618  return CUDieMap.lookup(Die);
619  }
620 
621  /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger.
622  ///
623  /// Returns whether we are "tuning" for a given debugger.
624  /// @{
625  bool tuneForGDB() const { return DebuggerTuning == DebuggerKind::GDB; }
626  bool tuneForLLDB() const { return DebuggerTuning == DebuggerKind::LLDB; }
627  bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; }
628  /// @}
629 };
630 
631 } // end namespace llvm
632 
633 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
bool isObjectPointer() const
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
void push_back(const T &Elt)
Definition: SmallVector.h:213
const DILocation * getInlinedAt() const
Definition: DwarfDebug.h:125
void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override
For symbols that have a size designated (e.g.
Definition: DwarfDebug.h:516
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
unsigned getDebugLocListIndex() const
Definition: DwarfDebug.h:135
void addMMIEntry(const DbgVariable &V)
Definition: DwarfDebug.cpp:253
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
std::pair< const DILocalVariable *, const DILocation * > InlinedVariable
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:137
DWARF v5 .debug_names.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
const DIType * getType() const
Definition: DwarfDebug.cpp:190
AccelTableKind getAccelTableKind() const
Returns what kind (if any) of accelerator tables to emit.
Definition: DwarfDebug.h:552
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:285
DIE * getDIE() const
Definition: DwarfDebug.h:133
const DebugLocStream & getDebugLocs() const
Returns the entries for the .debug_loc section.
Definition: DwarfDebug.h:582
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:204
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:199
This file contains the declarations for metadata subclasses.
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:526
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:38
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:862
F(f)
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:45
const MachineFunction * getCurrentFunction() const
Definition: DwarfDebug.h:609
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:92
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support...
Definition: DwarfDebug.h:560
void initializeDbgValue(const MachineInstr *DbgValue)
Initialize from a DBG_VALUE instruction.
Definition: DwarfDebug.h:110
void addArangeLabel(SymbolCU SCU)
Add a label so that arange data can be generated for it.
Definition: DwarfDebug.h:512
StringRef getName() const
bool isObjectPointer() const
Definition: DwarfDebug.h:161
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
The access may reference the value stored in memory.
Holds a subclass of DINode.
AccelTableKind
The kind of accelerator tables we should emit.
Definition: DwarfDebug.h:196
AddressPool & getAddressPool()
Definition: DwarfDebug.h:599
Subprogram description.
const DIExpression * getSingleExpression() const
Definition: DwarfDebug.h:127
This class is used to track local variable information.
Definition: DwarfDebug.h:76
const DILocalVariable * getVariable() const
Definition: DwarfDebug.h:124
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
.apple_names, .apple_namespaces, .apple_types, .apple_objc.
const SmallVectorImpl< std::unique_ptr< DwarfCompileUnit > > & getUnits()
Definition: DwarfFile.h:77
const MachineInstr * getMInsn() const
Definition: DwarfDebug.h:137
Debug location.
const DwarfCompileUnit * getPrevCU() const
Returns the previous CU that was being updated.
Definition: DwarfDebug.h:578
bool hasComplexAddress() const
Definition: DwarfDebug.h:169
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:68
#define P(N)
DwarfCompileUnit * CU
Definition: DwarfDebug.h:192
bool tuneForLLDB() const
Definition: DwarfDebug.h:626
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:140
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void setDIE(DIE &D)
Definition: DwarfDebug.h:132
A structured debug information entry.
Definition: DIE.h:662
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
Definition: DwarfDebug.h:530
bool hasFrameIndexExprs() const
Definition: DwarfDebug.h:140
bool useSegmentedStringOffsetsTable() const
Returns whether to generate a string offsets table with (possibly shared) contributions from each CU ...
Definition: DwarfDebug.h:568
dwarf::Tag getTag() const
Definition: DwarfDebug.h:144
T * resolve(TypedDINodeRef< T > Ref) const
Find the MDNode for the given reference.
Definition: DwarfDebug.h:593
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:188
void initializeMMI(const DIExpression *E, int FI)
Initialize from the MMI table.
Definition: DwarfDebug.h:99
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:522
SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym)
Definition: DwarfDebug.h:189
const DIExpression * getDebugExpression() const
Return the complex address expression referenced by this DBG_VALUE instruction.
ArrayRef< FrameIndexExpr > getFrameIndexExprs() const
Get the FI entries, sorted by fragment offset.
Definition: DwarfDebug.cpp:235
An imported module (C++ using directive or similar).
bool useLocSection() const
Returns whether .debug_loc section should be emitted.
Definition: DwarfDebug.h:547
bool tuneForGDB() const
Definition: DwarfDebug.h:625
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
Definition: DwarfDebug.h:542
void setPrevCU(const DwarfCompileUnit *PrevCU)
Definition: DwarfDebug.h:579
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
Base class for types.
DwarfCompileUnit * lookupCU(const DIE *Die)
Find the matching DwarfCompileUnit for the given CU DIE.
Definition: DwarfDebug.h:616
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:554
DWARF expression.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:220
This file contains constants used for implementing Dwarf debug support.
StringRef getName() const
Definition: DwarfDebug.h:136
const DwarfCompileUnit * lookupCU(const DIE *Die) const
Definition: DwarfDebug.h:617
Representation of each machine instruction.
Definition: MachineInstr.h:60
bool isArtificial() const
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:62
bool useRangesSection() const
Returns whether ranges section should be emitted.
Definition: DwarfDebug.h:539
bool isBlockByrefVariable() const
Definition: DwarfDebug.cpp:185
#define N
Base class for debug information backends.
bool usePubSections() const
Returns whether GNU pub sections should be emitted.
Definition: DwarfDebug.h:536
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:181
void setDebugLocListIndex(unsigned O)
Definition: DwarfDebug.h:134
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A vector that has set insertion semantics.
Definition: SetVector.h:41
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
const DILocalVariable * getDebugVariable() const
Return the debug variable referenced by this DBG_VALUE instruction.
unsigned getUnits(MCInstrInfo const &MCII, MCSubtargetInfo const &STI, MCInst const &MCI)
Return the slots used by the insn.
DbgVariable(const DILocalVariable *V, const DILocation *IA)
Frame index + expression.
Definition: DwarfDebug.h:95
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
bool tuneForSCE() const
Definition: DwarfDebug.h:627
Byte stream of .debug_loc entries.
bool isArtificial() const
Return true if DbgVariable is artificial.
Definition: DwarfDebug.h:153
bool useInlineStrings() const
Returns whether to use inline strings.
Definition: DwarfDebug.h:533
const MCSymbol * Sym
Definition: DwarfDebug.h:191