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), HasCURanges(false),
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 SP = SPCU->getOdrUniqueSubprogram(resolve(SP.getContext()), SP);
373 DIE *SPDie = SPCU->getDIE(SP);
375 assert(SPDie && "Unable to find subprogram DIE!");
377 // If we're updating an abstract DIE, then we will be adding the children and
378 // object pointer later on. But what we don't want to do is process the
379 // concrete DIE twice.
380 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
381 // Pick up abstract subprogram DIE.
383 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
384 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
386 DISubprogram SPDecl = SP.getFunctionDeclaration();
387 if (!SPDecl.isSubprogram()) {
388 // There is not any need to generate specification DIE for a function
389 // defined at compile unit level. If a function is defined inside another
390 // function then gdb prefers the definition at top level and but does not
391 // expect specification DIE in parent function. So avoid creating
392 // specification DIE for a function defined inside a function.
393 DIScope SPContext = resolve(SP.getContext());
394 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
395 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
396 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
399 DICompositeType SPTy = SP.getType();
400 DIArray Args = SPTy.getTypeArray();
401 uint16_t SPTag = SPTy.getTag();
402 if (SPTag == dwarf::DW_TAG_subroutine_type)
403 SPCU->constructSubprogramArguments(*SPDie, Args);
404 DIE *SPDeclDie = SPDie;
405 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
406 *SPCU->getUnitDie());
407 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
412 attachLowHighPC(SPCU, SPDie, FunctionBeginSym, FunctionEndSym);
414 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
415 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
416 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
418 // Add name to the name table, we do this here because we're guaranteed
419 // to have concrete versions of our DW_TAG_subprogram nodes.
420 addSubprogramNames(SPCU, SP, SPDie);
425 /// Check whether we should create a DIE for the given Scope, return true
426 /// if we don't create a DIE (the corresponding DIE is null).
427 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
428 if (Scope->isAbstractScope())
431 // We don't create a DIE if there is no Range.
432 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
436 if (Ranges.size() > 1)
439 // We don't create a DIE if we have a single Range and the end label
441 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
442 MCSymbol *End = getLabelAfterInsn(RI->second);
446 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
447 dwarf::Attribute A, const MCSymbol *L,
448 const MCSymbol *Sec) {
449 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
450 U->addSectionLabel(D, A, L);
452 U->addSectionDelta(D, A, L, Sec);
455 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
456 const SmallVectorImpl<InsnRange> &Range) {
457 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
458 // emitting it appropriately.
459 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
460 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
461 DwarfDebugRangeSectionSym);
463 RangeSpanList List(RangeSym);
464 for (const InsnRange &R : Range) {
465 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
466 List.addRange(std::move(Span));
469 // Add the range list to the set of ranges to be emitted.
470 TheCU->addRangeList(std::move(List));
473 // Construct new DW_TAG_lexical_block for this scope and attach
474 // DW_AT_low_pc/DW_AT_high_pc labels.
475 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
476 LexicalScope *Scope) {
477 if (isLexicalScopeDIENull(Scope))
480 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
481 if (Scope->isAbstractScope())
484 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
486 // If we have multiple ranges, emit them into the range section.
487 if (ScopeRanges.size() > 1) {
488 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
492 // Construct the address range for this DIE.
493 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
494 MCSymbol *Start = getLabelBeforeInsn(RI->first);
495 MCSymbol *End = getLabelAfterInsn(RI->second);
496 assert(End && "End label should not be null!");
498 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
499 assert(End->isDefined() && "Invalid end label for an inlined scope!");
501 attachLowHighPC(TheCU, ScopeDIE, Start, End);
506 // This scope represents inlined body of a function. Construct DIE to
507 // represent this concrete inlined copy of the function.
508 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
509 LexicalScope *Scope) {
510 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
511 assert(!ScopeRanges.empty() &&
512 "LexicalScope does not have instruction markers!");
514 if (!Scope->getScopeNode())
516 DIScope DS(Scope->getScopeNode());
517 DISubprogram InlinedSP = getDISubprogram(DS);
518 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
520 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
524 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
525 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
527 // If we have multiple ranges, emit them into the range section.
528 if (ScopeRanges.size() > 1)
529 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
531 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
532 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
533 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
535 if (StartLabel == 0 || EndLabel == 0)
536 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
538 assert(StartLabel->isDefined() &&
539 "Invalid starting label for an inlined scope!");
540 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
542 attachLowHighPC(TheCU, ScopeDIE, StartLabel, EndLabel);
545 InlinedSubprogramDIEs.insert(OriginDIE);
547 // Add the call site information to the DIE.
548 DILocation DL(Scope->getInlinedAt());
550 ScopeDIE, dwarf::DW_AT_call_file, None,
551 TheCU->getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
552 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
554 // Add name to the name table, we do this here because we're guaranteed
555 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
556 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
561 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
563 SmallVectorImpl<DIE *> &Children) {
564 DIE *ObjectPointer = NULL;
566 // Collect arguments for current function.
567 if (LScopes.isCurrentFunctionScope(Scope)) {
568 for (DbgVariable *ArgDV : CurrentFnArguments)
571 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
572 Children.push_back(Arg);
573 if (ArgDV->isObjectPointer())
577 // If this is a variadic function, add an unspecified parameter.
578 DISubprogram SP(Scope->getScopeNode());
579 DIArray FnArgs = SP.getType().getTypeArray();
580 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
581 .isUnspecifiedParameter()) {
582 DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
583 Children.push_back(Ellipsis);
587 // Collect lexical scope children first.
588 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
589 if (DIE *Variable = TheCU->constructVariableDIE(*DV,
590 Scope->isAbstractScope())) {
591 Children.push_back(Variable);
592 if (DV->isObjectPointer())
593 ObjectPointer = Variable;
595 for (LexicalScope *LS : Scope->getChildren())
596 if (DIE *Nested = constructScopeDIE(TheCU, LS))
597 Children.push_back(Nested);
598 return ObjectPointer;
601 // Construct a DIE for this scope.
602 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
603 LexicalScope *Scope) {
604 if (!Scope || !Scope->getScopeNode())
607 DIScope DS(Scope->getScopeNode());
609 SmallVector<DIE *, 8> Children;
610 DIE *ObjectPointer = NULL;
611 bool ChildrenCreated = false;
613 // We try to create the scope DIE first, then the children DIEs. This will
614 // avoid creating un-used children then removing them later when we find out
615 // the scope DIE is null.
616 DIE *ScopeDIE = NULL;
617 if (Scope->getInlinedAt())
618 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
619 else if (DS.isSubprogram()) {
620 ProcessedSPNodes.insert(DS);
621 if (Scope->isAbstractScope()) {
622 ScopeDIE = TheCU->getDIE(DS);
623 // Note down abstract DIE.
625 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
627 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
629 // Early exit when we know the scope DIE is going to be null.
630 if (isLexicalScopeDIENull(Scope))
633 // We create children here when we know the scope DIE is not going to be
634 // null and the children will be added to the scope DIE.
635 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
636 ChildrenCreated = true;
638 // There is no need to emit empty lexical block DIE.
639 std::pair<ImportedEntityMap::const_iterator,
640 ImportedEntityMap::const_iterator> Range =
642 ScopesWithImportedEntities.begin(),
643 ScopesWithImportedEntities.end(),
644 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
646 if (Children.empty() && Range.first == Range.second)
648 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
649 assert(ScopeDIE && "Scope DIE should not be null.");
650 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
652 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
656 assert(Children.empty() &&
657 "We create children only when the scope DIE is not null.");
660 if (!ChildrenCreated)
661 // We create children when the scope DIE is not null.
662 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
665 for (DIE *I : Children)
666 ScopeDIE->addChild(I);
668 if (DS.isSubprogram() && ObjectPointer != NULL)
669 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
674 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
675 if (!GenerateGnuPubSections)
678 U->addFlag(D, dwarf::DW_AT_GNU_pubnames);
681 // Create new DwarfCompileUnit for the given metadata node with tag
682 // DW_TAG_compile_unit.
683 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit,
685 StringRef FN = DIUnit.getFilename();
686 CompilationDir = DIUnit.getDirectory();
688 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
689 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
690 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
691 InfoHolder.addUnit(NewCU);
692 if (!Asm->OutStreamer.hasRawTextSupport() || Singular)
693 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
694 NewCU->getUniqueID(), CompilationDir);
696 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
697 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
698 DIUnit.getLanguage());
699 NewCU->addString(Die, dwarf::DW_AT_name, FN);
701 if (!useSplitDwarf()) {
702 NewCU->initStmtList(DwarfLineSectionSym);
704 // If we're using split dwarf the compilation dir is going to be in the
705 // skeleton CU and so we don't need to duplicate it here.
706 if (!CompilationDir.empty())
707 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
709 addGnuPubAttributes(NewCU, Die);
712 if (DIUnit.isOptimized())
713 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
715 StringRef Flags = DIUnit.getFlags();
717 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
719 if (unsigned RVer = DIUnit.getRunTimeVersion())
720 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
721 dwarf::DW_FORM_data1, RVer);
726 if (useSplitDwarf()) {
727 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
728 DwarfInfoDWOSectionSym);
729 NewCU->setSkeleton(constructSkeletonCU(NewCU));
731 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
732 DwarfInfoSectionSym);
734 CUMap.insert(std::make_pair(DIUnit, NewCU));
735 CUDieMap.insert(std::make_pair(Die, NewCU));
739 // Construct subprogram DIE.
740 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
742 // FIXME: We should only call this routine once, however, during LTO if a
743 // program is defined in multiple CUs we could end up calling it out of
744 // beginModule as we walk the CUs.
746 DwarfCompileUnit *&CURef = SPMap[N];
752 if (!SP.isDefinition())
753 // This is a method declaration which will be handled while constructing
757 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
759 // Expose as a global name.
760 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
763 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
765 DIImportedEntity Module(N);
766 assert(Module.Verify());
767 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
768 constructImportedEntityDIE(TheCU, Module, D);
771 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
772 const MDNode *N, DIE *Context) {
773 DIImportedEntity Module(N);
774 assert(Module.Verify());
775 return constructImportedEntityDIE(TheCU, Module, Context);
778 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
779 const DIImportedEntity &Module,
781 assert(Module.Verify() &&
782 "Use one of the MDNode * overloads to handle invalid metadata");
783 assert(Context && "Should always have a context for an imported_module");
784 DIE *IMDie = new DIE(Module.getTag());
785 TheCU->insertDIE(Module, IMDie);
787 DIDescriptor Entity = Module.getEntity();
788 if (Entity.isNameSpace())
789 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
790 else if (Entity.isSubprogram())
791 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
792 else if (Entity.isType())
793 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
795 EntityDie = TheCU->getDIE(Entity);
796 TheCU->addSourceLine(IMDie, Module.getLineNumber(),
797 Module.getContext().getFilename(),
798 Module.getContext().getDirectory());
799 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
800 StringRef Name = Module.getName();
802 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
803 Context->addChild(IMDie);
806 // Emit all Dwarf sections that should come prior to the content. Create
807 // global DIEs and emit initial debug info sections. This is invoked by
808 // the target AsmPrinter.
809 void DwarfDebug::beginModule() {
810 if (DisableDebugInfoPrinting)
813 const Module *M = MMI->getModule();
815 // If module has named metadata anchors then use them, otherwise scan the
816 // module using debug info finder to collect debug info.
817 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
820 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
822 // Emit initial sections so we can reference labels later.
825 auto Operands = CU_Nodes->operands();
827 bool SingleCU = std::next(Operands.begin()) == Operands.end();
829 for (MDNode *N : Operands) {
830 DICompileUnit CUNode(N);
831 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode, SingleCU);
832 DIArray ImportedEntities = CUNode.getImportedEntities();
833 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
834 ScopesWithImportedEntities.push_back(std::make_pair(
835 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
836 ImportedEntities.getElement(i)));
837 std::sort(ScopesWithImportedEntities.begin(),
838 ScopesWithImportedEntities.end(), less_first());
839 DIArray GVs = CUNode.getGlobalVariables();
840 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
841 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
842 DIArray SPs = CUNode.getSubprograms();
843 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
844 constructSubprogramDIE(CU, SPs.getElement(i));
845 DIArray EnumTypes = CUNode.getEnumTypes();
846 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
847 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
848 DIArray RetainedTypes = CUNode.getRetainedTypes();
849 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
850 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
851 // Emit imported_modules last so that the relevant context is already
853 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
854 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
857 // Tell MMI that we have debug info.
858 MMI->setDebugInfoAvailability(true);
860 // Prime section data.
861 SectionMap[Asm->getObjFileLowering().getTextSection()];
864 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
865 void DwarfDebug::computeInlinedDIEs() {
866 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
867 for (DIE *ISP : InlinedSubprogramDIEs)
868 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
870 for (const auto &AI : AbstractSPDies) {
871 DIE *ISP = AI.second;
872 if (InlinedSubprogramDIEs.count(ISP))
874 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
878 // Collect info for variables that were optimized out.
879 void DwarfDebug::collectDeadVariables() {
880 const Module *M = MMI->getModule();
882 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
883 for (MDNode *N : CU_Nodes->operands()) {
884 DICompileUnit TheCU(N);
885 DIArray Subprograms = TheCU.getSubprograms();
886 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
887 DISubprogram SP(Subprograms.getElement(i));
888 if (ProcessedSPNodes.count(SP) != 0)
890 if (!SP.isSubprogram())
892 if (!SP.isDefinition())
894 DIArray Variables = SP.getVariables();
895 if (Variables.getNumElements() == 0)
898 // Construct subprogram DIE and add variables DIEs.
899 DwarfCompileUnit *SPCU =
900 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
901 assert(SPCU && "Unable to find Compile Unit!");
902 // FIXME: See the comment in constructSubprogramDIE about duplicate
904 constructSubprogramDIE(SPCU, SP);
905 DIE *SPDIE = SPCU->getDIE(SP);
906 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
907 DIVariable DV(Variables.getElement(vi));
908 if (!DV.isVariable())
910 DbgVariable NewVar(DV, NULL, this);
911 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
912 SPDIE->addChild(VariableDIE);
919 void DwarfDebug::finalizeModuleInfo() {
920 // Collect info for variables that were optimized out.
921 collectDeadVariables();
923 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
924 computeInlinedDIEs();
926 // Handle anything that needs to be done on a per-unit basis after
927 // all other generation.
928 for (DwarfUnit *TheU : getUnits()) {
929 // Emit DW_AT_containing_type attribute to connect types with their
930 // vtable holding type.
931 TheU->constructContainingTypeDIEs();
933 // Add CU specific attributes if we need to add any.
934 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
935 // If we're splitting the dwarf out now that we've got the entire
936 // CU then add the dwo id to it.
937 DwarfCompileUnit *SkCU =
938 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
939 if (useSplitDwarf()) {
940 // Emit a unique identifier for this CU.
941 uint64_t ID = DIEHash(Asm).computeCUSignature(*TheU->getUnitDie());
942 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
943 dwarf::DW_FORM_data8, ID);
944 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
945 dwarf::DW_FORM_data8, ID);
948 // If we have code split among multiple sections or we've requested
949 // it then emit a DW_AT_ranges attribute on the unit that will remain
950 // in the .o file, otherwise add a DW_AT_low_pc.
951 // FIXME: Also add a high pc if we can.
952 // FIXME: We should use ranges if we have multiple compile units or
953 // allow reordering of code ala .subsections_via_symbols in mach-o.
954 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
955 if (useCURanges() && TheU->getRanges().size()) {
956 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
957 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
958 DwarfDebugRangeSectionSym);
960 // A DW_AT_low_pc attribute may also be specified in combination with
961 // DW_AT_ranges to specify the default base address for use in location
962 // lists (see Section 2.6.2) and range lists (see Section 2.17.3).
963 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
966 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
971 // Compute DIE offsets and sizes.
972 InfoHolder.computeSizeAndOffsets();
974 SkeletonHolder.computeSizeAndOffsets();
977 void DwarfDebug::endSections() {
978 // Filter labels by section.
979 for (const SymbolCU &SCU : ArangeLabels) {
980 if (SCU.Sym->isInSection()) {
981 // Make a note of this symbol and it's section.
982 const MCSection *Section = &SCU.Sym->getSection();
983 if (!Section->getKind().isMetadata())
984 SectionMap[Section].push_back(SCU);
986 // Some symbols (e.g. common/bss on mach-o) can have no section but still
987 // appear in the output. This sucks as we rely on sections to build
988 // arange spans. We can do it without, but it's icky.
989 SectionMap[NULL].push_back(SCU);
993 // Build a list of sections used.
994 std::vector<const MCSection *> Sections;
995 for (const auto &it : SectionMap) {
996 const MCSection *Section = it.first;
997 Sections.push_back(Section);
1000 // Sort the sections into order.
1001 // This is only done to ensure consistent output order across different runs.
1002 std::sort(Sections.begin(), Sections.end(), SectionSort);
1004 // Add terminating symbols for each section.
1005 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
1006 const MCSection *Section = Sections[ID];
1007 MCSymbol *Sym = NULL;
1010 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1011 // if we know the section name up-front. For user-created sections, the
1012 // resulting label may not be valid to use as a label. (section names can
1013 // use a greater set of characters on some systems)
1014 Sym = Asm->GetTempSymbol("debug_end", ID);
1015 Asm->OutStreamer.SwitchSection(Section);
1016 Asm->OutStreamer.EmitLabel(Sym);
1019 // Insert a final terminator.
1020 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1023 // For now only turn on CU ranges if we have -ffunction-sections enabled,
1024 // we've emitted a function into a unique section, or we're using LTO. If
1025 // we're using LTO then we can't know that any particular function in the
1026 // module is correlated to a particular CU and so we need to be conservative.
1027 // At this point all sections should be finalized except for dwarf sections.
1028 HasCURanges = UsedNonDefaultText || (CUMap.size() > 1) ||
1029 TargetMachine::getFunctionSections();
1032 // Emit all Dwarf sections that should come after the content.
1033 void DwarfDebug::endModule() {
1040 // End any existing sections.
1041 // TODO: Does this need to happen?
1044 // Finalize the debug info for the module.
1045 finalizeModuleInfo();
1049 // Emit all the DIEs into a debug info section.
1052 // Corresponding abbreviations into a abbrev section.
1053 emitAbbreviations();
1055 // Emit info into a debug loc section.
1058 // Emit info into a debug aranges section.
1059 if (GenerateARangeSection)
1062 // Emit info into a debug ranges section.
1065 if (useSplitDwarf()) {
1068 emitDebugAbbrevDWO();
1070 // Emit DWO addresses.
1071 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1074 // Emit info into the dwarf accelerator table sections.
1075 if (useDwarfAccelTables()) {
1078 emitAccelNamespaces();
1082 // Emit the pubnames and pubtypes sections if requested.
1083 if (HasDwarfPubSections) {
1084 emitDebugPubNames(GenerateGnuPubSections);
1085 emitDebugPubTypes(GenerateGnuPubSections);
1091 // Reset these for the next Module if we have one.
1095 // Find abstract variable, if any, associated with Var.
1096 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1097 DebugLoc ScopeLoc) {
1098 LLVMContext &Ctx = DV->getContext();
1099 // More then one inlined variable corresponds to one abstract variable.
1100 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1101 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1103 return AbsDbgVariable;
1105 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1109 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1110 addScopeVariable(Scope, AbsDbgVariable);
1111 AbstractVariables[Var] = AbsDbgVariable;
1112 return AbsDbgVariable;
1115 // If Var is a current function argument then add it to CurrentFnArguments list.
1116 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1117 if (!LScopes.isCurrentFunctionScope(Scope))
1119 DIVariable DV = Var->getVariable();
1120 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1122 unsigned ArgNo = DV.getArgNumber();
1126 size_t Size = CurrentFnArguments.size();
1128 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1129 // llvm::Function argument size is not good indicator of how many
1130 // arguments does the function have at source level.
1132 CurrentFnArguments.resize(ArgNo * 2);
1133 CurrentFnArguments[ArgNo - 1] = Var;
1137 // Collect variable information from side table maintained by MMI.
1138 void DwarfDebug::collectVariableInfoFromMMITable(
1139 SmallPtrSet<const MDNode *, 16> &Processed) {
1140 for (const auto &VI : MMI->getVariableDbgInfo()) {
1143 Processed.insert(VI.Var);
1144 DIVariable DV(VI.Var);
1145 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1147 // If variable scope is not found then skip this variable.
1151 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1152 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1153 RegVar->setFrameIndex(VI.Slot);
1154 if (!addCurrentFnArgument(RegVar, Scope))
1155 addScopeVariable(Scope, RegVar);
1157 AbsDbgVariable->setFrameIndex(VI.Slot);
1161 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1163 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1164 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1165 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1166 MI->getOperand(0).getReg() &&
1167 (MI->getOperand(1).isImm() ||
1168 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1171 // Get .debug_loc entry for the instruction range starting at MI.
1172 static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1173 const MCSymbol *FLabel,
1174 const MCSymbol *SLabel,
1175 const MachineInstr *MI) {
1176 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1178 assert(MI->getNumOperands() == 3);
1179 if (MI->getOperand(0).isReg()) {
1180 MachineLocation MLoc;
1181 // If the second operand is an immediate, this is a
1182 // register-indirect address.
1183 if (!MI->getOperand(1).isImm())
1184 MLoc.set(MI->getOperand(0).getReg());
1186 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1187 return DebugLocEntry(FLabel, SLabel, MLoc, Var);
1189 if (MI->getOperand(0).isImm())
1190 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1191 if (MI->getOperand(0).isFPImm())
1192 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1193 if (MI->getOperand(0).isCImm())
1194 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1196 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1199 // Find variables for each lexical scope.
1201 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1203 // Grab the variable info that was squirreled away in the MMI side-table.
1204 collectVariableInfoFromMMITable(Processed);
1206 for (const MDNode *Var : UserVariables) {
1207 if (Processed.count(Var))
1210 // History contains relevant DBG_VALUE instructions for Var and instructions
1212 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1213 if (History.empty())
1215 const MachineInstr *MInsn = History.front();
1218 LexicalScope *Scope = NULL;
1219 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1220 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1221 Scope = LScopes.getCurrentFunctionScope();
1222 else if (MDNode *IA = DV.getInlinedAt())
1223 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1225 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1226 // If variable scope is not found then skip this variable.
1230 Processed.insert(DV);
1231 assert(MInsn->isDebugValue() && "History must begin with debug value");
1232 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1233 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1234 if (!addCurrentFnArgument(RegVar, Scope))
1235 addScopeVariable(Scope, RegVar);
1237 AbsVar->setMInsn(MInsn);
1239 // Simplify ranges that are fully coalesced.
1240 if (History.size() <= 1 ||
1241 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1242 RegVar->setMInsn(MInsn);
1246 // Handle multiple DBG_VALUE instructions describing one variable.
1247 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1249 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1250 HI = History.begin(),
1253 const MachineInstr *Begin = *HI;
1254 assert(Begin->isDebugValue() && "Invalid History entry");
1256 // Check if DBG_VALUE is truncating a range.
1257 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1258 !Begin->getOperand(0).getReg())
1261 // Compute the range for a register location.
1262 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1263 const MCSymbol *SLabel = 0;
1266 // If Begin is the last instruction in History then its value is valid
1267 // until the end of the function.
1268 SLabel = FunctionEndSym;
1270 const MachineInstr *End = HI[1];
1271 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1272 << "\t" << *Begin << "\t" << *End << "\n");
1273 if (End->isDebugValue())
1274 SLabel = getLabelBeforeInsn(End);
1276 // End is a normal instruction clobbering the range.
1277 SLabel = getLabelAfterInsn(End);
1278 assert(SLabel && "Forgot label after clobber instruction");
1283 // The value is valid until the next DBG_VALUE or clobber.
1284 DotDebugLocEntries.push_back(
1285 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1287 DotDebugLocEntries.push_back(DebugLocEntry());
1290 // Collect info for variables that were optimized out.
1291 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1292 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1293 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1294 DIVariable DV(Variables.getElement(i));
1295 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1297 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1298 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1302 // Return Label preceding the instruction.
1303 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1304 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1305 assert(Label && "Didn't insert label before instruction");
1309 // Return Label immediately following the instruction.
1310 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1311 return LabelsAfterInsn.lookup(MI);
1314 // Process beginning of an instruction.
1315 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1318 // Check if source location changes, but ignore DBG_VALUE locations.
1319 if (!MI->isDebugValue()) {
1320 DebugLoc DL = MI->getDebugLoc();
1321 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1324 if (DL == PrologEndLoc) {
1325 Flags |= DWARF2_FLAG_PROLOGUE_END;
1326 PrologEndLoc = DebugLoc();
1328 if (PrologEndLoc.isUnknown())
1329 Flags |= DWARF2_FLAG_IS_STMT;
1331 if (!DL.isUnknown()) {
1332 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1333 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1335 recordSourceLine(0, 0, 0, 0);
1339 // Insert labels where requested.
1340 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1341 LabelsBeforeInsn.find(MI);
1344 if (I == LabelsBeforeInsn.end())
1347 // Label already assigned.
1352 PrevLabel = MMI->getContext().CreateTempSymbol();
1353 Asm->OutStreamer.EmitLabel(PrevLabel);
1355 I->second = PrevLabel;
1358 // Process end of an instruction.
1359 void DwarfDebug::endInstruction() {
1361 // Don't create a new label after DBG_VALUE instructions.
1362 // They don't generate code.
1363 if (!CurMI->isDebugValue())
1366 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1367 LabelsAfterInsn.find(CurMI);
1371 if (I == LabelsAfterInsn.end())
1374 // Label already assigned.
1378 // We need a label after this instruction.
1380 PrevLabel = MMI->getContext().CreateTempSymbol();
1381 Asm->OutStreamer.EmitLabel(PrevLabel);
1383 I->second = PrevLabel;
1386 // Each LexicalScope has first instruction and last instruction to mark
1387 // beginning and end of a scope respectively. Create an inverse map that list
1388 // scopes starts (and ends) with an instruction. One instruction may start (or
1389 // end) multiple scopes. Ignore scopes that are not reachable.
1390 void DwarfDebug::identifyScopeMarkers() {
1391 SmallVector<LexicalScope *, 4> WorkList;
1392 WorkList.push_back(LScopes.getCurrentFunctionScope());
1393 while (!WorkList.empty()) {
1394 LexicalScope *S = WorkList.pop_back_val();
1396 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1397 if (!Children.empty())
1398 WorkList.append(Children.begin(), Children.end());
1400 if (S->isAbstractScope())
1403 for (const InsnRange &R : S->getRanges()) {
1404 assert(R.first && "InsnRange does not have first instruction!");
1405 assert(R.second && "InsnRange does not have second instruction!");
1406 requestLabelBeforeInsn(R.first);
1407 requestLabelAfterInsn(R.second);
1412 // Gather pre-function debug information. Assumes being called immediately
1413 // after the function entry point has been emitted.
1414 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1417 // If there's no debug info for the function we're not going to do anything.
1418 if (!MMI->hasDebugInfo())
1421 // Grab the lexical scopes for the function, if we don't have any of those
1422 // then we're not going to be able to do anything.
1423 LScopes.initialize(*MF);
1424 if (LScopes.empty()) {
1425 // If we don't have a lexical scope for this function then there will
1426 // be a hole in the range information. Keep note of this.
1427 UsedNonDefaultText = true;
1431 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1433 // Make sure that each lexical scope will have a begin/end label.
1434 identifyScopeMarkers();
1436 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1437 // belongs to so that we add to the correct per-cu line table in the
1439 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1440 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1441 assert(TheCU && "Unable to find compile unit!");
1442 if (Asm->OutStreamer.hasRawTextSupport())
1443 // Use a single line table if we are generating assembly.
1444 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1446 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1448 // Check the current section against the standard text section. If different
1449 // keep track so that we will know when we're emitting functions into multiple
1451 if (Asm->getObjFileLowering().getTextSection() != Asm->getCurrentSection())
1452 UsedNonDefaultText = true;
1454 // Emit a label for the function so that we have a beginning address.
1455 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1456 // Assumes in correct section after the entry point.
1457 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1459 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1460 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1461 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1463 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1465 bool AtBlockEntry = true;
1466 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1468 const MachineInstr *MI = II;
1470 if (MI->isDebugValue()) {
1471 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1473 // Keep track of user variables.
1475 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1477 // Variable is in a register, we need to check for clobbers.
1478 if (isDbgValueInDefinedReg(MI))
1479 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1481 // Check the history of this variable.
1482 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1483 if (History.empty()) {
1484 UserVariables.push_back(Var);
1485 // The first mention of a function argument gets the FunctionBeginSym
1486 // label, so arguments are visible when breaking at function entry.
1488 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1489 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1490 LabelsBeforeInsn[MI] = FunctionBeginSym;
1492 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1493 const MachineInstr *Prev = History.back();
1494 if (Prev->isDebugValue()) {
1495 // Coalesce identical entries at the end of History.
1496 if (History.size() >= 2 &&
1497 Prev->isIdenticalTo(History[History.size() - 2])) {
1498 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1499 << "\t" << *Prev << "\t"
1500 << *History[History.size() - 2] << "\n");
1504 // Terminate old register assignments that don't reach MI;
1505 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1506 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1507 isDbgValueInDefinedReg(Prev)) {
1508 // Previous register assignment needs to terminate at the end of
1510 MachineBasicBlock::const_iterator LastMI =
1511 PrevMBB->getLastNonDebugInstr();
1512 if (LastMI == PrevMBB->end()) {
1513 // Drop DBG_VALUE for empty range.
1514 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1515 << "\t" << *Prev << "\n");
1517 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1518 // Terminate after LastMI.
1519 History.push_back(LastMI);
1523 History.push_back(MI);
1525 // Not a DBG_VALUE instruction.
1526 if (!MI->isPosition())
1527 AtBlockEntry = false;
1529 // First known non-DBG_VALUE and non-frame setup location marks
1530 // the beginning of the function body.
1531 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1532 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1533 PrologEndLoc = MI->getDebugLoc();
1535 // Check if the instruction clobbers any registers with debug vars.
1536 for (const MachineOperand &MO : MI->operands()) {
1537 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1539 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1542 const MDNode *Var = LiveUserVar[Reg];
1545 // Reg is now clobbered.
1546 LiveUserVar[Reg] = 0;
1548 // Was MD last defined by a DBG_VALUE referring to Reg?
1549 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1550 if (HistI == DbgValues.end())
1552 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1553 if (History.empty())
1555 const MachineInstr *Prev = History.back();
1556 // Sanity-check: Register assignments are terminated at the end of
1558 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1560 // Is the variable still in Reg?
1561 if (!isDbgValueInDefinedReg(Prev) ||
1562 Prev->getOperand(0).getReg() != Reg)
1564 // Var is clobbered. Make sure the next instruction gets a label.
1565 History.push_back(MI);
1572 for (auto &I : DbgValues) {
1573 SmallVectorImpl<const MachineInstr *> &History = I.second;
1574 if (History.empty())
1577 // Make sure the final register assignments are terminated.
1578 const MachineInstr *Prev = History.back();
1579 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1580 const MachineBasicBlock *PrevMBB = Prev->getParent();
1581 MachineBasicBlock::const_iterator LastMI =
1582 PrevMBB->getLastNonDebugInstr();
1583 if (LastMI == PrevMBB->end())
1584 // Drop DBG_VALUE for empty range.
1586 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1587 // Terminate after LastMI.
1588 History.push_back(LastMI);
1591 // Request labels for the full history.
1592 for (const MachineInstr *MI : History) {
1593 if (MI->isDebugValue())
1594 requestLabelBeforeInsn(MI);
1596 requestLabelAfterInsn(MI);
1600 PrevInstLoc = DebugLoc();
1601 PrevLabel = FunctionBeginSym;
1603 // Record beginning of function.
1604 if (!PrologEndLoc.isUnknown()) {
1605 DebugLoc FnStartDL =
1606 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1608 FnStartDL.getLine(), FnStartDL.getCol(),
1609 FnStartDL.getScope(MF->getFunction()->getContext()),
1610 // We'd like to list the prologue as "not statements" but GDB behaves
1611 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1612 DWARF2_FLAG_IS_STMT);
1616 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1617 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1618 DIVariable DV = Var->getVariable();
1619 // Variables with positive arg numbers are parameters.
1620 if (unsigned ArgNum = DV.getArgNumber()) {
1621 // Keep all parameters in order at the start of the variable list to ensure
1622 // function types are correct (no out-of-order parameters)
1624 // This could be improved by only doing it for optimized builds (unoptimized
1625 // builds have the right order to begin with), searching from the back (this
1626 // would catch the unoptimized case quickly), or doing a binary search
1627 // rather than linear search.
1628 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1629 while (I != Vars.end()) {
1630 unsigned CurNum = (*I)->getVariable().getArgNumber();
1631 // A local (non-parameter) variable has been found, insert immediately
1635 // A later indexed parameter has been found, insert immediately before it.
1636 if (CurNum > ArgNum)
1640 Vars.insert(I, Var);
1644 Vars.push_back(Var);
1647 // Gather and emit post-function debug information.
1648 void DwarfDebug::endFunction(const MachineFunction *MF) {
1649 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1650 // though the beginFunction may not be called at all.
1651 // We should handle both cases.
1655 assert(CurFn == MF);
1658 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1663 // Define end label for subprogram.
1664 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1665 // Assumes in correct section after the entry point.
1666 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1668 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1669 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1671 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1672 collectVariableInfo(ProcessedVars);
1674 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1675 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1676 assert(TheCU && "Unable to find compile unit!");
1678 // Construct abstract scopes.
1679 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1680 DISubprogram SP(AScope->getScopeNode());
1681 if (SP.isSubprogram()) {
1682 // Collect info for variables that were optimized out.
1683 DIArray Variables = SP.getVariables();
1684 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1685 DIVariable DV(Variables.getElement(i));
1686 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1688 // Check that DbgVariable for DV wasn't created earlier, when
1689 // findAbstractVariable() was called for inlined instance of DV.
1690 LLVMContext &Ctx = DV->getContext();
1691 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1692 if (AbstractVariables.lookup(CleanDV))
1694 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1695 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1698 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1699 constructScopeDIE(TheCU, AScope);
1702 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1703 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1704 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1706 // Add the range of this function to the list of ranges for the CU.
1707 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1708 TheCU->addRange(std::move(Span));
1711 for (auto &I : ScopeVariables)
1712 DeleteContainerPointers(I.second);
1713 ScopeVariables.clear();
1714 DeleteContainerPointers(CurrentFnArguments);
1715 UserVariables.clear();
1717 AbstractVariables.clear();
1718 LabelsBeforeInsn.clear();
1719 LabelsAfterInsn.clear();
1724 // Register a source line with debug info. Returns the unique label that was
1725 // emitted and which provides correspondence to the source line list.
1726 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1731 unsigned Discriminator = 0;
1733 DIDescriptor Scope(S);
1735 if (Scope.isCompileUnit()) {
1736 DICompileUnit CU(S);
1737 Fn = CU.getFilename();
1738 Dir = CU.getDirectory();
1739 } else if (Scope.isFile()) {
1741 Fn = F.getFilename();
1742 Dir = F.getDirectory();
1743 } else if (Scope.isSubprogram()) {
1745 Fn = SP.getFilename();
1746 Dir = SP.getDirectory();
1747 } else if (Scope.isLexicalBlockFile()) {
1748 DILexicalBlockFile DBF(S);
1749 Fn = DBF.getFilename();
1750 Dir = DBF.getDirectory();
1751 } else if (Scope.isLexicalBlock()) {
1752 DILexicalBlock DB(S);
1753 Fn = DB.getFilename();
1754 Dir = DB.getDirectory();
1755 Discriminator = DB.getDiscriminator();
1757 llvm_unreachable("Unexpected scope info");
1759 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1760 Src = static_cast<DwarfCompileUnit *>(InfoHolder.getUnits()[CUID])
1761 ->getOrCreateSourceID(Fn, Dir);
1763 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1767 //===----------------------------------------------------------------------===//
1769 //===----------------------------------------------------------------------===//
1771 // Compute the size and offset of a DIE. The offset is relative to start of the
1772 // CU. It returns the offset after laying out the DIE.
1773 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1774 // Record the abbreviation.
1775 assignAbbrevNumber(Die->getAbbrev());
1777 // Get the abbreviation for this DIE.
1778 const DIEAbbrev &Abbrev = Die->getAbbrev();
1781 Die->setOffset(Offset);
1783 // Start the size with the size of abbreviation code.
1784 Offset += getULEB128Size(Die->getAbbrevNumber());
1786 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1787 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1789 // Size the DIE attribute values.
1790 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1791 // Size attribute value.
1792 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1794 // Get the children.
1795 const std::vector<DIE *> &Children = Die->getChildren();
1797 // Size the DIE children if any.
1798 if (!Children.empty()) {
1799 assert(Abbrev.hasChildren() && "Children flag not set");
1801 for (DIE *Child : Children)
1802 Offset = computeSizeAndOffset(Child, Offset);
1804 // End of children marker.
1805 Offset += sizeof(int8_t);
1808 Die->setSize(Offset - Die->getOffset());
1812 // Compute the size and offset for each DIE.
1813 void DwarfFile::computeSizeAndOffsets() {
1814 // Offset from the first CU in the debug info section is 0 initially.
1815 unsigned SecOffset = 0;
1817 // Iterate over each compile unit and set the size and offsets for each
1818 // DIE within each compile unit. All offsets are CU relative.
1819 for (DwarfUnit *TheU : CUs) {
1820 TheU->setDebugInfoOffset(SecOffset);
1822 // CU-relative offset is reset to 0 here.
1823 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1824 TheU->getHeaderSize(); // Unit-specific headers
1826 // EndOffset here is CU-relative, after laying out
1827 // all of the CU DIE.
1828 unsigned EndOffset = computeSizeAndOffset(TheU->getUnitDie(), Offset);
1829 SecOffset += EndOffset;
1833 // Emit initial Dwarf sections with a label at the start of each one.
1834 void DwarfDebug::emitSectionLabels() {
1835 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1837 // Dwarf sections base addresses.
1838 DwarfInfoSectionSym =
1839 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1840 if (useSplitDwarf())
1841 DwarfInfoDWOSectionSym =
1842 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1843 DwarfAbbrevSectionSym =
1844 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1845 if (useSplitDwarf())
1846 DwarfAbbrevDWOSectionSym = emitSectionSym(
1847 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1848 if (GenerateARangeSection)
1849 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1851 DwarfLineSectionSym =
1852 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1853 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1854 if (GenerateGnuPubSections) {
1855 DwarfGnuPubNamesSectionSym =
1856 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1857 DwarfGnuPubTypesSectionSym =
1858 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1859 } else if (HasDwarfPubSections) {
1860 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1861 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1864 DwarfStrSectionSym =
1865 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1866 if (useSplitDwarf()) {
1867 DwarfStrDWOSectionSym =
1868 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1869 DwarfAddrSectionSym =
1870 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1872 DwarfDebugRangeSectionSym =
1873 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1875 DwarfDebugLocSectionSym =
1876 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1879 // Recursively emits a debug information entry.
1880 void DwarfDebug::emitDIE(DIE *Die) {
1881 // Get the abbreviation for this DIE.
1882 const DIEAbbrev &Abbrev = Die->getAbbrev();
1884 // Emit the code (index) for the abbreviation.
1885 if (Asm->isVerbose())
1886 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1887 "] 0x" + Twine::utohexstr(Die->getOffset()) +
1888 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
1889 dwarf::TagString(Abbrev.getTag()));
1890 Asm->EmitULEB128(Abbrev.getNumber());
1892 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1893 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1895 // Emit the DIE attribute values.
1896 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1897 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1898 dwarf::Form Form = AbbrevData[i].getForm();
1899 assert(Form && "Too many attributes for DIE (check abbreviation)");
1901 if (Asm->isVerbose()) {
1902 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1903 if (Attr == dwarf::DW_AT_accessibility)
1904 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1905 cast<DIEInteger>(Values[i])->getValue()));
1908 // Emit an attribute using the defined form.
1909 Values[i]->EmitValue(Asm, Form);
1912 // Emit the DIE children if any.
1913 if (Abbrev.hasChildren()) {
1914 const std::vector<DIE *> &Children = Die->getChildren();
1916 for (DIE *Child : Children)
1919 Asm->OutStreamer.AddComment("End Of Children Mark");
1924 // Emit the various dwarf units to the unit section USection with
1925 // the abbreviations going into ASection.
1926 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
1927 const MCSymbol *ASectionSym) {
1928 for (DwarfUnit *TheU : CUs) {
1929 DIE *Die = TheU->getUnitDie();
1930 const MCSection *USection = TheU->getSection();
1931 Asm->OutStreamer.SwitchSection(USection);
1933 // Emit the compile units header.
1934 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
1936 // Emit size of content not including length itself
1937 Asm->OutStreamer.AddComment("Length of Unit");
1938 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
1940 TheU->emitHeader(ASection, ASectionSym);
1943 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
1947 // Emit the debug info section.
1948 void DwarfDebug::emitDebugInfo() {
1949 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1951 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
1952 DwarfAbbrevSectionSym);
1955 // Emit the abbreviation section.
1956 void DwarfDebug::emitAbbreviations() {
1957 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1959 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1962 void DwarfFile::emitAbbrevs(const MCSection *Section) {
1963 // Check to see if it is worth the effort.
1964 if (!Abbreviations.empty()) {
1965 // Start the debug abbrev section.
1966 Asm->OutStreamer.SwitchSection(Section);
1968 // For each abbrevation.
1969 for (const DIEAbbrev *Abbrev : Abbreviations) {
1970 // Emit the abbrevations code (base 1 index.)
1971 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1973 // Emit the abbreviations data.
1977 // Mark end of abbreviations.
1978 Asm->EmitULEB128(0, "EOM(3)");
1982 // Emit the last address of the section and the end of the line matrix.
1983 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1984 // Define last address of section.
1985 Asm->OutStreamer.AddComment("Extended Op");
1988 Asm->OutStreamer.AddComment("Op size");
1989 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1990 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1991 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1993 Asm->OutStreamer.AddComment("Section end label");
1995 Asm->OutStreamer.EmitSymbolValue(
1996 Asm->GetTempSymbol("section_end", SectionEnd),
1997 Asm->getDataLayout().getPointerSize());
1999 // Mark end of matrix.
2000 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2006 // Emit visible names into a hashed accelerator table section.
2007 void DwarfDebug::emitAccelNames() {
2009 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2010 for (DwarfUnit *TheU : getUnits()) {
2011 for (const auto &GI : TheU->getAccelNames()) {
2012 StringRef Name = GI.getKey();
2013 for (const DIE *D : GI.second)
2014 AT.AddName(Name, D);
2018 AT.FinalizeTable(Asm, "Names");
2019 Asm->OutStreamer.SwitchSection(
2020 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2021 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2022 Asm->OutStreamer.EmitLabel(SectionBegin);
2024 // Emit the full data.
2025 AT.Emit(Asm, SectionBegin, &InfoHolder);
2028 // Emit objective C classes and categories into a hashed accelerator table
2030 void DwarfDebug::emitAccelObjC() {
2032 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2033 for (DwarfUnit *TheU : getUnits()) {
2034 for (const auto &GI : TheU->getAccelObjC()) {
2035 StringRef Name = GI.getKey();
2036 for (const DIE *D : GI.second)
2037 AT.AddName(Name, D);
2041 AT.FinalizeTable(Asm, "ObjC");
2042 Asm->OutStreamer.SwitchSection(
2043 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2044 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2045 Asm->OutStreamer.EmitLabel(SectionBegin);
2047 // Emit the full data.
2048 AT.Emit(Asm, SectionBegin, &InfoHolder);
2051 // Emit namespace dies into a hashed accelerator table.
2052 void DwarfDebug::emitAccelNamespaces() {
2054 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2055 for (DwarfUnit *TheU : getUnits()) {
2056 for (const auto &GI : TheU->getAccelNamespace()) {
2057 StringRef Name = GI.getKey();
2058 for (const DIE *D : GI.second)
2059 AT.AddName(Name, D);
2063 AT.FinalizeTable(Asm, "namespac");
2064 Asm->OutStreamer.SwitchSection(
2065 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2066 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2067 Asm->OutStreamer.EmitLabel(SectionBegin);
2069 // Emit the full data.
2070 AT.Emit(Asm, SectionBegin, &InfoHolder);
2073 // Emit type dies into a hashed accelerator table.
2074 void DwarfDebug::emitAccelTypes() {
2075 std::vector<DwarfAccelTable::Atom> Atoms;
2077 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2079 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2081 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2082 DwarfAccelTable AT(Atoms);
2083 for (DwarfUnit *TheU : getUnits()) {
2084 for (const auto &GI : TheU->getAccelTypes()) {
2085 StringRef Name = GI.getKey();
2086 for (const auto &DI : GI.second)
2087 AT.AddName(Name, DI.first, DI.second);
2091 AT.FinalizeTable(Asm, "types");
2092 Asm->OutStreamer.SwitchSection(
2093 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2094 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2095 Asm->OutStreamer.EmitLabel(SectionBegin);
2097 // Emit the full data.
2098 AT.Emit(Asm, SectionBegin, &InfoHolder);
2101 // Public name handling.
2102 // The format for the various pubnames:
2104 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2105 // for the DIE that is named.
2107 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2108 // into the CU and the index value is computed according to the type of value
2109 // for the DIE that is named.
2111 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2112 // it's the offset within the debug_info/debug_types dwo section, however, the
2113 // reference in the pubname header doesn't change.
2115 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2116 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2118 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2120 // We could have a specification DIE that has our most of our knowledge,
2121 // look for that now.
2122 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2124 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2125 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2126 Linkage = dwarf::GIEL_EXTERNAL;
2127 } else if (Die->findAttribute(dwarf::DW_AT_external))
2128 Linkage = dwarf::GIEL_EXTERNAL;
2130 switch (Die->getTag()) {
2131 case dwarf::DW_TAG_class_type:
2132 case dwarf::DW_TAG_structure_type:
2133 case dwarf::DW_TAG_union_type:
2134 case dwarf::DW_TAG_enumeration_type:
2135 return dwarf::PubIndexEntryDescriptor(
2136 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2137 ? dwarf::GIEL_STATIC
2138 : dwarf::GIEL_EXTERNAL);
2139 case dwarf::DW_TAG_typedef:
2140 case dwarf::DW_TAG_base_type:
2141 case dwarf::DW_TAG_subrange_type:
2142 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2143 case dwarf::DW_TAG_namespace:
2144 return dwarf::GIEK_TYPE;
2145 case dwarf::DW_TAG_subprogram:
2146 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2147 case dwarf::DW_TAG_constant:
2148 case dwarf::DW_TAG_variable:
2149 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2150 case dwarf::DW_TAG_enumerator:
2151 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2152 dwarf::GIEL_STATIC);
2154 return dwarf::GIEK_NONE;
2158 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2160 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2161 const MCSection *PSec =
2162 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2163 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2165 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2168 void DwarfDebug::emitDebugPubSection(
2169 bool GnuStyle, const MCSection *PSec, StringRef Name,
2170 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
2171 for (const auto &NU : CUMap) {
2172 DwarfCompileUnit *TheU = NU.second;
2174 const auto &Globals = (TheU->*Accessor)();
2176 if (Globals.empty())
2179 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2181 unsigned ID = TheU->getUniqueID();
2183 // Start the dwarf pubnames section.
2184 Asm->OutStreamer.SwitchSection(PSec);
2187 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2188 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2189 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2190 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2192 Asm->OutStreamer.EmitLabel(BeginLabel);
2194 Asm->OutStreamer.AddComment("DWARF Version");
2195 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2197 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2198 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2200 Asm->OutStreamer.AddComment("Compilation Unit Length");
2201 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2203 // Emit the pubnames for this compilation unit.
2204 for (const auto &GI : Globals) {
2205 const char *Name = GI.getKeyData();
2206 const DIE *Entity = GI.second;
2208 Asm->OutStreamer.AddComment("DIE offset");
2209 Asm->EmitInt32(Entity->getOffset());
2212 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2213 Asm->OutStreamer.AddComment(
2214 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2215 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2216 Asm->EmitInt8(Desc.toBits());
2219 Asm->OutStreamer.AddComment("External Name");
2220 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2223 Asm->OutStreamer.AddComment("End Mark");
2225 Asm->OutStreamer.EmitLabel(EndLabel);
2229 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2230 const MCSection *PSec =
2231 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2232 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2234 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2237 // Emit strings into a string section.
2238 void DwarfFile::emitStrings(const MCSection *StrSection,
2239 const MCSection *OffsetSection = NULL,
2240 const MCSymbol *StrSecSym = NULL) {
2242 if (StringPool.empty())
2245 // Start the dwarf str section.
2246 Asm->OutStreamer.SwitchSection(StrSection);
2248 // Get all of the string pool entries and put them in an array by their ID so
2249 // we can sort them.
2250 SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
2252 for (const auto &I : StringPool)
2253 Entries.push_back(std::make_pair(I.second.second, &I));
2255 array_pod_sort(Entries.begin(), Entries.end());
2257 for (const auto &Entry : Entries) {
2258 // Emit a label for reference from debug information entries.
2259 Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
2261 // Emit the string itself with a terminating null byte.
2262 Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
2263 Entry.second->getKeyLength() + 1));
2266 // If we've got an offset section go ahead and emit that now as well.
2267 if (OffsetSection) {
2268 Asm->OutStreamer.SwitchSection(OffsetSection);
2269 unsigned offset = 0;
2270 unsigned size = 4; // FIXME: DWARF64 is 8.
2271 for (const auto &Entry : Entries) {
2272 Asm->OutStreamer.EmitIntValue(offset, size);
2273 offset += Entry.second->getKeyLength() + 1;
2278 // Emit addresses into the section given.
2279 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2281 if (AddressPool.empty())
2284 // Start the dwarf addr section.
2285 Asm->OutStreamer.SwitchSection(AddrSection);
2287 // Order the address pool entries by ID
2288 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2290 for (const auto &I : AddressPool)
2291 Entries[I.second.Number] =
2293 ? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
2294 : MCSymbolRefExpr::Create(I.first, Asm->OutContext);
2296 for (const MCExpr *Entry : Entries)
2297 Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
2300 // Emit visible names into a debug str section.
2301 void DwarfDebug::emitDebugStr() {
2302 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2303 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2306 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2307 const DebugLocEntry &Entry) {
2308 DIVariable DV(Entry.getVariable());
2309 if (Entry.isInt()) {
2310 DIBasicType BTy(resolve(DV.getType()));
2311 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2312 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2313 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2314 Streamer.EmitSLEB128(Entry.getInt());
2316 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2317 Streamer.EmitULEB128(Entry.getInt());
2319 } else if (Entry.isLocation()) {
2320 MachineLocation Loc = Entry.getLoc();
2321 if (!DV.hasComplexAddress())
2323 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2325 // Complex address entry.
2326 unsigned N = DV.getNumAddrElements();
2328 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2329 if (Loc.getOffset()) {
2331 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2332 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2333 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2334 Streamer.EmitSLEB128(DV.getAddrElement(1));
2336 // If first address element is OpPlus then emit
2337 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2338 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2339 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2343 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2346 // Emit remaining complex address elements.
2347 for (; i < N; ++i) {
2348 uint64_t Element = DV.getAddrElement(i);
2349 if (Element == DIBuilder::OpPlus) {
2350 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2351 Streamer.EmitULEB128(DV.getAddrElement(++i));
2352 } else if (Element == DIBuilder::OpDeref) {
2354 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2356 llvm_unreachable("unknown Opcode found in complex address");
2360 // else ... ignore constant fp. There is not any good way to
2361 // to represent them here in dwarf.
2365 // Emit locations into the debug loc section.
2366 void DwarfDebug::emitDebugLoc() {
2367 if (DotDebugLocEntries.empty())
2370 for (SmallVectorImpl<DebugLocEntry>::iterator
2371 I = DotDebugLocEntries.begin(),
2372 E = DotDebugLocEntries.end();
2374 DebugLocEntry &Entry = *I;
2375 if (I + 1 != DotDebugLocEntries.end())
2379 // Start the dwarf loc section.
2380 Asm->OutStreamer.SwitchSection(
2381 Asm->getObjFileLowering().getDwarfLocSection());
2382 unsigned char Size = Asm->getDataLayout().getPointerSize();
2383 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2385 for (SmallVectorImpl<DebugLocEntry>::const_iterator
2386 I = DotDebugLocEntries.begin(),
2387 E = DotDebugLocEntries.end();
2388 I != E; ++I, ++index) {
2389 const DebugLocEntry &Entry = *I;
2390 if (Entry.isMerged())
2393 if (Entry.isEmpty()) {
2394 Asm->OutStreamer.EmitIntValue(0, Size);
2395 Asm->OutStreamer.EmitIntValue(0, Size);
2396 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2398 // Set up the range.
2399 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2400 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2401 Asm->OutStreamer.AddComment("Loc expr size");
2402 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2403 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2404 Asm->EmitLabelDifference(end, begin, 2);
2405 Asm->OutStreamer.EmitLabel(begin);
2407 APByteStreamer Streamer(*Asm);
2408 emitDebugLocEntry(Streamer, Entry);
2410 Asm->OutStreamer.EmitLabel(end);
2416 const MCSymbol *Start, *End;
2419 // Emit a debug aranges section, containing a CU lookup for any
2420 // address we can tie back to a CU.
2421 void DwarfDebug::emitDebugARanges() {
2422 // Start the dwarf aranges section.
2423 Asm->OutStreamer.SwitchSection(
2424 Asm->getObjFileLowering().getDwarfARangesSection());
2426 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2430 // Build a list of sections used.
2431 std::vector<const MCSection *> Sections;
2432 for (const auto &it : SectionMap) {
2433 const MCSection *Section = it.first;
2434 Sections.push_back(Section);
2437 // Sort the sections into order.
2438 // This is only done to ensure consistent output order across different runs.
2439 std::sort(Sections.begin(), Sections.end(), SectionSort);
2441 // Build a set of address spans, sorted by CU.
2442 for (const MCSection *Section : Sections) {
2443 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2444 if (List.size() < 2)
2447 // Sort the symbols by offset within the section.
2448 std::sort(List.begin(), List.end(),
2449 [&](const SymbolCU &A, const SymbolCU &B) {
2450 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2451 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2453 // Symbols with no order assigned should be placed at the end.
2454 // (e.g. section end labels)
2462 // If we have no section (e.g. common), just write out
2463 // individual spans for each symbol.
2464 if (Section == NULL) {
2465 for (const SymbolCU &Cur : List) {
2467 Span.Start = Cur.Sym;
2470 Spans[Cur.CU].push_back(Span);
2473 // Build spans between each label.
2474 const MCSymbol *StartSym = List[0].Sym;
2475 for (size_t n = 1, e = List.size(); n < e; n++) {
2476 const SymbolCU &Prev = List[n - 1];
2477 const SymbolCU &Cur = List[n];
2479 // Try and build the longest span we can within the same CU.
2480 if (Cur.CU != Prev.CU) {
2482 Span.Start = StartSym;
2484 Spans[Prev.CU].push_back(Span);
2491 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2493 // Build a list of CUs used.
2494 std::vector<DwarfCompileUnit *> CUs;
2495 for (const auto &it : Spans) {
2496 DwarfCompileUnit *CU = it.first;
2500 // Sort the CU list (again, to ensure consistent output order).
2501 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2502 return A->getUniqueID() < B->getUniqueID();
2505 // Emit an arange table for each CU we used.
2506 for (DwarfCompileUnit *CU : CUs) {
2507 std::vector<ArangeSpan> &List = Spans[CU];
2509 // Emit size of content not including length itself.
2510 unsigned ContentSize =
2511 sizeof(int16_t) + // DWARF ARange version number
2512 sizeof(int32_t) + // Offset of CU in the .debug_info section
2513 sizeof(int8_t) + // Pointer Size (in bytes)
2514 sizeof(int8_t); // Segment Size (in bytes)
2516 unsigned TupleSize = PtrSize * 2;
2518 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2520 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2522 ContentSize += Padding;
2523 ContentSize += (List.size() + 1) * TupleSize;
2525 // For each compile unit, write the list of spans it covers.
2526 Asm->OutStreamer.AddComment("Length of ARange Set");
2527 Asm->EmitInt32(ContentSize);
2528 Asm->OutStreamer.AddComment("DWARF Arange version number");
2529 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2530 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2531 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2532 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2533 Asm->EmitInt8(PtrSize);
2534 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2537 Asm->OutStreamer.EmitFill(Padding, 0xff);
2539 for (const ArangeSpan &Span : List) {
2540 Asm->EmitLabelReference(Span.Start, PtrSize);
2542 // Calculate the size as being from the span start to it's end.
2544 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2546 // For symbols without an end marker (e.g. common), we
2547 // write a single arange entry containing just that one symbol.
2548 uint64_t Size = SymSize[Span.Start];
2552 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2556 Asm->OutStreamer.AddComment("ARange terminator");
2557 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2558 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2562 // Emit visible names into a debug ranges section.
2563 void DwarfDebug::emitDebugRanges() {
2564 // Start the dwarf ranges section.
2565 Asm->OutStreamer.SwitchSection(
2566 Asm->getObjFileLowering().getDwarfRangesSection());
2568 // Size for our labels.
2569 unsigned char Size = Asm->getDataLayout().getPointerSize();
2571 // Grab the specific ranges for the compile units in the module.
2572 for (const auto &I : CUMap) {
2573 DwarfCompileUnit *TheCU = I.second;
2575 // Emit a symbol so we can find the beginning of our ranges.
2576 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2578 // Iterate over the misc ranges for the compile units in the module.
2579 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2580 // Emit our symbol so we can find the beginning of the range.
2581 Asm->OutStreamer.EmitLabel(List.getSym());
2583 for (const RangeSpan &Range : List.getRanges()) {
2584 const MCSymbol *Begin = Range.getStart();
2585 const MCSymbol *End = Range.getEnd();
2586 assert(Begin && "Range without a begin symbol?");
2587 assert(End && "Range without an end symbol?");
2588 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2589 Asm->OutStreamer.EmitSymbolValue(End, Size);
2592 // And terminate the list with two 0 values.
2593 Asm->OutStreamer.EmitIntValue(0, Size);
2594 Asm->OutStreamer.EmitIntValue(0, Size);
2597 // Now emit a range for the CU itself.
2598 if (useCURanges() && TheCU->getRanges().size()) {
2599 Asm->OutStreamer.EmitLabel(
2600 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2601 for (const RangeSpan &Range : TheCU->getRanges()) {
2602 const MCSymbol *Begin = Range.getStart();
2603 const MCSymbol *End = Range.getEnd();
2604 assert(Begin && "Range without a begin symbol?");
2605 assert(End && "Range without an end symbol?");
2606 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2607 Asm->OutStreamer.EmitSymbolValue(End, Size);
2609 // And terminate the list with two 0 values.
2610 Asm->OutStreamer.EmitIntValue(0, Size);
2611 Asm->OutStreamer.EmitIntValue(0, Size);
2616 // DWARF5 Experimental Separate Dwarf emitters.
2618 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2620 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2621 U->getCUNode().getSplitDebugFilename());
2623 // Relocate to the beginning of the addr_base section, else 0 for the
2624 // beginning of the one for this compile unit.
2625 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2626 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2628 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2630 if (!CompilationDir.empty())
2631 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2633 addGnuPubAttributes(NewU, Die);
2635 SkeletonHolder.addUnit(NewU);
2638 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2639 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2640 // DW_AT_ranges_base, DW_AT_addr_base.
2641 // TODO: Implement DW_AT_ranges_base.
2642 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2644 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2645 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2646 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2647 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2648 DwarfInfoSectionSym);
2650 NewCU->initStmtList(DwarfLineSectionSym);
2652 initSkeletonUnit(CU, Die, NewCU);
2657 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2659 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
2660 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2661 *SkeletonHolder.getUnits()[TU->getCU().getUniqueID()]);
2663 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2664 DwarfTypeUnit *NewTU =
2665 new DwarfTypeUnit(TU->getUniqueID(), Die, CU, Asm, this, &SkeletonHolder);
2666 NewTU->setTypeSignature(TU->getTypeSignature());
2667 NewTU->setType(NULL);
2669 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2671 initSkeletonUnit(TU, Die, NewTU);
2675 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2676 // compile units that would normally be in debug_info.
2677 void DwarfDebug::emitDebugInfoDWO() {
2678 assert(useSplitDwarf() && "No split dwarf debug info?");
2679 InfoHolder.emitUnits(this,
2680 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2681 DwarfAbbrevDWOSectionSym);
2684 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2685 // abbreviations for the .debug_info.dwo section.
2686 void DwarfDebug::emitDebugAbbrevDWO() {
2687 assert(useSplitDwarf() && "No split dwarf?");
2688 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2691 void DwarfDebug::emitDebugLineDWO() {
2692 assert(useSplitDwarf() && "No split dwarf?");
2693 Asm->OutStreamer.SwitchSection(
2694 Asm->getObjFileLowering().getDwarfLineDWOSection());
2695 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2698 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2699 // string section and is identical in format to traditional .debug_str
2701 void DwarfDebug::emitDebugStrDWO() {
2702 assert(useSplitDwarf() && "No split dwarf?");
2703 const MCSection *OffSec =
2704 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2705 const MCSymbol *StrSym = DwarfStrSectionSym;
2706 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2710 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2711 StringRef Identifier, DIE *RefDie,
2712 DICompositeType CTy) {
2713 // Flag the type unit reference as a declaration so that if it contains
2714 // members (implicit special members, static data member definitions, member
2715 // declarations for definitions in this CU, etc) consumers don't get confused
2716 // and think this is a full definition.
2717 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2719 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2721 CU.addDIETypeSignature(RefDie, *TU);
2725 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2726 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
2727 InfoHolder.getUnits().size(), UnitDie, CU, Asm, this, &InfoHolder,
2728 useSplitDwarf() ? &SplitTypeUnitFileTable : nullptr);
2730 InfoHolder.addUnit(NewTU);
2732 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2736 Hash.update(Identifier);
2737 // ... take the least significant 8 bytes and return those. Our MD5
2738 // implementation always returns its results in little endian, swap bytes
2740 MD5::MD5Result Result;
2742 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2743 NewTU->setTypeSignature(Signature);
2744 if (useSplitDwarf())
2745 NewTU->setSkeleton(constructSkeletonTU(NewTU));
2747 CU.applyStmtList(*UnitDie);
2749 NewTU->setType(NewTU->createTypeDIE(CTy));
2753 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2754 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2756 CU.addDIETypeSignature(RefDie, *NewTU);
2759 void DwarfDebug::attachLowHighPC(DwarfCompileUnit *Unit, DIE *D,
2760 MCSymbol *Begin, MCSymbol *End) {
2761 Unit->addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2762 if (DwarfVersion < 4)
2763 Unit->addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2765 Unit->addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);