LLVM 18.0.0git
DwarfCompileUnit.h
Go to the documentation of this file.
1//===- llvm/CodeGen/DwarfCompileUnit.h - Dwarf Compile Unit -----*- 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 compile unit.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
14#define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
15
16#include "DwarfDebug.h"
17#include "DwarfUnit.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/StringMap.h"
22#include "llvm/ADT/StringRef.h"
28#include <cassert>
29#include <cstdint>
30#include <memory>
31
32namespace llvm {
33
34class AsmPrinter;
35class DIE;
36class DIELoc;
37class DIEValueList;
38class DwarfFile;
39class GlobalVariable;
40class MCExpr;
41class MCSymbol;
42class MDNode;
43
44enum class UnitKind { Skeleton, Full };
45
46class DwarfCompileUnit final : public DwarfUnit {
47 bool HasRangeLists = false;
48
49 /// The start of the unit line section, this is also
50 /// reused in appyStmtList.
51 MCSymbol *LineTableStartSym;
52
53 /// Skeleton unit associated with this unit.
54 DwarfCompileUnit *Skeleton = nullptr;
55
56 /// The start of the unit macro info within macro section.
57 MCSymbol *MacroLabelBegin;
58
59 /// GlobalNames - A map of globally visible named entities for this unit.
60 StringMap<const DIE *> GlobalNames;
61
62 /// GlobalTypes - A map of globally visible types for this unit.
63 StringMap<const DIE *> GlobalTypes;
64
65 // List of ranges for a given compile unit.
67
68 // The base address of this unit, if any. Used for relative references in
69 // ranges/locs.
70 const MCSymbol *BaseAddress = nullptr;
71
72 using MDNodeSetVector =
75
76 // List of entities (either static locals, types or imports) that
77 // belong to subprograms within this CU.
78 MDNodeSetVector DeferredLocalDecls;
79
80 // List of concrete lexical block scopes belong to subprograms within this CU.
82
83 // List of abstract local scopes (either DISubprogram or DILexicalBlock).
84 DenseMap<const DILocalScope *, DIE *> AbstractLocalScopeDIEs;
85
87
88 /// DWO ID for correlating skeleton and split units.
89 uint64_t DWOId = 0;
90
91 const DIFile *LastFile = nullptr;
92 unsigned LastFileID;
93
94 /// \anchor applyConcreteDbgVariableAttribute
95 /// \name applyConcreteDbgVariableAttribute
96 /// Overload set which applies attributes to \c VariableDie based on
97 /// the active variant of \c DV, which is passed as the first argument.
98 ///@{
99
100 /// See \ref applyConcreteDbgVariableAttribute
101 void applyConcreteDbgVariableAttributes(const Loc::Single &Single,
102 const DbgVariable &DV,
103 DIE &VariableDie);
104 /// See \ref applyConcreteDbgVariableAttribute
105 void applyConcreteDbgVariableAttributes(const Loc::Multi &Multi,
106 const DbgVariable &DV,
107 DIE &VariableDie);
108 /// See \ref applyConcreteDbgVariableAttribute
109 void applyConcreteDbgVariableAttributes(const Loc::MMI &MMI,
110 const DbgVariable &DV,
111 DIE &VariableDie);
112 /// See \ref applyConcreteDbgVariableAttribute
113 void applyConcreteDbgVariableAttributes(const Loc::EntryValue &EntryValue,
114 const DbgVariable &DV,
115 DIE &VariableDie);
116 /// See \ref applyConcreteDbgVariableAttribute
117 void applyConcreteDbgVariableAttributes(const std::monostate &,
118 const DbgVariable &DV,
119 DIE &VariableDie);
120
121 ///@}
122
123 bool isDwoUnit() const override;
124
125 DenseMap<const DILocalScope *, DIE *> &getAbstractScopeDIEs() {
126 if (isDwoUnit() && !DD->shareAcrossDWOCUs())
127 return AbstractLocalScopeDIEs;
128 return DU->getAbstractScopeDIEs();
129 }
130
132 if (isDwoUnit() && !DD->shareAcrossDWOCUs())
133 return AbstractEntities;
134 return DU->getAbstractEntities();
135 }
136
137 void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
138
139 /// Add info for Wasm-global-based relocation.
140 void addWasmRelocBaseGlobal(DIELoc *Loc, StringRef GlobalName,
141 uint64_t GlobalIndex);
142
143public:
144 DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
145 DwarfDebug *DW, DwarfFile *DWU,
146 UnitKind Kind = UnitKind::Full);
147
148 bool hasRangeLists() const { return HasRangeLists; }
149
151 return Skeleton;
152 }
153
154 bool includeMinimalInlineScopes() const;
155
156 void initStmtList();
157
158 /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
159 void applyStmtList(DIE &D);
160
161 /// Get line table start symbol for this unit.
162 MCSymbol *getLineTableStartSym() const { return LineTableStartSym; }
163
164 /// A pair of GlobalVariable and DIExpression.
165 struct GlobalExpr {
168 };
169
170 struct BaseTypeRef {
173 unsigned BitSize;
175 DIE *Die = nullptr;
176 };
177
178 std::vector<BaseTypeRef> ExprRefedBaseTypes;
179
180 /// Get or create global variable DIE.
181 DIE *
183 ArrayRef<GlobalExpr> GlobalExprs);
184
186 ArrayRef<GlobalExpr> GlobalExprs);
187
188 void addLocationAttribute(DIE *ToDIE, const DIGlobalVariable *GV,
189 ArrayRef<GlobalExpr> GlobalExprs);
190
191 /// addLabelAddress - Add a dwarf label attribute data and value using
192 /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
194 const MCSymbol *Label);
195
196 /// addLocalLabelAddress - Add a dwarf label attribute data and value using
197 /// DW_FORM_addr only.
199 const MCSymbol *Label);
200
201 DwarfCompileUnit &getCU() override { return *this; }
202
203 unsigned getOrCreateSourceID(const DIFile *File) override;
204
205 /// addRange - Add an address range to the list of ranges for this unit.
206 void addRange(RangeSpan Range);
207
208 void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
209
210 /// Find DIE for the given subprogram and attach appropriate
211 /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
212 /// variables in this scope then create and insert DIEs for these
213 /// variables.
215
216 void constructScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE);
217
218 /// A helper function to construct a RangeSpanList for a given
219 /// lexical scope.
220 void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
221
223
225 const SmallVectorImpl<InsnRange> &Ranges);
226
227 /// This scope represents an inlined body of a function. Construct a
228 /// DIE to represent this concrete inlined copy of the function.
229 DIE *constructInlinedScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE);
230
231 /// Construct new DW_TAG_lexical_block for this scope and
232 /// attach DW_AT_low_pc/DW_AT_high_pc labels.
234
235 /// Get a DIE for the given DILexicalBlock.
236 /// Note that this function assumes that the DIE has been already created
237 /// and it's an error, if it hasn't.
239
240 /// Construct a DIE for the given DbgVariable.
241 DIE *constructVariableDIE(DbgVariable &DV, bool Abstract = false);
242
243 /// Convenience overload which writes the DIE pointer into an out variable
244 /// ObjectPointer in addition to returning it.
246 DIE *&ObjectPointer);
247
248 /// Construct a DIE for the given DbgLabel.
250
251 void createBaseTypeDIEs();
252
253 /// Construct a DIE for a given scope.
254 /// This instance of 'getOrCreateContextDIE()' can handle DILocalScope.
255 DIE *getOrCreateContextDIE(const DIScope *Ty) override;
256
257 /// Construct a DIE for this subprogram scope.
259 LexicalScope *Scope);
260
261 DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
262
264
265 /// Whether to use the GNU analog for a DWARF5 tag, attribute, or location
266 /// atom. Only applicable when emitting otherwise DWARF4-compliant debug info.
267 bool useGNUAnalogForDwarf5Feature() const;
268
269 /// This takes a DWARF 5 tag and returns it or a GNU analog.
271
272 /// This takes a DWARF 5 attribute and returns it or a GNU analog.
274
275 /// This takes a DWARF 5 location atom and either returns it or a GNU analog.
277
278 /// Construct a call site entry DIE describing a call within \p Scope to a
279 /// callee described by \p CalleeSP.
280 /// \p IsTail specifies whether the call is a tail call.
281 /// \p PCAddr points to the PC value after the call instruction.
282 /// \p CallAddr points to the PC value at the call instruction (or is null).
283 /// \p CallReg is a register location for an indirect call. For direct calls
284 /// the \p CallReg is set to 0.
285 DIE &constructCallSiteEntryDIE(DIE &ScopeDIE, const DISubprogram *CalleeSP,
286 bool IsTail, const MCSymbol *PCAddr,
287 const MCSymbol *CallAddr, unsigned CallReg);
288 /// Construct call site parameter DIEs for the \p CallSiteDIE. The \p Params
289 /// were collected by the \ref collectCallSiteParameters.
290 /// Note: The order of parameters does not matter, since debuggers recognize
291 /// call site parameters by the DW_AT_location attribute.
292 void constructCallSiteParmEntryDIEs(DIE &CallSiteDIE,
294
295 /// Get or create a DIE for an imported entity.
298
300 void finishEntityDefinition(const DbgEntity *Entity);
301
302 /// Find abstract variable associated with Var.
305 void createAbstractEntity(const DINode *Node, LexicalScope *Scope);
306
307 /// Set the skeleton unit associated with this unit.
308 void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
309
310 unsigned getHeaderSize() const override {
311 // DWARF v5 added the DWO ID to the header for split/skeleton units.
312 unsigned DWOIdSize =
313 DD->getDwarfVersion() >= 5 && DD->useSplitDwarf() ? sizeof(uint64_t)
314 : 0;
315 return DwarfUnit::getHeaderSize() + DWOIdSize;
316 }
317 unsigned getLength() {
318 return Asm->getUnitLengthFieldByteSize() + // Length field
320 }
321
322 void emitHeader(bool UseOffsets) override;
323
324 /// Add the DW_AT_addr_base attribute to the unit DIE.
325 void addAddrTableBase();
326
328 return MacroLabelBegin;
329 }
330
331 /// Add a new global name to the compile unit.
332 void addGlobalName(StringRef Name, const DIE &Die,
333 const DIScope *Context) override;
334
335 /// Add a new global name present in a type unit to this compile unit.
336 void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context);
337
338 /// Add a new global type to the compile unit.
339 void addGlobalType(const DIType *Ty, const DIE &Die,
340 const DIScope *Context) override;
341
342 /// Add a new global type present in a type unit to this compile unit.
343 void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context);
344
345 const StringMap<const DIE *> &getGlobalNames() const { return GlobalNames; }
346 const StringMap<const DIE *> &getGlobalTypes() const { return GlobalTypes; }
347
348 /// Add DW_AT_location attribute for a DbgVariable based on provided
349 /// MachineLocation.
350 void addVariableAddress(const DbgVariable &DV, DIE &Die,
351 MachineLocation Location);
352 /// Add an address attribute to a die based on the location provided.
354 const MachineLocation &Location);
355
356 /// Start with the address based on the location provided, and generate the
357 /// DWARF information necessary to find the actual variable (navigating the
358 /// extra location information encoded in the type) based on the starting
359 /// location. Add the DWARF information to the die.
360 void addComplexAddress(const DIExpression *DIExpr, DIE &Die,
362 const MachineLocation &Location);
363
364 /// Add a Dwarf loclistptr attribute data and value.
365 void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index);
366
367 /// Add attributes to \p Var which reflect the common attributes of \p
368 /// VariableDie, namely those which are not dependant on the active variant.
370 DIE &VariableDie);
371
372 /// Add a Dwarf expression attribute data and value.
373 void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr);
374
376 DIE &SPDie);
377
378 void applyLabelAttributes(const DbgLabel &Label, DIE &LabelDie);
379
380 /// getRanges - Get the list of ranges for this unit.
381 const SmallVectorImpl<RangeSpan> &getRanges() const { return CURanges; }
382 SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }
383
384 void setBaseAddress(const MCSymbol *Base) { BaseAddress = Base; }
385 const MCSymbol *getBaseAddress() const { return BaseAddress; }
386
387 uint64_t getDWOId() const { return DWOId; }
388 void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
389
390 bool hasDwarfPubSections() const;
391
392 void addBaseTypeRef(DIEValueList &Die, int64_t Idx);
393
394 MDNodeSetVector &getDeferredLocalDecls() { return DeferredLocalDecls; }
395};
396
397} // end namespace llvm
398
399#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file defines the StringMap class.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
std::string Name
bool End
Definition: ELF_riscv.cpp:478
This file defines the SmallVector class.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:84
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
Debug common block.
DIELoc - Represents an expression location.
Definition: DIE.h:1010
DIE & getUnitDie()
Definition: DIE.h:999
A list of DIE values.
Definition: DIE.h:689
A structured debug information entry.
Definition: DIE.h:819
unsigned getSize() const
Definition: DIE.h:862
DWARF expression.
An imported module (C++ using directive or similar).
Debug lexical block.
Tagged DWARF-like metadata node.
Base class for scope-like contexts.
Subprogram description.
Base class for types.
This class is defined as the common parent of DbgVariable and DbgLabel such that it could levarage po...
Definition: DwarfDebug.h:65
This class is used to track label information.
Definition: DwarfDebug.h:289
std::pair< const DINode *, const DILocation * > InlinedEntity
This class is used to track local variable information.
Definition: DwarfDebug.h:214
bool useGNUAnalogForDwarf5Feature() const
Whether to use the GNU analog for a DWARF5 tag, attribute, or location atom.
void constructCallSiteParmEntryDIEs(DIE &CallSiteDIE, SmallVector< DbgCallSiteParam, 4 > &Params)
Construct call site parameter DIEs for the CallSiteDIE.
void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End)
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
unsigned getHeaderSize() const override
Compute the size of a header for this unit, not including the initial length field.
dwarf::Tag getDwarf5OrGNUTag(dwarf::Tag Tag) const
This takes a DWARF 5 tag and returns it or a GNU analog.
DIE & updateSubprogramScopeDIE(const DISubprogram *SP)
Find DIE for the given subprogram and attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
void constructAbstractSubprogramScopeDIE(LexicalScope *Scope)
bool includeMinimalInlineScopes() const
DIE * getOrCreateImportedEntityDIE(const DIImportedEntity *IE)
Get or create a DIE for an imported entity.
SmallVector< RangeSpan, 2 > takeRanges()
void addBaseTypeRef(DIEValueList &Die, int64_t Idx)
void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context)
Add a new global name present in a type unit to this compile unit.
void finishEntityDefinition(const DbgEntity *Entity)
void addRange(RangeSpan Range)
addRange - Add an address range to the list of ranges for this unit.
void addAddrTableBase()
Add the DW_AT_addr_base attribute to the unit DIE.
DIE & constructCallSiteEntryDIE(DIE &ScopeDIE, const DISubprogram *CalleeSP, bool IsTail, const MCSymbol *PCAddr, const MCSymbol *CallAddr, unsigned CallReg)
Construct a call site entry DIE describing a call within Scope to a callee described by CalleeSP.
MCSymbol * getMacroLabelBegin() const
std::vector< BaseTypeRef > ExprRefedBaseTypes
DIE * constructInlinedScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE)
This scope represents an inlined body of a function.
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
void addScopeRangeList(DIE &ScopeDIE, SmallVector< RangeSpan, 2 > Range)
A helper function to construct a RangeSpanList for a given lexical scope.
uint64_t getDWOId() const
DIE * getOrCreateCommonBlock(const DICommonBlock *CB, ArrayRef< GlobalExpr > GlobalExprs)
void addVariableAddress(const DbgVariable &DV, DIE &Die, MachineLocation Location)
Add DW_AT_location attribute for a DbgVariable based on provided MachineLocation.
DbgValueHistoryMap::InlinedEntity InlinedEntity
Find abstract variable associated with Var.
MDNodeSetVector & getDeferredLocalDecls()
DIE * getLexicalBlockDIE(const DILexicalBlock *LB)
Get a DIE for the given DILexicalBlock.
void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
void createAbstractEntity(const DINode *Node, LexicalScope *Scope)
void applyStmtList(DIE &D)
Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
DIE * getOrCreateContextDIE(const DIScope *Ty) override
Construct a DIE for a given scope.
void applyCommonDbgVariableAttributes(const DbgVariable &Var, DIE &VariableDie)
Add attributes to Var which reflect the common attributes of VariableDie, namely those which are not ...
DIE * constructVariableDIE(DbgVariable &DV, bool Abstract=false)
Construct a DIE for the given DbgVariable.
dwarf::LocationAtom getDwarf5OrGNULocationAtom(dwarf::LocationAtom Loc) const
This takes a DWARF 5 location atom and either returns it or a GNU analog.
DIE & constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope)
Construct a DIE for this subprogram scope.
DIE * getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV, ArrayRef< GlobalExpr > GlobalExprs)
Get or create global variable DIE.
void addLocationAttribute(DIE *ToDIE, const DIGlobalVariable *GV, ArrayRef< GlobalExpr > GlobalExprs)
DwarfCompileUnit * getSkeleton() const
void applySubprogramAttributesToDefinition(const DISubprogram *SP, DIE &SPDie)
DIE * createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE)
void setSkeleton(DwarfCompileUnit &Skel)
Set the skeleton unit associated with this unit.
void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr)
Add a Dwarf expression attribute data and value.
dwarf::Attribute getDwarf5OrGNUAttr(dwarf::Attribute Attr) const
This takes a DWARF 5 attribute and returns it or a GNU analog.
void addAddress(DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Add an address attribute to a die based on the location provided.
void applyLabelAttributes(const DbgLabel &Label, DIE &LabelDie)
void setDWOId(uint64_t DwoId)
void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label)
addLocalLabelAddress - Add a dwarf label attribute data and value using DW_FORM_addr only.
DIE * constructLexicalScopeDIE(LexicalScope *Scope)
Construct new DW_TAG_lexical_block for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
MCSymbol * getLineTableStartSym() const
Get line table start symbol for this unit.
const SmallVectorImpl< RangeSpan > & getRanges() const
getRanges - Get the list of ranges for this unit.
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
void constructScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE)
const MCSymbol * getBaseAddress() const
const StringMap< const DIE * > & getGlobalNames() const
DIE * constructLabelDIE(DbgLabel &DL, const LexicalScope &Scope)
Construct a DIE for the given DbgLabel.
void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context)
Add a new global type present in a type unit to this compile unit.
DbgEntity * getExistingAbstractEntity(const DINode *Node)
const StringMap< const DIE * > & getGlobalTypes() const
void addLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label)
addLabelAddress - Add a dwarf label attribute data and value using either DW_FORM_addr or DW_FORM_GNU...
void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index)
Add a Dwarf loclistptr attribute data and value.
void addComplexAddress(const DIExpression *DIExpr, DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Start with the address based on the location provided, and generate the DWARF information necessary t...
DIE * constructImportedEntityDIE(const DIImportedEntity *IE)
DwarfCompileUnit & getCU() override
void attachRangesOrLowHighPC(DIE &D, SmallVector< RangeSpan, 2 > Ranges)
void setBaseAddress(const MCSymbol *Base)
void finishSubprogramDefinition(const DISubprogram *SP)
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:351
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:540
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
Definition: DwarfDebug.h:806
DenseMap< const DINode *, std::unique_ptr< DbgEntity > > & getAbstractEntities()
Definition: DwarfFile.h:170
DenseMap< const DILocalScope *, DIE * > & getAbstractScopeDIEs()
Definition: DwarfFile.h:166
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:35
DwarfDebug * DD
Definition: DwarfUnit.h:55
virtual unsigned getHeaderSize() const
Compute the size of a header for this unit, not including the initial length field.
Definition: DwarfUnit.h:281
DwarfFile * DU
Definition: DwarfUnit.h:56
AsmPrinter * Asm
Target of Dwarf emission.
Definition: DwarfUnit.h:46
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:44
Multi-value location description.
Definition: DwarfDebug.h:142
Single value location description.
Definition: DwarfDebug.h:131
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:451
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:112
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Attribute
Attributes.
Definition: Dwarf.h:123
LocationAtom
Definition: Dwarf.h:136
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding)
A pair of GlobalVariable and DIExpression.
Single location defined by (potentially multiple) EntryValueInfo.
Definition: DwarfDebug.h:172
Single location defined by (potentially multiple) MMI entries.
Definition: DwarfDebug.h:159