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 = resolve(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);
960 // We don't keep track of which addresses are used in which CU so this
961 // is a bit pessimistic under LTO.
962 if (!InfoHolder.getAddrPool()->empty())
963 addSectionLabel(Asm, SkCU, SkCU->getUnitDie(),
964 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
965 DwarfAddrSectionSym);
966 if (!TheU->getRangeLists().empty())
967 addSectionLabel(Asm, SkCU, SkCU->getUnitDie(),
968 dwarf::DW_AT_GNU_ranges_base,
969 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
972 // If we have code split among multiple sections or non-contiguous
973 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
974 // remain in the .o file, otherwise add a DW_AT_low_pc.
975 // FIXME: We should use ranges allow reordering of code ala
976 // .subsections_via_symbols in mach-o. This would mean turning on
977 // ranges for all subprogram DIEs for mach-o.
978 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
979 unsigned NumRanges = TheU->getRanges().size();
982 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
983 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
984 DwarfDebugRangeSectionSym);
986 // A DW_AT_low_pc attribute may also be specified in combination with
987 // DW_AT_ranges to specify the default base address for use in
988 // location lists (see Section 2.6.2) and range lists (see Section
990 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
993 RangeSpan &Range = TheU->getRanges().back();
994 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_low_pc,
996 U->addLabelDelta(U->getUnitDie(), dwarf::DW_AT_high_pc,
997 Range.getEnd(), Range.getStart());
1003 // Compute DIE offsets and sizes.
1004 InfoHolder.computeSizeAndOffsets();
1005 if (useSplitDwarf())
1006 SkeletonHolder.computeSizeAndOffsets();
1009 void DwarfDebug::endSections() {
1010 // Filter labels by section.
1011 for (const SymbolCU &SCU : ArangeLabels) {
1012 if (SCU.Sym->isInSection()) {
1013 // Make a note of this symbol and it's section.
1014 const MCSection *Section = &SCU.Sym->getSection();
1015 if (!Section->getKind().isMetadata())
1016 SectionMap[Section].push_back(SCU);
1018 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1019 // appear in the output. This sucks as we rely on sections to build
1020 // arange spans. We can do it without, but it's icky.
1021 SectionMap[NULL].push_back(SCU);
1025 // Build a list of sections used.
1026 std::vector<const MCSection *> Sections;
1027 for (const auto &it : SectionMap) {
1028 const MCSection *Section = it.first;
1029 Sections.push_back(Section);
1032 // Sort the sections into order.
1033 // This is only done to ensure consistent output order across different runs.
1034 std::sort(Sections.begin(), Sections.end(), SectionSort);
1036 // Add terminating symbols for each section.
1037 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
1038 const MCSection *Section = Sections[ID];
1039 MCSymbol *Sym = NULL;
1042 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1043 // if we know the section name up-front. For user-created sections, the
1044 // resulting label may not be valid to use as a label. (section names can
1045 // use a greater set of characters on some systems)
1046 Sym = Asm->GetTempSymbol("debug_end", ID);
1047 Asm->OutStreamer.SwitchSection(Section);
1048 Asm->OutStreamer.EmitLabel(Sym);
1051 // Insert a final terminator.
1052 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1056 // Emit all Dwarf sections that should come after the content.
1057 void DwarfDebug::endModule() {
1064 // End any existing sections.
1065 // TODO: Does this need to happen?
1068 // Finalize the debug info for the module.
1069 finalizeModuleInfo();
1073 // Emit all the DIEs into a debug info section.
1076 // Corresponding abbreviations into a abbrev section.
1077 emitAbbreviations();
1079 // Emit info into a debug aranges section.
1080 if (GenerateARangeSection)
1083 // Emit info into a debug ranges section.
1086 if (useSplitDwarf()) {
1089 emitDebugAbbrevDWO();
1091 // Emit DWO addresses.
1092 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1095 // Emit info into a debug loc section.
1098 // Emit info into the dwarf accelerator table sections.
1099 if (useDwarfAccelTables()) {
1102 emitAccelNamespaces();
1106 // Emit the pubnames and pubtypes sections if requested.
1107 if (HasDwarfPubSections) {
1108 emitDebugPubNames(GenerateGnuPubSections);
1109 emitDebugPubTypes(GenerateGnuPubSections);
1115 // Reset these for the next Module if we have one.
1119 // Find abstract variable, if any, associated with Var.
1120 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1121 DebugLoc ScopeLoc) {
1122 LLVMContext &Ctx = DV->getContext();
1123 // More then one inlined variable corresponds to one abstract variable.
1124 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1125 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1127 return AbsDbgVariable;
1129 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1133 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1134 addScopeVariable(Scope, AbsDbgVariable);
1135 AbstractVariables[Var] = AbsDbgVariable;
1136 return AbsDbgVariable;
1139 // If Var is a current function argument then add it to CurrentFnArguments list.
1140 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1141 if (!LScopes.isCurrentFunctionScope(Scope))
1143 DIVariable DV = Var->getVariable();
1144 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1146 unsigned ArgNo = DV.getArgNumber();
1150 size_t Size = CurrentFnArguments.size();
1152 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1153 // llvm::Function argument size is not good indicator of how many
1154 // arguments does the function have at source level.
1156 CurrentFnArguments.resize(ArgNo * 2);
1157 CurrentFnArguments[ArgNo - 1] = Var;
1161 // Collect variable information from side table maintained by MMI.
1162 void DwarfDebug::collectVariableInfoFromMMITable(
1163 SmallPtrSet<const MDNode *, 16> &Processed) {
1164 for (const auto &VI : MMI->getVariableDbgInfo()) {
1167 Processed.insert(VI.Var);
1168 DIVariable DV(VI.Var);
1169 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1171 // If variable scope is not found then skip this variable.
1175 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1176 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1177 RegVar->setFrameIndex(VI.Slot);
1178 if (!addCurrentFnArgument(RegVar, Scope))
1179 addScopeVariable(Scope, RegVar);
1181 AbsDbgVariable->setFrameIndex(VI.Slot);
1185 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1187 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1188 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1189 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1190 MI->getOperand(0).getReg() &&
1191 (MI->getOperand(1).isImm() ||
1192 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1195 // Get .debug_loc entry for the instruction range starting at MI.
1196 static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1197 const MCSymbol *FLabel,
1198 const MCSymbol *SLabel,
1199 const MachineInstr *MI,
1200 DwarfCompileUnit *Unit) {
1201 const MDNode *Var = MI->getDebugVariable();
1203 assert(MI->getNumOperands() == 3);
1204 if (MI->getOperand(0).isReg()) {
1205 MachineLocation MLoc;
1206 // If the second operand is an immediate, this is a
1207 // register-indirect address.
1208 if (!MI->getOperand(1).isImm())
1209 MLoc.set(MI->getOperand(0).getReg());
1211 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1212 return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
1214 if (MI->getOperand(0).isImm())
1215 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Var, Unit);
1216 if (MI->getOperand(0).isFPImm())
1217 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(),
1219 if (MI->getOperand(0).isCImm())
1220 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(),
1223 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1226 // Find variables for each lexical scope.
1228 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1230 // Grab the variable info that was squirreled away in the MMI side-table.
1231 collectVariableInfoFromMMITable(Processed);
1233 for (const MDNode *Var : UserVariables) {
1234 if (Processed.count(Var))
1237 // History contains relevant DBG_VALUE instructions for Var and instructions
1239 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1240 if (History.empty())
1242 const MachineInstr *MInsn = History.front();
1245 LexicalScope *Scope = NULL;
1246 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1247 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1248 Scope = LScopes.getCurrentFunctionScope();
1249 else if (MDNode *IA = DV.getInlinedAt())
1250 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1252 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1253 // If variable scope is not found then skip this variable.
1257 Processed.insert(DV);
1258 assert(MInsn->isDebugValue() && "History must begin with debug value");
1259 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1260 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1261 if (!addCurrentFnArgument(RegVar, Scope))
1262 addScopeVariable(Scope, RegVar);
1264 AbsVar->setMInsn(MInsn);
1266 // Simplify ranges that are fully coalesced.
1267 if (History.size() <= 1 ||
1268 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1269 RegVar->setMInsn(MInsn);
1273 // Handle multiple DBG_VALUE instructions describing one variable.
1274 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1276 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1277 DebugLocList &LocList = DotDebugLocEntries.back();
1279 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1280 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1281 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1282 HI = History.begin(),
1285 const MachineInstr *Begin = *HI;
1286 assert(Begin->isDebugValue() && "Invalid History entry");
1288 // Check if DBG_VALUE is truncating a range.
1289 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1290 !Begin->getOperand(0).getReg())
1293 // Compute the range for a register location.
1294 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1295 const MCSymbol *SLabel = 0;
1298 // If Begin is the last instruction in History then its value is valid
1299 // until the end of the function.
1300 SLabel = FunctionEndSym;
1302 const MachineInstr *End = HI[1];
1303 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1304 << "\t" << *Begin << "\t" << *End << "\n");
1305 if (End->isDebugValue())
1306 SLabel = getLabelBeforeInsn(End);
1308 // End is a normal instruction clobbering the range.
1309 SLabel = getLabelAfterInsn(End);
1310 assert(SLabel && "Forgot label after clobber instruction");
1315 // The value is valid until the next DBG_VALUE or clobber.
1316 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1317 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1318 DebugLocEntry Loc = getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU);
1319 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1320 DebugLoc.push_back(std::move(Loc));
1324 // Collect info for variables that were optimized out.
1325 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1326 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1327 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1328 DIVariable DV(Variables.getElement(i));
1329 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1331 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1332 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1336 // Return Label preceding the instruction.
1337 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1338 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1339 assert(Label && "Didn't insert label before instruction");
1343 // Return Label immediately following the instruction.
1344 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1345 return LabelsAfterInsn.lookup(MI);
1348 // Process beginning of an instruction.
1349 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1352 // Check if source location changes, but ignore DBG_VALUE locations.
1353 if (!MI->isDebugValue()) {
1354 DebugLoc DL = MI->getDebugLoc();
1355 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1358 if (DL == PrologEndLoc) {
1359 Flags |= DWARF2_FLAG_PROLOGUE_END;
1360 PrologEndLoc = DebugLoc();
1362 if (PrologEndLoc.isUnknown())
1363 Flags |= DWARF2_FLAG_IS_STMT;
1365 if (!DL.isUnknown()) {
1366 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1367 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1369 recordSourceLine(0, 0, 0, 0);
1373 // Insert labels where requested.
1374 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1375 LabelsBeforeInsn.find(MI);
1378 if (I == LabelsBeforeInsn.end())
1381 // Label already assigned.
1386 PrevLabel = MMI->getContext().CreateTempSymbol();
1387 Asm->OutStreamer.EmitLabel(PrevLabel);
1389 I->second = PrevLabel;
1392 // Process end of an instruction.
1393 void DwarfDebug::endInstruction() {
1395 // Don't create a new label after DBG_VALUE instructions.
1396 // They don't generate code.
1397 if (!CurMI->isDebugValue())
1400 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1401 LabelsAfterInsn.find(CurMI);
1405 if (I == LabelsAfterInsn.end())
1408 // Label already assigned.
1412 // We need a label after this instruction.
1414 PrevLabel = MMI->getContext().CreateTempSymbol();
1415 Asm->OutStreamer.EmitLabel(PrevLabel);
1417 I->second = PrevLabel;
1420 // Each LexicalScope has first instruction and last instruction to mark
1421 // beginning and end of a scope respectively. Create an inverse map that list
1422 // scopes starts (and ends) with an instruction. One instruction may start (or
1423 // end) multiple scopes. Ignore scopes that are not reachable.
1424 void DwarfDebug::identifyScopeMarkers() {
1425 SmallVector<LexicalScope *, 4> WorkList;
1426 WorkList.push_back(LScopes.getCurrentFunctionScope());
1427 while (!WorkList.empty()) {
1428 LexicalScope *S = WorkList.pop_back_val();
1430 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1431 if (!Children.empty())
1432 WorkList.append(Children.begin(), Children.end());
1434 if (S->isAbstractScope())
1437 for (const InsnRange &R : S->getRanges()) {
1438 assert(R.first && "InsnRange does not have first instruction!");
1439 assert(R.second && "InsnRange does not have second instruction!");
1440 requestLabelBeforeInsn(R.first);
1441 requestLabelAfterInsn(R.second);
1446 // Gather pre-function debug information. Assumes being called immediately
1447 // after the function entry point has been emitted.
1448 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1451 // If there's no debug info for the function we're not going to do anything.
1452 if (!MMI->hasDebugInfo())
1455 // Grab the lexical scopes for the function, if we don't have any of those
1456 // then we're not going to be able to do anything.
1457 LScopes.initialize(*MF);
1458 if (LScopes.empty())
1461 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1463 // Make sure that each lexical scope will have a begin/end label.
1464 identifyScopeMarkers();
1466 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1467 // belongs to so that we add to the correct per-cu line table in the
1469 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1470 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1471 assert(TheCU && "Unable to find compile unit!");
1472 if (Asm->OutStreamer.hasRawTextSupport())
1473 // Use a single line table if we are generating assembly.
1474 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1476 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1478 // Emit a label for the function so that we have a beginning address.
1479 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1480 // Assumes in correct section after the entry point.
1481 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1483 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1484 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1485 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1487 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1489 bool AtBlockEntry = true;
1490 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1492 const MachineInstr *MI = II;
1494 if (MI->isDebugValue()) {
1495 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1497 // Keep track of user variables.
1498 const MDNode *Var = MI->getDebugVariable();
1500 // Variable is in a register, we need to check for clobbers.
1501 if (isDbgValueInDefinedReg(MI))
1502 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1504 // Check the history of this variable.
1505 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1506 if (History.empty()) {
1507 UserVariables.push_back(Var);
1508 // The first mention of a function argument gets the FunctionBeginSym
1509 // label, so arguments are visible when breaking at function entry.
1511 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1512 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1513 LabelsBeforeInsn[MI] = FunctionBeginSym;
1515 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1516 const MachineInstr *Prev = History.back();
1517 if (Prev->isDebugValue()) {
1518 // Coalesce identical entries at the end of History.
1519 if (History.size() >= 2 &&
1520 Prev->isIdenticalTo(History[History.size() - 2])) {
1521 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1522 << "\t" << *Prev << "\t"
1523 << *History[History.size() - 2] << "\n");
1527 // Terminate old register assignments that don't reach MI;
1528 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1529 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1530 isDbgValueInDefinedReg(Prev)) {
1531 // Previous register assignment needs to terminate at the end of
1533 MachineBasicBlock::const_iterator LastMI =
1534 PrevMBB->getLastNonDebugInstr();
1535 if (LastMI == PrevMBB->end()) {
1536 // Drop DBG_VALUE for empty range.
1537 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1538 << "\t" << *Prev << "\n");
1540 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1541 // Terminate after LastMI.
1542 History.push_back(LastMI);
1546 History.push_back(MI);
1548 // Not a DBG_VALUE instruction.
1549 if (!MI->isPosition())
1550 AtBlockEntry = false;
1552 // First known non-DBG_VALUE and non-frame setup location marks
1553 // the beginning of the function body.
1554 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1555 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1556 PrologEndLoc = MI->getDebugLoc();
1558 // Check if the instruction clobbers any registers with debug vars.
1559 for (const MachineOperand &MO : MI->operands()) {
1560 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1562 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1565 const MDNode *Var = LiveUserVar[Reg];
1568 // Reg is now clobbered.
1569 LiveUserVar[Reg] = 0;
1571 // Was MD last defined by a DBG_VALUE referring to Reg?
1572 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1573 if (HistI == DbgValues.end())
1575 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1576 if (History.empty())
1578 const MachineInstr *Prev = History.back();
1579 // Sanity-check: Register assignments are terminated at the end of
1581 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1583 // Is the variable still in Reg?
1584 if (!isDbgValueInDefinedReg(Prev) ||
1585 Prev->getOperand(0).getReg() != Reg)
1587 // Var is clobbered. Make sure the next instruction gets a label.
1588 History.push_back(MI);
1595 for (auto &I : DbgValues) {
1596 SmallVectorImpl<const MachineInstr *> &History = I.second;
1597 if (History.empty())
1600 // Make sure the final register assignments are terminated.
1601 const MachineInstr *Prev = History.back();
1602 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1603 const MachineBasicBlock *PrevMBB = Prev->getParent();
1604 MachineBasicBlock::const_iterator LastMI =
1605 PrevMBB->getLastNonDebugInstr();
1606 if (LastMI == PrevMBB->end())
1607 // Drop DBG_VALUE for empty range.
1609 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1610 // Terminate after LastMI.
1611 History.push_back(LastMI);
1614 // Request labels for the full history.
1615 for (const MachineInstr *MI : History) {
1616 if (MI->isDebugValue())
1617 requestLabelBeforeInsn(MI);
1619 requestLabelAfterInsn(MI);
1623 PrevInstLoc = DebugLoc();
1624 PrevLabel = FunctionBeginSym;
1626 // Record beginning of function.
1627 if (!PrologEndLoc.isUnknown()) {
1628 DebugLoc FnStartDL =
1629 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1631 FnStartDL.getLine(), FnStartDL.getCol(),
1632 FnStartDL.getScope(MF->getFunction()->getContext()),
1633 // We'd like to list the prologue as "not statements" but GDB behaves
1634 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1635 DWARF2_FLAG_IS_STMT);
1639 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1640 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1641 DIVariable DV = Var->getVariable();
1642 // Variables with positive arg numbers are parameters.
1643 if (unsigned ArgNum = DV.getArgNumber()) {
1644 // Keep all parameters in order at the start of the variable list to ensure
1645 // function types are correct (no out-of-order parameters)
1647 // This could be improved by only doing it for optimized builds (unoptimized
1648 // builds have the right order to begin with), searching from the back (this
1649 // would catch the unoptimized case quickly), or doing a binary search
1650 // rather than linear search.
1651 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1652 while (I != Vars.end()) {
1653 unsigned CurNum = (*I)->getVariable().getArgNumber();
1654 // A local (non-parameter) variable has been found, insert immediately
1658 // A later indexed parameter has been found, insert immediately before it.
1659 if (CurNum > ArgNum)
1663 Vars.insert(I, Var);
1667 Vars.push_back(Var);
1670 // Gather and emit post-function debug information.
1671 void DwarfDebug::endFunction(const MachineFunction *MF) {
1672 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1673 // though the beginFunction may not be called at all.
1674 // We should handle both cases.
1678 assert(CurFn == MF);
1681 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1682 // If we don't have a lexical scope for this function then there will
1683 // be a hole in the range information. Keep note of this by setting the
1684 // previously used section to nullptr.
1685 PrevSection = nullptr;
1691 // Define end label for subprogram.
1692 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1693 // Assumes in correct section after the entry point.
1694 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1696 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1697 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1699 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1700 collectVariableInfo(ProcessedVars);
1702 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1703 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1704 assert(TheCU && "Unable to find compile unit!");
1706 // Construct abstract scopes.
1707 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1708 DISubprogram SP(AScope->getScopeNode());
1709 if (SP.isSubprogram()) {
1710 // Collect info for variables that were optimized out.
1711 DIArray Variables = SP.getVariables();
1712 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1713 DIVariable DV(Variables.getElement(i));
1714 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1716 // Check that DbgVariable for DV wasn't created earlier, when
1717 // findAbstractVariable() was called for inlined instance of DV.
1718 LLVMContext &Ctx = DV->getContext();
1719 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1720 if (AbstractVariables.lookup(CleanDV))
1722 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1723 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1726 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1727 constructScopeDIE(TheCU, AScope);
1730 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1731 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1732 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1734 // Add the range of this function to the list of ranges for the CU.
1735 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1736 TheCU->addRange(std::move(Span));
1737 PrevSection = Asm->getCurrentSection();
1741 for (auto &I : ScopeVariables)
1742 DeleteContainerPointers(I.second);
1743 ScopeVariables.clear();
1744 DeleteContainerPointers(CurrentFnArguments);
1745 UserVariables.clear();
1747 AbstractVariables.clear();
1748 LabelsBeforeInsn.clear();
1749 LabelsAfterInsn.clear();
1754 // Register a source line with debug info. Returns the unique label that was
1755 // emitted and which provides correspondence to the source line list.
1756 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1761 unsigned Discriminator = 0;
1763 DIDescriptor Scope(S);
1765 if (Scope.isCompileUnit()) {
1766 DICompileUnit CU(S);
1767 Fn = CU.getFilename();
1768 Dir = CU.getDirectory();
1769 } else if (Scope.isFile()) {
1771 Fn = F.getFilename();
1772 Dir = F.getDirectory();
1773 } else if (Scope.isSubprogram()) {
1775 Fn = SP.getFilename();
1776 Dir = SP.getDirectory();
1777 } else if (Scope.isLexicalBlockFile()) {
1778 DILexicalBlockFile DBF(S);
1779 Fn = DBF.getFilename();
1780 Dir = DBF.getDirectory();
1781 } else if (Scope.isLexicalBlock()) {
1782 DILexicalBlock DB(S);
1783 Fn = DB.getFilename();
1784 Dir = DB.getDirectory();
1785 Discriminator = DB.getDiscriminator();
1787 llvm_unreachable("Unexpected scope info");
1789 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1790 Src = static_cast<DwarfCompileUnit *>(InfoHolder.getUnits()[CUID])
1791 ->getOrCreateSourceID(Fn, Dir);
1793 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1797 //===----------------------------------------------------------------------===//
1799 //===----------------------------------------------------------------------===//
1801 // Compute the size and offset of a DIE. The offset is relative to start of the
1802 // CU. It returns the offset after laying out the DIE.
1803 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1804 // Record the abbreviation.
1805 assignAbbrevNumber(Die->getAbbrev());
1807 // Get the abbreviation for this DIE.
1808 const DIEAbbrev &Abbrev = Die->getAbbrev();
1811 Die->setOffset(Offset);
1813 // Start the size with the size of abbreviation code.
1814 Offset += getULEB128Size(Die->getAbbrevNumber());
1816 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1817 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1819 // Size the DIE attribute values.
1820 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1821 // Size attribute value.
1822 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1824 // Get the children.
1825 const std::vector<DIE *> &Children = Die->getChildren();
1827 // Size the DIE children if any.
1828 if (!Children.empty()) {
1829 assert(Abbrev.hasChildren() && "Children flag not set");
1831 for (DIE *Child : Children)
1832 Offset = computeSizeAndOffset(Child, Offset);
1834 // End of children marker.
1835 Offset += sizeof(int8_t);
1838 Die->setSize(Offset - Die->getOffset());
1842 // Compute the size and offset for each DIE.
1843 void DwarfFile::computeSizeAndOffsets() {
1844 // Offset from the first CU in the debug info section is 0 initially.
1845 unsigned SecOffset = 0;
1847 // Iterate over each compile unit and set the size and offsets for each
1848 // DIE within each compile unit. All offsets are CU relative.
1849 for (DwarfUnit *TheU : CUs) {
1850 TheU->setDebugInfoOffset(SecOffset);
1852 // CU-relative offset is reset to 0 here.
1853 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1854 TheU->getHeaderSize(); // Unit-specific headers
1856 // EndOffset here is CU-relative, after laying out
1857 // all of the CU DIE.
1858 unsigned EndOffset = computeSizeAndOffset(TheU->getUnitDie(), Offset);
1859 SecOffset += EndOffset;
1863 // Emit initial Dwarf sections with a label at the start of each one.
1864 void DwarfDebug::emitSectionLabels() {
1865 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1867 // Dwarf sections base addresses.
1868 DwarfInfoSectionSym =
1869 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1870 if (useSplitDwarf())
1871 DwarfInfoDWOSectionSym =
1872 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1873 DwarfAbbrevSectionSym =
1874 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1875 if (useSplitDwarf())
1876 DwarfAbbrevDWOSectionSym = emitSectionSym(
1877 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1878 if (GenerateARangeSection)
1879 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1881 DwarfLineSectionSym =
1882 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1883 if (GenerateGnuPubSections) {
1884 DwarfGnuPubNamesSectionSym =
1885 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1886 DwarfGnuPubTypesSectionSym =
1887 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1888 } else if (HasDwarfPubSections) {
1889 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1890 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1893 DwarfStrSectionSym =
1894 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1895 if (useSplitDwarf()) {
1896 DwarfStrDWOSectionSym =
1897 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1898 DwarfAddrSectionSym =
1899 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1900 DwarfDebugLocSectionSym =
1901 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1903 DwarfDebugLocSectionSym =
1904 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1905 DwarfDebugRangeSectionSym =
1906 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1909 // Recursively emits a debug information entry.
1910 void DwarfDebug::emitDIE(DIE *Die) {
1911 // Get the abbreviation for this DIE.
1912 const DIEAbbrev &Abbrev = Die->getAbbrev();
1914 // Emit the code (index) for the abbreviation.
1915 if (Asm->isVerbose())
1916 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1917 "] 0x" + Twine::utohexstr(Die->getOffset()) +
1918 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
1919 dwarf::TagString(Abbrev.getTag()));
1920 Asm->EmitULEB128(Abbrev.getNumber());
1922 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1923 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1925 // Emit the DIE attribute values.
1926 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1927 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1928 dwarf::Form Form = AbbrevData[i].getForm();
1929 assert(Form && "Too many attributes for DIE (check abbreviation)");
1931 if (Asm->isVerbose()) {
1932 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1933 if (Attr == dwarf::DW_AT_accessibility)
1934 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1935 cast<DIEInteger>(Values[i])->getValue()));
1938 // Emit an attribute using the defined form.
1939 Values[i]->EmitValue(Asm, Form);
1942 // Emit the DIE children if any.
1943 if (Abbrev.hasChildren()) {
1944 const std::vector<DIE *> &Children = Die->getChildren();
1946 for (DIE *Child : Children)
1949 Asm->OutStreamer.AddComment("End Of Children Mark");
1954 // Emit the various dwarf units to the unit section USection with
1955 // the abbreviations going into ASection.
1956 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym) {
1957 for (DwarfUnit *TheU : CUs) {
1958 DIE *Die = TheU->getUnitDie();
1959 const MCSection *USection = TheU->getSection();
1960 Asm->OutStreamer.SwitchSection(USection);
1962 // Emit the compile units header.
1963 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
1965 // Emit size of content not including length itself
1966 Asm->OutStreamer.AddComment("Length of Unit");
1967 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
1969 TheU->emitHeader(ASectionSym);
1972 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
1976 // Emit the debug info section.
1977 void DwarfDebug::emitDebugInfo() {
1978 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1980 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1983 // Emit the abbreviation section.
1984 void DwarfDebug::emitAbbreviations() {
1985 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1987 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1990 void DwarfFile::emitAbbrevs(const MCSection *Section) {
1991 // Check to see if it is worth the effort.
1992 if (!Abbreviations.empty()) {
1993 // Start the debug abbrev section.
1994 Asm->OutStreamer.SwitchSection(Section);
1996 // For each abbrevation.
1997 for (const DIEAbbrev *Abbrev : Abbreviations) {
1998 // Emit the abbrevations code (base 1 index.)
1999 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2001 // Emit the abbreviations data.
2005 // Mark end of abbreviations.
2006 Asm->EmitULEB128(0, "EOM(3)");
2010 // Emit the last address of the section and the end of the line matrix.
2011 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2012 // Define last address of section.
2013 Asm->OutStreamer.AddComment("Extended Op");
2016 Asm->OutStreamer.AddComment("Op size");
2017 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2018 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2019 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2021 Asm->OutStreamer.AddComment("Section end label");
2023 Asm->OutStreamer.EmitSymbolValue(
2024 Asm->GetTempSymbol("section_end", SectionEnd),
2025 Asm->getDataLayout().getPointerSize());
2027 // Mark end of matrix.
2028 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2034 // Emit visible names into a hashed accelerator table section.
2035 void DwarfDebug::emitAccelNames() {
2037 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2038 for (DwarfUnit *TheU : getUnits()) {
2039 for (const auto &GI : TheU->getAccelNames()) {
2040 StringRef Name = GI.getKey();
2041 for (const DIE *D : GI.second)
2042 AT.AddName(Name, D);
2046 AT.FinalizeTable(Asm, "Names");
2047 Asm->OutStreamer.SwitchSection(
2048 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2049 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2050 Asm->OutStreamer.EmitLabel(SectionBegin);
2052 // Emit the full data.
2053 AT.Emit(Asm, SectionBegin, &InfoHolder);
2056 // Emit objective C classes and categories into a hashed accelerator table
2058 void DwarfDebug::emitAccelObjC() {
2060 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2061 for (DwarfUnit *TheU : getUnits()) {
2062 for (const auto &GI : TheU->getAccelObjC()) {
2063 StringRef Name = GI.getKey();
2064 for (const DIE *D : GI.second)
2065 AT.AddName(Name, D);
2069 AT.FinalizeTable(Asm, "ObjC");
2070 Asm->OutStreamer.SwitchSection(
2071 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2072 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2073 Asm->OutStreamer.EmitLabel(SectionBegin);
2075 // Emit the full data.
2076 AT.Emit(Asm, SectionBegin, &InfoHolder);
2079 // Emit namespace dies into a hashed accelerator table.
2080 void DwarfDebug::emitAccelNamespaces() {
2082 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2083 for (DwarfUnit *TheU : getUnits()) {
2084 for (const auto &GI : TheU->getAccelNamespace()) {
2085 StringRef Name = GI.getKey();
2086 for (const DIE *D : GI.second)
2087 AT.AddName(Name, D);
2091 AT.FinalizeTable(Asm, "namespac");
2092 Asm->OutStreamer.SwitchSection(
2093 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2094 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2095 Asm->OutStreamer.EmitLabel(SectionBegin);
2097 // Emit the full data.
2098 AT.Emit(Asm, SectionBegin, &InfoHolder);
2101 // Emit type dies into a hashed accelerator table.
2102 void DwarfDebug::emitAccelTypes() {
2103 std::vector<DwarfAccelTable::Atom> Atoms;
2105 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2107 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2109 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2110 DwarfAccelTable AT(Atoms);
2111 for (DwarfUnit *TheU : getUnits()) {
2112 for (const auto &GI : TheU->getAccelTypes()) {
2113 StringRef Name = GI.getKey();
2114 for (const auto &DI : GI.second)
2115 AT.AddName(Name, DI.first, DI.second);
2119 AT.FinalizeTable(Asm, "types");
2120 Asm->OutStreamer.SwitchSection(
2121 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2122 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2123 Asm->OutStreamer.EmitLabel(SectionBegin);
2125 // Emit the full data.
2126 AT.Emit(Asm, SectionBegin, &InfoHolder);
2129 // Public name handling.
2130 // The format for the various pubnames:
2132 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2133 // for the DIE that is named.
2135 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2136 // into the CU and the index value is computed according to the type of value
2137 // for the DIE that is named.
2139 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2140 // it's the offset within the debug_info/debug_types dwo section, however, the
2141 // reference in the pubname header doesn't change.
2143 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2144 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2146 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2148 // We could have a specification DIE that has our most of our knowledge,
2149 // look for that now.
2150 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2152 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2153 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2154 Linkage = dwarf::GIEL_EXTERNAL;
2155 } else if (Die->findAttribute(dwarf::DW_AT_external))
2156 Linkage = dwarf::GIEL_EXTERNAL;
2158 switch (Die->getTag()) {
2159 case dwarf::DW_TAG_class_type:
2160 case dwarf::DW_TAG_structure_type:
2161 case dwarf::DW_TAG_union_type:
2162 case dwarf::DW_TAG_enumeration_type:
2163 return dwarf::PubIndexEntryDescriptor(
2164 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2165 ? dwarf::GIEL_STATIC
2166 : dwarf::GIEL_EXTERNAL);
2167 case dwarf::DW_TAG_typedef:
2168 case dwarf::DW_TAG_base_type:
2169 case dwarf::DW_TAG_subrange_type:
2170 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2171 case dwarf::DW_TAG_namespace:
2172 return dwarf::GIEK_TYPE;
2173 case dwarf::DW_TAG_subprogram:
2174 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2175 case dwarf::DW_TAG_constant:
2176 case dwarf::DW_TAG_variable:
2177 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2178 case dwarf::DW_TAG_enumerator:
2179 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2180 dwarf::GIEL_STATIC);
2182 return dwarf::GIEK_NONE;
2186 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2188 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2189 const MCSection *PSec =
2190 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2191 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2193 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2196 void DwarfDebug::emitDebugPubSection(
2197 bool GnuStyle, const MCSection *PSec, StringRef Name,
2198 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
2199 for (const auto &NU : CUMap) {
2200 DwarfCompileUnit *TheU = NU.second;
2202 const auto &Globals = (TheU->*Accessor)();
2204 if (Globals.empty())
2207 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2209 unsigned ID = TheU->getUniqueID();
2211 // Start the dwarf pubnames section.
2212 Asm->OutStreamer.SwitchSection(PSec);
2215 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2216 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2217 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2218 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2220 Asm->OutStreamer.EmitLabel(BeginLabel);
2222 Asm->OutStreamer.AddComment("DWARF Version");
2223 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2225 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2226 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2228 Asm->OutStreamer.AddComment("Compilation Unit Length");
2229 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2231 // Emit the pubnames for this compilation unit.
2232 for (const auto &GI : Globals) {
2233 const char *Name = GI.getKeyData();
2234 const DIE *Entity = GI.second;
2236 Asm->OutStreamer.AddComment("DIE offset");
2237 Asm->EmitInt32(Entity->getOffset());
2240 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2241 Asm->OutStreamer.AddComment(
2242 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2243 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2244 Asm->EmitInt8(Desc.toBits());
2247 Asm->OutStreamer.AddComment("External Name");
2248 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2251 Asm->OutStreamer.AddComment("End Mark");
2253 Asm->OutStreamer.EmitLabel(EndLabel);
2257 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2258 const MCSection *PSec =
2259 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2260 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2262 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2265 // Emit strings into a string section.
2266 void DwarfFile::emitStrings(const MCSection *StrSection,
2267 const MCSection *OffsetSection = NULL,
2268 const MCSymbol *StrSecSym = NULL) {
2270 if (StringPool.empty())
2273 // Start the dwarf str section.
2274 Asm->OutStreamer.SwitchSection(StrSection);
2276 // Get all of the string pool entries and put them in an array by their ID so
2277 // we can sort them.
2278 SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
2280 for (const auto &I : StringPool)
2281 Entries.push_back(std::make_pair(I.second.second, &I));
2283 array_pod_sort(Entries.begin(), Entries.end());
2285 for (const auto &Entry : Entries) {
2286 // Emit a label for reference from debug information entries.
2287 Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
2289 // Emit the string itself with a terminating null byte.
2290 Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
2291 Entry.second->getKeyLength() + 1));
2294 // If we've got an offset section go ahead and emit that now as well.
2295 if (OffsetSection) {
2296 Asm->OutStreamer.SwitchSection(OffsetSection);
2297 unsigned offset = 0;
2298 unsigned size = 4; // FIXME: DWARF64 is 8.
2299 for (const auto &Entry : Entries) {
2300 Asm->OutStreamer.EmitIntValue(offset, size);
2301 offset += Entry.second->getKeyLength() + 1;
2306 // Emit addresses into the section given.
2307 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2309 if (AddressPool.empty())
2312 // Start the dwarf addr section.
2313 Asm->OutStreamer.SwitchSection(AddrSection);
2315 // Order the address pool entries by ID
2316 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2318 for (const auto &I : AddressPool)
2319 Entries[I.second.Number] =
2321 ? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
2322 : MCSymbolRefExpr::Create(I.first, Asm->OutContext);
2324 for (const MCExpr *Entry : Entries)
2325 Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
2328 // Emit visible names into a debug str section.
2329 void DwarfDebug::emitDebugStr() {
2330 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2331 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2334 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2335 const DebugLocEntry &Entry) {
2336 DIVariable DV(Entry.getVariable());
2337 if (Entry.isInt()) {
2338 DIBasicType BTy(resolve(DV.getType()));
2339 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2340 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2341 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2342 Streamer.EmitSLEB128(Entry.getInt());
2344 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2345 Streamer.EmitULEB128(Entry.getInt());
2347 } else if (Entry.isLocation()) {
2348 MachineLocation Loc = Entry.getLoc();
2349 if (!DV.hasComplexAddress())
2351 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2353 // Complex address entry.
2354 unsigned N = DV.getNumAddrElements();
2356 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2357 if (Loc.getOffset()) {
2359 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2360 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2361 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2362 Streamer.EmitSLEB128(DV.getAddrElement(1));
2364 // If first address element is OpPlus then emit
2365 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2366 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2367 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2371 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2374 // Emit remaining complex address elements.
2375 for (; i < N; ++i) {
2376 uint64_t Element = DV.getAddrElement(i);
2377 if (Element == DIBuilder::OpPlus) {
2378 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2379 Streamer.EmitULEB128(DV.getAddrElement(++i));
2380 } else if (Element == DIBuilder::OpDeref) {
2382 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2384 llvm_unreachable("unknown Opcode found in complex address");
2388 // else ... ignore constant fp. There is not any good way to
2389 // to represent them here in dwarf.
2393 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2394 Asm->OutStreamer.AddComment("Loc expr size");
2395 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2396 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2397 Asm->EmitLabelDifference(end, begin, 2);
2398 Asm->OutStreamer.EmitLabel(begin);
2400 APByteStreamer Streamer(*Asm);
2401 emitDebugLocEntry(Streamer, Entry);
2403 Asm->OutStreamer.EmitLabel(end);
2406 // Emit locations into the debug loc section.
2407 void DwarfDebug::emitDebugLoc() {
2408 // Start the dwarf loc section.
2409 Asm->OutStreamer.SwitchSection(
2410 Asm->getObjFileLowering().getDwarfLocSection());
2411 unsigned char Size = Asm->getDataLayout().getPointerSize();
2412 for (const auto &DebugLoc : DotDebugLocEntries) {
2413 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2414 for (const auto &Entry : DebugLoc.List) {
2415 // Set up the range. This range is relative to the entry point of the
2416 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2417 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2418 const DwarfCompileUnit *CU = Entry.getCU();
2419 if (CU->getRanges().size() == 1) {
2420 // Grab the begin symbol from the first range as our base.
2421 const MCSymbol *Base = CU->getRanges()[0].getStart();
2422 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2423 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2425 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2426 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2429 emitDebugLocEntryLocation(Entry);
2431 Asm->OutStreamer.EmitIntValue(0, Size);
2432 Asm->OutStreamer.EmitIntValue(0, Size);
2436 void DwarfDebug::emitDebugLocDWO() {
2437 Asm->OutStreamer.SwitchSection(
2438 Asm->getObjFileLowering().getDwarfLocDWOSection());
2439 for (const auto &DebugLoc : DotDebugLocEntries) {
2440 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2441 for (const auto &Entry : DebugLoc.List) {
2442 // Just always use start_length for now - at least that's one address
2443 // rather than two. We could get fancier and try to, say, reuse an
2444 // address we know we've emitted elsewhere (the start of the function?
2445 // The start of the CU or CU subrange that encloses this range?)
2446 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2447 unsigned idx = InfoHolder.getAddrPoolIndex(Entry.getBeginSym());
2448 Asm->EmitULEB128(idx);
2449 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2451 emitDebugLocEntryLocation(Entry);
2453 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2458 const MCSymbol *Start, *End;
2461 // Emit a debug aranges section, containing a CU lookup for any
2462 // address we can tie back to a CU.
2463 void DwarfDebug::emitDebugARanges() {
2464 // Start the dwarf aranges section.
2465 Asm->OutStreamer.SwitchSection(
2466 Asm->getObjFileLowering().getDwarfARangesSection());
2468 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2472 // Build a list of sections used.
2473 std::vector<const MCSection *> Sections;
2474 for (const auto &it : SectionMap) {
2475 const MCSection *Section = it.first;
2476 Sections.push_back(Section);
2479 // Sort the sections into order.
2480 // This is only done to ensure consistent output order across different runs.
2481 std::sort(Sections.begin(), Sections.end(), SectionSort);
2483 // Build a set of address spans, sorted by CU.
2484 for (const MCSection *Section : Sections) {
2485 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2486 if (List.size() < 2)
2489 // Sort the symbols by offset within the section.
2490 std::sort(List.begin(), List.end(),
2491 [&](const SymbolCU &A, const SymbolCU &B) {
2492 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2493 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2495 // Symbols with no order assigned should be placed at the end.
2496 // (e.g. section end labels)
2504 // If we have no section (e.g. common), just write out
2505 // individual spans for each symbol.
2506 if (Section == NULL) {
2507 for (const SymbolCU &Cur : List) {
2509 Span.Start = Cur.Sym;
2512 Spans[Cur.CU].push_back(Span);
2515 // Build spans between each label.
2516 const MCSymbol *StartSym = List[0].Sym;
2517 for (size_t n = 1, e = List.size(); n < e; n++) {
2518 const SymbolCU &Prev = List[n - 1];
2519 const SymbolCU &Cur = List[n];
2521 // Try and build the longest span we can within the same CU.
2522 if (Cur.CU != Prev.CU) {
2524 Span.Start = StartSym;
2526 Spans[Prev.CU].push_back(Span);
2533 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2535 // Build a list of CUs used.
2536 std::vector<DwarfCompileUnit *> CUs;
2537 for (const auto &it : Spans) {
2538 DwarfCompileUnit *CU = it.first;
2542 // Sort the CU list (again, to ensure consistent output order).
2543 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2544 return A->getUniqueID() < B->getUniqueID();
2547 // Emit an arange table for each CU we used.
2548 for (DwarfCompileUnit *CU : CUs) {
2549 std::vector<ArangeSpan> &List = Spans[CU];
2551 // Emit size of content not including length itself.
2552 unsigned ContentSize =
2553 sizeof(int16_t) + // DWARF ARange version number
2554 sizeof(int32_t) + // Offset of CU in the .debug_info section
2555 sizeof(int8_t) + // Pointer Size (in bytes)
2556 sizeof(int8_t); // Segment Size (in bytes)
2558 unsigned TupleSize = PtrSize * 2;
2560 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2562 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2564 ContentSize += Padding;
2565 ContentSize += (List.size() + 1) * TupleSize;
2567 // For each compile unit, write the list of spans it covers.
2568 Asm->OutStreamer.AddComment("Length of ARange Set");
2569 Asm->EmitInt32(ContentSize);
2570 Asm->OutStreamer.AddComment("DWARF Arange version number");
2571 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2572 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2573 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2574 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2575 Asm->EmitInt8(PtrSize);
2576 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2579 Asm->OutStreamer.EmitFill(Padding, 0xff);
2581 for (const ArangeSpan &Span : List) {
2582 Asm->EmitLabelReference(Span.Start, PtrSize);
2584 // Calculate the size as being from the span start to it's end.
2586 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2588 // For symbols without an end marker (e.g. common), we
2589 // write a single arange entry containing just that one symbol.
2590 uint64_t Size = SymSize[Span.Start];
2594 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2598 Asm->OutStreamer.AddComment("ARange terminator");
2599 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2600 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2604 // Emit visible names into a debug ranges section.
2605 void DwarfDebug::emitDebugRanges() {
2606 // Start the dwarf ranges section.
2607 Asm->OutStreamer.SwitchSection(
2608 Asm->getObjFileLowering().getDwarfRangesSection());
2610 // Size for our labels.
2611 unsigned char Size = Asm->getDataLayout().getPointerSize();
2613 // Grab the specific ranges for the compile units in the module.
2614 for (const auto &I : CUMap) {
2615 DwarfCompileUnit *TheCU = I.second;
2617 // Emit a symbol so we can find the beginning of our ranges.
2618 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2620 // Iterate over the misc ranges for the compile units in the module.
2621 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2622 // Emit our symbol so we can find the beginning of the range.
2623 Asm->OutStreamer.EmitLabel(List.getSym());
2625 for (const RangeSpan &Range : List.getRanges()) {
2626 const MCSymbol *Begin = Range.getStart();
2627 const MCSymbol *End = Range.getEnd();
2628 assert(Begin && "Range without a begin symbol?");
2629 assert(End && "Range without an end symbol?");
2630 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2631 Asm->OutStreamer.EmitSymbolValue(End, Size);
2634 // And terminate the list with two 0 values.
2635 Asm->OutStreamer.EmitIntValue(0, Size);
2636 Asm->OutStreamer.EmitIntValue(0, Size);
2639 // Now emit a range for the CU itself.
2640 if (TheCU->getRanges().size() > 1) {
2641 Asm->OutStreamer.EmitLabel(
2642 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2643 for (const RangeSpan &Range : TheCU->getRanges()) {
2644 const MCSymbol *Begin = Range.getStart();
2645 const MCSymbol *End = Range.getEnd();
2646 assert(Begin && "Range without a begin symbol?");
2647 assert(End && "Range without an end symbol?");
2648 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2649 Asm->OutStreamer.EmitSymbolValue(End, Size);
2651 // And terminate the list with two 0 values.
2652 Asm->OutStreamer.EmitIntValue(0, Size);
2653 Asm->OutStreamer.EmitIntValue(0, Size);
2658 // DWARF5 Experimental Separate Dwarf emitters.
2660 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2662 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2663 U->getCUNode().getSplitDebugFilename());
2665 if (!CompilationDir.empty())
2666 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2668 addGnuPubAttributes(NewU, Die);
2670 SkeletonHolder.addUnit(NewU);
2673 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2674 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2675 // DW_AT_addr_base, DW_AT_ranges_base.
2676 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2678 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2679 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2680 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2681 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2682 DwarfInfoSectionSym);
2684 NewCU->initStmtList(DwarfLineSectionSym);
2686 initSkeletonUnit(CU, Die, NewCU);
2691 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2693 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
2694 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2695 *SkeletonHolder.getUnits()[TU->getCU().getUniqueID()]);
2697 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2698 DwarfTypeUnit *NewTU =
2699 new DwarfTypeUnit(TU->getUniqueID(), Die, CU, Asm, this, &SkeletonHolder);
2700 NewTU->setTypeSignature(TU->getTypeSignature());
2701 NewTU->setType(NULL);
2703 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2705 initSkeletonUnit(TU, Die, NewTU);
2709 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2710 // compile units that would normally be in debug_info.
2711 void DwarfDebug::emitDebugInfoDWO() {
2712 assert(useSplitDwarf() && "No split dwarf debug info?");
2713 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2714 // emit relocations into the dwo file.
2715 InfoHolder.emitUnits(this, /* AbbrevSymbol */nullptr);
2718 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2719 // abbreviations for the .debug_info.dwo section.
2720 void DwarfDebug::emitDebugAbbrevDWO() {
2721 assert(useSplitDwarf() && "No split dwarf?");
2722 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2725 void DwarfDebug::emitDebugLineDWO() {
2726 assert(useSplitDwarf() && "No split dwarf?");
2727 Asm->OutStreamer.SwitchSection(
2728 Asm->getObjFileLowering().getDwarfLineDWOSection());
2729 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2732 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2733 // string section and is identical in format to traditional .debug_str
2735 void DwarfDebug::emitDebugStrDWO() {
2736 assert(useSplitDwarf() && "No split dwarf?");
2737 const MCSection *OffSec =
2738 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2739 const MCSymbol *StrSym = DwarfStrSectionSym;
2740 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2744 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2745 if (!useSplitDwarf())
2748 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2749 return &SplitTypeUnitFileTable;
2752 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2753 StringRef Identifier, DIE *RefDie,
2754 DICompositeType CTy) {
2755 // Flag the type unit reference as a declaration so that if it contains
2756 // members (implicit special members, static data member definitions, member
2757 // declarations for definitions in this CU, etc) consumers don't get confused
2758 // and think this is a full definition.
2759 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2761 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2763 CU.addDIETypeSignature(RefDie, *TU);
2767 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2768 DwarfTypeUnit *NewTU =
2769 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, CU, Asm, this,
2770 &InfoHolder, getDwoLineTable(CU));
2772 InfoHolder.addUnit(NewTU);
2774 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2778 Hash.update(Identifier);
2779 // ... take the least significant 8 bytes and return those. Our MD5
2780 // implementation always returns its results in little endian, swap bytes
2782 MD5::MD5Result Result;
2784 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2785 NewTU->setTypeSignature(Signature);
2786 if (useSplitDwarf())
2787 NewTU->setSkeleton(constructSkeletonTU(NewTU));
2789 CU.applyStmtList(*UnitDie);
2791 NewTU->setType(NewTU->createTypeDIE(CTy));
2795 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2796 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2798 CU.addDIETypeSignature(RefDie, *NewTU);
2801 void DwarfDebug::attachLowHighPC(DwarfCompileUnit *Unit, DIE *D,
2802 MCSymbol *Begin, MCSymbol *End) {
2803 Unit->addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2804 if (DwarfVersion < 4)
2805 Unit->addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2807 Unit->addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);