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 const char *const DWARFGroupName = "DWARF Emission";
102 static const char *const DbgTimerName = "DWARF Debug Writer";
104 //===----------------------------------------------------------------------===//
106 /// resolve - Look in the DwarfDebug map for the MDNode that
107 /// corresponds to the reference.
108 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
109 return DD->resolve(Ref);
112 bool DbgVariable::isBlockByrefVariable() const {
113 assert(Var.isVariable() && "Invalid complex DbgVariable!");
114 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
117 DIType DbgVariable::getType() const {
118 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
119 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
120 // addresses instead.
121 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
122 /* Byref variables, in Blocks, are declared by the programmer as
123 "SomeType VarName;", but the compiler creates a
124 __Block_byref_x_VarName struct, and gives the variable VarName
125 either the struct, or a pointer to the struct, as its type. This
126 is necessary for various behind-the-scenes things the compiler
127 needs to do with by-reference variables in blocks.
129 However, as far as the original *programmer* is concerned, the
130 variable should still have type 'SomeType', as originally declared.
132 The following function dives into the __Block_byref_x_VarName
133 struct to find the original type of the variable. This will be
134 passed back to the code generating the type for the Debug
135 Information Entry for the variable 'VarName'. 'VarName' will then
136 have the original type 'SomeType' in its debug information.
138 The original type 'SomeType' will be the type of the field named
139 'VarName' inside the __Block_byref_x_VarName struct.
141 NOTE: In order for this to not completely fail on the debugger
142 side, the Debug Information Entry for the variable VarName needs to
143 have a DW_AT_location that tells the debugger how to unwind through
144 the pointers and __Block_byref_x_VarName struct to find the actual
145 value of the variable. The function addBlockByrefType does this. */
147 uint16_t tag = Ty.getTag();
149 if (tag == dwarf::DW_TAG_pointer_type)
150 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
152 DIArray Elements = DICompositeType(subType).getTypeArray();
153 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
154 DIDerivedType DT(Elements.getElement(i));
155 if (getName() == DT.getName())
156 return (resolve(DT.getTypeDerivedFrom()));
162 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
163 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
164 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
165 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
167 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
168 : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
169 GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
170 UsedNonDefaultText(false),
171 SkeletonHolder(A, "skel_string", DIEValueAllocator),
172 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
173 dwarf::DW_FORM_data4)),
174 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
175 dwarf::DW_FORM_data4)),
176 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
177 dwarf::DW_FORM_data4)),
178 AccelTypes(TypeAtoms) {
180 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
181 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
182 DwarfLineSectionSym = nullptr;
183 DwarfAddrSectionSym = nullptr;
184 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
185 FunctionBeginSym = FunctionEndSym = nullptr;
189 // Turn on accelerator tables for Darwin by default, pubnames by
190 // default for non-Darwin, and handle split dwarf.
191 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
193 if (DwarfAccelTables == Default)
194 HasDwarfAccelTables = IsDarwin;
196 HasDwarfAccelTables = DwarfAccelTables == Enable;
198 if (SplitDwarf == Default)
199 HasSplitDwarf = false;
201 HasSplitDwarf = SplitDwarf == Enable;
203 if (DwarfPubSections == Default)
204 HasDwarfPubSections = !IsDarwin;
206 HasDwarfPubSections = DwarfPubSections == Enable;
208 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
209 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
210 : MMI->getModule()->getDwarfVersion();
212 Asm->OutStreamer.getContext().setDwarfVersion(DwarfVersion);
215 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
220 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
221 DwarfDebug::~DwarfDebug() { }
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.getOrCreateSubprogramDIE(SP);
318 attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
320 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
321 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
322 SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
324 // Add name to the name table, we do this here because we're guaranteed
325 // to have concrete versions of our DW_TAG_subprogram nodes.
326 addSubprogramNames(SP, *SPDie);
331 /// Check whether we should create a DIE for the given Scope, return true
332 /// if we don't create a DIE (the corresponding DIE is null).
333 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
334 if (Scope->isAbstractScope())
337 // We don't create a DIE if there is no Range.
338 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
342 if (Ranges.size() > 1)
345 // We don't create a DIE if we have a single Range and the end label
347 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
348 MCSymbol *End = getLabelAfterInsn(RI->second);
352 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
353 dwarf::Attribute A, const MCSymbol *L,
354 const MCSymbol *Sec) {
355 if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
356 U.addSectionLabel(D, A, L);
358 U.addSectionDelta(D, A, L, Sec);
361 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
362 const SmallVectorImpl<InsnRange> &Range) {
363 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
364 // emitting it appropriately.
365 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
367 // Under fission, ranges are specified by constant offsets relative to the
368 // CU's DW_AT_GNU_ranges_base.
370 TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
371 DwarfDebugRangeSectionSym);
373 addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
374 DwarfDebugRangeSectionSym);
376 RangeSpanList List(RangeSym);
377 for (const InsnRange &R : Range) {
378 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
379 List.addRange(std::move(Span));
382 // Add the range list to the set of ranges to be emitted.
383 TheCU.addRangeList(std::move(List));
386 void DwarfDebug::attachRangesOrLowHighPC(DwarfCompileUnit &TheCU, DIE &Die,
387 const SmallVectorImpl<InsnRange> &Ranges) {
388 assert(!Ranges.empty());
389 if (Ranges.size() == 1)
390 attachLowHighPC(TheCU, Die, getLabelBeforeInsn(Ranges.front().first),
391 getLabelAfterInsn(Ranges.front().second));
393 addScopeRangeList(TheCU, Die, Ranges);
396 // Construct new DW_TAG_lexical_block for this scope and attach
397 // DW_AT_low_pc/DW_AT_high_pc labels.
399 DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
400 LexicalScope *Scope) {
401 if (isLexicalScopeDIENull(Scope))
404 auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
405 if (Scope->isAbstractScope())
408 attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
413 // This scope represents inlined body of a function. Construct DIE to
414 // represent this concrete inlined copy of the function.
416 DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
417 LexicalScope *Scope) {
418 assert(Scope->getScopeNode());
419 DIScope DS(Scope->getScopeNode());
420 DISubprogram InlinedSP = getDISubprogram(DS);
421 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
422 // was inlined from another compile unit.
423 DIE *OriginDIE = AbstractSPDies[InlinedSP];
424 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
426 auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
427 TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
429 attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
431 InlinedSubprogramDIEs.insert(OriginDIE);
433 // Add the call site information to the DIE.
434 DILocation DL(Scope->getInlinedAt());
435 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
436 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
437 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
439 // Add name to the name table, we do this here because we're guaranteed
440 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
441 addSubprogramNames(InlinedSP, *ScopeDIE);
446 static std::unique_ptr<DIE> constructVariableDIE(DwarfCompileUnit &TheCU,
448 const LexicalScope &Scope,
449 DIE *&ObjectPointer) {
450 auto Var = TheCU.constructVariableDIE(DV, Scope.isAbstractScope());
451 if (DV.isObjectPointer())
452 ObjectPointer = Var.get();
456 DIE *DwarfDebug::createScopeChildrenDIE(
457 DwarfCompileUnit &TheCU, LexicalScope *Scope,
458 SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
459 DIE *ObjectPointer = nullptr;
461 // Collect arguments for current function.
462 if (LScopes.isCurrentFunctionScope(Scope)) {
463 for (DbgVariable *ArgDV : CurrentFnArguments)
466 constructVariableDIE(TheCU, *ArgDV, *Scope, ObjectPointer));
468 // If this is a variadic function, add an unspecified parameter.
469 DISubprogram SP(Scope->getScopeNode());
470 DIArray FnArgs = SP.getType().getTypeArray();
471 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
472 .isUnspecifiedParameter()) {
474 make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
478 // Collect lexical scope children first.
479 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
480 Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
482 for (LexicalScope *LS : Scope->getChildren())
483 if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
484 Children.push_back(std::move(Nested));
485 return ObjectPointer;
488 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
489 LexicalScope *Scope, DIE &ScopeDIE) {
490 // We create children when the scope DIE is not null.
491 SmallVector<std::unique_ptr<DIE>, 8> Children;
492 if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
493 TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
496 for (auto &I : Children)
497 ScopeDIE.addChild(std::move(I));
500 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
501 LexicalScope *Scope) {
502 assert(Scope && Scope->getScopeNode());
503 assert(Scope->isAbstractScope());
504 assert(!Scope->getInlinedAt());
506 DISubprogram SP(Scope->getScopeNode());
508 ProcessedSPNodes.insert(SP);
510 DIE *&AbsDef = AbstractSPDies[SP];
514 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
515 // was inlined from another compile unit.
516 DwarfCompileUnit &SPCU = *SPMap[SP];
519 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
520 // the important distinction that the DIDescriptor is not associated with the
521 // DIE (since the DIDescriptor will be associated with the concrete DIE, if
522 // any). It could be refactored to some common utility function.
523 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
524 ContextDIE = &SPCU.getUnitDie();
525 SPCU.getOrCreateSubprogramDIE(SPDecl);
527 ContextDIE = SPCU.getOrCreateContextDIE(resolve(SP.getContext()));
529 // Passing null as the associated DIDescriptor because the abstract definition
530 // shouldn't be found by lookup.
531 AbsDef = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE,
533 SPCU.applySubprogramAttributesToDefinition(SP, *AbsDef);
535 SPCU.addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
536 createAndAddScopeChildren(SPCU, Scope, *AbsDef);
539 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
540 LexicalScope *Scope) {
541 assert(Scope && Scope->getScopeNode());
542 assert(!Scope->getInlinedAt());
543 assert(!Scope->isAbstractScope());
544 DISubprogram Sub(Scope->getScopeNode());
546 assert(Sub.isSubprogram());
548 ProcessedSPNodes.insert(Sub);
550 DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
552 createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
557 // Construct a DIE for this scope.
558 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
559 LexicalScope *Scope) {
560 if (!Scope || !Scope->getScopeNode())
563 DIScope DS(Scope->getScopeNode());
565 assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
566 "Only handle inlined subprograms here, use "
567 "constructSubprogramScopeDIE for non-inlined "
570 SmallVector<std::unique_ptr<DIE>, 8> Children;
572 // We try to create the scope DIE first, then the children DIEs. This will
573 // avoid creating un-used children then removing them later when we find out
574 // the scope DIE is null.
575 std::unique_ptr<DIE> ScopeDIE;
576 if (Scope->getParent() && DS.isSubprogram()) {
577 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
580 // We create children when the scope DIE is not null.
581 createScopeChildrenDIE(TheCU, Scope, Children);
583 // Early exit when we know the scope DIE is going to be null.
584 if (isLexicalScopeDIENull(Scope))
587 // We create children here when we know the scope DIE is not going to be
588 // null and the children will be added to the scope DIE.
589 createScopeChildrenDIE(TheCU, Scope, Children);
591 // There is no need to emit empty lexical block DIE.
592 std::pair<ImportedEntityMap::const_iterator,
593 ImportedEntityMap::const_iterator> Range =
594 std::equal_range(ScopesWithImportedEntities.begin(),
595 ScopesWithImportedEntities.end(),
596 std::pair<const MDNode *, const MDNode *>(DS, nullptr),
598 if (Children.empty() && Range.first == Range.second)
600 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
601 assert(ScopeDIE && "Scope DIE should not be null.");
602 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
604 constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
608 for (auto &I : Children)
609 ScopeDIE->addChild(std::move(I));
614 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
615 if (!GenerateGnuPubSections)
618 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
621 // Create new DwarfCompileUnit for the given metadata node with tag
622 // DW_TAG_compile_unit.
623 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
624 StringRef FN = DIUnit.getFilename();
625 CompilationDir = DIUnit.getDirectory();
627 auto OwnedUnit = make_unique<DwarfCompileUnit>(
628 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
629 DwarfCompileUnit &NewCU = *OwnedUnit;
630 DIE &Die = NewCU.getUnitDie();
631 InfoHolder.addUnit(std::move(OwnedUnit));
633 // LTO with assembly output shares a single line table amongst multiple CUs.
634 // To avoid the compilation directory being ambiguous, let the line table
635 // explicitly describe the directory of all files, never relying on the
636 // compilation directory.
637 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
638 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
639 NewCU.getUniqueID(), CompilationDir);
641 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
642 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
643 DIUnit.getLanguage());
644 NewCU.addString(Die, dwarf::DW_AT_name, FN);
646 if (!useSplitDwarf()) {
647 NewCU.initStmtList(DwarfLineSectionSym);
649 // If we're using split dwarf the compilation dir is going to be in the
650 // skeleton CU and so we don't need to duplicate it here.
651 if (!CompilationDir.empty())
652 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
654 addGnuPubAttributes(NewCU, Die);
657 if (DIUnit.isOptimized())
658 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
660 StringRef Flags = DIUnit.getFlags();
662 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
664 if (unsigned RVer = DIUnit.getRunTimeVersion())
665 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
666 dwarf::DW_FORM_data1, RVer);
671 if (useSplitDwarf()) {
672 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
673 DwarfInfoDWOSectionSym);
674 NewCU.setSkeleton(constructSkeletonCU(NewCU));
676 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
677 DwarfInfoSectionSym);
679 CUMap.insert(std::make_pair(DIUnit, &NewCU));
680 CUDieMap.insert(std::make_pair(&Die, &NewCU));
684 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
686 DIImportedEntity Module(N);
687 assert(Module.Verify());
688 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
689 constructImportedEntityDIE(TheCU, Module, *D);
692 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
693 const MDNode *N, DIE &Context) {
694 DIImportedEntity Module(N);
695 assert(Module.Verify());
696 return constructImportedEntityDIE(TheCU, Module, Context);
699 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
700 const DIImportedEntity &Module,
702 assert(Module.Verify() &&
703 "Use one of the MDNode * overloads to handle invalid metadata");
704 DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
706 DIDescriptor Entity = resolve(Module.getEntity());
707 if (Entity.isNameSpace())
708 EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
709 else if (Entity.isSubprogram())
710 EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
711 else if (Entity.isType())
712 EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
714 EntityDie = TheCU.getDIE(Entity);
715 TheCU.addSourceLine(IMDie, Module.getLineNumber(),
716 Module.getContext().getFilename(),
717 Module.getContext().getDirectory());
718 TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
719 StringRef Name = Module.getName();
721 TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
724 // Emit all Dwarf sections that should come prior to the content. Create
725 // global DIEs and emit initial debug info sections. This is invoked by
726 // the target AsmPrinter.
727 void DwarfDebug::beginModule() {
728 if (DisableDebugInfoPrinting)
731 const Module *M = MMI->getModule();
733 FunctionDIs = makeSubprogramMap(*M);
735 // If module has named metadata anchors then use them, otherwise scan the
736 // module using debug info finder to collect debug info.
737 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
740 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
742 // Emit initial sections so we can reference labels later.
745 SingleCU = CU_Nodes->getNumOperands() == 1;
747 for (MDNode *N : CU_Nodes->operands()) {
748 DICompileUnit CUNode(N);
749 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
750 DIArray ImportedEntities = CUNode.getImportedEntities();
751 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
752 ScopesWithImportedEntities.push_back(std::make_pair(
753 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
754 ImportedEntities.getElement(i)));
755 std::sort(ScopesWithImportedEntities.begin(),
756 ScopesWithImportedEntities.end(), less_first());
757 DIArray GVs = CUNode.getGlobalVariables();
758 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
759 CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
760 DIArray SPs = CUNode.getSubprograms();
761 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
762 SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
763 DIArray EnumTypes = CUNode.getEnumTypes();
764 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
765 CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
766 DIArray RetainedTypes = CUNode.getRetainedTypes();
767 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
768 DIType Ty(RetainedTypes.getElement(i));
769 // The retained types array by design contains pointers to
770 // MDNodes rather than DIRefs. Unique them here.
771 DIType UniqueTy(resolve(Ty.getRef()));
772 CU.getOrCreateTypeDIE(UniqueTy);
774 // Emit imported_modules last so that the relevant context is already
776 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
777 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
780 // Tell MMI that we have debug info.
781 MMI->setDebugInfoAvailability(true);
783 // Prime section data.
784 SectionMap[Asm->getObjFileLowering().getTextSection()];
787 void DwarfDebug::finishVariableDefinitions() {
788 for (const auto &Var : ConcreteVariables) {
789 DIE *VariableDie = Var->getDIE();
790 // FIXME: There shouldn't be any variables without DIEs.
793 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
794 // in the ConcreteVariables list, rather than looking it up again here.
795 // DIE::getUnit isn't simple - it walks parent pointers, etc.
796 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
798 DbgVariable *AbsVar = getExistingAbstractVariable(Var->getVariable());
799 if (AbsVar && AbsVar->getDIE()) {
800 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
803 Unit->applyVariableAttributes(*Var, *VariableDie);
807 void DwarfDebug::finishSubprogramDefinitions() {
808 const Module *M = MMI->getModule();
810 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
811 for (MDNode *N : CU_Nodes->operands()) {
812 DICompileUnit TheCU(N);
813 // Construct subprogram DIE and add variables DIEs.
814 DwarfCompileUnit *SPCU =
815 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
816 DIArray Subprograms = TheCU.getSubprograms();
817 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
818 DISubprogram SP(Subprograms.getElement(i));
819 // Perhaps the subprogram is in another CU (such as due to comdat
820 // folding, etc), in which case ignore it here.
821 if (SPMap[SP] != SPCU)
823 DIE *D = SPCU->getDIE(SP);
824 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
826 // If this subprogram has an abstract definition, reference that
827 SPCU->addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
830 // Lazily construct the subprogram if we didn't see either concrete or
831 // inlined versions during codegen.
832 D = SPCU->getOrCreateSubprogramDIE(SP);
833 // And attach the attributes
834 SPCU->applySubprogramAttributesToDefinition(SP, *D);
841 // Collect info for variables that were optimized out.
842 void DwarfDebug::collectDeadVariables() {
843 const Module *M = MMI->getModule();
845 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
846 for (MDNode *N : CU_Nodes->operands()) {
847 DICompileUnit TheCU(N);
848 // Construct subprogram DIE and add variables DIEs.
849 DwarfCompileUnit *SPCU =
850 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
851 assert(SPCU && "Unable to find Compile Unit!");
852 DIArray Subprograms = TheCU.getSubprograms();
853 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
854 DISubprogram SP(Subprograms.getElement(i));
855 if (ProcessedSPNodes.count(SP) != 0)
857 assert(SP.isSubprogram() &&
858 "CU's subprogram list contains a non-subprogram");
859 assert(SP.isDefinition() &&
860 "CU's subprogram list contains a subprogram declaration");
861 DIArray Variables = SP.getVariables();
862 if (Variables.getNumElements() == 0)
865 DIE *SPDIE = AbstractSPDies.lookup(SP);
867 SPDIE = SPCU->getDIE(SP);
869 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
870 DIVariable DV(Variables.getElement(vi));
871 assert(DV.isVariable());
872 DbgVariable NewVar(DV, this);
873 auto VariableDie = SPCU->constructVariableDIE(NewVar);
874 SPCU->applyVariableAttributes(NewVar, *VariableDie);
875 SPDIE->addChild(std::move(VariableDie));
882 void DwarfDebug::finalizeModuleInfo() {
883 finishSubprogramDefinitions();
885 finishVariableDefinitions();
887 // Collect info for variables that were optimized out.
888 collectDeadVariables();
890 // Handle anything that needs to be done on a per-unit basis after
891 // all other generation.
892 for (const auto &TheU : getUnits()) {
893 // Emit DW_AT_containing_type attribute to connect types with their
894 // vtable holding type.
895 TheU->constructContainingTypeDIEs();
897 // Add CU specific attributes if we need to add any.
898 if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
899 // If we're splitting the dwarf out now that we've got the entire
900 // CU then add the dwo id to it.
901 DwarfCompileUnit *SkCU =
902 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
903 if (useSplitDwarf()) {
904 // Emit a unique identifier for this CU.
905 uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
906 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
907 dwarf::DW_FORM_data8, ID);
908 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
909 dwarf::DW_FORM_data8, ID);
911 // We don't keep track of which addresses are used in which CU so this
912 // is a bit pessimistic under LTO.
913 if (!AddrPool.isEmpty())
914 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
915 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
916 DwarfAddrSectionSym);
917 if (!TheU->getRangeLists().empty())
918 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
919 dwarf::DW_AT_GNU_ranges_base,
920 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
923 // If we have code split among multiple sections or non-contiguous
924 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
925 // remain in the .o file, otherwise add a DW_AT_low_pc.
926 // FIXME: We should use ranges allow reordering of code ala
927 // .subsections_via_symbols in mach-o. This would mean turning on
928 // ranges for all subprogram DIEs for mach-o.
929 DwarfCompileUnit &U =
930 SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
931 unsigned NumRanges = TheU->getRanges().size();
934 addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
935 Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
936 DwarfDebugRangeSectionSym);
938 // A DW_AT_low_pc attribute may also be specified in combination with
939 // DW_AT_ranges to specify the default base address for use in
940 // location lists (see Section 2.6.2) and range lists (see Section
942 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
945 RangeSpan &Range = TheU->getRanges().back();
946 U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
948 U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
955 // Compute DIE offsets and sizes.
956 InfoHolder.computeSizeAndOffsets();
958 SkeletonHolder.computeSizeAndOffsets();
961 void DwarfDebug::endSections() {
962 // Filter labels by section.
963 for (const SymbolCU &SCU : ArangeLabels) {
964 if (SCU.Sym->isInSection()) {
965 // Make a note of this symbol and it's section.
966 const MCSection *Section = &SCU.Sym->getSection();
967 if (!Section->getKind().isMetadata())
968 SectionMap[Section].push_back(SCU);
970 // Some symbols (e.g. common/bss on mach-o) can have no section but still
971 // appear in the output. This sucks as we rely on sections to build
972 // arange spans. We can do it without, but it's icky.
973 SectionMap[nullptr].push_back(SCU);
977 // Build a list of sections used.
978 std::vector<const MCSection *> Sections;
979 for (const auto &it : SectionMap) {
980 const MCSection *Section = it.first;
981 Sections.push_back(Section);
984 // Sort the sections into order.
985 // This is only done to ensure consistent output order across different runs.
986 std::sort(Sections.begin(), Sections.end(), SectionSort);
988 // Add terminating symbols for each section.
989 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
990 const MCSection *Section = Sections[ID];
991 MCSymbol *Sym = nullptr;
994 // We can't call MCSection::getLabelEndName, as it's only safe to do so
995 // if we know the section name up-front. For user-created sections, the
996 // resulting label may not be valid to use as a label. (section names can
997 // use a greater set of characters on some systems)
998 Sym = Asm->GetTempSymbol("debug_end", ID);
999 Asm->OutStreamer.SwitchSection(Section);
1000 Asm->OutStreamer.EmitLabel(Sym);
1003 // Insert a final terminator.
1004 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
1008 // Emit all Dwarf sections that should come after the content.
1009 void DwarfDebug::endModule() {
1010 assert(CurFn == nullptr);
1011 assert(CurMI == nullptr);
1016 // End any existing sections.
1017 // TODO: Does this need to happen?
1020 // Finalize the debug info for the module.
1021 finalizeModuleInfo();
1025 // Emit all the DIEs into a debug info section.
1028 // Corresponding abbreviations into a abbrev section.
1029 emitAbbreviations();
1031 // Emit info into a debug aranges section.
1032 if (GenerateARangeSection)
1035 // Emit info into a debug ranges section.
1038 if (useSplitDwarf()) {
1041 emitDebugAbbrevDWO();
1044 // Emit DWO addresses.
1045 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1047 // Emit info into a debug loc section.
1050 // Emit info into the dwarf accelerator table sections.
1051 if (useDwarfAccelTables()) {
1054 emitAccelNamespaces();
1058 // Emit the pubnames and pubtypes sections if requested.
1059 if (HasDwarfPubSections) {
1060 emitDebugPubNames(GenerateGnuPubSections);
1061 emitDebugPubTypes(GenerateGnuPubSections);
1066 AbstractVariables.clear();
1068 // Reset these for the next Module if we have one.
1072 // Find abstract variable, if any, associated with Var.
1073 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV,
1074 DIVariable &Cleansed) {
1075 LLVMContext &Ctx = DV->getContext();
1076 // More then one inlined variable corresponds to one abstract variable.
1077 // FIXME: This duplication of variables when inlining should probably be
1078 // removed. It's done to allow each DIVariable to describe its location
1079 // because the DebugLoc on the dbg.value/declare isn't accurate. We should
1080 // make it accurate then remove this duplication/cleansing stuff.
1081 Cleansed = cleanseInlinedVariable(DV, Ctx);
1082 auto I = AbstractVariables.find(Cleansed);
1083 if (I != AbstractVariables.end())
1084 return I->second.get();
1088 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV) {
1089 DIVariable Cleansed;
1090 return getExistingAbstractVariable(DV, Cleansed);
1093 void DwarfDebug::createAbstractVariable(const DIVariable &Var,
1094 LexicalScope *Scope) {
1095 auto AbsDbgVariable = make_unique<DbgVariable>(Var, this);
1096 addScopeVariable(Scope, AbsDbgVariable.get());
1097 AbstractVariables[Var] = std::move(AbsDbgVariable);
1100 void DwarfDebug::ensureAbstractVariableIsCreated(const DIVariable &DV,
1101 const MDNode *ScopeNode) {
1102 DIVariable Cleansed = DV;
1103 if (getExistingAbstractVariable(DV, Cleansed))
1106 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(ScopeNode));
1110 DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(const DIVariable &DV,
1111 const MDNode *ScopeNode) {
1112 DIVariable Cleansed = DV;
1113 if (getExistingAbstractVariable(DV, Cleansed))
1116 if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
1117 createAbstractVariable(Cleansed, Scope);
1120 // If Var is a current function argument then add it to CurrentFnArguments list.
1121 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1122 if (!LScopes.isCurrentFunctionScope(Scope))
1124 DIVariable DV = Var->getVariable();
1125 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1127 unsigned ArgNo = DV.getArgNumber();
1131 size_t Size = CurrentFnArguments.size();
1133 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1134 // llvm::Function argument size is not good indicator of how many
1135 // arguments does the function have at source level.
1137 CurrentFnArguments.resize(ArgNo * 2);
1138 CurrentFnArguments[ArgNo - 1] = Var;
1142 // Collect variable information from side table maintained by MMI.
1143 void DwarfDebug::collectVariableInfoFromMMITable(
1144 SmallPtrSet<const MDNode *, 16> &Processed) {
1145 for (const auto &VI : MMI->getVariableDbgInfo()) {
1148 Processed.insert(VI.Var);
1149 DIVariable DV(VI.Var);
1150 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1152 // If variable scope is not found then skip this variable.
1156 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1157 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1158 DbgVariable *RegVar = ConcreteVariables.back().get();
1159 RegVar->setFrameIndex(VI.Slot);
1160 addScopeVariable(Scope, RegVar);
1164 // Get .debug_loc entry for the instruction range starting at MI.
1165 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1166 const MDNode *Var = MI->getDebugVariable();
1168 assert(MI->getNumOperands() == 3);
1169 if (MI->getOperand(0).isReg()) {
1170 MachineLocation MLoc;
1171 // If the second operand is an immediate, this is a
1172 // register-indirect address.
1173 if (!MI->getOperand(1).isImm())
1174 MLoc.set(MI->getOperand(0).getReg());
1176 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1177 return DebugLocEntry::Value(Var, MLoc);
1179 if (MI->getOperand(0).isImm())
1180 return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1181 if (MI->getOperand(0).isFPImm())
1182 return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1183 if (MI->getOperand(0).isCImm())
1184 return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1186 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1189 // Find variables for each lexical scope.
1191 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1192 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1193 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1195 // Grab the variable info that was squirreled away in the MMI side-table.
1196 collectVariableInfoFromMMITable(Processed);
1198 for (const auto &I : DbgValues) {
1199 DIVariable DV(I.first);
1200 if (Processed.count(DV))
1203 // Instruction ranges, specifying where DV is accessible.
1204 const auto &Ranges = I.second;
1208 LexicalScope *Scope = nullptr;
1209 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1210 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1211 Scope = LScopes.getCurrentFunctionScope();
1212 else if (MDNode *IA = DV.getInlinedAt()) {
1213 DebugLoc DL = DebugLoc::getFromDILocation(IA);
1214 Scope = LScopes.findInlinedScope(DebugLoc::get(
1215 DL.getLine(), DL.getCol(), DV.getContext(), IA));
1217 Scope = LScopes.findLexicalScope(DV.getContext());
1218 // If variable scope is not found then skip this variable.
1222 Processed.insert(DV);
1223 const MachineInstr *MInsn = Ranges.front().first;
1224 assert(MInsn->isDebugValue() && "History must begin with debug value");
1225 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1226 ConcreteVariables.push_back(make_unique<DbgVariable>(MInsn, this));
1227 DbgVariable *RegVar = ConcreteVariables.back().get();
1228 addScopeVariable(Scope, RegVar);
1230 // Check if the first DBG_VALUE is valid for the rest of the function.
1231 if (Ranges.size() == 1 && Ranges.front().second == nullptr)
1234 // Handle multiple DBG_VALUE instructions describing one variable.
1235 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1237 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1238 DebugLocList &LocList = DotDebugLocEntries.back();
1240 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1241 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1242 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1243 const MachineInstr *Begin = I->first;
1244 const MachineInstr *End = I->second;
1245 assert(Begin->isDebugValue() && "Invalid History entry");
1247 // Check if a variable is unaccessible in this range.
1248 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1249 !Begin->getOperand(0).getReg())
1251 DEBUG(dbgs() << "DotDebugLoc Pair:\n" << "\t" << *Begin);
1253 DEBUG(dbgs() << "\t" << *End);
1255 DEBUG(dbgs() << "\tNULL\n");
1257 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1258 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1260 const MCSymbol *EndLabel;
1262 EndLabel = getLabelAfterInsn(End);
1263 else if (std::next(I) == Ranges.end())
1264 EndLabel = FunctionEndSym;
1266 EndLabel = getLabelBeforeInsn(std::next(I)->first);
1267 assert(EndLabel && "Forgot label after instruction ending a range!");
1269 DebugLocEntry Loc(StartLabel, EndLabel, getDebugLocValue(Begin), TheCU);
1270 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1271 DebugLoc.push_back(std::move(Loc));
1275 // Collect info for variables that were optimized out.
1276 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1277 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1278 DIVariable DV(Variables.getElement(i));
1279 assert(DV.isVariable());
1280 if (!Processed.insert(DV))
1282 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
1283 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1284 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1285 addScopeVariable(Scope, ConcreteVariables.back().get());
1290 // Return Label preceding the instruction.
1291 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1292 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1293 assert(Label && "Didn't insert label before instruction");
1297 // Return Label immediately following the instruction.
1298 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1299 return LabelsAfterInsn.lookup(MI);
1302 // Process beginning of an instruction.
1303 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1304 assert(CurMI == nullptr);
1306 // Check if source location changes, but ignore DBG_VALUE locations.
1307 if (!MI->isDebugValue()) {
1308 DebugLoc DL = MI->getDebugLoc();
1309 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1312 if (DL == PrologEndLoc) {
1313 Flags |= DWARF2_FLAG_PROLOGUE_END;
1314 PrologEndLoc = DebugLoc();
1316 if (PrologEndLoc.isUnknown())
1317 Flags |= DWARF2_FLAG_IS_STMT;
1319 if (!DL.isUnknown()) {
1320 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1321 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1323 recordSourceLine(0, 0, nullptr, 0);
1327 // Insert labels where requested.
1328 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1329 LabelsBeforeInsn.find(MI);
1332 if (I == LabelsBeforeInsn.end())
1335 // Label already assigned.
1340 PrevLabel = MMI->getContext().CreateTempSymbol();
1341 Asm->OutStreamer.EmitLabel(PrevLabel);
1343 I->second = PrevLabel;
1346 // Process end of an instruction.
1347 void DwarfDebug::endInstruction() {
1348 assert(CurMI != nullptr);
1349 // Don't create a new label after DBG_VALUE instructions.
1350 // They don't generate code.
1351 if (!CurMI->isDebugValue())
1352 PrevLabel = nullptr;
1354 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1355 LabelsAfterInsn.find(CurMI);
1359 if (I == LabelsAfterInsn.end())
1362 // Label already assigned.
1366 // We need a label after this instruction.
1368 PrevLabel = MMI->getContext().CreateTempSymbol();
1369 Asm->OutStreamer.EmitLabel(PrevLabel);
1371 I->second = PrevLabel;
1374 // Each LexicalScope has first instruction and last instruction to mark
1375 // beginning and end of a scope respectively. Create an inverse map that list
1376 // scopes starts (and ends) with an instruction. One instruction may start (or
1377 // end) multiple scopes. Ignore scopes that are not reachable.
1378 void DwarfDebug::identifyScopeMarkers() {
1379 SmallVector<LexicalScope *, 4> WorkList;
1380 WorkList.push_back(LScopes.getCurrentFunctionScope());
1381 while (!WorkList.empty()) {
1382 LexicalScope *S = WorkList.pop_back_val();
1384 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1385 if (!Children.empty())
1386 WorkList.append(Children.begin(), Children.end());
1388 if (S->isAbstractScope())
1391 for (const InsnRange &R : S->getRanges()) {
1392 assert(R.first && "InsnRange does not have first instruction!");
1393 assert(R.second && "InsnRange does not have second instruction!");
1394 requestLabelBeforeInsn(R.first);
1395 requestLabelAfterInsn(R.second);
1400 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1401 // First known non-DBG_VALUE and non-frame setup location marks
1402 // the beginning of the function body.
1403 for (const auto &MBB : *MF)
1404 for (const auto &MI : MBB)
1405 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1406 !MI.getDebugLoc().isUnknown())
1407 return MI.getDebugLoc();
1411 // Gather pre-function debug information. Assumes being called immediately
1412 // after the function entry point has been emitted.
1413 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1416 // If there's no debug info for the function we're not going to do anything.
1417 if (!MMI->hasDebugInfo())
1420 auto DI = FunctionDIs.find(MF->getFunction());
1421 if (DI == FunctionDIs.end())
1424 // Grab the lexical scopes for the function, if we don't have any of those
1425 // then we're not going to be able to do anything.
1426 LScopes.initialize(*MF);
1427 if (LScopes.empty())
1430 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1432 // Make sure that each lexical scope will have a begin/end label.
1433 identifyScopeMarkers();
1435 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1436 // belongs to so that we add to the correct per-cu line table in the
1438 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1439 assert(FnScope->getScopeNode() == DI->second);
1440 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1441 assert(TheCU && "Unable to find compile unit!");
1442 if (Asm->OutStreamer.hasRawTextSupport())
1443 // Use a single line table if we are generating assembly.
1444 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1446 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1448 // Emit a label for the function so that we have a beginning address.
1449 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1450 // Assumes in correct section after the entry point.
1451 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1453 // Calculate history for local variables.
1454 calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1456 // Request labels for the full history.
1457 for (const auto &I : DbgValues) {
1458 const auto &Ranges = I.second;
1462 // The first mention of a function argument gets the FunctionBeginSym
1463 // label, so arguments are visible when breaking at function entry.
1464 DIVariable DV(I.first);
1465 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1466 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1467 LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1469 for (const auto &Range : Ranges) {
1470 requestLabelBeforeInsn(Range.first);
1472 requestLabelAfterInsn(Range.second);
1476 PrevInstLoc = DebugLoc();
1477 PrevLabel = FunctionBeginSym;
1479 // Record beginning of function.
1480 PrologEndLoc = findPrologueEndLoc(MF);
1481 if (!PrologEndLoc.isUnknown()) {
1482 DebugLoc FnStartDL =
1483 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1485 FnStartDL.getLine(), FnStartDL.getCol(),
1486 FnStartDL.getScope(MF->getFunction()->getContext()),
1487 // We'd like to list the prologue as "not statements" but GDB behaves
1488 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1489 DWARF2_FLAG_IS_STMT);
1493 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1494 if (addCurrentFnArgument(Var, LS))
1496 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1497 DIVariable DV = Var->getVariable();
1498 // Variables with positive arg numbers are parameters.
1499 if (unsigned ArgNum = DV.getArgNumber()) {
1500 // Keep all parameters in order at the start of the variable list to ensure
1501 // function types are correct (no out-of-order parameters)
1503 // This could be improved by only doing it for optimized builds (unoptimized
1504 // builds have the right order to begin with), searching from the back (this
1505 // would catch the unoptimized case quickly), or doing a binary search
1506 // rather than linear search.
1507 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1508 while (I != Vars.end()) {
1509 unsigned CurNum = (*I)->getVariable().getArgNumber();
1510 // A local (non-parameter) variable has been found, insert immediately
1514 // A later indexed parameter has been found, insert immediately before it.
1515 if (CurNum > ArgNum)
1519 Vars.insert(I, Var);
1523 Vars.push_back(Var);
1526 // Gather and emit post-function debug information.
1527 void DwarfDebug::endFunction(const MachineFunction *MF) {
1528 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1529 // though the beginFunction may not be called at all.
1530 // We should handle both cases.
1534 assert(CurFn == MF);
1535 assert(CurFn != nullptr);
1537 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1538 !FunctionDIs.count(MF->getFunction())) {
1539 // If we don't have a lexical scope for this function then there will
1540 // be a hole in the range information. Keep note of this by setting the
1541 // previously used section to nullptr.
1542 PrevSection = nullptr;
1548 // Define end label for subprogram.
1549 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1550 // Assumes in correct section after the entry point.
1551 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1553 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1554 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1556 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1557 collectVariableInfo(ProcessedVars);
1559 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1560 DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1562 // Construct abstract scopes.
1563 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1564 DISubprogram SP(AScope->getScopeNode());
1565 if (!SP.isSubprogram())
1567 // Collect info for variables that were optimized out.
1568 DIArray Variables = SP.getVariables();
1569 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1570 DIVariable DV(Variables.getElement(i));
1571 assert(DV && DV.isVariable());
1572 if (!ProcessedVars.insert(DV))
1574 ensureAbstractVariableIsCreated(DV, DV.getContext());
1576 constructAbstractSubprogramScopeDIE(TheCU, AScope);
1579 DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1580 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1581 TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1583 // Add the range of this function to the list of ranges for the CU.
1584 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1585 TheCU.addRange(std::move(Span));
1586 PrevSection = Asm->getCurrentSection();
1590 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1591 // DbgVariables except those that are also in AbstractVariables (since they
1592 // can be used cross-function)
1593 ScopeVariables.clear();
1594 CurrentFnArguments.clear();
1596 LabelsBeforeInsn.clear();
1597 LabelsAfterInsn.clear();
1598 PrevLabel = nullptr;
1602 // Register a source line with debug info. Returns the unique label that was
1603 // emitted and which provides correspondence to the source line list.
1604 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1609 unsigned Discriminator = 0;
1610 if (DIScope Scope = DIScope(S)) {
1611 assert(Scope.isScope());
1612 Fn = Scope.getFilename();
1613 Dir = Scope.getDirectory();
1614 if (Scope.isLexicalBlock())
1615 Discriminator = DILexicalBlock(S).getDiscriminator();
1617 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1618 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1619 .getOrCreateSourceID(Fn, Dir);
1621 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1625 //===----------------------------------------------------------------------===//
1627 //===----------------------------------------------------------------------===//
1629 // Emit initial Dwarf sections with a label at the start of each one.
1630 void DwarfDebug::emitSectionLabels() {
1631 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1633 // Dwarf sections base addresses.
1634 DwarfInfoSectionSym =
1635 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1636 if (useSplitDwarf())
1637 DwarfInfoDWOSectionSym =
1638 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1639 DwarfAbbrevSectionSym =
1640 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1641 if (useSplitDwarf())
1642 DwarfAbbrevDWOSectionSym = emitSectionSym(
1643 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1644 if (GenerateARangeSection)
1645 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1647 DwarfLineSectionSym =
1648 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1649 if (GenerateGnuPubSections) {
1650 DwarfGnuPubNamesSectionSym =
1651 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1652 DwarfGnuPubTypesSectionSym =
1653 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1654 } else if (HasDwarfPubSections) {
1655 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1656 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1659 DwarfStrSectionSym =
1660 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1661 if (useSplitDwarf()) {
1662 DwarfStrDWOSectionSym =
1663 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1664 DwarfAddrSectionSym =
1665 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1666 DwarfDebugLocSectionSym =
1667 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1669 DwarfDebugLocSectionSym =
1670 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1671 DwarfDebugRangeSectionSym =
1672 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1675 // Recursively emits a debug information entry.
1676 void DwarfDebug::emitDIE(DIE &Die) {
1677 // Get the abbreviation for this DIE.
1678 const DIEAbbrev &Abbrev = Die.getAbbrev();
1680 // Emit the code (index) for the abbreviation.
1681 if (Asm->isVerbose())
1682 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1683 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1684 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1685 dwarf::TagString(Abbrev.getTag()));
1686 Asm->EmitULEB128(Abbrev.getNumber());
1688 const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1689 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1691 // Emit the DIE attribute values.
1692 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1693 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1694 dwarf::Form Form = AbbrevData[i].getForm();
1695 assert(Form && "Too many attributes for DIE (check abbreviation)");
1697 if (Asm->isVerbose()) {
1698 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1699 if (Attr == dwarf::DW_AT_accessibility)
1700 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1701 cast<DIEInteger>(Values[i])->getValue()));
1704 // Emit an attribute using the defined form.
1705 Values[i]->EmitValue(Asm, Form);
1708 // Emit the DIE children if any.
1709 if (Abbrev.hasChildren()) {
1710 for (auto &Child : Die.getChildren())
1713 Asm->OutStreamer.AddComment("End Of Children Mark");
1718 // Emit the debug info section.
1719 void DwarfDebug::emitDebugInfo() {
1720 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1722 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1725 // Emit the abbreviation section.
1726 void DwarfDebug::emitAbbreviations() {
1727 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1729 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1732 // Emit the last address of the section and the end of the line matrix.
1733 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1734 // Define last address of section.
1735 Asm->OutStreamer.AddComment("Extended Op");
1738 Asm->OutStreamer.AddComment("Op size");
1739 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1740 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1741 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1743 Asm->OutStreamer.AddComment("Section end label");
1745 Asm->OutStreamer.EmitSymbolValue(
1746 Asm->GetTempSymbol("section_end", SectionEnd),
1747 Asm->getDataLayout().getPointerSize());
1749 // Mark end of matrix.
1750 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1756 // Emit visible names into a hashed accelerator table section.
1757 void DwarfDebug::emitAccelNames() {
1758 AccelNames.FinalizeTable(Asm, "Names");
1759 Asm->OutStreamer.SwitchSection(
1760 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1761 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1762 Asm->OutStreamer.EmitLabel(SectionBegin);
1764 // Emit the full data.
1765 AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1768 // Emit objective C classes and categories into a hashed accelerator table
1770 void DwarfDebug::emitAccelObjC() {
1771 AccelObjC.FinalizeTable(Asm, "ObjC");
1772 Asm->OutStreamer.SwitchSection(
1773 Asm->getObjFileLowering().getDwarfAccelObjCSection());
1774 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1775 Asm->OutStreamer.EmitLabel(SectionBegin);
1777 // Emit the full data.
1778 AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1781 // Emit namespace dies into a hashed accelerator table.
1782 void DwarfDebug::emitAccelNamespaces() {
1783 AccelNamespace.FinalizeTable(Asm, "namespac");
1784 Asm->OutStreamer.SwitchSection(
1785 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1786 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1787 Asm->OutStreamer.EmitLabel(SectionBegin);
1789 // Emit the full data.
1790 AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1793 // Emit type dies into a hashed accelerator table.
1794 void DwarfDebug::emitAccelTypes() {
1796 AccelTypes.FinalizeTable(Asm, "types");
1797 Asm->OutStreamer.SwitchSection(
1798 Asm->getObjFileLowering().getDwarfAccelTypesSection());
1799 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1800 Asm->OutStreamer.EmitLabel(SectionBegin);
1802 // Emit the full data.
1803 AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1806 // Public name handling.
1807 // The format for the various pubnames:
1809 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1810 // for the DIE that is named.
1812 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1813 // into the CU and the index value is computed according to the type of value
1814 // for the DIE that is named.
1816 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1817 // it's the offset within the debug_info/debug_types dwo section, however, the
1818 // reference in the pubname header doesn't change.
1820 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1821 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1823 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1825 // We could have a specification DIE that has our most of our knowledge,
1826 // look for that now.
1827 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1829 DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1830 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1831 Linkage = dwarf::GIEL_EXTERNAL;
1832 } else if (Die->findAttribute(dwarf::DW_AT_external))
1833 Linkage = dwarf::GIEL_EXTERNAL;
1835 switch (Die->getTag()) {
1836 case dwarf::DW_TAG_class_type:
1837 case dwarf::DW_TAG_structure_type:
1838 case dwarf::DW_TAG_union_type:
1839 case dwarf::DW_TAG_enumeration_type:
1840 return dwarf::PubIndexEntryDescriptor(
1841 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1842 ? dwarf::GIEL_STATIC
1843 : dwarf::GIEL_EXTERNAL);
1844 case dwarf::DW_TAG_typedef:
1845 case dwarf::DW_TAG_base_type:
1846 case dwarf::DW_TAG_subrange_type:
1847 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1848 case dwarf::DW_TAG_namespace:
1849 return dwarf::GIEK_TYPE;
1850 case dwarf::DW_TAG_subprogram:
1851 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1852 case dwarf::DW_TAG_constant:
1853 case dwarf::DW_TAG_variable:
1854 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1855 case dwarf::DW_TAG_enumerator:
1856 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1857 dwarf::GIEL_STATIC);
1859 return dwarf::GIEK_NONE;
1863 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1865 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1866 const MCSection *PSec =
1867 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1868 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1870 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1873 void DwarfDebug::emitDebugPubSection(
1874 bool GnuStyle, const MCSection *PSec, StringRef Name,
1875 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1876 for (const auto &NU : CUMap) {
1877 DwarfCompileUnit *TheU = NU.second;
1879 const auto &Globals = (TheU->*Accessor)();
1881 if (Globals.empty())
1884 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1886 unsigned ID = TheU->getUniqueID();
1888 // Start the dwarf pubnames section.
1889 Asm->OutStreamer.SwitchSection(PSec);
1892 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1893 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1894 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1895 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1897 Asm->OutStreamer.EmitLabel(BeginLabel);
1899 Asm->OutStreamer.AddComment("DWARF Version");
1900 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1902 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1903 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1905 Asm->OutStreamer.AddComment("Compilation Unit Length");
1906 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1908 // Emit the pubnames for this compilation unit.
1909 for (const auto &GI : Globals) {
1910 const char *Name = GI.getKeyData();
1911 const DIE *Entity = GI.second;
1913 Asm->OutStreamer.AddComment("DIE offset");
1914 Asm->EmitInt32(Entity->getOffset());
1917 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1918 Asm->OutStreamer.AddComment(
1919 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1920 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1921 Asm->EmitInt8(Desc.toBits());
1924 Asm->OutStreamer.AddComment("External Name");
1925 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1928 Asm->OutStreamer.AddComment("End Mark");
1930 Asm->OutStreamer.EmitLabel(EndLabel);
1934 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1935 const MCSection *PSec =
1936 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1937 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1939 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1942 // Emit visible names into a debug str section.
1943 void DwarfDebug::emitDebugStr() {
1944 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1945 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1948 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1949 const DebugLocEntry &Entry) {
1950 assert(Entry.getValues().size() == 1 &&
1951 "multi-value entries are not supported yet.");
1952 const DebugLocEntry::Value Value = Entry.getValues()[0];
1953 DIVariable DV(Value.getVariable());
1954 if (Value.isInt()) {
1955 DIBasicType BTy(resolve(DV.getType()));
1956 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1957 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1958 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1959 Streamer.EmitSLEB128(Value.getInt());
1961 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1962 Streamer.EmitULEB128(Value.getInt());
1964 } else if (Value.isLocation()) {
1965 MachineLocation Loc = Value.getLoc();
1966 if (!DV.hasComplexAddress())
1968 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1970 // Complex address entry.
1971 unsigned N = DV.getNumAddrElements();
1973 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1974 if (Loc.getOffset()) {
1976 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1977 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1978 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1979 Streamer.EmitSLEB128(DV.getAddrElement(1));
1981 // If first address element is OpPlus then emit
1982 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1983 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1984 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1988 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1991 // Emit remaining complex address elements.
1992 for (; i < N; ++i) {
1993 uint64_t Element = DV.getAddrElement(i);
1994 if (Element == DIBuilder::OpPlus) {
1995 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1996 Streamer.EmitULEB128(DV.getAddrElement(++i));
1997 } else if (Element == DIBuilder::OpDeref) {
1999 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2001 llvm_unreachable("unknown Opcode found in complex address");
2005 // else ... ignore constant fp. There is not any good way to
2006 // to represent them here in dwarf.
2010 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2011 Asm->OutStreamer.AddComment("Loc expr size");
2012 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2013 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2014 Asm->EmitLabelDifference(end, begin, 2);
2015 Asm->OutStreamer.EmitLabel(begin);
2017 APByteStreamer Streamer(*Asm);
2018 emitDebugLocEntry(Streamer, Entry);
2020 Asm->OutStreamer.EmitLabel(end);
2023 // Emit locations into the debug loc section.
2024 void DwarfDebug::emitDebugLoc() {
2025 // Start the dwarf loc section.
2026 Asm->OutStreamer.SwitchSection(
2027 Asm->getObjFileLowering().getDwarfLocSection());
2028 unsigned char Size = Asm->getDataLayout().getPointerSize();
2029 for (const auto &DebugLoc : DotDebugLocEntries) {
2030 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2031 for (const auto &Entry : DebugLoc.List) {
2032 // Set up the range. This range is relative to the entry point of the
2033 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2034 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2035 const DwarfCompileUnit *CU = Entry.getCU();
2036 if (CU->getRanges().size() == 1) {
2037 // Grab the begin symbol from the first range as our base.
2038 const MCSymbol *Base = CU->getRanges()[0].getStart();
2039 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2040 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2042 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2043 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2046 emitDebugLocEntryLocation(Entry);
2048 Asm->OutStreamer.EmitIntValue(0, Size);
2049 Asm->OutStreamer.EmitIntValue(0, Size);
2053 void DwarfDebug::emitDebugLocDWO() {
2054 Asm->OutStreamer.SwitchSection(
2055 Asm->getObjFileLowering().getDwarfLocDWOSection());
2056 for (const auto &DebugLoc : DotDebugLocEntries) {
2057 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2058 for (const auto &Entry : DebugLoc.List) {
2059 // Just always use start_length for now - at least that's one address
2060 // rather than two. We could get fancier and try to, say, reuse an
2061 // address we know we've emitted elsewhere (the start of the function?
2062 // The start of the CU or CU subrange that encloses this range?)
2063 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2064 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2065 Asm->EmitULEB128(idx);
2066 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2068 emitDebugLocEntryLocation(Entry);
2070 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2075 const MCSymbol *Start, *End;
2078 // Emit a debug aranges section, containing a CU lookup for any
2079 // address we can tie back to a CU.
2080 void DwarfDebug::emitDebugARanges() {
2081 // Start the dwarf aranges section.
2082 Asm->OutStreamer.SwitchSection(
2083 Asm->getObjFileLowering().getDwarfARangesSection());
2085 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2089 // Build a list of sections used.
2090 std::vector<const MCSection *> Sections;
2091 for (const auto &it : SectionMap) {
2092 const MCSection *Section = it.first;
2093 Sections.push_back(Section);
2096 // Sort the sections into order.
2097 // This is only done to ensure consistent output order across different runs.
2098 std::sort(Sections.begin(), Sections.end(), SectionSort);
2100 // Build a set of address spans, sorted by CU.
2101 for (const MCSection *Section : Sections) {
2102 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2103 if (List.size() < 2)
2106 // Sort the symbols by offset within the section.
2107 std::sort(List.begin(), List.end(),
2108 [&](const SymbolCU &A, const SymbolCU &B) {
2109 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2110 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2112 // Symbols with no order assigned should be placed at the end.
2113 // (e.g. section end labels)
2121 // If we have no section (e.g. common), just write out
2122 // individual spans for each symbol.
2124 for (const SymbolCU &Cur : List) {
2126 Span.Start = Cur.Sym;
2129 Spans[Cur.CU].push_back(Span);
2132 // Build spans between each label.
2133 const MCSymbol *StartSym = List[0].Sym;
2134 for (size_t n = 1, e = List.size(); n < e; n++) {
2135 const SymbolCU &Prev = List[n - 1];
2136 const SymbolCU &Cur = List[n];
2138 // Try and build the longest span we can within the same CU.
2139 if (Cur.CU != Prev.CU) {
2141 Span.Start = StartSym;
2143 Spans[Prev.CU].push_back(Span);
2150 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2152 // Build a list of CUs used.
2153 std::vector<DwarfCompileUnit *> CUs;
2154 for (const auto &it : Spans) {
2155 DwarfCompileUnit *CU = it.first;
2159 // Sort the CU list (again, to ensure consistent output order).
2160 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2161 return A->getUniqueID() < B->getUniqueID();
2164 // Emit an arange table for each CU we used.
2165 for (DwarfCompileUnit *CU : CUs) {
2166 std::vector<ArangeSpan> &List = Spans[CU];
2168 // Emit size of content not including length itself.
2169 unsigned ContentSize =
2170 sizeof(int16_t) + // DWARF ARange version number
2171 sizeof(int32_t) + // Offset of CU in the .debug_info section
2172 sizeof(int8_t) + // Pointer Size (in bytes)
2173 sizeof(int8_t); // Segment Size (in bytes)
2175 unsigned TupleSize = PtrSize * 2;
2177 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2179 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2181 ContentSize += Padding;
2182 ContentSize += (List.size() + 1) * TupleSize;
2184 // For each compile unit, write the list of spans it covers.
2185 Asm->OutStreamer.AddComment("Length of ARange Set");
2186 Asm->EmitInt32(ContentSize);
2187 Asm->OutStreamer.AddComment("DWARF Arange version number");
2188 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2189 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2190 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2191 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2192 Asm->EmitInt8(PtrSize);
2193 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2196 Asm->OutStreamer.EmitFill(Padding, 0xff);
2198 for (const ArangeSpan &Span : List) {
2199 Asm->EmitLabelReference(Span.Start, PtrSize);
2201 // Calculate the size as being from the span start to it's end.
2203 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2205 // For symbols without an end marker (e.g. common), we
2206 // write a single arange entry containing just that one symbol.
2207 uint64_t Size = SymSize[Span.Start];
2211 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2215 Asm->OutStreamer.AddComment("ARange terminator");
2216 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2217 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2221 // Emit visible names into a debug ranges section.
2222 void DwarfDebug::emitDebugRanges() {
2223 // Start the dwarf ranges section.
2224 Asm->OutStreamer.SwitchSection(
2225 Asm->getObjFileLowering().getDwarfRangesSection());
2227 // Size for our labels.
2228 unsigned char Size = Asm->getDataLayout().getPointerSize();
2230 // Grab the specific ranges for the compile units in the module.
2231 for (const auto &I : CUMap) {
2232 DwarfCompileUnit *TheCU = I.second;
2234 // Iterate over the misc ranges for the compile units in the module.
2235 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2236 // Emit our symbol so we can find the beginning of the range.
2237 Asm->OutStreamer.EmitLabel(List.getSym());
2239 for (const RangeSpan &Range : List.getRanges()) {
2240 const MCSymbol *Begin = Range.getStart();
2241 const MCSymbol *End = Range.getEnd();
2242 assert(Begin && "Range without a begin symbol?");
2243 assert(End && "Range without an end symbol?");
2244 if (TheCU->getRanges().size() == 1) {
2245 // Grab the begin symbol from the first range as our base.
2246 const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2247 Asm->EmitLabelDifference(Begin, Base, Size);
2248 Asm->EmitLabelDifference(End, Base, Size);
2250 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2251 Asm->OutStreamer.EmitSymbolValue(End, Size);
2255 // And terminate the list with two 0 values.
2256 Asm->OutStreamer.EmitIntValue(0, Size);
2257 Asm->OutStreamer.EmitIntValue(0, Size);
2260 // Now emit a range for the CU itself.
2261 if (TheCU->getRanges().size() > 1) {
2262 Asm->OutStreamer.EmitLabel(
2263 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2264 for (const RangeSpan &Range : TheCU->getRanges()) {
2265 const MCSymbol *Begin = Range.getStart();
2266 const MCSymbol *End = Range.getEnd();
2267 assert(Begin && "Range without a begin symbol?");
2268 assert(End && "Range without an end symbol?");
2269 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2270 Asm->OutStreamer.EmitSymbolValue(End, Size);
2272 // And terminate the list with two 0 values.
2273 Asm->OutStreamer.EmitIntValue(0, Size);
2274 Asm->OutStreamer.EmitIntValue(0, Size);
2279 // DWARF5 Experimental Separate Dwarf emitters.
2281 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2282 std::unique_ptr<DwarfUnit> NewU) {
2283 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2284 U.getCUNode().getSplitDebugFilename());
2286 if (!CompilationDir.empty())
2287 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2289 addGnuPubAttributes(*NewU, Die);
2291 SkeletonHolder.addUnit(std::move(NewU));
2294 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2295 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2296 // DW_AT_addr_base, DW_AT_ranges_base.
2297 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2299 auto OwnedUnit = make_unique<DwarfCompileUnit>(
2300 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2301 DwarfCompileUnit &NewCU = *OwnedUnit;
2302 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2303 DwarfInfoSectionSym);
2305 NewCU.initStmtList(DwarfLineSectionSym);
2307 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2312 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2314 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2315 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2316 *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2318 auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2320 DwarfTypeUnit &NewTU = *OwnedUnit;
2321 NewTU.setTypeSignature(TU.getTypeSignature());
2322 NewTU.setType(nullptr);
2324 Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2326 initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2330 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2331 // compile units that would normally be in debug_info.
2332 void DwarfDebug::emitDebugInfoDWO() {
2333 assert(useSplitDwarf() && "No split dwarf debug info?");
2334 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2335 // emit relocations into the dwo file.
2336 InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2339 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2340 // abbreviations for the .debug_info.dwo section.
2341 void DwarfDebug::emitDebugAbbrevDWO() {
2342 assert(useSplitDwarf() && "No split dwarf?");
2343 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2346 void DwarfDebug::emitDebugLineDWO() {
2347 assert(useSplitDwarf() && "No split dwarf?");
2348 Asm->OutStreamer.SwitchSection(
2349 Asm->getObjFileLowering().getDwarfLineDWOSection());
2350 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2353 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2354 // string section and is identical in format to traditional .debug_str
2356 void DwarfDebug::emitDebugStrDWO() {
2357 assert(useSplitDwarf() && "No split dwarf?");
2358 const MCSection *OffSec =
2359 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2360 const MCSymbol *StrSym = DwarfStrSectionSym;
2361 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2365 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2366 if (!useSplitDwarf())
2369 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2370 return &SplitTypeUnitFileTable;
2373 static uint64_t makeTypeSignature(StringRef Identifier) {
2375 Hash.update(Identifier);
2376 // ... take the least significant 8 bytes and return those. Our MD5
2377 // implementation always returns its results in little endian, swap bytes
2379 MD5::MD5Result Result;
2381 return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2384 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2385 StringRef Identifier, DIE &RefDie,
2386 DICompositeType CTy) {
2387 // Fast path if we're building some type units and one has already used the
2388 // address pool we know we're going to throw away all this work anyway, so
2389 // don't bother building dependent types.
2390 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2393 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2395 CU.addDIETypeSignature(RefDie, *TU);
2399 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2400 AddrPool.resetUsedFlag();
2403 make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), CU, Asm, this,
2404 &InfoHolder, getDwoLineTable(CU));
2405 DwarfTypeUnit &NewTU = *OwnedUnit;
2406 DIE &UnitDie = NewTU.getUnitDie();
2408 TypeUnitsUnderConstruction.push_back(
2409 std::make_pair(std::move(OwnedUnit), CTy));
2411 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2414 uint64_t Signature = makeTypeSignature(Identifier);
2415 NewTU.setTypeSignature(Signature);
2417 if (!useSplitDwarf())
2418 CU.applyStmtList(UnitDie);
2420 // FIXME: Skip using COMDAT groups for type units in the .dwo file once tools
2421 // such as DWP ( http://gcc.gnu.org/wiki/DebugFissionDWP ) can cope with it.
2424 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2425 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2427 NewTU.setType(NewTU.createTypeDIE(CTy));
2430 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2431 TypeUnitsUnderConstruction.clear();
2433 // Types referencing entries in the address table cannot be placed in type
2435 if (AddrPool.hasBeenUsed()) {
2437 // Remove all the types built while building this type.
2438 // This is pessimistic as some of these types might not be dependent on
2439 // the type that used an address.
2440 for (const auto &TU : TypeUnitsToAdd)
2441 DwarfTypeUnits.erase(TU.second);
2443 // Construct this type in the CU directly.
2444 // This is inefficient because all the dependent types will be rebuilt
2445 // from scratch, including building them in type units, discovering that
2446 // they depend on addresses, throwing them out and rebuilding them.
2447 CU.constructTypeDIE(RefDie, CTy);
2451 // If the type wasn't dependent on fission addresses, finish adding the type
2452 // and all its dependent types.
2453 for (auto &TU : TypeUnitsToAdd) {
2454 if (useSplitDwarf())
2455 TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2456 InfoHolder.addUnit(std::move(TU.first));
2459 CU.addDIETypeSignature(RefDie, NewTU);
2462 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2463 MCSymbol *Begin, MCSymbol *End) {
2464 assert(Begin && "Begin label should not be null!");
2465 assert(End && "End label should not be null!");
2466 assert(Begin->isDefined() && "Invalid starting label");
2467 assert(End->isDefined() && "Invalid end label");
2469 Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2470 if (DwarfVersion < 4)
2471 Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2473 Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2476 // Accelerator table mutators - add each name along with its companion
2477 // DIE to the proper table while ensuring that the name that we're going
2478 // to reference is in the string table. We do this since the names we
2479 // add may not only be identical to the names in the DIE.
2480 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2481 if (!useDwarfAccelTables())
2483 AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2487 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2488 if (!useDwarfAccelTables())
2490 AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2494 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2495 if (!useDwarfAccelTables())
2497 AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2501 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2502 if (!useDwarfAccelTables())
2504 AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),