1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #include "ByteStreamer.h"
15 #include "DwarfDebug.h"
18 #include "DwarfUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DIBuilder.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/ValueHandle.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/Endian.h"
40 #include "llvm/Support/ErrorHandling.h"
41 #include "llvm/Support/FormattedStream.h"
42 #include "llvm/Support/LEB128.h"
43 #include "llvm/Support/MD5.h"
44 #include "llvm/Support/Path.h"
45 #include "llvm/Support/Timer.h"
46 #include "llvm/Target/TargetFrameLowering.h"
47 #include "llvm/Target/TargetLoweringObjectFile.h"
48 #include "llvm/Target/TargetMachine.h"
49 #include "llvm/Target/TargetOptions.h"
50 #include "llvm/Target/TargetRegisterInfo.h"
53 #define DEBUG_TYPE "dwarfdebug"
56 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
57 cl::desc("Disable debug info printing"));
59 static cl::opt<bool> UnknownLocations(
60 "use-unknown-locations", cl::Hidden,
61 cl::desc("Make an absence of debug location information explicit."),
65 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
66 cl::desc("Generate GNU-style pubnames and pubtypes"),
69 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
71 cl::desc("Generate dwarf aranges"),
75 enum DefaultOnOff { Default, Enable, Disable };
78 static cl::opt<DefaultOnOff>
79 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
80 cl::desc("Output prototype dwarf accelerator tables."),
81 cl::values(clEnumVal(Default, "Default for platform"),
82 clEnumVal(Enable, "Enabled"),
83 clEnumVal(Disable, "Disabled"), clEnumValEnd),
86 static cl::opt<DefaultOnOff>
87 SplitDwarf("split-dwarf", cl::Hidden,
88 cl::desc("Output DWARF5 split debug info."),
89 cl::values(clEnumVal(Default, "Default for platform"),
90 clEnumVal(Enable, "Enabled"),
91 clEnumVal(Disable, "Disabled"), clEnumValEnd),
94 static cl::opt<DefaultOnOff>
95 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
96 cl::desc("Generate DWARF pubnames and pubtypes sections"),
97 cl::values(clEnumVal(Default, "Default for platform"),
98 clEnumVal(Enable, "Enabled"),
99 clEnumVal(Disable, "Disabled"), clEnumValEnd),
102 static const char *const DWARFGroupName = "DWARF Emission";
103 static const char *const DbgTimerName = "DWARF Debug Writer";
105 //===----------------------------------------------------------------------===//
107 /// resolve - Look in the DwarfDebug map for the MDNode that
108 /// corresponds to the reference.
109 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
110 return DD->resolve(Ref);
113 bool DbgVariable::isBlockByrefVariable() const {
114 assert(Var.isVariable() && "Invalid complex DbgVariable!");
115 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
118 DIType DbgVariable::getType() const {
119 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
120 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
121 // addresses instead.
122 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
123 /* Byref variables, in Blocks, are declared by the programmer as
124 "SomeType VarName;", but the compiler creates a
125 __Block_byref_x_VarName struct, and gives the variable VarName
126 either the struct, or a pointer to the struct, as its type. This
127 is necessary for various behind-the-scenes things the compiler
128 needs to do with by-reference variables in blocks.
130 However, as far as the original *programmer* is concerned, the
131 variable should still have type 'SomeType', as originally declared.
133 The following function dives into the __Block_byref_x_VarName
134 struct to find the original type of the variable. This will be
135 passed back to the code generating the type for the Debug
136 Information Entry for the variable 'VarName'. 'VarName' will then
137 have the original type 'SomeType' in its debug information.
139 The original type 'SomeType' will be the type of the field named
140 'VarName' inside the __Block_byref_x_VarName struct.
142 NOTE: In order for this to not completely fail on the debugger
143 side, the Debug Information Entry for the variable VarName needs to
144 have a DW_AT_location that tells the debugger how to unwind through
145 the pointers and __Block_byref_x_VarName struct to find the actual
146 value of the variable. The function addBlockByrefType does this. */
148 uint16_t tag = Ty.getTag();
150 if (tag == dwarf::DW_TAG_pointer_type)
151 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
153 DIArray Elements = DICompositeType(subType).getElements();
154 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
155 DIDerivedType DT(Elements.getElement(i));
156 if (getName() == DT.getName())
157 return (resolve(DT.getTypeDerivedFrom()));
163 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
164 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
165 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
166 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
168 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
169 : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
170 GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
171 UsedNonDefaultText(false),
172 SkeletonHolder(A, "skel_string", DIEValueAllocator),
173 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
174 dwarf::DW_FORM_data4)),
175 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
176 dwarf::DW_FORM_data4)),
177 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
178 dwarf::DW_FORM_data4)),
179 AccelTypes(TypeAtoms) {
181 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
182 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
183 DwarfLineSectionSym = nullptr;
184 DwarfAddrSectionSym = nullptr;
185 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
186 FunctionBeginSym = FunctionEndSym = nullptr;
190 // Turn on accelerator tables for Darwin by default, pubnames by
191 // default for non-Darwin, and handle split dwarf.
192 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
194 if (DwarfAccelTables == Default)
195 HasDwarfAccelTables = IsDarwin;
197 HasDwarfAccelTables = DwarfAccelTables == Enable;
199 if (SplitDwarf == Default)
200 HasSplitDwarf = false;
202 HasSplitDwarf = SplitDwarf == Enable;
204 if (DwarfPubSections == Default)
205 HasDwarfPubSections = !IsDarwin;
207 HasDwarfPubSections = DwarfPubSections == Enable;
209 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
210 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
211 : MMI->getModule()->getDwarfVersion();
213 Asm->OutStreamer.getContext().setDwarfVersion(DwarfVersion);
216 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
221 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
222 DwarfDebug::~DwarfDebug() { }
224 // Switch to the specified MCSection and emit an assembler
225 // temporary label to it if SymbolStem is specified.
226 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
227 const char *SymbolStem = nullptr) {
228 Asm->OutStreamer.SwitchSection(Section);
232 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
233 Asm->OutStreamer.EmitLabel(TmpSym);
237 static bool isObjCClass(StringRef Name) {
238 return Name.startswith("+") || Name.startswith("-");
241 static bool hasObjCCategory(StringRef Name) {
242 if (!isObjCClass(Name))
245 return Name.find(") ") != StringRef::npos;
248 static void getObjCClassCategory(StringRef In, StringRef &Class,
249 StringRef &Category) {
250 if (!hasObjCCategory(In)) {
251 Class = In.slice(In.find('[') + 1, In.find(' '));
256 Class = In.slice(In.find('[') + 1, In.find('('));
257 Category = In.slice(In.find('[') + 1, In.find(' '));
261 static StringRef getObjCMethodName(StringRef In) {
262 return In.slice(In.find(' ') + 1, In.find(']'));
265 // Helper for sorting sections into a stable output order.
266 static bool SectionSort(const MCSection *A, const MCSection *B) {
267 std::string LA = (A ? A->getLabelBeginName() : "");
268 std::string LB = (B ? B->getLabelBeginName() : "");
272 // Add the various names to the Dwarf accelerator table names.
273 // TODO: Determine whether or not we should add names for programs
274 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
275 // is only slightly different than the lookup of non-standard ObjC names.
276 void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
277 if (!SP.isDefinition())
279 addAccelName(SP.getName(), Die);
281 // If the linkage name is different than the name, go ahead and output
282 // that as well into the name table.
283 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
284 addAccelName(SP.getLinkageName(), Die);
286 // If this is an Objective-C selector name add it to the ObjC accelerator
288 if (isObjCClass(SP.getName())) {
289 StringRef Class, Category;
290 getObjCClassCategory(SP.getName(), Class, Category);
291 addAccelObjC(Class, Die);
293 addAccelObjC(Category, Die);
294 // Also add the base method name to the name table.
295 addAccelName(getObjCMethodName(SP.getName()), Die);
299 /// isSubprogramContext - Return true if Context is either a subprogram
300 /// or another context nested inside a subprogram.
301 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
304 DIDescriptor D(Context);
305 if (D.isSubprogram())
308 return isSubprogramContext(resolve(DIType(Context).getContext()));
312 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
313 // and DW_AT_high_pc attributes. If there are global variables in this
314 // scope then create and insert DIEs for these variables.
315 DIE &DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit &SPCU,
317 DIE *SPDie = SPCU.getOrCreateSubprogramDIE(SP);
319 attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
321 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
322 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
323 SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
325 // Add name to the name table, we do this here because we're guaranteed
326 // to have concrete versions of our DW_TAG_subprogram nodes.
327 addSubprogramNames(SP, *SPDie);
332 /// Check whether we should create a DIE for the given Scope, return true
333 /// if we don't create a DIE (the corresponding DIE is null).
334 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
335 if (Scope->isAbstractScope())
338 // We don't create a DIE if there is no Range.
339 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
343 if (Ranges.size() > 1)
346 // We don't create a DIE if we have a single Range and the end label
348 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
349 MCSymbol *End = getLabelAfterInsn(RI->second);
353 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
354 dwarf::Attribute A, const MCSymbol *L,
355 const MCSymbol *Sec) {
356 if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
357 U.addSectionLabel(D, A, L);
359 U.addSectionDelta(D, A, L, Sec);
362 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
363 const SmallVectorImpl<InsnRange> &Range) {
364 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
365 // emitting it appropriately.
366 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
368 // Under fission, ranges are specified by constant offsets relative to the
369 // CU's DW_AT_GNU_ranges_base.
371 TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
372 DwarfDebugRangeSectionSym);
374 addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
375 DwarfDebugRangeSectionSym);
377 RangeSpanList List(RangeSym);
378 for (const InsnRange &R : Range) {
379 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
380 List.addRange(std::move(Span));
383 // Add the range list to the set of ranges to be emitted.
384 TheCU.addRangeList(std::move(List));
387 void DwarfDebug::attachRangesOrLowHighPC(DwarfCompileUnit &TheCU, DIE &Die,
388 const SmallVectorImpl<InsnRange> &Ranges) {
389 assert(!Ranges.empty());
390 if (Ranges.size() == 1)
391 attachLowHighPC(TheCU, Die, getLabelBeforeInsn(Ranges.front().first),
392 getLabelAfterInsn(Ranges.front().second));
394 addScopeRangeList(TheCU, Die, Ranges);
397 // Construct new DW_TAG_lexical_block for this scope and attach
398 // DW_AT_low_pc/DW_AT_high_pc labels.
400 DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
401 LexicalScope *Scope) {
402 if (isLexicalScopeDIENull(Scope))
405 auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
406 if (Scope->isAbstractScope())
409 attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
414 // This scope represents inlined body of a function. Construct DIE to
415 // represent this concrete inlined copy of the function.
417 DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
418 LexicalScope *Scope) {
419 assert(Scope->getScopeNode());
420 DIScope DS(Scope->getScopeNode());
421 DISubprogram InlinedSP = getDISubprogram(DS);
422 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
423 // was inlined from another compile unit.
424 DIE *OriginDIE = AbstractSPDies[InlinedSP];
425 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
427 auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
428 TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
430 attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
432 InlinedSubprogramDIEs.insert(OriginDIE);
434 // Add the call site information to the DIE.
435 DILocation DL(Scope->getInlinedAt());
436 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
437 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
438 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
440 // Add name to the name table, we do this here because we're guaranteed
441 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
442 addSubprogramNames(InlinedSP, *ScopeDIE);
447 static std::unique_ptr<DIE> constructVariableDIE(DwarfCompileUnit &TheCU,
449 const LexicalScope &Scope,
450 DIE *&ObjectPointer) {
451 auto Var = TheCU.constructVariableDIE(DV, Scope.isAbstractScope());
452 if (DV.isObjectPointer())
453 ObjectPointer = Var.get();
457 DIE *DwarfDebug::createScopeChildrenDIE(
458 DwarfCompileUnit &TheCU, LexicalScope *Scope,
459 SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
460 DIE *ObjectPointer = nullptr;
462 // Collect arguments for current function.
463 if (LScopes.isCurrentFunctionScope(Scope)) {
464 for (DbgVariable *ArgDV : CurrentFnArguments)
467 constructVariableDIE(TheCU, *ArgDV, *Scope, ObjectPointer));
469 // If this is a variadic function, add an unspecified parameter.
470 DISubprogram SP(Scope->getScopeNode());
471 DITypeArray FnArgs = SP.getType().getTypeArray();
472 // If we have a single element of null, it is a function that returns void.
473 // If we have more than one elements and the last one is null, it is a
474 // variadic function.
475 if (FnArgs.getNumElements() > 1 &&
476 !FnArgs.getElement(FnArgs.getNumElements() - 1))
478 make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
481 // Collect lexical scope children first.
482 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
483 Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
485 for (LexicalScope *LS : Scope->getChildren())
486 if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
487 Children.push_back(std::move(Nested));
488 return ObjectPointer;
491 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
492 LexicalScope *Scope, DIE &ScopeDIE) {
493 // We create children when the scope DIE is not null.
494 SmallVector<std::unique_ptr<DIE>, 8> Children;
495 if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
496 TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
499 for (auto &I : Children)
500 ScopeDIE.addChild(std::move(I));
503 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
504 LexicalScope *Scope) {
505 assert(Scope && Scope->getScopeNode());
506 assert(Scope->isAbstractScope());
507 assert(!Scope->getInlinedAt());
509 DISubprogram SP(Scope->getScopeNode());
511 ProcessedSPNodes.insert(SP);
513 DIE *&AbsDef = AbstractSPDies[SP];
517 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
518 // was inlined from another compile unit.
519 DwarfCompileUnit &SPCU = *SPMap[SP];
522 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
523 // the important distinction that the DIDescriptor is not associated with the
524 // DIE (since the DIDescriptor will be associated with the concrete DIE, if
525 // any). It could be refactored to some common utility function.
526 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
527 ContextDIE = &SPCU.getUnitDie();
528 SPCU.getOrCreateSubprogramDIE(SPDecl);
530 ContextDIE = SPCU.getOrCreateContextDIE(resolve(SP.getContext()));
532 // Passing null as the associated DIDescriptor because the abstract definition
533 // shouldn't be found by lookup.
534 AbsDef = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE,
536 SPCU.applySubprogramAttributesToDefinition(SP, *AbsDef);
538 SPCU.addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
539 createAndAddScopeChildren(SPCU, Scope, *AbsDef);
542 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
543 LexicalScope *Scope) {
544 assert(Scope && Scope->getScopeNode());
545 assert(!Scope->getInlinedAt());
546 assert(!Scope->isAbstractScope());
547 DISubprogram Sub(Scope->getScopeNode());
549 assert(Sub.isSubprogram());
551 ProcessedSPNodes.insert(Sub);
553 DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
555 createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
560 // Construct a DIE for this scope.
561 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
562 LexicalScope *Scope) {
563 if (!Scope || !Scope->getScopeNode())
566 DIScope DS(Scope->getScopeNode());
568 assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
569 "Only handle inlined subprograms here, use "
570 "constructSubprogramScopeDIE for non-inlined "
573 SmallVector<std::unique_ptr<DIE>, 8> Children;
575 // We try to create the scope DIE first, then the children DIEs. This will
576 // avoid creating un-used children then removing them later when we find out
577 // the scope DIE is null.
578 std::unique_ptr<DIE> ScopeDIE;
579 if (Scope->getParent() && DS.isSubprogram()) {
580 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
583 // We create children when the scope DIE is not null.
584 createScopeChildrenDIE(TheCU, Scope, Children);
586 // Early exit when we know the scope DIE is going to be null.
587 if (isLexicalScopeDIENull(Scope))
590 // We create children here when we know the scope DIE is not going to be
591 // null and the children will be added to the scope DIE.
592 createScopeChildrenDIE(TheCU, Scope, Children);
594 // There is no need to emit empty lexical block DIE.
595 std::pair<ImportedEntityMap::const_iterator,
596 ImportedEntityMap::const_iterator> Range =
597 std::equal_range(ScopesWithImportedEntities.begin(),
598 ScopesWithImportedEntities.end(),
599 std::pair<const MDNode *, const MDNode *>(DS, nullptr),
601 if (Children.empty() && Range.first == Range.second)
603 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
604 assert(ScopeDIE && "Scope DIE should not be null.");
605 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
607 constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
611 for (auto &I : Children)
612 ScopeDIE->addChild(std::move(I));
617 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
618 if (!GenerateGnuPubSections)
621 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
624 // Create new DwarfCompileUnit for the given metadata node with tag
625 // DW_TAG_compile_unit.
626 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
627 StringRef FN = DIUnit.getFilename();
628 CompilationDir = DIUnit.getDirectory();
630 auto OwnedUnit = make_unique<DwarfCompileUnit>(
631 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
632 DwarfCompileUnit &NewCU = *OwnedUnit;
633 DIE &Die = NewCU.getUnitDie();
634 InfoHolder.addUnit(std::move(OwnedUnit));
636 // LTO with assembly output shares a single line table amongst multiple CUs.
637 // To avoid the compilation directory being ambiguous, let the line table
638 // explicitly describe the directory of all files, never relying on the
639 // compilation directory.
640 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
641 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
642 NewCU.getUniqueID(), CompilationDir);
644 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
645 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
646 DIUnit.getLanguage());
647 NewCU.addString(Die, dwarf::DW_AT_name, FN);
649 if (!useSplitDwarf()) {
650 NewCU.initStmtList(DwarfLineSectionSym);
652 // If we're using split dwarf the compilation dir is going to be in the
653 // skeleton CU and so we don't need to duplicate it here.
654 if (!CompilationDir.empty())
655 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
657 addGnuPubAttributes(NewCU, Die);
660 if (DIUnit.isOptimized())
661 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
663 StringRef Flags = DIUnit.getFlags();
665 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
667 if (unsigned RVer = DIUnit.getRunTimeVersion())
668 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
669 dwarf::DW_FORM_data1, RVer);
674 if (useSplitDwarf()) {
675 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
676 DwarfInfoDWOSectionSym);
677 NewCU.setSkeleton(constructSkeletonCU(NewCU));
679 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
680 DwarfInfoSectionSym);
682 CUMap.insert(std::make_pair(DIUnit, &NewCU));
683 CUDieMap.insert(std::make_pair(&Die, &NewCU));
687 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
689 DIImportedEntity Module(N);
690 assert(Module.Verify());
691 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
692 constructImportedEntityDIE(TheCU, Module, *D);
695 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
696 const MDNode *N, DIE &Context) {
697 DIImportedEntity Module(N);
698 assert(Module.Verify());
699 return constructImportedEntityDIE(TheCU, Module, Context);
702 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
703 const DIImportedEntity &Module,
705 assert(Module.Verify() &&
706 "Use one of the MDNode * overloads to handle invalid metadata");
707 DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
709 DIDescriptor Entity = resolve(Module.getEntity());
710 if (Entity.isNameSpace())
711 EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
712 else if (Entity.isSubprogram())
713 EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
714 else if (Entity.isType())
715 EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
717 EntityDie = TheCU.getDIE(Entity);
718 TheCU.addSourceLine(IMDie, Module.getLineNumber(),
719 Module.getContext().getFilename(),
720 Module.getContext().getDirectory());
721 TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
722 StringRef Name = Module.getName();
724 TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
727 // Emit all Dwarf sections that should come prior to the content. Create
728 // global DIEs and emit initial debug info sections. This is invoked by
729 // the target AsmPrinter.
730 void DwarfDebug::beginModule() {
731 if (DisableDebugInfoPrinting)
734 const Module *M = MMI->getModule();
736 FunctionDIs = makeSubprogramMap(*M);
738 // If module has named metadata anchors then use them, otherwise scan the
739 // module using debug info finder to collect debug info.
740 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
743 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
745 // Emit initial sections so we can reference labels later.
748 SingleCU = CU_Nodes->getNumOperands() == 1;
750 for (MDNode *N : CU_Nodes->operands()) {
751 DICompileUnit CUNode(N);
752 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
753 DIArray ImportedEntities = CUNode.getImportedEntities();
754 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
755 ScopesWithImportedEntities.push_back(std::make_pair(
756 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
757 ImportedEntities.getElement(i)));
758 std::sort(ScopesWithImportedEntities.begin(),
759 ScopesWithImportedEntities.end(), less_first());
760 DIArray GVs = CUNode.getGlobalVariables();
761 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
762 CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
763 DIArray SPs = CUNode.getSubprograms();
764 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
765 SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
766 DIArray EnumTypes = CUNode.getEnumTypes();
767 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) {
768 DIType Ty(EnumTypes.getElement(i));
769 // The enum types array by design contains pointers to
770 // MDNodes rather than DIRefs. Unique them here.
771 DIType UniqueTy(resolve(Ty.getRef()));
772 CU.getOrCreateTypeDIE(UniqueTy);
774 DIArray RetainedTypes = CUNode.getRetainedTypes();
775 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
776 DIType Ty(RetainedTypes.getElement(i));
777 // The retained types array by design contains pointers to
778 // MDNodes rather than DIRefs. Unique them here.
779 DIType UniqueTy(resolve(Ty.getRef()));
780 CU.getOrCreateTypeDIE(UniqueTy);
782 // Emit imported_modules last so that the relevant context is already
784 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
785 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
788 // Tell MMI that we have debug info.
789 MMI->setDebugInfoAvailability(true);
791 // Prime section data.
792 SectionMap[Asm->getObjFileLowering().getTextSection()];
795 void DwarfDebug::finishVariableDefinitions() {
796 for (const auto &Var : ConcreteVariables) {
797 DIE *VariableDie = Var->getDIE();
798 // FIXME: There shouldn't be any variables without DIEs.
801 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
802 // in the ConcreteVariables list, rather than looking it up again here.
803 // DIE::getUnit isn't simple - it walks parent pointers, etc.
804 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
806 DbgVariable *AbsVar = getExistingAbstractVariable(Var->getVariable());
807 if (AbsVar && AbsVar->getDIE()) {
808 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
811 Unit->applyVariableAttributes(*Var, *VariableDie);
815 void DwarfDebug::finishSubprogramDefinitions() {
816 const Module *M = MMI->getModule();
818 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
819 for (MDNode *N : CU_Nodes->operands()) {
820 DICompileUnit TheCU(N);
821 // Construct subprogram DIE and add variables DIEs.
822 DwarfCompileUnit *SPCU =
823 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
824 DIArray Subprograms = TheCU.getSubprograms();
825 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
826 DISubprogram SP(Subprograms.getElement(i));
827 // Perhaps the subprogram is in another CU (such as due to comdat
828 // folding, etc), in which case ignore it here.
829 if (SPMap[SP] != SPCU)
831 DIE *D = SPCU->getDIE(SP);
832 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
834 // If this subprogram has an abstract definition, reference that
835 SPCU->addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
838 // Lazily construct the subprogram if we didn't see either concrete or
839 // inlined versions during codegen.
840 D = SPCU->getOrCreateSubprogramDIE(SP);
841 // And attach the attributes
842 SPCU->applySubprogramAttributesToDefinition(SP, *D);
849 // Collect info for variables that were optimized out.
850 void DwarfDebug::collectDeadVariables() {
851 const Module *M = MMI->getModule();
853 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
854 for (MDNode *N : CU_Nodes->operands()) {
855 DICompileUnit TheCU(N);
856 // Construct subprogram DIE and add variables DIEs.
857 DwarfCompileUnit *SPCU =
858 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
859 assert(SPCU && "Unable to find Compile Unit!");
860 DIArray Subprograms = TheCU.getSubprograms();
861 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
862 DISubprogram SP(Subprograms.getElement(i));
863 if (ProcessedSPNodes.count(SP) != 0)
865 assert(SP.isSubprogram() &&
866 "CU's subprogram list contains a non-subprogram");
867 assert(SP.isDefinition() &&
868 "CU's subprogram list contains a subprogram declaration");
869 DIArray Variables = SP.getVariables();
870 if (Variables.getNumElements() == 0)
873 DIE *SPDIE = AbstractSPDies.lookup(SP);
875 SPDIE = SPCU->getDIE(SP);
877 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
878 DIVariable DV(Variables.getElement(vi));
879 assert(DV.isVariable());
880 DbgVariable NewVar(DV, this);
881 auto VariableDie = SPCU->constructVariableDIE(NewVar);
882 SPCU->applyVariableAttributes(NewVar, *VariableDie);
883 SPDIE->addChild(std::move(VariableDie));
890 void DwarfDebug::finalizeModuleInfo() {
891 finishSubprogramDefinitions();
893 finishVariableDefinitions();
895 // Collect info for variables that were optimized out.
896 collectDeadVariables();
898 // Handle anything that needs to be done on a per-unit basis after
899 // all other generation.
900 for (const auto &TheU : getUnits()) {
901 // Emit DW_AT_containing_type attribute to connect types with their
902 // vtable holding type.
903 TheU->constructContainingTypeDIEs();
905 // Add CU specific attributes if we need to add any.
906 if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
907 // If we're splitting the dwarf out now that we've got the entire
908 // CU then add the dwo id to it.
909 DwarfCompileUnit *SkCU =
910 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
911 if (useSplitDwarf()) {
912 // Emit a unique identifier for this CU.
913 uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
914 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
915 dwarf::DW_FORM_data8, ID);
916 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
917 dwarf::DW_FORM_data8, ID);
919 // We don't keep track of which addresses are used in which CU so this
920 // is a bit pessimistic under LTO.
921 if (!AddrPool.isEmpty())
922 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
923 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
924 DwarfAddrSectionSym);
925 if (!TheU->getRangeLists().empty())
926 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
927 dwarf::DW_AT_GNU_ranges_base,
928 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
931 // If we have code split among multiple sections or non-contiguous
932 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
933 // remain in the .o file, otherwise add a DW_AT_low_pc.
934 // FIXME: We should use ranges allow reordering of code ala
935 // .subsections_via_symbols in mach-o. This would mean turning on
936 // ranges for all subprogram DIEs for mach-o.
937 DwarfCompileUnit &U =
938 SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
939 unsigned NumRanges = TheU->getRanges().size();
942 addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
943 Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
944 DwarfDebugRangeSectionSym);
946 // A DW_AT_low_pc attribute may also be specified in combination with
947 // DW_AT_ranges to specify the default base address for use in
948 // location lists (see Section 2.6.2) and range lists (see Section
950 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
953 RangeSpan &Range = TheU->getRanges().back();
954 U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
956 U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
963 // Compute DIE offsets and sizes.
964 InfoHolder.computeSizeAndOffsets();
966 SkeletonHolder.computeSizeAndOffsets();
969 void DwarfDebug::endSections() {
970 // Filter labels by section.
971 for (const SymbolCU &SCU : ArangeLabels) {
972 if (SCU.Sym->isInSection()) {
973 // Make a note of this symbol and it's section.
974 const MCSection *Section = &SCU.Sym->getSection();
975 if (!Section->getKind().isMetadata())
976 SectionMap[Section].push_back(SCU);
978 // Some symbols (e.g. common/bss on mach-o) can have no section but still
979 // appear in the output. This sucks as we rely on sections to build
980 // arange spans. We can do it without, but it's icky.
981 SectionMap[nullptr].push_back(SCU);
985 // Build a list of sections used.
986 std::vector<const MCSection *> Sections;
987 for (const auto &it : SectionMap) {
988 const MCSection *Section = it.first;
989 Sections.push_back(Section);
992 // Sort the sections into order.
993 // This is only done to ensure consistent output order across different runs.
994 std::sort(Sections.begin(), Sections.end(), SectionSort);
996 // Add terminating symbols for each section.
997 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
998 const MCSection *Section = Sections[ID];
999 MCSymbol *Sym = nullptr;
1002 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1003 // if we know the section name up-front. For user-created sections, the
1004 // resulting label may not be valid to use as a label. (section names can
1005 // use a greater set of characters on some systems)
1006 Sym = Asm->GetTempSymbol("debug_end", ID);
1007 Asm->OutStreamer.SwitchSection(Section);
1008 Asm->OutStreamer.EmitLabel(Sym);
1011 // Insert a final terminator.
1012 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
1016 // Emit all Dwarf sections that should come after the content.
1017 void DwarfDebug::endModule() {
1018 assert(CurFn == nullptr);
1019 assert(CurMI == nullptr);
1024 // End any existing sections.
1025 // TODO: Does this need to happen?
1028 // Finalize the debug info for the module.
1029 finalizeModuleInfo();
1033 // Emit all the DIEs into a debug info section.
1036 // Corresponding abbreviations into a abbrev section.
1037 emitAbbreviations();
1039 // Emit info into a debug aranges section.
1040 if (GenerateARangeSection)
1043 // Emit info into a debug ranges section.
1046 if (useSplitDwarf()) {
1049 emitDebugAbbrevDWO();
1052 // Emit DWO addresses.
1053 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1055 // Emit info into a debug loc section.
1058 // Emit info into the dwarf accelerator table sections.
1059 if (useDwarfAccelTables()) {
1062 emitAccelNamespaces();
1066 // Emit the pubnames and pubtypes sections if requested.
1067 if (HasDwarfPubSections) {
1068 emitDebugPubNames(GenerateGnuPubSections);
1069 emitDebugPubTypes(GenerateGnuPubSections);
1074 AbstractVariables.clear();
1076 // Reset these for the next Module if we have one.
1080 // Find abstract variable, if any, associated with Var.
1081 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV,
1082 DIVariable &Cleansed) {
1083 LLVMContext &Ctx = DV->getContext();
1084 // More then one inlined variable corresponds to one abstract variable.
1085 // FIXME: This duplication of variables when inlining should probably be
1086 // removed. It's done to allow each DIVariable to describe its location
1087 // because the DebugLoc on the dbg.value/declare isn't accurate. We should
1088 // make it accurate then remove this duplication/cleansing stuff.
1089 Cleansed = cleanseInlinedVariable(DV, Ctx);
1090 auto I = AbstractVariables.find(Cleansed);
1091 if (I != AbstractVariables.end())
1092 return I->second.get();
1096 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV) {
1097 DIVariable Cleansed;
1098 return getExistingAbstractVariable(DV, Cleansed);
1101 void DwarfDebug::createAbstractVariable(const DIVariable &Var,
1102 LexicalScope *Scope) {
1103 auto AbsDbgVariable = make_unique<DbgVariable>(Var, this);
1104 addScopeVariable(Scope, AbsDbgVariable.get());
1105 AbstractVariables[Var] = std::move(AbsDbgVariable);
1108 void DwarfDebug::ensureAbstractVariableIsCreated(const DIVariable &DV,
1109 const MDNode *ScopeNode) {
1110 DIVariable Cleansed = DV;
1111 if (getExistingAbstractVariable(DV, Cleansed))
1114 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(ScopeNode));
1118 DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(const DIVariable &DV,
1119 const MDNode *ScopeNode) {
1120 DIVariable Cleansed = DV;
1121 if (getExistingAbstractVariable(DV, Cleansed))
1124 if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
1125 createAbstractVariable(Cleansed, Scope);
1128 // If Var is a current function argument then add it to CurrentFnArguments list.
1129 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1130 if (!LScopes.isCurrentFunctionScope(Scope))
1132 DIVariable DV = Var->getVariable();
1133 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1135 unsigned ArgNo = DV.getArgNumber();
1139 size_t Size = CurrentFnArguments.size();
1141 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1142 // llvm::Function argument size is not good indicator of how many
1143 // arguments does the function have at source level.
1145 CurrentFnArguments.resize(ArgNo * 2);
1146 CurrentFnArguments[ArgNo - 1] = Var;
1150 // Collect variable information from side table maintained by MMI.
1151 void DwarfDebug::collectVariableInfoFromMMITable(
1152 SmallPtrSet<const MDNode *, 16> &Processed) {
1153 for (const auto &VI : MMI->getVariableDbgInfo()) {
1156 Processed.insert(VI.Var);
1157 DIVariable DV(VI.Var);
1158 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1160 // If variable scope is not found then skip this variable.
1164 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1165 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1166 DbgVariable *RegVar = ConcreteVariables.back().get();
1167 RegVar->setFrameIndex(VI.Slot);
1168 addScopeVariable(Scope, RegVar);
1172 // Get .debug_loc entry for the instruction range starting at MI.
1173 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1174 const MDNode *Var = MI->getDebugVariable();
1176 assert(MI->getNumOperands() == 3);
1177 if (MI->getOperand(0).isReg()) {
1178 MachineLocation MLoc;
1179 // If the second operand is an immediate, this is a
1180 // register-indirect address.
1181 if (!MI->getOperand(1).isImm())
1182 MLoc.set(MI->getOperand(0).getReg());
1184 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1185 return DebugLocEntry::Value(Var, MLoc);
1187 if (MI->getOperand(0).isImm())
1188 return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1189 if (MI->getOperand(0).isFPImm())
1190 return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1191 if (MI->getOperand(0).isCImm())
1192 return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1194 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1197 // Find variables for each lexical scope.
1199 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1200 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1201 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1203 // Grab the variable info that was squirreled away in the MMI side-table.
1204 collectVariableInfoFromMMITable(Processed);
1206 for (const auto &I : DbgValues) {
1207 DIVariable DV(I.first);
1208 if (Processed.count(DV))
1211 // Instruction ranges, specifying where DV is accessible.
1212 const auto &Ranges = I.second;
1216 LexicalScope *Scope = nullptr;
1217 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1218 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1219 Scope = LScopes.getCurrentFunctionScope();
1220 else if (MDNode *IA = DV.getInlinedAt()) {
1221 DebugLoc DL = DebugLoc::getFromDILocation(IA);
1222 Scope = LScopes.findInlinedScope(DebugLoc::get(
1223 DL.getLine(), DL.getCol(), DV.getContext(), IA));
1225 Scope = LScopes.findLexicalScope(DV.getContext());
1226 // If variable scope is not found then skip this variable.
1230 Processed.insert(DV);
1231 const MachineInstr *MInsn = Ranges.front().first;
1232 assert(MInsn->isDebugValue() && "History must begin with debug value");
1233 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1234 ConcreteVariables.push_back(make_unique<DbgVariable>(MInsn, this));
1235 DbgVariable *RegVar = ConcreteVariables.back().get();
1236 addScopeVariable(Scope, RegVar);
1238 // Check if the first DBG_VALUE is valid for the rest of the function.
1239 if (Ranges.size() == 1 && Ranges.front().second == nullptr)
1242 // Handle multiple DBG_VALUE instructions describing one variable.
1243 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1245 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1246 DebugLocList &LocList = DotDebugLocEntries.back();
1248 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1249 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1250 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1251 const MachineInstr *Begin = I->first;
1252 const MachineInstr *End = I->second;
1253 assert(Begin->isDebugValue() && "Invalid History entry");
1255 // Check if a variable is unaccessible in this range.
1256 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1257 !Begin->getOperand(0).getReg())
1259 DEBUG(dbgs() << "DotDebugLoc Pair:\n" << "\t" << *Begin);
1261 DEBUG(dbgs() << "\t" << *End);
1263 DEBUG(dbgs() << "\tNULL\n");
1265 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1266 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1268 const MCSymbol *EndLabel;
1270 EndLabel = getLabelAfterInsn(End);
1271 else if (std::next(I) == Ranges.end())
1272 EndLabel = FunctionEndSym;
1274 EndLabel = getLabelBeforeInsn(std::next(I)->first);
1275 assert(EndLabel && "Forgot label after instruction ending a range!");
1277 DebugLocEntry Loc(StartLabel, EndLabel, getDebugLocValue(Begin), TheCU);
1278 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1279 DebugLoc.push_back(std::move(Loc));
1283 // Collect info for variables that were optimized out.
1284 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1285 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1286 DIVariable DV(Variables.getElement(i));
1287 assert(DV.isVariable());
1288 if (!Processed.insert(DV))
1290 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
1291 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1292 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1293 addScopeVariable(Scope, ConcreteVariables.back().get());
1298 // Return Label preceding the instruction.
1299 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1300 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1301 assert(Label && "Didn't insert label before instruction");
1305 // Return Label immediately following the instruction.
1306 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1307 return LabelsAfterInsn.lookup(MI);
1310 // Process beginning of an instruction.
1311 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1312 assert(CurMI == nullptr);
1314 // Check if source location changes, but ignore DBG_VALUE locations.
1315 if (!MI->isDebugValue()) {
1316 DebugLoc DL = MI->getDebugLoc();
1317 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1320 if (DL == PrologEndLoc) {
1321 Flags |= DWARF2_FLAG_PROLOGUE_END;
1322 PrologEndLoc = DebugLoc();
1324 if (PrologEndLoc.isUnknown())
1325 Flags |= DWARF2_FLAG_IS_STMT;
1327 if (!DL.isUnknown()) {
1328 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1329 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1331 recordSourceLine(0, 0, nullptr, 0);
1335 // Insert labels where requested.
1336 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1337 LabelsBeforeInsn.find(MI);
1340 if (I == LabelsBeforeInsn.end())
1343 // Label already assigned.
1348 PrevLabel = MMI->getContext().CreateTempSymbol();
1349 Asm->OutStreamer.EmitLabel(PrevLabel);
1351 I->second = PrevLabel;
1354 // Process end of an instruction.
1355 void DwarfDebug::endInstruction() {
1356 assert(CurMI != nullptr);
1357 // Don't create a new label after DBG_VALUE instructions.
1358 // They don't generate code.
1359 if (!CurMI->isDebugValue())
1360 PrevLabel = nullptr;
1362 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1363 LabelsAfterInsn.find(CurMI);
1367 if (I == LabelsAfterInsn.end())
1370 // Label already assigned.
1374 // We need a label after this instruction.
1376 PrevLabel = MMI->getContext().CreateTempSymbol();
1377 Asm->OutStreamer.EmitLabel(PrevLabel);
1379 I->second = PrevLabel;
1382 // Each LexicalScope has first instruction and last instruction to mark
1383 // beginning and end of a scope respectively. Create an inverse map that list
1384 // scopes starts (and ends) with an instruction. One instruction may start (or
1385 // end) multiple scopes. Ignore scopes that are not reachable.
1386 void DwarfDebug::identifyScopeMarkers() {
1387 SmallVector<LexicalScope *, 4> WorkList;
1388 WorkList.push_back(LScopes.getCurrentFunctionScope());
1389 while (!WorkList.empty()) {
1390 LexicalScope *S = WorkList.pop_back_val();
1392 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1393 if (!Children.empty())
1394 WorkList.append(Children.begin(), Children.end());
1396 if (S->isAbstractScope())
1399 for (const InsnRange &R : S->getRanges()) {
1400 assert(R.first && "InsnRange does not have first instruction!");
1401 assert(R.second && "InsnRange does not have second instruction!");
1402 requestLabelBeforeInsn(R.first);
1403 requestLabelAfterInsn(R.second);
1408 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1409 // First known non-DBG_VALUE and non-frame setup location marks
1410 // the beginning of the function body.
1411 for (const auto &MBB : *MF)
1412 for (const auto &MI : MBB)
1413 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1414 !MI.getDebugLoc().isUnknown())
1415 return MI.getDebugLoc();
1419 // Gather pre-function debug information. Assumes being called immediately
1420 // after the function entry point has been emitted.
1421 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1424 // If there's no debug info for the function we're not going to do anything.
1425 if (!MMI->hasDebugInfo())
1428 auto DI = FunctionDIs.find(MF->getFunction());
1429 if (DI == FunctionDIs.end())
1432 // Grab the lexical scopes for the function, if we don't have any of those
1433 // then we're not going to be able to do anything.
1434 LScopes.initialize(*MF);
1435 if (LScopes.empty())
1438 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1440 // Make sure that each lexical scope will have a begin/end label.
1441 identifyScopeMarkers();
1443 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1444 // belongs to so that we add to the correct per-cu line table in the
1446 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1447 // FnScope->getScopeNode() and DI->second should represent the same function,
1448 // though they may not be the same MDNode due to inline functions merged in
1449 // LTO where the debug info metadata still differs (either due to distinct
1450 // written differences - two versions of a linkonce_odr function
1451 // written/copied into two separate files, or some sub-optimal metadata that
1452 // isn't structurally identical (see: file path/name info from clang, which
1453 // includes the directory of the cpp file being built, even when the file name
1454 // is absolute (such as an <> lookup header)))
1455 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1456 assert(TheCU && "Unable to find compile unit!");
1457 if (Asm->OutStreamer.hasRawTextSupport())
1458 // Use a single line table if we are generating assembly.
1459 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1461 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1463 // Emit a label for the function so that we have a beginning address.
1464 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1465 // Assumes in correct section after the entry point.
1466 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1468 // Calculate history for local variables.
1469 calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1471 // Request labels for the full history.
1472 for (const auto &I : DbgValues) {
1473 const auto &Ranges = I.second;
1477 // The first mention of a function argument gets the FunctionBeginSym
1478 // label, so arguments are visible when breaking at function entry.
1479 DIVariable DV(I.first);
1480 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1481 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1482 LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1484 for (const auto &Range : Ranges) {
1485 requestLabelBeforeInsn(Range.first);
1487 requestLabelAfterInsn(Range.second);
1491 PrevInstLoc = DebugLoc();
1492 PrevLabel = FunctionBeginSym;
1494 // Record beginning of function.
1495 PrologEndLoc = findPrologueEndLoc(MF);
1496 if (!PrologEndLoc.isUnknown()) {
1497 DebugLoc FnStartDL =
1498 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1500 FnStartDL.getLine(), FnStartDL.getCol(),
1501 FnStartDL.getScope(MF->getFunction()->getContext()),
1502 // We'd like to list the prologue as "not statements" but GDB behaves
1503 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1504 DWARF2_FLAG_IS_STMT);
1508 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1509 if (addCurrentFnArgument(Var, LS))
1511 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1512 DIVariable DV = Var->getVariable();
1513 // Variables with positive arg numbers are parameters.
1514 if (unsigned ArgNum = DV.getArgNumber()) {
1515 // Keep all parameters in order at the start of the variable list to ensure
1516 // function types are correct (no out-of-order parameters)
1518 // This could be improved by only doing it for optimized builds (unoptimized
1519 // builds have the right order to begin with), searching from the back (this
1520 // would catch the unoptimized case quickly), or doing a binary search
1521 // rather than linear search.
1522 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1523 while (I != Vars.end()) {
1524 unsigned CurNum = (*I)->getVariable().getArgNumber();
1525 // A local (non-parameter) variable has been found, insert immediately
1529 // A later indexed parameter has been found, insert immediately before it.
1530 if (CurNum > ArgNum)
1534 Vars.insert(I, Var);
1538 Vars.push_back(Var);
1541 // Gather and emit post-function debug information.
1542 void DwarfDebug::endFunction(const MachineFunction *MF) {
1543 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1544 // though the beginFunction may not be called at all.
1545 // We should handle both cases.
1549 assert(CurFn == MF);
1550 assert(CurFn != nullptr);
1552 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1553 !FunctionDIs.count(MF->getFunction())) {
1554 // If we don't have a lexical scope for this function then there will
1555 // be a hole in the range information. Keep note of this by setting the
1556 // previously used section to nullptr.
1557 PrevSection = nullptr;
1563 // Define end label for subprogram.
1564 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1565 // Assumes in correct section after the entry point.
1566 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1568 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1569 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1571 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1572 collectVariableInfo(ProcessedVars);
1574 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1575 DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1577 // Construct abstract scopes.
1578 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1579 DISubprogram SP(AScope->getScopeNode());
1580 assert(SP.isSubprogram());
1581 // Collect info for variables that were optimized out.
1582 DIArray Variables = SP.getVariables();
1583 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1584 DIVariable DV(Variables.getElement(i));
1585 assert(DV && DV.isVariable());
1586 if (!ProcessedVars.insert(DV))
1588 ensureAbstractVariableIsCreated(DV, DV.getContext());
1590 constructAbstractSubprogramScopeDIE(TheCU, AScope);
1593 DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1594 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1595 TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1597 // Add the range of this function to the list of ranges for the CU.
1598 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1599 TheCU.addRange(std::move(Span));
1600 PrevSection = Asm->getCurrentSection();
1604 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1605 // DbgVariables except those that are also in AbstractVariables (since they
1606 // can be used cross-function)
1607 ScopeVariables.clear();
1608 CurrentFnArguments.clear();
1610 LabelsBeforeInsn.clear();
1611 LabelsAfterInsn.clear();
1612 PrevLabel = nullptr;
1616 // Register a source line with debug info. Returns the unique label that was
1617 // emitted and which provides correspondence to the source line list.
1618 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1623 unsigned Discriminator = 0;
1624 if (DIScope Scope = DIScope(S)) {
1625 assert(Scope.isScope());
1626 Fn = Scope.getFilename();
1627 Dir = Scope.getDirectory();
1628 if (Scope.isLexicalBlock())
1629 Discriminator = DILexicalBlock(S).getDiscriminator();
1631 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1632 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1633 .getOrCreateSourceID(Fn, Dir);
1635 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1639 //===----------------------------------------------------------------------===//
1641 //===----------------------------------------------------------------------===//
1643 // Emit initial Dwarf sections with a label at the start of each one.
1644 void DwarfDebug::emitSectionLabels() {
1645 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1647 // Dwarf sections base addresses.
1648 DwarfInfoSectionSym =
1649 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1650 if (useSplitDwarf()) {
1651 DwarfInfoDWOSectionSym =
1652 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1653 DwarfTypesDWOSectionSym =
1654 emitSectionSym(Asm, TLOF.getDwarfTypesDWOSection(), "section_types_dwo");
1656 DwarfAbbrevSectionSym =
1657 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1658 if (useSplitDwarf())
1659 DwarfAbbrevDWOSectionSym = emitSectionSym(
1660 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1661 if (GenerateARangeSection)
1662 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1664 DwarfLineSectionSym =
1665 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1666 if (GenerateGnuPubSections) {
1667 DwarfGnuPubNamesSectionSym =
1668 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1669 DwarfGnuPubTypesSectionSym =
1670 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1671 } else if (HasDwarfPubSections) {
1672 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1673 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1676 DwarfStrSectionSym =
1677 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1678 if (useSplitDwarf()) {
1679 DwarfStrDWOSectionSym =
1680 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1681 DwarfAddrSectionSym =
1682 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1683 DwarfDebugLocSectionSym =
1684 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1686 DwarfDebugLocSectionSym =
1687 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1688 DwarfDebugRangeSectionSym =
1689 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1692 // Recursively emits a debug information entry.
1693 void DwarfDebug::emitDIE(DIE &Die) {
1694 // Get the abbreviation for this DIE.
1695 const DIEAbbrev &Abbrev = Die.getAbbrev();
1697 // Emit the code (index) for the abbreviation.
1698 if (Asm->isVerbose())
1699 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1700 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1701 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1702 dwarf::TagString(Abbrev.getTag()));
1703 Asm->EmitULEB128(Abbrev.getNumber());
1705 const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1706 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1708 // Emit the DIE attribute values.
1709 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1710 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1711 dwarf::Form Form = AbbrevData[i].getForm();
1712 assert(Form && "Too many attributes for DIE (check abbreviation)");
1714 if (Asm->isVerbose()) {
1715 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1716 if (Attr == dwarf::DW_AT_accessibility)
1717 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1718 cast<DIEInteger>(Values[i])->getValue()));
1721 // Emit an attribute using the defined form.
1722 Values[i]->EmitValue(Asm, Form);
1725 // Emit the DIE children if any.
1726 if (Abbrev.hasChildren()) {
1727 for (auto &Child : Die.getChildren())
1730 Asm->OutStreamer.AddComment("End Of Children Mark");
1735 // Emit the debug info section.
1736 void DwarfDebug::emitDebugInfo() {
1737 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1739 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1742 // Emit the abbreviation section.
1743 void DwarfDebug::emitAbbreviations() {
1744 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1746 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1749 // Emit the last address of the section and the end of the line matrix.
1750 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1751 // Define last address of section.
1752 Asm->OutStreamer.AddComment("Extended Op");
1755 Asm->OutStreamer.AddComment("Op size");
1756 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1757 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1758 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1760 Asm->OutStreamer.AddComment("Section end label");
1762 Asm->OutStreamer.EmitSymbolValue(
1763 Asm->GetTempSymbol("section_end", SectionEnd),
1764 Asm->getDataLayout().getPointerSize());
1766 // Mark end of matrix.
1767 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1773 // Emit visible names into a hashed accelerator table section.
1774 void DwarfDebug::emitAccelNames() {
1775 AccelNames.FinalizeTable(Asm, "Names");
1776 Asm->OutStreamer.SwitchSection(
1777 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1778 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1779 Asm->OutStreamer.EmitLabel(SectionBegin);
1781 // Emit the full data.
1782 AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1785 // Emit objective C classes and categories into a hashed accelerator table
1787 void DwarfDebug::emitAccelObjC() {
1788 AccelObjC.FinalizeTable(Asm, "ObjC");
1789 Asm->OutStreamer.SwitchSection(
1790 Asm->getObjFileLowering().getDwarfAccelObjCSection());
1791 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1792 Asm->OutStreamer.EmitLabel(SectionBegin);
1794 // Emit the full data.
1795 AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1798 // Emit namespace dies into a hashed accelerator table.
1799 void DwarfDebug::emitAccelNamespaces() {
1800 AccelNamespace.FinalizeTable(Asm, "namespac");
1801 Asm->OutStreamer.SwitchSection(
1802 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1803 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1804 Asm->OutStreamer.EmitLabel(SectionBegin);
1806 // Emit the full data.
1807 AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1810 // Emit type dies into a hashed accelerator table.
1811 void DwarfDebug::emitAccelTypes() {
1813 AccelTypes.FinalizeTable(Asm, "types");
1814 Asm->OutStreamer.SwitchSection(
1815 Asm->getObjFileLowering().getDwarfAccelTypesSection());
1816 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1817 Asm->OutStreamer.EmitLabel(SectionBegin);
1819 // Emit the full data.
1820 AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1823 // Public name handling.
1824 // The format for the various pubnames:
1826 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1827 // for the DIE that is named.
1829 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1830 // into the CU and the index value is computed according to the type of value
1831 // for the DIE that is named.
1833 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1834 // it's the offset within the debug_info/debug_types dwo section, however, the
1835 // reference in the pubname header doesn't change.
1837 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1838 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1840 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1842 // We could have a specification DIE that has our most of our knowledge,
1843 // look for that now.
1844 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1846 DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1847 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1848 Linkage = dwarf::GIEL_EXTERNAL;
1849 } else if (Die->findAttribute(dwarf::DW_AT_external))
1850 Linkage = dwarf::GIEL_EXTERNAL;
1852 switch (Die->getTag()) {
1853 case dwarf::DW_TAG_class_type:
1854 case dwarf::DW_TAG_structure_type:
1855 case dwarf::DW_TAG_union_type:
1856 case dwarf::DW_TAG_enumeration_type:
1857 return dwarf::PubIndexEntryDescriptor(
1858 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1859 ? dwarf::GIEL_STATIC
1860 : dwarf::GIEL_EXTERNAL);
1861 case dwarf::DW_TAG_typedef:
1862 case dwarf::DW_TAG_base_type:
1863 case dwarf::DW_TAG_subrange_type:
1864 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1865 case dwarf::DW_TAG_namespace:
1866 return dwarf::GIEK_TYPE;
1867 case dwarf::DW_TAG_subprogram:
1868 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1869 case dwarf::DW_TAG_constant:
1870 case dwarf::DW_TAG_variable:
1871 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1872 case dwarf::DW_TAG_enumerator:
1873 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1874 dwarf::GIEL_STATIC);
1876 return dwarf::GIEK_NONE;
1880 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1882 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1883 const MCSection *PSec =
1884 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1885 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1887 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1890 void DwarfDebug::emitDebugPubSection(
1891 bool GnuStyle, const MCSection *PSec, StringRef Name,
1892 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1893 for (const auto &NU : CUMap) {
1894 DwarfCompileUnit *TheU = NU.second;
1896 const auto &Globals = (TheU->*Accessor)();
1898 if (Globals.empty())
1901 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1903 unsigned ID = TheU->getUniqueID();
1905 // Start the dwarf pubnames section.
1906 Asm->OutStreamer.SwitchSection(PSec);
1909 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1910 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1911 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1912 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1914 Asm->OutStreamer.EmitLabel(BeginLabel);
1916 Asm->OutStreamer.AddComment("DWARF Version");
1917 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1919 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1920 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1922 Asm->OutStreamer.AddComment("Compilation Unit Length");
1923 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1925 // Emit the pubnames for this compilation unit.
1926 for (const auto &GI : Globals) {
1927 const char *Name = GI.getKeyData();
1928 const DIE *Entity = GI.second;
1930 Asm->OutStreamer.AddComment("DIE offset");
1931 Asm->EmitInt32(Entity->getOffset());
1934 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1935 Asm->OutStreamer.AddComment(
1936 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1937 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1938 Asm->EmitInt8(Desc.toBits());
1941 Asm->OutStreamer.AddComment("External Name");
1942 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1945 Asm->OutStreamer.AddComment("End Mark");
1947 Asm->OutStreamer.EmitLabel(EndLabel);
1951 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1952 const MCSection *PSec =
1953 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1954 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1956 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1959 // Emit visible names into a debug str section.
1960 void DwarfDebug::emitDebugStr() {
1961 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1962 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1965 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1966 const DebugLocEntry &Entry) {
1967 assert(Entry.getValues().size() == 1 &&
1968 "multi-value entries are not supported yet.");
1969 const DebugLocEntry::Value Value = Entry.getValues()[0];
1970 DIVariable DV(Value.getVariable());
1971 if (Value.isInt()) {
1972 DIBasicType BTy(resolve(DV.getType()));
1973 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1974 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1975 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1976 Streamer.EmitSLEB128(Value.getInt());
1978 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1979 Streamer.EmitULEB128(Value.getInt());
1981 } else if (Value.isLocation()) {
1982 MachineLocation Loc = Value.getLoc();
1983 if (!DV.hasComplexAddress())
1985 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1987 // Complex address entry.
1988 unsigned N = DV.getNumAddrElements();
1990 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1991 if (Loc.getOffset()) {
1993 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1994 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1995 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1996 Streamer.EmitSLEB128(DV.getAddrElement(1));
1998 // If first address element is OpPlus then emit
1999 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2000 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2001 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2005 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2008 // Emit remaining complex address elements.
2009 for (; i < N; ++i) {
2010 uint64_t Element = DV.getAddrElement(i);
2011 if (Element == DIBuilder::OpPlus) {
2012 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2013 Streamer.EmitULEB128(DV.getAddrElement(++i));
2014 } else if (Element == DIBuilder::OpDeref) {
2016 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2018 llvm_unreachable("unknown Opcode found in complex address");
2022 // else ... ignore constant fp. There is not any good way to
2023 // to represent them here in dwarf.
2027 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2028 Asm->OutStreamer.AddComment("Loc expr size");
2029 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2030 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2031 Asm->EmitLabelDifference(end, begin, 2);
2032 Asm->OutStreamer.EmitLabel(begin);
2034 APByteStreamer Streamer(*Asm);
2035 emitDebugLocEntry(Streamer, Entry);
2037 Asm->OutStreamer.EmitLabel(end);
2040 // Emit locations into the debug loc section.
2041 void DwarfDebug::emitDebugLoc() {
2042 // Start the dwarf loc section.
2043 Asm->OutStreamer.SwitchSection(
2044 Asm->getObjFileLowering().getDwarfLocSection());
2045 unsigned char Size = Asm->getDataLayout().getPointerSize();
2046 for (const auto &DebugLoc : DotDebugLocEntries) {
2047 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2048 for (const auto &Entry : DebugLoc.List) {
2049 // Set up the range. This range is relative to the entry point of the
2050 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2051 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2052 const DwarfCompileUnit *CU = Entry.getCU();
2053 if (CU->getRanges().size() == 1) {
2054 // Grab the begin symbol from the first range as our base.
2055 const MCSymbol *Base = CU->getRanges()[0].getStart();
2056 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2057 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2059 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2060 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2063 emitDebugLocEntryLocation(Entry);
2065 Asm->OutStreamer.EmitIntValue(0, Size);
2066 Asm->OutStreamer.EmitIntValue(0, Size);
2070 void DwarfDebug::emitDebugLocDWO() {
2071 Asm->OutStreamer.SwitchSection(
2072 Asm->getObjFileLowering().getDwarfLocDWOSection());
2073 for (const auto &DebugLoc : DotDebugLocEntries) {
2074 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2075 for (const auto &Entry : DebugLoc.List) {
2076 // Just always use start_length for now - at least that's one address
2077 // rather than two. We could get fancier and try to, say, reuse an
2078 // address we know we've emitted elsewhere (the start of the function?
2079 // The start of the CU or CU subrange that encloses this range?)
2080 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2081 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2082 Asm->EmitULEB128(idx);
2083 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2085 emitDebugLocEntryLocation(Entry);
2087 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2092 const MCSymbol *Start, *End;
2095 // Emit a debug aranges section, containing a CU lookup for any
2096 // address we can tie back to a CU.
2097 void DwarfDebug::emitDebugARanges() {
2098 // Start the dwarf aranges section.
2099 Asm->OutStreamer.SwitchSection(
2100 Asm->getObjFileLowering().getDwarfARangesSection());
2102 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2106 // Build a list of sections used.
2107 std::vector<const MCSection *> Sections;
2108 for (const auto &it : SectionMap) {
2109 const MCSection *Section = it.first;
2110 Sections.push_back(Section);
2113 // Sort the sections into order.
2114 // This is only done to ensure consistent output order across different runs.
2115 std::sort(Sections.begin(), Sections.end(), SectionSort);
2117 // Build a set of address spans, sorted by CU.
2118 for (const MCSection *Section : Sections) {
2119 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2120 if (List.size() < 2)
2123 // Sort the symbols by offset within the section.
2124 std::sort(List.begin(), List.end(),
2125 [&](const SymbolCU &A, const SymbolCU &B) {
2126 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2127 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2129 // Symbols with no order assigned should be placed at the end.
2130 // (e.g. section end labels)
2138 // If we have no section (e.g. common), just write out
2139 // individual spans for each symbol.
2141 for (const SymbolCU &Cur : List) {
2143 Span.Start = Cur.Sym;
2146 Spans[Cur.CU].push_back(Span);
2149 // Build spans between each label.
2150 const MCSymbol *StartSym = List[0].Sym;
2151 for (size_t n = 1, e = List.size(); n < e; n++) {
2152 const SymbolCU &Prev = List[n - 1];
2153 const SymbolCU &Cur = List[n];
2155 // Try and build the longest span we can within the same CU.
2156 if (Cur.CU != Prev.CU) {
2158 Span.Start = StartSym;
2160 Spans[Prev.CU].push_back(Span);
2167 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2169 // Build a list of CUs used.
2170 std::vector<DwarfCompileUnit *> CUs;
2171 for (const auto &it : Spans) {
2172 DwarfCompileUnit *CU = it.first;
2176 // Sort the CU list (again, to ensure consistent output order).
2177 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2178 return A->getUniqueID() < B->getUniqueID();
2181 // Emit an arange table for each CU we used.
2182 for (DwarfCompileUnit *CU : CUs) {
2183 std::vector<ArangeSpan> &List = Spans[CU];
2185 // Emit size of content not including length itself.
2186 unsigned ContentSize =
2187 sizeof(int16_t) + // DWARF ARange version number
2188 sizeof(int32_t) + // Offset of CU in the .debug_info section
2189 sizeof(int8_t) + // Pointer Size (in bytes)
2190 sizeof(int8_t); // Segment Size (in bytes)
2192 unsigned TupleSize = PtrSize * 2;
2194 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2196 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2198 ContentSize += Padding;
2199 ContentSize += (List.size() + 1) * TupleSize;
2201 // For each compile unit, write the list of spans it covers.
2202 Asm->OutStreamer.AddComment("Length of ARange Set");
2203 Asm->EmitInt32(ContentSize);
2204 Asm->OutStreamer.AddComment("DWARF Arange version number");
2205 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2206 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2207 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2208 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2209 Asm->EmitInt8(PtrSize);
2210 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2213 Asm->OutStreamer.EmitFill(Padding, 0xff);
2215 for (const ArangeSpan &Span : List) {
2216 Asm->EmitLabelReference(Span.Start, PtrSize);
2218 // Calculate the size as being from the span start to it's end.
2220 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2222 // For symbols without an end marker (e.g. common), we
2223 // write a single arange entry containing just that one symbol.
2224 uint64_t Size = SymSize[Span.Start];
2228 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2232 Asm->OutStreamer.AddComment("ARange terminator");
2233 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2234 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2238 // Emit visible names into a debug ranges section.
2239 void DwarfDebug::emitDebugRanges() {
2240 // Start the dwarf ranges section.
2241 Asm->OutStreamer.SwitchSection(
2242 Asm->getObjFileLowering().getDwarfRangesSection());
2244 // Size for our labels.
2245 unsigned char Size = Asm->getDataLayout().getPointerSize();
2247 // Grab the specific ranges for the compile units in the module.
2248 for (const auto &I : CUMap) {
2249 DwarfCompileUnit *TheCU = I.second;
2251 // Iterate over the misc ranges for the compile units in the module.
2252 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2253 // Emit our symbol so we can find the beginning of the range.
2254 Asm->OutStreamer.EmitLabel(List.getSym());
2256 for (const RangeSpan &Range : List.getRanges()) {
2257 const MCSymbol *Begin = Range.getStart();
2258 const MCSymbol *End = Range.getEnd();
2259 assert(Begin && "Range without a begin symbol?");
2260 assert(End && "Range without an end symbol?");
2261 if (TheCU->getRanges().size() == 1) {
2262 // Grab the begin symbol from the first range as our base.
2263 const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2264 Asm->EmitLabelDifference(Begin, Base, Size);
2265 Asm->EmitLabelDifference(End, Base, Size);
2267 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2268 Asm->OutStreamer.EmitSymbolValue(End, Size);
2272 // And terminate the list with two 0 values.
2273 Asm->OutStreamer.EmitIntValue(0, Size);
2274 Asm->OutStreamer.EmitIntValue(0, Size);
2277 // Now emit a range for the CU itself.
2278 if (TheCU->getRanges().size() > 1) {
2279 Asm->OutStreamer.EmitLabel(
2280 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2281 for (const RangeSpan &Range : TheCU->getRanges()) {
2282 const MCSymbol *Begin = Range.getStart();
2283 const MCSymbol *End = Range.getEnd();
2284 assert(Begin && "Range without a begin symbol?");
2285 assert(End && "Range without an end symbol?");
2286 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2287 Asm->OutStreamer.EmitSymbolValue(End, Size);
2289 // And terminate the list with two 0 values.
2290 Asm->OutStreamer.EmitIntValue(0, Size);
2291 Asm->OutStreamer.EmitIntValue(0, Size);
2296 // DWARF5 Experimental Separate Dwarf emitters.
2298 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2299 std::unique_ptr<DwarfUnit> NewU) {
2300 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2301 U.getCUNode().getSplitDebugFilename());
2303 if (!CompilationDir.empty())
2304 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2306 addGnuPubAttributes(*NewU, Die);
2308 SkeletonHolder.addUnit(std::move(NewU));
2311 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2312 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2313 // DW_AT_addr_base, DW_AT_ranges_base.
2314 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2316 auto OwnedUnit = make_unique<DwarfCompileUnit>(
2317 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2318 DwarfCompileUnit &NewCU = *OwnedUnit;
2319 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2320 DwarfInfoSectionSym);
2322 NewCU.initStmtList(DwarfLineSectionSym);
2324 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2329 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2331 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2332 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2333 *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2335 auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2337 DwarfTypeUnit &NewTU = *OwnedUnit;
2338 NewTU.setTypeSignature(TU.getTypeSignature());
2339 NewTU.setType(nullptr);
2341 Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2343 initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2347 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2348 // compile units that would normally be in debug_info.
2349 void DwarfDebug::emitDebugInfoDWO() {
2350 assert(useSplitDwarf() && "No split dwarf debug info?");
2351 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2352 // emit relocations into the dwo file.
2353 InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2356 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2357 // abbreviations for the .debug_info.dwo section.
2358 void DwarfDebug::emitDebugAbbrevDWO() {
2359 assert(useSplitDwarf() && "No split dwarf?");
2360 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2363 void DwarfDebug::emitDebugLineDWO() {
2364 assert(useSplitDwarf() && "No split dwarf?");
2365 Asm->OutStreamer.SwitchSection(
2366 Asm->getObjFileLowering().getDwarfLineDWOSection());
2367 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2370 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2371 // string section and is identical in format to traditional .debug_str
2373 void DwarfDebug::emitDebugStrDWO() {
2374 assert(useSplitDwarf() && "No split dwarf?");
2375 const MCSection *OffSec =
2376 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2377 const MCSymbol *StrSym = DwarfStrSectionSym;
2378 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2382 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2383 if (!useSplitDwarf())
2386 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2387 return &SplitTypeUnitFileTable;
2390 static uint64_t makeTypeSignature(StringRef Identifier) {
2392 Hash.update(Identifier);
2393 // ... take the least significant 8 bytes and return those. Our MD5
2394 // implementation always returns its results in little endian, swap bytes
2396 MD5::MD5Result Result;
2398 return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2401 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2402 StringRef Identifier, DIE &RefDie,
2403 DICompositeType CTy) {
2404 // Fast path if we're building some type units and one has already used the
2405 // address pool we know we're going to throw away all this work anyway, so
2406 // don't bother building dependent types.
2407 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2410 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2412 CU.addDIETypeSignature(RefDie, *TU);
2416 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2417 AddrPool.resetUsedFlag();
2419 auto OwnedUnit = make_unique<DwarfTypeUnit>(
2420 InfoHolder.getUnits().size() + TypeUnitsUnderConstruction.size(), CU, Asm,
2421 this, &InfoHolder, getDwoLineTable(CU));
2422 DwarfTypeUnit &NewTU = *OwnedUnit;
2423 DIE &UnitDie = NewTU.getUnitDie();
2425 TypeUnitsUnderConstruction.push_back(
2426 std::make_pair(std::move(OwnedUnit), CTy));
2428 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2431 uint64_t Signature = makeTypeSignature(Identifier);
2432 NewTU.setTypeSignature(Signature);
2434 if (useSplitDwarf())
2435 NewTU.initSection(Asm->getObjFileLowering().getDwarfTypesDWOSection(),
2436 DwarfTypesDWOSectionSym);
2438 CU.applyStmtList(UnitDie);
2440 Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2443 NewTU.setType(NewTU.createTypeDIE(CTy));
2446 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2447 TypeUnitsUnderConstruction.clear();
2449 // Types referencing entries in the address table cannot be placed in type
2451 if (AddrPool.hasBeenUsed()) {
2453 // Remove all the types built while building this type.
2454 // This is pessimistic as some of these types might not be dependent on
2455 // the type that used an address.
2456 for (const auto &TU : TypeUnitsToAdd)
2457 DwarfTypeUnits.erase(TU.second);
2459 // Construct this type in the CU directly.
2460 // This is inefficient because all the dependent types will be rebuilt
2461 // from scratch, including building them in type units, discovering that
2462 // they depend on addresses, throwing them out and rebuilding them.
2463 CU.constructTypeDIE(RefDie, CTy);
2467 // If the type wasn't dependent on fission addresses, finish adding the type
2468 // and all its dependent types.
2469 for (auto &TU : TypeUnitsToAdd) {
2470 if (useSplitDwarf())
2471 TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2472 InfoHolder.addUnit(std::move(TU.first));
2475 CU.addDIETypeSignature(RefDie, NewTU);
2478 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2479 MCSymbol *Begin, MCSymbol *End) {
2480 assert(Begin && "Begin label should not be null!");
2481 assert(End && "End label should not be null!");
2482 assert(Begin->isDefined() && "Invalid starting label");
2483 assert(End->isDefined() && "Invalid end label");
2485 Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2486 if (DwarfVersion < 4)
2487 Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2489 Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2492 // Accelerator table mutators - add each name along with its companion
2493 // DIE to the proper table while ensuring that the name that we're going
2494 // to reference is in the string table. We do this since the names we
2495 // add may not only be identical to the names in the DIE.
2496 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2497 if (!useDwarfAccelTables())
2499 AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2503 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2504 if (!useDwarfAccelTables())
2506 AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2510 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2511 if (!useDwarfAccelTables())
2513 AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2517 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2518 if (!useDwarfAccelTables())
2520 AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),