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 const char *const DWARFGroupName = "DWARF Emission";
102 static const char *const DbgTimerName = "DWARF Debug Writer";
104 //===----------------------------------------------------------------------===//
106 /// resolve - Look in the DwarfDebug map for the MDNode that
107 /// corresponds to the reference.
108 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
109 return DD->resolve(Ref);
112 bool DbgVariable::isBlockByrefVariable() const {
113 assert(Var.isVariable() && "Invalid complex DbgVariable!");
114 return Var.isBlockByrefVariable(DD->getTypeIdentifierMap());
117 DIType DbgVariable::getType() const {
118 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
119 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
120 // addresses instead.
121 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
122 /* Byref variables, in Blocks, are declared by the programmer as
123 "SomeType VarName;", but the compiler creates a
124 __Block_byref_x_VarName struct, and gives the variable VarName
125 either the struct, or a pointer to the struct, as its type. This
126 is necessary for various behind-the-scenes things the compiler
127 needs to do with by-reference variables in blocks.
129 However, as far as the original *programmer* is concerned, the
130 variable should still have type 'SomeType', as originally declared.
132 The following function dives into the __Block_byref_x_VarName
133 struct to find the original type of the variable. This will be
134 passed back to the code generating the type for the Debug
135 Information Entry for the variable 'VarName'. 'VarName' will then
136 have the original type 'SomeType' in its debug information.
138 The original type 'SomeType' will be the type of the field named
139 'VarName' inside the __Block_byref_x_VarName struct.
141 NOTE: In order for this to not completely fail on the debugger
142 side, the Debug Information Entry for the variable VarName needs to
143 have a DW_AT_location that tells the debugger how to unwind through
144 the pointers and __Block_byref_x_VarName struct to find the actual
145 value of the variable. The function addBlockByrefType does this. */
147 uint16_t tag = Ty.getTag();
149 if (tag == dwarf::DW_TAG_pointer_type)
150 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
152 DIArray Elements = DICompositeType(subType).getTypeArray();
153 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
154 DIDerivedType DT(Elements.getElement(i));
155 if (getName() == DT.getName())
156 return (resolve(DT.getTypeDerivedFrom()));
162 static LLVM_CONSTEXPR DwarfAccelTable::Atom TypeAtoms[] = {
163 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
164 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
165 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
167 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
168 : Asm(A), MMI(Asm->MMI), FirstCU(nullptr), PrevLabel(nullptr),
169 GlobalRangeCount(0), InfoHolder(A, "info_string", DIEValueAllocator),
170 UsedNonDefaultText(false),
171 SkeletonHolder(A, "skel_string", DIEValueAllocator),
172 AccelNames(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
173 dwarf::DW_FORM_data4)),
174 AccelObjC(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
175 dwarf::DW_FORM_data4)),
176 AccelNamespace(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
177 dwarf::DW_FORM_data4)),
178 AccelTypes(TypeAtoms) {
180 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = nullptr;
181 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = nullptr;
182 DwarfLineSectionSym = nullptr;
183 DwarfAddrSectionSym = nullptr;
184 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = nullptr;
185 FunctionBeginSym = FunctionEndSym = nullptr;
189 // Turn on accelerator tables for Darwin by default, pubnames by
190 // default for non-Darwin, and handle split dwarf.
191 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
193 if (DwarfAccelTables == Default)
194 HasDwarfAccelTables = IsDarwin;
196 HasDwarfAccelTables = DwarfAccelTables == Enable;
198 if (SplitDwarf == Default)
199 HasSplitDwarf = false;
201 HasSplitDwarf = SplitDwarf == Enable;
203 if (DwarfPubSections == Default)
204 HasDwarfPubSections = !IsDarwin;
206 HasDwarfPubSections = DwarfPubSections == Enable;
208 unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
209 DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
210 : MMI->getModule()->getDwarfVersion();
212 Asm->OutStreamer.getContext().setDwarfVersion(DwarfVersion);
215 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
220 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
221 DwarfDebug::~DwarfDebug() { }
223 // Switch to the specified MCSection and emit an assembler
224 // temporary label to it if SymbolStem is specified.
225 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
226 const char *SymbolStem = nullptr) {
227 Asm->OutStreamer.SwitchSection(Section);
231 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
232 Asm->OutStreamer.EmitLabel(TmpSym);
236 static bool isObjCClass(StringRef Name) {
237 return Name.startswith("+") || Name.startswith("-");
240 static bool hasObjCCategory(StringRef Name) {
241 if (!isObjCClass(Name))
244 return Name.find(") ") != StringRef::npos;
247 static void getObjCClassCategory(StringRef In, StringRef &Class,
248 StringRef &Category) {
249 if (!hasObjCCategory(In)) {
250 Class = In.slice(In.find('[') + 1, In.find(' '));
255 Class = In.slice(In.find('[') + 1, In.find('('));
256 Category = In.slice(In.find('[') + 1, In.find(' '));
260 static StringRef getObjCMethodName(StringRef In) {
261 return In.slice(In.find(' ') + 1, In.find(']'));
264 // Helper for sorting sections into a stable output order.
265 static bool SectionSort(const MCSection *A, const MCSection *B) {
266 std::string LA = (A ? A->getLabelBeginName() : "");
267 std::string LB = (B ? B->getLabelBeginName() : "");
271 // Add the various names to the Dwarf accelerator table names.
272 // TODO: Determine whether or not we should add names for programs
273 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
274 // is only slightly different than the lookup of non-standard ObjC names.
275 void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
276 if (!SP.isDefinition())
278 addAccelName(SP.getName(), Die);
280 // If the linkage name is different than the name, go ahead and output
281 // that as well into the name table.
282 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
283 addAccelName(SP.getLinkageName(), Die);
285 // If this is an Objective-C selector name add it to the ObjC accelerator
287 if (isObjCClass(SP.getName())) {
288 StringRef Class, Category;
289 getObjCClassCategory(SP.getName(), Class, Category);
290 addAccelObjC(Class, Die);
292 addAccelObjC(Category, Die);
293 // Also add the base method name to the name table.
294 addAccelName(getObjCMethodName(SP.getName()), Die);
298 /// isSubprogramContext - Return true if Context is either a subprogram
299 /// or another context nested inside a subprogram.
300 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
303 DIDescriptor D(Context);
304 if (D.isSubprogram())
307 return isSubprogramContext(resolve(DIType(Context).getContext()));
311 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
312 // and DW_AT_high_pc attributes. If there are global variables in this
313 // scope then create and insert DIEs for these variables.
314 DIE &DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit &SPCU,
316 DIE *SPDie = SPCU.getOrCreateSubprogramDIE(SP);
318 attachLowHighPC(SPCU, *SPDie, FunctionBeginSym, FunctionEndSym);
320 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
321 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
322 SPCU.addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
324 // Add name to the name table, we do this here because we're guaranteed
325 // to have concrete versions of our DW_TAG_subprogram nodes.
326 addSubprogramNames(SP, *SPDie);
331 /// Check whether we should create a DIE for the given Scope, return true
332 /// if we don't create a DIE (the corresponding DIE is null).
333 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
334 if (Scope->isAbstractScope())
337 // We don't create a DIE if there is no Range.
338 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
342 if (Ranges.size() > 1)
345 // We don't create a DIE if we have a single Range and the end label
347 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
348 MCSymbol *End = getLabelAfterInsn(RI->second);
352 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE &D,
353 dwarf::Attribute A, const MCSymbol *L,
354 const MCSymbol *Sec) {
355 if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
356 U.addSectionLabel(D, A, L);
358 U.addSectionDelta(D, A, L, Sec);
361 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE &ScopeDIE,
362 const SmallVectorImpl<InsnRange> &Range) {
363 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
364 // emitting it appropriately.
365 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
367 // Under fission, ranges are specified by constant offsets relative to the
368 // CU's DW_AT_GNU_ranges_base.
370 TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
371 DwarfDebugRangeSectionSym);
373 addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
374 DwarfDebugRangeSectionSym);
376 RangeSpanList List(RangeSym);
377 for (const InsnRange &R : Range) {
378 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
379 List.addRange(std::move(Span));
382 // Add the range list to the set of ranges to be emitted.
383 TheCU.addRangeList(std::move(List));
386 void DwarfDebug::attachRangesOrLowHighPC(DwarfCompileUnit &TheCU, DIE &Die,
387 const SmallVectorImpl<InsnRange> &Ranges) {
388 assert(!Ranges.empty());
389 if (Ranges.size() == 1)
390 attachLowHighPC(TheCU, Die, getLabelBeforeInsn(Ranges.front().first),
391 getLabelAfterInsn(Ranges.front().second));
393 addScopeRangeList(TheCU, Die, Ranges);
396 // Construct new DW_TAG_lexical_block for this scope and attach
397 // DW_AT_low_pc/DW_AT_high_pc labels.
399 DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
400 LexicalScope *Scope) {
401 if (isLexicalScopeDIENull(Scope))
404 auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_lexical_block);
405 if (Scope->isAbstractScope())
408 attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
413 // This scope represents inlined body of a function. Construct DIE to
414 // represent this concrete inlined copy of the function.
416 DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
417 LexicalScope *Scope) {
418 assert(Scope->getScopeNode());
419 DIScope DS(Scope->getScopeNode());
420 DISubprogram InlinedSP = getDISubprogram(DS);
421 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
422 // was inlined from another compile unit.
423 DIE *OriginDIE = AbstractSPDies[InlinedSP];
424 assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
426 auto ScopeDIE = make_unique<DIE>(dwarf::DW_TAG_inlined_subroutine);
427 TheCU.addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
429 attachRangesOrLowHighPC(TheCU, *ScopeDIE, Scope->getRanges());
431 InlinedSubprogramDIEs.insert(OriginDIE);
433 // Add the call site information to the DIE.
434 DILocation DL(Scope->getInlinedAt());
435 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
436 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
437 TheCU.addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
439 // Add name to the name table, we do this here because we're guaranteed
440 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
441 addSubprogramNames(InlinedSP, *ScopeDIE);
446 static std::unique_ptr<DIE> constructVariableDIE(DwarfCompileUnit &TheCU,
448 const LexicalScope &Scope,
449 DIE *&ObjectPointer) {
450 auto Var = TheCU.constructVariableDIE(DV, Scope.isAbstractScope());
451 if (DV.isObjectPointer())
452 ObjectPointer = Var.get();
456 DIE *DwarfDebug::createScopeChildrenDIE(
457 DwarfCompileUnit &TheCU, LexicalScope *Scope,
458 SmallVectorImpl<std::unique_ptr<DIE>> &Children) {
459 DIE *ObjectPointer = nullptr;
461 // Collect arguments for current function.
462 if (LScopes.isCurrentFunctionScope(Scope)) {
463 for (DbgVariable *ArgDV : CurrentFnArguments)
466 constructVariableDIE(TheCU, *ArgDV, *Scope, ObjectPointer));
468 // If this is a variadic function, add an unspecified parameter.
469 DISubprogram SP(Scope->getScopeNode());
470 DIArray FnArgs = SP.getType().getTypeArray();
471 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
472 .isUnspecifiedParameter()) {
474 make_unique<DIE>(dwarf::DW_TAG_unspecified_parameters));
478 // Collect lexical scope children first.
479 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
480 Children.push_back(constructVariableDIE(TheCU, *DV, *Scope, ObjectPointer));
482 for (LexicalScope *LS : Scope->getChildren())
483 if (std::unique_ptr<DIE> Nested = constructScopeDIE(TheCU, LS))
484 Children.push_back(std::move(Nested));
485 return ObjectPointer;
488 void DwarfDebug::createAndAddScopeChildren(DwarfCompileUnit &TheCU,
489 LexicalScope *Scope, DIE &ScopeDIE) {
490 // We create children when the scope DIE is not null.
491 SmallVector<std::unique_ptr<DIE>, 8> Children;
492 if (DIE *ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children))
493 TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
496 for (auto &I : Children)
497 ScopeDIE.addChild(std::move(I));
500 void DwarfDebug::constructAbstractSubprogramScopeDIE(DwarfCompileUnit &TheCU,
501 LexicalScope *Scope) {
502 assert(Scope && Scope->getScopeNode());
503 assert(Scope->isAbstractScope());
504 assert(!Scope->getInlinedAt());
506 DISubprogram SP(Scope->getScopeNode());
508 ProcessedSPNodes.insert(SP);
510 DIE *&AbsDef = AbstractSPDies[SP];
514 // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
515 // was inlined from another compile unit.
516 DwarfCompileUnit &SPCU = *SPMap[SP];
519 // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
520 // the important distinction that the DIDescriptor is not associated with the
521 // DIE (since the DIDescriptor will be associated with the concrete DIE, if
522 // any). It could be refactored to some common utility function.
523 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) {
524 ContextDIE = &SPCU.getUnitDie();
525 SPCU.getOrCreateSubprogramDIE(SPDecl);
527 ContextDIE = SPCU.getOrCreateContextDIE(resolve(SP.getContext()));
529 // Passing null as the associated DIDescriptor because the abstract definition
530 // shouldn't be found by lookup.
531 AbsDef = &SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE,
533 SPCU.applySubprogramAttributesToDefinition(SP, *AbsDef);
535 SPCU.addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
536 createAndAddScopeChildren(SPCU, Scope, *AbsDef);
539 DIE &DwarfDebug::constructSubprogramScopeDIE(DwarfCompileUnit &TheCU,
540 LexicalScope *Scope) {
541 assert(Scope && Scope->getScopeNode());
542 assert(!Scope->getInlinedAt());
543 assert(!Scope->isAbstractScope());
544 DISubprogram Sub(Scope->getScopeNode());
546 assert(Sub.isSubprogram());
548 ProcessedSPNodes.insert(Sub);
550 DIE &ScopeDIE = updateSubprogramScopeDIE(TheCU, Sub);
552 createAndAddScopeChildren(TheCU, Scope, ScopeDIE);
557 // Construct a DIE for this scope.
558 std::unique_ptr<DIE> DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
559 LexicalScope *Scope) {
560 if (!Scope || !Scope->getScopeNode())
563 DIScope DS(Scope->getScopeNode());
565 assert((Scope->getInlinedAt() || !DS.isSubprogram()) &&
566 "Only handle inlined subprograms here, use "
567 "constructSubprogramScopeDIE for non-inlined "
570 SmallVector<std::unique_ptr<DIE>, 8> Children;
572 // We try to create the scope DIE first, then the children DIEs. This will
573 // avoid creating un-used children then removing them later when we find out
574 // the scope DIE is null.
575 std::unique_ptr<DIE> ScopeDIE;
576 if (Scope->getParent() && DS.isSubprogram()) {
577 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
580 // We create children when the scope DIE is not null.
581 createScopeChildrenDIE(TheCU, Scope, Children);
583 // Early exit when we know the scope DIE is going to be null.
584 if (isLexicalScopeDIENull(Scope))
587 // We create children here when we know the scope DIE is not going to be
588 // null and the children will be added to the scope DIE.
589 createScopeChildrenDIE(TheCU, Scope, Children);
591 // There is no need to emit empty lexical block DIE.
592 std::pair<ImportedEntityMap::const_iterator,
593 ImportedEntityMap::const_iterator> Range =
594 std::equal_range(ScopesWithImportedEntities.begin(),
595 ScopesWithImportedEntities.end(),
596 std::pair<const MDNode *, const MDNode *>(DS, nullptr),
598 if (Children.empty() && Range.first == Range.second)
600 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
601 assert(ScopeDIE && "Scope DIE should not be null.");
602 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
604 constructImportedEntityDIE(TheCU, i->second, *ScopeDIE);
608 for (auto &I : Children)
609 ScopeDIE->addChild(std::move(I));
614 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE &D) const {
615 if (!GenerateGnuPubSections)
618 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
621 // Create new DwarfCompileUnit for the given metadata node with tag
622 // DW_TAG_compile_unit.
623 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
624 StringRef FN = DIUnit.getFilename();
625 CompilationDir = DIUnit.getDirectory();
627 auto OwnedUnit = make_unique<DwarfCompileUnit>(
628 InfoHolder.getUnits().size(), DIUnit, Asm, this, &InfoHolder);
629 DwarfCompileUnit &NewCU = *OwnedUnit;
630 DIE &Die = NewCU.getUnitDie();
631 InfoHolder.addUnit(std::move(OwnedUnit));
633 // LTO with assembly output shares a single line table amongst multiple CUs.
634 // To avoid the compilation directory being ambiguous, let the line table
635 // explicitly describe the directory of all files, never relying on the
636 // compilation directory.
637 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
638 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
639 NewCU.getUniqueID(), CompilationDir);
641 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
642 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
643 DIUnit.getLanguage());
644 NewCU.addString(Die, dwarf::DW_AT_name, FN);
646 if (!useSplitDwarf()) {
647 NewCU.initStmtList(DwarfLineSectionSym);
649 // If we're using split dwarf the compilation dir is going to be in the
650 // skeleton CU and so we don't need to duplicate it here.
651 if (!CompilationDir.empty())
652 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
654 addGnuPubAttributes(NewCU, Die);
657 if (DIUnit.isOptimized())
658 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
660 StringRef Flags = DIUnit.getFlags();
662 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
664 if (unsigned RVer = DIUnit.getRunTimeVersion())
665 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
666 dwarf::DW_FORM_data1, RVer);
671 if (useSplitDwarf()) {
672 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
673 DwarfInfoDWOSectionSym);
674 NewCU.setSkeleton(constructSkeletonCU(NewCU));
676 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
677 DwarfInfoSectionSym);
679 CUMap.insert(std::make_pair(DIUnit, &NewCU));
680 CUDieMap.insert(std::make_pair(&Die, &NewCU));
684 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
686 DIImportedEntity Module(N);
687 assert(Module.Verify());
688 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
689 constructImportedEntityDIE(TheCU, Module, *D);
692 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
693 const MDNode *N, DIE &Context) {
694 DIImportedEntity Module(N);
695 assert(Module.Verify());
696 return constructImportedEntityDIE(TheCU, Module, Context);
699 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
700 const DIImportedEntity &Module,
702 assert(Module.Verify() &&
703 "Use one of the MDNode * overloads to handle invalid metadata");
704 DIE &IMDie = TheCU.createAndAddDIE(Module.getTag(), Context, Module);
706 DIDescriptor Entity = resolve(Module.getEntity());
707 if (Entity.isNameSpace())
708 EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
709 else if (Entity.isSubprogram())
710 EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
711 else if (Entity.isType())
712 EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
714 EntityDie = TheCU.getDIE(Entity);
715 TheCU.addSourceLine(IMDie, Module.getLineNumber(),
716 Module.getContext().getFilename(),
717 Module.getContext().getDirectory());
718 TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, *EntityDie);
719 StringRef Name = Module.getName();
721 TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
724 // Emit all Dwarf sections that should come prior to the content. Create
725 // global DIEs and emit initial debug info sections. This is invoked by
726 // the target AsmPrinter.
727 void DwarfDebug::beginModule() {
728 if (DisableDebugInfoPrinting)
731 const Module *M = MMI->getModule();
733 FunctionDIs = makeSubprogramMap(*M);
735 // If module has named metadata anchors then use them, otherwise scan the
736 // module using debug info finder to collect debug info.
737 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
740 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
742 // Emit initial sections so we can reference labels later.
745 SingleCU = CU_Nodes->getNumOperands() == 1;
747 for (MDNode *N : CU_Nodes->operands()) {
748 DICompileUnit CUNode(N);
749 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
750 DIArray ImportedEntities = CUNode.getImportedEntities();
751 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
752 ScopesWithImportedEntities.push_back(std::make_pair(
753 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
754 ImportedEntities.getElement(i)));
755 std::sort(ScopesWithImportedEntities.begin(),
756 ScopesWithImportedEntities.end(), less_first());
757 DIArray GVs = CUNode.getGlobalVariables();
758 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
759 CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
760 DIArray SPs = CUNode.getSubprograms();
761 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
762 SPMap.insert(std::make_pair(SPs.getElement(i), &CU));
763 DIArray EnumTypes = CUNode.getEnumTypes();
764 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
765 CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
766 DIArray RetainedTypes = CUNode.getRetainedTypes();
767 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
768 DIType Ty(RetainedTypes.getElement(i));
769 // The retained 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 // Emit imported_modules last so that the relevant context is already
776 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
777 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
780 // Tell MMI that we have debug info.
781 MMI->setDebugInfoAvailability(true);
783 // Prime section data.
784 SectionMap[Asm->getObjFileLowering().getTextSection()];
787 void DwarfDebug::finishVariableDefinitions() {
788 for (const auto &Var : ConcreteVariables) {
789 DIE *VariableDie = Var->getDIE();
790 // FIXME: There shouldn't be any variables without DIEs.
793 // FIXME: Consider the time-space tradeoff of just storing the unit pointer
794 // in the ConcreteVariables list, rather than looking it up again here.
795 // DIE::getUnit isn't simple - it walks parent pointers, etc.
796 DwarfCompileUnit *Unit = lookupUnit(VariableDie->getUnit());
798 DbgVariable *AbsVar = getExistingAbstractVariable(Var->getVariable());
799 if (AbsVar && AbsVar->getDIE()) {
800 Unit->addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
803 Unit->applyVariableAttributes(*Var, *VariableDie);
807 void DwarfDebug::finishSubprogramDefinitions() {
808 const Module *M = MMI->getModule();
810 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
811 for (MDNode *N : CU_Nodes->operands()) {
812 DICompileUnit TheCU(N);
813 // Construct subprogram DIE and add variables DIEs.
814 DwarfCompileUnit *SPCU =
815 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
816 DIArray Subprograms = TheCU.getSubprograms();
817 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
818 DISubprogram SP(Subprograms.getElement(i));
819 // Perhaps the subprogram is in another CU (such as due to comdat
820 // folding, etc), in which case ignore it here.
821 if (SPMap[SP] != SPCU)
823 DIE *D = SPCU->getDIE(SP);
824 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
826 // If this subprogram has an abstract definition, reference that
827 SPCU->addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
830 // Lazily construct the subprogram if we didn't see either concrete or
831 // inlined versions during codegen.
832 D = SPCU->getOrCreateSubprogramDIE(SP);
833 // And attach the attributes
834 SPCU->applySubprogramAttributesToDefinition(SP, *D);
841 // Collect info for variables that were optimized out.
842 void DwarfDebug::collectDeadVariables() {
843 const Module *M = MMI->getModule();
845 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
846 for (MDNode *N : CU_Nodes->operands()) {
847 DICompileUnit TheCU(N);
848 // Construct subprogram DIE and add variables DIEs.
849 DwarfCompileUnit *SPCU =
850 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
851 assert(SPCU && "Unable to find Compile Unit!");
852 DIArray Subprograms = TheCU.getSubprograms();
853 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
854 DISubprogram SP(Subprograms.getElement(i));
855 if (ProcessedSPNodes.count(SP) != 0)
857 assert(SP.isSubprogram() &&
858 "CU's subprogram list contains a non-subprogram");
859 assert(SP.isDefinition() &&
860 "CU's subprogram list contains a subprogram declaration");
861 DIArray Variables = SP.getVariables();
862 if (Variables.getNumElements() == 0)
865 DIE *SPDIE = AbstractSPDies.lookup(SP);
867 SPDIE = SPCU->getDIE(SP);
869 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
870 DIVariable DV(Variables.getElement(vi));
871 assert(DV.isVariable());
872 DbgVariable NewVar(DV, this);
873 auto VariableDie = SPCU->constructVariableDIE(NewVar);
874 SPCU->applyVariableAttributes(NewVar, *VariableDie);
875 SPDIE->addChild(std::move(VariableDie));
882 void DwarfDebug::finalizeModuleInfo() {
883 finishSubprogramDefinitions();
885 finishVariableDefinitions();
887 // Collect info for variables that were optimized out.
888 collectDeadVariables();
890 // Handle anything that needs to be done on a per-unit basis after
891 // all other generation.
892 for (const auto &TheU : getUnits()) {
893 // Emit DW_AT_containing_type attribute to connect types with their
894 // vtable holding type.
895 TheU->constructContainingTypeDIEs();
897 // Add CU specific attributes if we need to add any.
898 if (TheU->getUnitDie().getTag() == dwarf::DW_TAG_compile_unit) {
899 // If we're splitting the dwarf out now that we've got the entire
900 // CU then add the dwo id to it.
901 DwarfCompileUnit *SkCU =
902 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
903 if (useSplitDwarf()) {
904 // Emit a unique identifier for this CU.
905 uint64_t ID = DIEHash(Asm).computeCUSignature(TheU->getUnitDie());
906 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
907 dwarf::DW_FORM_data8, ID);
908 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
909 dwarf::DW_FORM_data8, ID);
911 // We don't keep track of which addresses are used in which CU so this
912 // is a bit pessimistic under LTO.
913 if (!AddrPool.isEmpty())
914 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
915 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
916 DwarfAddrSectionSym);
917 if (!TheU->getRangeLists().empty())
918 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
919 dwarf::DW_AT_GNU_ranges_base,
920 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
923 // If we have code split among multiple sections or non-contiguous
924 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
925 // remain in the .o file, otherwise add a DW_AT_low_pc.
926 // FIXME: We should use ranges allow reordering of code ala
927 // .subsections_via_symbols in mach-o. This would mean turning on
928 // ranges for all subprogram DIEs for mach-o.
929 DwarfCompileUnit &U =
930 SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
931 unsigned NumRanges = TheU->getRanges().size();
934 addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
935 Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
936 DwarfDebugRangeSectionSym);
938 // A DW_AT_low_pc attribute may also be specified in combination with
939 // DW_AT_ranges to specify the default base address for use in
940 // location lists (see Section 2.6.2) and range lists (see Section
942 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
945 RangeSpan &Range = TheU->getRanges().back();
946 U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
948 U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
955 // Compute DIE offsets and sizes.
956 InfoHolder.computeSizeAndOffsets();
958 SkeletonHolder.computeSizeAndOffsets();
961 void DwarfDebug::endSections() {
962 // Filter labels by section.
963 for (const SymbolCU &SCU : ArangeLabels) {
964 if (SCU.Sym->isInSection()) {
965 // Make a note of this symbol and it's section.
966 const MCSection *Section = &SCU.Sym->getSection();
967 if (!Section->getKind().isMetadata())
968 SectionMap[Section].push_back(SCU);
970 // Some symbols (e.g. common/bss on mach-o) can have no section but still
971 // appear in the output. This sucks as we rely on sections to build
972 // arange spans. We can do it without, but it's icky.
973 SectionMap[nullptr].push_back(SCU);
977 // Build a list of sections used.
978 std::vector<const MCSection *> Sections;
979 for (const auto &it : SectionMap) {
980 const MCSection *Section = it.first;
981 Sections.push_back(Section);
984 // Sort the sections into order.
985 // This is only done to ensure consistent output order across different runs.
986 std::sort(Sections.begin(), Sections.end(), SectionSort);
988 // Add terminating symbols for each section.
989 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
990 const MCSection *Section = Sections[ID];
991 MCSymbol *Sym = nullptr;
994 // We can't call MCSection::getLabelEndName, as it's only safe to do so
995 // if we know the section name up-front. For user-created sections, the
996 // resulting label may not be valid to use as a label. (section names can
997 // use a greater set of characters on some systems)
998 Sym = Asm->GetTempSymbol("debug_end", ID);
999 Asm->OutStreamer.SwitchSection(Section);
1000 Asm->OutStreamer.EmitLabel(Sym);
1003 // Insert a final terminator.
1004 SectionMap[Section].push_back(SymbolCU(nullptr, Sym));
1008 // Emit all Dwarf sections that should come after the content.
1009 void DwarfDebug::endModule() {
1010 assert(CurFn == nullptr);
1011 assert(CurMI == nullptr);
1016 // End any existing sections.
1017 // TODO: Does this need to happen?
1020 // Finalize the debug info for the module.
1021 finalizeModuleInfo();
1025 // Emit all the DIEs into a debug info section.
1028 // Corresponding abbreviations into a abbrev section.
1029 emitAbbreviations();
1031 // Emit info into a debug aranges section.
1032 if (GenerateARangeSection)
1035 // Emit info into a debug ranges section.
1038 if (useSplitDwarf()) {
1041 emitDebugAbbrevDWO();
1044 // Emit DWO addresses.
1045 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1047 // Emit info into a debug loc section.
1050 // Emit info into the dwarf accelerator table sections.
1051 if (useDwarfAccelTables()) {
1054 emitAccelNamespaces();
1058 // Emit the pubnames and pubtypes sections if requested.
1059 if (HasDwarfPubSections) {
1060 emitDebugPubNames(GenerateGnuPubSections);
1061 emitDebugPubTypes(GenerateGnuPubSections);
1066 AbstractVariables.clear();
1068 // Reset these for the next Module if we have one.
1072 // Find abstract variable, if any, associated with Var.
1073 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV,
1074 DIVariable &Cleansed) {
1075 LLVMContext &Ctx = DV->getContext();
1076 // More then one inlined variable corresponds to one abstract variable.
1077 // FIXME: This duplication of variables when inlining should probably be
1078 // removed. It's done to allow each DIVariable to describe its location
1079 // because the DebugLoc on the dbg.value/declare isn't accurate. We should
1080 // make it accurate then remove this duplication/cleansing stuff.
1081 Cleansed = cleanseInlinedVariable(DV, Ctx);
1082 auto I = AbstractVariables.find(Cleansed);
1083 if (I != AbstractVariables.end())
1084 return I->second.get();
1088 DbgVariable *DwarfDebug::getExistingAbstractVariable(const DIVariable &DV) {
1089 DIVariable Cleansed;
1090 return getExistingAbstractVariable(DV, Cleansed);
1093 void DwarfDebug::createAbstractVariable(const DIVariable &Var,
1094 LexicalScope *Scope) {
1095 auto AbsDbgVariable = make_unique<DbgVariable>(Var, this);
1096 addScopeVariable(Scope, AbsDbgVariable.get());
1097 AbstractVariables[Var] = std::move(AbsDbgVariable);
1100 void DwarfDebug::ensureAbstractVariableIsCreated(const DIVariable &DV,
1101 const MDNode *ScopeNode) {
1102 DIVariable Cleansed = DV;
1103 if (getExistingAbstractVariable(DV, Cleansed))
1106 createAbstractVariable(Cleansed, LScopes.getOrCreateAbstractScope(ScopeNode));
1110 DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(const DIVariable &DV,
1111 const MDNode *ScopeNode) {
1112 DIVariable Cleansed = DV;
1113 if (getExistingAbstractVariable(DV, Cleansed))
1116 if (LexicalScope *Scope = LScopes.findAbstractScope(ScopeNode))
1117 createAbstractVariable(Cleansed, Scope);
1120 // If Var is a current function argument then add it to CurrentFnArguments list.
1121 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1122 if (!LScopes.isCurrentFunctionScope(Scope))
1124 DIVariable DV = Var->getVariable();
1125 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1127 unsigned ArgNo = DV.getArgNumber();
1131 size_t Size = CurrentFnArguments.size();
1133 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1134 // llvm::Function argument size is not good indicator of how many
1135 // arguments does the function have at source level.
1137 CurrentFnArguments.resize(ArgNo * 2);
1138 CurrentFnArguments[ArgNo - 1] = Var;
1142 // Collect variable information from side table maintained by MMI.
1143 void DwarfDebug::collectVariableInfoFromMMITable(
1144 SmallPtrSet<const MDNode *, 16> &Processed) {
1145 for (const auto &VI : MMI->getVariableDbgInfo()) {
1148 Processed.insert(VI.Var);
1149 DIVariable DV(VI.Var);
1150 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1152 // If variable scope is not found then skip this variable.
1156 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1157 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1158 DbgVariable *RegVar = ConcreteVariables.back().get();
1159 RegVar->setFrameIndex(VI.Slot);
1160 addScopeVariable(Scope, RegVar);
1164 // Get .debug_loc entry for the instruction range starting at MI.
1165 static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
1166 const MDNode *Var = MI->getDebugVariable();
1168 assert(MI->getNumOperands() == 3);
1169 if (MI->getOperand(0).isReg()) {
1170 MachineLocation MLoc;
1171 // If the second operand is an immediate, this is a
1172 // register-indirect address.
1173 if (!MI->getOperand(1).isImm())
1174 MLoc.set(MI->getOperand(0).getReg());
1176 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1177 return DebugLocEntry::Value(Var, MLoc);
1179 if (MI->getOperand(0).isImm())
1180 return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
1181 if (MI->getOperand(0).isFPImm())
1182 return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
1183 if (MI->getOperand(0).isCImm())
1184 return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
1186 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1189 // Find variables for each lexical scope.
1191 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1192 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1193 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1195 // Grab the variable info that was squirreled away in the MMI side-table.
1196 collectVariableInfoFromMMITable(Processed);
1198 for (const auto &I : DbgValues) {
1199 DIVariable DV(I.first);
1200 if (Processed.count(DV))
1203 // Instruction ranges, specifying where DV is accessible.
1204 const auto &Ranges = I.second;
1208 LexicalScope *Scope = nullptr;
1209 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1210 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1211 Scope = LScopes.getCurrentFunctionScope();
1212 else if (MDNode *IA = DV.getInlinedAt()) {
1213 DebugLoc DL = DebugLoc::getFromDILocation(IA);
1214 Scope = LScopes.findInlinedScope(DebugLoc::get(
1215 DL.getLine(), DL.getCol(), DV.getContext(), IA));
1217 Scope = LScopes.findLexicalScope(DV.getContext());
1218 // If variable scope is not found then skip this variable.
1222 Processed.insert(DV);
1223 const MachineInstr *MInsn = Ranges.front().first;
1224 assert(MInsn->isDebugValue() && "History must begin with debug value");
1225 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1226 ConcreteVariables.push_back(make_unique<DbgVariable>(MInsn, this));
1227 DbgVariable *RegVar = ConcreteVariables.back().get();
1228 addScopeVariable(Scope, RegVar);
1230 // Check if the first DBG_VALUE is valid for the rest of the function.
1231 if (Ranges.size() == 1 && Ranges.front().second == nullptr)
1234 // Handle multiple DBG_VALUE instructions describing one variable.
1235 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1237 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1238 DebugLocList &LocList = DotDebugLocEntries.back();
1240 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1241 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1242 for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1243 const MachineInstr *Begin = I->first;
1244 const MachineInstr *End = I->second;
1245 assert(Begin->isDebugValue() && "Invalid History entry");
1247 // Check if a variable is unaccessible in this range.
1248 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1249 !Begin->getOperand(0).getReg())
1251 DEBUG(dbgs() << "DotDebugLoc Pair:\n" << "\t" << *Begin);
1253 DEBUG(dbgs() << "\t" << *End);
1255 DEBUG(dbgs() << "\tNULL\n");
1257 const MCSymbol *StartLabel = getLabelBeforeInsn(Begin);
1258 assert(StartLabel && "Forgot label before DBG_VALUE starting a range!");
1260 const MCSymbol *EndLabel;
1262 EndLabel = getLabelAfterInsn(End);
1263 else if (std::next(I) == Ranges.end())
1264 EndLabel = FunctionEndSym;
1266 EndLabel = getLabelBeforeInsn(std::next(I)->first);
1267 assert(EndLabel && "Forgot label after instruction ending a range!");
1269 DebugLocEntry Loc(StartLabel, EndLabel, getDebugLocValue(Begin), TheCU);
1270 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1271 DebugLoc.push_back(std::move(Loc));
1275 // Collect info for variables that were optimized out.
1276 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1277 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1278 DIVariable DV(Variables.getElement(i));
1279 assert(DV.isVariable());
1280 if (!Processed.insert(DV))
1282 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext())) {
1283 ensureAbstractVariableIsCreatedIfScoped(DV, Scope->getScopeNode());
1284 ConcreteVariables.push_back(make_unique<DbgVariable>(DV, this));
1285 addScopeVariable(Scope, ConcreteVariables.back().get());
1290 // Return Label preceding the instruction.
1291 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1292 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1293 assert(Label && "Didn't insert label before instruction");
1297 // Return Label immediately following the instruction.
1298 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1299 return LabelsAfterInsn.lookup(MI);
1302 // Process beginning of an instruction.
1303 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1304 assert(CurMI == nullptr);
1306 // Check if source location changes, but ignore DBG_VALUE locations.
1307 if (!MI->isDebugValue()) {
1308 DebugLoc DL = MI->getDebugLoc();
1309 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1312 if (DL == PrologEndLoc) {
1313 Flags |= DWARF2_FLAG_PROLOGUE_END;
1314 PrologEndLoc = DebugLoc();
1316 if (PrologEndLoc.isUnknown())
1317 Flags |= DWARF2_FLAG_IS_STMT;
1319 if (!DL.isUnknown()) {
1320 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1321 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1323 recordSourceLine(0, 0, nullptr, 0);
1327 // Insert labels where requested.
1328 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1329 LabelsBeforeInsn.find(MI);
1332 if (I == LabelsBeforeInsn.end())
1335 // Label already assigned.
1340 PrevLabel = MMI->getContext().CreateTempSymbol();
1341 Asm->OutStreamer.EmitLabel(PrevLabel);
1343 I->second = PrevLabel;
1346 // Process end of an instruction.
1347 void DwarfDebug::endInstruction() {
1348 assert(CurMI != nullptr);
1349 // Don't create a new label after DBG_VALUE instructions.
1350 // They don't generate code.
1351 if (!CurMI->isDebugValue())
1352 PrevLabel = nullptr;
1354 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1355 LabelsAfterInsn.find(CurMI);
1359 if (I == LabelsAfterInsn.end())
1362 // Label already assigned.
1366 // We need a label after this instruction.
1368 PrevLabel = MMI->getContext().CreateTempSymbol();
1369 Asm->OutStreamer.EmitLabel(PrevLabel);
1371 I->second = PrevLabel;
1374 // Each LexicalScope has first instruction and last instruction to mark
1375 // beginning and end of a scope respectively. Create an inverse map that list
1376 // scopes starts (and ends) with an instruction. One instruction may start (or
1377 // end) multiple scopes. Ignore scopes that are not reachable.
1378 void DwarfDebug::identifyScopeMarkers() {
1379 SmallVector<LexicalScope *, 4> WorkList;
1380 WorkList.push_back(LScopes.getCurrentFunctionScope());
1381 while (!WorkList.empty()) {
1382 LexicalScope *S = WorkList.pop_back_val();
1384 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1385 if (!Children.empty())
1386 WorkList.append(Children.begin(), Children.end());
1388 if (S->isAbstractScope())
1391 for (const InsnRange &R : S->getRanges()) {
1392 assert(R.first && "InsnRange does not have first instruction!");
1393 assert(R.second && "InsnRange does not have second instruction!");
1394 requestLabelBeforeInsn(R.first);
1395 requestLabelAfterInsn(R.second);
1400 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
1401 // First known non-DBG_VALUE and non-frame setup location marks
1402 // the beginning of the function body.
1403 for (const auto &MBB : *MF)
1404 for (const auto &MI : MBB)
1405 if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1406 !MI.getDebugLoc().isUnknown())
1407 return MI.getDebugLoc();
1411 // Gather pre-function debug information. Assumes being called immediately
1412 // after the function entry point has been emitted.
1413 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1416 // If there's no debug info for the function we're not going to do anything.
1417 if (!MMI->hasDebugInfo())
1420 auto DI = FunctionDIs.find(MF->getFunction());
1421 if (DI == FunctionDIs.end())
1424 // Grab the lexical scopes for the function, if we don't have any of those
1425 // then we're not going to be able to do anything.
1426 LScopes.initialize(*MF);
1427 if (LScopes.empty())
1430 assert(DbgValues.empty() && "DbgValues map wasn't cleaned!");
1432 // Make sure that each lexical scope will have a begin/end label.
1433 identifyScopeMarkers();
1435 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1436 // belongs to so that we add to the correct per-cu line table in the
1438 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1439 // FnScope->getScopeNode() and DI->second should represent the same function,
1440 // though they may not be the same MDNode due to inline functions merged in
1441 // LTO where the debug info metadata still differs (either due to distinct
1442 // written differences - two versions of a linkonce_odr function
1443 // written/copied into two separate files, or some sub-optimal metadata that
1444 // isn't structurally identical (see: file path/name info from clang, which
1445 // includes the directory of the cpp file being built, even when the file name
1446 // is absolute (such as an <> lookup header)))
1447 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1448 assert(TheCU && "Unable to find compile unit!");
1449 if (Asm->OutStreamer.hasRawTextSupport())
1450 // Use a single line table if we are generating assembly.
1451 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1453 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1455 // Emit a label for the function so that we have a beginning address.
1456 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1457 // Assumes in correct section after the entry point.
1458 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1460 // Calculate history for local variables.
1461 calculateDbgValueHistory(MF, Asm->TM.getRegisterInfo(), DbgValues);
1463 // Request labels for the full history.
1464 for (const auto &I : DbgValues) {
1465 const auto &Ranges = I.second;
1469 // The first mention of a function argument gets the FunctionBeginSym
1470 // label, so arguments are visible when breaking at function entry.
1471 DIVariable DV(I.first);
1472 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1473 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1474 LabelsBeforeInsn[Ranges.front().first] = FunctionBeginSym;
1476 for (const auto &Range : Ranges) {
1477 requestLabelBeforeInsn(Range.first);
1479 requestLabelAfterInsn(Range.second);
1483 PrevInstLoc = DebugLoc();
1484 PrevLabel = FunctionBeginSym;
1486 // Record beginning of function.
1487 PrologEndLoc = findPrologueEndLoc(MF);
1488 if (!PrologEndLoc.isUnknown()) {
1489 DebugLoc FnStartDL =
1490 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1492 FnStartDL.getLine(), FnStartDL.getCol(),
1493 FnStartDL.getScope(MF->getFunction()->getContext()),
1494 // We'd like to list the prologue as "not statements" but GDB behaves
1495 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1496 DWARF2_FLAG_IS_STMT);
1500 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1501 if (addCurrentFnArgument(Var, LS))
1503 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1504 DIVariable DV = Var->getVariable();
1505 // Variables with positive arg numbers are parameters.
1506 if (unsigned ArgNum = DV.getArgNumber()) {
1507 // Keep all parameters in order at the start of the variable list to ensure
1508 // function types are correct (no out-of-order parameters)
1510 // This could be improved by only doing it for optimized builds (unoptimized
1511 // builds have the right order to begin with), searching from the back (this
1512 // would catch the unoptimized case quickly), or doing a binary search
1513 // rather than linear search.
1514 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1515 while (I != Vars.end()) {
1516 unsigned CurNum = (*I)->getVariable().getArgNumber();
1517 // A local (non-parameter) variable has been found, insert immediately
1521 // A later indexed parameter has been found, insert immediately before it.
1522 if (CurNum > ArgNum)
1526 Vars.insert(I, Var);
1530 Vars.push_back(Var);
1533 // Gather and emit post-function debug information.
1534 void DwarfDebug::endFunction(const MachineFunction *MF) {
1535 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1536 // though the beginFunction may not be called at all.
1537 // We should handle both cases.
1541 assert(CurFn == MF);
1542 assert(CurFn != nullptr);
1544 if (!MMI->hasDebugInfo() || LScopes.empty() ||
1545 !FunctionDIs.count(MF->getFunction())) {
1546 // If we don't have a lexical scope for this function then there will
1547 // be a hole in the range information. Keep note of this by setting the
1548 // previously used section to nullptr.
1549 PrevSection = nullptr;
1555 // Define end label for subprogram.
1556 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1557 // Assumes in correct section after the entry point.
1558 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1560 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1561 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1563 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1564 collectVariableInfo(ProcessedVars);
1566 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1567 DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1569 // Construct abstract scopes.
1570 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1571 DISubprogram SP(AScope->getScopeNode());
1572 if (!SP.isSubprogram())
1574 // Collect info for variables that were optimized out.
1575 DIArray Variables = SP.getVariables();
1576 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1577 DIVariable DV(Variables.getElement(i));
1578 assert(DV && DV.isVariable());
1579 if (!ProcessedVars.insert(DV))
1581 ensureAbstractVariableIsCreated(DV, DV.getContext());
1583 constructAbstractSubprogramScopeDIE(TheCU, AScope);
1586 DIE &CurFnDIE = constructSubprogramScopeDIE(TheCU, FnScope);
1587 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1588 TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1590 // Add the range of this function to the list of ranges for the CU.
1591 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1592 TheCU.addRange(std::move(Span));
1593 PrevSection = Asm->getCurrentSection();
1597 // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
1598 // DbgVariables except those that are also in AbstractVariables (since they
1599 // can be used cross-function)
1600 ScopeVariables.clear();
1601 CurrentFnArguments.clear();
1603 LabelsBeforeInsn.clear();
1604 LabelsAfterInsn.clear();
1605 PrevLabel = nullptr;
1609 // Register a source line with debug info. Returns the unique label that was
1610 // emitted and which provides correspondence to the source line list.
1611 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1616 unsigned Discriminator = 0;
1617 if (DIScope Scope = DIScope(S)) {
1618 assert(Scope.isScope());
1619 Fn = Scope.getFilename();
1620 Dir = Scope.getDirectory();
1621 if (Scope.isLexicalBlock())
1622 Discriminator = DILexicalBlock(S).getDiscriminator();
1624 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1625 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1626 .getOrCreateSourceID(Fn, Dir);
1628 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1632 //===----------------------------------------------------------------------===//
1634 //===----------------------------------------------------------------------===//
1636 // Emit initial Dwarf sections with a label at the start of each one.
1637 void DwarfDebug::emitSectionLabels() {
1638 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1640 // Dwarf sections base addresses.
1641 DwarfInfoSectionSym =
1642 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1643 if (useSplitDwarf())
1644 DwarfInfoDWOSectionSym =
1645 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1646 DwarfAbbrevSectionSym =
1647 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1648 if (useSplitDwarf())
1649 DwarfAbbrevDWOSectionSym = emitSectionSym(
1650 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1651 if (GenerateARangeSection)
1652 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1654 DwarfLineSectionSym =
1655 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1656 if (GenerateGnuPubSections) {
1657 DwarfGnuPubNamesSectionSym =
1658 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1659 DwarfGnuPubTypesSectionSym =
1660 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1661 } else if (HasDwarfPubSections) {
1662 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1663 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1666 DwarfStrSectionSym =
1667 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1668 if (useSplitDwarf()) {
1669 DwarfStrDWOSectionSym =
1670 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1671 DwarfAddrSectionSym =
1672 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1673 DwarfDebugLocSectionSym =
1674 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1676 DwarfDebugLocSectionSym =
1677 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1678 DwarfDebugRangeSectionSym =
1679 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1682 // Recursively emits a debug information entry.
1683 void DwarfDebug::emitDIE(DIE &Die) {
1684 // Get the abbreviation for this DIE.
1685 const DIEAbbrev &Abbrev = Die.getAbbrev();
1687 // Emit the code (index) for the abbreviation.
1688 if (Asm->isVerbose())
1689 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1690 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1691 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1692 dwarf::TagString(Abbrev.getTag()));
1693 Asm->EmitULEB128(Abbrev.getNumber());
1695 const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1696 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1698 // Emit the DIE attribute values.
1699 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1700 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1701 dwarf::Form Form = AbbrevData[i].getForm();
1702 assert(Form && "Too many attributes for DIE (check abbreviation)");
1704 if (Asm->isVerbose()) {
1705 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1706 if (Attr == dwarf::DW_AT_accessibility)
1707 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1708 cast<DIEInteger>(Values[i])->getValue()));
1711 // Emit an attribute using the defined form.
1712 Values[i]->EmitValue(Asm, Form);
1715 // Emit the DIE children if any.
1716 if (Abbrev.hasChildren()) {
1717 for (auto &Child : Die.getChildren())
1720 Asm->OutStreamer.AddComment("End Of Children Mark");
1725 // Emit the debug info section.
1726 void DwarfDebug::emitDebugInfo() {
1727 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1729 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1732 // Emit the abbreviation section.
1733 void DwarfDebug::emitAbbreviations() {
1734 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1736 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1739 // Emit the last address of the section and the end of the line matrix.
1740 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1741 // Define last address of section.
1742 Asm->OutStreamer.AddComment("Extended Op");
1745 Asm->OutStreamer.AddComment("Op size");
1746 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1747 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1748 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1750 Asm->OutStreamer.AddComment("Section end label");
1752 Asm->OutStreamer.EmitSymbolValue(
1753 Asm->GetTempSymbol("section_end", SectionEnd),
1754 Asm->getDataLayout().getPointerSize());
1756 // Mark end of matrix.
1757 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1763 // Emit visible names into a hashed accelerator table section.
1764 void DwarfDebug::emitAccelNames() {
1765 AccelNames.FinalizeTable(Asm, "Names");
1766 Asm->OutStreamer.SwitchSection(
1767 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1768 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1769 Asm->OutStreamer.EmitLabel(SectionBegin);
1771 // Emit the full data.
1772 AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1775 // Emit objective C classes and categories into a hashed accelerator table
1777 void DwarfDebug::emitAccelObjC() {
1778 AccelObjC.FinalizeTable(Asm, "ObjC");
1779 Asm->OutStreamer.SwitchSection(
1780 Asm->getObjFileLowering().getDwarfAccelObjCSection());
1781 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1782 Asm->OutStreamer.EmitLabel(SectionBegin);
1784 // Emit the full data.
1785 AccelObjC.Emit(Asm, SectionBegin, &InfoHolder);
1788 // Emit namespace dies into a hashed accelerator table.
1789 void DwarfDebug::emitAccelNamespaces() {
1790 AccelNamespace.FinalizeTable(Asm, "namespac");
1791 Asm->OutStreamer.SwitchSection(
1792 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1793 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1794 Asm->OutStreamer.EmitLabel(SectionBegin);
1796 // Emit the full data.
1797 AccelNamespace.Emit(Asm, SectionBegin, &InfoHolder);
1800 // Emit type dies into a hashed accelerator table.
1801 void DwarfDebug::emitAccelTypes() {
1803 AccelTypes.FinalizeTable(Asm, "types");
1804 Asm->OutStreamer.SwitchSection(
1805 Asm->getObjFileLowering().getDwarfAccelTypesSection());
1806 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1807 Asm->OutStreamer.EmitLabel(SectionBegin);
1809 // Emit the full data.
1810 AccelTypes.Emit(Asm, SectionBegin, &InfoHolder);
1813 // Public name handling.
1814 // The format for the various pubnames:
1816 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1817 // for the DIE that is named.
1819 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1820 // into the CU and the index value is computed according to the type of value
1821 // for the DIE that is named.
1823 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1824 // it's the offset within the debug_info/debug_types dwo section, however, the
1825 // reference in the pubname header doesn't change.
1827 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1828 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1830 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1832 // We could have a specification DIE that has our most of our knowledge,
1833 // look for that now.
1834 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1836 DIE &SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1837 if (SpecDIE.findAttribute(dwarf::DW_AT_external))
1838 Linkage = dwarf::GIEL_EXTERNAL;
1839 } else if (Die->findAttribute(dwarf::DW_AT_external))
1840 Linkage = dwarf::GIEL_EXTERNAL;
1842 switch (Die->getTag()) {
1843 case dwarf::DW_TAG_class_type:
1844 case dwarf::DW_TAG_structure_type:
1845 case dwarf::DW_TAG_union_type:
1846 case dwarf::DW_TAG_enumeration_type:
1847 return dwarf::PubIndexEntryDescriptor(
1848 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1849 ? dwarf::GIEL_STATIC
1850 : dwarf::GIEL_EXTERNAL);
1851 case dwarf::DW_TAG_typedef:
1852 case dwarf::DW_TAG_base_type:
1853 case dwarf::DW_TAG_subrange_type:
1854 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1855 case dwarf::DW_TAG_namespace:
1856 return dwarf::GIEK_TYPE;
1857 case dwarf::DW_TAG_subprogram:
1858 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1859 case dwarf::DW_TAG_constant:
1860 case dwarf::DW_TAG_variable:
1861 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1862 case dwarf::DW_TAG_enumerator:
1863 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1864 dwarf::GIEL_STATIC);
1866 return dwarf::GIEK_NONE;
1870 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1872 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
1873 const MCSection *PSec =
1874 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
1875 : Asm->getObjFileLowering().getDwarfPubNamesSection();
1877 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
1880 void DwarfDebug::emitDebugPubSection(
1881 bool GnuStyle, const MCSection *PSec, StringRef Name,
1882 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
1883 for (const auto &NU : CUMap) {
1884 DwarfCompileUnit *TheU = NU.second;
1886 const auto &Globals = (TheU->*Accessor)();
1888 if (Globals.empty())
1891 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
1893 unsigned ID = TheU->getUniqueID();
1895 // Start the dwarf pubnames section.
1896 Asm->OutStreamer.SwitchSection(PSec);
1899 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
1900 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
1901 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
1902 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
1904 Asm->OutStreamer.EmitLabel(BeginLabel);
1906 Asm->OutStreamer.AddComment("DWARF Version");
1907 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
1909 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1910 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
1912 Asm->OutStreamer.AddComment("Compilation Unit Length");
1913 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
1915 // Emit the pubnames for this compilation unit.
1916 for (const auto &GI : Globals) {
1917 const char *Name = GI.getKeyData();
1918 const DIE *Entity = GI.second;
1920 Asm->OutStreamer.AddComment("DIE offset");
1921 Asm->EmitInt32(Entity->getOffset());
1924 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
1925 Asm->OutStreamer.AddComment(
1926 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
1927 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
1928 Asm->EmitInt8(Desc.toBits());
1931 Asm->OutStreamer.AddComment("External Name");
1932 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
1935 Asm->OutStreamer.AddComment("End Mark");
1937 Asm->OutStreamer.EmitLabel(EndLabel);
1941 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
1942 const MCSection *PSec =
1943 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
1944 : Asm->getObjFileLowering().getDwarfPubTypesSection();
1946 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
1949 // Emit visible names into a debug str section.
1950 void DwarfDebug::emitDebugStr() {
1951 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1952 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
1955 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
1956 const DebugLocEntry &Entry) {
1957 assert(Entry.getValues().size() == 1 &&
1958 "multi-value entries are not supported yet.");
1959 const DebugLocEntry::Value Value = Entry.getValues()[0];
1960 DIVariable DV(Value.getVariable());
1961 if (Value.isInt()) {
1962 DIBasicType BTy(resolve(DV.getType()));
1963 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
1964 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1965 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
1966 Streamer.EmitSLEB128(Value.getInt());
1968 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
1969 Streamer.EmitULEB128(Value.getInt());
1971 } else if (Value.isLocation()) {
1972 MachineLocation Loc = Value.getLoc();
1973 if (!DV.hasComplexAddress())
1975 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1977 // Complex address entry.
1978 unsigned N = DV.getNumAddrElements();
1980 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1981 if (Loc.getOffset()) {
1983 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1984 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
1985 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
1986 Streamer.EmitSLEB128(DV.getAddrElement(1));
1988 // If first address element is OpPlus then emit
1989 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1990 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
1991 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
1995 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
1998 // Emit remaining complex address elements.
1999 for (; i < N; ++i) {
2000 uint64_t Element = DV.getAddrElement(i);
2001 if (Element == DIBuilder::OpPlus) {
2002 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2003 Streamer.EmitULEB128(DV.getAddrElement(++i));
2004 } else if (Element == DIBuilder::OpDeref) {
2006 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2008 llvm_unreachable("unknown Opcode found in complex address");
2012 // else ... ignore constant fp. There is not any good way to
2013 // to represent them here in dwarf.
2017 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2018 Asm->OutStreamer.AddComment("Loc expr size");
2019 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2020 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2021 Asm->EmitLabelDifference(end, begin, 2);
2022 Asm->OutStreamer.EmitLabel(begin);
2024 APByteStreamer Streamer(*Asm);
2025 emitDebugLocEntry(Streamer, Entry);
2027 Asm->OutStreamer.EmitLabel(end);
2030 // Emit locations into the debug loc section.
2031 void DwarfDebug::emitDebugLoc() {
2032 // Start the dwarf loc section.
2033 Asm->OutStreamer.SwitchSection(
2034 Asm->getObjFileLowering().getDwarfLocSection());
2035 unsigned char Size = Asm->getDataLayout().getPointerSize();
2036 for (const auto &DebugLoc : DotDebugLocEntries) {
2037 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2038 for (const auto &Entry : DebugLoc.List) {
2039 // Set up the range. This range is relative to the entry point of the
2040 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2041 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2042 const DwarfCompileUnit *CU = Entry.getCU();
2043 if (CU->getRanges().size() == 1) {
2044 // Grab the begin symbol from the first range as our base.
2045 const MCSymbol *Base = CU->getRanges()[0].getStart();
2046 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2047 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2049 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2050 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2053 emitDebugLocEntryLocation(Entry);
2055 Asm->OutStreamer.EmitIntValue(0, Size);
2056 Asm->OutStreamer.EmitIntValue(0, Size);
2060 void DwarfDebug::emitDebugLocDWO() {
2061 Asm->OutStreamer.SwitchSection(
2062 Asm->getObjFileLowering().getDwarfLocDWOSection());
2063 for (const auto &DebugLoc : DotDebugLocEntries) {
2064 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2065 for (const auto &Entry : DebugLoc.List) {
2066 // Just always use start_length for now - at least that's one address
2067 // rather than two. We could get fancier and try to, say, reuse an
2068 // address we know we've emitted elsewhere (the start of the function?
2069 // The start of the CU or CU subrange that encloses this range?)
2070 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2071 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2072 Asm->EmitULEB128(idx);
2073 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2075 emitDebugLocEntryLocation(Entry);
2077 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2082 const MCSymbol *Start, *End;
2085 // Emit a debug aranges section, containing a CU lookup for any
2086 // address we can tie back to a CU.
2087 void DwarfDebug::emitDebugARanges() {
2088 // Start the dwarf aranges section.
2089 Asm->OutStreamer.SwitchSection(
2090 Asm->getObjFileLowering().getDwarfARangesSection());
2092 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> SpansType;
2096 // Build a list of sections used.
2097 std::vector<const MCSection *> Sections;
2098 for (const auto &it : SectionMap) {
2099 const MCSection *Section = it.first;
2100 Sections.push_back(Section);
2103 // Sort the sections into order.
2104 // This is only done to ensure consistent output order across different runs.
2105 std::sort(Sections.begin(), Sections.end(), SectionSort);
2107 // Build a set of address spans, sorted by CU.
2108 for (const MCSection *Section : Sections) {
2109 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2110 if (List.size() < 2)
2113 // Sort the symbols by offset within the section.
2114 std::sort(List.begin(), List.end(),
2115 [&](const SymbolCU &A, const SymbolCU &B) {
2116 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2117 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2119 // Symbols with no order assigned should be placed at the end.
2120 // (e.g. section end labels)
2128 // If we have no section (e.g. common), just write out
2129 // individual spans for each symbol.
2131 for (const SymbolCU &Cur : List) {
2133 Span.Start = Cur.Sym;
2136 Spans[Cur.CU].push_back(Span);
2139 // Build spans between each label.
2140 const MCSymbol *StartSym = List[0].Sym;
2141 for (size_t n = 1, e = List.size(); n < e; n++) {
2142 const SymbolCU &Prev = List[n - 1];
2143 const SymbolCU &Cur = List[n];
2145 // Try and build the longest span we can within the same CU.
2146 if (Cur.CU != Prev.CU) {
2148 Span.Start = StartSym;
2150 Spans[Prev.CU].push_back(Span);
2157 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2159 // Build a list of CUs used.
2160 std::vector<DwarfCompileUnit *> CUs;
2161 for (const auto &it : Spans) {
2162 DwarfCompileUnit *CU = it.first;
2166 // Sort the CU list (again, to ensure consistent output order).
2167 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2168 return A->getUniqueID() < B->getUniqueID();
2171 // Emit an arange table for each CU we used.
2172 for (DwarfCompileUnit *CU : CUs) {
2173 std::vector<ArangeSpan> &List = Spans[CU];
2175 // Emit size of content not including length itself.
2176 unsigned ContentSize =
2177 sizeof(int16_t) + // DWARF ARange version number
2178 sizeof(int32_t) + // Offset of CU in the .debug_info section
2179 sizeof(int8_t) + // Pointer Size (in bytes)
2180 sizeof(int8_t); // Segment Size (in bytes)
2182 unsigned TupleSize = PtrSize * 2;
2184 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2186 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2188 ContentSize += Padding;
2189 ContentSize += (List.size() + 1) * TupleSize;
2191 // For each compile unit, write the list of spans it covers.
2192 Asm->OutStreamer.AddComment("Length of ARange Set");
2193 Asm->EmitInt32(ContentSize);
2194 Asm->OutStreamer.AddComment("DWARF Arange version number");
2195 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2196 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2197 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2198 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2199 Asm->EmitInt8(PtrSize);
2200 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2203 Asm->OutStreamer.EmitFill(Padding, 0xff);
2205 for (const ArangeSpan &Span : List) {
2206 Asm->EmitLabelReference(Span.Start, PtrSize);
2208 // Calculate the size as being from the span start to it's end.
2210 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2212 // For symbols without an end marker (e.g. common), we
2213 // write a single arange entry containing just that one symbol.
2214 uint64_t Size = SymSize[Span.Start];
2218 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2222 Asm->OutStreamer.AddComment("ARange terminator");
2223 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2224 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2228 // Emit visible names into a debug ranges section.
2229 void DwarfDebug::emitDebugRanges() {
2230 // Start the dwarf ranges section.
2231 Asm->OutStreamer.SwitchSection(
2232 Asm->getObjFileLowering().getDwarfRangesSection());
2234 // Size for our labels.
2235 unsigned char Size = Asm->getDataLayout().getPointerSize();
2237 // Grab the specific ranges for the compile units in the module.
2238 for (const auto &I : CUMap) {
2239 DwarfCompileUnit *TheCU = I.second;
2241 // Iterate over the misc ranges for the compile units in the module.
2242 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2243 // Emit our symbol so we can find the beginning of the range.
2244 Asm->OutStreamer.EmitLabel(List.getSym());
2246 for (const RangeSpan &Range : List.getRanges()) {
2247 const MCSymbol *Begin = Range.getStart();
2248 const MCSymbol *End = Range.getEnd();
2249 assert(Begin && "Range without a begin symbol?");
2250 assert(End && "Range without an end symbol?");
2251 if (TheCU->getRanges().size() == 1) {
2252 // Grab the begin symbol from the first range as our base.
2253 const MCSymbol *Base = TheCU->getRanges()[0].getStart();
2254 Asm->EmitLabelDifference(Begin, Base, Size);
2255 Asm->EmitLabelDifference(End, Base, Size);
2257 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2258 Asm->OutStreamer.EmitSymbolValue(End, Size);
2262 // And terminate the list with two 0 values.
2263 Asm->OutStreamer.EmitIntValue(0, Size);
2264 Asm->OutStreamer.EmitIntValue(0, Size);
2267 // Now emit a range for the CU itself.
2268 if (TheCU->getRanges().size() > 1) {
2269 Asm->OutStreamer.EmitLabel(
2270 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2271 for (const RangeSpan &Range : TheCU->getRanges()) {
2272 const MCSymbol *Begin = Range.getStart();
2273 const MCSymbol *End = Range.getEnd();
2274 assert(Begin && "Range without a begin symbol?");
2275 assert(End && "Range without an end symbol?");
2276 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2277 Asm->OutStreamer.EmitSymbolValue(End, Size);
2279 // And terminate the list with two 0 values.
2280 Asm->OutStreamer.EmitIntValue(0, Size);
2281 Asm->OutStreamer.EmitIntValue(0, Size);
2286 // DWARF5 Experimental Separate Dwarf emitters.
2288 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
2289 std::unique_ptr<DwarfUnit> NewU) {
2290 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2291 U.getCUNode().getSplitDebugFilename());
2293 if (!CompilationDir.empty())
2294 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2296 addGnuPubAttributes(*NewU, Die);
2298 SkeletonHolder.addUnit(std::move(NewU));
2301 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2302 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2303 // DW_AT_addr_base, DW_AT_ranges_base.
2304 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2306 auto OwnedUnit = make_unique<DwarfCompileUnit>(
2307 CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
2308 DwarfCompileUnit &NewCU = *OwnedUnit;
2309 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2310 DwarfInfoSectionSym);
2312 NewCU.initStmtList(DwarfLineSectionSym);
2314 initSkeletonUnit(CU, NewCU.getUnitDie(), std::move(OwnedUnit));
2319 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2321 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2322 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2323 *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2325 auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), CU, Asm, this,
2327 DwarfTypeUnit &NewTU = *OwnedUnit;
2328 NewTU.setTypeSignature(TU.getTypeSignature());
2329 NewTU.setType(nullptr);
2331 Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2333 initSkeletonUnit(TU, NewTU.getUnitDie(), std::move(OwnedUnit));
2337 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2338 // compile units that would normally be in debug_info.
2339 void DwarfDebug::emitDebugInfoDWO() {
2340 assert(useSplitDwarf() && "No split dwarf debug info?");
2341 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2342 // emit relocations into the dwo file.
2343 InfoHolder.emitUnits(this, /* AbbrevSymbol */ nullptr);
2346 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2347 // abbreviations for the .debug_info.dwo section.
2348 void DwarfDebug::emitDebugAbbrevDWO() {
2349 assert(useSplitDwarf() && "No split dwarf?");
2350 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2353 void DwarfDebug::emitDebugLineDWO() {
2354 assert(useSplitDwarf() && "No split dwarf?");
2355 Asm->OutStreamer.SwitchSection(
2356 Asm->getObjFileLowering().getDwarfLineDWOSection());
2357 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2360 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2361 // string section and is identical in format to traditional .debug_str
2363 void DwarfDebug::emitDebugStrDWO() {
2364 assert(useSplitDwarf() && "No split dwarf?");
2365 const MCSection *OffSec =
2366 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2367 const MCSymbol *StrSym = DwarfStrSectionSym;
2368 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2372 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2373 if (!useSplitDwarf())
2376 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2377 return &SplitTypeUnitFileTable;
2380 static uint64_t makeTypeSignature(StringRef Identifier) {
2382 Hash.update(Identifier);
2383 // ... take the least significant 8 bytes and return those. Our MD5
2384 // implementation always returns its results in little endian, swap bytes
2386 MD5::MD5Result Result;
2388 return *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2391 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2392 StringRef Identifier, DIE &RefDie,
2393 DICompositeType CTy) {
2394 // Fast path if we're building some type units and one has already used the
2395 // address pool we know we're going to throw away all this work anyway, so
2396 // don't bother building dependent types.
2397 if (!TypeUnitsUnderConstruction.empty() && AddrPool.hasBeenUsed())
2400 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2402 CU.addDIETypeSignature(RefDie, *TU);
2406 bool TopLevelType = TypeUnitsUnderConstruction.empty();
2407 AddrPool.resetUsedFlag();
2410 make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), CU, Asm, this,
2411 &InfoHolder, getDwoLineTable(CU));
2412 DwarfTypeUnit &NewTU = *OwnedUnit;
2413 DIE &UnitDie = NewTU.getUnitDie();
2415 TypeUnitsUnderConstruction.push_back(
2416 std::make_pair(std::move(OwnedUnit), CTy));
2418 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2421 uint64_t Signature = makeTypeSignature(Identifier);
2422 NewTU.setTypeSignature(Signature);
2424 if (!useSplitDwarf())
2425 CU.applyStmtList(UnitDie);
2427 // FIXME: Skip using COMDAT groups for type units in the .dwo file once tools
2428 // such as DWP ( http://gcc.gnu.org/wiki/DebugFissionDWP ) can cope with it.
2431 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2432 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2434 NewTU.setType(NewTU.createTypeDIE(CTy));
2437 auto TypeUnitsToAdd = std::move(TypeUnitsUnderConstruction);
2438 TypeUnitsUnderConstruction.clear();
2440 // Types referencing entries in the address table cannot be placed in type
2442 if (AddrPool.hasBeenUsed()) {
2444 // Remove all the types built while building this type.
2445 // This is pessimistic as some of these types might not be dependent on
2446 // the type that used an address.
2447 for (const auto &TU : TypeUnitsToAdd)
2448 DwarfTypeUnits.erase(TU.second);
2450 // Construct this type in the CU directly.
2451 // This is inefficient because all the dependent types will be rebuilt
2452 // from scratch, including building them in type units, discovering that
2453 // they depend on addresses, throwing them out and rebuilding them.
2454 CU.constructTypeDIE(RefDie, CTy);
2458 // If the type wasn't dependent on fission addresses, finish adding the type
2459 // and all its dependent types.
2460 for (auto &TU : TypeUnitsToAdd) {
2461 if (useSplitDwarf())
2462 TU.first->setSkeleton(constructSkeletonTU(*TU.first));
2463 InfoHolder.addUnit(std::move(TU.first));
2466 CU.addDIETypeSignature(RefDie, NewTU);
2469 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE &D,
2470 MCSymbol *Begin, MCSymbol *End) {
2471 assert(Begin && "Begin label should not be null!");
2472 assert(End && "End label should not be null!");
2473 assert(Begin->isDefined() && "Invalid starting label");
2474 assert(End->isDefined() && "Invalid end label");
2476 Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2477 if (DwarfVersion < 4)
2478 Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2480 Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2483 // Accelerator table mutators - add each name along with its companion
2484 // DIE to the proper table while ensuring that the name that we're going
2485 // to reference is in the string table. We do this since the names we
2486 // add may not only be identical to the names in the DIE.
2487 void DwarfDebug::addAccelName(StringRef Name, const DIE &Die) {
2488 if (!useDwarfAccelTables())
2490 AccelNames.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2494 void DwarfDebug::addAccelObjC(StringRef Name, const DIE &Die) {
2495 if (!useDwarfAccelTables())
2497 AccelObjC.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2501 void DwarfDebug::addAccelNamespace(StringRef Name, const DIE &Die) {
2502 if (!useDwarfAccelTables())
2504 AccelNamespace.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),
2508 void DwarfDebug::addAccelType(StringRef Name, const DIE &Die, char Flags) {
2509 if (!useDwarfAccelTables())
2511 AccelTypes.AddName(Name, InfoHolder.getStringPool().getSymbol(*Asm, Name),