LLVM  9.0.0svn
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"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringMap.h"
22 #include "llvm/ADT/StringRef.h"
25 #include "llvm/CodeGen/DIE.h"
28 #include "llvm/Support/Casting.h"
29 #include <algorithm>
30 #include <cassert>
31 #include <cstdint>
32 #include <memory>
33 
34 namespace llvm {
35 
36 class AsmPrinter;
37 class DwarfFile;
38 class GlobalVariable;
39 class MCExpr;
40 class MCSymbol;
41 class MDNode;
42 
43 class DwarfCompileUnit final : public DwarfUnit {
44  /// A numeric ID unique among all CUs in the module
45  unsigned UniqueID;
46  bool HasRangeLists = false;
47 
48  /// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding
49  /// the need to search for it in applyStmtList.
50  DIE::value_iterator StmtListValue;
51 
52  /// Skeleton unit associated with this unit.
53  DwarfCompileUnit *Skeleton = nullptr;
54 
55  /// The start of the unit within its section.
56  MCSymbol *LabelBegin;
57 
58  /// The start of the unit macro info within macro section.
59  MCSymbol *MacroLabelBegin;
60 
63 
64  ImportedEntityMap ImportedEntities;
65 
66  /// GlobalNames - A map of globally visible named entities for this unit.
67  StringMap<const DIE *> GlobalNames;
68 
69  /// GlobalTypes - A map of globally visible types for this unit.
70  StringMap<const DIE *> GlobalTypes;
71 
72  // List of ranges for a given compile unit.
74 
75  // The base address of this unit, if any. Used for relative references in
76  // ranges/locs.
77  const MCSymbol *BaseAddress = nullptr;
78 
79  DenseMap<const MDNode *, DIE *> AbstractSPDies;
81 
82  /// DWO ID for correlating skeleton and split units.
83  uint64_t DWOId = 0;
84 
85  /// Construct a DIE for the given DbgVariable without initializing the
86  /// DbgVariable's DIE reference.
87  DIE *constructVariableDIEImpl(const DbgVariable &DV, bool Abstract);
88 
89  bool isDwoUnit() const override;
90 
91  DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
92  if (isDwoUnit() && !DD->shareAcrossDWOCUs())
93  return AbstractSPDies;
94  return DU->getAbstractSPDies();
95  }
96 
98  if (isDwoUnit() && !DD->shareAcrossDWOCUs())
99  return AbstractEntities;
100  return DU->getAbstractEntities();
101  }
102 
103  void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
104 
105 public:
106  DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
107  DwarfDebug *DW, DwarfFile *DWU);
108 
109  bool hasRangeLists() const { return HasRangeLists; }
110  unsigned getUniqueID() const { return UniqueID; }
111 
113  return Skeleton;
114  }
115 
116  bool includeMinimalInlineScopes() const;
117 
118  void initStmtList();
119 
120  /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
121  void applyStmtList(DIE &D);
122 
123  /// A pair of GlobalVariable and DIExpression.
124  struct GlobalExpr {
127  };
128 
129  struct BaseTypeRef {
130  BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding) :
131  BitSize(BitSize), Encoding(Encoding) {}
132  unsigned BitSize;
134  DIE *Die = nullptr;
135  };
136 
137  std::vector<BaseTypeRef> ExprRefedBaseTypes;
138 
139  /// Get or create global variable DIE.
140  DIE *
142  ArrayRef<GlobalExpr> GlobalExprs);
143 
145  ArrayRef<GlobalExpr> GlobalExprs);
146 
147  void addLocationAttribute(DIE *ToDIE, const DIGlobalVariable *GV,
148  ArrayRef<GlobalExpr> GlobalExprs);
149 
150  /// addLabelAddress - Add a dwarf label attribute data and value using
151  /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
153  const MCSymbol *Label);
154 
155  /// addLocalLabelAddress - Add a dwarf label attribute data and value using
156  /// DW_FORM_addr only.
158  const MCSymbol *Label);
159 
160  DwarfCompileUnit &getCU() override { return *this; }
161 
162  unsigned getOrCreateSourceID(const DIFile *File) override;
163 
165  DIScope *Scope = IE->getScope();
166  assert(Scope && "Invalid Scope encoding!");
167  if (!isa<DILocalScope>(Scope))
168  // No need to add imported enities that are not local declaration.
169  return;
170 
171  auto *LocalScope = cast<DILocalScope>(Scope)->getNonLexicalBlockFileScope();
172  ImportedEntities[LocalScope].push_back(IE);
173  }
174 
175  /// addRange - Add an address range to the list of ranges for this unit.
176  void addRange(RangeSpan Range);
177 
178  void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
179 
180  /// Find DIE for the given subprogram and attach appropriate
181  /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
182  /// variables in this scope then create and insert DIEs for these
183  /// variables.
185 
186  void constructScopeDIE(LexicalScope *Scope,
187  SmallVectorImpl<DIE *> &FinalChildren);
188 
189  /// A helper function to construct a RangeSpanList for a given
190  /// lexical scope.
191  void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
192 
194 
196  const SmallVectorImpl<InsnRange> &Ranges);
197 
198  /// This scope represents inlined body of a function. Construct
199  /// DIE to represent this concrete inlined copy of the function.
201 
202  /// Construct new DW_TAG_lexical_block for this scope and
203  /// attach DW_AT_low_pc/DW_AT_high_pc labels.
205 
206  /// constructVariableDIE - Construct a DIE for the given DbgVariable.
207  DIE *constructVariableDIE(DbgVariable &DV, bool Abstract = false);
208 
210  DIE *&ObjectPointer);
211 
212  /// Construct a DIE for the given DbgLabel.
213  DIE *constructLabelDIE(DbgLabel &DL, const LexicalScope &Scope);
214 
215  /// A helper function to create children of a Scope DIE.
217  SmallVectorImpl<DIE *> &Children,
218  bool *HasNonScopeChildren = nullptr);
219 
220  void createBaseTypeDIEs();
221 
222  /// Construct a DIE for this subprogram scope.
224  LexicalScope *Scope);
225 
226  DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
227 
229 
230  /// Construct a call site entry DIE describing a call within \p Scope to a
231  /// callee described by \p CalleeSP. \p IsTail specifies whether the call is
232  /// a tail call. \p PCOffset must be non-zero for non-tail calls or be the
233  /// function-local offset to PC value after the call instruction.
234  DIE &constructCallSiteEntryDIE(DIE &ScopeDIE, const DISubprogram &CalleeSP,
235  bool IsTail, const MCExpr *PCOffset);
236 
237  /// Construct import_module DIE.
239 
241  void finishEntityDefinition(const DbgEntity *Entity);
242 
243  /// Find abstract variable associated with Var.
246  void createAbstractEntity(const DINode *Node, LexicalScope *Scope);
247 
248  /// Set the skeleton unit associated with this unit.
249  void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
250 
251  unsigned getHeaderSize() const override {
252  // DWARF v5 added the DWO ID to the header for split/skeleton units.
253  unsigned DWOIdSize =
254  DD->getDwarfVersion() >= 5 && DD->useSplitDwarf() ? sizeof(uint64_t)
255  : 0;
256  return DwarfUnit::getHeaderSize() + DWOIdSize;
257  }
258  unsigned getLength() {
259  return sizeof(uint32_t) + // Length field
261  }
262 
263  void emitHeader(bool UseOffsets) override;
264 
265  /// Add the DW_AT_addr_base attribute to the unit DIE.
266  void addAddrTableBase();
267 
269  assert(getSection());
270  return LabelBegin;
271  }
272 
274  return MacroLabelBegin;
275  }
276 
277  /// Add a new global name to the compile unit.
278  void addGlobalName(StringRef Name, const DIE &Die,
279  const DIScope *Context) override;
280 
281  /// Add a new global name present in a type unit to this compile unit.
282  void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context);
283 
284  /// Add a new global type to the compile unit.
285  void addGlobalType(const DIType *Ty, const DIE &Die,
286  const DIScope *Context) override;
287 
288  /// Add a new global type present in a type unit to this compile unit.
289  void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context);
290 
291  const StringMap<const DIE *> &getGlobalNames() const { return GlobalNames; }
292  const StringMap<const DIE *> &getGlobalTypes() const { return GlobalTypes; }
293 
294  /// Add DW_AT_location attribute for a DbgVariable based on provided
295  /// MachineLocation.
296  void addVariableAddress(const DbgVariable &DV, DIE &Die,
297  MachineLocation Location);
298  /// Add an address attribute to a die based on the location provided.
300  const MachineLocation &Location);
301 
302  /// Start with the address based on the location provided, and generate the
303  /// DWARF information necessary to find the actual variable (navigating the
304  /// extra location information encoded in the type) based on the starting
305  /// location. Add the DWARF information to the die.
306  void addComplexAddress(const DbgVariable &DV, DIE &Die,
307  dwarf::Attribute Attribute,
308  const MachineLocation &Location);
309 
310  /// Add a Dwarf loclistptr attribute data and value.
311  void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index);
312  void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie);
313 
314  /// Add a Dwarf expression attribute data and value.
315  void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr);
316 
317  /// Add an attribute containing an address expression to \p Die.
318  void addAddressExpr(DIE &Die, dwarf::Attribute Attribute, const MCExpr *Expr);
319 
321  DIE &SPDie);
322 
323  void applyLabelAttributes(const DbgLabel &Label, DIE &LabelDie);
324 
325  /// getRanges - Get the list of ranges for this unit.
326  const SmallVectorImpl<RangeSpan> &getRanges() const { return CURanges; }
327  SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }
328 
329  void setBaseAddress(const MCSymbol *Base) { BaseAddress = Base; }
330  const MCSymbol *getBaseAddress() const { return BaseAddress; }
331 
332  uint64_t getDWOId() const { return DWOId; }
333  void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
334 
335  bool hasDwarfPubSections() const;
336 
337  void addBaseTypeRef(DIEValueList &Die, int64_t Idx);
338 };
339 
340 } // end namespace llvm
341 
342 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
const StringMap< const DIE * > & getGlobalTypes() const
unsigned getSize() const
Definition: DIE.h:739
std::vector< BaseTypeRef > ExprRefedBaseTypes
LLVMContext & Context
virtual unsigned getHeaderSize() const
Compute the size of a header for this unit, not including the initial length field.
Definition: DwarfUnit.h:264
const MCSymbol * getBaseAddress() const
DIELoc - Represents an expression location.
Definition: DIE.h:891
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
void applyLabelAttributes(const DbgLabel &Label, DIE &LabelDie)
Attribute
Attributes.
Definition: Dwarf.h:114
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:270
This class is defined as the common parent of DbgVariable and DbgLabel such that it could levarage po...
Definition: DwarfDebug.h:67
void addRange(RangeSpan Range)
addRange - Add an address range to the list of ranges for this unit.
void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End)
DwarfCompileUnit & getCU() override
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:44
Tagged DWARF-like metadata node.
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support...
Definition: DwarfDebug.h:661
DbgEntity * getExistingAbstractEntity(const DINode *Node)
void attachRangesOrLowHighPC(DIE &D, SmallVector< RangeSpan, 2 > Ranges)
DIScope * getScope() const
DIE * getOrCreateCommonBlock(const DICommonBlock *CB, ArrayRef< GlobalExpr > GlobalExprs)
void addComplexAddress(const DbgVariable &DV, DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Start with the address based on the location provided, and generate the DWARF information necessary t...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context)
Add a new global type present in a type unit to this compile unit.
DbgValueHistoryMap::InlinedEntity InlinedEntity
Find abstract variable associated with Var.
void setDWOId(uint64_t DwoId)
void createAbstractEntity(const DINode *Node, LexicalScope *Scope)
DIE * constructInlinedScopeDIE(LexicalScope *Scope)
This scope represents inlined body of a function.
Subprogram description.
unsigned getUniqueID() const
uint64_t getDWOId() const
DenseMap< const MDNode *, DIE * > & getAbstractSPDies()
Definition: DwarfFile.h:186
This class is used to track local variable information.
Definition: DwarfDebug.h:116
void setBaseAddress(const MCSymbol *Base)
void addAddrTableBase()
Add the DW_AT_addr_base attribute to the unit DIE.
A list of DIE values.
Definition: DIE.h:627
DIE * constructVariableDIE(DbgVariable &DV, bool Abstract=false)
constructVariableDIE - Construct a DIE for the given DbgVariable.
void addAddressExpr(DIE &Die, dwarf::Attribute Attribute, const MCExpr *Expr)
Add an attribute containing an address expression to Die.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context)
Add a new global name present in a type unit to this compile unit.
void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr)
Add a Dwarf expression attribute data and value.
This class is used to track label information.
Definition: DwarfDebug.h:227
This dwarf writer support class manages information associated with a source file.
Definition: DwarfUnit.h:40
void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index)
Add a Dwarf loclistptr attribute data and value.
Instrumentation for Order File
A structured debug information entry.
Definition: DIE.h:700
DIE & getUnitDie()
Definition: DIE.h:879
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
DIE * createScopeChildrenDIE(LexicalScope *Scope, SmallVectorImpl< DIE *> &Children, bool *HasNonScopeChildren=nullptr)
A helper function to create children of a Scope DIE.
void finishEntityDefinition(const DbgEntity *Entity)
DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
void addAddress(DIE &Die, dwarf::Attribute Attribute, const MachineLocation &Location)
Add an address attribute to a die based on the location provided.
DIE * createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE)
unsigned getHeaderSize() const override
Compute the size of a header for this unit, not including the initial length field.
DenseMap< const DINode *, std::unique_ptr< DbgEntity > > & getAbstractEntities()
Definition: DwarfFile.h:190
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...
A pair of GlobalVariable and DIExpression.
void addScopeRangeList(DIE &ScopeDIE, SmallVector< RangeSpan, 2 > Range)
A helper function to construct a RangeSpanList for a given lexical scope.
std::pair< const DINode *, const DILocation * > InlinedEntity
An imported module (C++ using directive or similar).
void setSkeleton(DwarfCompileUnit &Skel)
Set the skeleton unit associated with this unit.
Base class for scope-like contexts.
DIE * constructImportedEntityDIE(const DIImportedEntity *Module)
Construct import_module DIE.
DIE * constructLabelDIE(DbgLabel &DL, const LexicalScope &Scope)
Construct a DIE for the given DbgLabel.
SmallVector< RangeSpan, 2 > takeRanges()
void constructAbstractSubprogramScopeDIE(LexicalScope *Scope)
MCSymbol * getMacroLabelBegin() const
const StringMap< const DIE * > & getGlobalNames() const
Base class for types.
BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding)
MCSection * getSection() const
Return the section that this DIEUnit will be emitted into.
Definition: DIE.h:872
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
void applySubprogramAttributesToDefinition(const DISubprogram *SP, DIE &SPDie)
void finishSubprogramDefinition(const DISubprogram *SP)
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
DWARF expression.
DIE & constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope)
Construct a DIE for this subprogram scope.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:219
This file contains constants used for implementing Dwarf debug support.
DwarfDebug * DD
Definition: DwarfUnit.h:55
const SmallVectorImpl< RangeSpan > & getRanges() const
getRanges - Get the list of ranges for this unit.
void addImportedEntity(const DIImportedEntity *IE)
DIE * getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV, ArrayRef< GlobalExpr > GlobalExprs)
Get or create global variable DIE.
void addVariableAddress(const DbgVariable &DV, DIE &Die, MachineLocation Location)
Add DW_AT_location attribute for a DbgVariable based on provided MachineLocation. ...
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie)
bool shareAcrossDWOCUs() const
Definition: DwarfDebug.cpp:488
void addBaseTypeRef(DIEValueList &Die, int64_t Idx)
DIE & constructCallSiteEntryDIE(DIE &ScopeDIE, const DISubprogram &CalleeSP, bool IsTail, const MCExpr *PCOffset)
Construct a call site entry DIE describing a call within Scope to a callee described by CalleeSP...
bool includeMinimalInlineScopes() const
DwarfCompileUnit * getSkeleton() const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label)
addLocalLabelAddress - Add a dwarf label attribute data and value using DW_FORM_addr only...
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
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 constructScopeDIE(LexicalScope *Scope, SmallVectorImpl< DIE *> &FinalChildren)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
DwarfFile * DU
Definition: DwarfUnit.h:56
void addLocationAttribute(DIE *ToDIE, const DIGlobalVariable *GV, ArrayRef< GlobalExpr > GlobalExprs)
MCSymbol * getLabelBegin() const
void applyStmtList(DIE &D)
Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
DIE * constructLexicalScopeDIE(LexicalScope *Scope)
Construct new DW_TAG_lexical_block for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels...