LLVM  4.0.0
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 
18 #include "DebugHandlerBase.h"
19 #include "DebugLocStream.h"
20 #include "DwarfAccelTable.h"
21 #include "DwarfFile.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/DenseSet.h"
24 #include "llvm/ADT/MapVector.h"
25 #include "llvm/ADT/SetVector.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/ADT/StringMap.h"
28 #include "llvm/CodeGen/DIE.h"
31 #include "llvm/IR/DebugInfo.h"
32 #include "llvm/IR/DebugLoc.h"
33 #include "llvm/MC/MCDwarf.h"
35 #include "llvm/Support/Allocator.h"
37 #include <memory>
38 
39 namespace llvm {
40 
41 class AsmPrinter;
42 class ByteStreamer;
43 class ConstantInt;
44 class ConstantFP;
45 class DebugLocEntry;
46 class DwarfCompileUnit;
47 class DwarfDebug;
48 class DwarfTypeUnit;
49 class DwarfUnit;
50 class MachineModuleInfo;
51 
52 //===----------------------------------------------------------------------===//
53 /// This class is used to track local variable information.
54 ///
55 /// Variables can be created from allocas, in which case they're generated from
56 /// the MMI table. Such variables can have multiple expressions and frame
57 /// indices.
58 ///
59 /// Variables can be created from \c DBG_VALUE instructions. Those whose
60 /// location changes over time use \a DebugLocListIndex, while those with a
61 /// single instruction use \a MInsn and (optionally) a single entry of \a Expr.
62 ///
63 /// Variables that have been optimized out use none of these fields.
64 class DbgVariable {
65  const DILocalVariable *Var; /// Variable Descriptor.
66  const DILocation *IA; /// Inlined at location.
67  DIE *TheDIE = nullptr; /// Variable DIE.
68  unsigned DebugLocListIndex = ~0u; /// Offset in DebugLocs.
69  const MachineInstr *MInsn = nullptr; /// DBG_VALUE instruction.
70 
71  struct FrameIndexExpr {
72  int FI;
73  const DIExpression *Expr;
74  };
76  FrameIndexExprs; /// Frame index + expression.
77 
78 public:
79  /// Construct a DbgVariable.
80  ///
81  /// Creates a variable without any DW_AT_location. Call \a initializeMMI()
82  /// for MMI entries, or \a initializeDbgValue() for DBG_VALUE instructions.
83  DbgVariable(const DILocalVariable *V, const DILocation *IA)
84  : Var(V), IA(IA) {}
85 
86  /// Initialize from the MMI table.
87  void initializeMMI(const DIExpression *E, int FI) {
88  assert(FrameIndexExprs.empty() && "Already initialized?");
89  assert(!MInsn && "Already initialized?");
90 
91  assert((!E || E->isValid()) && "Expected valid expression");
92  assert(~FI && "Expected valid index");
93 
94  FrameIndexExprs.push_back({FI, E});
95  }
96 
97  /// Initialize from a DBG_VALUE instruction.
98  void initializeDbgValue(const MachineInstr *DbgValue) {
99  assert(FrameIndexExprs.empty() && "Already initialized?");
100  assert(!MInsn && "Already initialized?");
101 
102  assert(Var == DbgValue->getDebugVariable() && "Wrong variable");
103  assert(IA == DbgValue->getDebugLoc()->getInlinedAt() && "Wrong inlined-at");
104 
105  MInsn = DbgValue;
106  if (auto *E = DbgValue->getDebugExpression())
107  if (E->getNumElements())
108  FrameIndexExprs.push_back({0, E});
109  }
110 
111  // Accessors.
112  const DILocalVariable *getVariable() const { return Var; }
113  const DILocation *getInlinedAt() const { return IA; }
115  assert(MInsn && FrameIndexExprs.size() <= 1);
116  return FrameIndexExprs.size() ? FrameIndexExprs[0].Expr : nullptr;
117  }
118  void setDIE(DIE &D) { TheDIE = &D; }
119  DIE *getDIE() const { return TheDIE; }
120  void setDebugLocListIndex(unsigned O) { DebugLocListIndex = O; }
121  unsigned getDebugLocListIndex() const { return DebugLocListIndex; }
122  StringRef getName() const { return Var->getName(); }
123  const MachineInstr *getMInsn() const { return MInsn; }
124  /// Get the FI entries, sorted by fragment offset.
125  ArrayRef<FrameIndexExpr> getFrameIndexExprs() const;
126  bool hasFrameIndexExprs() const { return !FrameIndexExprs.empty(); }
127 
128  void addMMIEntry(const DbgVariable &V) {
129  assert(DebugLocListIndex == ~0U && !MInsn && "not an MMI entry");
130  assert(V.DebugLocListIndex == ~0U && !V.MInsn && "not an MMI entry");
131  assert(V.Var == Var && "conflicting variable");
132  assert(V.IA == IA && "conflicting inlined-at location");
133 
134  assert(!FrameIndexExprs.empty() && "Expected an MMI entry");
135  assert(!V.FrameIndexExprs.empty() && "Expected an MMI entry");
136 
137  FrameIndexExprs.append(V.FrameIndexExprs.begin(), V.FrameIndexExprs.end());
138  assert(all_of(FrameIndexExprs,
139  [](FrameIndexExpr &FIE) {
140  return FIE.Expr && FIE.Expr->isFragment();
141  }) &&
142  "conflicting locations for variable");
143  }
144 
145  // Translate tag to proper Dwarf tag.
146  dwarf::Tag getTag() const {
147  // FIXME: Why don't we just infer this tag and store it all along?
148  if (Var->isParameter())
149  return dwarf::DW_TAG_formal_parameter;
150 
151  return dwarf::DW_TAG_variable;
152  }
153  /// Return true if DbgVariable is artificial.
154  bool isArtificial() const {
155  if (Var->isArtificial())
156  return true;
157  if (getType()->isArtificial())
158  return true;
159  return false;
160  }
161 
162  bool isObjectPointer() const {
163  if (Var->isObjectPointer())
164  return true;
165  if (getType()->isObjectPointer())
166  return true;
167  return false;
168  }
169 
170  bool hasComplexAddress() const {
171  assert(MInsn && "Expected DBG_VALUE, not MMI variable");
172  assert((FrameIndexExprs.empty() ||
173  (FrameIndexExprs.size() == 1 &&
174  FrameIndexExprs[0].Expr->getNumElements())) &&
175  "Invalid Expr for DBG_VALUE");
176  return !FrameIndexExprs.empty();
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 
188 /// Helper used to pair up a symbol and its DWARF compile unit.
189 struct SymbolCU {
190  SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {}
191  const MCSymbol *Sym;
193 };
194 
195 /// Collects and handles dwarf debug information.
196 class DwarfDebug : public DebugHandlerBase {
197  /// All DIEValues are allocated through this allocator.
198  BumpPtrAllocator DIEValueAllocator;
199 
200  /// Maps MDNode with its corresponding DwarfCompileUnit.
202 
203  /// Maps a CU DIE with its corresponding DwarfCompileUnit.
205 
206  /// List of all labels used in aranges generation.
207  std::vector<SymbolCU> ArangeLabels;
208 
209  /// Size of each symbol emitted (for those symbols that have a specific size).
211 
212  /// Collection of abstract variables.
214  SmallVector<std::unique_ptr<DbgVariable>, 64> ConcreteVariables;
215 
216  /// Collection of DebugLocEntry. Stored in a linked list so that DIELocLists
217  /// can refer to them in spite of insertions into this list.
218  DebugLocStream DebugLocs;
219 
220  /// This is a collection of subprogram MDNodes that are processed to
221  /// create DIEs.
224  ProcessedSPNodes;
225 
226  /// If nonnull, stores the current machine function we're processing.
227  const MachineFunction *CurFn;
228 
229  /// If nonnull, stores the CU in which the previous subprogram was contained.
230  const DwarfCompileUnit *PrevCU;
231 
232  /// As an optimization, there is no need to emit an entry in the directory
233  /// table for the same directory as DW_AT_comp_dir.
234  StringRef CompilationDir;
235 
236  /// Holder for the file specific debug information.
237  DwarfFile InfoHolder;
238 
239  /// Holders for the various debug information flags that we might need to
240  /// have exposed. See accessor functions below for description.
241 
242  /// Map from MDNodes for user-defined types to their type signatures. Also
243  /// used to keep track of which types we have emitted type units for.
244  DenseMap<const MDNode *, uint64_t> TypeSignatures;
245 
246  SmallVector<
247  std::pair<std::unique_ptr<DwarfTypeUnit>, const DICompositeType *>, 1>
248  TypeUnitsUnderConstruction;
249 
250  /// Whether to emit the pubnames/pubtypes sections.
251  bool HasDwarfPubSections;
252 
253  /// Whether to use the GNU TLS opcode (instead of the standard opcode).
254  bool UseGNUTLSOpcode;
255 
256  /// Whether to use DWARF 2 bitfields (instead of the DWARF 4 format).
257  bool UseDWARF2Bitfields;
258 
259  /// Whether to emit all linkage names, or just abstract subprograms.
260  bool UseAllLinkageNames;
261 
262  /// DWARF5 Experimental Options
263  /// @{
264  bool HasDwarfAccelTables;
265  bool HasAppleExtensionAttributes;
266  bool HasSplitDwarf;
267 
268  /// Separated Dwarf Variables
269  /// In general these will all be for bits that are left in the
270  /// original object file, rather than things that are meant
271  /// to be in the .dwo sections.
272 
273  /// Holder for the skeleton information.
274  DwarfFile SkeletonHolder;
275 
276  /// Store file names for type units under fission in a line table
277  /// header that will be emitted into debug_line.dwo.
278  // FIXME: replace this with a map from comp_dir to table so that we
279  // can emit multiple tables during LTO each of which uses directory
280  // 0, referencing the comp_dir of all the type units that use it.
281  MCDwarfDwoLineTable SplitTypeUnitFileTable;
282  /// @}
283 
284  /// True iff there are multiple CUs in this module.
285  bool SingleCU;
286  bool IsDarwin;
287 
288  AddressPool AddrPool;
289 
290  DwarfAccelTable AccelNames;
291  DwarfAccelTable AccelObjC;
292  DwarfAccelTable AccelNamespace;
293  DwarfAccelTable AccelTypes;
294 
295  // Identify a debugger for "tuning" the debug info.
296  DebuggerKind DebuggerTuning;
297 
298  /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger.
299  ///
300  /// Returns whether we are "tuning" for a given debugger.
301  /// Should be used only within the constructor, to set feature flags.
302  /// @{
303  bool tuneForGDB() const { return DebuggerTuning == DebuggerKind::GDB; }
304  bool tuneForLLDB() const { return DebuggerTuning == DebuggerKind::LLDB; }
305  bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; }
306  /// @}
307 
308  MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &);
309 
311  return InfoHolder.getUnits();
312  }
313 
314  typedef DbgValueHistoryMap::InlinedVariable InlinedVariable;
315 
316  /// Find abstract variable associated with Var.
317  DbgVariable *getExistingAbstractVariable(InlinedVariable IV,
318  const DILocalVariable *&Cleansed);
319  DbgVariable *getExistingAbstractVariable(InlinedVariable IV);
320  void createAbstractVariable(const DILocalVariable *DV, LexicalScope *Scope);
321  void ensureAbstractVariableIsCreated(InlinedVariable Var,
322  const MDNode *Scope);
323  void ensureAbstractVariableIsCreatedIfScoped(InlinedVariable Var,
324  const MDNode *Scope);
325 
326  DbgVariable *createConcreteVariable(LexicalScope &Scope, InlinedVariable IV);
327 
328  /// Construct a DIE for this abstract scope.
329  void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
330 
331  void finishVariableDefinitions();
332 
333  void finishSubprogramDefinitions();
334 
335  /// Finish off debug information after all functions have been
336  /// processed.
337  void finalizeModuleInfo();
338 
339  /// Emit the debug info section.
340  void emitDebugInfo();
341 
342  /// Emit the abbreviation section.
343  void emitAbbreviations();
344 
345  /// Emit a specified accelerator table.
346  void emitAccel(DwarfAccelTable &Accel, MCSection *Section,
347  StringRef TableName);
348 
349  /// Emit visible names into a hashed accelerator table section.
350  void emitAccelNames();
351 
352  /// Emit objective C classes and categories into a hashed
353  /// accelerator table section.
354  void emitAccelObjC();
355 
356  /// Emit namespace dies into a hashed accelerator table.
357  void emitAccelNamespaces();
358 
359  /// Emit type dies into a hashed accelerator table.
360  void emitAccelTypes();
361 
362  /// Emit visible names into a debug pubnames section.
363  /// \param GnuStyle determines whether or not we want to emit
364  /// additional information into the table ala newer gcc for gdb
365  /// index.
366  void emitDebugPubNames(bool GnuStyle = false);
367 
368  /// Emit visible types into a debug pubtypes section.
369  /// \param GnuStyle determines whether or not we want to emit
370  /// additional information into the table ala newer gcc for gdb
371  /// index.
372  void emitDebugPubTypes(bool GnuStyle = false);
373 
374  void emitDebugPubSection(
375  bool GnuStyle, MCSection *PSec, StringRef Name,
376  const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const);
377 
378  /// Emit null-terminated strings into a debug str section.
379  void emitDebugStr();
380 
381  /// Emit variable locations into a debug loc section.
382  void emitDebugLoc();
383 
384  /// Emit variable locations into a debug loc dwo section.
385  void emitDebugLocDWO();
386 
387  /// Emit address ranges into a debug aranges section.
388  void emitDebugARanges();
389 
390  /// Emit address ranges into a debug ranges section.
391  void emitDebugRanges();
392 
393  /// Emit macros into a debug macinfo section.
394  void emitDebugMacinfo();
395  void emitMacro(DIMacro &M);
396  void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U);
397  void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U);
398 
399  /// DWARF 5 Experimental Split Dwarf Emitters
400 
401  /// Initialize common features of skeleton units.
402  void initSkeletonUnit(const DwarfUnit &U, DIE &Die,
403  std::unique_ptr<DwarfCompileUnit> NewU);
404 
405  /// Construct the split debug info compile unit for the debug info
406  /// section.
407  DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU);
408 
409  /// Emit the debug info dwo section.
410  void emitDebugInfoDWO();
411 
412  /// Emit the debug abbrev dwo section.
413  void emitDebugAbbrevDWO();
414 
415  /// Emit the debug line dwo section.
416  void emitDebugLineDWO();
417 
418  /// Emit the debug str dwo section.
419  void emitDebugStrDWO();
420 
421  /// Flags to let the linker know we have emitted new style pubnames. Only
422  /// emit it here if we don't have a skeleton CU for split dwarf.
423  void addGnuPubAttributes(DwarfUnit &U, DIE &D) const;
424 
425  /// Create new DwarfCompileUnit for the given metadata node with tag
426  /// DW_TAG_compile_unit.
427  DwarfCompileUnit &constructDwarfCompileUnit(const DICompileUnit *DIUnit);
428 
429  /// Construct imported_module or imported_declaration DIE.
430  void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
431  const DIImportedEntity *N);
432 
433  /// Register a source line with debug info. Returns the unique
434  /// label that was emitted and which provides correspondence to the
435  /// source line list.
436  void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
437  unsigned Flags);
438 
439  /// Populate LexicalScope entries with variables' info.
440  void collectVariableInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP,
441  DenseSet<InlinedVariable> &ProcessedVars);
442 
443  /// Build the location list for all DBG_VALUEs in the
444  /// function that describe the same variable.
445  void buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
446  const DbgValueHistoryMap::InstrRanges &Ranges);
447 
448  /// Collect variable information from the side table maintained by MF.
449  void collectVariableInfoFromMFTable(DenseSet<InlinedVariable> &P);
450 
451 public:
452  //===--------------------------------------------------------------------===//
453  // Main entry points.
454  //
456 
457  ~DwarfDebug() override;
458 
459  /// Emit all Dwarf sections that should come prior to the
460  /// content.
461  void beginModule();
462 
463  /// Emit all Dwarf sections that should come after the content.
464  void endModule() override;
465 
466  /// Gather pre-function debug information.
467  void beginFunction(const MachineFunction *MF) override;
468 
469  /// Gather and emit post-function debug information.
470  void endFunction(const MachineFunction *MF) override;
471 
472  /// Process beginning of an instruction.
473  void beginInstruction(const MachineInstr *MI) override;
474 
475  /// Perform an MD5 checksum of \p Identifier and return the lower 64 bits.
476  static uint64_t makeTypeSignature(StringRef Identifier);
477 
478  /// Add a DIE to the set of types that we're going to pull into
479  /// type units.
480  void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier,
481  DIE &Die, const DICompositeType *CTy);
482 
483  /// Add a label so that arange data can be generated for it.
484  void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); }
485 
486  /// For symbols that have a size designated (e.g. common symbols),
487  /// this tracks that size.
488  void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
489  SymSize[Sym] = Size;
490  }
491 
492  /// Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
493  /// If not, we still might emit certain cases.
494  bool useAllLinkageNames() const { return UseAllLinkageNames; }
495 
496  /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the
497  /// standard DW_OP_form_tls_address opcode
498  bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; }
499 
500  /// Returns whether to use the DWARF2 format for bitfields instyead of the
501  /// DWARF4 format.
502  bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; }
503 
504  // Experimental DWARF5 features.
505 
506  /// Returns whether or not to emit tables that dwarf consumers can
507  /// use to accelerate lookup.
508  bool useDwarfAccelTables() const { return HasDwarfAccelTables; }
509 
511  return HasAppleExtensionAttributes;
512  }
513 
514  /// Returns whether or not to change the current debug info for the
515  /// split dwarf proposal support.
516  bool useSplitDwarf() const { return HasSplitDwarf; }
517 
518  /// Returns the Dwarf Version.
519  uint16_t getDwarfVersion() const;
520 
521  /// Returns the previous CU that was being updated
522  const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
523  void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }
524 
525  /// Returns the entries for the .debug_loc section.
526  const DebugLocStream &getDebugLocs() const { return DebugLocs; }
527 
528  /// Emit an entry for the debug loc section. This can be used to
529  /// handle an entry that's going to be emitted into the debug loc section.
530  void emitDebugLocEntry(ByteStreamer &Streamer,
531  const DebugLocStream::Entry &Entry);
532 
533  /// Emit the location for a debug loc entry, including the size header.
534  void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry);
535 
536  /// Find the MDNode for the given reference.
537  template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
538  return Ref.resolve();
539  }
540 
541  void addSubprogramNames(const DISubprogram *SP, DIE &Die);
542 
543  AddressPool &getAddressPool() { return AddrPool; }
544 
545  void addAccelName(StringRef Name, const DIE &Die);
546 
547  void addAccelObjC(StringRef Name, const DIE &Die);
548 
549  void addAccelNamespace(StringRef Name, const DIE &Die);
550 
551  void addAccelType(StringRef Name, const DIE &Die, char Flags);
552 
553  const MachineFunction *getCurrentFunction() const { return CurFn; }
554 
555  /// A helper function to check whether the DIE for a given Scope is
556  /// going to be null.
557  bool isLexicalScopeDIENull(LexicalScope *Scope);
558 };
559 } // End of namespace llvm
560 
561 #endif
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:40
void push_back(const T &Elt)
Definition: SmallVector.h:211
void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override
For symbols that have a size designated (e.g.
Definition: DwarfDebug.h:488
const MachineInstr * getMInsn() const
Definition: DwarfDebug.h:123
bool useAppleExtensionAttributes() const
Definition: DwarfDebug.h:510
unsigned getDebugLocListIndex() const
Definition: DwarfDebug.h:121
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
const MachineFunction * getCurrentFunction() const
Definition: DwarfDebug.h:553
Implements a dense probed hash-table based set.
Definition: DenseSet.h:202
const DIExpression * getSingleExpression() const
Definition: DwarfDebug.h:114
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:196
bool useDwarfAccelTables() const
Returns whether or not to emit tables that dwarf consumers can use to accelerate lookup.
Definition: DwarfDebug.h:508
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:32
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:736
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:830
StringRef getName() const
Definition: DwarfDebug.h:122
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:905
bool hasComplexAddress() const
Definition: DwarfDebug.h:170
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:45
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:498
const DILocation * getInlinedAt() const
Definition: DwarfDebug.h:113
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:92
void initializeDbgValue(const MachineInstr *DbgValue)
Initialize from a DBG_VALUE instruction.
Definition: DwarfDebug.h:98
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
Definition: DwarfDebug.h:502
void addArangeLabel(SymbolCU SCU)
Add a label so that arange data can be generated for it.
Definition: DwarfDebug.h:484
struct fuzzer::@269 Flags
bool isArtificial() const
Return true if DbgVariable is artificial.
Definition: DwarfDebug.h:154
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
static GCRegistry::Add< StatepointGC > D("statepoint-example","an example strategy for statepoint")
Holds a subclass of DINode.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
AddressPool & getAddressPool()
Definition: DwarfDebug.h:543
Subprogram description.
#define F(x, y, z)
Definition: MD5.cpp:51
This class is used to track local variable information.
Definition: DwarfDebug.h:64
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
DIE * getDIE() const
Definition: DwarfDebug.h:119
Debug location.
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support...
Definition: DwarfDebug.h:516
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
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:138
void addMMIEntry(const DbgVariable &V)
Definition: DwarfDebug.h:128
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
void setDIE(DIE &D)
Definition: DwarfDebug.h:118
A structured debug information entry.
Definition: DIE.h:655
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:67
T * resolve(TypedDINodeRef< T > Ref) const
Find the MDNode for the given reference.
Definition: DwarfDebug.h:537
const DIExpression * getDebugExpression() const
Return the complex address expression referenced by this DBG_VALUE instruction.
Helper used to pair up a symbol and its DWARF compile unit.
Definition: DwarfDebug.h:189
void initializeMMI(const DIExpression *E, int FI)
Initialize from the MMI table.
Definition: DwarfDebug.h:87
SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym)
Definition: DwarfDebug.h:190
An imported module (C++ using directive or similar).
void setPrevCU(const DwarfCompileUnit *PrevCU)
Definition: DwarfDebug.h:523
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
Base class for types.
const DebugLocStream & getDebugLocs() const
Returns the entries for the .debug_loc section.
Definition: DwarfDebug.h:526
DWARF expression.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:223
const DILocalVariable * getVariable() const
Definition: DwarfDebug.h:112
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:250
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
Definition: DwarfDebug.h:494
Representation of each machine instruction.
Definition: MachineInstr.h:52
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
#define N
Base class for debug information backends.
dwarf::Tag getTag() const
Definition: DwarfDebug.h:146
const DILocalVariable * getDebugVariable() const
Return the debug variable referenced by this DBG_VALUE instruction.
void setDebugLocListIndex(unsigned O)
Definition: DwarfDebug.h:120
const DwarfCompileUnit * getPrevCU() const
Returns the previous CU that was being updated.
Definition: DwarfDebug.h:522
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isObjectPointer() const
Definition: DwarfDebug.h:162
A vector that has set insertion semantics.
Definition: SetVector.h:41
std::pair< const DILocalVariable *, const DILocation * > InlinedVariable
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:83
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
Byte stream of .debug_loc entries.
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
bool hasFrameIndexExprs() const
Definition: DwarfDebug.h:126
const MCSymbol * Sym
Definition: DwarfDebug.h:191