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 public:
104  DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
105  DwarfDebug *DW, DwarfFile *DWU);
106 
107  bool hasRangeLists() const { return HasRangeLists; }
108  unsigned getUniqueID() const { return UniqueID; }
109 
111  return Skeleton;
112  }
113 
114  bool includeMinimalInlineScopes() const;
115 
116  void initStmtList();
117 
118  /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
119  void applyStmtList(DIE &D);
120 
121  /// A pair of GlobalVariable and DIExpression.
122  struct GlobalExpr {
125  };
126 
127  struct BaseTypeRef {
128  BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding) :
129  BitSize(BitSize), Encoding(Encoding) {}
130  unsigned BitSize;
132  DIE *Die = nullptr;
133  };
134 
135  std::vector<BaseTypeRef> ExprRefedBaseTypes;
136 
137  /// Get or create global variable DIE.
138  DIE *
140  ArrayRef<GlobalExpr> GlobalExprs);
141 
143  ArrayRef<GlobalExpr> GlobalExprs);
144 
145  void addLocationAttribute(DIE *ToDIE, const DIGlobalVariable *GV,
146  ArrayRef<GlobalExpr> GlobalExprs);
147 
148  /// addLabelAddress - Add a dwarf label attribute data and value using
149  /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
151  const MCSymbol *Label);
152 
153  /// addLocalLabelAddress - Add a dwarf label attribute data and value using
154  /// DW_FORM_addr only.
156  const MCSymbol *Label);
157 
158  DwarfCompileUnit &getCU() override { return *this; }
159 
160  unsigned getOrCreateSourceID(const DIFile *File) override;
161 
163  DIScope *Scope = IE->getScope();
164  assert(Scope && "Invalid Scope encoding!");
165  if (!isa<DILocalScope>(Scope))
166  // No need to add imported enities that are not local declaration.
167  return;
168 
169  auto *LocalScope = cast<DILocalScope>(Scope)->getNonLexicalBlockFileScope();
170  ImportedEntities[LocalScope].push_back(IE);
171  }
172 
173  /// addRange - Add an address range to the list of ranges for this unit.
174  void addRange(RangeSpan Range);
175 
176  void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
177 
178  /// Find DIE for the given subprogram and attach appropriate
179  /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
180  /// variables in this scope then create and insert DIEs for these
181  /// variables.
183 
184  void constructScopeDIE(LexicalScope *Scope,
185  SmallVectorImpl<DIE *> &FinalChildren);
186 
187  /// A helper function to construct a RangeSpanList for a given
188  /// lexical scope.
189  void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
190 
192 
194  const SmallVectorImpl<InsnRange> &Ranges);
195 
196  /// This scope represents inlined body of a function. Construct
197  /// DIE to represent this concrete inlined copy of the function.
199 
200  /// Construct new DW_TAG_lexical_block for this scope and
201  /// attach DW_AT_low_pc/DW_AT_high_pc labels.
203 
204  /// constructVariableDIE - Construct a DIE for the given DbgVariable.
205  DIE *constructVariableDIE(DbgVariable &DV, bool Abstract = false);
206 
208  DIE *&ObjectPointer);
209 
210  /// Construct a DIE for the given DbgLabel.
211  DIE *constructLabelDIE(DbgLabel &DL, const LexicalScope &Scope);
212 
213  /// A helper function to create children of a Scope DIE.
215  SmallVectorImpl<DIE *> &Children,
216  bool *HasNonScopeChildren = nullptr);
217 
218  void createBaseTypeDIEs();
219 
220  /// Construct a DIE for this subprogram scope.
222  LexicalScope *Scope);
223 
224  DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
225 
227 
228  /// Construct a call site entry DIE describing a call within \p Scope to a
229  /// callee described by \p CalleeSP. \p IsTail specifies whether the call is
230  /// a tail call. \p PCOffset must be non-zero for non-tail calls or be the
231  /// function-local offset to PC value after the call instruction.
232  DIE &constructCallSiteEntryDIE(DIE &ScopeDIE, const DISubprogram &CalleeSP,
233  bool IsTail, const MCExpr *PCOffset);
234 
235  /// Construct import_module DIE.
237 
239  void finishEntityDefinition(const DbgEntity *Entity);
240 
241  /// Find abstract variable associated with Var.
244  void createAbstractEntity(const DINode *Node, LexicalScope *Scope);
245 
246  /// Set the skeleton unit associated with this unit.
247  void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
248 
249  unsigned getHeaderSize() const override {
250  // DWARF v5 added the DWO ID to the header for split/skeleton units.
251  unsigned DWOIdSize =
252  DD->getDwarfVersion() >= 5 && DD->useSplitDwarf() ? sizeof(uint64_t)
253  : 0;
254  return DwarfUnit::getHeaderSize() + DWOIdSize;
255  }
256  unsigned getLength() {
257  return sizeof(uint32_t) + // Length field
259  }
260 
261  void emitHeader(bool UseOffsets) override;
262 
263  /// Add the DW_AT_addr_base attribute to the unit DIE.
264  void addAddrTableBase();
265 
267  assert(getSection());
268  return LabelBegin;
269  }
270 
272  return MacroLabelBegin;
273  }
274 
275  /// Add a new global name to the compile unit.
276  void addGlobalName(StringRef Name, const DIE &Die,
277  const DIScope *Context) override;
278 
279  /// Add a new global name present in a type unit to this compile unit.
280  void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context);
281 
282  /// Add a new global type to the compile unit.
283  void addGlobalType(const DIType *Ty, const DIE &Die,
284  const DIScope *Context) override;
285 
286  /// Add a new global type present in a type unit to this compile unit.
287  void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context);
288 
289  const StringMap<const DIE *> &getGlobalNames() const { return GlobalNames; }
290  const StringMap<const DIE *> &getGlobalTypes() const { return GlobalTypes; }
291 
292  /// Add DW_AT_location attribute for a DbgVariable based on provided
293  /// MachineLocation.
294  void addVariableAddress(const DbgVariable &DV, DIE &Die,
295  MachineLocation Location);
296  /// Add an address attribute to a die based on the location provided.
298  const MachineLocation &Location);
299 
300  /// Start with the address based on the location provided, and generate the
301  /// DWARF information necessary to find the actual variable (navigating the
302  /// extra location information encoded in the type) based on the starting
303  /// location. Add the DWARF information to the die.
304  void addComplexAddress(const DbgVariable &DV, DIE &Die,
305  dwarf::Attribute Attribute,
306  const MachineLocation &Location);
307 
308  /// Add a Dwarf loclistptr attribute data and value.
309  void addLocationList(DIE &Die, dwarf::Attribute Attribute, unsigned Index);
310  void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie);
311 
312  /// Add a Dwarf expression attribute data and value.
313  void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr);
314 
315  /// Add an attribute containing an address expression to \p Die.
316  void addAddressExpr(DIE &Die, dwarf::Attribute Attribute, const MCExpr *Expr);
317 
319  DIE &SPDie);
320 
321  void applyLabelAttributes(const DbgLabel &Label, DIE &LabelDie);
322 
323  /// getRanges - Get the list of ranges for this unit.
324  const SmallVectorImpl<RangeSpan> &getRanges() const { return CURanges; }
325  SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }
326 
327  void setBaseAddress(const MCSymbol *Base) { BaseAddress = Base; }
328  const MCSymbol *getBaseAddress() const { return BaseAddress; }
329 
330  uint64_t getDWOId() const { return DWOId; }
331  void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
332 
333  bool hasDwarfPubSections() const;
334 
335  void addBaseTypeRef(DIEValueList &Die, int64_t Idx);
336 };
337 
338 } // end namespace llvm
339 
340 #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:280
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:658
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:232
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:484
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...