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 #define DEBUG_TYPE "dwarfdebug"
15 #include "ByteStreamer.h"
16 #include "DwarfDebug.h"
19 #include "DwarfAccelTable.h"
20 #include "DwarfUnit.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/Statistic.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/ADT/Triple.h"
25 #include "llvm/CodeGen/MachineFunction.h"
26 #include "llvm/CodeGen/MachineModuleInfo.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DIBuilder.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/ValueHandle.h"
34 #include "llvm/MC/MCAsmInfo.h"
35 #include "llvm/MC/MCSection.h"
36 #include "llvm/MC/MCStreamer.h"
37 #include "llvm/MC/MCSymbol.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/Dwarf.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/FormattedStream.h"
43 #include "llvm/Support/LEB128.h"
44 #include "llvm/Support/MD5.h"
45 #include "llvm/Support/Path.h"
46 #include "llvm/Support/Timer.h"
47 #include "llvm/Target/TargetFrameLowering.h"
48 #include "llvm/Target/TargetLoweringObjectFile.h"
49 #include "llvm/Target/TargetMachine.h"
50 #include "llvm/Target/TargetOptions.h"
51 #include "llvm/Target/TargetRegisterInfo.h"
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 //===----------------------------------------------------------------------===//
112 /// resolve - Look in the DwarfDebug map for the MDNode that
113 /// corresponds to the reference.
114 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
115 return DD->resolve(Ref);
118 bool DbgVariable::isBlockByrefVariable() const {
119 assert(Var.isVariable() && "Invalid complex DbgVariable!");
120 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
124 DIType DbgVariable::getType() const {
125 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
126 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
127 // addresses instead.
128 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
129 /* Byref variables, in Blocks, are declared by the programmer as
130 "SomeType VarName;", but the compiler creates a
131 __Block_byref_x_VarName struct, and gives the variable VarName
132 either the struct, or a pointer to the struct, as its type. This
133 is necessary for various behind-the-scenes things the compiler
134 needs to do with by-reference variables in blocks.
136 However, as far as the original *programmer* is concerned, the
137 variable should still have type 'SomeType', as originally declared.
139 The following function dives into the __Block_byref_x_VarName
140 struct to find the original type of the variable. This will be
141 passed back to the code generating the type for the Debug
142 Information Entry for the variable 'VarName'. 'VarName' will then
143 have the original type 'SomeType' in its debug information.
145 The original type 'SomeType' will be the type of the field named
146 'VarName' inside the __Block_byref_x_VarName struct.
148 NOTE: In order for this to not completely fail on the debugger
149 side, the Debug Information Entry for the variable VarName needs to
150 have a DW_AT_location that tells the debugger how to unwind through
151 the pointers and __Block_byref_x_VarName struct to find the actual
152 value of the variable. The function addBlockByrefType does this. */
154 uint16_t tag = Ty.getTag();
156 if (tag == dwarf::DW_TAG_pointer_type)
157 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
159 DIArray Elements = DICompositeType(subType).getTypeArray();
160 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
161 DIDerivedType DT(Elements.getElement(i));
162 if (getName() == DT.getName())
163 return (resolve(DT.getTypeDerivedFrom()));
169 } // end llvm namespace
171 /// Return Dwarf Version by checking module flags.
172 static unsigned getDwarfVersionFromModule(const Module *M) {
173 Value *Val = M->getModuleFlag("Dwarf Version");
175 return dwarf::DWARF_VERSION;
176 return cast<ConstantInt>(Val)->getZExtValue();
179 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
180 : Asm(A), MMI(Asm->MMI), FirstCU(0), PrevLabel(NULL), GlobalRangeCount(0),
181 InfoHolder(A, "info_string", DIEValueAllocator),
182 UsedNonDefaultText(false),
183 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
186 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
187 DwarfAddrSectionSym = 0;
188 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
189 FunctionBeginSym = FunctionEndSym = 0;
193 // Turn on accelerator tables for Darwin by default, pubnames by
194 // default for non-Darwin, and handle split dwarf.
195 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
197 if (DwarfAccelTables == Default)
198 HasDwarfAccelTables = IsDarwin;
200 HasDwarfAccelTables = DwarfAccelTables == Enable;
202 if (SplitDwarf == Default)
203 HasSplitDwarf = false;
205 HasSplitDwarf = SplitDwarf == Enable;
207 if (DwarfPubSections == Default)
208 HasDwarfPubSections = !IsDarwin;
210 HasDwarfPubSections = DwarfPubSections == Enable;
212 DwarfVersion = DwarfVersionNumber
214 : getDwarfVersionFromModule(MMI->getModule());
217 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
222 // Switch to the specified MCSection and emit an assembler
223 // temporary label to it if SymbolStem is specified.
224 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
225 const char *SymbolStem = 0) {
226 Asm->OutStreamer.SwitchSection(Section);
230 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
231 Asm->OutStreamer.EmitLabel(TmpSym);
235 DwarfFile::~DwarfFile() {
236 for (DwarfUnit *DU : CUs)
240 MCSymbol *DwarfFile::getStringPoolSym() {
241 return Asm->GetTempSymbol(StringPref);
244 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
245 std::pair<MCSymbol *, unsigned> &Entry =
246 StringPool.GetOrCreateValue(Str).getValue();
250 Entry.second = NextStringPoolNumber++;
251 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
254 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
255 std::pair<MCSymbol *, unsigned> &Entry =
256 StringPool.GetOrCreateValue(Str).getValue();
260 Entry.second = NextStringPoolNumber++;
261 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
265 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym, bool TLS) {
266 std::pair<AddrPool::iterator, bool> P = AddressPool.insert(
267 std::make_pair(Sym, AddressPoolEntry(NextAddrPoolNumber, TLS)));
269 ++NextAddrPoolNumber;
270 return P.first->second.Number;
273 // Define a unique number for the abbreviation.
275 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
276 // Check the set for priors.
277 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
279 // If it's newly added.
280 if (InSet == &Abbrev) {
281 // Add to abbreviation list.
282 Abbreviations.push_back(&Abbrev);
284 // Assign the vector position + 1 as its number.
285 Abbrev.setNumber(Abbreviations.size());
287 // Assign existing abbreviation number.
288 Abbrev.setNumber(InSet->getNumber());
292 static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
296 static bool hasObjCCategory(StringRef Name) {
297 if (!isObjCClass(Name))
300 return Name.find(") ") != StringRef::npos;
303 static void getObjCClassCategory(StringRef In, StringRef &Class,
304 StringRef &Category) {
305 if (!hasObjCCategory(In)) {
306 Class = In.slice(In.find('[') + 1, In.find(' '));
311 Class = In.slice(In.find('[') + 1, In.find('('));
312 Category = In.slice(In.find('[') + 1, In.find(' '));
316 static StringRef getObjCMethodName(StringRef In) {
317 return In.slice(In.find(' ') + 1, In.find(']'));
320 // Helper for sorting sections into a stable output order.
321 static bool SectionSort(const MCSection *A, const MCSection *B) {
322 std::string LA = (A ? A->getLabelBeginName() : "");
323 std::string LB = (B ? B->getLabelBeginName() : "");
327 // Add the various names to the Dwarf accelerator table names.
328 // TODO: Determine whether or not we should add names for programs
329 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
330 // is only slightly different than the lookup of non-standard ObjC names.
331 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
332 if (!SP.isDefinition())
334 TheU->addAccelName(SP.getName(), Die);
336 // If the linkage name is different than the name, go ahead and output
337 // that as well into the name table.
338 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
339 TheU->addAccelName(SP.getLinkageName(), Die);
341 // If this is an Objective-C selector name add it to the ObjC accelerator
343 if (isObjCClass(SP.getName())) {
344 StringRef Class, Category;
345 getObjCClassCategory(SP.getName(), Class, Category);
346 TheU->addAccelObjC(Class, Die);
348 TheU->addAccelObjC(Category, Die);
349 // Also add the base method name to the name table.
350 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
354 /// isSubprogramContext - Return true if Context is either a subprogram
355 /// or another context nested inside a subprogram.
356 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
359 DIDescriptor D(Context);
360 if (D.isSubprogram())
363 return isSubprogramContext(resolve(DIType(Context).getContext()));
367 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
368 // and DW_AT_high_pc attributes. If there are global variables in this
369 // scope then create and insert DIEs for these variables.
370 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
372 DIE *SPDie = SPCU->getDIE(SP);
374 assert(SPDie && "Unable to find subprogram DIE!");
376 // If we're updating an abstract DIE, then we will be adding the children and
377 // object pointer later on. But what we don't want to do is process the
378 // concrete DIE twice.
379 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
380 // Pick up abstract subprogram DIE.
382 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
383 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
385 DISubprogram SPDecl = SP.getFunctionDeclaration();
386 if (!SPDecl.isSubprogram()) {
387 // There is not any need to generate specification DIE for a function
388 // defined at compile unit level. If a function is defined inside another
389 // function then gdb prefers the definition at top level and but does not
390 // expect specification DIE in parent function. So avoid creating
391 // specification DIE for a function defined inside a function.
392 DIScope SPContext = resolve(SP.getContext());
393 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
394 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
395 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
398 DICompositeType SPTy = SP.getType();
399 DIArray Args = SPTy.getTypeArray();
400 uint16_t SPTag = SPTy.getTag();
401 if (SPTag == dwarf::DW_TAG_subroutine_type)
402 SPCU->constructSubprogramArguments(*SPDie, Args);
403 DIE *SPDeclDie = SPDie;
404 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
405 *SPCU->getUnitDie());
406 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
411 attachLowHighPC(SPCU, SPDie, FunctionBeginSym, FunctionEndSym);
413 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
414 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
415 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
417 // Add name to the name table, we do this here because we're guaranteed
418 // to have concrete versions of our DW_TAG_subprogram nodes.
419 addSubprogramNames(SPCU, SP, SPDie);
424 /// Check whether we should create a DIE for the given Scope, return true
425 /// if we don't create a DIE (the corresponding DIE is null).
426 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
427 if (Scope->isAbstractScope())
430 // We don't create a DIE if there is no Range.
431 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
435 if (Ranges.size() > 1)
438 // We don't create a DIE if we have a single Range and the end label
440 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
441 MCSymbol *End = getLabelAfterInsn(RI->second);
445 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
446 dwarf::Attribute A, const MCSymbol *L,
447 const MCSymbol *Sec) {
448 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
449 U->addSectionLabel(D, A, L);
451 U->addSectionDelta(D, A, L, Sec);
454 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
455 const SmallVectorImpl<InsnRange> &Range) {
456 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
457 // emitting it appropriately.
458 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
460 // Under fission, ranges are specified by constant offsets relative to the
461 // CU's DW_AT_GNU_ranges_base.
463 TheCU->addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
464 DwarfDebugRangeSectionSym);
466 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
467 DwarfDebugRangeSectionSym);
469 RangeSpanList List(RangeSym);
470 for (const InsnRange &R : Range) {
471 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
472 List.addRange(std::move(Span));
475 // Add the range list to the set of ranges to be emitted.
476 TheCU->addRangeList(std::move(List));
479 // Construct new DW_TAG_lexical_block for this scope and attach
480 // DW_AT_low_pc/DW_AT_high_pc labels.
481 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
482 LexicalScope *Scope) {
483 if (isLexicalScopeDIENull(Scope))
486 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
487 if (Scope->isAbstractScope())
490 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
492 // If we have multiple ranges, emit them into the range section.
493 if (ScopeRanges.size() > 1) {
494 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
498 // Construct the address range for this DIE.
499 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
500 MCSymbol *Start = getLabelBeforeInsn(RI->first);
501 MCSymbol *End = getLabelAfterInsn(RI->second);
502 assert(End && "End label should not be null!");
504 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
505 assert(End->isDefined() && "Invalid end label for an inlined scope!");
507 attachLowHighPC(TheCU, ScopeDIE, Start, End);
512 // This scope represents inlined body of a function. Construct DIE to
513 // represent this concrete inlined copy of the function.
514 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
515 LexicalScope *Scope) {
516 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
517 assert(!ScopeRanges.empty() &&
518 "LexicalScope does not have instruction markers!");
520 if (!Scope->getScopeNode())
522 DIScope DS(Scope->getScopeNode());
523 DISubprogram InlinedSP = getDISubprogram(DS);
524 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
526 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
530 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
531 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
533 // If we have multiple ranges, emit them into the range section.
534 if (ScopeRanges.size() > 1)
535 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
537 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
538 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
539 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
541 if (StartLabel == 0 || EndLabel == 0)
542 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
544 assert(StartLabel->isDefined() &&
545 "Invalid starting label for an inlined scope!");
546 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
548 attachLowHighPC(TheCU, ScopeDIE, StartLabel, EndLabel);
551 InlinedSubprogramDIEs.insert(OriginDIE);
553 // Add the call site information to the DIE.
554 DILocation DL(Scope->getInlinedAt());
556 ScopeDIE, dwarf::DW_AT_call_file, None,
557 TheCU->getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
558 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
560 // Add name to the name table, we do this here because we're guaranteed
561 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
562 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
567 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
569 SmallVectorImpl<DIE *> &Children) {
570 DIE *ObjectPointer = NULL;
572 // Collect arguments for current function.
573 if (LScopes.isCurrentFunctionScope(Scope)) {
574 for (DbgVariable *ArgDV : CurrentFnArguments)
577 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
578 Children.push_back(Arg);
579 if (ArgDV->isObjectPointer())
583 // If this is a variadic function, add an unspecified parameter.
584 DISubprogram SP(Scope->getScopeNode());
585 DIArray FnArgs = SP.getType().getTypeArray();
586 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
587 .isUnspecifiedParameter()) {
588 DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
589 Children.push_back(Ellipsis);
593 // Collect lexical scope children first.
594 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
595 if (DIE *Variable = TheCU->constructVariableDIE(*DV,
596 Scope->isAbstractScope())) {
597 Children.push_back(Variable);
598 if (DV->isObjectPointer())
599 ObjectPointer = Variable;
601 for (LexicalScope *LS : Scope->getChildren())
602 if (DIE *Nested = constructScopeDIE(TheCU, LS))
603 Children.push_back(Nested);
604 return ObjectPointer;
607 // Construct a DIE for this scope.
608 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
609 LexicalScope *Scope) {
610 if (!Scope || !Scope->getScopeNode())
613 DIScope DS(Scope->getScopeNode());
615 SmallVector<DIE *, 8> Children;
616 DIE *ObjectPointer = NULL;
617 bool ChildrenCreated = false;
619 // We try to create the scope DIE first, then the children DIEs. This will
620 // avoid creating un-used children then removing them later when we find out
621 // the scope DIE is null.
622 DIE *ScopeDIE = NULL;
623 if (Scope->getInlinedAt())
624 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
625 else if (DS.isSubprogram()) {
626 ProcessedSPNodes.insert(DS);
627 if (Scope->isAbstractScope()) {
628 ScopeDIE = TheCU->getDIE(DS);
629 // Note down abstract DIE.
631 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
633 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
635 // Early exit when we know the scope DIE is going to be null.
636 if (isLexicalScopeDIENull(Scope))
639 // We create children here when we know the scope DIE is not going to be
640 // null and the children will be added to the scope DIE.
641 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
642 ChildrenCreated = true;
644 // There is no need to emit empty lexical block DIE.
645 std::pair<ImportedEntityMap::const_iterator,
646 ImportedEntityMap::const_iterator> Range =
648 ScopesWithImportedEntities.begin(),
649 ScopesWithImportedEntities.end(),
650 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
652 if (Children.empty() && Range.first == Range.second)
654 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
655 assert(ScopeDIE && "Scope DIE should not be null.");
656 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
658 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
662 assert(Children.empty() &&
663 "We create children only when the scope DIE is not null.");
666 if (!ChildrenCreated)
667 // We create children when the scope DIE is not null.
668 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
671 for (DIE *I : Children)
672 ScopeDIE->addChild(I);
674 if (DS.isSubprogram() && ObjectPointer != NULL)
675 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
680 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
681 if (!GenerateGnuPubSections)
684 U->addFlag(D, dwarf::DW_AT_GNU_pubnames);
687 // Create new DwarfCompileUnit for the given metadata node with tag
688 // DW_TAG_compile_unit.
689 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
690 StringRef FN = DIUnit.getFilename();
691 CompilationDir = DIUnit.getDirectory();
693 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
694 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
695 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
696 InfoHolder.addUnit(NewCU);
698 // LTO with assembly output shares a single line table amongst multiple CUs.
699 // To avoid the compilation directory being ambiguous, let the line table
700 // explicitly describe the directory of all files, never relying on the
701 // compilation directory.
702 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
703 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
704 NewCU->getUniqueID(), CompilationDir);
706 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
707 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
708 DIUnit.getLanguage());
709 NewCU->addString(Die, dwarf::DW_AT_name, FN);
711 if (!useSplitDwarf()) {
712 NewCU->initStmtList(DwarfLineSectionSym);
714 // If we're using split dwarf the compilation dir is going to be in the
715 // skeleton CU and so we don't need to duplicate it here.
716 if (!CompilationDir.empty())
717 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
719 addGnuPubAttributes(NewCU, Die);
722 if (DIUnit.isOptimized())
723 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
725 StringRef Flags = DIUnit.getFlags();
727 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
729 if (unsigned RVer = DIUnit.getRunTimeVersion())
730 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
731 dwarf::DW_FORM_data1, RVer);
736 if (useSplitDwarf()) {
737 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
738 DwarfInfoDWOSectionSym);
739 NewCU->setSkeleton(constructSkeletonCU(NewCU));
741 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
742 DwarfInfoSectionSym);
744 CUMap.insert(std::make_pair(DIUnit, NewCU));
745 CUDieMap.insert(std::make_pair(Die, NewCU));
749 // Construct subprogram DIE.
750 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
752 // FIXME: We should only call this routine once, however, during LTO if a
753 // program is defined in multiple CUs we could end up calling it out of
754 // beginModule as we walk the CUs.
756 DwarfCompileUnit *&CURef = SPMap[N];
762 if (!SP.isDefinition())
763 // This is a method declaration which will be handled while constructing
767 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
769 // Expose as a global name.
770 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
773 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
775 DIImportedEntity Module(N);
776 assert(Module.Verify());
777 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
778 constructImportedEntityDIE(TheCU, Module, D);
781 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
782 const MDNode *N, DIE *Context) {
783 DIImportedEntity Module(N);
784 assert(Module.Verify());
785 return constructImportedEntityDIE(TheCU, Module, Context);
788 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
789 const DIImportedEntity &Module,
791 assert(Module.Verify() &&
792 "Use one of the MDNode * overloads to handle invalid metadata");
793 assert(Context && "Should always have a context for an imported_module");
794 DIE *IMDie = new DIE(Module.getTag());
795 TheCU->insertDIE(Module, IMDie);
797 DIDescriptor Entity = Module.getEntity();
798 if (Entity.isNameSpace())
799 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
800 else if (Entity.isSubprogram())
801 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
802 else if (Entity.isType())
803 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
805 EntityDie = TheCU->getDIE(Entity);
806 TheCU->addSourceLine(IMDie, Module.getLineNumber(),
807 Module.getContext().getFilename(),
808 Module.getContext().getDirectory());
809 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
810 StringRef Name = Module.getName();
812 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
813 Context->addChild(IMDie);
816 // Emit all Dwarf sections that should come prior to the content. Create
817 // global DIEs and emit initial debug info sections. This is invoked by
818 // the target AsmPrinter.
819 void DwarfDebug::beginModule() {
820 if (DisableDebugInfoPrinting)
823 const Module *M = MMI->getModule();
825 // If module has named metadata anchors then use them, otherwise scan the
826 // module using debug info finder to collect debug info.
827 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
830 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
832 // Emit initial sections so we can reference labels later.
835 SingleCU = CU_Nodes->getNumOperands() == 1;
837 for (MDNode *N : CU_Nodes->operands()) {
838 DICompileUnit CUNode(N);
839 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
840 DIArray ImportedEntities = CUNode.getImportedEntities();
841 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
842 ScopesWithImportedEntities.push_back(std::make_pair(
843 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
844 ImportedEntities.getElement(i)));
845 std::sort(ScopesWithImportedEntities.begin(),
846 ScopesWithImportedEntities.end(), less_first());
847 DIArray GVs = CUNode.getGlobalVariables();
848 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
849 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
850 DIArray SPs = CUNode.getSubprograms();
851 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
852 constructSubprogramDIE(CU, SPs.getElement(i));
853 DIArray EnumTypes = CUNode.getEnumTypes();
854 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
855 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
856 DIArray RetainedTypes = CUNode.getRetainedTypes();
857 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
858 DIType Ty(RetainedTypes.getElement(i));
859 // The retained types array by design contains pointers to
860 // MDNodes rather than DIRefs. Unique them here.
861 DIType UniqueTy(resolve(Ty.getRef()));
862 CU->getOrCreateTypeDIE(UniqueTy);
864 // Emit imported_modules last so that the relevant context is already
866 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
867 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
870 // Tell MMI that we have debug info.
871 MMI->setDebugInfoAvailability(true);
873 // Prime section data.
874 SectionMap[Asm->getObjFileLowering().getTextSection()];
877 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
878 void DwarfDebug::computeInlinedDIEs() {
879 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
880 for (DIE *ISP : InlinedSubprogramDIEs)
881 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
883 for (const auto &AI : AbstractSPDies) {
884 DIE *ISP = AI.second;
885 if (InlinedSubprogramDIEs.count(ISP))
887 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
891 // Collect info for variables that were optimized out.
892 void DwarfDebug::collectDeadVariables() {
893 const Module *M = MMI->getModule();
895 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
896 for (MDNode *N : CU_Nodes->operands()) {
897 DICompileUnit TheCU(N);
898 DIArray Subprograms = TheCU.getSubprograms();
899 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
900 DISubprogram SP(Subprograms.getElement(i));
901 if (ProcessedSPNodes.count(SP) != 0)
903 if (!SP.isSubprogram())
905 if (!SP.isDefinition())
907 DIArray Variables = SP.getVariables();
908 if (Variables.getNumElements() == 0)
911 // Construct subprogram DIE and add variables DIEs.
912 DwarfCompileUnit *SPCU =
913 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
914 assert(SPCU && "Unable to find Compile Unit!");
915 // FIXME: See the comment in constructSubprogramDIE about duplicate
917 constructSubprogramDIE(SPCU, SP);
918 DIE *SPDIE = SPCU->getDIE(SP);
919 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
920 DIVariable DV(Variables.getElement(vi));
921 if (!DV.isVariable())
923 DbgVariable NewVar(DV, NULL, this);
924 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
925 SPDIE->addChild(VariableDIE);
932 void DwarfDebug::finalizeModuleInfo() {
933 // Collect info for variables that were optimized out.
934 collectDeadVariables();
936 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
937 computeInlinedDIEs();
939 // Handle anything that needs to be done on a per-unit basis after
940 // all other generation.
941 for (DwarfUnit *TheU : getUnits()) {
942 // Emit DW_AT_containing_type attribute to connect types with their
943 // vtable holding type.
944 TheU->constructContainingTypeDIEs();
946 // Add CU specific attributes if we need to add any.
947 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
948 // If we're splitting the dwarf out now that we've got the entire
949 // CU then add the dwo id to it.
950 DwarfCompileUnit *SkCU =
951 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
952 if (useSplitDwarf()) {
953 // Emit a unique identifier for this CU.
954 uint64_t ID = DIEHash(Asm).computeCUSignature(*TheU->getUnitDie());
955 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
956 dwarf::DW_FORM_data8, ID);
957 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
958 dwarf::DW_FORM_data8, ID);
961 // If we have code split among multiple sections or non-contiguous
962 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
963 // remain in the .o file, otherwise add a DW_AT_low_pc.
964 // FIXME: We should use ranges allow reordering of code ala
965 // .subsections_via_symbols in mach-o. This would mean turning on
966 // ranges for all subprogram DIEs for mach-o.
967 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
968 unsigned NumRanges = TheU->getRanges().size();
971 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
972 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
973 DwarfDebugRangeSectionSym);
975 // A DW_AT_low_pc attribute may also be specified in combination with
976 // DW_AT_ranges to specify the default base address for use in
977 // location lists (see Section 2.6.2) and range lists (see Section
979 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
982 RangeSpan &Range = TheU->getRanges().back();
983 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_low_pc,
985 U->addLabelDelta(U->getUnitDie(), dwarf::DW_AT_high_pc,
986 Range.getEnd(), Range.getStart());
992 // Compute DIE offsets and sizes.
993 InfoHolder.computeSizeAndOffsets();
995 SkeletonHolder.computeSizeAndOffsets();
998 void DwarfDebug::endSections() {
999 // Filter labels by section.
1000 for (const SymbolCU &SCU : ArangeLabels) {
1001 if (SCU.Sym->isInSection()) {
1002 // Make a note of this symbol and it's section.
1003 const MCSection *Section = &SCU.Sym->getSection();
1004 if (!Section->getKind().isMetadata())
1005 SectionMap[Section].push_back(SCU);
1007 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1008 // appear in the output. This sucks as we rely on sections to build
1009 // arange spans. We can do it without, but it's icky.
1010 SectionMap[NULL].push_back(SCU);
1014 // Build a list of sections used.
1015 std::vector<const MCSection *> Sections;
1016 for (const auto &it : SectionMap) {
1017 const MCSection *Section = it.first;
1018 Sections.push_back(Section);
1021 // Sort the sections into order.
1022 // This is only done to ensure consistent output order across different runs.
1023 std::sort(Sections.begin(), Sections.end(), SectionSort);
1025 // Add terminating symbols for each section.
1026 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
1027 const MCSection *Section = Sections[ID];
1028 MCSymbol *Sym = NULL;
1031 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1032 // if we know the section name up-front. For user-created sections, the
1033 // resulting label may not be valid to use as a label. (section names can
1034 // use a greater set of characters on some systems)
1035 Sym = Asm->GetTempSymbol("debug_end", ID);
1036 Asm->OutStreamer.SwitchSection(Section);
1037 Asm->OutStreamer.EmitLabel(Sym);
1040 // Insert a final terminator.
1041 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1045 // Emit all Dwarf sections that should come after the content.
1046 void DwarfDebug::endModule() {
1053 // End any existing sections.
1054 // TODO: Does this need to happen?
1057 // Finalize the debug info for the module.
1058 finalizeModuleInfo();
1062 // Emit all the DIEs into a debug info section.
1065 // Corresponding abbreviations into a abbrev section.
1066 emitAbbreviations();
1068 // Emit info into a debug loc section.
1071 // Emit info into a debug aranges section.
1072 if (GenerateARangeSection)
1075 // Emit info into a debug ranges section.
1078 if (useSplitDwarf()) {
1081 emitDebugAbbrevDWO();
1083 // Emit DWO addresses.
1084 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1087 // Emit info into the dwarf accelerator table sections.
1088 if (useDwarfAccelTables()) {
1091 emitAccelNamespaces();
1095 // Emit the pubnames and pubtypes sections if requested.
1096 if (HasDwarfPubSections) {
1097 emitDebugPubNames(GenerateGnuPubSections);
1098 emitDebugPubTypes(GenerateGnuPubSections);
1104 // Reset these for the next Module if we have one.
1108 // Find abstract variable, if any, associated with Var.
1109 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1110 DebugLoc ScopeLoc) {
1111 LLVMContext &Ctx = DV->getContext();
1112 // More then one inlined variable corresponds to one abstract variable.
1113 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1114 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1116 return AbsDbgVariable;
1118 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1122 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1123 addScopeVariable(Scope, AbsDbgVariable);
1124 AbstractVariables[Var] = AbsDbgVariable;
1125 return AbsDbgVariable;
1128 // If Var is a current function argument then add it to CurrentFnArguments list.
1129 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1130 if (!LScopes.isCurrentFunctionScope(Scope))
1132 DIVariable DV = Var->getVariable();
1133 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1135 unsigned ArgNo = DV.getArgNumber();
1139 size_t Size = CurrentFnArguments.size();
1141 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1142 // llvm::Function argument size is not good indicator of how many
1143 // arguments does the function have at source level.
1145 CurrentFnArguments.resize(ArgNo * 2);
1146 CurrentFnArguments[ArgNo - 1] = Var;
1150 // Collect variable information from side table maintained by MMI.
1151 void DwarfDebug::collectVariableInfoFromMMITable(
1152 SmallPtrSet<const MDNode *, 16> &Processed) {
1153 for (const auto &VI : MMI->getVariableDbgInfo()) {
1156 Processed.insert(VI.Var);
1157 DIVariable DV(VI.Var);
1158 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1160 // If variable scope is not found then skip this variable.
1164 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1165 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1166 RegVar->setFrameIndex(VI.Slot);
1167 if (!addCurrentFnArgument(RegVar, Scope))
1168 addScopeVariable(Scope, RegVar);
1170 AbsDbgVariable->setFrameIndex(VI.Slot);
1174 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1176 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1177 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1178 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1179 MI->getOperand(0).getReg() &&
1180 (MI->getOperand(1).isImm() ||
1181 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1184 // Get .debug_loc entry for the instruction range starting at MI.
1185 static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1186 const MCSymbol *FLabel,
1187 const MCSymbol *SLabel,
1188 const MachineInstr *MI,
1189 DwarfCompileUnit *Unit) {
1190 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1192 assert(MI->getNumOperands() == 3);
1193 if (MI->getOperand(0).isReg()) {
1194 MachineLocation MLoc;
1195 // If the second operand is an immediate, this is a
1196 // register-indirect address.
1197 if (!MI->getOperand(1).isImm())
1198 MLoc.set(MI->getOperand(0).getReg());
1200 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1201 return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
1203 if (MI->getOperand(0).isImm())
1204 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Unit);
1205 if (MI->getOperand(0).isFPImm())
1206 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(), Unit);
1207 if (MI->getOperand(0).isCImm())
1208 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(), Unit);
1210 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1213 // Find variables for each lexical scope.
1215 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1217 // Grab the variable info that was squirreled away in the MMI side-table.
1218 collectVariableInfoFromMMITable(Processed);
1220 for (const MDNode *Var : UserVariables) {
1221 if (Processed.count(Var))
1224 // History contains relevant DBG_VALUE instructions for Var and instructions
1226 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1227 if (History.empty())
1229 const MachineInstr *MInsn = History.front();
1232 LexicalScope *Scope = NULL;
1233 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1234 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1235 Scope = LScopes.getCurrentFunctionScope();
1236 else if (MDNode *IA = DV.getInlinedAt())
1237 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1239 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1240 // If variable scope is not found then skip this variable.
1244 Processed.insert(DV);
1245 assert(MInsn->isDebugValue() && "History must begin with debug value");
1246 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1247 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1248 if (!addCurrentFnArgument(RegVar, Scope))
1249 addScopeVariable(Scope, RegVar);
1251 AbsVar->setMInsn(MInsn);
1253 // Simplify ranges that are fully coalesced.
1254 if (History.size() <= 1 ||
1255 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1256 RegVar->setMInsn(MInsn);
1260 // Handle multiple DBG_VALUE instructions describing one variable.
1261 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1263 SmallVector<DebugLocEntry, 4> DebugLoc;
1264 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1265 HI = History.begin(),
1268 const MachineInstr *Begin = *HI;
1269 assert(Begin->isDebugValue() && "Invalid History entry");
1271 // Check if DBG_VALUE is truncating a range.
1272 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1273 !Begin->getOperand(0).getReg())
1276 // Compute the range for a register location.
1277 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1278 const MCSymbol *SLabel = 0;
1281 // If Begin is the last instruction in History then its value is valid
1282 // until the end of the function.
1283 SLabel = FunctionEndSym;
1285 const MachineInstr *End = HI[1];
1286 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1287 << "\t" << *Begin << "\t" << *End << "\n");
1288 if (End->isDebugValue())
1289 SLabel = getLabelBeforeInsn(End);
1291 // End is a normal instruction clobbering the range.
1292 SLabel = getLabelAfterInsn(End);
1293 assert(SLabel && "Forgot label after clobber instruction");
1298 // The value is valid until the next DBG_VALUE or clobber.
1299 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1300 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1301 DebugLocEntry Loc = getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU);
1302 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1303 DebugLoc.push_back(std::move(Loc));
1305 DotDebugLocEntries.push_back(std::move(DebugLoc));
1308 // Collect info for variables that were optimized out.
1309 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1310 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1311 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1312 DIVariable DV(Variables.getElement(i));
1313 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1315 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1316 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1320 // Return Label preceding the instruction.
1321 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1322 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1323 assert(Label && "Didn't insert label before instruction");
1327 // Return Label immediately following the instruction.
1328 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1329 return LabelsAfterInsn.lookup(MI);
1332 // Process beginning of an instruction.
1333 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1336 // Check if source location changes, but ignore DBG_VALUE locations.
1337 if (!MI->isDebugValue()) {
1338 DebugLoc DL = MI->getDebugLoc();
1339 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1342 if (DL == PrologEndLoc) {
1343 Flags |= DWARF2_FLAG_PROLOGUE_END;
1344 PrologEndLoc = DebugLoc();
1346 if (PrologEndLoc.isUnknown())
1347 Flags |= DWARF2_FLAG_IS_STMT;
1349 if (!DL.isUnknown()) {
1350 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1351 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1353 recordSourceLine(0, 0, 0, 0);
1357 // Insert labels where requested.
1358 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1359 LabelsBeforeInsn.find(MI);
1362 if (I == LabelsBeforeInsn.end())
1365 // Label already assigned.
1370 PrevLabel = MMI->getContext().CreateTempSymbol();
1371 Asm->OutStreamer.EmitLabel(PrevLabel);
1373 I->second = PrevLabel;
1376 // Process end of an instruction.
1377 void DwarfDebug::endInstruction() {
1379 // Don't create a new label after DBG_VALUE instructions.
1380 // They don't generate code.
1381 if (!CurMI->isDebugValue())
1384 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1385 LabelsAfterInsn.find(CurMI);
1389 if (I == LabelsAfterInsn.end())
1392 // Label already assigned.
1396 // We need a label after this instruction.
1398 PrevLabel = MMI->getContext().CreateTempSymbol();
1399 Asm->OutStreamer.EmitLabel(PrevLabel);
1401 I->second = PrevLabel;
1404 // Each LexicalScope has first instruction and last instruction to mark
1405 // beginning and end of a scope respectively. Create an inverse map that list
1406 // scopes starts (and ends) with an instruction. One instruction may start (or
1407 // end) multiple scopes. Ignore scopes that are not reachable.
1408 void DwarfDebug::identifyScopeMarkers() {
1409 SmallVector<LexicalScope *, 4> WorkList;
1410 WorkList.push_back(LScopes.getCurrentFunctionScope());
1411 while (!WorkList.empty()) {
1412 LexicalScope *S = WorkList.pop_back_val();
1414 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1415 if (!Children.empty())
1416 WorkList.append(Children.begin(), Children.end());
1418 if (S->isAbstractScope())
1421 for (const InsnRange &R : S->getRanges()) {
1422 assert(R.first && "InsnRange does not have first instruction!");
1423 assert(R.second && "InsnRange does not have second instruction!");
1424 requestLabelBeforeInsn(R.first);
1425 requestLabelAfterInsn(R.second);
1430 // Gather pre-function debug information. Assumes being called immediately
1431 // after the function entry point has been emitted.
1432 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1435 // If there's no debug info for the function we're not going to do anything.
1436 if (!MMI->hasDebugInfo())
1439 // Grab the lexical scopes for the function, if we don't have any of those
1440 // then we're not going to be able to do anything.
1441 LScopes.initialize(*MF);
1442 if (LScopes.empty())
1445 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1447 // Make sure that each lexical scope will have a begin/end label.
1448 identifyScopeMarkers();
1450 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1451 // belongs to so that we add to the correct per-cu line table in the
1453 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1454 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1455 assert(TheCU && "Unable to find compile unit!");
1456 if (Asm->OutStreamer.hasRawTextSupport())
1457 // Use a single line table if we are generating assembly.
1458 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1460 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1462 // Emit a label for the function so that we have a beginning address.
1463 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1464 // Assumes in correct section after the entry point.
1465 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1467 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1468 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1469 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1471 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1473 bool AtBlockEntry = true;
1474 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1476 const MachineInstr *MI = II;
1478 if (MI->isDebugValue()) {
1479 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1481 // Keep track of user variables.
1483 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1485 // Variable is in a register, we need to check for clobbers.
1486 if (isDbgValueInDefinedReg(MI))
1487 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1489 // Check the history of this variable.
1490 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1491 if (History.empty()) {
1492 UserVariables.push_back(Var);
1493 // The first mention of a function argument gets the FunctionBeginSym
1494 // label, so arguments are visible when breaking at function entry.
1496 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1497 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1498 LabelsBeforeInsn[MI] = FunctionBeginSym;
1500 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1501 const MachineInstr *Prev = History.back();
1502 if (Prev->isDebugValue()) {
1503 // Coalesce identical entries at the end of History.
1504 if (History.size() >= 2 &&
1505 Prev->isIdenticalTo(History[History.size() - 2])) {
1506 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1507 << "\t" << *Prev << "\t"
1508 << *History[History.size() - 2] << "\n");
1512 // Terminate old register assignments that don't reach MI;
1513 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1514 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1515 isDbgValueInDefinedReg(Prev)) {
1516 // Previous register assignment needs to terminate at the end of
1518 MachineBasicBlock::const_iterator LastMI =
1519 PrevMBB->getLastNonDebugInstr();
1520 if (LastMI == PrevMBB->end()) {
1521 // Drop DBG_VALUE for empty range.
1522 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1523 << "\t" << *Prev << "\n");
1525 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1526 // Terminate after LastMI.
1527 History.push_back(LastMI);
1531 History.push_back(MI);
1533 // Not a DBG_VALUE instruction.
1534 if (!MI->isPosition())
1535 AtBlockEntry = false;
1537 // First known non-DBG_VALUE and non-frame setup location marks
1538 // the beginning of the function body.
1539 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1540 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1541 PrologEndLoc = MI->getDebugLoc();
1543 // Check if the instruction clobbers any registers with debug vars.
1544 for (const MachineOperand &MO : MI->operands()) {
1545 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1547 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1550 const MDNode *Var = LiveUserVar[Reg];
1553 // Reg is now clobbered.
1554 LiveUserVar[Reg] = 0;
1556 // Was MD last defined by a DBG_VALUE referring to Reg?
1557 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1558 if (HistI == DbgValues.end())
1560 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1561 if (History.empty())
1563 const MachineInstr *Prev = History.back();
1564 // Sanity-check: Register assignments are terminated at the end of
1566 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1568 // Is the variable still in Reg?
1569 if (!isDbgValueInDefinedReg(Prev) ||
1570 Prev->getOperand(0).getReg() != Reg)
1572 // Var is clobbered. Make sure the next instruction gets a label.
1573 History.push_back(MI);
1580 for (auto &I : DbgValues) {
1581 SmallVectorImpl<const MachineInstr *> &History = I.second;
1582 if (History.empty())
1585 // Make sure the final register assignments are terminated.
1586 const MachineInstr *Prev = History.back();
1587 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1588 const MachineBasicBlock *PrevMBB = Prev->getParent();
1589 MachineBasicBlock::const_iterator LastMI =
1590 PrevMBB->getLastNonDebugInstr();
1591 if (LastMI == PrevMBB->end())
1592 // Drop DBG_VALUE for empty range.
1594 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1595 // Terminate after LastMI.
1596 History.push_back(LastMI);
1599 // Request labels for the full history.
1600 for (const MachineInstr *MI : History) {
1601 if (MI->isDebugValue())
1602 requestLabelBeforeInsn(MI);
1604 requestLabelAfterInsn(MI);
1608 PrevInstLoc = DebugLoc();
1609 PrevLabel = FunctionBeginSym;
1611 // Record beginning of function.
1612 if (!PrologEndLoc.isUnknown()) {
1613 DebugLoc FnStartDL =
1614 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1616 FnStartDL.getLine(), FnStartDL.getCol(),
1617 FnStartDL.getScope(MF->getFunction()->getContext()),
1618 // We'd like to list the prologue as "not statements" but GDB behaves
1619 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1620 DWARF2_FLAG_IS_STMT);
1624 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1625 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1626 DIVariable DV = Var->getVariable();
1627 // Variables with positive arg numbers are parameters.
1628 if (unsigned ArgNum = DV.getArgNumber()) {
1629 // Keep all parameters in order at the start of the variable list to ensure
1630 // function types are correct (no out-of-order parameters)
1632 // This could be improved by only doing it for optimized builds (unoptimized
1633 // builds have the right order to begin with), searching from the back (this
1634 // would catch the unoptimized case quickly), or doing a binary search
1635 // rather than linear search.
1636 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1637 while (I != Vars.end()) {
1638 unsigned CurNum = (*I)->getVariable().getArgNumber();
1639 // A local (non-parameter) variable has been found, insert immediately
1643 // A later indexed parameter has been found, insert immediately before it.
1644 if (CurNum > ArgNum)
1648 Vars.insert(I, Var);
1652 Vars.push_back(Var);
1655 // Gather and emit post-function debug information.
1656 void DwarfDebug::endFunction(const MachineFunction *MF) {
1657 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1658 // though the beginFunction may not be called at all.
1659 // We should handle both cases.
1663 assert(CurFn == MF);
1666 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1667 // If we don't have a lexical scope for this function then there will
1668 // be a hole in the range information. Keep note of this by setting the
1669 // previously used section to nullptr.
1670 PrevSection = nullptr;
1676 // Define end label for subprogram.
1677 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1678 // Assumes in correct section after the entry point.
1679 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1681 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1682 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1684 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1685 collectVariableInfo(ProcessedVars);
1687 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1688 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1689 assert(TheCU && "Unable to find compile unit!");
1691 // Construct abstract scopes.
1692 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1693 DISubprogram SP(AScope->getScopeNode());
1694 if (SP.isSubprogram()) {
1695 // Collect info for variables that were optimized out.
1696 DIArray Variables = SP.getVariables();
1697 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1698 DIVariable DV(Variables.getElement(i));
1699 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1701 // Check that DbgVariable for DV wasn't created earlier, when
1702 // findAbstractVariable() was called for inlined instance of DV.
1703 LLVMContext &Ctx = DV->getContext();
1704 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1705 if (AbstractVariables.lookup(CleanDV))
1707 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1708 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1711 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1712 constructScopeDIE(TheCU, AScope);
1715 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1716 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1717 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1719 // Add the range of this function to the list of ranges for the CU.
1720 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1721 TheCU->addRange(std::move(Span));
1722 PrevSection = Asm->getCurrentSection();
1726 for (auto &I : ScopeVariables)
1727 DeleteContainerPointers(I.second);
1728 ScopeVariables.clear();
1729 DeleteContainerPointers(CurrentFnArguments);
1730 UserVariables.clear();
1732 AbstractVariables.clear();
1733 LabelsBeforeInsn.clear();
1734 LabelsAfterInsn.clear();
1739 // Register a source line with debug info. Returns the unique label that was
1740 // emitted and which provides correspondence to the source line list.
1741 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1746 unsigned Discriminator = 0;
1748 DIDescriptor Scope(S);
1750 if (Scope.isCompileUnit()) {
1751 DICompileUnit CU(S);
1752 Fn = CU.getFilename();
1753 Dir = CU.getDirectory();
1754 } else if (Scope.isFile()) {
1756 Fn = F.getFilename();
1757 Dir = F.getDirectory();
1758 } else if (Scope.isSubprogram()) {
1760 Fn = SP.getFilename();
1761 Dir = SP.getDirectory();
1762 } else if (Scope.isLexicalBlockFile()) {
1763 DILexicalBlockFile DBF(S);
1764 Fn = DBF.getFilename();
1765 Dir = DBF.getDirectory();
1766 } else if (Scope.isLexicalBlock()) {
1767 DILexicalBlock DB(S);
1768 Fn = DB.getFilename();
1769 Dir = DB.getDirectory();
1770 Discriminator = DB.getDiscriminator();
1772 llvm_unreachable("Unexpected scope info");
1774 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1775 Src = static_cast<DwarfCompileUnit *>(InfoHolder.getUnits()[CUID])
1776 ->getOrCreateSourceID(Fn, Dir);
1778 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1782 //===----------------------------------------------------------------------===//
1784 //===----------------------------------------------------------------------===//
1786 // Compute the size and offset of a DIE. The offset is relative to start of the
1787 // CU. It returns the offset after laying out the DIE.
1788 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1789 // Record the abbreviation.
1790 assignAbbrevNumber(Die->getAbbrev());
1792 // Get the abbreviation for this DIE.
1793 const DIEAbbrev &Abbrev = Die->getAbbrev();
1796 Die->setOffset(Offset);
1798 // Start the size with the size of abbreviation code.
1799 Offset += getULEB128Size(Die->getAbbrevNumber());
1801 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1802 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1804 // Size the DIE attribute values.
1805 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1806 // Size attribute value.
1807 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1809 // Get the children.
1810 const std::vector<DIE *> &Children = Die->getChildren();
1812 // Size the DIE children if any.
1813 if (!Children.empty()) {
1814 assert(Abbrev.hasChildren() && "Children flag not set");
1816 for (DIE *Child : Children)
1817 Offset = computeSizeAndOffset(Child, Offset);
1819 // End of children marker.
1820 Offset += sizeof(int8_t);
1823 Die->setSize(Offset - Die->getOffset());
1827 // Compute the size and offset for each DIE.
1828 void DwarfFile::computeSizeAndOffsets() {
1829 // Offset from the first CU in the debug info section is 0 initially.
1830 unsigned SecOffset = 0;
1832 // Iterate over each compile unit and set the size and offsets for each
1833 // DIE within each compile unit. All offsets are CU relative.
1834 for (DwarfUnit *TheU : CUs) {
1835 TheU->setDebugInfoOffset(SecOffset);
1837 // CU-relative offset is reset to 0 here.
1838 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1839 TheU->getHeaderSize(); // Unit-specific headers
1841 // EndOffset here is CU-relative, after laying out
1842 // all of the CU DIE.
1843 unsigned EndOffset = computeSizeAndOffset(TheU->getUnitDie(), Offset);
1844 SecOffset += EndOffset;
1848 // Emit initial Dwarf sections with a label at the start of each one.
1849 void DwarfDebug::emitSectionLabels() {
1850 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1852 // Dwarf sections base addresses.
1853 DwarfInfoSectionSym =
1854 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1855 if (useSplitDwarf())
1856 DwarfInfoDWOSectionSym =
1857 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1858 DwarfAbbrevSectionSym =
1859 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1860 if (useSplitDwarf())
1861 DwarfAbbrevDWOSectionSym = emitSectionSym(
1862 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1863 if (GenerateARangeSection)
1864 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1866 DwarfLineSectionSym =
1867 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1868 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1869 if (GenerateGnuPubSections) {
1870 DwarfGnuPubNamesSectionSym =
1871 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1872 DwarfGnuPubTypesSectionSym =
1873 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1874 } else if (HasDwarfPubSections) {
1875 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1876 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1879 DwarfStrSectionSym =
1880 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1881 if (useSplitDwarf()) {
1882 DwarfStrDWOSectionSym =
1883 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1884 DwarfAddrSectionSym =
1885 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1887 DwarfDebugRangeSectionSym =
1888 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1890 DwarfDebugLocSectionSym =
1891 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1894 // Recursively emits a debug information entry.
1895 void DwarfDebug::emitDIE(DIE *Die) {
1896 // Get the abbreviation for this DIE.
1897 const DIEAbbrev &Abbrev = Die->getAbbrev();
1899 // Emit the code (index) for the abbreviation.
1900 if (Asm->isVerbose())
1901 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1902 "] 0x" + Twine::utohexstr(Die->getOffset()) +
1903 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
1904 dwarf::TagString(Abbrev.getTag()));
1905 Asm->EmitULEB128(Abbrev.getNumber());
1907 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1908 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1910 // Emit the DIE attribute values.
1911 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1912 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1913 dwarf::Form Form = AbbrevData[i].getForm();
1914 assert(Form && "Too many attributes for DIE (check abbreviation)");
1916 if (Asm->isVerbose()) {
1917 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1918 if (Attr == dwarf::DW_AT_accessibility)
1919 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1920 cast<DIEInteger>(Values[i])->getValue()));
1923 // Emit an attribute using the defined form.
1924 Values[i]->EmitValue(Asm, Form);
1927 // Emit the DIE children if any.
1928 if (Abbrev.hasChildren()) {
1929 const std::vector<DIE *> &Children = Die->getChildren();
1931 for (DIE *Child : Children)
1934 Asm->OutStreamer.AddComment("End Of Children Mark");
1939 // Emit the various dwarf units to the unit section USection with
1940 // the abbreviations going into ASection.
1941 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym) {
1942 for (DwarfUnit *TheU : CUs) {
1943 DIE *Die = TheU->getUnitDie();
1944 const MCSection *USection = TheU->getSection();
1945 Asm->OutStreamer.SwitchSection(USection);
1947 // Emit the compile units header.
1948 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
1950 // Emit size of content not including length itself
1951 Asm->OutStreamer.AddComment("Length of Unit");
1952 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
1954 TheU->emitHeader(ASectionSym);
1957 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
1961 // Emit the debug info section.
1962 void DwarfDebug::emitDebugInfo() {
1963 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1965 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1968 // Emit the abbreviation section.
1969 void DwarfDebug::emitAbbreviations() {
1970 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1972 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1975 void DwarfFile::emitAbbrevs(const MCSection *Section) {
1976 // Check to see if it is worth the effort.
1977 if (!Abbreviations.empty()) {
1978 // Start the debug abbrev section.
1979 Asm->OutStreamer.SwitchSection(Section);
1981 // For each abbrevation.
1982 for (const DIEAbbrev *Abbrev : Abbreviations) {
1983 // Emit the abbrevations code (base 1 index.)
1984 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1986 // Emit the abbreviations data.
1990 // Mark end of abbreviations.
1991 Asm->EmitULEB128(0, "EOM(3)");
1995 // Emit the last address of the section and the end of the line matrix.
1996 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1997 // Define last address of section.
1998 Asm->OutStreamer.AddComment("Extended Op");
2001 Asm->OutStreamer.AddComment("Op size");
2002 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2003 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2004 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2006 Asm->OutStreamer.AddComment("Section end label");
2008 Asm->OutStreamer.EmitSymbolValue(
2009 Asm->GetTempSymbol("section_end", SectionEnd),
2010 Asm->getDataLayout().getPointerSize());
2012 // Mark end of matrix.
2013 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2019 // Emit visible names into a hashed accelerator table section.
2020 void DwarfDebug::emitAccelNames() {
2022 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2023 for (DwarfUnit *TheU : getUnits()) {
2024 for (const auto &GI : TheU->getAccelNames()) {
2025 StringRef Name = GI.getKey();
2026 for (const DIE *D : GI.second)
2027 AT.AddName(Name, D);
2031 AT.FinalizeTable(Asm, "Names");
2032 Asm->OutStreamer.SwitchSection(
2033 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2034 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2035 Asm->OutStreamer.EmitLabel(SectionBegin);
2037 // Emit the full data.
2038 AT.Emit(Asm, SectionBegin, &InfoHolder);
2041 // Emit objective C classes and categories into a hashed accelerator table
2043 void DwarfDebug::emitAccelObjC() {
2045 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2046 for (DwarfUnit *TheU : getUnits()) {
2047 for (const auto &GI : TheU->getAccelObjC()) {
2048 StringRef Name = GI.getKey();
2049 for (const DIE *D : GI.second)
2050 AT.AddName(Name, D);
2054 AT.FinalizeTable(Asm, "ObjC");
2055 Asm->OutStreamer.SwitchSection(
2056 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2057 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2058 Asm->OutStreamer.EmitLabel(SectionBegin);
2060 // Emit the full data.
2061 AT.Emit(Asm, SectionBegin, &InfoHolder);
2064 // Emit namespace dies into a hashed accelerator table.
2065 void DwarfDebug::emitAccelNamespaces() {
2067 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2068 for (DwarfUnit *TheU : getUnits()) {
2069 for (const auto &GI : TheU->getAccelNamespace()) {
2070 StringRef Name = GI.getKey();
2071 for (const DIE *D : GI.second)
2072 AT.AddName(Name, D);
2076 AT.FinalizeTable(Asm, "namespac");
2077 Asm->OutStreamer.SwitchSection(
2078 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2079 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2080 Asm->OutStreamer.EmitLabel(SectionBegin);
2082 // Emit the full data.
2083 AT.Emit(Asm, SectionBegin, &InfoHolder);
2086 // Emit type dies into a hashed accelerator table.
2087 void DwarfDebug::emitAccelTypes() {
2088 std::vector<DwarfAccelTable::Atom> Atoms;
2090 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2092 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2094 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2095 DwarfAccelTable AT(Atoms);
2096 for (DwarfUnit *TheU : getUnits()) {
2097 for (const auto &GI : TheU->getAccelTypes()) {
2098 StringRef Name = GI.getKey();
2099 for (const auto &DI : GI.second)
2100 AT.AddName(Name, DI.first, DI.second);
2104 AT.FinalizeTable(Asm, "types");
2105 Asm->OutStreamer.SwitchSection(
2106 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2107 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2108 Asm->OutStreamer.EmitLabel(SectionBegin);
2110 // Emit the full data.
2111 AT.Emit(Asm, SectionBegin, &InfoHolder);
2114 // Public name handling.
2115 // The format for the various pubnames:
2117 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2118 // for the DIE that is named.
2120 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2121 // into the CU and the index value is computed according to the type of value
2122 // for the DIE that is named.
2124 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2125 // it's the offset within the debug_info/debug_types dwo section, however, the
2126 // reference in the pubname header doesn't change.
2128 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2129 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2131 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2133 // We could have a specification DIE that has our most of our knowledge,
2134 // look for that now.
2135 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2137 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2138 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2139 Linkage = dwarf::GIEL_EXTERNAL;
2140 } else if (Die->findAttribute(dwarf::DW_AT_external))
2141 Linkage = dwarf::GIEL_EXTERNAL;
2143 switch (Die->getTag()) {
2144 case dwarf::DW_TAG_class_type:
2145 case dwarf::DW_TAG_structure_type:
2146 case dwarf::DW_TAG_union_type:
2147 case dwarf::DW_TAG_enumeration_type:
2148 return dwarf::PubIndexEntryDescriptor(
2149 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2150 ? dwarf::GIEL_STATIC
2151 : dwarf::GIEL_EXTERNAL);
2152 case dwarf::DW_TAG_typedef:
2153 case dwarf::DW_TAG_base_type:
2154 case dwarf::DW_TAG_subrange_type:
2155 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2156 case dwarf::DW_TAG_namespace:
2157 return dwarf::GIEK_TYPE;
2158 case dwarf::DW_TAG_subprogram:
2159 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2160 case dwarf::DW_TAG_constant:
2161 case dwarf::DW_TAG_variable:
2162 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2163 case dwarf::DW_TAG_enumerator:
2164 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2165 dwarf::GIEL_STATIC);
2167 return dwarf::GIEK_NONE;
2171 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2173 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2174 const MCSection *PSec =
2175 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2176 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2178 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2181 void DwarfDebug::emitDebugPubSection(
2182 bool GnuStyle, const MCSection *PSec, StringRef Name,
2183 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
2184 for (const auto &NU : CUMap) {
2185 DwarfCompileUnit *TheU = NU.second;
2187 const auto &Globals = (TheU->*Accessor)();
2189 if (Globals.empty())
2192 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2194 unsigned ID = TheU->getUniqueID();
2196 // Start the dwarf pubnames section.
2197 Asm->OutStreamer.SwitchSection(PSec);
2200 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2201 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2202 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2203 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2205 Asm->OutStreamer.EmitLabel(BeginLabel);
2207 Asm->OutStreamer.AddComment("DWARF Version");
2208 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2210 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2211 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2213 Asm->OutStreamer.AddComment("Compilation Unit Length");
2214 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2216 // Emit the pubnames for this compilation unit.
2217 for (const auto &GI : Globals) {
2218 const char *Name = GI.getKeyData();
2219 const DIE *Entity = GI.second;
2221 Asm->OutStreamer.AddComment("DIE offset");
2222 Asm->EmitInt32(Entity->getOffset());
2225 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2226 Asm->OutStreamer.AddComment(
2227 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2228 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2229 Asm->EmitInt8(Desc.toBits());
2232 Asm->OutStreamer.AddComment("External Name");
2233 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2236 Asm->OutStreamer.AddComment("End Mark");
2238 Asm->OutStreamer.EmitLabel(EndLabel);
2242 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2243 const MCSection *PSec =
2244 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2245 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2247 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2250 // Emit strings into a string section.
2251 void DwarfFile::emitStrings(const MCSection *StrSection,
2252 const MCSection *OffsetSection = NULL,
2253 const MCSymbol *StrSecSym = NULL) {
2255 if (StringPool.empty())
2258 // Start the dwarf str section.
2259 Asm->OutStreamer.SwitchSection(StrSection);
2261 // Get all of the string pool entries and put them in an array by their ID so
2262 // we can sort them.
2263 SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
2265 for (const auto &I : StringPool)
2266 Entries.push_back(std::make_pair(I.second.second, &I));
2268 array_pod_sort(Entries.begin(), Entries.end());
2270 for (const auto &Entry : Entries) {
2271 // Emit a label for reference from debug information entries.
2272 Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
2274 // Emit the string itself with a terminating null byte.
2275 Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
2276 Entry.second->getKeyLength() + 1));
2279 // If we've got an offset section go ahead and emit that now as well.
2280 if (OffsetSection) {
2281 Asm->OutStreamer.SwitchSection(OffsetSection);
2282 unsigned offset = 0;
2283 unsigned size = 4; // FIXME: DWARF64 is 8.
2284 for (const auto &Entry : Entries) {
2285 Asm->OutStreamer.EmitIntValue(offset, size);
2286 offset += Entry.second->getKeyLength() + 1;
2291 // Emit addresses into the section given.
2292 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2294 if (AddressPool.empty())
2297 // Start the dwarf addr section.
2298 Asm->OutStreamer.SwitchSection(AddrSection);
2300 // Order the address pool entries by ID
2301 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2303 for (const auto &I : AddressPool)
2304 Entries[I.second.Number] =
2306 ? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
2307 : MCSymbolRefExpr::Create(I.first, Asm->OutContext);
2309 for (const MCExpr *Entry : Entries)
2310 Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
2313 // Emit visible names into a debug str section.
2314 void DwarfDebug::emitDebugStr() {
2315 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2316 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2319 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2320 const DebugLocEntry &Entry) {
2321 DIVariable DV(Entry.getVariable());
2322 if (Entry.isInt()) {
2323 DIBasicType BTy(resolve(DV.getType()));
2324 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2325 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2326 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2327 Streamer.EmitSLEB128(Entry.getInt());
2329 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2330 Streamer.EmitULEB128(Entry.getInt());
2332 } else if (Entry.isLocation()) {
2333 MachineLocation Loc = Entry.getLoc();
2334 if (!DV.hasComplexAddress())
2336 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2338 // Complex address entry.
2339 unsigned N = DV.getNumAddrElements();
2341 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2342 if (Loc.getOffset()) {
2344 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2345 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2346 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2347 Streamer.EmitSLEB128(DV.getAddrElement(1));
2349 // If first address element is OpPlus then emit
2350 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2351 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2352 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2356 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2359 // Emit remaining complex address elements.
2360 for (; i < N; ++i) {
2361 uint64_t Element = DV.getAddrElement(i);
2362 if (Element == DIBuilder::OpPlus) {
2363 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2364 Streamer.EmitULEB128(DV.getAddrElement(++i));
2365 } else if (Element == DIBuilder::OpDeref) {
2367 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2369 llvm_unreachable("unknown Opcode found in complex address");
2373 // else ... ignore constant fp. There is not any good way to
2374 // to represent them here in dwarf.
2378 // Emit locations into the debug loc section.
2379 void DwarfDebug::emitDebugLoc() {
2380 if (DotDebugLocEntries.empty())
2383 // Start the dwarf loc section.
2384 Asm->OutStreamer.SwitchSection(
2385 Asm->getObjFileLowering().getDwarfLocSection());
2386 unsigned char Size = Asm->getDataLayout().getPointerSize();
2388 for (const auto &DebugLoc : DotDebugLocEntries) {
2389 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2390 for (const auto &Entry : DebugLoc) {
2391 // Set up the range. This range is relative to the entry point of the
2392 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2393 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2394 const DwarfCompileUnit *CU = Entry.getCU();
2395 if (CU->getRanges().size() == 1) {
2396 // Grab the begin symbol from the first range as our base.
2397 const MCSymbol *Base = CU->getRanges()[0].getStart();
2398 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2399 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2401 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2402 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2404 Asm->OutStreamer.AddComment("Loc expr size");
2405 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2406 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2407 Asm->EmitLabelDifference(end, begin, 2);
2408 Asm->OutStreamer.EmitLabel(begin);
2410 APByteStreamer Streamer(*Asm);
2411 emitDebugLocEntry(Streamer, Entry);
2413 Asm->OutStreamer.EmitLabel(end);
2415 Asm->OutStreamer.EmitIntValue(0, Size);
2416 Asm->OutStreamer.EmitIntValue(0, Size);
2422 const MCSymbol *Start, *End;
2425 // Emit a debug aranges section, containing a CU lookup for any
2426 // address we can tie back to a CU.
2427 void DwarfDebug::emitDebugARanges() {
2428 // Start the dwarf aranges section.
2429 Asm->OutStreamer.SwitchSection(
2430 Asm->getObjFileLowering().getDwarfARangesSection());
2432 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2436 // Build a list of sections used.
2437 std::vector<const MCSection *> Sections;
2438 for (const auto &it : SectionMap) {
2439 const MCSection *Section = it.first;
2440 Sections.push_back(Section);
2443 // Sort the sections into order.
2444 // This is only done to ensure consistent output order across different runs.
2445 std::sort(Sections.begin(), Sections.end(), SectionSort);
2447 // Build a set of address spans, sorted by CU.
2448 for (const MCSection *Section : Sections) {
2449 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2450 if (List.size() < 2)
2453 // Sort the symbols by offset within the section.
2454 std::sort(List.begin(), List.end(),
2455 [&](const SymbolCU &A, const SymbolCU &B) {
2456 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2457 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2459 // Symbols with no order assigned should be placed at the end.
2460 // (e.g. section end labels)
2468 // If we have no section (e.g. common), just write out
2469 // individual spans for each symbol.
2470 if (Section == NULL) {
2471 for (const SymbolCU &Cur : List) {
2473 Span.Start = Cur.Sym;
2476 Spans[Cur.CU].push_back(Span);
2479 // Build spans between each label.
2480 const MCSymbol *StartSym = List[0].Sym;
2481 for (size_t n = 1, e = List.size(); n < e; n++) {
2482 const SymbolCU &Prev = List[n - 1];
2483 const SymbolCU &Cur = List[n];
2485 // Try and build the longest span we can within the same CU.
2486 if (Cur.CU != Prev.CU) {
2488 Span.Start = StartSym;
2490 Spans[Prev.CU].push_back(Span);
2497 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2499 // Build a list of CUs used.
2500 std::vector<DwarfCompileUnit *> CUs;
2501 for (const auto &it : Spans) {
2502 DwarfCompileUnit *CU = it.first;
2506 // Sort the CU list (again, to ensure consistent output order).
2507 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2508 return A->getUniqueID() < B->getUniqueID();
2511 // Emit an arange table for each CU we used.
2512 for (DwarfCompileUnit *CU : CUs) {
2513 std::vector<ArangeSpan> &List = Spans[CU];
2515 // Emit size of content not including length itself.
2516 unsigned ContentSize =
2517 sizeof(int16_t) + // DWARF ARange version number
2518 sizeof(int32_t) + // Offset of CU in the .debug_info section
2519 sizeof(int8_t) + // Pointer Size (in bytes)
2520 sizeof(int8_t); // Segment Size (in bytes)
2522 unsigned TupleSize = PtrSize * 2;
2524 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2526 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2528 ContentSize += Padding;
2529 ContentSize += (List.size() + 1) * TupleSize;
2531 // For each compile unit, write the list of spans it covers.
2532 Asm->OutStreamer.AddComment("Length of ARange Set");
2533 Asm->EmitInt32(ContentSize);
2534 Asm->OutStreamer.AddComment("DWARF Arange version number");
2535 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2536 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2537 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2538 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2539 Asm->EmitInt8(PtrSize);
2540 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2543 Asm->OutStreamer.EmitFill(Padding, 0xff);
2545 for (const ArangeSpan &Span : List) {
2546 Asm->EmitLabelReference(Span.Start, PtrSize);
2548 // Calculate the size as being from the span start to it's end.
2550 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2552 // For symbols without an end marker (e.g. common), we
2553 // write a single arange entry containing just that one symbol.
2554 uint64_t Size = SymSize[Span.Start];
2558 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2562 Asm->OutStreamer.AddComment("ARange terminator");
2563 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2564 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2568 // Emit visible names into a debug ranges section.
2569 void DwarfDebug::emitDebugRanges() {
2570 // Start the dwarf ranges section.
2571 Asm->OutStreamer.SwitchSection(
2572 Asm->getObjFileLowering().getDwarfRangesSection());
2574 // Size for our labels.
2575 unsigned char Size = Asm->getDataLayout().getPointerSize();
2577 // Grab the specific ranges for the compile units in the module.
2578 for (const auto &I : CUMap) {
2579 DwarfCompileUnit *TheCU = I.second;
2581 // Emit a symbol so we can find the beginning of our ranges.
2582 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2584 // Iterate over the misc ranges for the compile units in the module.
2585 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2586 // Emit our symbol so we can find the beginning of the range.
2587 Asm->OutStreamer.EmitLabel(List.getSym());
2589 for (const RangeSpan &Range : List.getRanges()) {
2590 const MCSymbol *Begin = Range.getStart();
2591 const MCSymbol *End = Range.getEnd();
2592 assert(Begin && "Range without a begin symbol?");
2593 assert(End && "Range without an end symbol?");
2594 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2595 Asm->OutStreamer.EmitSymbolValue(End, Size);
2598 // And terminate the list with two 0 values.
2599 Asm->OutStreamer.EmitIntValue(0, Size);
2600 Asm->OutStreamer.EmitIntValue(0, Size);
2603 // Now emit a range for the CU itself.
2604 if (TheCU->getRanges().size() > 1) {
2605 Asm->OutStreamer.EmitLabel(
2606 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2607 for (const RangeSpan &Range : TheCU->getRanges()) {
2608 const MCSymbol *Begin = Range.getStart();
2609 const MCSymbol *End = Range.getEnd();
2610 assert(Begin && "Range without a begin symbol?");
2611 assert(End && "Range without an end symbol?");
2612 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2613 Asm->OutStreamer.EmitSymbolValue(End, Size);
2615 // And terminate the list with two 0 values.
2616 Asm->OutStreamer.EmitIntValue(0, Size);
2617 Asm->OutStreamer.EmitIntValue(0, Size);
2622 // DWARF5 Experimental Separate Dwarf emitters.
2624 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2626 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2627 U->getCUNode().getSplitDebugFilename());
2629 if (!CompilationDir.empty())
2630 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2632 addGnuPubAttributes(NewU, Die);
2634 SkeletonHolder.addUnit(NewU);
2637 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2638 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2639 // DW_AT_addr_base, DW_AT_ranges_base.
2640 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2642 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2643 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2644 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2645 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2646 DwarfInfoSectionSym);
2648 NewCU->initStmtList(DwarfLineSectionSym);
2650 initSkeletonUnit(CU, Die, NewCU);
2652 // Relocate to the beginning of the addr_base section, else 0 for the
2653 // beginning of the one for this compile unit.
2654 // We could shave off some space if we deferred adding these attributes until
2655 // the end of the CU to see if we have a non-empty debug_addr and debug_ranges
2656 // sections so we don't bother with extra attributes and relocations.
2657 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2658 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2659 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_ranges_base, DwarfDebugRangeSectionSym);
2661 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2662 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_ranges_base, 0);
2668 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2670 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
2671 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2672 *SkeletonHolder.getUnits()[TU->getCU().getUniqueID()]);
2674 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2675 DwarfTypeUnit *NewTU =
2676 new DwarfTypeUnit(TU->getUniqueID(), Die, CU, Asm, this, &SkeletonHolder);
2677 NewTU->setTypeSignature(TU->getTypeSignature());
2678 NewTU->setType(NULL);
2680 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2682 initSkeletonUnit(TU, Die, NewTU);
2686 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2687 // compile units that would normally be in debug_info.
2688 void DwarfDebug::emitDebugInfoDWO() {
2689 assert(useSplitDwarf() && "No split dwarf debug info?");
2690 InfoHolder.emitUnits(this, nullptr);
2693 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2694 // abbreviations for the .debug_info.dwo section.
2695 void DwarfDebug::emitDebugAbbrevDWO() {
2696 assert(useSplitDwarf() && "No split dwarf?");
2697 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2700 void DwarfDebug::emitDebugLineDWO() {
2701 assert(useSplitDwarf() && "No split dwarf?");
2702 Asm->OutStreamer.SwitchSection(
2703 Asm->getObjFileLowering().getDwarfLineDWOSection());
2704 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2707 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2708 // string section and is identical in format to traditional .debug_str
2710 void DwarfDebug::emitDebugStrDWO() {
2711 assert(useSplitDwarf() && "No split dwarf?");
2712 const MCSection *OffSec =
2713 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2714 const MCSymbol *StrSym = DwarfStrSectionSym;
2715 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2719 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2720 if (!useSplitDwarf())
2723 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2724 return &SplitTypeUnitFileTable;
2727 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2728 StringRef Identifier, DIE *RefDie,
2729 DICompositeType CTy) {
2730 // Flag the type unit reference as a declaration so that if it contains
2731 // members (implicit special members, static data member definitions, member
2732 // declarations for definitions in this CU, etc) consumers don't get confused
2733 // and think this is a full definition.
2734 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2736 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2738 CU.addDIETypeSignature(RefDie, *TU);
2742 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2743 DwarfTypeUnit *NewTU =
2744 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, CU, Asm, this,
2745 &InfoHolder, getDwoLineTable(CU));
2747 InfoHolder.addUnit(NewTU);
2749 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2753 Hash.update(Identifier);
2754 // ... take the least significant 8 bytes and return those. Our MD5
2755 // implementation always returns its results in little endian, swap bytes
2757 MD5::MD5Result Result;
2759 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2760 NewTU->setTypeSignature(Signature);
2761 if (useSplitDwarf())
2762 NewTU->setSkeleton(constructSkeletonTU(NewTU));
2764 CU.applyStmtList(*UnitDie);
2766 NewTU->setType(NewTU->createTypeDIE(CTy));
2770 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2771 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2773 CU.addDIETypeSignature(RefDie, *NewTU);
2776 void DwarfDebug::attachLowHighPC(DwarfCompileUnit *Unit, DIE *D,
2777 MCSymbol *Begin, MCSymbol *End) {
2778 Unit->addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2779 if (DwarfVersion < 4)
2780 Unit->addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2782 Unit->addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);