1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
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 #include "ByteStreamer.h"
15 #include "DwarfDebug.h"
18 #include "DwarfUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DIBuilder.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/ValueHandle.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/LEB128.h"
42 #include "llvm/Support/MD5.h"
43 #include "llvm/Support/Path.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
52 #define DEBUG_TYPE "dwarfdebug"
55 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
56 cl::desc("Disable debug info printing"));
58 static cl::opt<bool> UnknownLocations(
59 "use-unknown-locations", cl::Hidden,
60 cl::desc("Make an absence of debug location information explicit."),
64 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
65 cl::desc("Generate GNU-style pubnames and pubtypes"),
68 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
70 cl::desc("Generate dwarf aranges"),
74 enum DefaultOnOff { Default, Enable, Disable };
77 static cl::opt<DefaultOnOff>
78 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
79 cl::desc("Output prototype dwarf accelerator tables."),
80 cl::values(clEnumVal(Default, "Default for platform"),
81 clEnumVal(Enable, "Enabled"),
82 clEnumVal(Disable, "Disabled"), clEnumValEnd),
85 static cl::opt<DefaultOnOff>
86 SplitDwarf("split-dwarf", cl::Hidden,
87 cl::desc("Output DWARF5 split debug info."),
88 cl::values(clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"), clEnumValEnd),
93 static cl::opt<DefaultOnOff>
94 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
95 cl::desc("Generate DWARF pubnames and pubtypes sections"),
96 cl::values(clEnumVal(Default, "Default for platform"),
97 clEnumVal(Enable, "Enabled"),
98 clEnumVal(Disable, "Disabled"), clEnumValEnd),
101 static cl::opt<unsigned>
102 DwarfVersionNumber("dwarf-version", cl::Hidden,
103 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
105 static const char *const DWARFGroupName = "DWARF Emission";
106 static const char *const DbgTimerName = "DWARF Debug Writer";
108 //===----------------------------------------------------------------------===//
110 /// resolve - Look in the DwarfDebug map for the MDNode that
111 /// corresponds to the reference.
112 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
113 return DD->resolve(Ref);
116 bool DbgVariable::isBlockByrefVariable() const {
117 assert(Var.isVariable() && "Invalid complex DbgVariable!");
118 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
122 DIType DbgVariable::getType() const {
123 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
124 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
125 // addresses instead.
126 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
127 /* Byref variables, in Blocks, are declared by the programmer as
128 "SomeType VarName;", but the compiler creates a
129 __Block_byref_x_VarName struct, and gives the variable VarName
130 either the struct, or a pointer to the struct, as its type. This
131 is necessary for various behind-the-scenes things the compiler
132 needs to do with by-reference variables in blocks.
134 However, as far as the original *programmer* is concerned, the
135 variable should still have type 'SomeType', as originally declared.
137 The following function dives into the __Block_byref_x_VarName
138 struct to find the original type of the variable. This will be
139 passed back to the code generating the type for the Debug
140 Information Entry for the variable 'VarName'. 'VarName' will then
141 have the original type 'SomeType' in its debug information.
143 The original type 'SomeType' will be the type of the field named
144 'VarName' inside the __Block_byref_x_VarName struct.
146 NOTE: In order for this to not completely fail on the debugger
147 side, the Debug Information Entry for the variable VarName needs to
148 have a DW_AT_location that tells the debugger how to unwind through
149 the pointers and __Block_byref_x_VarName struct to find the actual
150 value of the variable. The function addBlockByrefType does this. */
152 uint16_t tag = Ty.getTag();
154 if (tag == dwarf::DW_TAG_pointer_type)
155 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
157 DIArray Elements = DICompositeType(subType).getTypeArray();
158 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
159 DIDerivedType DT(Elements.getElement(i));
160 if (getName() == DT.getName())
161 return (resolve(DT.getTypeDerivedFrom()));
167 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
168 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
169 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
170 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
172 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
173 : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
174 GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
175 UsedNonDefaultText(false),
176 SkeletonHolder(A, "skel_string", DIEValueAllocator),
177 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
178 dwarf::DW_FORM_data4)),
179 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
180 dwarf::DW_FORM_data4)),
181 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
182 dwarf::DW_FORM_data4)),
183 AccelTypes(TypeAtoms) {
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
186 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
187 DwarfLineSectionSym = nullptr;
188 DwarfAddrSectionSym = nullptr;
189 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
190 FunctionBeginSym = FunctionEndSym = nullptr;
194 // Turn on accelerator tables for Darwin by default, pubnames by
195 // default for non-Darwin, and handle split dwarf.
196 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
198 if (DwarfAccelTables == Default)
199 HasDwarfAccelTables = IsDarwin;
201 HasDwarfAccelTables = DwarfAccelTables == Enable;
203 if (SplitDwarf == Default)
204 HasSplitDwarf = false;
206 HasSplitDwarf = SplitDwarf == Enable;
208 if (DwarfPubSections == Default)
209 HasDwarfPubSections = !IsDarwin;
211 HasDwarfPubSections = DwarfPubSections == Enable;
213 DwarfVersion = DwarfVersionNumber
215 : MMI->getModule()->getDwarfVersion();
218 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
223 // Switch to the specified MCSection and emit an assembler
224 // temporary label to it if SymbolStem is specified.
225 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
226 const char *SymbolStem = nullptr) {
227 Asm->OutStreamer.SwitchSection(Section);
231 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
232 Asm->OutStreamer.EmitLabel(TmpSym);
236 static bool isObjCClass(StringRef Name) {
237 return Name.startswith("+") || Name.startswith("-");
240 static bool hasObjCCategory(StringRef Name) {
241 if (!isObjCClass(Name))
244 return Name.find(") ") != StringRef::npos;
247 static void getObjCClassCategory(StringRef In, StringRef &Class,
248 StringRef &Category) {
249 if (!hasObjCCategory(In)) {
250 Class = In.slice(In.find('[') + 1, In.find(' '));
255 Class = In.slice(In.find('[') + 1, In.find('('));
256 Category = In.slice(In.find('[') + 1, In.find(' '));
260 static StringRef getObjCMethodName(StringRef In) {
261 return In.slice(In.find(' ') + 1, In.find(']'));
264 // Helper for sorting sections into a stable output order.
265 static bool SectionSort(const MCSection *A, const MCSection *B) {
266 std::string LA = (A ? A->getLabelBeginName() : "");
267 std::string LB = (B ? B->getLabelBeginName() : "");
271 // Add the various names to the Dwarf accelerator table names.
272 // TODO: Determine whether or not we should add names for programs
273 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
274 // is only slightly different than the lookup of non-standard ObjC names.
275 void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
276 if (!SP.isDefinition())
278 addAccelName(SP.getName(), Die);
280 // If the linkage name is different than the name, go ahead and output
281 // that as well into the name table.
282 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
283 addAccelName(SP.getLinkageName(), Die);
285 // If this is an Objective-C selector name add it to the ObjC accelerator
287 if (isObjCClass(SP.getName())) {
288 StringRef Class, Category;
289 getObjCClassCategory(SP.getName(), Class, Category);
290 addAccelObjC(Class, Die);
292 addAccelObjC(Category, Die);
293 // Also add the base method name to the name table.
294 addAccelName(getObjCMethodName(SP.getName()), Die);
298 /// isSubprogramContext - Return true if Context is either a subprogram
299 /// or another context nested inside a subprogram.
300 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
303 DIDescriptor D(Context);
304 if (D.isSubprogram())
307 return isSubprogramContext(resolve(DIType(Context).getContext()));
311 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
312 // and DW_AT_high_pc attributes. If there are global variables in this
313 // scope then create and insert DIEs for these variables.
314 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit &SPCU,
316 DIE *SPDie = SPCU.getDIE(SP);
318 assert(SPDie && "Unable to find subprogram DIE!");
320 // If we're updating an abstract DIE, then we will be adding the children and
321 // object pointer later on. But what we don't want to do is process the
322 // concrete DIE twice.
323 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
324 // Pick up abstract subprogram DIE.
325 SPDie = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, SPCU.getUnitDie());
326 SPCU.addDIEEntry(*SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
328 DISubprogram SPDecl = SP.getFunctionDeclaration();
329 if (!SPDecl.isSubprogram()) {
330 // There is not any need to generate specification DIE for a function
331 // defined at compile unit level. If a function is defined inside another
332 // function then gdb prefers the definition at top level and but does not
333 // expect specification DIE in parent function. So avoid creating
334 // specification DIE for a function defined inside a function.
335 DIScope SPContext = resolve(SP.getContext());
336 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
337 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
338 SPCU.addFlag(*SPDie, dwarf::DW_AT_declaration);
341 DICompositeType SPTy = SP.getType();
342 DIArray Args = SPTy.getTypeArray();
343 uint16_t SPTag = SPTy.getTag();
344 if (SPTag == dwarf::DW_TAG_subroutine_type)
345 SPCU.constructSubprogramArguments(*SPDie, Args);
346 DIE *SPDeclDie = SPDie;
348 &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, SPCU.getUnitDie());
349 SPCU.addDIEEntry(*SPDie, dwarf::DW_AT_specification, SPDeclDie);
354 attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
356 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
357 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
358 SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
360 // Add name to the name table, we do this here because we're guaranteed
361 // to have concrete versions of our DW_TAG_subprogram nodes.
362 addSubprogramNames(SP, *SPDie);
367 /// Check whether we should create a DIE for the given Scope, return true
368 /// if we don't create a DIE (the corresponding DIE is null).
369 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
370 if (Scope->isAbstractScope())
373 // We don't create a DIE if there is no Range.
374 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
378 if (Ranges.size() > 1)
381 // We don't create a DIE if we have a single Range and the end label
383 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
384 MCSymbol *End = getLabelAfterInsn(RI->second);
388 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
389 dwarf::Attribute A, const MCSymbol *L,
390 const MCSymbol *Sec) {
391 if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
392 U.addSectionLabel(D, A, L);
394 U.addSectionDelta(D, A, L, Sec);
397 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
398 const SmallVectorImpl<InsnRange> &Range) {
399 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
400 // emitting it appropriately.
401 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
403 // Under fission, ranges are specified by constant offsets relative to the
404 // CU's DW_AT_GNU_ranges_base.
406 TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
407 DwarfDebugRangeSectionSym);
409 addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
410 DwarfDebugRangeSectionSym);
412 RangeSpanList List(RangeSym);
413 for (const InsnRange &R : Range) {
414 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
415 List.addRange(std::move(Span));
418 // Add the range list to the set of ranges to be emitted.
419 TheCU.addRangeList(std::move(List));
422 // Construct new DW_TAG_lexical_block for this scope and attach
423 // DW_AT_low_pc/DW_AT_high_pc labels.
424 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
425 LexicalScope *Scope) {
426 if (isLexicalScopeDIENull(Scope))
429 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
430 if (Scope->isAbstractScope())
433 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
435 // If we have multiple ranges, emit them into the range section.
436 if (ScopeRanges.size() > 1) {
437 addScopeRangeList(TheCU, *ScopeDIE, ScopeRanges);
441 // Construct the address range for this DIE.
442 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
443 MCSymbol *Start = getLabelBeforeInsn(RI->first);
444 MCSymbol *End = getLabelAfterInsn(RI->second);
445 assert(End && "End label should not be null!");
447 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
448 assert(End->isDefined() && "Invalid end label for an inlined scope!");
450 attachLowHighPC(TheCU, *ScopeDIE, Start, End);
455 // This scope represents inlined body of a function. Construct DIE to
456 // represent this concrete inlined copy of the function.
457 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
458 LexicalScope *Scope) {
459 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
460 assert(!ScopeRanges.empty() &&
461 "LexicalScope does not have instruction markers!");
463 if (!Scope->getScopeNode())
465 DIScope DS(Scope->getScopeNode());
466 DISubprogram InlinedSP = getDISubprogram(DS);
467 DIE *OriginDIE = TheCU.getDIE(InlinedSP);
469 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
473 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
474 TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
476 // If we have multiple ranges, emit them into the range section.
477 if (ScopeRanges.size() > 1)
478 addScopeRangeList(TheCU, *ScopeDIE, ScopeRanges);
480 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
481 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
482 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
484 if (!StartLabel || !EndLabel)
485 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
487 assert(StartLabel->isDefined() &&
488 "Invalid starting label for an inlined scope!");
489 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
491 attachLowHighPC(TheCU, *ScopeDIE, StartLabel, EndLabel);
494 InlinedSubprogramDIEs.insert(OriginDIE);
496 // Add the call site information to the DIE.
497 DILocation DL(Scope->getInlinedAt());
498 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
499 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
500 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
502 // Add name to the name table, we do this here because we're guaranteed
503 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
504 addSubprogramNames(InlinedSP, *ScopeDIE);
509 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit &TheCU,
511 SmallVectorImpl<DIE *> &Children) {
512 DIE *ObjectPointer = nullptr;
514 // Collect arguments for current function.
515 if (LScopes.isCurrentFunctionScope(Scope)) {
516 for (DbgVariable *ArgDV : CurrentFnArguments)
519 TheCU.constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
520 Children.push_back(Arg);
521 if (ArgDV->isObjectPointer())
525 // If this is a variadic function, add an unspecified parameter.
526 DISubprogram SP(Scope->getScopeNode());
527 DIArray FnArgs = SP.getType().getTypeArray();
528 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
529 .isUnspecifiedParameter()) {
530 DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
531 Children.push_back(Ellipsis);
535 // Collect lexical scope children first.
536 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
538 TheCU.constructVariableDIE(*DV, Scope->isAbstractScope())) {
539 Children.push_back(Variable);
540 if (DV->isObjectPointer())
541 ObjectPointer = Variable;
543 for (LexicalScope *LS : Scope->getChildren())
544 if (DIE *Nested = constructScopeDIE(TheCU, LS))
545 Children.push_back(Nested);
546 return ObjectPointer;
549 // Construct a DIE for this scope.
550 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
551 LexicalScope *Scope) {
552 if (!Scope || !Scope->getScopeNode())
555 DIScope DS(Scope->getScopeNode());
557 SmallVector<DIE *, 8> Children;
558 DIE *ObjectPointer = nullptr;
559 bool ChildrenCreated = false;
561 // We try to create the scope DIE first, then the children DIEs. This will
562 // avoid creating un-used children then removing them later when we find out
563 // the scope DIE is null.
564 DIE *ScopeDIE = nullptr;
565 if (Scope->getInlinedAt())
566 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
567 else if (DS.isSubprogram()) {
568 ProcessedSPNodes.insert(DS);
569 if (Scope->isAbstractScope()) {
570 ScopeDIE = TheCU.getDIE(DS);
571 // Note down abstract DIE.
573 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
575 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
577 // Early exit when we know the scope DIE is going to be null.
578 if (isLexicalScopeDIENull(Scope))
581 // We create children here when we know the scope DIE is not going to be
582 // null and the children will be added to the scope DIE.
583 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
584 ChildrenCreated = true;
586 // There is no need to emit empty lexical block DIE.
587 std::pair<ImportedEntityMap::const_iterator,
588 ImportedEntityMap::const_iterator> Range =
590 ScopesWithImportedEntities.begin(),
591 ScopesWithImportedEntities.end(),
592 std::pair<const MDNode *, const MDNode *>(DS, nullptr),
594 if (Children.empty() && Range.first == Range.second)
596 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
597 assert(ScopeDIE && "Scope DIE should not be null.");
598 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
600 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
604 assert(Children.empty() &&
605 "We create children only when the scope DIE is not null.");
608 if (!ChildrenCreated)
609 // We create children when the scope DIE is not null.
610 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
613 for (DIE *I : Children)
614 ScopeDIE->addChild(I);
616 if (DS.isSubprogram() && ObjectPointer != nullptr)
617 TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
622 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
623 if (!GenerateGnuPubSections)
626 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
629 // Create new DwarfCompileUnit for the given metadata node with tag
630 // DW_TAG_compile_unit.
631 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
632 StringRef FN = DIUnit.getFilename();
633 CompilationDir = DIUnit.getDirectory();
635 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
636 auto OwnedUnit = make_unique<DwarfCompileUnit>(
637 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
638 DwarfCompileUnit &NewCU = *OwnedUnit;
639 InfoHolder.addUnit(std::move(OwnedUnit));
641 // LTO with assembly output shares a single line table amongst multiple CUs.
642 // To avoid the compilation directory being ambiguous, let the line table
643 // explicitly describe the directory of all files, never relying on the
644 // compilation directory.
645 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
646 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
647 NewCU.getUniqueID(), CompilationDir);
649 NewCU.addString(*Die, dwarf::DW_AT_producer, DIUnit.getProducer());
650 NewCU.addUInt(*Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
651 DIUnit.getLanguage());
652 NewCU.addString(*Die, dwarf::DW_AT_name, FN);
654 if (!useSplitDwarf()) {
655 NewCU.initStmtList(DwarfLineSectionSym);
657 // If we're using split dwarf the compilation dir is going to be in the
658 // skeleton CU and so we don't need to duplicate it here.
659 if (!CompilationDir.empty())
660 NewCU.addString(*Die, dwarf::DW_AT_comp_dir, CompilationDir);
662 addGnuPubAttributes(NewCU, *Die);
665 if (DIUnit.isOptimized())
666 NewCU.addFlag(*Die, dwarf::DW_AT_APPLE_optimized);
668 StringRef Flags = DIUnit.getFlags();
670 NewCU.addString(*Die, dwarf::DW_AT_APPLE_flags, Flags);
672 if (unsigned RVer = DIUnit.getRunTimeVersion())
673 NewCU.addUInt(*Die, dwarf::DW_AT_APPLE_major_runtime_vers,
674 dwarf::DW_FORM_data1, RVer);
679 if (useSplitDwarf()) {
680 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
681 DwarfInfoDWOSectionSym);
682 NewCU.setSkeleton(constructSkeletonCU(NewCU));
684 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
685 DwarfInfoSectionSym);
687 CUMap.insert(std::make_pair(DIUnit, &NewCU));
688 CUDieMap.insert(std::make_pair(Die, &NewCU));
692 // Construct subprogram DIE.
693 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit &TheCU,
695 // FIXME: We should only call this routine once, however, during LTO if a
696 // program is defined in multiple CUs we could end up calling it out of
697 // beginModule as we walk the CUs.
699 DwarfCompileUnit *&CURef = SPMap[N];
705 if (!SP.isDefinition())
706 // This is a method declaration which will be handled while constructing
710 DIE &SubprogramDie = *TheCU.getOrCreateSubprogramDIE(SP);
712 // Expose as a global name.
713 TheCU.addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
716 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
718 DIImportedEntity Module(N);
719 assert(Module.Verify());
720 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
721 constructImportedEntityDIE(TheCU, Module, D);
724 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
725 const MDNode *N, DIE *Context) {
726 DIImportedEntity Module(N);
727 assert(Module.Verify());
728 return constructImportedEntityDIE(TheCU, Module, Context);
731 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
732 const DIImportedEntity &Module,
734 assert(Module.Verify() &&
735 "Use one of the MDNode * overloads to handle invalid metadata");
736 assert(Context && "Should always have a context for an imported_module");
737 DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), *Context, Module);
739 DIDescriptor Entity = resolve(Module.getEntity());
740 if (Entity.isNameSpace())
741 EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
742 else if (Entity.isSubprogram())
743 EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
744 else if (Entity.isType())
745 EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
747 EntityDie = TheCU.getDIE(Entity);
748 TheCU.addSourceLine(IMDie, Module.getLineNumber(),
749 Module.getContext().getFilename(),
750 Module.getContext().getDirectory());
751 TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
752 StringRef Name = Module.getName();
754 TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
757 // Emit all Dwarf sections that should come prior to the content. Create
758 // global DIEs and emit initial debug info sections. This is invoked by
759 // the target AsmPrinter.
760 void DwarfDebug::beginModule() {
761 if (DisableDebugInfoPrinting)
764 const Module *M = MMI->getModule();
766 // If module has named metadata anchors then use them, otherwise scan the
767 // module using debug info finder to collect debug info.
768 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
771 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
773 // Emit initial sections so we can reference labels later.
776 SingleCU = CU_Nodes->getNumOperands() == 1;
778 for (MDNode *N : CU_Nodes->operands()) {
779 DICompileUnit CUNode(N);
780 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
781 DIArray ImportedEntities = CUNode.getImportedEntities();
782 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
783 ScopesWithImportedEntities.push_back(std::make_pair(
784 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
785 ImportedEntities.getElement(i)));
786 std::sort(ScopesWithImportedEntities.begin(),
787 ScopesWithImportedEntities.end(), less_first());
788 DIArray GVs = CUNode.getGlobalVariables();
789 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
790 CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
791 DIArray SPs = CUNode.getSubprograms();
792 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
793 constructSubprogramDIE(CU, SPs.getElement(i));
794 DIArray EnumTypes = CUNode.getEnumTypes();
795 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
796 CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
797 DIArray RetainedTypes = CUNode.getRetainedTypes();
798 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
799 DIType Ty(RetainedTypes.getElement(i));
800 // The retained types array by design contains pointers to
801 // MDNodes rather than DIRefs. Unique them here.
802 DIType UniqueTy(resolve(Ty.getRef()));
803 CU.getOrCreateTypeDIE(UniqueTy);
805 // Emit imported_modules last so that the relevant context is already
807 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
808 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
811 // Tell MMI that we have debug info.
812 MMI->setDebugInfoAvailability(true);
814 // Prime section data.
815 SectionMap[Asm->getObjFileLowering().getTextSection()];
818 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
819 void DwarfDebug::computeInlinedDIEs() {
820 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
821 for (DIE *ISP : InlinedSubprogramDIEs)
822 FirstCU->addUInt(*ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
824 for (const auto &AI : AbstractSPDies) {
825 DIE &ISP = *AI.second;
826 if (InlinedSubprogramDIEs.count(&ISP))
828 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
832 // Collect info for variables that were optimized out.
833 void DwarfDebug::collectDeadVariables() {
834 const Module *M = MMI->getModule();
836 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
837 for (MDNode *N : CU_Nodes->operands()) {
838 DICompileUnit TheCU(N);
839 DIArray Subprograms = TheCU.getSubprograms();
840 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
841 DISubprogram SP(Subprograms.getElement(i));
842 if (ProcessedSPNodes.count(SP) != 0)
844 if (!SP.isSubprogram())
846 if (!SP.isDefinition())
848 DIArray Variables = SP.getVariables();
849 if (Variables.getNumElements() == 0)
852 // Construct subprogram DIE and add variables DIEs.
853 DwarfCompileUnit *SPCU =
854 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
855 assert(SPCU && "Unable to find Compile Unit!");
856 // FIXME: See the comment in constructSubprogramDIE about duplicate
858 constructSubprogramDIE(*SPCU, SP);
859 DIE *SPDIE = SPCU->getDIE(SP);
860 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
861 DIVariable DV(Variables.getElement(vi));
862 if (!DV.isVariable())
864 DbgVariable NewVar(DV, nullptr, this);
865 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
866 SPDIE->addChild(VariableDIE);
873 void DwarfDebug::finalizeModuleInfo() {
874 // Collect info for variables that were optimized out.
875 collectDeadVariables();
877 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
878 computeInlinedDIEs();
880 // Handle anything that needs to be done on a per-unit basis after
881 // all other generation.
882 for (const auto &TheU : getUnits()) {
883 // Emit DW_AT_containing_type attribute to connect types with their
884 // vtable holding type.
885 TheU->constructContainingTypeDIEs();
887 // Add CU specific attributes if we need to add any.
888 if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
889 // If we're splitting the dwarf out now that we've got the entire
890 // CU then add the dwo id to it.
891 DwarfCompileUnit *SkCU =
892 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
893 if (useSplitDwarf()) {
894 // Emit a unique identifier for this CU.
895 uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
896 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
897 dwarf::DW_FORM_data8, ID);
898 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
899 dwarf::DW_FORM_data8, ID);
901 // We don't keep track of which addresses are used in which CU so this
902 // is a bit pessimistic under LTO.
903 if (!AddrPool.isEmpty())
904 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
905 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
906 DwarfAddrSectionSym);
907 if (!TheU->getRangeLists().empty())
908 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
909 dwarf::DW_AT_GNU_ranges_base,
910 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
913 // If we have code split among multiple sections or non-contiguous
914 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
915 // remain in the .o file, otherwise add a DW_AT_low_pc.
916 // FIXME: We should use ranges allow reordering of code ala
917 // .subsections_via_symbols in mach-o. This would mean turning on
918 // ranges for all subprogram DIEs for mach-o.
919 DwarfCompileUnit &U =
920 SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
921 unsigned NumRanges = TheU->getRanges().size();
924 addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
925 Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
926 DwarfDebugRangeSectionSym);
928 // A DW_AT_low_pc attribute may also be specified in combination with
929 // DW_AT_ranges to specify the default base address for use in
930 // location lists (see Section 2.6.2) and range lists (see Section
932 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
935 RangeSpan &Range = TheU->getRanges().back();
936 U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
938 U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
945 // Compute DIE offsets and sizes.
946 InfoHolder.computeSizeAndOffsets();
948 SkeletonHolder.computeSizeAndOffsets();
951 void DwarfDebug::endSections() {
952 // Filter labels by section.
953 for (const SymbolCU &SCU : ArangeLabels) {
954 if (SCU.Sym->isInSection()) {
955 // Make a note of this symbol and it's section.
956 const MCSection *Section = &SCU.Sym->getSection();
957 if (!Section->getKind().isMetadata())
958 SectionMap[Section].push_back(SCU);
960 // Some symbols (e.g. common/bss on mach-o) can have no section but still
961 // appear in the output. This sucks as we rely on sections to build
962 // arange spans. We can do it without, but it's icky.
963 SectionMap[nullptr].push_back(SCU);
967 // Build a list of sections used.
968 std::vector<const MCSection *> Sections;
969 for (const auto &it : SectionMap) {
970 const MCSection *Section = it.first;
971 Sections.push_back(Section);
974 // Sort the sections into order.
975 // This is only done to ensure consistent output order across different runs.
976 std::sort(Sections.begin(), Sections.end(), SectionSort);
978 // Add terminating symbols for each section.
979 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
980 const MCSection *Section = Sections[ID];
981 MCSymbol *Sym = nullptr;
984 // We can't call MCSection::getLabelEndName, as it's only safe to do so
985 // if we know the section name up-front. For user-created sections, the
986 // resulting label may not be valid to use as a label. (section names can
987 // use a greater set of characters on some systems)
988 Sym = Asm->GetTempSymbol("debug_end", ID);
989 Asm->OutStreamer.SwitchSection(Section);
990 Asm->OutStreamer.EmitLabel(Sym);
993 // Insert a final terminator.
994 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
998 // Emit all Dwarf sections that should come after the content.
999 void DwarfDebug::endModule() {
1006 // End any existing sections.
1007 // TODO: Does this need to happen?
1010 // Finalize the debug info for the module.
1011 finalizeModuleInfo();
1015 // Emit all the DIEs into a debug info section.
1018 // Corresponding abbreviations into a abbrev section.
1019 emitAbbreviations();
1021 // Emit info into a debug aranges section.
1022 if (GenerateARangeSection)
1025 // Emit info into a debug ranges section.
1028 if (useSplitDwarf()) {
1031 emitDebugAbbrevDWO();
1033 // Emit DWO addresses.
1034 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1037 // Emit info into a debug loc section.
1040 // Emit info into the dwarf accelerator table sections.
1041 if (useDwarfAccelTables()) {
1044 emitAccelNamespaces();
1048 // Emit the pubnames and pubtypes sections if requested.
1049 if (HasDwarfPubSections) {
1050 emitDebugPubNames(GenerateGnuPubSections);
1051 emitDebugPubTypes(GenerateGnuPubSections);
1057 // Reset these for the next Module if we have one.
1061 // Find abstract variable, if any, associated with Var.
1062 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1063 DebugLoc ScopeLoc) {
1064 LLVMContext &Ctx = DV->getContext();
1065 // More then one inlined variable corresponds to one abstract variable.
1066 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1067 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1069 return AbsDbgVariable;
1071 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1075 AbsDbgVariable = new DbgVariable(Var, nullptr, this);
1076 addScopeVariable(Scope, AbsDbgVariable);
1077 AbstractVariables[Var] = AbsDbgVariable;
1078 return AbsDbgVariable;
1081 // If Var is a current function argument then add it to CurrentFnArguments list.
1082 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1083 if (!LScopes.isCurrentFunctionScope(Scope))
1085 DIVariable DV = Var->getVariable();
1086 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1088 unsigned ArgNo = DV.getArgNumber();
1092 size_t Size = CurrentFnArguments.size();
1094 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1095 // llvm::Function argument size is not good indicator of how many
1096 // arguments does the function have at source level.
1098 CurrentFnArguments.resize(ArgNo * 2);
1099 CurrentFnArguments[ArgNo - 1] = Var;
1103 // Collect variable information from side table maintained by MMI.
1104 void DwarfDebug::collectVariableInfoFromMMITable(
1105 SmallPtrSet<const MDNode *, 16> &Processed) {
1106 for (const auto &VI : MMI->getVariableDbgInfo()) {
1109 Processed.insert(VI.Var);
1110 DIVariable DV(VI.Var);
1111 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1113 // If variable scope is not found then skip this variable.
1117 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1118 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1119 RegVar->setFrameIndex(VI.Slot);
1120 if (!addCurrentFnArgument(RegVar, Scope))
1121 addScopeVariable(Scope, RegVar);
1123 AbsDbgVariable->setFrameIndex(VI.Slot);
1127 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1129 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1130 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1131 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1132 MI->getOperand(0).getReg() &&
1133 (MI->getOperand(1).isImm() ||
1134 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1137 // Get .debug_loc entry for the instruction range starting at MI.
1138 static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1139 const MCSymbol *FLabel,
1140 const MCSymbol *SLabel,
1141 const MachineInstr *MI,
1142 DwarfCompileUnit *Unit) {
1143 const MDNode *Var = MI->getDebugVariable();
1145 assert(MI->getNumOperands() == 3);
1146 if (MI->getOperand(0).isReg()) {
1147 MachineLocation MLoc;
1148 // If the second operand is an immediate, this is a
1149 // register-indirect address.
1150 if (!MI->getOperand(1).isImm())
1151 MLoc.set(MI->getOperand(0).getReg());
1153 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1154 return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
1156 if (MI->getOperand(0).isImm())
1157 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Var, Unit);
1158 if (MI->getOperand(0).isFPImm())
1159 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(),
1161 if (MI->getOperand(0).isCImm())
1162 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(),
1165 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1168 // Find variables for each lexical scope.
1170 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1172 // Grab the variable info that was squirreled away in the MMI side-table.
1173 collectVariableInfoFromMMITable(Processed);
1175 for (const MDNode *Var : UserVariables) {
1176 if (Processed.count(Var))
1179 // History contains relevant DBG_VALUE instructions for Var and instructions
1181 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1182 if (History.empty())
1184 const MachineInstr *MInsn = History.front();
1187 LexicalScope *Scope = nullptr;
1188 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1189 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1190 Scope = LScopes.getCurrentFunctionScope();
1191 else if (MDNode *IA = DV.getInlinedAt())
1192 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1194 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1195 // If variable scope is not found then skip this variable.
1199 Processed.insert(DV);
1200 assert(MInsn->isDebugValue() && "History must begin with debug value");
1201 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1202 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1203 if (!addCurrentFnArgument(RegVar, Scope))
1204 addScopeVariable(Scope, RegVar);
1206 AbsVar->setMInsn(MInsn);
1208 // Simplify ranges that are fully coalesced.
1209 if (History.size() <= 1 ||
1210 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1211 RegVar->setMInsn(MInsn);
1215 // Handle multiple DBG_VALUE instructions describing one variable.
1216 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1218 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1219 DebugLocList &LocList = DotDebugLocEntries.back();
1221 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1222 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1223 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1224 HI = History.begin(),
1227 const MachineInstr *Begin = *HI;
1228 assert(Begin->isDebugValue() && "Invalid History entry");
1230 // Check if DBG_VALUE is truncating a range.
1231 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1232 !Begin->getOperand(0).getReg())
1235 // Compute the range for a register location.
1236 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1237 const MCSymbol *SLabel = nullptr;
1240 // If Begin is the last instruction in History then its value is valid
1241 // until the end of the function.
1242 SLabel = FunctionEndSym;
1244 const MachineInstr *End = HI[1];
1245 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1246 << "\t" << *Begin << "\t" << *End << "\n");
1247 if (End->isDebugValue())
1248 SLabel = getLabelBeforeInsn(End);
1250 // End is a normal instruction clobbering the range.
1251 SLabel = getLabelAfterInsn(End);
1252 assert(SLabel && "Forgot label after clobber instruction");
1257 // The value is valid until the next DBG_VALUE or clobber.
1258 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1259 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1260 DebugLocEntry Loc = getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU);
1261 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1262 DebugLoc.push_back(std::move(Loc));
1266 // Collect info for variables that were optimized out.
1267 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1268 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1269 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1270 DIVariable DV(Variables.getElement(i));
1271 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1273 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1274 addScopeVariable(Scope, new DbgVariable(DV, nullptr, this));
1278 // Return Label preceding the instruction.
1279 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1280 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1281 assert(Label && "Didn't insert label before instruction");
1285 // Return Label immediately following the instruction.
1286 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1287 return LabelsAfterInsn.lookup(MI);
1290 // Process beginning of an instruction.
1291 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1294 // Check if source location changes, but ignore DBG_VALUE locations.
1295 if (!MI->isDebugValue()) {
1296 DebugLoc DL = MI->getDebugLoc();
1297 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1300 if (DL == PrologEndLoc) {
1301 Flags |= DWARF2_FLAG_PROLOGUE_END;
1302 PrologEndLoc = DebugLoc();
1304 if (PrologEndLoc.isUnknown())
1305 Flags |= DWARF2_FLAG_IS_STMT;
1307 if (!DL.isUnknown()) {
1308 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1309 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1311 recordSourceLine(0, 0, nullptr, 0);
1315 // Insert labels where requested.
1316 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1317 LabelsBeforeInsn.find(MI);
1320 if (I == LabelsBeforeInsn.end())
1323 // Label already assigned.
1328 PrevLabel = MMI->getContext().CreateTempSymbol();
1329 Asm->OutStreamer.EmitLabel(PrevLabel);
1331 I->second = PrevLabel;
1334 // Process end of an instruction.
1335 void DwarfDebug::endInstruction() {
1337 // Don't create a new label after DBG_VALUE instructions.
1338 // They don't generate code.
1339 if (!CurMI->isDebugValue())
1340 PrevLabel = nullptr;
1342 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1343 LabelsAfterInsn.find(CurMI);
1347 if (I == LabelsAfterInsn.end())
1350 // Label already assigned.
1354 // We need a label after this instruction.
1356 PrevLabel = MMI->getContext().CreateTempSymbol();
1357 Asm->OutStreamer.EmitLabel(PrevLabel);
1359 I->second = PrevLabel;
1362 // Each LexicalScope has first instruction and last instruction to mark
1363 // beginning and end of a scope respectively. Create an inverse map that list
1364 // scopes starts (and ends) with an instruction. One instruction may start (or
1365 // end) multiple scopes. Ignore scopes that are not reachable.
1366 void DwarfDebug::identifyScopeMarkers() {
1367 SmallVector<LexicalScope *, 4> WorkList;
1368 WorkList.push_back(LScopes.getCurrentFunctionScope());
1369 while (!WorkList.empty()) {
1370 LexicalScope *S = WorkList.pop_back_val();
1372 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1373 if (!Children.empty())
1374 WorkList.append(Children.begin(), Children.end());
1376 if (S->isAbstractScope())
1379 for (const InsnRange &R : S->getRanges()) {
1380 assert(R.first && "InsnRange does not have first instruction!");
1381 assert(R.second && "InsnRange does not have second instruction!");
1382 requestLabelBeforeInsn(R.first);
1383 requestLabelAfterInsn(R.second);
1388 // Gather pre-function debug information. Assumes being called immediately
1389 // after the function entry point has been emitted.
1390 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1393 // If there's no debug info for the function we're not going to do anything.
1394 if (!MMI->hasDebugInfo())
1397 // Grab the lexical scopes for the function, if we don't have any of those
1398 // then we're not going to be able to do anything.
1399 LScopes.initialize(*MF);
1400 if (LScopes.empty())
1403 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1405 // Make sure that each lexical scope will have a begin/end label.
1406 identifyScopeMarkers();
1408 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1409 // belongs to so that we add to the correct per-cu line table in the
1411 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1412 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1413 assert(TheCU && "Unable to find compile unit!");
1414 if (Asm->OutStreamer.hasRawTextSupport())
1415 // Use a single line table if we are generating assembly.
1416 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1418 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1420 // Emit a label for the function so that we have a beginning address.
1421 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1422 // Assumes in correct section after the entry point.
1423 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1425 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1426 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1427 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1429 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1431 bool AtBlockEntry = true;
1432 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1434 const MachineInstr *MI = II;
1436 if (MI->isDebugValue()) {
1437 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1439 // Keep track of user variables.
1440 const MDNode *Var = MI->getDebugVariable();
1442 // Variable is in a register, we need to check for clobbers.
1443 if (isDbgValueInDefinedReg(MI))
1444 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1446 // Check the history of this variable.
1447 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1448 if (History.empty()) {
1449 UserVariables.push_back(Var);
1450 // The first mention of a function argument gets the FunctionBeginSym
1451 // label, so arguments are visible when breaking at function entry.
1453 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1454 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1455 LabelsBeforeInsn[MI] = FunctionBeginSym;
1457 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1458 const MachineInstr *Prev = History.back();
1459 if (Prev->isDebugValue()) {
1460 // Coalesce identical entries at the end of History.
1461 if (History.size() >= 2 &&
1462 Prev->isIdenticalTo(History[History.size() - 2])) {
1463 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1464 << "\t" << *Prev << "\t"
1465 << *History[History.size() - 2] << "\n");
1469 // Terminate old register assignments that don't reach MI;
1470 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1471 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1472 isDbgValueInDefinedReg(Prev)) {
1473 // Previous register assignment needs to terminate at the end of
1475 MachineBasicBlock::const_iterator LastMI =
1476 PrevMBB->getLastNonDebugInstr();
1477 if (LastMI == PrevMBB->end()) {
1478 // Drop DBG_VALUE for empty range.
1479 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1480 << "\t" << *Prev << "\n");
1482 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1483 // Terminate after LastMI.
1484 History.push_back(LastMI);
1488 History.push_back(MI);
1490 // Not a DBG_VALUE instruction.
1491 if (!MI->isPosition())
1492 AtBlockEntry = false;
1494 // First known non-DBG_VALUE and non-frame setup location marks
1495 // the beginning of the function body.
1496 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1497 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1498 PrologEndLoc = MI->getDebugLoc();
1500 // Check if the instruction clobbers any registers with debug vars.
1501 for (const MachineOperand &MO : MI->operands()) {
1502 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1504 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1507 const MDNode *Var = LiveUserVar[Reg];
1510 // Reg is now clobbered.
1511 LiveUserVar[Reg] = nullptr;
1513 // Was MD last defined by a DBG_VALUE referring to Reg?
1514 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1515 if (HistI == DbgValues.end())
1517 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1518 if (History.empty())
1520 const MachineInstr *Prev = History.back();
1521 // Sanity-check: Register assignments are terminated at the end of
1523 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1525 // Is the variable still in Reg?
1526 if (!isDbgValueInDefinedReg(Prev) ||
1527 Prev->getOperand(0).getReg() != Reg)
1529 // Var is clobbered. Make sure the next instruction gets a label.
1530 History.push_back(MI);
1537 for (auto &I : DbgValues) {
1538 SmallVectorImpl<const MachineInstr *> &History = I.second;
1539 if (History.empty())
1542 // Make sure the final register assignments are terminated.
1543 const MachineInstr *Prev = History.back();
1544 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1545 const MachineBasicBlock *PrevMBB = Prev->getParent();
1546 MachineBasicBlock::const_iterator LastMI =
1547 PrevMBB->getLastNonDebugInstr();
1548 if (LastMI == PrevMBB->end())
1549 // Drop DBG_VALUE for empty range.
1551 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1552 // Terminate after LastMI.
1553 History.push_back(LastMI);
1556 // Request labels for the full history.
1557 for (const MachineInstr *MI : History) {
1558 if (MI->isDebugValue())
1559 requestLabelBeforeInsn(MI);
1561 requestLabelAfterInsn(MI);
1565 PrevInstLoc = DebugLoc();
1566 PrevLabel = FunctionBeginSym;
1568 // Record beginning of function.
1569 if (!PrologEndLoc.isUnknown()) {
1570 DebugLoc FnStartDL =
1571 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1573 FnStartDL.getLine(), FnStartDL.getCol(),
1574 FnStartDL.getScope(MF->getFunction()->getContext()),
1575 // We'd like to list the prologue as "not statements" but GDB behaves
1576 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1577 DWARF2_FLAG_IS_STMT);
1581 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1582 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1583 DIVariable DV = Var->getVariable();
1584 // Variables with positive arg numbers are parameters.
1585 if (unsigned ArgNum = DV.getArgNumber()) {
1586 // Keep all parameters in order at the start of the variable list to ensure
1587 // function types are correct (no out-of-order parameters)
1589 // This could be improved by only doing it for optimized builds (unoptimized
1590 // builds have the right order to begin with), searching from the back (this
1591 // would catch the unoptimized case quickly), or doing a binary search
1592 // rather than linear search.
1593 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1594 while (I != Vars.end()) {
1595 unsigned CurNum = (*I)->getVariable().getArgNumber();
1596 // A local (non-parameter) variable has been found, insert immediately
1600 // A later indexed parameter has been found, insert immediately before it.
1601 if (CurNum > ArgNum)
1605 Vars.insert(I, Var);
1609 Vars.push_back(Var);
1612 // Gather and emit post-function debug information.
1613 void DwarfDebug::endFunction(const MachineFunction *MF) {
1614 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1615 // though the beginFunction may not be called at all.
1616 // We should handle both cases.
1620 assert(CurFn == MF);
1623 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1624 // If we don't have a lexical scope for this function then there will
1625 // be a hole in the range information. Keep note of this by setting the
1626 // previously used section to nullptr.
1627 PrevSection = nullptr;
1633 // Define end label for subprogram.
1634 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1635 // Assumes in correct section after the entry point.
1636 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1638 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1639 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1641 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1642 collectVariableInfo(ProcessedVars);
1644 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1645 DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1647 // Construct abstract scopes.
1648 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1649 DISubprogram SP(AScope->getScopeNode());
1650 if (SP.isSubprogram()) {
1651 // Collect info for variables that were optimized out.
1652 DIArray Variables = SP.getVariables();
1653 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1654 DIVariable DV(Variables.getElement(i));
1655 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1657 // Check that DbgVariable for DV wasn't created earlier, when
1658 // findAbstractVariable() was called for inlined instance of DV.
1659 LLVMContext &Ctx = DV->getContext();
1660 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1661 if (AbstractVariables.lookup(CleanDV))
1663 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1664 addScopeVariable(Scope, new DbgVariable(DV, nullptr, this));
1667 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1668 constructScopeDIE(TheCU, AScope);
1671 DIE &CurFnDIE = *constructScopeDIE(TheCU, FnScope);
1672 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1673 TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1675 // Add the range of this function to the list of ranges for the CU.
1676 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1677 TheCU.addRange(std::move(Span));
1678 PrevSection = Asm->getCurrentSection();
1682 for (auto &I : ScopeVariables)
1683 DeleteContainerPointers(I.second);
1684 ScopeVariables.clear();
1685 DeleteContainerPointers(CurrentFnArguments);
1686 UserVariables.clear();
1688 AbstractVariables.clear();
1689 LabelsBeforeInsn.clear();
1690 LabelsAfterInsn.clear();
1691 PrevLabel = nullptr;
1695 // Register a source line with debug info. Returns the unique label that was
1696 // emitted and which provides correspondence to the source line list.
1697 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1702 unsigned Discriminator = 0;
1704 DIDescriptor Scope(S);
1706 if (Scope.isCompileUnit()) {
1707 DICompileUnit CU(S);
1708 Fn = CU.getFilename();
1709 Dir = CU.getDirectory();
1710 } else if (Scope.isFile()) {
1712 Fn = F.getFilename();
1713 Dir = F.getDirectory();
1714 } else if (Scope.isSubprogram()) {
1716 Fn = SP.getFilename();
1717 Dir = SP.getDirectory();
1718 } else if (Scope.isLexicalBlockFile()) {
1719 DILexicalBlockFile DBF(S);
1720 Fn = DBF.getFilename();
1721 Dir = DBF.getDirectory();
1722 } else if (Scope.isLexicalBlock()) {
1723 DILexicalBlock DB(S);
1724 Fn = DB.getFilename();
1725 Dir = DB.getDirectory();
1726 Discriminator = DB.getDiscriminator();
1728 llvm_unreachable("Unexpected scope info");
1730 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1731 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1732 .getOrCreateSourceID(Fn, Dir);
1734 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1738 //===----------------------------------------------------------------------===//
1740 //===----------------------------------------------------------------------===//
1742 // Emit initial Dwarf sections with a label at the start of each one.
1743 void DwarfDebug::emitSectionLabels() {
1744 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1746 // Dwarf sections base addresses.
1747 DwarfInfoSectionSym =
1748 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1749 if (useSplitDwarf())
1750 DwarfInfoDWOSectionSym =
1751 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1752 DwarfAbbrevSectionSym =
1753 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1754 if (useSplitDwarf())
1755 DwarfAbbrevDWOSectionSym = emitSectionSym(
1756 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1757 if (GenerateARangeSection)
1758 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1760 DwarfLineSectionSym =
1761 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1762 if (GenerateGnuPubSections) {
1763 DwarfGnuPubNamesSectionSym =
1764 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1765 DwarfGnuPubTypesSectionSym =
1766 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1767 } else if (HasDwarfPubSections) {
1768 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1769 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1772 DwarfStrSectionSym =
1773 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1774 if (useSplitDwarf()) {
1775 DwarfStrDWOSectionSym =
1776 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1777 DwarfAddrSectionSym =
1778 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1779 DwarfDebugLocSectionSym =
1780 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1782 DwarfDebugLocSectionSym =
1783 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1784 DwarfDebugRangeSectionSym =
1785 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1788 // Recursively emits a debug information entry.
1789 void DwarfDebug::emitDIE(DIE &Die) {
1790 // Get the abbreviation for this DIE.
1791 const DIEAbbrev &Abbrev = Die.getAbbrev();
1793 // Emit the code (index) for the abbreviation.
1794 if (Asm->isVerbose())
1795 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1796 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1797 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1798 dwarf::TagString(Abbrev.getTag()));
1799 Asm->EmitULEB128(Abbrev.getNumber());
1801 const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1802 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1804 // Emit the DIE attribute values.
1805 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1806 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1807 dwarf::Form Form = AbbrevData[i].getForm();
1808 assert(Form && "Too many attributes for DIE (check abbreviation)");
1810 if (Asm->isVerbose()) {
1811 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1812 if (Attr == dwarf::DW_AT_accessibility)
1813 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1814 cast<DIEInteger>(Values[i])->getValue()));
1817 // Emit an attribute using the defined form.
1818 Values[i]->EmitValue(Asm, Form);
1821 // Emit the DIE children if any.
1822 if (Abbrev.hasChildren()) {
1823 for (auto &Child : Die.getChildren())
1826 Asm->OutStreamer.AddComment("End Of Children Mark");
1831 // Emit the debug info section.
1832 void DwarfDebug::emitDebugInfo() {
1833 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1835 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1838 // Emit the abbreviation section.
1839 void DwarfDebug::emitAbbreviations() {
1840 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1842 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1845 // Emit the last address of the section and the end of the line matrix.
1846 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1847 // Define last address of section.
1848 Asm->OutStreamer.AddComment("Extended Op");
1851 Asm->OutStreamer.AddComment("Op size");
1852 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1853 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1854 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1856 Asm->OutStreamer.AddComment("Section end label");
1858 Asm->OutStreamer.EmitSymbolValue(
1859 Asm->GetTempSymbol("section_end", SectionEnd),
1860 Asm->getDataLayout().getPointerSize());
1862 // Mark end of matrix.
1863 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1869 // Emit visible names into a hashed accelerator table section.
1870 void DwarfDebug::emitAccelNames() {
1871 AccelNames.FinalizeTable(Asm, "Names");
1872 Asm->OutStreamer.SwitchSection(
1873 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1874 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1875 Asm->OutStreamer.EmitLabel(SectionBegin);
1877 // Emit the full data.
1878 AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1881 // Emit objective C classes and categories into a hashed accelerator table
1883 void DwarfDebug::emitAccelObjC() {
1884 AccelObjC.FinalizeTable(Asm, "ObjC");
1885 Asm->OutStreamer.SwitchSection(
1886 Asm->getObjFileLowering().getDwarfAccelObjCSection());
1887 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1888 Asm->OutStreamer.EmitLabel(SectionBegin);
1890 // Emit the full data.
1891 AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1894 // Emit namespace dies into a hashed accelerator table.
1895 void DwarfDebug::emitAccelNamespaces() {
1896 AccelNamespace.FinalizeTable(Asm, "namespac");
1897 Asm->OutStreamer.SwitchSection(
1898 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1899 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1900 Asm->OutStreamer.EmitLabel(SectionBegin);
1902 // Emit the full data.
1903 AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1906 // Emit type dies into a hashed accelerator table.
1907 void DwarfDebug::emitAccelTypes() {
1909 AccelTypes.FinalizeTable(Asm, "types");
1910 Asm->OutStreamer.SwitchSection(
1911 Asm->getObjFileLowering().getDwarfAccelTypesSection());
1912 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1913 Asm->OutStreamer.EmitLabel(SectionBegin);
1915 // Emit the full data.
1916 AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1919 // Public name handling.
1920 // The format for the various pubnames:
1922 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1923 // for the DIE that is named.
1925 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1926 // into the CU and the index value is computed according to the type of value
1927 // for the DIE that is named.
1929 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1930 // it's the offset within the debug_info/debug_types dwo section, however, the
1931 // reference in the pubname header doesn't change.
1933 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1934 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1936 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1938 // We could have a specification DIE that has our most of our knowledge,
1939 // look for that now.
1940 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1942 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1943 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
1944 Linkage = dwarf::GIEL_EXTERNAL;
1945 } else if (Die->findAttribute(dwarf::DW_AT_external))
1946 Linkage = dwarf::GIEL_EXTERNAL;
1948 switch (Die->getTag()) {
1949 case dwarf::DW_TAG_class_type:
1950 case dwarf::DW_TAG_structure_type:
1951 case dwarf::DW_TAG_union_type:
1952 case dwarf::DW_TAG_enumeration_type:
1953 return dwarf::PubIndexEntryDescriptor(
1954 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1955 ? dwarf::GIEL_STATIC
1956 : dwarf::GIEL_EXTERNAL);
1957 case dwarf::DW_TAG_typedef:
1958 case dwarf::DW_TAG_base_type:
1959 case dwarf::DW_TAG_subrange_type:
1960 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1961 case dwarf::DW_TAG_namespace:
1962 return dwarf::GIEK_TYPE;
1963 case dwarf::DW_TAG_subprogram:
1964 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1965 case dwarf::DW_TAG_constant:
1966 case dwarf::DW_TAG_variable:
1967 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1968 case dwarf::DW_TAG_enumerator:
1969 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1970 dwarf::GIEL_STATIC);
1972 return dwarf::GIEK_NONE;
1976 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1978 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1979 const MCSection *PSec =
1980 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1981 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1983 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1986 void DwarfDebug::emitDebugPubSection(
1987 bool GnuStyle, const MCSection *PSec, StringRef Name,
1988 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1989 for (const auto &NU : CUMap) {
1990 DwarfCompileUnit *TheU = NU.second;
1992 const auto &Globals = (TheU->*Accessor)();
1994 if (Globals.empty())
1997 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1999 unsigned ID = TheU->getUniqueID();
2001 // Start the dwarf pubnames section.
2002 Asm->OutStreamer.SwitchSection(PSec);
2005 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2006 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2007 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2008 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2010 Asm->OutStreamer.EmitLabel(BeginLabel);
2012 Asm->OutStreamer.AddComment("DWARF Version");
2013 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2015 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2016 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2018 Asm->OutStreamer.AddComment("Compilation Unit Length");
2019 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2021 // Emit the pubnames for this compilation unit.
2022 for (const auto &GI : Globals) {
2023 const char *Name = GI.getKeyData();
2024 const DIE *Entity = GI.second;
2026 Asm->OutStreamer.AddComment("DIE offset");
2027 Asm->EmitInt32(Entity->getOffset());
2030 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2031 Asm->OutStreamer.AddComment(
2032 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2033 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2034 Asm->EmitInt8(Desc.toBits());
2037 Asm->OutStreamer.AddComment("External Name");
2038 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2041 Asm->OutStreamer.AddComment("End Mark");
2043 Asm->OutStreamer.EmitLabel(EndLabel);
2047 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2048 const MCSection *PSec =
2049 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2050 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2052 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2055 // Emit visible names into a debug str section.
2056 void DwarfDebug::emitDebugStr() {
2057 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2058 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2061 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2062 const DebugLocEntry &Entry) {
2063 DIVariable DV(Entry.getVariable());
2064 if (Entry.isInt()) {
2065 DIBasicType BTy(resolve(DV.getType()));
2066 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2067 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2068 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2069 Streamer.EmitSLEB128(Entry.getInt());
2071 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2072 Streamer.EmitULEB128(Entry.getInt());
2074 } else if (Entry.isLocation()) {
2075 MachineLocation Loc = Entry.getLoc();
2076 if (!DV.hasComplexAddress())
2078 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2080 // Complex address entry.
2081 unsigned N = DV.getNumAddrElements();
2083 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2084 if (Loc.getOffset()) {
2086 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2087 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2088 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2089 Streamer.EmitSLEB128(DV.getAddrElement(1));
2091 // If first address element is OpPlus then emit
2092 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2093 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2094 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2098 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2101 // Emit remaining complex address elements.
2102 for (; i < N; ++i) {
2103 uint64_t Element = DV.getAddrElement(i);
2104 if (Element == DIBuilder::OpPlus) {
2105 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2106 Streamer.EmitULEB128(DV.getAddrElement(++i));
2107 } else if (Element == DIBuilder::OpDeref) {
2109 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2111 llvm_unreachable("unknown Opcode found in complex address");
2115 // else ... ignore constant fp. There is not any good way to
2116 // to represent them here in dwarf.
2120 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2121 Asm->OutStreamer.AddComment("Loc expr size");
2122 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2123 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2124 Asm->EmitLabelDifference(end, begin, 2);
2125 Asm->OutStreamer.EmitLabel(begin);
2127 APByteStreamer Streamer(*Asm);
2128 emitDebugLocEntry(Streamer, Entry);
2130 Asm->OutStreamer.EmitLabel(end);
2133 // Emit locations into the debug loc section.
2134 void DwarfDebug::emitDebugLoc() {
2135 // Start the dwarf loc section.
2136 Asm->OutStreamer.SwitchSection(
2137 Asm->getObjFileLowering().getDwarfLocSection());
2138 unsigned char Size = Asm->getDataLayout().getPointerSize();
2139 for (const auto &DebugLoc : DotDebugLocEntries) {
2140 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2141 for (const auto &Entry : DebugLoc.List) {
2142 // Set up the range. This range is relative to the entry point of the
2143 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2144 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2145 const DwarfCompileUnit *CU = Entry.getCU();
2146 if (CU->getRanges().size() == 1) {
2147 // Grab the begin symbol from the first range as our base.
2148 const MCSymbol *Base = CU->getRanges()[0].getStart();
2149 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2150 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2152 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2153 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2156 emitDebugLocEntryLocation(Entry);
2158 Asm->OutStreamer.EmitIntValue(0, Size);
2159 Asm->OutStreamer.EmitIntValue(0, Size);
2163 void DwarfDebug::emitDebugLocDWO() {
2164 Asm->OutStreamer.SwitchSection(
2165 Asm->getObjFileLowering().getDwarfLocDWOSection());
2166 for (const auto &DebugLoc : DotDebugLocEntries) {
2167 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2168 for (const auto &Entry : DebugLoc.List) {
2169 // Just always use start_length for now - at least that's one address
2170 // rather than two. We could get fancier and try to, say, reuse an
2171 // address we know we've emitted elsewhere (the start of the function?
2172 // The start of the CU or CU subrange that encloses this range?)
2173 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2174 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2175 Asm->EmitULEB128(idx);
2176 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2178 emitDebugLocEntryLocation(Entry);
2180 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2185 const MCSymbol *Start, *End;
2188 // Emit a debug aranges section, containing a CU lookup for any
2189 // address we can tie back to a CU.
2190 void DwarfDebug::emitDebugARanges() {
2191 // Start the dwarf aranges section.
2192 Asm->OutStreamer.SwitchSection(
2193 Asm->getObjFileLowering().getDwarfARangesSection());
2195 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2199 // Build a list of sections used.
2200 std::vector<const MCSection *> Sections;
2201 for (const auto &it : SectionMap) {
2202 const MCSection *Section = it.first;
2203 Sections.push_back(Section);
2206 // Sort the sections into order.
2207 // This is only done to ensure consistent output order across different runs.
2208 std::sort(Sections.begin(), Sections.end(), SectionSort);
2210 // Build a set of address spans, sorted by CU.
2211 for (const MCSection *Section : Sections) {
2212 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2213 if (List.size() < 2)
2216 // Sort the symbols by offset within the section.
2217 std::sort(List.begin(), List.end(),
2218 [&](const SymbolCU &A, const SymbolCU &B) {
2219 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2220 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2222 // Symbols with no order assigned should be placed at the end.
2223 // (e.g. section end labels)
2231 // If we have no section (e.g. common), just write out
2232 // individual spans for each symbol.
2234 for (const SymbolCU &Cur : List) {
2236 Span.Start = Cur.Sym;
2239 Spans[Cur.CU].push_back(Span);
2242 // Build spans between each label.
2243 const MCSymbol *StartSym = List[0].Sym;
2244 for (size_t n = 1, e = List.size(); n < e; n++) {
2245 const SymbolCU &Prev = List[n - 1];
2246 const SymbolCU &Cur = List[n];
2248 // Try and build the longest span we can within the same CU.
2249 if (Cur.CU != Prev.CU) {
2251 Span.Start = StartSym;
2253 Spans[Prev.CU].push_back(Span);
2260 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2262 // Build a list of CUs used.
2263 std::vector<DwarfCompileUnit *> CUs;
2264 for (const auto &it : Spans) {
2265 DwarfCompileUnit *CU = it.first;
2269 // Sort the CU list (again, to ensure consistent output order).
2270 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2271 return A->getUniqueID() < B->getUniqueID();
2274 // Emit an arange table for each CU we used.
2275 for (DwarfCompileUnit *CU : CUs) {
2276 std::vector<ArangeSpan> &List = Spans[CU];
2278 // Emit size of content not including length itself.
2279 unsigned ContentSize =
2280 sizeof(int16_t) + // DWARF ARange version number
2281 sizeof(int32_t) + // Offset of CU in the .debug_info section
2282 sizeof(int8_t) + // Pointer Size (in bytes)
2283 sizeof(int8_t); // Segment Size (in bytes)
2285 unsigned TupleSize = PtrSize * 2;
2287 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2289 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2291 ContentSize += Padding;
2292 ContentSize += (List.size() + 1) * TupleSize;
2294 // For each compile unit, write the list of spans it covers.
2295 Asm->OutStreamer.AddComment("Length of ARange Set");
2296 Asm->EmitInt32(ContentSize);
2297 Asm->OutStreamer.AddComment("DWARF Arange version number");
2298 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2299 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2300 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2301 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2302 Asm->EmitInt8(PtrSize);
2303 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2306 Asm->OutStreamer.EmitFill(Padding, 0xff);
2308 for (const ArangeSpan &Span : List) {
2309 Asm->EmitLabelReference(Span.Start, PtrSize);
2311 // Calculate the size as being from the span start to it's end.
2313 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2315 // For symbols without an end marker (e.g. common), we
2316 // write a single arange entry containing just that one symbol.
2317 uint64_t Size = SymSize[Span.Start];
2321 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2325 Asm->OutStreamer.AddComment("ARange terminator");
2326 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2327 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2331 // Emit visible names into a debug ranges section.
2332 void DwarfDebug::emitDebugRanges() {
2333 // Start the dwarf ranges section.
2334 Asm->OutStreamer.SwitchSection(
2335 Asm->getObjFileLowering().getDwarfRangesSection());
2337 // Size for our labels.
2338 unsigned char Size = Asm->getDataLayout().getPointerSize();
2340 // Grab the specific ranges for the compile units in the module.
2341 for (const auto &I : CUMap) {
2342 DwarfCompileUnit *TheCU = I.second;
2344 // Emit a symbol so we can find the beginning of our ranges.
2345 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2347 // Iterate over the misc ranges for the compile units in the module.
2348 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2349 // Emit our symbol so we can find the beginning of the range.
2350 Asm->OutStreamer.EmitLabel(List.getSym());
2352 for (const RangeSpan &Range : List.getRanges()) {
2353 const MCSymbol *Begin = Range.getStart();
2354 const MCSymbol *End = Range.getEnd();
2355 assert(Begin && "Range without a begin symbol?");
2356 assert(End && "Range without an end symbol?");
2357 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2358 Asm->OutStreamer.EmitSymbolValue(End, Size);
2361 // And terminate the list with two 0 values.
2362 Asm->OutStreamer.EmitIntValue(0, Size);
2363 Asm->OutStreamer.EmitIntValue(0, Size);
2366 // Now emit a range for the CU itself.
2367 if (TheCU->getRanges().size() > 1) {
2368 Asm->OutStreamer.EmitLabel(
2369 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2370 for (const RangeSpan &Range : TheCU->getRanges()) {
2371 const MCSymbol *Begin = Range.getStart();
2372 const MCSymbol *End = Range.getEnd();
2373 assert(Begin && "Range without a begin symbol?");
2374 assert(End && "Range without an end symbol?");
2375 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2376 Asm->OutStreamer.EmitSymbolValue(End, Size);
2378 // And terminate the list with two 0 values.
2379 Asm->OutStreamer.EmitIntValue(0, Size);
2380 Asm->OutStreamer.EmitIntValue(0, Size);
2385 // DWARF5 Experimental Separate Dwarf emitters.
2387 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2388 std::unique_ptr<DwarfUnit> NewU) {
2389 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2390 U.getCUNode().getSplitDebugFilename());
2392 if (!CompilationDir.empty())
2393 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2395 addGnuPubAttributes(*NewU, Die);
2397 SkeletonHolder.addUnit(std::move(NewU));
2400 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2401 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2402 // DW_AT_addr_base, DW_AT_ranges_base.
2403 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2405 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2406 auto OwnedUnit = make_unique<DwarfCompileUnit>(
2407 CU.getUniqueID(), Die, CU.getCUNode(), Asm, this, &SkeletonHolder);
2408 DwarfCompileUnit &NewCU = *OwnedUnit;
2409 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2410 DwarfInfoSectionSym);
2412 NewCU.initStmtList(DwarfLineSectionSym);
2414 initSkeletonUnit(CU, *Die, std::move(OwnedUnit));
2419 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2421 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2422 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2423 *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2425 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2426 auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), Die, CU, Asm,
2427 this, &SkeletonHolder);
2428 DwarfTypeUnit &NewTU = *OwnedUnit;
2429 NewTU.setTypeSignature(TU.getTypeSignature());
2430 NewTU.setType(nullptr);
2432 Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2434 initSkeletonUnit(TU, *Die, std::move(OwnedUnit));
2438 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2439 // compile units that would normally be in debug_info.
2440 void DwarfDebug::emitDebugInfoDWO() {
2441 assert(useSplitDwarf() && "No split dwarf debug info?");
2442 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2443 // emit relocations into the dwo file.
2444 InfoHolder.emitUnits(this, /* AbbrevSymbol */nullptr);
2447 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2448 // abbreviations for the .debug_info.dwo section.
2449 void DwarfDebug::emitDebugAbbrevDWO() {
2450 assert(useSplitDwarf() && "No split dwarf?");
2451 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2454 void DwarfDebug::emitDebugLineDWO() {
2455 assert(useSplitDwarf() && "No split dwarf?");
2456 Asm->OutStreamer.SwitchSection(
2457 Asm->getObjFileLowering().getDwarfLineDWOSection());
2458 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2461 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2462 // string section and is identical in format to traditional .debug_str
2464 void DwarfDebug::emitDebugStrDWO() {
2465 assert(useSplitDwarf() && "No split dwarf?");
2466 const MCSection *OffSec =
2467 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2468 const MCSymbol *StrSym = DwarfStrSectionSym;
2469 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2473 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2474 if (!useSplitDwarf())
2477 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2478 return &SplitTypeUnitFileTable;
2481 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2482 StringRef Identifier, DIE &RefDie,
2483 DICompositeType CTy) {
2484 // Flag the type unit reference as a declaration so that if it contains
2485 // members (implicit special members, static data member definitions, member
2486 // declarations for definitions in this CU, etc) consumers don't get confused
2487 // and think this is a full definition.
2488 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2490 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2492 CU.addDIETypeSignature(RefDie, *TU);
2496 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2498 make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), UnitDie, CU, Asm,
2499 this, &InfoHolder, getDwoLineTable(CU));
2500 DwarfTypeUnit &NewTU = *OwnedUnit;
2502 InfoHolder.addUnit(std::move(OwnedUnit));
2504 NewTU.addUInt(*UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2508 Hash.update(Identifier);
2509 // ... take the least significant 8 bytes and return those. Our MD5
2510 // implementation always returns its results in little endian, swap bytes
2512 MD5::MD5Result Result;
2514 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2515 NewTU.setTypeSignature(Signature);
2516 if (useSplitDwarf())
2517 NewTU.setSkeleton(constructSkeletonTU(NewTU));
2519 CU.applyStmtList(*UnitDie);
2521 NewTU.setType(NewTU.createTypeDIE(CTy));
2525 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2526 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2528 CU.addDIETypeSignature(RefDie, NewTU);
2531 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2532 MCSymbol *Begin, MCSymbol *End) {
2533 Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2534 if (DwarfVersion < 4)
2535 Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2537 Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2540 // Accelerator table mutators - add each name along with its companion
2541 // DIE to the proper table while ensuring that the name that we're going
2542 // to reference is in the string table. We do this since the names we
2543 // add may not only be identical to the names in the DIE.
2544 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2545 if (!useDwarfAccelTables())
2547 InfoHolder.getStringPoolEntry(Name);
2548 AccelNames.AddName(Name, &Die);
2551 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2552 if (!useDwarfAccelTables())
2554 InfoHolder.getStringPoolEntry(Name);
2555 AccelObjC.AddName(Name, &Die);
2558 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2559 if (!useDwarfAccelTables())
2561 InfoHolder.getStringPoolEntry(Name);
2562 AccelNamespace.AddName(Name, &Die);
2565 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2566 if (!useDwarfAccelTables())
2568 InfoHolder.getStringPoolEntry(Name);
2569 AccelTypes.AddName(Name, &Die, Flags);