1 //===-- llvm/CodeGen/DwarfDebug.h - Dwarf Debug Framework ------*- C++ -*--===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
15 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H
17 #include "DbgValueHistoryCalculator.h"
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/SmallPtrSet.h"
26 #include "llvm/ADT/StringMap.h"
27 #include "llvm/CodeGen/DIE.h"
28 #include "llvm/CodeGen/LexicalScopes.h"
29 #include "llvm/CodeGen/MachineInstr.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/DebugLoc.h"
32 #include "llvm/MC/MCDwarf.h"
33 #include "llvm/MC/MachineLocation.h"
34 #include "llvm/Support/Allocator.h"
35 #include "llvm/Target/TargetOptions.h"
45 class DwarfCompileUnit;
49 class MachineModuleInfo;
51 //===----------------------------------------------------------------------===//
52 /// This class is used to track local variable information.
54 /// Variables can be created from allocas, in which case they're generated from
55 /// the MMI table. Such variables can have multiple expressions and frame
56 /// indices. The \a Expr and \a FrameIndices array must match.
58 /// Variables can be created from \c DBG_VALUE instructions. Those whose
59 /// location changes over time use \a DebugLocListIndex, while those with a
60 /// single instruction use \a MInsn and (optionally) a single entry of \a Expr.
62 /// Variables that have been optimized out use none of these fields.
64 const DILocalVariable *Var; /// Variable Descriptor.
65 const DILocation *IA; /// Inlined at location.
66 SmallVector<const DIExpression *, 1> Expr; /// Complex address.
67 DIE *TheDIE = nullptr; /// Variable DIE.
68 unsigned DebugLocListIndex = ~0u; /// Offset in DebugLocs.
69 const MachineInstr *MInsn = nullptr; /// DBG_VALUE instruction.
70 SmallVector<int, 1> FrameIndex; /// Frame index.
73 /// Construct a DbgVariable.
75 /// Creates a variable without any DW_AT_location. Call \a initializeMMI()
76 /// for MMI entries, or \a initializeDbgValue() for DBG_VALUE instructions.
77 DbgVariable(const DILocalVariable *V, const DILocation *IA)
80 /// Initialize from the MMI table.
81 void initializeMMI(const DIExpression *E, int FI) {
82 assert(Expr.empty() && "Already initialized?");
83 assert(FrameIndex.empty() && "Already initialized?");
84 assert(!MInsn && "Already initialized?");
86 assert((!E || E->isValid()) && "Expected valid expression");
87 assert(~FI && "Expected valid index");
90 FrameIndex.push_back(FI);
93 /// Initialize from a DBG_VALUE instruction.
94 void initializeDbgValue(const MachineInstr *DbgValue) {
95 assert(Expr.empty() && "Already initialized?");
96 assert(FrameIndex.empty() && "Already initialized?");
97 assert(!MInsn && "Already initialized?");
99 assert(Var == DbgValue->getDebugVariable() && "Wrong variable");
100 assert(IA == DbgValue->getDebugLoc()->getInlinedAt() && "Wrong inlined-at");
103 if (auto *E = DbgValue->getDebugExpression())
104 if (E->getNumElements())
109 const DILocalVariable *getVariable() const { return Var; }
110 const DILocation *getInlinedAt() const { return IA; }
111 ArrayRef<const DIExpression *> getExpression() const { return Expr; }
112 const DIExpression *getSingleExpression() const {
113 assert(MInsn && Expr.size() <= 1);
114 return Expr.size() ? Expr[0] : nullptr;
116 void setDIE(DIE &D) { TheDIE = &D; }
117 DIE *getDIE() const { return TheDIE; }
118 void setDebugLocListIndex(unsigned O) { DebugLocListIndex = O; }
119 unsigned getDebugLocListIndex() const { return DebugLocListIndex; }
120 StringRef getName() const { return Var->getName(); }
121 const MachineInstr *getMInsn() const { return MInsn; }
122 ArrayRef<int> getFrameIndex() const { return FrameIndex; }
124 void addMMIEntry(const DbgVariable &V) {
125 assert(DebugLocListIndex == ~0U && !MInsn && "not an MMI entry");
126 assert(V.DebugLocListIndex == ~0U && !V.MInsn && "not an MMI entry");
127 assert(V.Var == Var && "conflicting variable");
128 assert(V.IA == IA && "conflicting inlined-at location");
130 assert(!FrameIndex.empty() && "Expected an MMI entry");
131 assert(!V.FrameIndex.empty() && "Expected an MMI entry");
132 assert(Expr.size() == FrameIndex.size() && "Mismatched expressions");
133 assert(V.Expr.size() == V.FrameIndex.size() && "Mismatched expressions");
135 Expr.append(V.Expr.begin(), V.Expr.end());
136 FrameIndex.append(V.FrameIndex.begin(), V.FrameIndex.end());
137 assert(std::all_of(Expr.begin(), Expr.end(), [](const DIExpression *E) {
138 return E && E->isBitPiece();
139 }) && "conflicting locations for variable");
142 // Translate tag to proper Dwarf tag.
143 dwarf::Tag getTag() const {
144 // FIXME: Why don't we just infer this tag and store it all along?
145 if (Var->isParameter())
146 return dwarf::DW_TAG_formal_parameter;
148 return dwarf::DW_TAG_variable;
150 /// Return true if DbgVariable is artificial.
151 bool isArtificial() const {
152 if (Var->isArtificial())
154 if (getType()->isArtificial())
159 bool isObjectPointer() const {
160 if (Var->isObjectPointer())
162 if (getType()->isObjectPointer())
167 bool hasComplexAddress() const {
168 assert(MInsn && "Expected DBG_VALUE, not MMI variable");
169 assert(FrameIndex.empty() && "Expected DBG_VALUE, not MMI variable");
171 (Expr.empty() || (Expr.size() == 1 && Expr.back()->getNumElements())) &&
172 "Invalid Expr for DBG_VALUE");
173 return !Expr.empty();
175 bool isBlockByrefVariable() const;
176 const DIType *getType() const;
179 template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
180 return Ref.resolve();
185 /// Helper used to pair up a symbol and its DWARF compile unit.
187 SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {}
189 DwarfCompileUnit *CU;
192 /// Collects and handles dwarf debug information.
193 class DwarfDebug : public DebugHandlerBase {
194 /// All DIEValues are allocated through this allocator.
195 BumpPtrAllocator DIEValueAllocator;
197 /// Maps MDNode with its corresponding DwarfCompileUnit.
198 MapVector<const MDNode *, DwarfCompileUnit *> CUMap;
200 /// Maps a CU DIE with its corresponding DwarfCompileUnit.
201 DenseMap<const DIE *, DwarfCompileUnit *> CUDieMap;
203 /// List of all labels used in aranges generation.
204 std::vector<SymbolCU> ArangeLabels;
206 /// Size of each symbol emitted (for those symbols that have a specific size).
207 DenseMap<const MCSymbol *, uint64_t> SymSize;
209 /// Collection of abstract variables.
210 DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> AbstractVariables;
211 SmallVector<std::unique_ptr<DbgVariable>, 64> ConcreteVariables;
213 /// Collection of DebugLocEntry. Stored in a linked list so that DIELocLists
214 /// can refer to them in spite of insertions into this list.
215 DebugLocStream DebugLocs;
217 /// This is a collection of subprogram MDNodes that are processed to
219 SmallPtrSet<const MDNode *, 16> ProcessedSPNodes;
221 /// If nonnull, stores the current machine function we're processing.
222 const MachineFunction *CurFn;
224 /// If nonnull, stores the CU in which the previous subprogram was contained.
225 const DwarfCompileUnit *PrevCU;
227 /// As an optimization, there is no need to emit an entry in the directory
228 /// table for the same directory as DW_AT_comp_dir.
229 StringRef CompilationDir;
231 /// Holder for the file specific debug information.
232 DwarfFile InfoHolder;
234 /// Holders for the various debug information flags that we might need to
235 /// have exposed. See accessor functions below for description.
237 /// Map from MDNodes for user-defined types to their type signatures. Also
238 /// used to keep track of which types we have emitted type units for.
239 DenseMap<const MDNode *, uint64_t> TypeSignatures;
242 std::pair<std::unique_ptr<DwarfTypeUnit>, const DICompositeType *>, 1>
243 TypeUnitsUnderConstruction;
245 /// Whether to emit the pubnames/pubtypes sections.
246 bool HasDwarfPubSections;
248 /// Whether to use the GNU TLS opcode (instead of the standard opcode).
249 bool UseGNUTLSOpcode;
251 /// Whether to use DWARF 2 bitfields (instead of the DWARF 4 format).
252 bool UseDWARF2Bitfields;
254 /// Whether to emit all linkage names, or just abstract subprograms.
255 bool UseAllLinkageNames;
257 /// Version of dwarf we're emitting.
258 unsigned DwarfVersion;
260 /// DWARF5 Experimental Options
262 bool HasDwarfAccelTables;
263 bool HasAppleExtensionAttributes;
266 /// Separated Dwarf Variables
267 /// In general these will all be for bits that are left in the
268 /// original object file, rather than things that are meant
269 /// to be in the .dwo sections.
271 /// Holder for the skeleton information.
272 DwarfFile SkeletonHolder;
274 /// Store file names for type units under fission in a line table
275 /// header that will be emitted into debug_line.dwo.
276 // FIXME: replace this with a map from comp_dir to table so that we
277 // can emit multiple tables during LTO each of which uses directory
278 // 0, referencing the comp_dir of all the type units that use it.
279 MCDwarfDwoLineTable SplitTypeUnitFileTable;
282 /// True iff there are multiple CUs in this module.
286 AddressPool AddrPool;
288 DwarfAccelTable AccelNames;
289 DwarfAccelTable AccelObjC;
290 DwarfAccelTable AccelNamespace;
291 DwarfAccelTable AccelTypes;
293 // Identify a debugger for "tuning" the debug info.
294 DebuggerKind DebuggerTuning;
296 /// \defgroup DebuggerTuning Predicates to tune DWARF for a given debugger.
298 /// Returns whether we are "tuning" for a given debugger.
299 /// Should be used only within the constructor, to set feature flags.
301 bool tuneForGDB() const { return DebuggerTuning == DebuggerKind::GDB; }
302 bool tuneForLLDB() const { return DebuggerTuning == DebuggerKind::LLDB; }
303 bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; }
306 MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &);
308 const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() {
309 return InfoHolder.getUnits();
312 typedef DbgValueHistoryMap::InlinedVariable InlinedVariable;
314 /// Find abstract variable associated with Var.
315 DbgVariable *getExistingAbstractVariable(InlinedVariable IV,
316 const DILocalVariable *&Cleansed);
317 DbgVariable *getExistingAbstractVariable(InlinedVariable IV);
318 void createAbstractVariable(const DILocalVariable *DV, LexicalScope *Scope);
319 void ensureAbstractVariableIsCreated(InlinedVariable Var,
320 const MDNode *Scope);
321 void ensureAbstractVariableIsCreatedIfScoped(InlinedVariable Var,
322 const MDNode *Scope);
324 DbgVariable *createConcreteVariable(LexicalScope &Scope, InlinedVariable IV);
326 /// Construct a DIE for this abstract scope.
327 void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
329 void finishVariableDefinitions();
331 void finishSubprogramDefinitions();
333 /// Finish off debug information after all functions have been
335 void finalizeModuleInfo();
337 /// Emit the debug info section.
338 void emitDebugInfo();
340 /// Emit the abbreviation section.
341 void emitAbbreviations();
343 /// Emit a specified accelerator table.
344 void emitAccel(DwarfAccelTable &Accel, MCSection *Section,
345 StringRef TableName);
347 /// Emit visible names into a hashed accelerator table section.
348 void emitAccelNames();
350 /// Emit objective C classes and categories into a hashed
351 /// accelerator table section.
352 void emitAccelObjC();
354 /// Emit namespace dies into a hashed accelerator table.
355 void emitAccelNamespaces();
357 /// Emit type dies into a hashed accelerator table.
358 void emitAccelTypes();
360 /// Emit visible names into a debug pubnames section.
361 /// \param GnuStyle determines whether or not we want to emit
362 /// additional information into the table ala newer gcc for gdb
364 void emitDebugPubNames(bool GnuStyle = false);
366 /// Emit visible types into a debug pubtypes section.
367 /// \param GnuStyle determines whether or not we want to emit
368 /// additional information into the table ala newer gcc for gdb
370 void emitDebugPubTypes(bool GnuStyle = false);
372 void emitDebugPubSection(
373 bool GnuStyle, MCSection *PSec, StringRef Name,
374 const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const);
376 /// Emit null-terminated strings into a debug str section.
379 /// Emit variable locations into a debug loc section.
382 /// Emit variable locations into a debug loc dwo section.
383 void emitDebugLocDWO();
385 /// Emit address ranges into a debug aranges section.
386 void emitDebugARanges();
388 /// Emit address ranges into a debug ranges section.
389 void emitDebugRanges();
391 /// Emit macros into a debug macinfo section.
392 void emitDebugMacinfo();
393 void emitMacro(DIMacro &M);
394 void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U);
395 void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U);
397 /// DWARF 5 Experimental Split Dwarf Emitters
399 /// Initialize common features of skeleton units.
400 void initSkeletonUnit(const DwarfUnit &U, DIE &Die,
401 std::unique_ptr<DwarfCompileUnit> NewU);
403 /// Construct the split debug info compile unit for the debug info
405 DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU);
407 /// Emit the debug info dwo section.
408 void emitDebugInfoDWO();
410 /// Emit the debug abbrev dwo section.
411 void emitDebugAbbrevDWO();
413 /// Emit the debug line dwo section.
414 void emitDebugLineDWO();
416 /// Emit the debug str dwo section.
417 void emitDebugStrDWO();
419 /// Flags to let the linker know we have emitted new style pubnames. Only
420 /// emit it here if we don't have a skeleton CU for split dwarf.
421 void addGnuPubAttributes(DwarfUnit &U, DIE &D) const;
423 /// Create new DwarfCompileUnit for the given metadata node with tag
424 /// DW_TAG_compile_unit.
425 DwarfCompileUnit &constructDwarfCompileUnit(const DICompileUnit *DIUnit);
427 /// Construct imported_module or imported_declaration DIE.
428 void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
429 const DIImportedEntity *N);
431 /// Register a source line with debug info. Returns the unique
432 /// label that was emitted and which provides correspondence to the
433 /// source line list.
434 void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
437 /// Populate LexicalScope entries with variables' info.
438 void collectVariableInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP,
439 DenseSet<InlinedVariable> &ProcessedVars);
441 /// Build the location list for all DBG_VALUEs in the
442 /// function that describe the same variable.
443 void buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
444 const DbgValueHistoryMap::InstrRanges &Ranges);
446 /// Collect variable information from the side table maintained
448 void collectVariableInfoFromMMITable(DenseSet<InlinedVariable> &P);
451 //===--------------------------------------------------------------------===//
452 // Main entry points.
454 DwarfDebug(AsmPrinter *A, Module *M);
456 ~DwarfDebug() override;
458 /// Emit all Dwarf sections that should come prior to the
462 /// Emit all Dwarf sections that should come after the content.
463 void endModule() override;
465 /// Gather pre-function debug information.
466 void beginFunction(const MachineFunction *MF) override;
468 /// Gather and emit post-function debug information.
469 void endFunction(const MachineFunction *MF) override;
471 /// Process beginning of an instruction.
472 void beginInstruction(const MachineInstr *MI) override;
474 /// Perform an MD5 checksum of \p Identifier and return the lower 64 bits.
475 static uint64_t makeTypeSignature(StringRef Identifier);
477 /// Add a DIE to the set of types that we're going to pull into
479 void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier,
480 DIE &Die, const DICompositeType *CTy);
482 /// Add a label so that arange data can be generated for it.
483 void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); }
485 /// For symbols that have a size designated (e.g. common symbols),
486 /// this tracks that size.
487 void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {
491 /// Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
492 /// If not, we still might emit certain cases.
493 bool useAllLinkageNames() const { return UseAllLinkageNames; }
495 /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the
496 /// standard DW_OP_form_tls_address opcode
497 bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; }
499 /// Returns whether to use the DWARF2 format for bitfields instyead of the
501 bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; }
503 // Experimental DWARF5 features.
505 /// Returns whether or not to emit tables that dwarf consumers can
506 /// use to accelerate lookup.
507 bool useDwarfAccelTables() const { return HasDwarfAccelTables; }
509 bool useAppleExtensionAttributes() const {
510 return HasAppleExtensionAttributes;
513 /// Returns whether or not to change the current debug info for the
514 /// split dwarf proposal support.
515 bool useSplitDwarf() const { return HasSplitDwarf; }
517 /// Returns the Dwarf Version.
518 unsigned getDwarfVersion() const { return DwarfVersion; }
520 /// Returns the previous CU that was being updated
521 const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
522 void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }
524 /// Returns the entries for the .debug_loc section.
525 const DebugLocStream &getDebugLocs() const { return DebugLocs; }
527 /// Emit an entry for the debug loc section. This can be used to
528 /// handle an entry that's going to be emitted into the debug loc section.
529 void emitDebugLocEntry(ByteStreamer &Streamer,
530 const DebugLocStream::Entry &Entry);
532 /// Emit the location for a debug loc entry, including the size header.
533 void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry);
535 /// Find the MDNode for the given reference.
536 template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
537 return Ref.resolve();
540 /// Find the DwarfCompileUnit for the given CU Die.
541 DwarfCompileUnit *lookupUnit(const DIE *CU) const {
542 return CUDieMap.lookup(CU);
545 void addSubprogramNames(const DISubprogram *SP, DIE &Die);
547 AddressPool &getAddressPool() { return AddrPool; }
549 void addAccelName(StringRef Name, const DIE &Die);
551 void addAccelObjC(StringRef Name, const DIE &Die);
553 void addAccelNamespace(StringRef Name, const DIE &Die);
555 void addAccelType(StringRef Name, const DIE &Die, char Flags);
557 const MachineFunction *getCurrentFunction() const { return CurFn; }
559 /// A helper function to check whether the DIE for a given Scope is
560 /// going to be null.
561 bool isLexicalScopeDIENull(LexicalScope *Scope);
563 // FIXME: Sink these functions down into DwarfFile/Dwarf*Unit.
565 SmallPtrSet<const MDNode *, 16> &getProcessedSPNodes() {
566 return ProcessedSPNodes;
569 } // End of namespace llvm