1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #include "ByteStreamer.h"
15 #include "DwarfDebug.h"
18 #include "DwarfUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DIBuilder.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/ValueHandle.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/LEB128.h"
42 #include "llvm/Support/MD5.h"
43 #include "llvm/Support/Path.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
52 #define DEBUG_TYPE "dwarfdebug"
55 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
56 cl::desc("Disable debug info printing"));
58 static cl::opt<bool> UnknownLocations(
59 "use-unknown-locations", cl::Hidden,
60 cl::desc("Make an absence of debug location information explicit."),
64 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
65 cl::desc("Generate GNU-style pubnames and pubtypes"),
68 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
70 cl::desc("Generate dwarf aranges"),
74 enum DefaultOnOff { Default, Enable, Disable };
77 static cl::opt<DefaultOnOff>
78 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
79 cl::desc("Output prototype dwarf accelerator tables."),
80 cl::values(clEnumVal(Default, "Default for platform"),
81 clEnumVal(Enable, "Enabled"),
82 clEnumVal(Disable, "Disabled"), clEnumValEnd),
85 static cl::opt<DefaultOnOff>
86 SplitDwarf("split-dwarf", cl::Hidden,
87 cl::desc("Output DWARF5 split debug info."),
88 cl::values(clEnumVal(Default, "Default for platform"),
89 clEnumVal(Enable, "Enabled"),
90 clEnumVal(Disable, "Disabled"), clEnumValEnd),
93 static cl::opt<DefaultOnOff>
94 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
95 cl::desc("Generate DWARF pubnames and pubtypes sections"),
96 cl::values(clEnumVal(Default, "Default for platform"),
97 clEnumVal(Enable, "Enabled"),
98 clEnumVal(Disable, "Disabled"), clEnumValEnd),
101 static 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 //===----------------------------------------------------------------------===//
110 /// resolve - Look in the DwarfDebug map for the MDNode that
111 /// corresponds to the reference.
112 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
113 return DD->resolve(Ref);
116 bool DbgVariable::isBlockByrefVariable() const {
117 assert(Var.isVariable() && "Invalid complex DbgVariable!");
118 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
121 DIType DbgVariable::getType() const {
122 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
123 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
124 // addresses instead.
125 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
126 /* Byref variables, in Blocks, are declared by the programmer as
127 "SomeType VarName;", but the compiler creates a
128 __Block_byref_x_VarName struct, and gives the variable VarName
129 either the struct, or a pointer to the struct, as its type. This
130 is necessary for various behind-the-scenes things the compiler
131 needs to do with by-reference variables in blocks.
133 However, as far as the original *programmer* is concerned, the
134 variable should still have type 'SomeType', as originally declared.
136 The following function dives into the __Block_byref_x_VarName
137 struct to find the original type of the variable. This will be
138 passed back to the code generating the type for the Debug
139 Information Entry for the variable 'VarName'. 'VarName' will then
140 have the original type 'SomeType' in its debug information.
142 The original type 'SomeType' will be the type of the field named
143 'VarName' inside the __Block_byref_x_VarName struct.
145 NOTE: In order for this to not completely fail on the debugger
146 side, the Debug Information Entry for the variable VarName needs to
147 have a DW_AT_location that tells the debugger how to unwind through
148 the pointers and __Block_byref_x_VarName struct to find the actual
149 value of the variable. The function addBlockByrefType does this. */
151 uint16_t tag = Ty.getTag();
153 if (tag == dwarf::DW_TAG_pointer_type)
154 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
156 DIArray Elements = DICompositeType(subType).getTypeArray();
157 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
158 DIDerivedType DT(Elements.getElement(i));
159 if (getName() == DT.getName())
160 return (resolve(DT.getTypeDerivedFrom()));
166 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
167 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
168 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
169 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
171 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
172 : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
173 GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
174 UsedNonDefaultText(false),
175 SkeletonHolder(A, "skel_string", DIEValueAllocator),
176 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
177 dwarf::DW_FORM_data4)),
178 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
179 dwarf::DW_FORM_data4)),
180 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
181 dwarf::DW_FORM_data4)),
182 AccelTypes(TypeAtoms) {
184 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
185 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
186 DwarfLineSectionSym = nullptr;
187 DwarfAddrSectionSym = nullptr;
188 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
189 FunctionBeginSym = FunctionEndSym = nullptr;
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 ? DwarfVersionNumber
213 : MMI->getModule()->getDwarfVersion();
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 DIArray FnArgs = SP.getType().getTypeArray();
472 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
473 .isUnspecifiedParameter()) {
475 make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
479 // Collect lexical scope children first.
480 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
481 Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
483 for (LexicalScope *LS : Scope->getChildren())
484 if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
485 Children.push_back(std::move(Nested));
486 return ObjectPointer;
489 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
490 LexicalScope *Scope, DIE &ScopeDIE) {
491 // We create children when the scope DIE is not null.
492 SmallVector<std::unique_ptr<DIE>, 8> Children;
493 if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
494 TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
497 for (auto &I : Children)
498 ScopeDIE.addChild(std::move(I));
501 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
502 LexicalScope *Scope) {
503 assert(Scope && Scope->getScopeNode());
504 assert(Scope->isAbstractScope());
505 assert(!Scope->getInlinedAt());
507 DISubprogram SP(Scope->getScopeNode());
509 ProcessedSPNodes.insert(SP);
511 DIE *&AbsDef = AbstractSPDies[SP];
515 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
516 // was inlined from another compile unit.
517 DwarfCompileUnit &SPCU = *SPMap[SP];
520 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
521 // the important distinction that the DIDescriptor is not associated with the
522 // DIE (since the DIDescriptor will be associated with the concrete DIE, if
523 // any). It could be refactored to some common utility function.
524 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
525 ContextDIE = &SPCU.getUnitDie();
526 SPCU.getOrCreateSubprogramDIE(SPDecl);
528 ContextDIE = SPCU.getOrCreateContextDIE(resolve(SP.getContext()));
530 // Passing null as the associated DIDescriptor because the abstract definition
531 // shouldn't be found by lookup.
532 AbsDef = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE,
534 SPCU.applySubprogramAttributesToDefinition(SP, *AbsDef);
536 SPCU.addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
537 createAndAddScopeChildren(SPCU, Scope, *AbsDef);
540 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
541 LexicalScope *Scope) {
542 assert(Scope && Scope->getScopeNode());
543 assert(!Scope->getInlinedAt());
544 assert(!Scope->isAbstractScope());
545 DISubprogram Sub(Scope->getScopeNode());
547 assert(Sub.isSubprogram());
549 ProcessedSPNodes.insert(Sub);
551 DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
553 createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
558 // Construct a DIE for this scope.
559 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
560 LexicalScope *Scope) {
561 if (!Scope || !Scope->getScopeNode())
564 DIScope DS(Scope->getScopeNode());
566 assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
567 "Only handle inlined subprograms here, use "
568 "constructSubprogramScopeDIE for non-inlined "
571 SmallVector<std::unique_ptr<DIE>, 8> Children;
573 // We try to create the scope DIE first, then the children DIEs. This will
574 // avoid creating un-used children then removing them later when we find out
575 // the scope DIE is null.
576 std::unique_ptr<DIE> ScopeDIE;
577 if (Scope->getParent() && DS.isSubprogram()) {
578 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
581 // We create children when the scope DIE is not null.
582 createScopeChildrenDIE(TheCU, Scope, Children);
584 // Early exit when we know the scope DIE is going to be null.
585 if (isLexicalScopeDIENull(Scope))
588 // We create children here when we know the scope DIE is not going to be
589 // null and the children will be added to the scope DIE.
590 createScopeChildrenDIE(TheCU, Scope, Children);
592 // There is no need to emit empty lexical block DIE.
593 std::pair<ImportedEntityMap::const_iterator,
594 ImportedEntityMap::const_iterator> Range =
595 std::equal_range(ScopesWithImportedEntities.begin(),
596 ScopesWithImportedEntities.end(),
597 std::pair<const MDNode *, const MDNode *>(DS, nullptr),
599 if (Children.empty() && Range.first == Range.second)
601 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
602 assert(ScopeDIE && "Scope DIE should not be null.");
603 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
605 constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
609 for (auto &I : Children)
610 ScopeDIE->addChild(std::move(I));
615 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
616 if (!GenerateGnuPubSections)
619 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
622 // Create new DwarfCompileUnit for the given metadata node with tag
623 // DW_TAG_compile_unit.
624 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
625 StringRef FN = DIUnit.getFilename();
626 CompilationDir = DIUnit.getDirectory();
628 auto OwnedUnit = make_unique<DwarfCompileUnit>(
629 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
630 DwarfCompileUnit &NewCU = *OwnedUnit;
631 DIE &Die = NewCU.getUnitDie();
632 InfoHolder.addUnit(std::move(OwnedUnit));
634 // LTO with assembly output shares a single line table amongst multiple CUs.
635 // To avoid the compilation directory being ambiguous, let the line table
636 // explicitly describe the directory of all files, never relying on the
637 // compilation directory.
638 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
639 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
640 NewCU.getUniqueID(), CompilationDir);
642 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
643 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
644 DIUnit.getLanguage());
645 NewCU.addString(Die, dwarf::DW_AT_name, FN);
647 if (!useSplitDwarf()) {
648 NewCU.initStmtList(DwarfLineSectionSym);
650 // If we're using split dwarf the compilation dir is going to be in the
651 // skeleton CU and so we don't need to duplicate it here.
652 if (!CompilationDir.empty())
653 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
655 addGnuPubAttributes(NewCU, Die);
658 if (DIUnit.isOptimized())
659 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
661 StringRef Flags = DIUnit.getFlags();
663 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
665 if (unsigned RVer = DIUnit.getRunTimeVersion())
666 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
667 dwarf::DW_FORM_data1, RVer);
672 if (useSplitDwarf()) {
673 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
674 DwarfInfoDWOSectionSym);
675 NewCU.setSkeleton(constructSkeletonCU(NewCU));
677 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
678 DwarfInfoSectionSym);
680 CUMap.insert(std::make_pair(DIUnit, &NewCU));
681 CUDieMap.insert(std::make_pair(&Die, &NewCU));
685 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
687 DIImportedEntity Module(N);
688 assert(Module.Verify());
689 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
690 constructImportedEntityDIE(TheCU, Module, *D);
693 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
694 const MDNode *N, DIE &Context) {
695 DIImportedEntity Module(N);
696 assert(Module.Verify());
697 return constructImportedEntityDIE(TheCU, Module, Context);
700 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
701 const DIImportedEntity &Module,
703 assert(Module.Verify() &&
704 "Use one of the MDNode * overloads to handle invalid metadata");
705 DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
707 DIDescriptor Entity = resolve(Module.getEntity());
708 if (Entity.isNameSpace())
709 EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
710 else if (Entity.isSubprogram())
711 EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
712 else if (Entity.isType())
713 EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
715 EntityDie = TheCU.getDIE(Entity);
716 TheCU.addSourceLine(IMDie, Module.getLineNumber(),
717 Module.getContext().getFilename(),
718 Module.getContext().getDirectory());
719 TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
720 StringRef Name = Module.getName();
722 TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
725 // Emit all Dwarf sections that should come prior to the content. Create
726 // global DIEs and emit initial debug info sections. This is invoked by
727 // the target AsmPrinter.
728 void DwarfDebug::beginModule() {
729 if (DisableDebugInfoPrinting)
732 const Module *M = MMI->getModule();
734 // If module has named metadata anchors then use them, otherwise scan the
735 // module using debug info finder to collect debug info.
736 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
739 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
741 // Emit initial sections so we can reference labels later.
744 SingleCU = CU_Nodes->getNumOperands() == 1;
746 for (MDNode *N : CU_Nodes->operands()) {
747 DICompileUnit CUNode(N);
748 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
749 DIArray ImportedEntities = CUNode.getImportedEntities();
750 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
751 ScopesWithImportedEntities.push_back(std::make_pair(
752 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
753 ImportedEntities.getElement(i)));
754 std::sort(ScopesWithImportedEntities.begin(),
755 ScopesWithImportedEntities.end(), less_first());
756 DIArray GVs = CUNode.getGlobalVariables();
757 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
758 CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
759 DIArray SPs = CUNode.getSubprograms();
760 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
761 SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
762 DIArray EnumTypes = CUNode.getEnumTypes();
763 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
764 CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
765 DIArray RetainedTypes = CUNode.getRetainedTypes();
766 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
767 DIType Ty(RetainedTypes.getElement(i));
768 // The retained types array by design contains pointers to
769 // MDNodes rather than DIRefs. Unique them here.
770 DIType UniqueTy(resolve(Ty.getRef()));
771 CU.getOrCreateTypeDIE(UniqueTy);
773 // Emit imported_modules last so that the relevant context is already
775 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
776 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
779 // Tell MMI that we have debug info.
780 MMI->setDebugInfoAvailability(true);
782 // Prime section data.
783 SectionMap[Asm->getObjFileLowering().getTextSection()];
786 void DwarfDebug::finishSubprogramDefinitions() {
787 const Module *M = MMI->getModule();
789 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
790 for (MDNode *N : CU_Nodes->operands()) {
791 DICompileUnit TheCU(N);
792 // Construct subprogram DIE and add variables DIEs.
793 DwarfCompileUnit *SPCU =
794 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
795 DIArray Subprograms = TheCU.getSubprograms();
796 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
797 DISubprogram SP(Subprograms.getElement(i));
798 // Perhaps the subprogram is in another CU (such as due to comdat
799 // folding, etc), in which case ignore it here.
800 if (SPMap[SP] != SPCU)
802 DIE *D = SPCU->getDIE(SP);
803 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
805 // If this subprogram has an abstract definition, reference that
806 SPCU->addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
809 // Lazily construct the subprogram if we didn't see either concrete or
810 // inlined versions during codegen.
811 D = SPCU->getOrCreateSubprogramDIE(SP);
812 // And attach the attributes
813 SPCU->applySubprogramAttributesToDefinition(SP, *D);
820 // Collect info for variables that were optimized out.
821 void DwarfDebug::collectDeadVariables() {
822 const Module *M = MMI->getModule();
824 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
825 for (MDNode *N : CU_Nodes->operands()) {
826 DICompileUnit TheCU(N);
827 // Construct subprogram DIE and add variables DIEs.
828 DwarfCompileUnit *SPCU =
829 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
830 assert(SPCU && "Unable to find Compile Unit!");
831 DIArray Subprograms = TheCU.getSubprograms();
832 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
833 DISubprogram SP(Subprograms.getElement(i));
834 if (ProcessedSPNodes.count(SP) != 0)
836 assert(SP.isSubprogram() &&
837 "CU's subprogram list contains a non-subprogram");
838 assert(SP.isDefinition() &&
839 "CU's subprogram list contains a subprogram declaration");
840 DIArray Variables = SP.getVariables();
841 if (Variables.getNumElements() == 0)
844 DIE *SPDIE = AbstractSPDies.lookup(SP);
846 SPDIE = SPCU->getDIE(SP);
848 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
849 DIVariable DV(Variables.getElement(vi));
850 assert(DV.isVariable());
851 DbgVariable NewVar(DV, nullptr, this);
852 SPDIE->addChild(SPCU->constructVariableDIE(NewVar));
859 void DwarfDebug::finalizeModuleInfo() {
860 finishSubprogramDefinitions();
862 // Collect info for variables that were optimized out.
863 collectDeadVariables();
865 // Handle anything that needs to be done on a per-unit basis after
866 // all other generation.
867 for (const auto &TheU : getUnits()) {
868 // Emit DW_AT_containing_type attribute to connect types with their
869 // vtable holding type.
870 TheU->constructContainingTypeDIEs();
872 // Add CU specific attributes if we need to add any.
873 if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
874 // If we're splitting the dwarf out now that we've got the entire
875 // CU then add the dwo id to it.
876 DwarfCompileUnit *SkCU =
877 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
878 if (useSplitDwarf()) {
879 // Emit a unique identifier for this CU.
880 uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
881 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
882 dwarf::DW_FORM_data8, ID);
883 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
884 dwarf::DW_FORM_data8, ID);
886 // We don't keep track of which addresses are used in which CU so this
887 // is a bit pessimistic under LTO.
888 if (!AddrPool.isEmpty())
889 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
890 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
891 DwarfAddrSectionSym);
892 if (!TheU->getRangeLists().empty())
893 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
894 dwarf::DW_AT_GNU_ranges_base,
895 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
898 // If we have code split among multiple sections or non-contiguous
899 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
900 // remain in the .o file, otherwise add a DW_AT_low_pc.
901 // FIXME: We should use ranges allow reordering of code ala
902 // .subsections_via_symbols in mach-o. This would mean turning on
903 // ranges for all subprogram DIEs for mach-o.
904 DwarfCompileUnit &U =
905 SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
906 unsigned NumRanges = TheU->getRanges().size();
909 addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
910 Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
911 DwarfDebugRangeSectionSym);
913 // A DW_AT_low_pc attribute may also be specified in combination with
914 // DW_AT_ranges to specify the default base address for use in
915 // location lists (see Section 2.6.2) and range lists (see Section
917 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
920 RangeSpan &Range = TheU->getRanges().back();
921 U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
923 U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
930 // Compute DIE offsets and sizes.
931 InfoHolder.computeSizeAndOffsets();
933 SkeletonHolder.computeSizeAndOffsets();
936 void DwarfDebug::endSections() {
937 // Filter labels by section.
938 for (const SymbolCU &SCU : ArangeLabels) {
939 if (SCU.Sym->isInSection()) {
940 // Make a note of this symbol and it's section.
941 const MCSection *Section = &SCU.Sym->getSection();
942 if (!Section->getKind().isMetadata())
943 SectionMap[Section].push_back(SCU);
945 // Some symbols (e.g. common/bss on mach-o) can have no section but still
946 // appear in the output. This sucks as we rely on sections to build
947 // arange spans. We can do it without, but it's icky.
948 SectionMap[nullptr].push_back(SCU);
952 // Build a list of sections used.
953 std::vector<const MCSection *> Sections;
954 for (const auto &it : SectionMap) {
955 const MCSection *Section = it.first;
956 Sections.push_back(Section);
959 // Sort the sections into order.
960 // This is only done to ensure consistent output order across different runs.
961 std::sort(Sections.begin(), Sections.end(), SectionSort);
963 // Add terminating symbols for each section.
964 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
965 const MCSection *Section = Sections[ID];
966 MCSymbol *Sym = nullptr;
969 // We can't call MCSection::getLabelEndName, as it's only safe to do so
970 // if we know the section name up-front. For user-created sections, the
971 // resulting label may not be valid to use as a label. (section names can
972 // use a greater set of characters on some systems)
973 Sym = Asm->GetTempSymbol("debug_end", ID);
974 Asm->OutStreamer.SwitchSection(Section);
975 Asm->OutStreamer.EmitLabel(Sym);
978 // Insert a final terminator.
979 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
983 // Emit all Dwarf sections that should come after the content.
984 void DwarfDebug::endModule() {
985 assert(CurFn == nullptr);
986 assert(CurMI == nullptr);
991 // End any existing sections.
992 // TODO: Does this need to happen?
995 // Finalize the debug info for the module.
996 finalizeModuleInfo();
1000 // Emit all the DIEs into a debug info section.
1003 // Corresponding abbreviations into a abbrev section.
1004 emitAbbreviations();
1006 // Emit info into a debug aranges section.
1007 if (GenerateARangeSection)
1010 // Emit info into a debug ranges section.
1013 if (useSplitDwarf()) {
1016 emitDebugAbbrevDWO();
1018 // Emit DWO addresses.
1019 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1022 // Emit info into a debug loc section.
1025 // Emit info into the dwarf accelerator table sections.
1026 if (useDwarfAccelTables()) {
1029 emitAccelNamespaces();
1033 // Emit the pubnames and pubtypes sections if requested.
1034 if (HasDwarfPubSections) {
1035 emitDebugPubNames(GenerateGnuPubSections);
1036 emitDebugPubTypes(GenerateGnuPubSections);
1041 AbstractVariables.clear();
1043 // Reset these for the next Module if we have one.
1047 // Find abstract variable, if any, associated with Var.
1048 DbgVariable *DwarfDebug::getExistingAbstractVariable(DIVariable &DV,
1049 DIVariable &Cleansed) {
1050 LLVMContext &Ctx = DV->getContext();
1051 // More then one inlined variable corresponds to one abstract variable.
1052 // FIXME: This duplication of variables when inlining should probably be
1053 // removed. It's done to allow each DIVariable to describe its location
1054 // because the DebugLoc on the dbg.value/declare isn't accurate. We should
1055 // make it accurate then remove this duplication/cleansing stuff.
1056 Cleansed = cleanseInlinedVariable(DV, Ctx);
1057 auto I = AbstractVariables.find(Cleansed);
1058 if (I != AbstractVariables.end())
1059 return I->second.get();
1063 DbgVariable *DwarfDebug::createAbstractVariable(DIVariable &Var,
1064 LexicalScope *Scope) {
1065 auto AbsDbgVariable = make_unique<DbgVariable>(Var, nullptr, this);
1066 addScopeVariable(Scope, AbsDbgVariable.get());
1067 return (AbstractVariables[Var] = std::move(AbsDbgVariable)).get();
1070 DbgVariable *DwarfDebug::getOrCreateAbstractVariable(DIVariable &DV,
1071 const MDNode *ScopeNode) {
1072 DIVariable Cleansed = DV;
1073 if (DbgVariable *Var = getExistingAbstractVariable(DV, Cleansed))
1076 return createAbstractVariable(Cleansed,
1077 LScopes.getOrCreateAbstractScope(ScopeNode));
1080 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1081 const MDNode *ScopeNode) {
1082 DIVariable Cleansed = DV;
1083 if (DbgVariable *Var = getExistingAbstractVariable(DV, Cleansed))
1086 if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
1087 return createAbstractVariable(Cleansed, Scope);
1091 // If Var is a current function argument then add it to CurrentFnArguments list.
1092 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1093 if (!LScopes.isCurrentFunctionScope(Scope))
1095 DIVariable DV = Var->getVariable();
1096 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1098 unsigned ArgNo = DV.getArgNumber();
1102 size_t Size = CurrentFnArguments.size();
1104 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1105 // llvm::Function argument size is not good indicator of how many
1106 // arguments does the function have at source level.
1108 CurrentFnArguments.resize(ArgNo * 2);
1109 CurrentFnArguments[ArgNo - 1] = Var;
1113 // Collect variable information from side table maintained by MMI.
1114 void DwarfDebug::collectVariableInfoFromMMITable(
1115 SmallPtrSet<const MDNode *, 16> &Processed) {
1116 for (const auto &VI : MMI->getVariableDbgInfo()) {
1119 Processed.insert(VI.Var);
1120 DIVariable DV(VI.Var);
1121 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1123 // If variable scope is not found then skip this variable.
1127 DbgVariable *AbsDbgVariable =
1128 findAbstractVariable(DV, Scope->getScopeNode());
1129 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1130 RegVar->setFrameIndex(VI.Slot);
1131 addScopeVariable(Scope, RegVar);
1135 // Get .debug_loc entry for the instruction range starting at MI.
1136 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1137 const MDNode *Var = MI->getDebugVariable();
1139 assert(MI->getNumOperands() == 3);
1140 if (MI->getOperand(0).isReg()) {
1141 MachineLocation MLoc;
1142 // If the second operand is an immediate, this is a
1143 // register-indirect address.
1144 if (!MI->getOperand(1).isImm())
1145 MLoc.set(MI->getOperand(0).getReg());
1147 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1148 return DebugLocEntry::Value(Var, MLoc);
1150 if (MI->getOperand(0).isImm())
1151 return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1152 if (MI->getOperand(0).isFPImm())
1153 return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1154 if (MI->getOperand(0).isCImm())
1155 return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1157 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1160 // Find variables for each lexical scope.
1162 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1163 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1164 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1166 // Grab the variable info that was squirreled away in the MMI side-table.
1167 collectVariableInfoFromMMITable(Processed);
1169 for (const auto &I : DbgValues) {
1170 DIVariable DV(I.first);
1171 if (Processed.count(DV))
1174 // Instruction ranges, specifying where DV is accessible.
1175 const auto &Ranges = I.second;
1179 LexicalScope *Scope = nullptr;
1180 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1181 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1182 Scope = LScopes.getCurrentFunctionScope();
1183 else if (MDNode *IA = DV.getInlinedAt()) {
1184 DebugLoc DL = DebugLoc::getFromDILocation(IA);
1185 Scope = LScopes.findInlinedScope(DebugLoc::get(
1186 DL.getLine(), DL.getCol(), DV.getContext(), IA));
1188 Scope = LScopes.findLexicalScope(DV.getContext());
1189 // If variable scope is not found then skip this variable.
1193 Processed.insert(DV);
1194 const MachineInstr *MInsn = Ranges.front().first;
1195 assert(MInsn->isDebugValue() && "History must begin with debug value");
1196 DbgVariable *AbsVar = findAbstractVariable(DV, Scope->getScopeNode());
1197 DbgVariable *RegVar = new DbgVariable(MInsn, AbsVar, this);
1198 addScopeVariable(Scope, RegVar);
1200 // Check if the first DBG_VALUE is valid for the rest of the function.
1201 if (Ranges.size() == 1 && Ranges.front().second == nullptr)
1204 // Handle multiple DBG_VALUE instructions describing one variable.
1205 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1207 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1208 DebugLocList &LocList = DotDebugLocEntries.back();
1210 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1211 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1212 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1213 const MachineInstr *Begin = I->first;
1214 const MachineInstr *End = I->second;
1215 assert(Begin->isDebugValue() && "Invalid History entry");
1217 // Check if a variable is unaccessible in this range.
1218 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1219 !Begin->getOperand(0).getReg())
1221 DEBUG(dbgs() << "DotDebugLoc Pair:\n" << "\t" << *Begin);
1223 DEBUG(dbgs() << "\t" << *End);
1225 DEBUG(dbgs() << "\tNULL\n");
1227 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1228 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1230 const MCSymbol *EndLabel;
1232 EndLabel = getLabelAfterInsn(End);
1233 else if (std::next(I) == Ranges.end())
1234 EndLabel = FunctionEndSym;
1236 EndLabel = getLabelBeforeInsn(std::next(I)->first);
1237 assert(EndLabel && "Forgot label after instruction ending a range!");
1239 DebugLocEntry Loc(StartLabel, EndLabel, getDebugLocValue(Begin), TheCU);
1240 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1241 DebugLoc.push_back(std::move(Loc));
1245 // Collect info for variables that were optimized out.
1246 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1247 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1248 DIVariable DV(Variables.getElement(i));
1249 assert(DV.isVariable());
1250 if (!Processed.insert(DV))
1252 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
1253 auto *RegVar = new DbgVariable(
1254 DV, findAbstractVariable(DV, Scope->getScopeNode()), this);
1255 addScopeVariable(Scope, RegVar);
1260 // Return Label preceding the instruction.
1261 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1262 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1263 assert(Label && "Didn't insert label before instruction");
1267 // Return Label immediately following the instruction.
1268 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1269 return LabelsAfterInsn.lookup(MI);
1272 // Process beginning of an instruction.
1273 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1274 assert(CurMI == nullptr);
1276 // Check if source location changes, but ignore DBG_VALUE locations.
1277 if (!MI->isDebugValue()) {
1278 DebugLoc DL = MI->getDebugLoc();
1279 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1282 if (DL == PrologEndLoc) {
1283 Flags |= DWARF2_FLAG_PROLOGUE_END;
1284 PrologEndLoc = DebugLoc();
1286 if (PrologEndLoc.isUnknown())
1287 Flags |= DWARF2_FLAG_IS_STMT;
1289 if (!DL.isUnknown()) {
1290 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1291 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1293 recordSourceLine(0, 0, nullptr, 0);
1297 // Insert labels where requested.
1298 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1299 LabelsBeforeInsn.find(MI);
1302 if (I == LabelsBeforeInsn.end())
1305 // Label already assigned.
1310 PrevLabel = MMI->getContext().CreateTempSymbol();
1311 Asm->OutStreamer.EmitLabel(PrevLabel);
1313 I->second = PrevLabel;
1316 // Process end of an instruction.
1317 void DwarfDebug::endInstruction() {
1318 assert(CurMI != nullptr);
1319 // Don't create a new label after DBG_VALUE instructions.
1320 // They don't generate code.
1321 if (!CurMI->isDebugValue())
1322 PrevLabel = nullptr;
1324 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1325 LabelsAfterInsn.find(CurMI);
1329 if (I == LabelsAfterInsn.end())
1332 // Label already assigned.
1336 // We need a label after this instruction.
1338 PrevLabel = MMI->getContext().CreateTempSymbol();
1339 Asm->OutStreamer.EmitLabel(PrevLabel);
1341 I->second = PrevLabel;
1344 // Each LexicalScope has first instruction and last instruction to mark
1345 // beginning and end of a scope respectively. Create an inverse map that list
1346 // scopes starts (and ends) with an instruction. One instruction may start (or
1347 // end) multiple scopes. Ignore scopes that are not reachable.
1348 void DwarfDebug::identifyScopeMarkers() {
1349 SmallVector<LexicalScope *, 4> WorkList;
1350 WorkList.push_back(LScopes.getCurrentFunctionScope());
1351 while (!WorkList.empty()) {
1352 LexicalScope *S = WorkList.pop_back_val();
1354 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1355 if (!Children.empty())
1356 WorkList.append(Children.begin(), Children.end());
1358 if (S->isAbstractScope())
1361 for (const InsnRange &R : S->getRanges()) {
1362 assert(R.first && "InsnRange does not have first instruction!");
1363 assert(R.second && "InsnRange does not have second instruction!");
1364 requestLabelBeforeInsn(R.first);
1365 requestLabelAfterInsn(R.second);
1370 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1371 // First known non-DBG_VALUE and non-frame setup location marks
1372 // the beginning of the function body.
1373 for (const auto &MBB : *MF)
1374 for (const auto &MI : MBB)
1375 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1376 !MI.getDebugLoc().isUnknown())
1377 return MI.getDebugLoc();
1381 // Gather pre-function debug information. Assumes being called immediately
1382 // after the function entry point has been emitted.
1383 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1386 // If there's no debug info for the function we're not going to do anything.
1387 if (!MMI->hasDebugInfo())
1390 // Grab the lexical scopes for the function, if we don't have any of those
1391 // then we're not going to be able to do anything.
1392 LScopes.initialize(*MF);
1393 if (LScopes.empty())
1396 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1398 // Make sure that each lexical scope will have a begin/end label.
1399 identifyScopeMarkers();
1401 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1402 // belongs to so that we add to the correct per-cu line table in the
1404 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1405 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1406 assert(TheCU && "Unable to find compile unit!");
1407 if (Asm->OutStreamer.hasRawTextSupport())
1408 // Use a single line table if we are generating assembly.
1409 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1411 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1413 // Emit a label for the function so that we have a beginning address.
1414 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1415 // Assumes in correct section after the entry point.
1416 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1418 // Calculate history for local variables.
1419 calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1421 // Request labels for the full history.
1422 for (const auto &I : DbgValues) {
1423 const auto &Ranges = I.second;
1427 // The first mention of a function argument gets the FunctionBeginSym
1428 // label, so arguments are visible when breaking at function entry.
1429 DIVariable DV(I.first);
1430 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1431 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1432 LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1434 for (const auto &Range : Ranges) {
1435 requestLabelBeforeInsn(Range.first);
1437 requestLabelAfterInsn(Range.second);
1441 PrevInstLoc = DebugLoc();
1442 PrevLabel = FunctionBeginSym;
1444 // Record beginning of function.
1445 PrologEndLoc = findPrologueEndLoc(MF);
1446 if (!PrologEndLoc.isUnknown()) {
1447 DebugLoc FnStartDL =
1448 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1450 FnStartDL.getLine(), FnStartDL.getCol(),
1451 FnStartDL.getScope(MF->getFunction()->getContext()),
1452 // We'd like to list the prologue as "not statements" but GDB behaves
1453 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1454 DWARF2_FLAG_IS_STMT);
1458 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1459 if (addCurrentFnArgument(Var, LS))
1461 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1462 DIVariable DV = Var->getVariable();
1463 // Variables with positive arg numbers are parameters.
1464 if (unsigned ArgNum = DV.getArgNumber()) {
1465 // Keep all parameters in order at the start of the variable list to ensure
1466 // function types are correct (no out-of-order parameters)
1468 // This could be improved by only doing it for optimized builds (unoptimized
1469 // builds have the right order to begin with), searching from the back (this
1470 // would catch the unoptimized case quickly), or doing a binary search
1471 // rather than linear search.
1472 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1473 while (I != Vars.end()) {
1474 unsigned CurNum = (*I)->getVariable().getArgNumber();
1475 // A local (non-parameter) variable has been found, insert immediately
1479 // A later indexed parameter has been found, insert immediately before it.
1480 if (CurNum > ArgNum)
1484 Vars.insert(I, Var);
1488 Vars.push_back(Var);
1491 // Gather and emit post-function debug information.
1492 void DwarfDebug::endFunction(const MachineFunction *MF) {
1493 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1494 // though the beginFunction may not be called at all.
1495 // We should handle both cases.
1499 assert(CurFn == MF);
1500 assert(CurFn != nullptr);
1502 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1503 // If we don't have a lexical scope for this function then there will
1504 // be a hole in the range information. Keep note of this by setting the
1505 // previously used section to nullptr.
1506 PrevSection = nullptr;
1512 // Define end label for subprogram.
1513 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1514 // Assumes in correct section after the entry point.
1515 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1517 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1518 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1520 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1521 collectVariableInfo(ProcessedVars);
1523 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1524 DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1526 // Construct abstract scopes.
1527 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1528 DISubprogram SP(AScope->getScopeNode());
1529 if (!SP.isSubprogram())
1531 // Collect info for variables that were optimized out.
1532 DIArray Variables = SP.getVariables();
1533 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1534 DIVariable DV(Variables.getElement(i));
1535 assert(DV && DV.isVariable());
1536 if (!ProcessedVars.insert(DV))
1538 getOrCreateAbstractVariable(DV, DV.getContext());
1540 constructAbstractSubprogramScopeDIE(TheCU, AScope);
1543 DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1544 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1545 TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1547 // Add the range of this function to the list of ranges for the CU.
1548 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1549 TheCU.addRange(std::move(Span));
1550 PrevSection = Asm->getCurrentSection();
1554 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1555 // DbgVariables except those that are also in AbstractVariables (since they
1556 // can be used cross-function)
1557 for (const auto &I : ScopeVariables)
1558 for (const auto *Var : I.second)
1559 if (!AbstractVariables.count(Var->getVariable()) || Var->getAbstractVariable())
1561 ScopeVariables.clear();
1562 DeleteContainerPointers(CurrentFnArguments);
1564 LabelsBeforeInsn.clear();
1565 LabelsAfterInsn.clear();
1566 PrevLabel = nullptr;
1570 // Register a source line with debug info. Returns the unique label that was
1571 // emitted and which provides correspondence to the source line list.
1572 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1577 unsigned Discriminator = 0;
1578 if (DIScope Scope = DIScope(S)) {
1579 assert(Scope.isScope());
1580 Fn = Scope.getFilename();
1581 Dir = Scope.getDirectory();
1582 if (Scope.isLexicalBlock())
1583 Discriminator = DILexicalBlock(S).getDiscriminator();
1585 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1586 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1587 .getOrCreateSourceID(Fn, Dir);
1589 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1593 //===----------------------------------------------------------------------===//
1595 //===----------------------------------------------------------------------===//
1597 // Emit initial Dwarf sections with a label at the start of each one.
1598 void DwarfDebug::emitSectionLabels() {
1599 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1601 // Dwarf sections base addresses.
1602 DwarfInfoSectionSym =
1603 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1604 if (useSplitDwarf())
1605 DwarfInfoDWOSectionSym =
1606 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1607 DwarfAbbrevSectionSym =
1608 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1609 if (useSplitDwarf())
1610 DwarfAbbrevDWOSectionSym = emitSectionSym(
1611 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1612 if (GenerateARangeSection)
1613 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1615 DwarfLineSectionSym =
1616 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1617 if (GenerateGnuPubSections) {
1618 DwarfGnuPubNamesSectionSym =
1619 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1620 DwarfGnuPubTypesSectionSym =
1621 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1622 } else if (HasDwarfPubSections) {
1623 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1624 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1627 DwarfStrSectionSym =
1628 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1629 if (useSplitDwarf()) {
1630 DwarfStrDWOSectionSym =
1631 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1632 DwarfAddrSectionSym =
1633 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1634 DwarfDebugLocSectionSym =
1635 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1637 DwarfDebugLocSectionSym =
1638 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1639 DwarfDebugRangeSectionSym =
1640 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1643 // Recursively emits a debug information entry.
1644 void DwarfDebug::emitDIE(DIE &Die) {
1645 // Get the abbreviation for this DIE.
1646 const DIEAbbrev &Abbrev = Die.getAbbrev();
1648 // Emit the code (index) for the abbreviation.
1649 if (Asm->isVerbose())
1650 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1651 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1652 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1653 dwarf::TagString(Abbrev.getTag()));
1654 Asm->EmitULEB128(Abbrev.getNumber());
1656 const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1657 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1659 // Emit the DIE attribute values.
1660 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1661 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1662 dwarf::Form Form = AbbrevData[i].getForm();
1663 assert(Form && "Too many attributes for DIE (check abbreviation)");
1665 if (Asm->isVerbose()) {
1666 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1667 if (Attr == dwarf::DW_AT_accessibility)
1668 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1669 cast<DIEInteger>(Values[i])->getValue()));
1672 // Emit an attribute using the defined form.
1673 Values[i]->EmitValue(Asm, Form);
1676 // Emit the DIE children if any.
1677 if (Abbrev.hasChildren()) {
1678 for (auto &Child : Die.getChildren())
1681 Asm->OutStreamer.AddComment("End Of Children Mark");
1686 // Emit the debug info section.
1687 void DwarfDebug::emitDebugInfo() {
1688 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1690 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1693 // Emit the abbreviation section.
1694 void DwarfDebug::emitAbbreviations() {
1695 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1697 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1700 // Emit the last address of the section and the end of the line matrix.
1701 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1702 // Define last address of section.
1703 Asm->OutStreamer.AddComment("Extended Op");
1706 Asm->OutStreamer.AddComment("Op size");
1707 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1708 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1709 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1711 Asm->OutStreamer.AddComment("Section end label");
1713 Asm->OutStreamer.EmitSymbolValue(
1714 Asm->GetTempSymbol("section_end", SectionEnd),
1715 Asm->getDataLayout().getPointerSize());
1717 // Mark end of matrix.
1718 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1724 // Emit visible names into a hashed accelerator table section.
1725 void DwarfDebug::emitAccelNames() {
1726 AccelNames.FinalizeTable(Asm, "Names");
1727 Asm->OutStreamer.SwitchSection(
1728 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1729 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1730 Asm->OutStreamer.EmitLabel(SectionBegin);
1732 // Emit the full data.
1733 AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1736 // Emit objective C classes and categories into a hashed accelerator table
1738 void DwarfDebug::emitAccelObjC() {
1739 AccelObjC.FinalizeTable(Asm, "ObjC");
1740 Asm->OutStreamer.SwitchSection(
1741 Asm->getObjFileLowering().getDwarfAccelObjCSection());
1742 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1743 Asm->OutStreamer.EmitLabel(SectionBegin);
1745 // Emit the full data.
1746 AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1749 // Emit namespace dies into a hashed accelerator table.
1750 void DwarfDebug::emitAccelNamespaces() {
1751 AccelNamespace.FinalizeTable(Asm, "namespac");
1752 Asm->OutStreamer.SwitchSection(
1753 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1754 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1755 Asm->OutStreamer.EmitLabel(SectionBegin);
1757 // Emit the full data.
1758 AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1761 // Emit type dies into a hashed accelerator table.
1762 void DwarfDebug::emitAccelTypes() {
1764 AccelTypes.FinalizeTable(Asm, "types");
1765 Asm->OutStreamer.SwitchSection(
1766 Asm->getObjFileLowering().getDwarfAccelTypesSection());
1767 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1768 Asm->OutStreamer.EmitLabel(SectionBegin);
1770 // Emit the full data.
1771 AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1774 // Public name handling.
1775 // The format for the various pubnames:
1777 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1778 // for the DIE that is named.
1780 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1781 // into the CU and the index value is computed according to the type of value
1782 // for the DIE that is named.
1784 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1785 // it's the offset within the debug_info/debug_types dwo section, however, the
1786 // reference in the pubname header doesn't change.
1788 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1789 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1791 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1793 // We could have a specification DIE that has our most of our knowledge,
1794 // look for that now.
1795 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1797 DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1798 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1799 Linkage = dwarf::GIEL_EXTERNAL;
1800 } else if (Die->findAttribute(dwarf::DW_AT_external))
1801 Linkage = dwarf::GIEL_EXTERNAL;
1803 switch (Die->getTag()) {
1804 case dwarf::DW_TAG_class_type:
1805 case dwarf::DW_TAG_structure_type:
1806 case dwarf::DW_TAG_union_type:
1807 case dwarf::DW_TAG_enumeration_type:
1808 return dwarf::PubIndexEntryDescriptor(
1809 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1810 ? dwarf::GIEL_STATIC
1811 : dwarf::GIEL_EXTERNAL);
1812 case dwarf::DW_TAG_typedef:
1813 case dwarf::DW_TAG_base_type:
1814 case dwarf::DW_TAG_subrange_type:
1815 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1816 case dwarf::DW_TAG_namespace:
1817 return dwarf::GIEK_TYPE;
1818 case dwarf::DW_TAG_subprogram:
1819 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1820 case dwarf::DW_TAG_constant:
1821 case dwarf::DW_TAG_variable:
1822 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1823 case dwarf::DW_TAG_enumerator:
1824 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1825 dwarf::GIEL_STATIC);
1827 return dwarf::GIEK_NONE;
1831 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1833 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1834 const MCSection *PSec =
1835 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1836 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1838 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1841 void DwarfDebug::emitDebugPubSection(
1842 bool GnuStyle, const MCSection *PSec, StringRef Name,
1843 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1844 for (const auto &NU : CUMap) {
1845 DwarfCompileUnit *TheU = NU.second;
1847 const auto &Globals = (TheU->*Accessor)();
1849 if (Globals.empty())
1852 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1854 unsigned ID = TheU->getUniqueID();
1856 // Start the dwarf pubnames section.
1857 Asm->OutStreamer.SwitchSection(PSec);
1860 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1861 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1862 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1863 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1865 Asm->OutStreamer.EmitLabel(BeginLabel);
1867 Asm->OutStreamer.AddComment("DWARF Version");
1868 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1870 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1871 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1873 Asm->OutStreamer.AddComment("Compilation Unit Length");
1874 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1876 // Emit the pubnames for this compilation unit.
1877 for (const auto &GI : Globals) {
1878 const char *Name = GI.getKeyData();
1879 const DIE *Entity = GI.second;
1881 Asm->OutStreamer.AddComment("DIE offset");
1882 Asm->EmitInt32(Entity->getOffset());
1885 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1886 Asm->OutStreamer.AddComment(
1887 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1888 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1889 Asm->EmitInt8(Desc.toBits());
1892 Asm->OutStreamer.AddComment("External Name");
1893 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1896 Asm->OutStreamer.AddComment("End Mark");
1898 Asm->OutStreamer.EmitLabel(EndLabel);
1902 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1903 const MCSection *PSec =
1904 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1905 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1907 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1910 // Emit visible names into a debug str section.
1911 void DwarfDebug::emitDebugStr() {
1912 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1913 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1916 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1917 const DebugLocEntry &Entry) {
1918 assert(Entry.getValues().size() == 1 &&
1919 "multi-value entries are not supported yet.");
1920 const DebugLocEntry::Value Value = Entry.getValues()[0];
1921 DIVariable DV(Value.getVariable());
1922 if (Value.isInt()) {
1923 DIBasicType BTy(resolve(DV.getType()));
1924 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1925 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1926 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1927 Streamer.EmitSLEB128(Value.getInt());
1929 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1930 Streamer.EmitULEB128(Value.getInt());
1932 } else if (Value.isLocation()) {
1933 MachineLocation Loc = Value.getLoc();
1934 if (!DV.hasComplexAddress())
1936 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1938 // Complex address entry.
1939 unsigned N = DV.getNumAddrElements();
1941 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1942 if (Loc.getOffset()) {
1944 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1945 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1946 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1947 Streamer.EmitSLEB128(DV.getAddrElement(1));
1949 // If first address element is OpPlus then emit
1950 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1951 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1952 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1956 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1959 // Emit remaining complex address elements.
1960 for (; i < N; ++i) {
1961 uint64_t Element = DV.getAddrElement(i);
1962 if (Element == DIBuilder::OpPlus) {
1963 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1964 Streamer.EmitULEB128(DV.getAddrElement(++i));
1965 } else if (Element == DIBuilder::OpDeref) {
1967 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1969 llvm_unreachable("unknown Opcode found in complex address");
1973 // else ... ignore constant fp. There is not any good way to
1974 // to represent them here in dwarf.
1978 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
1979 Asm->OutStreamer.AddComment("Loc expr size");
1980 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1981 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1982 Asm->EmitLabelDifference(end, begin, 2);
1983 Asm->OutStreamer.EmitLabel(begin);
1985 APByteStreamer Streamer(*Asm);
1986 emitDebugLocEntry(Streamer, Entry);
1988 Asm->OutStreamer.EmitLabel(end);
1991 // Emit locations into the debug loc section.
1992 void DwarfDebug::emitDebugLoc() {
1993 // Start the dwarf loc section.
1994 Asm->OutStreamer.SwitchSection(
1995 Asm->getObjFileLowering().getDwarfLocSection());
1996 unsigned char Size = Asm->getDataLayout().getPointerSize();
1997 for (const auto &DebugLoc : DotDebugLocEntries) {
1998 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
1999 for (const auto &Entry : DebugLoc.List) {
2000 // Set up the range. This range is relative to the entry point of the
2001 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2002 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2003 const DwarfCompileUnit *CU = Entry.getCU();
2004 if (CU->getRanges().size() == 1) {
2005 // Grab the begin symbol from the first range as our base.
2006 const MCSymbol *Base = CU->getRanges()[0].getStart();
2007 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2008 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2010 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2011 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2014 emitDebugLocEntryLocation(Entry);
2016 Asm->OutStreamer.EmitIntValue(0, Size);
2017 Asm->OutStreamer.EmitIntValue(0, Size);
2021 void DwarfDebug::emitDebugLocDWO() {
2022 Asm->OutStreamer.SwitchSection(
2023 Asm->getObjFileLowering().getDwarfLocDWOSection());
2024 for (const auto &DebugLoc : DotDebugLocEntries) {
2025 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2026 for (const auto &Entry : DebugLoc.List) {
2027 // Just always use start_length for now - at least that's one address
2028 // rather than two. We could get fancier and try to, say, reuse an
2029 // address we know we've emitted elsewhere (the start of the function?
2030 // The start of the CU or CU subrange that encloses this range?)
2031 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2032 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2033 Asm->EmitULEB128(idx);
2034 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2036 emitDebugLocEntryLocation(Entry);
2038 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2043 const MCSymbol *Start, *End;
2046 // Emit a debug aranges section, containing a CU lookup for any
2047 // address we can tie back to a CU.
2048 void DwarfDebug::emitDebugARanges() {
2049 // Start the dwarf aranges section.
2050 Asm->OutStreamer.SwitchSection(
2051 Asm->getObjFileLowering().getDwarfARangesSection());
2053 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2057 // Build a list of sections used.
2058 std::vector<const MCSection *> Sections;
2059 for (const auto &it : SectionMap) {
2060 const MCSection *Section = it.first;
2061 Sections.push_back(Section);
2064 // Sort the sections into order.
2065 // This is only done to ensure consistent output order across different runs.
2066 std::sort(Sections.begin(), Sections.end(), SectionSort);
2068 // Build a set of address spans, sorted by CU.
2069 for (const MCSection *Section : Sections) {
2070 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2071 if (List.size() < 2)
2074 // Sort the symbols by offset within the section.
2075 std::sort(List.begin(), List.end(),
2076 [&](const SymbolCU &A, const SymbolCU &B) {
2077 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2078 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2080 // Symbols with no order assigned should be placed at the end.
2081 // (e.g. section end labels)
2089 // If we have no section (e.g. common), just write out
2090 // individual spans for each symbol.
2092 for (const SymbolCU &Cur : List) {
2094 Span.Start = Cur.Sym;
2097 Spans[Cur.CU].push_back(Span);
2100 // Build spans between each label.
2101 const MCSymbol *StartSym = List[0].Sym;
2102 for (size_t n = 1, e = List.size(); n < e; n++) {
2103 const SymbolCU &Prev = List[n - 1];
2104 const SymbolCU &Cur = List[n];
2106 // Try and build the longest span we can within the same CU.
2107 if (Cur.CU != Prev.CU) {
2109 Span.Start = StartSym;
2111 Spans[Prev.CU].push_back(Span);
2118 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2120 // Build a list of CUs used.
2121 std::vector<DwarfCompileUnit *> CUs;
2122 for (const auto &it : Spans) {
2123 DwarfCompileUnit *CU = it.first;
2127 // Sort the CU list (again, to ensure consistent output order).
2128 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2129 return A->getUniqueID() < B->getUniqueID();
2132 // Emit an arange table for each CU we used.
2133 for (DwarfCompileUnit *CU : CUs) {
2134 std::vector<ArangeSpan> &List = Spans[CU];
2136 // Emit size of content not including length itself.
2137 unsigned ContentSize =
2138 sizeof(int16_t) + // DWARF ARange version number
2139 sizeof(int32_t) + // Offset of CU in the .debug_info section
2140 sizeof(int8_t) + // Pointer Size (in bytes)
2141 sizeof(int8_t); // Segment Size (in bytes)
2143 unsigned TupleSize = PtrSize * 2;
2145 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2147 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2149 ContentSize += Padding;
2150 ContentSize += (List.size() + 1) * TupleSize;
2152 // For each compile unit, write the list of spans it covers.
2153 Asm->OutStreamer.AddComment("Length of ARange Set");
2154 Asm->EmitInt32(ContentSize);
2155 Asm->OutStreamer.AddComment("DWARF Arange version number");
2156 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2157 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2158 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2159 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2160 Asm->EmitInt8(PtrSize);
2161 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2164 Asm->OutStreamer.EmitFill(Padding, 0xff);
2166 for (const ArangeSpan &Span : List) {
2167 Asm->EmitLabelReference(Span.Start, PtrSize);
2169 // Calculate the size as being from the span start to it's end.
2171 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2173 // For symbols without an end marker (e.g. common), we
2174 // write a single arange entry containing just that one symbol.
2175 uint64_t Size = SymSize[Span.Start];
2179 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2183 Asm->OutStreamer.AddComment("ARange terminator");
2184 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2185 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2189 // Emit visible names into a debug ranges section.
2190 void DwarfDebug::emitDebugRanges() {
2191 // Start the dwarf ranges section.
2192 Asm->OutStreamer.SwitchSection(
2193 Asm->getObjFileLowering().getDwarfRangesSection());
2195 // Size for our labels.
2196 unsigned char Size = Asm->getDataLayout().getPointerSize();
2198 // Grab the specific ranges for the compile units in the module.
2199 for (const auto &I : CUMap) {
2200 DwarfCompileUnit *TheCU = I.second;
2202 // Iterate over the misc ranges for the compile units in the module.
2203 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2204 // Emit our symbol so we can find the beginning of the range.
2205 Asm->OutStreamer.EmitLabel(List.getSym());
2207 for (const RangeSpan &Range : List.getRanges()) {
2208 const MCSymbol *Begin = Range.getStart();
2209 const MCSymbol *End = Range.getEnd();
2210 assert(Begin && "Range without a begin symbol?");
2211 assert(End && "Range without an end symbol?");
2212 if (TheCU->getRanges().size() == 1) {
2213 // Grab the begin symbol from the first range as our base.
2214 const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2215 Asm->EmitLabelDifference(Begin, Base, Size);
2216 Asm->EmitLabelDifference(End, Base, Size);
2218 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2219 Asm->OutStreamer.EmitSymbolValue(End, Size);
2223 // And terminate the list with two 0 values.
2224 Asm->OutStreamer.EmitIntValue(0, Size);
2225 Asm->OutStreamer.EmitIntValue(0, Size);
2228 // Now emit a range for the CU itself.
2229 if (TheCU->getRanges().size() > 1) {
2230 Asm->OutStreamer.EmitLabel(
2231 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2232 for (const RangeSpan &Range : TheCU->getRanges()) {
2233 const MCSymbol *Begin = Range.getStart();
2234 const MCSymbol *End = Range.getEnd();
2235 assert(Begin && "Range without a begin symbol?");
2236 assert(End && "Range without an end symbol?");
2237 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2238 Asm->OutStreamer.EmitSymbolValue(End, Size);
2240 // And terminate the list with two 0 values.
2241 Asm->OutStreamer.EmitIntValue(0, Size);
2242 Asm->OutStreamer.EmitIntValue(0, Size);
2247 // DWARF5 Experimental Separate Dwarf emitters.
2249 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2250 std::unique_ptr<DwarfUnit> NewU) {
2251 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2252 U.getCUNode().getSplitDebugFilename());
2254 if (!CompilationDir.empty())
2255 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2257 addGnuPubAttributes(*NewU, Die);
2259 SkeletonHolder.addUnit(std::move(NewU));
2262 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2263 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2264 // DW_AT_addr_base, DW_AT_ranges_base.
2265 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2267 auto OwnedUnit = make_unique<DwarfCompileUnit>(
2268 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2269 DwarfCompileUnit &NewCU = *OwnedUnit;
2270 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2271 DwarfInfoSectionSym);
2273 NewCU.initStmtList(DwarfLineSectionSym);
2275 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2280 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2282 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2283 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2284 *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2286 auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2288 DwarfTypeUnit &NewTU = *OwnedUnit;
2289 NewTU.setTypeSignature(TU.getTypeSignature());
2290 NewTU.setType(nullptr);
2292 Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2294 initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2298 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2299 // compile units that would normally be in debug_info.
2300 void DwarfDebug::emitDebugInfoDWO() {
2301 assert(useSplitDwarf() && "No split dwarf debug info?");
2302 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2303 // emit relocations into the dwo file.
2304 InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2307 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2308 // abbreviations for the .debug_info.dwo section.
2309 void DwarfDebug::emitDebugAbbrevDWO() {
2310 assert(useSplitDwarf() && "No split dwarf?");
2311 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2314 void DwarfDebug::emitDebugLineDWO() {
2315 assert(useSplitDwarf() && "No split dwarf?");
2316 Asm->OutStreamer.SwitchSection(
2317 Asm->getObjFileLowering().getDwarfLineDWOSection());
2318 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2321 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2322 // string section and is identical in format to traditional .debug_str
2324 void DwarfDebug::emitDebugStrDWO() {
2325 assert(useSplitDwarf() && "No split dwarf?");
2326 const MCSection *OffSec =
2327 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2328 const MCSymbol *StrSym = DwarfStrSectionSym;
2329 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2333 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2334 if (!useSplitDwarf())
2337 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2338 return &SplitTypeUnitFileTable;
2341 static uint64_t makeTypeSignature(StringRef Identifier) {
2343 Hash.update(Identifier);
2344 // ... take the least significant 8 bytes and return those. Our MD5
2345 // implementation always returns its results in little endian, swap bytes
2347 MD5::MD5Result Result;
2349 return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2352 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2353 StringRef Identifier, DIE &RefDie,
2354 DICompositeType CTy) {
2355 // Fast path if we're building some type units and one has already used the
2356 // address pool we know we're going to throw away all this work anyway, so
2357 // don't bother building dependent types.
2358 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2361 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2363 CU.addDIETypeSignature(RefDie, *TU);
2367 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2368 AddrPool.resetUsedFlag();
2371 make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), CU, Asm, this,
2372 &InfoHolder, getDwoLineTable(CU));
2373 DwarfTypeUnit &NewTU = *OwnedUnit;
2374 DIE &UnitDie = NewTU.getUnitDie();
2376 TypeUnitsUnderConstruction.push_back(
2377 std::make_pair(std::move(OwnedUnit), CTy));
2379 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2382 uint64_t Signature = makeTypeSignature(Identifier);
2383 NewTU.setTypeSignature(Signature);
2385 if (!useSplitDwarf())
2386 CU.applyStmtList(UnitDie);
2388 // FIXME: Skip using COMDAT groups for type units in the .dwo file once tools
2389 // such as DWP ( http://gcc.gnu.org/wiki/DebugFissionDWP ) can cope with it.
2392 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2393 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2395 NewTU.setType(NewTU.createTypeDIE(CTy));
2398 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2399 TypeUnitsUnderConstruction.clear();
2401 // Types referencing entries in the address table cannot be placed in type
2403 if (AddrPool.hasBeenUsed()) {
2405 // Remove all the types built while building this type.
2406 // This is pessimistic as some of these types might not be dependent on
2407 // the type that used an address.
2408 for (const auto &TU : TypeUnitsToAdd)
2409 DwarfTypeUnits.erase(TU.second);
2411 // Construct this type in the CU directly.
2412 // This is inefficient because all the dependent types will be rebuilt
2413 // from scratch, including building them in type units, discovering that
2414 // they depend on addresses, throwing them out and rebuilding them.
2415 CU.constructTypeDIE(RefDie, CTy);
2419 // If the type wasn't dependent on fission addresses, finish adding the type
2420 // and all its dependent types.
2421 for (auto &TU : TypeUnitsToAdd) {
2422 if (useSplitDwarf())
2423 TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2424 InfoHolder.addUnit(std::move(TU.first));
2427 CU.addDIETypeSignature(RefDie, NewTU);
2430 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2431 MCSymbol *Begin, MCSymbol *End) {
2432 assert(Begin && "Begin label should not be null!");
2433 assert(End && "End label should not be null!");
2434 assert(Begin->isDefined() && "Invalid starting label");
2435 assert(End->isDefined() && "Invalid end label");
2437 Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2438 if (DwarfVersion < 4)
2439 Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2441 Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2444 // Accelerator table mutators - add each name along with its companion
2445 // DIE to the proper table while ensuring that the name that we're going
2446 // to reference is in the string table. We do this since the names we
2447 // add may not only be identical to the names in the DIE.
2448 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2449 if (!useDwarfAccelTables())
2451 AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2455 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2456 if (!useDwarfAccelTables())
2458 AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2462 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2463 if (!useDwarfAccelTables())
2465 AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2469 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2470 if (!useDwarfAccelTables())
2472 AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),