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());
122 DIType DbgVariable::getType() const {
123 DIType Ty = Var.getType().resolve(DD->getTypeIdentifierMap());
124 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
125 // addresses instead.
126 if (Var.isBlockByrefVariable(DD->getTypeIdentifierMap())) {
127 /* Byref variables, in Blocks, are declared by the programmer as
128 "SomeType VarName;", but the compiler creates a
129 __Block_byref_x_VarName struct, and gives the variable VarName
130 either the struct, or a pointer to the struct, as its type. This
131 is necessary for various behind-the-scenes things the compiler
132 needs to do with by-reference variables in blocks.
134 However, as far as the original *programmer* is concerned, the
135 variable should still have type 'SomeType', as originally declared.
137 The following function dives into the __Block_byref_x_VarName
138 struct to find the original type of the variable. This will be
139 passed back to the code generating the type for the Debug
140 Information Entry for the variable 'VarName'. 'VarName' will then
141 have the original type 'SomeType' in its debug information.
143 The original type 'SomeType' will be the type of the field named
144 'VarName' inside the __Block_byref_x_VarName struct.
146 NOTE: In order for this to not completely fail on the debugger
147 side, the Debug Information Entry for the variable VarName needs to
148 have a DW_AT_location that tells the debugger how to unwind through
149 the pointers and __Block_byref_x_VarName struct to find the actual
150 value of the variable. The function addBlockByrefType does this. */
152 uint16_t tag = Ty.getTag();
154 if (tag == dwarf::DW_TAG_pointer_type)
155 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
157 DIArray Elements = DICompositeType(subType).getTypeArray();
158 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
159 DIDerivedType DT(Elements.getElement(i));
160 if (getName() == DT.getName())
161 return (resolve(DT.getTypeDerivedFrom()));
167 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
168 : Asm(A), MMI(Asm->MMI), FirstCU(0), PrevLabel(NULL), GlobalRangeCount(0),
169 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)) {
175 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
176 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
177 DwarfAddrSectionSym = 0;
178 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
179 FunctionBeginSym = FunctionEndSym = 0;
183 // Turn on accelerator tables for Darwin by default, pubnames by
184 // default for non-Darwin, and handle split dwarf.
185 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
187 if (DwarfAccelTables == Default)
188 HasDwarfAccelTables = IsDarwin;
190 HasDwarfAccelTables = DwarfAccelTables == Enable;
192 if (SplitDwarf == Default)
193 HasSplitDwarf = false;
195 HasSplitDwarf = SplitDwarf == Enable;
197 if (DwarfPubSections == Default)
198 HasDwarfPubSections = !IsDarwin;
200 HasDwarfPubSections = DwarfPubSections == Enable;
202 DwarfVersion = DwarfVersionNumber
204 : MMI->getModule()->getDwarfVersion();
207 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
212 // Switch to the specified MCSection and emit an assembler
213 // temporary label to it if SymbolStem is specified.
214 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
215 const char *SymbolStem = 0) {
216 Asm->OutStreamer.SwitchSection(Section);
220 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
221 Asm->OutStreamer.EmitLabel(TmpSym);
225 static bool isObjCClass(StringRef Name) {
226 return Name.startswith("+") || Name.startswith("-");
229 static bool hasObjCCategory(StringRef Name) {
230 if (!isObjCClass(Name))
233 return Name.find(") ") != StringRef::npos;
236 static void getObjCClassCategory(StringRef In, StringRef &Class,
237 StringRef &Category) {
238 if (!hasObjCCategory(In)) {
239 Class = In.slice(In.find('[') + 1, In.find(' '));
244 Class = In.slice(In.find('[') + 1, In.find('('));
245 Category = In.slice(In.find('[') + 1, In.find(' '));
249 static StringRef getObjCMethodName(StringRef In) {
250 return In.slice(In.find(' ') + 1, In.find(']'));
253 // Helper for sorting sections into a stable output order.
254 static bool SectionSort(const MCSection *A, const MCSection *B) {
255 std::string LA = (A ? A->getLabelBeginName() : "");
256 std::string LB = (B ? B->getLabelBeginName() : "");
260 // Add the various names to the Dwarf accelerator table names.
261 // TODO: Determine whether or not we should add names for programs
262 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
263 // is only slightly different than the lookup of non-standard ObjC names.
264 void DwarfDebug::addSubprogramNames(DwarfUnit &TheU, DISubprogram SP,
266 if (!SP.isDefinition())
268 addAccelName(SP.getName(), Die);
270 // If the linkage name is different than the name, go ahead and output
271 // that as well into the name table.
272 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
273 addAccelName(SP.getLinkageName(), Die);
275 // If this is an Objective-C selector name add it to the ObjC accelerator
277 if (isObjCClass(SP.getName())) {
278 StringRef Class, Category;
279 getObjCClassCategory(SP.getName(), Class, Category);
280 TheU.addAccelObjC(Class, Die);
282 TheU.addAccelObjC(Category, Die);
283 // Also add the base method name to the name table.
284 addAccelName(getObjCMethodName(SP.getName()), Die);
288 /// isSubprogramContext - Return true if Context is either a subprogram
289 /// or another context nested inside a subprogram.
290 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
293 DIDescriptor D(Context);
294 if (D.isSubprogram())
297 return isSubprogramContext(resolve(DIType(Context).getContext()));
301 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
302 // and DW_AT_high_pc attributes. If there are global variables in this
303 // scope then create and insert DIEs for these variables.
304 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit &SPCU,
306 DIE *SPDie = SPCU.getDIE(SP);
308 assert(SPDie && "Unable to find subprogram DIE!");
310 // If we're updating an abstract DIE, then we will be adding the children and
311 // object pointer later on. But what we don't want to do is process the
312 // concrete DIE twice.
313 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
314 // Pick up abstract subprogram DIE.
315 SPDie = SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU.getUnitDie());
316 SPCU.addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
318 DISubprogram SPDecl = SP.getFunctionDeclaration();
319 if (!SPDecl.isSubprogram()) {
320 // There is not any need to generate specification DIE for a function
321 // defined at compile unit level. If a function is defined inside another
322 // function then gdb prefers the definition at top level and but does not
323 // expect specification DIE in parent function. So avoid creating
324 // specification DIE for a function defined inside a function.
325 DIScope SPContext = resolve(SP.getContext());
326 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
327 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
328 SPCU.addFlag(SPDie, dwarf::DW_AT_declaration);
331 DICompositeType SPTy = SP.getType();
332 DIArray Args = SPTy.getTypeArray();
333 uint16_t SPTag = SPTy.getTag();
334 if (SPTag == dwarf::DW_TAG_subroutine_type)
335 SPCU.constructSubprogramArguments(*SPDie, Args);
336 DIE *SPDeclDie = SPDie;
338 SPCU.createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU.getUnitDie());
339 SPCU.addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
344 attachLowHighPC(SPCU, SPDie, FunctionBeginSym, FunctionEndSym);
346 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
347 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
348 SPCU.addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
350 // Add name to the name table, we do this here because we're guaranteed
351 // to have concrete versions of our DW_TAG_subprogram nodes.
352 addSubprogramNames(SPCU, SP, SPDie);
357 /// Check whether we should create a DIE for the given Scope, return true
358 /// if we don't create a DIE (the corresponding DIE is null).
359 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
360 if (Scope->isAbstractScope())
363 // We don't create a DIE if there is no Range.
364 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
368 if (Ranges.size() > 1)
371 // We don't create a DIE if we have a single Range and the end label
373 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
374 MCSymbol *End = getLabelAfterInsn(RI->second);
378 static void addSectionLabel(AsmPrinter &Asm, DwarfUnit &U, DIE *D,
379 dwarf::Attribute A, const MCSymbol *L,
380 const MCSymbol *Sec) {
381 if (Asm.MAI->doesDwarfUseRelocationsAcrossSections())
382 U.addSectionLabel(D, A, L);
384 U.addSectionDelta(D, A, L, Sec);
387 void DwarfDebug::addScopeRangeList(DwarfCompileUnit &TheCU, DIE *ScopeDIE,
388 const SmallVectorImpl<InsnRange> &Range) {
389 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
390 // emitting it appropriately.
391 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
393 // Under fission, ranges are specified by constant offsets relative to the
394 // CU's DW_AT_GNU_ranges_base.
396 TheCU.addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
397 DwarfDebugRangeSectionSym);
399 addSectionLabel(*Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
400 DwarfDebugRangeSectionSym);
402 RangeSpanList List(RangeSym);
403 for (const InsnRange &R : Range) {
404 RangeSpan Span(getLabelBeforeInsn(R.first), getLabelAfterInsn(R.second));
405 List.addRange(std::move(Span));
408 // Add the range list to the set of ranges to be emitted.
409 TheCU.addRangeList(std::move(List));
412 // Construct new DW_TAG_lexical_block for this scope and attach
413 // DW_AT_low_pc/DW_AT_high_pc labels.
414 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit &TheCU,
415 LexicalScope *Scope) {
416 if (isLexicalScopeDIENull(Scope))
419 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
420 if (Scope->isAbstractScope())
423 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
425 // If we have multiple ranges, emit them into the range section.
426 if (ScopeRanges.size() > 1) {
427 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
431 // Construct the address range for this DIE.
432 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
433 MCSymbol *Start = getLabelBeforeInsn(RI->first);
434 MCSymbol *End = getLabelAfterInsn(RI->second);
435 assert(End && "End label should not be null!");
437 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
438 assert(End->isDefined() && "Invalid end label for an inlined scope!");
440 attachLowHighPC(TheCU, ScopeDIE, Start, End);
445 // This scope represents inlined body of a function. Construct DIE to
446 // represent this concrete inlined copy of the function.
447 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit &TheCU,
448 LexicalScope *Scope) {
449 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
450 assert(!ScopeRanges.empty() &&
451 "LexicalScope does not have instruction markers!");
453 if (!Scope->getScopeNode())
455 DIScope DS(Scope->getScopeNode());
456 DISubprogram InlinedSP = getDISubprogram(DS);
457 DIE *OriginDIE = TheCU.getDIE(InlinedSP);
459 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
463 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
464 TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
466 // If we have multiple ranges, emit them into the range section.
467 if (ScopeRanges.size() > 1)
468 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
470 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
471 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
472 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
474 if (StartLabel == 0 || EndLabel == 0)
475 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
477 assert(StartLabel->isDefined() &&
478 "Invalid starting label for an inlined scope!");
479 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
481 attachLowHighPC(TheCU, ScopeDIE, StartLabel, EndLabel);
484 InlinedSubprogramDIEs.insert(OriginDIE);
486 // Add the call site information to the DIE.
487 DILocation DL(Scope->getInlinedAt());
488 TheCU.addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
489 TheCU.getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
490 TheCU.addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
492 // Add name to the name table, we do this here because we're guaranteed
493 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
494 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
499 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit &TheCU,
501 SmallVectorImpl<DIE *> &Children) {
502 DIE *ObjectPointer = NULL;
504 // Collect arguments for current function.
505 if (LScopes.isCurrentFunctionScope(Scope)) {
506 for (DbgVariable *ArgDV : CurrentFnArguments)
509 TheCU.constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
510 Children.push_back(Arg);
511 if (ArgDV->isObjectPointer())
515 // If this is a variadic function, add an unspecified parameter.
516 DISubprogram SP(Scope->getScopeNode());
517 DIArray FnArgs = SP.getType().getTypeArray();
518 if (FnArgs.getElement(FnArgs.getNumElements() - 1)
519 .isUnspecifiedParameter()) {
520 DIE *Ellipsis = new DIE(dwarf::DW_TAG_unspecified_parameters);
521 Children.push_back(Ellipsis);
525 // Collect lexical scope children first.
526 for (DbgVariable *DV : ScopeVariables.lookup(Scope))
528 TheCU.constructVariableDIE(*DV, Scope->isAbstractScope())) {
529 Children.push_back(Variable);
530 if (DV->isObjectPointer())
531 ObjectPointer = Variable;
533 for (LexicalScope *LS : Scope->getChildren())
534 if (DIE *Nested = constructScopeDIE(TheCU, LS))
535 Children.push_back(Nested);
536 return ObjectPointer;
539 // Construct a DIE for this scope.
540 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit &TheCU,
541 LexicalScope *Scope) {
542 if (!Scope || !Scope->getScopeNode())
545 DIScope DS(Scope->getScopeNode());
547 SmallVector<DIE *, 8> Children;
548 DIE *ObjectPointer = NULL;
549 bool ChildrenCreated = false;
551 // We try to create the scope DIE first, then the children DIEs. This will
552 // avoid creating un-used children then removing them later when we find out
553 // the scope DIE is null.
554 DIE *ScopeDIE = NULL;
555 if (Scope->getInlinedAt())
556 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
557 else if (DS.isSubprogram()) {
558 ProcessedSPNodes.insert(DS);
559 if (Scope->isAbstractScope()) {
560 ScopeDIE = TheCU.getDIE(DS);
561 // Note down abstract DIE.
563 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
565 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
567 // Early exit when we know the scope DIE is going to be null.
568 if (isLexicalScopeDIENull(Scope))
571 // We create children here when we know the scope DIE is not going to be
572 // null and the children will be added to the scope DIE.
573 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
574 ChildrenCreated = true;
576 // There is no need to emit empty lexical block DIE.
577 std::pair<ImportedEntityMap::const_iterator,
578 ImportedEntityMap::const_iterator> Range =
580 ScopesWithImportedEntities.begin(),
581 ScopesWithImportedEntities.end(),
582 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
584 if (Children.empty() && Range.first == Range.second)
586 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
587 assert(ScopeDIE && "Scope DIE should not be null.");
588 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
590 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
594 assert(Children.empty() &&
595 "We create children only when the scope DIE is not null.");
598 if (!ChildrenCreated)
599 // We create children when the scope DIE is not null.
600 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
603 for (DIE *I : Children)
604 ScopeDIE->addChild(I);
606 if (DS.isSubprogram() && ObjectPointer != NULL)
607 TheCU.addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
612 void DwarfDebug::addGnuPubAttributes(DwarfUnit &U, DIE *D) const {
613 if (!GenerateGnuPubSections)
616 U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
619 // Create new DwarfCompileUnit for the given metadata node with tag
620 // DW_TAG_compile_unit.
621 DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
622 StringRef FN = DIUnit.getFilename();
623 CompilationDir = DIUnit.getDirectory();
625 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
626 auto OwnedUnit = make_unique<DwarfCompileUnit>(
627 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
628 DwarfCompileUnit &NewCU = *OwnedUnit;
629 InfoHolder.addUnit(std::move(OwnedUnit));
631 // LTO with assembly output shares a single line table amongst multiple CUs.
632 // To avoid the compilation directory being ambiguous, let the line table
633 // explicitly describe the directory of all files, never relying on the
634 // compilation directory.
635 if (!Asm->OutStreamer.hasRawTextSupport() || SingleCU)
636 Asm->OutStreamer.getContext().setMCLineTableCompilationDir(
637 NewCU.getUniqueID(), CompilationDir);
639 NewCU.addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
640 NewCU.addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
641 DIUnit.getLanguage());
642 NewCU.addString(Die, dwarf::DW_AT_name, FN);
644 if (!useSplitDwarf()) {
645 NewCU.initStmtList(DwarfLineSectionSym);
647 // If we're using split dwarf the compilation dir is going to be in the
648 // skeleton CU and so we don't need to duplicate it here.
649 if (!CompilationDir.empty())
650 NewCU.addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
652 addGnuPubAttributes(NewCU, Die);
655 if (DIUnit.isOptimized())
656 NewCU.addFlag(Die, dwarf::DW_AT_APPLE_optimized);
658 StringRef Flags = DIUnit.getFlags();
660 NewCU.addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
662 if (unsigned RVer = DIUnit.getRunTimeVersion())
663 NewCU.addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
664 dwarf::DW_FORM_data1, RVer);
669 if (useSplitDwarf()) {
670 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
671 DwarfInfoDWOSectionSym);
672 NewCU.setSkeleton(constructSkeletonCU(NewCU));
674 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
675 DwarfInfoSectionSym);
677 CUMap.insert(std::make_pair(DIUnit, &NewCU));
678 CUDieMap.insert(std::make_pair(Die, &NewCU));
682 // Construct subprogram DIE.
683 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit &TheCU,
685 // FIXME: We should only call this routine once, however, during LTO if a
686 // program is defined in multiple CUs we could end up calling it out of
687 // beginModule as we walk the CUs.
689 DwarfCompileUnit *&CURef = SPMap[N];
695 if (!SP.isDefinition())
696 // This is a method declaration which will be handled while constructing
700 DIE *SubprogramDie = TheCU.getOrCreateSubprogramDIE(SP);
702 // Expose as a global name.
703 TheCU.addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
706 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
708 DIImportedEntity Module(N);
709 assert(Module.Verify());
710 if (DIE *D = TheCU.getOrCreateContextDIE(Module.getContext()))
711 constructImportedEntityDIE(TheCU, Module, D);
714 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
715 const MDNode *N, DIE *Context) {
716 DIImportedEntity Module(N);
717 assert(Module.Verify());
718 return constructImportedEntityDIE(TheCU, Module, Context);
721 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit &TheCU,
722 const DIImportedEntity &Module,
724 assert(Module.Verify() &&
725 "Use one of the MDNode * overloads to handle invalid metadata");
726 assert(Context && "Should always have a context for an imported_module");
727 DIE *IMDie = TheCU.createAndAddDIE(Module.getTag(), *Context, Module);
729 DIDescriptor Entity = resolve(Module.getEntity());
730 if (Entity.isNameSpace())
731 EntityDie = TheCU.getOrCreateNameSpace(DINameSpace(Entity));
732 else if (Entity.isSubprogram())
733 EntityDie = TheCU.getOrCreateSubprogramDIE(DISubprogram(Entity));
734 else if (Entity.isType())
735 EntityDie = TheCU.getOrCreateTypeDIE(DIType(Entity));
737 EntityDie = TheCU.getDIE(Entity);
738 TheCU.addSourceLine(IMDie, Module.getLineNumber(),
739 Module.getContext().getFilename(),
740 Module.getContext().getDirectory());
741 TheCU.addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
742 StringRef Name = Module.getName();
744 TheCU.addString(IMDie, dwarf::DW_AT_name, Name);
747 // Emit all Dwarf sections that should come prior to the content. Create
748 // global DIEs and emit initial debug info sections. This is invoked by
749 // the target AsmPrinter.
750 void DwarfDebug::beginModule() {
751 if (DisableDebugInfoPrinting)
754 const Module *M = MMI->getModule();
756 // If module has named metadata anchors then use them, otherwise scan the
757 // module using debug info finder to collect debug info.
758 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
761 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
763 // Emit initial sections so we can reference labels later.
766 SingleCU = CU_Nodes->getNumOperands() == 1;
768 for (MDNode *N : CU_Nodes->operands()) {
769 DICompileUnit CUNode(N);
770 DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
771 DIArray ImportedEntities = CUNode.getImportedEntities();
772 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
773 ScopesWithImportedEntities.push_back(std::make_pair(
774 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
775 ImportedEntities.getElement(i)));
776 std::sort(ScopesWithImportedEntities.begin(),
777 ScopesWithImportedEntities.end(), less_first());
778 DIArray GVs = CUNode.getGlobalVariables();
779 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
780 CU.createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
781 DIArray SPs = CUNode.getSubprograms();
782 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
783 constructSubprogramDIE(CU, SPs.getElement(i));
784 DIArray EnumTypes = CUNode.getEnumTypes();
785 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
786 CU.getOrCreateTypeDIE(EnumTypes.getElement(i));
787 DIArray RetainedTypes = CUNode.getRetainedTypes();
788 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) {
789 DIType Ty(RetainedTypes.getElement(i));
790 // The retained types array by design contains pointers to
791 // MDNodes rather than DIRefs. Unique them here.
792 DIType UniqueTy(resolve(Ty.getRef()));
793 CU.getOrCreateTypeDIE(UniqueTy);
795 // Emit imported_modules last so that the relevant context is already
797 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
798 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
801 // Tell MMI that we have debug info.
802 MMI->setDebugInfoAvailability(true);
804 // Prime section data.
805 SectionMap[Asm->getObjFileLowering().getTextSection()];
808 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
809 void DwarfDebug::computeInlinedDIEs() {
810 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
811 for (DIE *ISP : InlinedSubprogramDIEs)
812 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
814 for (const auto &AI : AbstractSPDies) {
815 DIE *ISP = AI.second;
816 if (InlinedSubprogramDIEs.count(ISP))
818 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
822 // Collect info for variables that were optimized out.
823 void DwarfDebug::collectDeadVariables() {
824 const Module *M = MMI->getModule();
826 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
827 for (MDNode *N : CU_Nodes->operands()) {
828 DICompileUnit TheCU(N);
829 DIArray Subprograms = TheCU.getSubprograms();
830 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
831 DISubprogram SP(Subprograms.getElement(i));
832 if (ProcessedSPNodes.count(SP) != 0)
834 if (!SP.isSubprogram())
836 if (!SP.isDefinition())
838 DIArray Variables = SP.getVariables();
839 if (Variables.getNumElements() == 0)
842 // Construct subprogram DIE and add variables DIEs.
843 DwarfCompileUnit *SPCU =
844 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
845 assert(SPCU && "Unable to find Compile Unit!");
846 // FIXME: See the comment in constructSubprogramDIE about duplicate
848 constructSubprogramDIE(*SPCU, SP);
849 DIE *SPDIE = SPCU->getDIE(SP);
850 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
851 DIVariable DV(Variables.getElement(vi));
852 if (!DV.isVariable())
854 DbgVariable NewVar(DV, NULL, this);
855 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
856 SPDIE->addChild(VariableDIE);
863 void DwarfDebug::finalizeModuleInfo() {
864 // Collect info for variables that were optimized out.
865 collectDeadVariables();
867 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
868 computeInlinedDIEs();
870 // Handle anything that needs to be done on a per-unit basis after
871 // all other generation.
872 for (const auto &TheU : getUnits()) {
873 // Emit DW_AT_containing_type attribute to connect types with their
874 // vtable holding type.
875 TheU->constructContainingTypeDIEs();
877 // Add CU specific attributes if we need to add any.
878 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
879 // If we're splitting the dwarf out now that we've got the entire
880 // CU then add the dwo id to it.
881 DwarfCompileUnit *SkCU =
882 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
883 if (useSplitDwarf()) {
884 // Emit a unique identifier for this CU.
885 uint64_t ID = DIEHash(Asm).computeCUSignature(*TheU->getUnitDie());
886 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
887 dwarf::DW_FORM_data8, ID);
888 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
889 dwarf::DW_FORM_data8, ID);
891 // We don't keep track of which addresses are used in which CU so this
892 // is a bit pessimistic under LTO.
893 if (!AddrPool.isEmpty())
894 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
895 dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym,
896 DwarfAddrSectionSym);
897 if (!TheU->getRangeLists().empty())
898 addSectionLabel(*Asm, *SkCU, SkCU->getUnitDie(),
899 dwarf::DW_AT_GNU_ranges_base,
900 DwarfDebugRangeSectionSym, DwarfDebugRangeSectionSym);
903 // If we have code split among multiple sections or non-contiguous
904 // ranges of code then emit a DW_AT_ranges attribute on the unit that will
905 // remain in the .o file, otherwise add a DW_AT_low_pc.
906 // FIXME: We should use ranges allow reordering of code ala
907 // .subsections_via_symbols in mach-o. This would mean turning on
908 // ranges for all subprogram DIEs for mach-o.
909 DwarfCompileUnit &U =
910 SkCU ? *SkCU : static_cast<DwarfCompileUnit &>(*TheU);
911 unsigned NumRanges = TheU->getRanges().size();
914 addSectionLabel(*Asm, U, U.getUnitDie(), dwarf::DW_AT_ranges,
915 Asm->GetTempSymbol("cu_ranges", U.getUniqueID()),
916 DwarfDebugRangeSectionSym);
918 // A DW_AT_low_pc attribute may also be specified in combination with
919 // DW_AT_ranges to specify the default base address for use in
920 // location lists (see Section 2.6.2) and range lists (see Section
922 U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
925 RangeSpan &Range = TheU->getRanges().back();
926 U.addLocalLabelAddress(U.getUnitDie(), dwarf::DW_AT_low_pc,
928 U.addLabelDelta(U.getUnitDie(), dwarf::DW_AT_high_pc, Range.getEnd(),
935 // Compute DIE offsets and sizes.
936 InfoHolder.computeSizeAndOffsets();
938 SkeletonHolder.computeSizeAndOffsets();
941 void DwarfDebug::endSections() {
942 // Filter labels by section.
943 for (const SymbolCU &SCU : ArangeLabels) {
944 if (SCU.Sym->isInSection()) {
945 // Make a note of this symbol and it's section.
946 const MCSection *Section = &SCU.Sym->getSection();
947 if (!Section->getKind().isMetadata())
948 SectionMap[Section].push_back(SCU);
950 // Some symbols (e.g. common/bss on mach-o) can have no section but still
951 // appear in the output. This sucks as we rely on sections to build
952 // arange spans. We can do it without, but it's icky.
953 SectionMap[NULL].push_back(SCU);
957 // Build a list of sections used.
958 std::vector<const MCSection *> Sections;
959 for (const auto &it : SectionMap) {
960 const MCSection *Section = it.first;
961 Sections.push_back(Section);
964 // Sort the sections into order.
965 // This is only done to ensure consistent output order across different runs.
966 std::sort(Sections.begin(), Sections.end(), SectionSort);
968 // Add terminating symbols for each section.
969 for (unsigned ID = 0, E = Sections.size(); ID != E; ID++) {
970 const MCSection *Section = Sections[ID];
971 MCSymbol *Sym = NULL;
974 // We can't call MCSection::getLabelEndName, as it's only safe to do so
975 // if we know the section name up-front. For user-created sections, the
976 // resulting label may not be valid to use as a label. (section names can
977 // use a greater set of characters on some systems)
978 Sym = Asm->GetTempSymbol("debug_end", ID);
979 Asm->OutStreamer.SwitchSection(Section);
980 Asm->OutStreamer.EmitLabel(Sym);
983 // Insert a final terminator.
984 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
988 // Emit all Dwarf sections that should come after the content.
989 void DwarfDebug::endModule() {
996 // End any existing sections.
997 // TODO: Does this need to happen?
1000 // Finalize the debug info for the module.
1001 finalizeModuleInfo();
1005 // Emit all the DIEs into a debug info section.
1008 // Corresponding abbreviations into a abbrev section.
1009 emitAbbreviations();
1011 // Emit info into a debug aranges section.
1012 if (GenerateARangeSection)
1015 // Emit info into a debug ranges section.
1018 if (useSplitDwarf()) {
1021 emitDebugAbbrevDWO();
1023 // Emit DWO addresses.
1024 AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
1027 // Emit info into a debug loc section.
1030 // Emit info into the dwarf accelerator table sections.
1031 if (useDwarfAccelTables()) {
1034 emitAccelNamespaces();
1038 // Emit the pubnames and pubtypes sections if requested.
1039 if (HasDwarfPubSections) {
1040 emitDebugPubNames(GenerateGnuPubSections);
1041 emitDebugPubTypes(GenerateGnuPubSections);
1047 // Reset these for the next Module if we have one.
1051 // Find abstract variable, if any, associated with Var.
1052 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1053 DebugLoc ScopeLoc) {
1054 LLVMContext &Ctx = DV->getContext();
1055 // More then one inlined variable corresponds to one abstract variable.
1056 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1057 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1059 return AbsDbgVariable;
1061 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1065 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1066 addScopeVariable(Scope, AbsDbgVariable);
1067 AbstractVariables[Var] = AbsDbgVariable;
1068 return AbsDbgVariable;
1071 // If Var is a current function argument then add it to CurrentFnArguments list.
1072 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1073 if (!LScopes.isCurrentFunctionScope(Scope))
1075 DIVariable DV = Var->getVariable();
1076 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1078 unsigned ArgNo = DV.getArgNumber();
1082 size_t Size = CurrentFnArguments.size();
1084 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1085 // llvm::Function argument size is not good indicator of how many
1086 // arguments does the function have at source level.
1088 CurrentFnArguments.resize(ArgNo * 2);
1089 CurrentFnArguments[ArgNo - 1] = Var;
1093 // Collect variable information from side table maintained by MMI.
1094 void DwarfDebug::collectVariableInfoFromMMITable(
1095 SmallPtrSet<const MDNode *, 16> &Processed) {
1096 for (const auto &VI : MMI->getVariableDbgInfo()) {
1099 Processed.insert(VI.Var);
1100 DIVariable DV(VI.Var);
1101 LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1103 // If variable scope is not found then skip this variable.
1107 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VI.Loc);
1108 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1109 RegVar->setFrameIndex(VI.Slot);
1110 if (!addCurrentFnArgument(RegVar, Scope))
1111 addScopeVariable(Scope, RegVar);
1113 AbsDbgVariable->setFrameIndex(VI.Slot);
1117 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1119 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1120 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1121 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1122 MI->getOperand(0).getReg() &&
1123 (MI->getOperand(1).isImm() ||
1124 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1127 // Get .debug_loc entry for the instruction range starting at MI.
1128 static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1129 const MCSymbol *FLabel,
1130 const MCSymbol *SLabel,
1131 const MachineInstr *MI,
1132 DwarfCompileUnit *Unit) {
1133 const MDNode *Var = MI->getDebugVariable();
1135 assert(MI->getNumOperands() == 3);
1136 if (MI->getOperand(0).isReg()) {
1137 MachineLocation MLoc;
1138 // If the second operand is an immediate, this is a
1139 // register-indirect address.
1140 if (!MI->getOperand(1).isImm())
1141 MLoc.set(MI->getOperand(0).getReg());
1143 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1144 return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
1146 if (MI->getOperand(0).isImm())
1147 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Var, Unit);
1148 if (MI->getOperand(0).isFPImm())
1149 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(),
1151 if (MI->getOperand(0).isCImm())
1152 return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(),
1155 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1158 // Find variables for each lexical scope.
1160 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1162 // Grab the variable info that was squirreled away in the MMI side-table.
1163 collectVariableInfoFromMMITable(Processed);
1165 for (const MDNode *Var : UserVariables) {
1166 if (Processed.count(Var))
1169 // History contains relevant DBG_VALUE instructions for Var and instructions
1171 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1172 if (History.empty())
1174 const MachineInstr *MInsn = History.front();
1177 LexicalScope *Scope = NULL;
1178 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1179 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1180 Scope = LScopes.getCurrentFunctionScope();
1181 else if (MDNode *IA = DV.getInlinedAt())
1182 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1184 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1185 // If variable scope is not found then skip this variable.
1189 Processed.insert(DV);
1190 assert(MInsn->isDebugValue() && "History must begin with debug value");
1191 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1192 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1193 if (!addCurrentFnArgument(RegVar, Scope))
1194 addScopeVariable(Scope, RegVar);
1196 AbsVar->setMInsn(MInsn);
1198 // Simplify ranges that are fully coalesced.
1199 if (History.size() <= 1 ||
1200 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1201 RegVar->setMInsn(MInsn);
1205 // Handle multiple DBG_VALUE instructions describing one variable.
1206 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1208 DotDebugLocEntries.resize(DotDebugLocEntries.size() + 1);
1209 DebugLocList &LocList = DotDebugLocEntries.back();
1211 Asm->GetTempSymbol("debug_loc", DotDebugLocEntries.size() - 1);
1212 SmallVector<DebugLocEntry, 4> &DebugLoc = LocList.List;
1213 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1214 HI = History.begin(),
1217 const MachineInstr *Begin = *HI;
1218 assert(Begin->isDebugValue() && "Invalid History entry");
1220 // Check if DBG_VALUE is truncating a range.
1221 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1222 !Begin->getOperand(0).getReg())
1225 // Compute the range for a register location.
1226 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1227 const MCSymbol *SLabel = 0;
1230 // If Begin is the last instruction in History then its value is valid
1231 // until the end of the function.
1232 SLabel = FunctionEndSym;
1234 const MachineInstr *End = HI[1];
1235 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1236 << "\t" << *Begin << "\t" << *End << "\n");
1237 if (End->isDebugValue())
1238 SLabel = getLabelBeforeInsn(End);
1240 // End is a normal instruction clobbering the range.
1241 SLabel = getLabelAfterInsn(End);
1242 assert(SLabel && "Forgot label after clobber instruction");
1247 // The value is valid until the next DBG_VALUE or clobber.
1248 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1249 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1250 DebugLocEntry Loc = getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU);
1251 if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
1252 DebugLoc.push_back(std::move(Loc));
1256 // Collect info for variables that were optimized out.
1257 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1258 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1259 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1260 DIVariable DV(Variables.getElement(i));
1261 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1263 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1264 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1268 // Return Label preceding the instruction.
1269 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1270 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1271 assert(Label && "Didn't insert label before instruction");
1275 // Return Label immediately following the instruction.
1276 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1277 return LabelsAfterInsn.lookup(MI);
1280 // Process beginning of an instruction.
1281 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1284 // Check if source location changes, but ignore DBG_VALUE locations.
1285 if (!MI->isDebugValue()) {
1286 DebugLoc DL = MI->getDebugLoc();
1287 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1290 if (DL == PrologEndLoc) {
1291 Flags |= DWARF2_FLAG_PROLOGUE_END;
1292 PrologEndLoc = DebugLoc();
1294 if (PrologEndLoc.isUnknown())
1295 Flags |= DWARF2_FLAG_IS_STMT;
1297 if (!DL.isUnknown()) {
1298 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1299 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1301 recordSourceLine(0, 0, 0, 0);
1305 // Insert labels where requested.
1306 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1307 LabelsBeforeInsn.find(MI);
1310 if (I == LabelsBeforeInsn.end())
1313 // Label already assigned.
1318 PrevLabel = MMI->getContext().CreateTempSymbol();
1319 Asm->OutStreamer.EmitLabel(PrevLabel);
1321 I->second = PrevLabel;
1324 // Process end of an instruction.
1325 void DwarfDebug::endInstruction() {
1327 // Don't create a new label after DBG_VALUE instructions.
1328 // They don't generate code.
1329 if (!CurMI->isDebugValue())
1332 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1333 LabelsAfterInsn.find(CurMI);
1337 if (I == LabelsAfterInsn.end())
1340 // Label already assigned.
1344 // We need a label after this instruction.
1346 PrevLabel = MMI->getContext().CreateTempSymbol();
1347 Asm->OutStreamer.EmitLabel(PrevLabel);
1349 I->second = PrevLabel;
1352 // Each LexicalScope has first instruction and last instruction to mark
1353 // beginning and end of a scope respectively. Create an inverse map that list
1354 // scopes starts (and ends) with an instruction. One instruction may start (or
1355 // end) multiple scopes. Ignore scopes that are not reachable.
1356 void DwarfDebug::identifyScopeMarkers() {
1357 SmallVector<LexicalScope *, 4> WorkList;
1358 WorkList.push_back(LScopes.getCurrentFunctionScope());
1359 while (!WorkList.empty()) {
1360 LexicalScope *S = WorkList.pop_back_val();
1362 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1363 if (!Children.empty())
1364 WorkList.append(Children.begin(), Children.end());
1366 if (S->isAbstractScope())
1369 for (const InsnRange &R : S->getRanges()) {
1370 assert(R.first && "InsnRange does not have first instruction!");
1371 assert(R.second && "InsnRange does not have second instruction!");
1372 requestLabelBeforeInsn(R.first);
1373 requestLabelAfterInsn(R.second);
1378 // Gather pre-function debug information. Assumes being called immediately
1379 // after the function entry point has been emitted.
1380 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1383 // If there's no debug info for the function we're not going to do anything.
1384 if (!MMI->hasDebugInfo())
1387 // Grab the lexical scopes for the function, if we don't have any of those
1388 // then we're not going to be able to do anything.
1389 LScopes.initialize(*MF);
1390 if (LScopes.empty())
1393 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1395 // Make sure that each lexical scope will have a begin/end label.
1396 identifyScopeMarkers();
1398 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1399 // belongs to so that we add to the correct per-cu line table in the
1401 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1402 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1403 assert(TheCU && "Unable to find compile unit!");
1404 if (Asm->OutStreamer.hasRawTextSupport())
1405 // Use a single line table if we are generating assembly.
1406 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1408 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1410 // Emit a label for the function so that we have a beginning address.
1411 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1412 // Assumes in correct section after the entry point.
1413 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1415 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1416 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1417 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1419 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1421 bool AtBlockEntry = true;
1422 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1424 const MachineInstr *MI = II;
1426 if (MI->isDebugValue()) {
1427 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1429 // Keep track of user variables.
1430 const MDNode *Var = MI->getDebugVariable();
1432 // Variable is in a register, we need to check for clobbers.
1433 if (isDbgValueInDefinedReg(MI))
1434 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1436 // Check the history of this variable.
1437 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1438 if (History.empty()) {
1439 UserVariables.push_back(Var);
1440 // The first mention of a function argument gets the FunctionBeginSym
1441 // label, so arguments are visible when breaking at function entry.
1443 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1444 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1445 LabelsBeforeInsn[MI] = FunctionBeginSym;
1447 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1448 const MachineInstr *Prev = History.back();
1449 if (Prev->isDebugValue()) {
1450 // Coalesce identical entries at the end of History.
1451 if (History.size() >= 2 &&
1452 Prev->isIdenticalTo(History[History.size() - 2])) {
1453 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1454 << "\t" << *Prev << "\t"
1455 << *History[History.size() - 2] << "\n");
1459 // Terminate old register assignments that don't reach MI;
1460 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1461 if (PrevMBB != I && (!AtBlockEntry || std::next(PrevMBB) != I) &&
1462 isDbgValueInDefinedReg(Prev)) {
1463 // Previous register assignment needs to terminate at the end of
1465 MachineBasicBlock::const_iterator LastMI =
1466 PrevMBB->getLastNonDebugInstr();
1467 if (LastMI == PrevMBB->end()) {
1468 // Drop DBG_VALUE for empty range.
1469 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1470 << "\t" << *Prev << "\n");
1472 } else if (std::next(PrevMBB) != PrevMBB->getParent()->end())
1473 // Terminate after LastMI.
1474 History.push_back(LastMI);
1478 History.push_back(MI);
1480 // Not a DBG_VALUE instruction.
1481 if (!MI->isPosition())
1482 AtBlockEntry = false;
1484 // First known non-DBG_VALUE and non-frame setup location marks
1485 // the beginning of the function body.
1486 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1487 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1488 PrologEndLoc = MI->getDebugLoc();
1490 // Check if the instruction clobbers any registers with debug vars.
1491 for (const MachineOperand &MO : MI->operands()) {
1492 if (!MO.isReg() || !MO.isDef() || !MO.getReg())
1494 for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
1497 const MDNode *Var = LiveUserVar[Reg];
1500 // Reg is now clobbered.
1501 LiveUserVar[Reg] = 0;
1503 // Was MD last defined by a DBG_VALUE referring to Reg?
1504 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1505 if (HistI == DbgValues.end())
1507 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1508 if (History.empty())
1510 const MachineInstr *Prev = History.back();
1511 // Sanity-check: Register assignments are terminated at the end of
1513 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1515 // Is the variable still in Reg?
1516 if (!isDbgValueInDefinedReg(Prev) ||
1517 Prev->getOperand(0).getReg() != Reg)
1519 // Var is clobbered. Make sure the next instruction gets a label.
1520 History.push_back(MI);
1527 for (auto &I : DbgValues) {
1528 SmallVectorImpl<const MachineInstr *> &History = I.second;
1529 if (History.empty())
1532 // Make sure the final register assignments are terminated.
1533 const MachineInstr *Prev = History.back();
1534 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1535 const MachineBasicBlock *PrevMBB = Prev->getParent();
1536 MachineBasicBlock::const_iterator LastMI =
1537 PrevMBB->getLastNonDebugInstr();
1538 if (LastMI == PrevMBB->end())
1539 // Drop DBG_VALUE for empty range.
1541 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1542 // Terminate after LastMI.
1543 History.push_back(LastMI);
1546 // Request labels for the full history.
1547 for (const MachineInstr *MI : History) {
1548 if (MI->isDebugValue())
1549 requestLabelBeforeInsn(MI);
1551 requestLabelAfterInsn(MI);
1555 PrevInstLoc = DebugLoc();
1556 PrevLabel = FunctionBeginSym;
1558 // Record beginning of function.
1559 if (!PrologEndLoc.isUnknown()) {
1560 DebugLoc FnStartDL =
1561 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1563 FnStartDL.getLine(), FnStartDL.getCol(),
1564 FnStartDL.getScope(MF->getFunction()->getContext()),
1565 // We'd like to list the prologue as "not statements" but GDB behaves
1566 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1567 DWARF2_FLAG_IS_STMT);
1571 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1572 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1573 DIVariable DV = Var->getVariable();
1574 // Variables with positive arg numbers are parameters.
1575 if (unsigned ArgNum = DV.getArgNumber()) {
1576 // Keep all parameters in order at the start of the variable list to ensure
1577 // function types are correct (no out-of-order parameters)
1579 // This could be improved by only doing it for optimized builds (unoptimized
1580 // builds have the right order to begin with), searching from the back (this
1581 // would catch the unoptimized case quickly), or doing a binary search
1582 // rather than linear search.
1583 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1584 while (I != Vars.end()) {
1585 unsigned CurNum = (*I)->getVariable().getArgNumber();
1586 // A local (non-parameter) variable has been found, insert immediately
1590 // A later indexed parameter has been found, insert immediately before it.
1591 if (CurNum > ArgNum)
1595 Vars.insert(I, Var);
1599 Vars.push_back(Var);
1602 // Gather and emit post-function debug information.
1603 void DwarfDebug::endFunction(const MachineFunction *MF) {
1604 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1605 // though the beginFunction may not be called at all.
1606 // We should handle both cases.
1610 assert(CurFn == MF);
1613 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1614 // If we don't have a lexical scope for this function then there will
1615 // be a hole in the range information. Keep note of this by setting the
1616 // previously used section to nullptr.
1617 PrevSection = nullptr;
1623 // Define end label for subprogram.
1624 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1625 // Assumes in correct section after the entry point.
1626 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1628 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1629 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1631 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1632 collectVariableInfo(ProcessedVars);
1634 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1635 DwarfCompileUnit &TheCU = *SPMap.lookup(FnScope->getScopeNode());
1637 // Construct abstract scopes.
1638 for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
1639 DISubprogram SP(AScope->getScopeNode());
1640 if (SP.isSubprogram()) {
1641 // Collect info for variables that were optimized out.
1642 DIArray Variables = SP.getVariables();
1643 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1644 DIVariable DV(Variables.getElement(i));
1645 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1647 // Check that DbgVariable for DV wasn't created earlier, when
1648 // findAbstractVariable() was called for inlined instance of DV.
1649 LLVMContext &Ctx = DV->getContext();
1650 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1651 if (AbstractVariables.lookup(CleanDV))
1653 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1654 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1657 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1658 constructScopeDIE(TheCU, AScope);
1661 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1662 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1663 TheCU.addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1665 // Add the range of this function to the list of ranges for the CU.
1666 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1667 TheCU.addRange(std::move(Span));
1668 PrevSection = Asm->getCurrentSection();
1672 for (auto &I : ScopeVariables)
1673 DeleteContainerPointers(I.second);
1674 ScopeVariables.clear();
1675 DeleteContainerPointers(CurrentFnArguments);
1676 UserVariables.clear();
1678 AbstractVariables.clear();
1679 LabelsBeforeInsn.clear();
1680 LabelsAfterInsn.clear();
1685 // Register a source line with debug info. Returns the unique label that was
1686 // emitted and which provides correspondence to the source line list.
1687 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1692 unsigned Discriminator = 0;
1694 DIDescriptor Scope(S);
1696 if (Scope.isCompileUnit()) {
1697 DICompileUnit CU(S);
1698 Fn = CU.getFilename();
1699 Dir = CU.getDirectory();
1700 } else if (Scope.isFile()) {
1702 Fn = F.getFilename();
1703 Dir = F.getDirectory();
1704 } else if (Scope.isSubprogram()) {
1706 Fn = SP.getFilename();
1707 Dir = SP.getDirectory();
1708 } else if (Scope.isLexicalBlockFile()) {
1709 DILexicalBlockFile DBF(S);
1710 Fn = DBF.getFilename();
1711 Dir = DBF.getDirectory();
1712 } else if (Scope.isLexicalBlock()) {
1713 DILexicalBlock DB(S);
1714 Fn = DB.getFilename();
1715 Dir = DB.getDirectory();
1716 Discriminator = DB.getDiscriminator();
1718 llvm_unreachable("Unexpected scope info");
1720 unsigned CUID = Asm->OutStreamer.getContext().getDwarfCompileUnitID();
1721 Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
1722 .getOrCreateSourceID(Fn, Dir);
1724 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
1728 //===----------------------------------------------------------------------===//
1730 //===----------------------------------------------------------------------===//
1732 // Emit initial Dwarf sections with a label at the start of each one.
1733 void DwarfDebug::emitSectionLabels() {
1734 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1736 // Dwarf sections base addresses.
1737 DwarfInfoSectionSym =
1738 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1739 if (useSplitDwarf())
1740 DwarfInfoDWOSectionSym =
1741 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1742 DwarfAbbrevSectionSym =
1743 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1744 if (useSplitDwarf())
1745 DwarfAbbrevDWOSectionSym = emitSectionSym(
1746 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1747 if (GenerateARangeSection)
1748 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1750 DwarfLineSectionSym =
1751 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1752 if (GenerateGnuPubSections) {
1753 DwarfGnuPubNamesSectionSym =
1754 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1755 DwarfGnuPubTypesSectionSym =
1756 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1757 } else if (HasDwarfPubSections) {
1758 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1759 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1762 DwarfStrSectionSym =
1763 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1764 if (useSplitDwarf()) {
1765 DwarfStrDWOSectionSym =
1766 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1767 DwarfAddrSectionSym =
1768 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1769 DwarfDebugLocSectionSym =
1770 emitSectionSym(Asm, TLOF.getDwarfLocDWOSection(), "skel_loc");
1772 DwarfDebugLocSectionSym =
1773 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1774 DwarfDebugRangeSectionSym =
1775 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1778 // Recursively emits a debug information entry.
1779 void DwarfDebug::emitDIE(DIE &Die) {
1780 // Get the abbreviation for this DIE.
1781 const DIEAbbrev &Abbrev = Die.getAbbrev();
1783 // Emit the code (index) for the abbreviation.
1784 if (Asm->isVerbose())
1785 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
1786 "] 0x" + Twine::utohexstr(Die.getOffset()) +
1787 ":0x" + Twine::utohexstr(Die.getSize()) + " " +
1788 dwarf::TagString(Abbrev.getTag()));
1789 Asm->EmitULEB128(Abbrev.getNumber());
1791 const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
1792 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1794 // Emit the DIE attribute values.
1795 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1796 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
1797 dwarf::Form Form = AbbrevData[i].getForm();
1798 assert(Form && "Too many attributes for DIE (check abbreviation)");
1800 if (Asm->isVerbose()) {
1801 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1802 if (Attr == dwarf::DW_AT_accessibility)
1803 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(
1804 cast<DIEInteger>(Values[i])->getValue()));
1807 // Emit an attribute using the defined form.
1808 Values[i]->EmitValue(Asm, Form);
1811 // Emit the DIE children if any.
1812 if (Abbrev.hasChildren()) {
1813 for (auto &Child : Die.getChildren())
1816 Asm->OutStreamer.AddComment("End Of Children Mark");
1821 // Emit the debug info section.
1822 void DwarfDebug::emitDebugInfo() {
1823 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1825 Holder.emitUnits(this, DwarfAbbrevSectionSym);
1828 // Emit the abbreviation section.
1829 void DwarfDebug::emitAbbreviations() {
1830 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1832 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1835 // Emit the last address of the section and the end of the line matrix.
1836 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1837 // Define last address of section.
1838 Asm->OutStreamer.AddComment("Extended Op");
1841 Asm->OutStreamer.AddComment("Op size");
1842 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1843 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1844 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1846 Asm->OutStreamer.AddComment("Section end label");
1848 Asm->OutStreamer.EmitSymbolValue(
1849 Asm->GetTempSymbol("section_end", SectionEnd),
1850 Asm->getDataLayout().getPointerSize());
1852 // Mark end of matrix.
1853 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1859 // Emit visible names into a hashed accelerator table section.
1860 void DwarfDebug::emitAccelNames() {
1861 AccelNames.FinalizeTable(Asm, "Names");
1862 Asm->OutStreamer.SwitchSection(
1863 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1864 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1865 Asm->OutStreamer.EmitLabel(SectionBegin);
1867 // Emit the full data.
1868 AccelNames.Emit(Asm, SectionBegin, &InfoHolder);
1871 // Emit objective C classes and categories into a hashed accelerator table
1873 void DwarfDebug::emitAccelObjC() {
1875 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
1876 for (const auto &TheU : getUnits()) {
1877 for (const auto &GI : TheU->getAccelObjC()) {
1878 StringRef Name = GI.getKey();
1879 for (const DIE *D : GI.second)
1880 AT.AddName(Name, D);
1884 AT.FinalizeTable(Asm, "ObjC");
1885 Asm->OutStreamer.SwitchSection(
1886 Asm->getObjFileLowering().getDwarfAccelObjCSection());
1887 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1888 Asm->OutStreamer.EmitLabel(SectionBegin);
1890 // Emit the full data.
1891 AT.Emit(Asm, SectionBegin, &InfoHolder);
1894 // Emit namespace dies into a hashed accelerator table.
1895 void DwarfDebug::emitAccelNamespaces() {
1897 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
1898 for (const auto &TheU : getUnits()) {
1899 for (const auto &GI : TheU->getAccelNamespace()) {
1900 StringRef Name = GI.getKey();
1901 for (const DIE *D : GI.second)
1902 AT.AddName(Name, D);
1906 AT.FinalizeTable(Asm, "namespac");
1907 Asm->OutStreamer.SwitchSection(
1908 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
1909 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1910 Asm->OutStreamer.EmitLabel(SectionBegin);
1912 // Emit the full data.
1913 AT.Emit(Asm, SectionBegin, &InfoHolder);
1916 // Emit type dies into a hashed accelerator table.
1917 void DwarfDebug::emitAccelTypes() {
1918 DwarfAccelTable::Atom Atoms[] = {
1919 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4),
1920 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2),
1921 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1)};
1922 DwarfAccelTable AT(Atoms);
1923 for (const auto &TheU : getUnits()) {
1924 for (const auto &GI : TheU->getAccelTypes()) {
1925 StringRef Name = GI.getKey();
1926 for (const auto &DI : GI.second)
1927 AT.AddName(Name, DI.first, DI.second);
1931 AT.FinalizeTable(Asm, "types");
1932 Asm->OutStreamer.SwitchSection(
1933 Asm->getObjFileLowering().getDwarfAccelTypesSection());
1934 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1935 Asm->OutStreamer.EmitLabel(SectionBegin);
1937 // Emit the full data.
1938 AT.Emit(Asm, SectionBegin, &InfoHolder);
1941 // Public name handling.
1942 // The format for the various pubnames:
1944 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
1945 // for the DIE that is named.
1947 // gnu pubnames - offset/index value/name tuples where the offset is the offset
1948 // into the CU and the index value is computed according to the type of value
1949 // for the DIE that is named.
1951 // For type units the offset is the offset of the skeleton DIE. For split dwarf
1952 // it's the offset within the debug_info/debug_types dwo section, however, the
1953 // reference in the pubname header doesn't change.
1955 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
1956 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
1958 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
1960 // We could have a specification DIE that has our most of our knowledge,
1961 // look for that now.
1962 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
1964 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
1965 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
1966 Linkage = dwarf::GIEL_EXTERNAL;
1967 } else if (Die->findAttribute(dwarf::DW_AT_external))
1968 Linkage = dwarf::GIEL_EXTERNAL;
1970 switch (Die->getTag()) {
1971 case dwarf::DW_TAG_class_type:
1972 case dwarf::DW_TAG_structure_type:
1973 case dwarf::DW_TAG_union_type:
1974 case dwarf::DW_TAG_enumeration_type:
1975 return dwarf::PubIndexEntryDescriptor(
1976 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
1977 ? dwarf::GIEL_STATIC
1978 : dwarf::GIEL_EXTERNAL);
1979 case dwarf::DW_TAG_typedef:
1980 case dwarf::DW_TAG_base_type:
1981 case dwarf::DW_TAG_subrange_type:
1982 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
1983 case dwarf::DW_TAG_namespace:
1984 return dwarf::GIEK_TYPE;
1985 case dwarf::DW_TAG_subprogram:
1986 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
1987 case dwarf::DW_TAG_constant:
1988 case dwarf::DW_TAG_variable:
1989 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
1990 case dwarf::DW_TAG_enumerator:
1991 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
1992 dwarf::GIEL_STATIC);
1994 return dwarf::GIEK_NONE;
1998 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2000 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2001 const MCSection *PSec =
2002 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2003 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2005 emitDebugPubSection(GnuStyle, PSec, "Names", &DwarfUnit::getGlobalNames);
2008 void DwarfDebug::emitDebugPubSection(
2009 bool GnuStyle, const MCSection *PSec, StringRef Name,
2010 const StringMap<const DIE *> &(DwarfUnit::*Accessor)() const) {
2011 for (const auto &NU : CUMap) {
2012 DwarfCompileUnit *TheU = NU.second;
2014 const auto &Globals = (TheU->*Accessor)();
2016 if (Globals.empty())
2019 if (auto Skeleton = static_cast<DwarfCompileUnit *>(TheU->getSkeleton()))
2021 unsigned ID = TheU->getUniqueID();
2023 // Start the dwarf pubnames section.
2024 Asm->OutStreamer.SwitchSection(PSec);
2027 Asm->OutStreamer.AddComment("Length of Public " + Name + " Info");
2028 MCSymbol *BeginLabel = Asm->GetTempSymbol("pub" + Name + "_begin", ID);
2029 MCSymbol *EndLabel = Asm->GetTempSymbol("pub" + Name + "_end", ID);
2030 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2032 Asm->OutStreamer.EmitLabel(BeginLabel);
2034 Asm->OutStreamer.AddComment("DWARF Version");
2035 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2037 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2038 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2040 Asm->OutStreamer.AddComment("Compilation Unit Length");
2041 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2043 // Emit the pubnames for this compilation unit.
2044 for (const auto &GI : Globals) {
2045 const char *Name = GI.getKeyData();
2046 const DIE *Entity = GI.second;
2048 Asm->OutStreamer.AddComment("DIE offset");
2049 Asm->EmitInt32(Entity->getOffset());
2052 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2053 Asm->OutStreamer.AddComment(
2054 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2055 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2056 Asm->EmitInt8(Desc.toBits());
2059 Asm->OutStreamer.AddComment("External Name");
2060 Asm->OutStreamer.EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
2063 Asm->OutStreamer.AddComment("End Mark");
2065 Asm->OutStreamer.EmitLabel(EndLabel);
2069 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2070 const MCSection *PSec =
2071 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2072 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2074 emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
2077 // Emit visible names into a debug str section.
2078 void DwarfDebug::emitDebugStr() {
2079 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2080 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2083 void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
2084 const DebugLocEntry &Entry) {
2085 DIVariable DV(Entry.getVariable());
2086 if (Entry.isInt()) {
2087 DIBasicType BTy(resolve(DV.getType()));
2088 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2089 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2090 Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
2091 Streamer.EmitSLEB128(Entry.getInt());
2093 Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
2094 Streamer.EmitULEB128(Entry.getInt());
2096 } else if (Entry.isLocation()) {
2097 MachineLocation Loc = Entry.getLoc();
2098 if (!DV.hasComplexAddress())
2100 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2102 // Complex address entry.
2103 unsigned N = DV.getNumAddrElements();
2105 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2106 if (Loc.getOffset()) {
2108 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2109 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2110 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2111 Streamer.EmitSLEB128(DV.getAddrElement(1));
2113 // If first address element is OpPlus then emit
2114 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2115 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2116 Asm->EmitDwarfRegOp(Streamer, TLoc, DV.isIndirect());
2120 Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());
2123 // Emit remaining complex address elements.
2124 for (; i < N; ++i) {
2125 uint64_t Element = DV.getAddrElement(i);
2126 if (Element == DIBuilder::OpPlus) {
2127 Streamer.EmitInt8(dwarf::DW_OP_plus_uconst, "DW_OP_plus_uconst");
2128 Streamer.EmitULEB128(DV.getAddrElement(++i));
2129 } else if (Element == DIBuilder::OpDeref) {
2131 Streamer.EmitInt8(dwarf::DW_OP_deref, "DW_OP_deref");
2133 llvm_unreachable("unknown Opcode found in complex address");
2137 // else ... ignore constant fp. There is not any good way to
2138 // to represent them here in dwarf.
2142 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocEntry &Entry) {
2143 Asm->OutStreamer.AddComment("Loc expr size");
2144 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2145 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2146 Asm->EmitLabelDifference(end, begin, 2);
2147 Asm->OutStreamer.EmitLabel(begin);
2149 APByteStreamer Streamer(*Asm);
2150 emitDebugLocEntry(Streamer, Entry);
2152 Asm->OutStreamer.EmitLabel(end);
2155 // Emit locations into the debug loc section.
2156 void DwarfDebug::emitDebugLoc() {
2157 // Start the dwarf loc section.
2158 Asm->OutStreamer.SwitchSection(
2159 Asm->getObjFileLowering().getDwarfLocSection());
2160 unsigned char Size = Asm->getDataLayout().getPointerSize();
2161 for (const auto &DebugLoc : DotDebugLocEntries) {
2162 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2163 for (const auto &Entry : DebugLoc.List) {
2164 // Set up the range. This range is relative to the entry point of the
2165 // compile unit. This is a hard coded 0 for low_pc when we're emitting
2166 // ranges, or the DW_AT_low_pc on the compile unit otherwise.
2167 const DwarfCompileUnit *CU = Entry.getCU();
2168 if (CU->getRanges().size() == 1) {
2169 // Grab the begin symbol from the first range as our base.
2170 const MCSymbol *Base = CU->getRanges()[0].getStart();
2171 Asm->EmitLabelDifference(Entry.getBeginSym(), Base, Size);
2172 Asm->EmitLabelDifference(Entry.getEndSym(), Base, Size);
2174 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2175 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2178 emitDebugLocEntryLocation(Entry);
2180 Asm->OutStreamer.EmitIntValue(0, Size);
2181 Asm->OutStreamer.EmitIntValue(0, Size);
2185 void DwarfDebug::emitDebugLocDWO() {
2186 Asm->OutStreamer.SwitchSection(
2187 Asm->getObjFileLowering().getDwarfLocDWOSection());
2188 for (const auto &DebugLoc : DotDebugLocEntries) {
2189 Asm->OutStreamer.EmitLabel(DebugLoc.Label);
2190 for (const auto &Entry : DebugLoc.List) {
2191 // Just always use start_length for now - at least that's one address
2192 // rather than two. We could get fancier and try to, say, reuse an
2193 // address we know we've emitted elsewhere (the start of the function?
2194 // The start of the CU or CU subrange that encloses this range?)
2195 Asm->EmitInt8(dwarf::DW_LLE_start_length_entry);
2196 unsigned idx = AddrPool.getIndex(Entry.getBeginSym());
2197 Asm->EmitULEB128(idx);
2198 Asm->EmitLabelDifference(Entry.getEndSym(), Entry.getBeginSym(), 4);
2200 emitDebugLocEntryLocation(Entry);
2202 Asm->EmitInt8(dwarf::DW_LLE_end_of_list_entry);
2207 const MCSymbol *Start, *End;
2210 // Emit a debug aranges section, containing a CU lookup for any
2211 // address we can tie back to a CU.
2212 void DwarfDebug::emitDebugARanges() {
2213 // Start the dwarf aranges section.
2214 Asm->OutStreamer.SwitchSection(
2215 Asm->getObjFileLowering().getDwarfARangesSection());
2217 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2221 // Build a list of sections used.
2222 std::vector<const MCSection *> Sections;
2223 for (const auto &it : SectionMap) {
2224 const MCSection *Section = it.first;
2225 Sections.push_back(Section);
2228 // Sort the sections into order.
2229 // This is only done to ensure consistent output order across different runs.
2230 std::sort(Sections.begin(), Sections.end(), SectionSort);
2232 // Build a set of address spans, sorted by CU.
2233 for (const MCSection *Section : Sections) {
2234 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2235 if (List.size() < 2)
2238 // Sort the symbols by offset within the section.
2239 std::sort(List.begin(), List.end(),
2240 [&](const SymbolCU &A, const SymbolCU &B) {
2241 unsigned IA = A.Sym ? Asm->OutStreamer.GetSymbolOrder(A.Sym) : 0;
2242 unsigned IB = B.Sym ? Asm->OutStreamer.GetSymbolOrder(B.Sym) : 0;
2244 // Symbols with no order assigned should be placed at the end.
2245 // (e.g. section end labels)
2253 // If we have no section (e.g. common), just write out
2254 // individual spans for each symbol.
2255 if (Section == NULL) {
2256 for (const SymbolCU &Cur : List) {
2258 Span.Start = Cur.Sym;
2261 Spans[Cur.CU].push_back(Span);
2264 // Build spans between each label.
2265 const MCSymbol *StartSym = List[0].Sym;
2266 for (size_t n = 1, e = List.size(); n < e; n++) {
2267 const SymbolCU &Prev = List[n - 1];
2268 const SymbolCU &Cur = List[n];
2270 // Try and build the longest span we can within the same CU.
2271 if (Cur.CU != Prev.CU) {
2273 Span.Start = StartSym;
2275 Spans[Prev.CU].push_back(Span);
2282 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2284 // Build a list of CUs used.
2285 std::vector<DwarfCompileUnit *> CUs;
2286 for (const auto &it : Spans) {
2287 DwarfCompileUnit *CU = it.first;
2291 // Sort the CU list (again, to ensure consistent output order).
2292 std::sort(CUs.begin(), CUs.end(), [](const DwarfUnit *A, const DwarfUnit *B) {
2293 return A->getUniqueID() < B->getUniqueID();
2296 // Emit an arange table for each CU we used.
2297 for (DwarfCompileUnit *CU : CUs) {
2298 std::vector<ArangeSpan> &List = Spans[CU];
2300 // Emit size of content not including length itself.
2301 unsigned ContentSize =
2302 sizeof(int16_t) + // DWARF ARange version number
2303 sizeof(int32_t) + // Offset of CU in the .debug_info section
2304 sizeof(int8_t) + // Pointer Size (in bytes)
2305 sizeof(int8_t); // Segment Size (in bytes)
2307 unsigned TupleSize = PtrSize * 2;
2309 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2311 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2313 ContentSize += Padding;
2314 ContentSize += (List.size() + 1) * TupleSize;
2316 // For each compile unit, write the list of spans it covers.
2317 Asm->OutStreamer.AddComment("Length of ARange Set");
2318 Asm->EmitInt32(ContentSize);
2319 Asm->OutStreamer.AddComment("DWARF Arange version number");
2320 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2321 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2322 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2323 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2324 Asm->EmitInt8(PtrSize);
2325 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2328 Asm->OutStreamer.EmitFill(Padding, 0xff);
2330 for (const ArangeSpan &Span : List) {
2331 Asm->EmitLabelReference(Span.Start, PtrSize);
2333 // Calculate the size as being from the span start to it's end.
2335 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2337 // For symbols without an end marker (e.g. common), we
2338 // write a single arange entry containing just that one symbol.
2339 uint64_t Size = SymSize[Span.Start];
2343 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2347 Asm->OutStreamer.AddComment("ARange terminator");
2348 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2349 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2353 // Emit visible names into a debug ranges section.
2354 void DwarfDebug::emitDebugRanges() {
2355 // Start the dwarf ranges section.
2356 Asm->OutStreamer.SwitchSection(
2357 Asm->getObjFileLowering().getDwarfRangesSection());
2359 // Size for our labels.
2360 unsigned char Size = Asm->getDataLayout().getPointerSize();
2362 // Grab the specific ranges for the compile units in the module.
2363 for (const auto &I : CUMap) {
2364 DwarfCompileUnit *TheCU = I.second;
2366 // Emit a symbol so we can find the beginning of our ranges.
2367 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2369 // Iterate over the misc ranges for the compile units in the module.
2370 for (const RangeSpanList &List : TheCU->getRangeLists()) {
2371 // Emit our symbol so we can find the beginning of the range.
2372 Asm->OutStreamer.EmitLabel(List.getSym());
2374 for (const RangeSpan &Range : List.getRanges()) {
2375 const MCSymbol *Begin = Range.getStart();
2376 const MCSymbol *End = Range.getEnd();
2377 assert(Begin && "Range without a begin symbol?");
2378 assert(End && "Range without an end symbol?");
2379 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2380 Asm->OutStreamer.EmitSymbolValue(End, Size);
2383 // And terminate the list with two 0 values.
2384 Asm->OutStreamer.EmitIntValue(0, Size);
2385 Asm->OutStreamer.EmitIntValue(0, Size);
2388 // Now emit a range for the CU itself.
2389 if (TheCU->getRanges().size() > 1) {
2390 Asm->OutStreamer.EmitLabel(
2391 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2392 for (const RangeSpan &Range : TheCU->getRanges()) {
2393 const MCSymbol *Begin = Range.getStart();
2394 const MCSymbol *End = Range.getEnd();
2395 assert(Begin && "Range without a begin symbol?");
2396 assert(End && "Range without an end symbol?");
2397 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2398 Asm->OutStreamer.EmitSymbolValue(End, Size);
2400 // And terminate the list with two 0 values.
2401 Asm->OutStreamer.EmitIntValue(0, Size);
2402 Asm->OutStreamer.EmitIntValue(0, Size);
2407 // DWARF5 Experimental Separate Dwarf emitters.
2409 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE *Die,
2410 std::unique_ptr<DwarfUnit> NewU) {
2411 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2412 U.getCUNode().getSplitDebugFilename());
2414 if (!CompilationDir.empty())
2415 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2417 addGnuPubAttributes(*NewU, Die);
2419 SkeletonHolder.addUnit(std::move(NewU));
2422 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2423 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2424 // DW_AT_addr_base, DW_AT_ranges_base.
2425 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
2427 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2428 auto OwnedUnit = make_unique<DwarfCompileUnit>(
2429 CU.getUniqueID(), Die, CU.getCUNode(), Asm, this, &SkeletonHolder);
2430 DwarfCompileUnit &NewCU = *OwnedUnit;
2431 NewCU.initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2432 DwarfInfoSectionSym);
2434 NewCU.initStmtList(DwarfLineSectionSym);
2436 initSkeletonUnit(CU, Die, std::move(OwnedUnit));
2441 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2443 DwarfTypeUnit &DwarfDebug::constructSkeletonTU(DwarfTypeUnit &TU) {
2444 DwarfCompileUnit &CU = static_cast<DwarfCompileUnit &>(
2445 *SkeletonHolder.getUnits()[TU.getCU().getUniqueID()]);
2447 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2448 auto OwnedUnit = make_unique<DwarfTypeUnit>(TU.getUniqueID(), Die, CU, Asm,
2449 this, &SkeletonHolder);
2450 DwarfTypeUnit &NewTU = *OwnedUnit;
2451 NewTU.setTypeSignature(TU.getTypeSignature());
2452 NewTU.setType(NULL);
2454 Asm->getObjFileLowering().getDwarfTypesSection(TU.getTypeSignature()));
2456 initSkeletonUnit(TU, Die, std::move(OwnedUnit));
2460 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2461 // compile units that would normally be in debug_info.
2462 void DwarfDebug::emitDebugInfoDWO() {
2463 assert(useSplitDwarf() && "No split dwarf debug info?");
2464 // Don't pass an abbrev symbol, using a constant zero instead so as not to
2465 // emit relocations into the dwo file.
2466 InfoHolder.emitUnits(this, /* AbbrevSymbol */nullptr);
2469 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2470 // abbreviations for the .debug_info.dwo section.
2471 void DwarfDebug::emitDebugAbbrevDWO() {
2472 assert(useSplitDwarf() && "No split dwarf?");
2473 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2476 void DwarfDebug::emitDebugLineDWO() {
2477 assert(useSplitDwarf() && "No split dwarf?");
2478 Asm->OutStreamer.SwitchSection(
2479 Asm->getObjFileLowering().getDwarfLineDWOSection());
2480 SplitTypeUnitFileTable.Emit(Asm->OutStreamer);
2483 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2484 // string section and is identical in format to traditional .debug_str
2486 void DwarfDebug::emitDebugStrDWO() {
2487 assert(useSplitDwarf() && "No split dwarf?");
2488 const MCSection *OffSec =
2489 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
2490 const MCSymbol *StrSym = DwarfStrSectionSym;
2491 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2495 MCDwarfDwoLineTable *DwarfDebug::getDwoLineTable(const DwarfCompileUnit &CU) {
2496 if (!useSplitDwarf())
2499 SplitTypeUnitFileTable.setCompilationDir(CU.getCUNode().getDirectory());
2500 return &SplitTypeUnitFileTable;
2503 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
2504 StringRef Identifier, DIE *RefDie,
2505 DICompositeType CTy) {
2506 // Flag the type unit reference as a declaration so that if it contains
2507 // members (implicit special members, static data member definitions, member
2508 // declarations for definitions in this CU, etc) consumers don't get confused
2509 // and think this is a full definition.
2510 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
2512 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
2514 CU.addDIETypeSignature(RefDie, *TU);
2518 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
2520 make_unique<DwarfTypeUnit>(InfoHolder.getUnits().size(), UnitDie, CU, Asm,
2521 this, &InfoHolder, getDwoLineTable(CU));
2522 DwarfTypeUnit &NewTU = *OwnedUnit;
2524 InfoHolder.addUnit(std::move(OwnedUnit));
2526 NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
2530 Hash.update(Identifier);
2531 // ... take the least significant 8 bytes and return those. Our MD5
2532 // implementation always returns its results in little endian, swap bytes
2534 MD5::MD5Result Result;
2536 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
2537 NewTU.setTypeSignature(Signature);
2538 if (useSplitDwarf())
2539 NewTU.setSkeleton(constructSkeletonTU(NewTU));
2541 CU.applyStmtList(*UnitDie);
2543 NewTU.setType(NewTU.createTypeDIE(CTy));
2547 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
2548 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
2550 CU.addDIETypeSignature(RefDie, NewTU);
2553 void DwarfDebug::attachLowHighPC(DwarfCompileUnit &Unit, DIE *D,
2554 MCSymbol *Begin, MCSymbol *End) {
2555 Unit.addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
2556 if (DwarfVersion < 4)
2557 Unit.addLabelAddress(D, dwarf::DW_AT_high_pc, End);
2559 Unit.addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
2562 // Accelerator table mutators - add each name along with its companion
2563 // DIE to the proper table while ensuring that the name that we're going
2564 // to reference is in the string table. We do this since the names we
2565 // add may not only be identical to the names in the DIE.
2566 void DwarfDebug::addAccelName(StringRef Name, const DIE *Die) {
2567 if (!useDwarfAccelTables())
2569 InfoHolder.getStringPoolEntry(Name);
2570 AccelNames.AddName(Name, Die);