1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.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/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.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"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
62 GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
66 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
67 cl::desc("Add the CU hash as the dwo_id."),
71 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
72 cl::desc("Generate GNU-style pubnames and pubtypes"),
83 static cl::opt<DefaultOnOff>
84 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
85 cl::desc("Output prototype dwarf accelerator tables."),
86 cl::values(clEnumVal(Default, "Default for platform"),
87 clEnumVal(Enable, "Enabled"),
88 clEnumVal(Disable, "Disabled"), clEnumValEnd),
91 static cl::opt<DefaultOnOff>
92 SplitDwarf("split-dwarf", cl::Hidden,
93 cl::desc("Output DWARF5 split debug info."),
94 cl::values(clEnumVal(Default, "Default for platform"),
95 clEnumVal(Enable, "Enabled"),
96 clEnumVal(Disable, "Disabled"), clEnumValEnd),
99 static cl::opt<DefaultOnOff>
100 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
101 cl::desc("Generate DWARF pubnames and pubtypes sections"),
102 cl::values(clEnumVal(Default, "Default for platform"),
103 clEnumVal(Enable, "Enabled"),
104 clEnumVal(Disable, "Disabled"), clEnumValEnd),
107 static cl::opt<unsigned>
108 DwarfVersionNumber("dwarf-version", cl::Hidden,
109 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
112 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
113 cl::desc("Generate DW_AT_ranges for compile units"),
116 static const char *const DWARFGroupName = "DWARF Emission";
117 static const char *const DbgTimerName = "DWARF Debug Writer";
119 //===----------------------------------------------------------------------===//
123 /// resolve - Look in the DwarfDebug map for the MDNode that
124 /// corresponds to the reference.
125 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
126 return DD->resolve(Ref);
129 DIType DbgVariable::getType() const {
130 DIType Ty = Var.getType();
131 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
132 // addresses instead.
133 if (Var.isBlockByrefVariable()) {
134 /* Byref variables, in Blocks, are declared by the programmer as
135 "SomeType VarName;", but the compiler creates a
136 __Block_byref_x_VarName struct, and gives the variable VarName
137 either the struct, or a pointer to the struct, as its type. This
138 is necessary for various behind-the-scenes things the compiler
139 needs to do with by-reference variables in blocks.
141 However, as far as the original *programmer* is concerned, the
142 variable should still have type 'SomeType', as originally declared.
144 The following function dives into the __Block_byref_x_VarName
145 struct to find the original type of the variable. This will be
146 passed back to the code generating the type for the Debug
147 Information Entry for the variable 'VarName'. 'VarName' will then
148 have the original type 'SomeType' in its debug information.
150 The original type 'SomeType' will be the type of the field named
151 'VarName' inside the __Block_byref_x_VarName struct.
153 NOTE: In order for this to not completely fail on the debugger
154 side, the Debug Information Entry for the variable VarName needs to
155 have a DW_AT_location that tells the debugger how to unwind through
156 the pointers and __Block_byref_x_VarName struct to find the actual
157 value of the variable. The function addBlockByrefType does this. */
159 uint16_t tag = Ty.getTag();
161 if (tag == dwarf::DW_TAG_pointer_type)
162 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
164 DIArray Elements = DICompositeType(subType).getTypeArray();
165 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
166 DIDerivedType DT(Elements.getElement(i));
167 if (getName() == DT.getName())
168 return (resolve(DT.getTypeDerivedFrom()));
174 } // end llvm namespace
176 /// Return Dwarf Version by checking module flags.
177 static unsigned getDwarfVersionFromModule(const Module *M) {
178 Value *Val = M->getModuleFlag("Dwarf Version");
180 return dwarf::DWARF_VERSION;
181 return cast<ConstantInt>(Val)->getZExtValue();
184 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
185 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
186 PrevLabel(NULL), GlobalRangeCount(0),
187 InfoHolder(A, "info_string", DIEValueAllocator),
188 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
190 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
191 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
192 DwarfAddrSectionSym = 0;
193 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
194 FunctionBeginSym = FunctionEndSym = 0;
198 // Turn on accelerator tables for Darwin by default, pubnames by
199 // default for non-Darwin, and handle split dwarf.
200 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
202 if (DwarfAccelTables == Default)
203 HasDwarfAccelTables = IsDarwin;
205 HasDwarfAccelTables = DwarfAccelTables == Enable;
207 if (SplitDwarf == Default)
208 HasSplitDwarf = false;
210 HasSplitDwarf = SplitDwarf == Enable;
212 if (DwarfPubSections == Default)
213 HasDwarfPubSections = !IsDarwin;
215 HasDwarfPubSections = DwarfPubSections == Enable;
217 DwarfVersion = DwarfVersionNumber
219 : getDwarfVersionFromModule(MMI->getModule());
222 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
227 // Switch to the specified MCSection and emit an assembler
228 // temporary label to it if SymbolStem is specified.
229 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
230 const char *SymbolStem = 0) {
231 Asm->OutStreamer.SwitchSection(Section);
235 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
236 Asm->OutStreamer.EmitLabel(TmpSym);
240 DwarfFile::~DwarfFile() {
241 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
246 MCSymbol *DwarfFile::getStringPoolSym() {
247 return Asm->GetTempSymbol(StringPref);
250 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
251 std::pair<MCSymbol *, unsigned> &Entry =
252 StringPool.GetOrCreateValue(Str).getValue();
256 Entry.second = NextStringPoolNumber++;
257 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
260 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
261 std::pair<MCSymbol *, unsigned> &Entry =
262 StringPool.GetOrCreateValue(Str).getValue();
266 Entry.second = NextStringPoolNumber++;
267 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
271 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
272 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
275 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
276 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
277 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
279 ++NextAddrPoolNumber;
280 return P.first->second;
283 // Define a unique number for the abbreviation.
285 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
286 // Check the set for priors.
287 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
289 // If it's newly added.
290 if (InSet == &Abbrev) {
291 // Add to abbreviation list.
292 Abbreviations.push_back(&Abbrev);
294 // Assign the vector position + 1 as its number.
295 Abbrev.setNumber(Abbreviations.size());
297 // Assign existing abbreviation number.
298 Abbrev.setNumber(InSet->getNumber());
302 static bool isObjCClass(StringRef Name) {
303 return Name.startswith("+") || Name.startswith("-");
306 static bool hasObjCCategory(StringRef Name) {
307 if (!isObjCClass(Name))
310 return Name.find(") ") != StringRef::npos;
313 static void getObjCClassCategory(StringRef In, StringRef &Class,
314 StringRef &Category) {
315 if (!hasObjCCategory(In)) {
316 Class = In.slice(In.find('[') + 1, In.find(' '));
321 Class = In.slice(In.find('[') + 1, In.find('('));
322 Category = In.slice(In.find('[') + 1, In.find(' '));
326 static StringRef getObjCMethodName(StringRef In) {
327 return In.slice(In.find(' ') + 1, In.find(']'));
330 // Helper for sorting sections into a stable output order.
331 static bool SectionSort(const MCSection *A, const MCSection *B) {
332 std::string LA = (A ? A->getLabelBeginName() : "");
333 std::string LB = (B ? B->getLabelBeginName() : "");
337 // Add the various names to the Dwarf accelerator table names.
338 // TODO: Determine whether or not we should add names for programs
339 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
340 // is only slightly different than the lookup of non-standard ObjC names.
341 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
342 if (!SP.isDefinition())
344 TheU->addAccelName(SP.getName(), Die);
346 // If the linkage name is different than the name, go ahead and output
347 // that as well into the name table.
348 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
349 TheU->addAccelName(SP.getLinkageName(), Die);
351 // If this is an Objective-C selector name add it to the ObjC accelerator
353 if (isObjCClass(SP.getName())) {
354 StringRef Class, Category;
355 getObjCClassCategory(SP.getName(), Class, Category);
356 TheU->addAccelObjC(Class, Die);
358 TheU->addAccelObjC(Category, Die);
359 // Also add the base method name to the name table.
360 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
364 /// isSubprogramContext - Return true if Context is either a subprogram
365 /// or another context nested inside a subprogram.
366 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
369 DIDescriptor D(Context);
370 if (D.isSubprogram())
373 return isSubprogramContext(resolve(DIType(Context).getContext()));
377 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
378 // and DW_AT_high_pc attributes. If there are global variables in this
379 // scope then create and insert DIEs for these variables.
380 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
382 DIE *SPDie = SPCU->getDIE(SP);
384 assert(SPDie && "Unable to find subprogram DIE!");
386 // If we're updating an abstract DIE, then we will be adding the children and
387 // object pointer later on. But what we don't want to do is process the
388 // concrete DIE twice.
389 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
390 // Pick up abstract subprogram DIE.
392 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
393 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
395 DISubprogram SPDecl = SP.getFunctionDeclaration();
396 if (!SPDecl.isSubprogram()) {
397 // There is not any need to generate specification DIE for a function
398 // defined at compile unit level. If a function is defined inside another
399 // function then gdb prefers the definition at top level and but does not
400 // expect specification DIE in parent function. So avoid creating
401 // specification DIE for a function defined inside a function.
402 DIScope SPContext = resolve(SP.getContext());
403 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
404 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
405 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
408 DICompositeType SPTy = SP.getType();
409 DIArray Args = SPTy.getTypeArray();
410 uint16_t SPTag = SPTy.getTag();
411 if (SPTag == dwarf::DW_TAG_subroutine_type)
412 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
414 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
415 DIType ATy(Args.getElement(i));
416 SPCU->addType(Arg, ATy);
417 if (ATy.isArtificial())
418 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
419 if (ATy.isObjectPointer())
420 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
422 DIE *SPDeclDie = SPDie;
423 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
424 *SPCU->getUnitDie());
425 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
430 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
431 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
433 // Add this range to the list of ranges for the CU.
434 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
435 SPCU->addRange(llvm_move(Span));
437 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
438 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
439 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
441 // Add name to the name table, we do this here because we're guaranteed
442 // to have concrete versions of our DW_TAG_subprogram nodes.
443 addSubprogramNames(SPCU, SP, SPDie);
448 /// Check whether we should create a DIE for the given Scope, return true
449 /// if we don't create a DIE (the corresponding DIE is null).
450 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
451 if (Scope->isAbstractScope())
454 // We don't create a DIE if there is no Range.
455 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
459 if (Ranges.size() > 1)
462 // We don't create a DIE if we have a single Range and the end label
464 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
465 MCSymbol *End = getLabelAfterInsn(RI->second);
469 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
470 dwarf::Attribute A, const MCSymbol *L,
471 const MCSymbol *Sec) {
472 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
473 U->addSectionLabel(D, A, L);
475 U->addSectionDelta(D, A, L, Sec);
478 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
479 const SmallVectorImpl<InsnRange> &Range) {
480 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
481 // emitting it appropriately.
482 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
483 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
484 DwarfDebugRangeSectionSym);
486 RangeSpanList List(RangeSym);
487 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
490 RangeSpan Span(getLabelBeforeInsn(RI->first),
491 getLabelAfterInsn(RI->second));
492 List.addRange(llvm_move(Span));
495 // Add the range list to the set of ranges to be emitted.
496 TheCU->addRangeList(llvm_move(List));
499 // Construct new DW_TAG_lexical_block for this scope and attach
500 // DW_AT_low_pc/DW_AT_high_pc labels.
501 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
502 LexicalScope *Scope) {
503 if (isLexicalScopeDIENull(Scope))
506 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
507 if (Scope->isAbstractScope())
510 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
512 // If we have multiple ranges, emit them into the range section.
513 if (ScopeRanges.size() > 1) {
514 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
518 // Construct the address range for this DIE.
519 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
520 MCSymbol *Start = getLabelBeforeInsn(RI->first);
521 MCSymbol *End = getLabelAfterInsn(RI->second);
522 assert(End && "End label should not be null!");
524 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
525 assert(End->isDefined() && "Invalid end label for an inlined scope!");
527 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
528 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
533 // This scope represents inlined body of a function. Construct DIE to
534 // represent this concrete inlined copy of the function.
535 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
536 LexicalScope *Scope) {
537 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
538 assert(!ScopeRanges.empty() &&
539 "LexicalScope does not have instruction markers!");
541 if (!Scope->getScopeNode())
543 DIScope DS(Scope->getScopeNode());
544 DISubprogram InlinedSP = getDISubprogram(DS);
545 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
547 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
551 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
552 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
554 // If we have multiple ranges, emit them into the range section.
555 if (ScopeRanges.size() > 1)
556 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
558 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
559 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
560 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
562 if (StartLabel == 0 || EndLabel == 0)
563 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
565 assert(StartLabel->isDefined() &&
566 "Invalid starting label for an inlined scope!");
567 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
569 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
570 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
573 InlinedSubprogramDIEs.insert(OriginDIE);
575 // Add the call site information to the DIE.
576 DILocation DL(Scope->getInlinedAt());
577 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
578 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
579 TheCU->getUniqueID()));
580 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
582 // Add name to the name table, we do this here because we're guaranteed
583 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
584 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
589 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
591 SmallVectorImpl<DIE *> &Children) {
592 DIE *ObjectPointer = NULL;
594 // Collect arguments for current function.
595 if (LScopes.isCurrentFunctionScope(Scope))
596 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
597 if (DbgVariable *ArgDV = CurrentFnArguments[i])
599 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
600 Children.push_back(Arg);
601 if (ArgDV->isObjectPointer())
605 // Collect lexical scope children first.
606 const SmallVectorImpl<DbgVariable *> &Variables =
607 ScopeVariables.lookup(Scope);
608 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
609 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
610 Scope->isAbstractScope())) {
611 Children.push_back(Variable);
612 if (Variables[i]->isObjectPointer())
613 ObjectPointer = Variable;
615 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
616 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
617 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
618 Children.push_back(Nested);
619 return ObjectPointer;
622 // Construct a DIE for this scope.
623 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
624 LexicalScope *Scope) {
625 if (!Scope || !Scope->getScopeNode())
628 DIScope DS(Scope->getScopeNode());
630 SmallVector<DIE *, 8> Children;
631 DIE *ObjectPointer = NULL;
632 bool ChildrenCreated = false;
634 // We try to create the scope DIE first, then the children DIEs. This will
635 // avoid creating un-used children then removing them later when we find out
636 // the scope DIE is null.
637 DIE *ScopeDIE = NULL;
638 if (Scope->getInlinedAt())
639 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
640 else if (DS.isSubprogram()) {
641 ProcessedSPNodes.insert(DS);
642 if (Scope->isAbstractScope()) {
643 ScopeDIE = TheCU->getDIE(DS);
644 // Note down abstract DIE.
646 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
648 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
650 // Early exit when we know the scope DIE is going to be null.
651 if (isLexicalScopeDIENull(Scope))
654 // We create children here when we know the scope DIE is not going to be
655 // null and the children will be added to the scope DIE.
656 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
657 ChildrenCreated = true;
659 // There is no need to emit empty lexical block DIE.
660 std::pair<ImportedEntityMap::const_iterator,
661 ImportedEntityMap::const_iterator> Range =
663 ScopesWithImportedEntities.begin(),
664 ScopesWithImportedEntities.end(),
665 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
667 if (Children.empty() && Range.first == Range.second)
669 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
670 assert(ScopeDIE && "Scope DIE should not be null.");
671 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
673 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
677 assert(Children.empty() &&
678 "We create children only when the scope DIE is not null.");
681 if (!ChildrenCreated)
682 // We create children when the scope DIE is not null.
683 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
686 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
689 ScopeDIE->addChild(*I);
691 if (DS.isSubprogram() && ObjectPointer != NULL)
692 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
697 // Look up the source id with the given directory and source file names.
698 // If none currently exists, create a new id and insert it in the
699 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
701 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
703 // If we use .loc in assembly, we can't separate .file entries according to
704 // compile units. Thus all files will belong to the default compile unit.
706 // FIXME: add a better feature test than hasRawTextSupport. Even better,
707 // extend .file to support this.
708 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
711 // If FE did not provide a file name, then assume stdin.
712 if (FileName.empty())
713 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
715 // TODO: this might not belong here. See if we can factor this better.
716 if (DirName == CompilationDir)
719 // FileIDCUMap stores the current ID for the given compile unit.
720 unsigned SrcId = FileIDCUMap[CUID] + 1;
722 // We look up the CUID/file/dir by concatenating them with a zero byte.
723 SmallString<128> NamePair;
724 NamePair += utostr(CUID);
727 NamePair += '\0'; // Zero bytes are not allowed in paths.
728 NamePair += FileName;
730 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
731 if (Ent.getValue() != SrcId)
732 return Ent.getValue();
734 FileIDCUMap[CUID] = SrcId;
735 // Print out a .file directive to specify files for .loc directives.
736 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
741 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
742 if (!GenerateGnuPubSections)
745 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
746 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
747 DwarfGnuPubNamesSectionSym);
749 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
750 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
751 DwarfGnuPubTypesSectionSym);
754 // Create new DwarfCompileUnit for the given metadata node with tag
755 // DW_TAG_compile_unit.
756 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
757 StringRef FN = DIUnit.getFilename();
758 CompilationDir = DIUnit.getDirectory();
760 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
761 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
762 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
763 InfoHolder.addUnit(NewCU);
765 FileIDCUMap[NewCU->getUniqueID()] = 0;
766 // Call this to emit a .file directive if it wasn't emitted for the source
767 // file this CU comes from yet.
768 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
770 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
771 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
772 DIUnit.getLanguage());
773 NewCU->addString(Die, dwarf::DW_AT_name, FN);
775 // Define start line table label for each Compile Unit.
776 MCSymbol *LineTableStartSym =
777 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
778 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
779 NewCU->getUniqueID());
781 // Use a single line table if we are using .loc and generating assembly.
783 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
784 (NewCU->getUniqueID() == 0);
786 if (!useSplitDwarf()) {
787 // DW_AT_stmt_list is a offset of line number information for this
788 // compile unit in debug_line section. For split dwarf this is
789 // left in the skeleton CU and so not included.
790 // The line table entries are not always emitted in assembly, so it
791 // is not okay to use line_table_start here.
792 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
793 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
794 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
795 : LineTableStartSym);
796 else if (UseTheFirstCU)
797 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
799 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
800 DwarfLineSectionSym);
802 // If we're using split dwarf the compilation dir is going to be in the
803 // skeleton CU and so we don't need to duplicate it here.
804 if (!CompilationDir.empty())
805 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
807 addGnuPubAttributes(NewCU, Die);
810 if (DIUnit.isOptimized())
811 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
813 StringRef Flags = DIUnit.getFlags();
815 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
817 if (unsigned RVer = DIUnit.getRunTimeVersion())
818 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
819 dwarf::DW_FORM_data1, RVer);
824 if (useSplitDwarf()) {
825 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
826 DwarfInfoDWOSectionSym);
827 NewCU->setSkeleton(constructSkeletonCU(NewCU));
829 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
830 DwarfInfoSectionSym);
832 CUMap.insert(std::make_pair(DIUnit, NewCU));
833 CUDieMap.insert(std::make_pair(Die, NewCU));
837 // Construct subprogram DIE.
838 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
840 // FIXME: We should only call this routine once, however, during LTO if a
841 // program is defined in multiple CUs we could end up calling it out of
842 // beginModule as we walk the CUs.
844 DwarfCompileUnit *&CURef = SPMap[N];
850 if (!SP.isDefinition())
851 // This is a method declaration which will be handled while constructing
855 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
857 // Expose as a global name.
858 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
861 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
863 DIImportedEntity Module(N);
864 if (!Module.Verify())
866 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
867 constructImportedEntityDIE(TheCU, Module, D);
870 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
871 const MDNode *N, DIE *Context) {
872 DIImportedEntity Module(N);
873 if (!Module.Verify())
875 return constructImportedEntityDIE(TheCU, Module, Context);
878 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
879 const DIImportedEntity &Module,
881 assert(Module.Verify() &&
882 "Use one of the MDNode * overloads to handle invalid metadata");
883 assert(Context && "Should always have a context for an imported_module");
884 DIE *IMDie = new DIE(Module.getTag());
885 TheCU->insertDIE(Module, IMDie);
887 DIDescriptor Entity = Module.getEntity();
888 if (Entity.isNameSpace())
889 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
890 else if (Entity.isSubprogram())
891 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
892 else if (Entity.isType())
893 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
895 EntityDie = TheCU->getDIE(Entity);
896 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
897 Module.getContext().getDirectory(),
898 TheCU->getUniqueID());
899 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
900 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
901 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
902 StringRef Name = Module.getName();
904 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
905 Context->addChild(IMDie);
908 // Emit all Dwarf sections that should come prior to the content. Create
909 // global DIEs and emit initial debug info sections. This is invoked by
910 // the target AsmPrinter.
911 void DwarfDebug::beginModule() {
912 if (DisableDebugInfoPrinting)
915 const Module *M = MMI->getModule();
917 // If module has named metadata anchors then use them, otherwise scan the
918 // module using debug info finder to collect debug info.
919 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
922 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
924 // Emit initial sections so we can reference labels later.
927 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
928 DICompileUnit CUNode(CU_Nodes->getOperand(i));
929 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
930 DIArray ImportedEntities = CUNode.getImportedEntities();
931 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
932 ScopesWithImportedEntities.push_back(std::make_pair(
933 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
934 ImportedEntities.getElement(i)));
935 std::sort(ScopesWithImportedEntities.begin(),
936 ScopesWithImportedEntities.end(), less_first());
937 DIArray GVs = CUNode.getGlobalVariables();
938 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
939 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
940 DIArray SPs = CUNode.getSubprograms();
941 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
942 constructSubprogramDIE(CU, SPs.getElement(i));
943 DIArray EnumTypes = CUNode.getEnumTypes();
944 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
945 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
946 DIArray RetainedTypes = CUNode.getRetainedTypes();
947 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
948 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
949 // Emit imported_modules last so that the relevant context is already
951 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
952 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
955 // Tell MMI that we have debug info.
956 MMI->setDebugInfoAvailability(true);
958 // Prime section data.
959 SectionMap[Asm->getObjFileLowering().getTextSection()];
962 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
963 void DwarfDebug::computeInlinedDIEs() {
964 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
965 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
966 AE = InlinedSubprogramDIEs.end();
969 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
971 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
972 AE = AbstractSPDies.end();
974 DIE *ISP = AI->second;
975 if (InlinedSubprogramDIEs.count(ISP))
977 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
981 // Collect info for variables that were optimized out.
982 void DwarfDebug::collectDeadVariables() {
983 const Module *M = MMI->getModule();
985 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
986 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
987 DICompileUnit TheCU(CU_Nodes->getOperand(i));
988 DIArray Subprograms = TheCU.getSubprograms();
989 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
990 DISubprogram SP(Subprograms.getElement(i));
991 if (ProcessedSPNodes.count(SP) != 0)
993 if (!SP.isSubprogram())
995 if (!SP.isDefinition())
997 DIArray Variables = SP.getVariables();
998 if (Variables.getNumElements() == 0)
1001 // Construct subprogram DIE and add variables DIEs.
1002 DwarfCompileUnit *SPCU =
1003 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1004 assert(SPCU && "Unable to find Compile Unit!");
1005 // FIXME: See the comment in constructSubprogramDIE about duplicate
1007 constructSubprogramDIE(SPCU, SP);
1008 DIE *SPDIE = SPCU->getDIE(SP);
1009 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1010 DIVariable DV(Variables.getElement(vi));
1011 if (!DV.isVariable())
1013 DbgVariable NewVar(DV, NULL, this);
1014 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1015 SPDIE->addChild(VariableDIE);
1022 // Type Signature [7.27] and ODR Hash code.
1024 /// \brief Grabs the string in whichever attribute is passed in and returns
1025 /// a reference to it. Returns "" if the attribute doesn't exist.
1026 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1027 DIEValue *V = Die->findAttribute(Attr);
1029 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1030 return S->getString();
1032 return StringRef("");
1035 /// Return true if the current DIE is contained within an anonymous namespace.
1036 static bool isContainedInAnonNamespace(DIE *Die) {
1037 DIE *Parent = Die->getParent();
1040 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1041 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1043 Parent = Parent->getParent();
1049 /// Test if the current CU language is C++ and that we have
1050 /// a named type that is not contained in an anonymous namespace.
1051 static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
1052 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1053 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1054 !isContainedInAnonNamespace(Die);
1057 void DwarfDebug::finalizeModuleInfo() {
1058 // Collect info for variables that were optimized out.
1059 collectDeadVariables();
1061 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1062 computeInlinedDIEs();
1064 // Handle anything that needs to be done on a per-unit basis after
1065 // all other generation.
1066 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1067 E = getUnits().end();
1069 DwarfUnit *TheU = *I;
1070 // Emit DW_AT_containing_type attribute to connect types with their
1071 // vtable holding type.
1072 TheU->constructContainingTypeDIEs();
1074 // Add CU specific attributes if we need to add any.
1075 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1076 // If we're splitting the dwarf out now that we've got the entire
1077 // CU then add the dwo id to it.
1078 DwarfCompileUnit *SkCU =
1079 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1080 if (useSplitDwarf()) {
1081 // This should be a unique identifier when we want to build .dwp files.
1083 if (GenerateCUHash) {
1085 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1087 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1088 dwarf::DW_FORM_data8, ID);
1089 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1090 dwarf::DW_FORM_data8, ID);
1093 // If we've requested ranges and have them emit a DW_AT_ranges attribute
1094 // on the unit that will remain in the .o file, otherwise add a
1096 // FIXME: Also add a high pc if we can.
1097 // FIXME: We should use ranges if we have multiple compile units.
1098 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1099 if (DwarfCURanges && TheU->getRanges().size())
1100 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1101 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1102 DwarfDebugRangeSectionSym);
1104 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1109 // Compute DIE offsets and sizes.
1110 InfoHolder.computeSizeAndOffsets();
1111 if (useSplitDwarf())
1112 SkeletonHolder.computeSizeAndOffsets();
1115 void DwarfDebug::endSections() {
1116 // Filter labels by section.
1117 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1118 const SymbolCU &SCU = ArangeLabels[n];
1119 if (SCU.Sym->isInSection()) {
1120 // Make a note of this symbol and it's section.
1121 const MCSection *Section = &SCU.Sym->getSection();
1122 if (!Section->getKind().isMetadata())
1123 SectionMap[Section].push_back(SCU);
1125 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1126 // appear in the output. This sucks as we rely on sections to build
1127 // arange spans. We can do it without, but it's icky.
1128 SectionMap[NULL].push_back(SCU);
1132 // Build a list of sections used.
1133 std::vector<const MCSection *> Sections;
1134 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1136 const MCSection *Section = it->first;
1137 Sections.push_back(Section);
1140 // Sort the sections into order.
1141 // This is only done to ensure consistent output order across different runs.
1142 std::sort(Sections.begin(), Sections.end(), SectionSort);
1144 // Add terminating symbols for each section.
1145 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1146 const MCSection *Section = Sections[ID];
1147 MCSymbol *Sym = NULL;
1150 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1151 // if we know the section name up-front. For user-created sections, the
1153 // label may not be valid to use as a label. (section names can use a
1155 // set of characters on some systems)
1156 Sym = Asm->GetTempSymbol("debug_end", ID);
1157 Asm->OutStreamer.SwitchSection(Section);
1158 Asm->OutStreamer.EmitLabel(Sym);
1161 // Insert a final terminator.
1162 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1166 // Emit all Dwarf sections that should come after the content.
1167 void DwarfDebug::endModule() {
1174 // End any existing sections.
1175 // TODO: Does this need to happen?
1178 // Finalize the debug info for the module.
1179 finalizeModuleInfo();
1183 // Emit all the DIEs into a debug info section.
1186 // Corresponding abbreviations into a abbrev section.
1187 emitAbbreviations();
1189 // Emit info into a debug loc section.
1192 // Emit info into a debug aranges section.
1195 // Emit info into a debug ranges section.
1198 if (useSplitDwarf()) {
1201 emitDebugAbbrevDWO();
1202 // Emit DWO addresses.
1203 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1206 // Emit info into the dwarf accelerator table sections.
1207 if (useDwarfAccelTables()) {
1210 emitAccelNamespaces();
1214 // Emit the pubnames and pubtypes sections if requested.
1215 if (HasDwarfPubSections) {
1216 emitDebugPubNames(GenerateGnuPubSections);
1217 emitDebugPubTypes(GenerateGnuPubSections);
1223 // Reset these for the next Module if we have one.
1227 // Find abstract variable, if any, associated with Var.
1228 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1229 DebugLoc ScopeLoc) {
1230 LLVMContext &Ctx = DV->getContext();
1231 // More then one inlined variable corresponds to one abstract variable.
1232 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1233 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1235 return AbsDbgVariable;
1237 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1241 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1242 addScopeVariable(Scope, AbsDbgVariable);
1243 AbstractVariables[Var] = AbsDbgVariable;
1244 return AbsDbgVariable;
1247 // If Var is a current function argument then add it to CurrentFnArguments list.
1248 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1249 if (!LScopes.isCurrentFunctionScope(Scope))
1251 DIVariable DV = Var->getVariable();
1252 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1254 unsigned ArgNo = DV.getArgNumber();
1258 size_t Size = CurrentFnArguments.size();
1260 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1261 // llvm::Function argument size is not good indicator of how many
1262 // arguments does the function have at source level.
1264 CurrentFnArguments.resize(ArgNo * 2);
1265 CurrentFnArguments[ArgNo - 1] = Var;
1269 // Collect variable information from side table maintained by MMI.
1270 void DwarfDebug::collectVariableInfoFromMMITable(
1271 SmallPtrSet<const MDNode *, 16> &Processed) {
1272 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1273 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1276 const MDNode *Var = VI->first;
1279 Processed.insert(Var);
1281 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1283 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1285 // If variable scope is not found then skip this variable.
1289 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1290 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1291 RegVar->setFrameIndex(VP.first);
1292 if (!addCurrentFnArgument(RegVar, Scope))
1293 addScopeVariable(Scope, RegVar);
1295 AbsDbgVariable->setFrameIndex(VP.first);
1299 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1301 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1302 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1303 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1304 MI->getOperand(0).getReg() &&
1305 (MI->getOperand(1).isImm() ||
1306 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1309 // Get .debug_loc entry for the instruction range starting at MI.
1310 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1311 const MCSymbol *FLabel,
1312 const MCSymbol *SLabel,
1313 const MachineInstr *MI) {
1314 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1316 assert(MI->getNumOperands() == 3);
1317 if (MI->getOperand(0).isReg()) {
1318 MachineLocation MLoc;
1319 // If the second operand is an immediate, this is a
1320 // register-indirect address.
1321 if (!MI->getOperand(1).isImm())
1322 MLoc.set(MI->getOperand(0).getReg());
1324 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1325 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1327 if (MI->getOperand(0).isImm())
1328 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1329 if (MI->getOperand(0).isFPImm())
1330 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1331 if (MI->getOperand(0).isCImm())
1332 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1334 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1337 // Find variables for each lexical scope.
1339 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1341 // Grab the variable info that was squirreled away in the MMI side-table.
1342 collectVariableInfoFromMMITable(Processed);
1344 for (SmallVectorImpl<const MDNode *>::const_iterator
1345 UVI = UserVariables.begin(),
1346 UVE = UserVariables.end();
1347 UVI != UVE; ++UVI) {
1348 const MDNode *Var = *UVI;
1349 if (Processed.count(Var))
1352 // History contains relevant DBG_VALUE instructions for Var and instructions
1354 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1355 if (History.empty())
1357 const MachineInstr *MInsn = History.front();
1360 LexicalScope *Scope = NULL;
1361 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1362 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1363 Scope = LScopes.getCurrentFunctionScope();
1364 else if (MDNode *IA = DV.getInlinedAt())
1365 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1367 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1368 // If variable scope is not found then skip this variable.
1372 Processed.insert(DV);
1373 assert(MInsn->isDebugValue() && "History must begin with debug value");
1374 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1375 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1376 if (!addCurrentFnArgument(RegVar, Scope))
1377 addScopeVariable(Scope, RegVar);
1379 AbsVar->setMInsn(MInsn);
1381 // Simplify ranges that are fully coalesced.
1382 if (History.size() <= 1 ||
1383 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1384 RegVar->setMInsn(MInsn);
1388 // Handle multiple DBG_VALUE instructions describing one variable.
1389 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1391 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1392 HI = History.begin(),
1395 const MachineInstr *Begin = *HI;
1396 assert(Begin->isDebugValue() && "Invalid History entry");
1398 // Check if DBG_VALUE is truncating a range.
1399 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1400 !Begin->getOperand(0).getReg())
1403 // Compute the range for a register location.
1404 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1405 const MCSymbol *SLabel = 0;
1408 // If Begin is the last instruction in History then its value is valid
1409 // until the end of the function.
1410 SLabel = FunctionEndSym;
1412 const MachineInstr *End = HI[1];
1413 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1414 << "\t" << *Begin << "\t" << *End << "\n");
1415 if (End->isDebugValue())
1416 SLabel = getLabelBeforeInsn(End);
1418 // End is a normal instruction clobbering the range.
1419 SLabel = getLabelAfterInsn(End);
1420 assert(SLabel && "Forgot label after clobber instruction");
1425 // The value is valid until the next DBG_VALUE or clobber.
1426 DotDebugLocEntries.push_back(
1427 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1429 DotDebugLocEntries.push_back(DotDebugLocEntry());
1432 // Collect info for variables that were optimized out.
1433 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1434 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1435 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1436 DIVariable DV(Variables.getElement(i));
1437 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1439 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1440 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1444 // Return Label preceding the instruction.
1445 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1446 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1447 assert(Label && "Didn't insert label before instruction");
1451 // Return Label immediately following the instruction.
1452 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1453 return LabelsAfterInsn.lookup(MI);
1456 // Process beginning of an instruction.
1457 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1460 // Check if source location changes, but ignore DBG_VALUE locations.
1461 if (!MI->isDebugValue()) {
1462 DebugLoc DL = MI->getDebugLoc();
1463 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1466 if (DL == PrologEndLoc) {
1467 Flags |= DWARF2_FLAG_PROLOGUE_END;
1468 PrologEndLoc = DebugLoc();
1470 if (PrologEndLoc.isUnknown())
1471 Flags |= DWARF2_FLAG_IS_STMT;
1473 if (!DL.isUnknown()) {
1474 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1475 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1477 recordSourceLine(0, 0, 0, 0);
1481 // Insert labels where requested.
1482 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1483 LabelsBeforeInsn.find(MI);
1486 if (I == LabelsBeforeInsn.end())
1489 // Label already assigned.
1494 PrevLabel = MMI->getContext().CreateTempSymbol();
1495 Asm->OutStreamer.EmitLabel(PrevLabel);
1497 I->second = PrevLabel;
1500 // Process end of an instruction.
1501 void DwarfDebug::endInstruction() {
1503 // Don't create a new label after DBG_VALUE instructions.
1504 // They don't generate code.
1505 if (!CurMI->isDebugValue())
1508 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1509 LabelsAfterInsn.find(CurMI);
1513 if (I == LabelsAfterInsn.end())
1516 // Label already assigned.
1520 // We need a label after this instruction.
1522 PrevLabel = MMI->getContext().CreateTempSymbol();
1523 Asm->OutStreamer.EmitLabel(PrevLabel);
1525 I->second = PrevLabel;
1528 // Each LexicalScope has first instruction and last instruction to mark
1529 // beginning and end of a scope respectively. Create an inverse map that list
1530 // scopes starts (and ends) with an instruction. One instruction may start (or
1531 // end) multiple scopes. Ignore scopes that are not reachable.
1532 void DwarfDebug::identifyScopeMarkers() {
1533 SmallVector<LexicalScope *, 4> WorkList;
1534 WorkList.push_back(LScopes.getCurrentFunctionScope());
1535 while (!WorkList.empty()) {
1536 LexicalScope *S = WorkList.pop_back_val();
1538 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1539 if (!Children.empty())
1540 for (SmallVectorImpl<LexicalScope *>::const_iterator
1541 SI = Children.begin(),
1542 SE = Children.end();
1544 WorkList.push_back(*SI);
1546 if (S->isAbstractScope())
1549 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1552 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1555 assert(RI->first && "InsnRange does not have first instruction!");
1556 assert(RI->second && "InsnRange does not have second instruction!");
1557 requestLabelBeforeInsn(RI->first);
1558 requestLabelAfterInsn(RI->second);
1563 // Get MDNode for DebugLoc's scope.
1564 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1565 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1566 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1567 return DL.getScope(Ctx);
1570 // Walk up the scope chain of given debug loc and find line number info
1571 // for the function.
1572 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1573 const MDNode *Scope = getScopeNode(DL, Ctx);
1574 DISubprogram SP = getDISubprogram(Scope);
1575 if (SP.isSubprogram()) {
1576 // Check for number of operands since the compatibility is
1578 if (SP->getNumOperands() > 19)
1579 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1581 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1587 // Gather pre-function debug information. Assumes being called immediately
1588 // after the function entry point has been emitted.
1589 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1592 // If there's no debug info for the function we're not going to do anything.
1593 if (!MMI->hasDebugInfo())
1596 // Grab the lexical scopes for the function, if we don't have any of those
1597 // then we're not going to be able to do anything.
1598 LScopes.initialize(*MF);
1599 if (LScopes.empty())
1602 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1604 // Make sure that each lexical scope will have a begin/end label.
1605 identifyScopeMarkers();
1607 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1608 // belongs to so that we add to the correct per-cu line table in the
1610 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1611 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1612 assert(TheCU && "Unable to find compile unit!");
1613 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1614 // Use a single line table if we are using .loc and generating assembly.
1615 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1617 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1619 // Emit a label for the function so that we have a beginning address.
1620 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1621 // Assumes in correct section after the entry point.
1622 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1624 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1625 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1626 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1628 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1630 bool AtBlockEntry = true;
1631 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1633 const MachineInstr *MI = II;
1635 if (MI->isDebugValue()) {
1636 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1638 // Keep track of user variables.
1640 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1642 // Variable is in a register, we need to check for clobbers.
1643 if (isDbgValueInDefinedReg(MI))
1644 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1646 // Check the history of this variable.
1647 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1648 if (History.empty()) {
1649 UserVariables.push_back(Var);
1650 // The first mention of a function argument gets the FunctionBeginSym
1651 // label, so arguments are visible when breaking at function entry.
1653 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1654 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1655 LabelsBeforeInsn[MI] = FunctionBeginSym;
1657 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1658 const MachineInstr *Prev = History.back();
1659 if (Prev->isDebugValue()) {
1660 // Coalesce identical entries at the end of History.
1661 if (History.size() >= 2 &&
1662 Prev->isIdenticalTo(History[History.size() - 2])) {
1663 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1664 << "\t" << *Prev << "\t"
1665 << *History[History.size() - 2] << "\n");
1669 // Terminate old register assignments that don't reach MI;
1670 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1671 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1672 isDbgValueInDefinedReg(Prev)) {
1673 // Previous register assignment needs to terminate at the end of
1675 MachineBasicBlock::const_iterator LastMI =
1676 PrevMBB->getLastNonDebugInstr();
1677 if (LastMI == PrevMBB->end()) {
1678 // Drop DBG_VALUE for empty range.
1679 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1680 << "\t" << *Prev << "\n");
1682 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1683 // Terminate after LastMI.
1684 History.push_back(LastMI);
1688 History.push_back(MI);
1690 // Not a DBG_VALUE instruction.
1692 AtBlockEntry = false;
1694 // First known non-DBG_VALUE and non-frame setup location marks
1695 // the beginning of the function body.
1696 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1697 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1698 PrologEndLoc = MI->getDebugLoc();
1700 // Check if the instruction clobbers any registers with debug vars.
1701 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1702 MOE = MI->operands_end();
1703 MOI != MOE; ++MOI) {
1704 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1706 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1709 const MDNode *Var = LiveUserVar[Reg];
1712 // Reg is now clobbered.
1713 LiveUserVar[Reg] = 0;
1715 // Was MD last defined by a DBG_VALUE referring to Reg?
1716 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1717 if (HistI == DbgValues.end())
1719 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1720 if (History.empty())
1722 const MachineInstr *Prev = History.back();
1723 // Sanity-check: Register assignments are terminated at the end of
1725 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1727 // Is the variable still in Reg?
1728 if (!isDbgValueInDefinedReg(Prev) ||
1729 Prev->getOperand(0).getReg() != Reg)
1731 // Var is clobbered. Make sure the next instruction gets a label.
1732 History.push_back(MI);
1739 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1741 SmallVectorImpl<const MachineInstr *> &History = I->second;
1742 if (History.empty())
1745 // Make sure the final register assignments are terminated.
1746 const MachineInstr *Prev = History.back();
1747 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1748 const MachineBasicBlock *PrevMBB = Prev->getParent();
1749 MachineBasicBlock::const_iterator LastMI =
1750 PrevMBB->getLastNonDebugInstr();
1751 if (LastMI == PrevMBB->end())
1752 // Drop DBG_VALUE for empty range.
1754 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1755 // Terminate after LastMI.
1756 History.push_back(LastMI);
1759 // Request labels for the full history.
1760 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1761 const MachineInstr *MI = History[i];
1762 if (MI->isDebugValue())
1763 requestLabelBeforeInsn(MI);
1765 requestLabelAfterInsn(MI);
1769 PrevInstLoc = DebugLoc();
1770 PrevLabel = FunctionBeginSym;
1772 // Record beginning of function.
1773 if (!PrologEndLoc.isUnknown()) {
1774 DebugLoc FnStartDL =
1775 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1777 FnStartDL.getLine(), FnStartDL.getCol(),
1778 FnStartDL.getScope(MF->getFunction()->getContext()),
1779 // We'd like to list the prologue as "not statements" but GDB behaves
1780 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1781 DWARF2_FLAG_IS_STMT);
1785 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1786 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1787 DIVariable DV = Var->getVariable();
1788 // Variables with positive arg numbers are parameters.
1789 if (unsigned ArgNum = DV.getArgNumber()) {
1790 // Keep all parameters in order at the start of the variable list to ensure
1791 // function types are correct (no out-of-order parameters)
1793 // This could be improved by only doing it for optimized builds (unoptimized
1794 // builds have the right order to begin with), searching from the back (this
1795 // would catch the unoptimized case quickly), or doing a binary search
1796 // rather than linear search.
1797 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1798 while (I != Vars.end()) {
1799 unsigned CurNum = (*I)->getVariable().getArgNumber();
1800 // A local (non-parameter) variable has been found, insert immediately
1804 // A later indexed parameter has been found, insert immediately before it.
1805 if (CurNum > ArgNum)
1809 Vars.insert(I, Var);
1813 Vars.push_back(Var);
1816 // Gather and emit post-function debug information.
1817 void DwarfDebug::endFunction(const MachineFunction *MF) {
1818 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1819 // though the beginFunction may not be called at all.
1820 // We should handle both cases.
1824 assert(CurFn == MF);
1827 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1832 // Define end label for subprogram.
1833 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1834 // Assumes in correct section after the entry point.
1835 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1836 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1837 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1839 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1840 collectVariableInfo(ProcessedVars);
1842 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1843 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1844 assert(TheCU && "Unable to find compile unit!");
1846 // Construct abstract scopes.
1847 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1848 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1849 LexicalScope *AScope = AList[i];
1850 DISubprogram SP(AScope->getScopeNode());
1851 if (SP.isSubprogram()) {
1852 // Collect info for variables that were optimized out.
1853 DIArray Variables = SP.getVariables();
1854 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1855 DIVariable DV(Variables.getElement(i));
1856 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1858 // Check that DbgVariable for DV wasn't created earlier, when
1859 // findAbstractVariable() was called for inlined instance of DV.
1860 LLVMContext &Ctx = DV->getContext();
1861 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1862 if (AbstractVariables.lookup(CleanDV))
1864 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1865 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1868 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1869 constructScopeDIE(TheCU, AScope);
1872 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1874 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1875 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1878 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1879 E = ScopeVariables.end();
1881 DeleteContainerPointers(I->second);
1882 ScopeVariables.clear();
1883 DeleteContainerPointers(CurrentFnArguments);
1884 UserVariables.clear();
1886 AbstractVariables.clear();
1887 LabelsBeforeInsn.clear();
1888 LabelsAfterInsn.clear();
1893 // Register a source line with debug info. Returns the unique label that was
1894 // emitted and which provides correspondence to the source line list.
1895 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1901 DIDescriptor Scope(S);
1903 if (Scope.isCompileUnit()) {
1904 DICompileUnit CU(S);
1905 Fn = CU.getFilename();
1906 Dir = CU.getDirectory();
1907 } else if (Scope.isFile()) {
1909 Fn = F.getFilename();
1910 Dir = F.getDirectory();
1911 } else if (Scope.isSubprogram()) {
1913 Fn = SP.getFilename();
1914 Dir = SP.getDirectory();
1915 } else if (Scope.isLexicalBlockFile()) {
1916 DILexicalBlockFile DBF(S);
1917 Fn = DBF.getFilename();
1918 Dir = DBF.getDirectory();
1919 } else if (Scope.isLexicalBlock()) {
1920 DILexicalBlock DB(S);
1921 Fn = DB.getFilename();
1922 Dir = DB.getDirectory();
1924 llvm_unreachable("Unexpected scope info");
1926 Src = getOrCreateSourceID(
1927 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1929 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1932 //===----------------------------------------------------------------------===//
1934 //===----------------------------------------------------------------------===//
1936 // Compute the size and offset of a DIE. The offset is relative to start of the
1937 // CU. It returns the offset after laying out the DIE.
1938 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1939 // Get the children.
1940 const std::vector<DIE *> &Children = Die->getChildren();
1942 // Record the abbreviation.
1943 assignAbbrevNumber(Die->getAbbrev());
1945 // Get the abbreviation for this DIE.
1946 const DIEAbbrev &Abbrev = Die->getAbbrev();
1949 Die->setOffset(Offset);
1951 // Start the size with the size of abbreviation code.
1952 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1954 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1955 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1957 // Size the DIE attribute values.
1958 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1959 // Size attribute value.
1960 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1962 // Size the DIE children if any.
1963 if (!Children.empty()) {
1964 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1965 "Children flag not set");
1967 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1968 Offset = computeSizeAndOffset(Children[j], Offset);
1970 // End of children marker.
1971 Offset += sizeof(int8_t);
1974 Die->setSize(Offset - Die->getOffset());
1978 // Compute the size and offset for each DIE.
1979 void DwarfFile::computeSizeAndOffsets() {
1980 // Offset from the first CU in the debug info section is 0 initially.
1981 unsigned SecOffset = 0;
1983 // Iterate over each compile unit and set the size and offsets for each
1984 // DIE within each compile unit. All offsets are CU relative.
1985 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1988 (*I)->setDebugInfoOffset(SecOffset);
1990 // CU-relative offset is reset to 0 here.
1991 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1992 (*I)->getHeaderSize(); // Unit-specific headers
1994 // EndOffset here is CU-relative, after laying out
1995 // all of the CU DIE.
1996 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1997 SecOffset += EndOffset;
2001 // Emit initial Dwarf sections with a label at the start of each one.
2002 void DwarfDebug::emitSectionLabels() {
2003 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2005 // Dwarf sections base addresses.
2006 DwarfInfoSectionSym =
2007 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2008 if (useSplitDwarf())
2009 DwarfInfoDWOSectionSym =
2010 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
2011 DwarfAbbrevSectionSym =
2012 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2013 if (useSplitDwarf())
2014 DwarfAbbrevDWOSectionSym = emitSectionSym(
2015 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
2016 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2018 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2019 emitSectionSym(Asm, MacroInfo);
2021 DwarfLineSectionSym =
2022 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2023 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2024 if (GenerateGnuPubSections) {
2025 DwarfGnuPubNamesSectionSym =
2026 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2027 DwarfGnuPubTypesSectionSym =
2028 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2029 } else if (HasDwarfPubSections) {
2030 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2031 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2034 DwarfStrSectionSym =
2035 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2036 if (useSplitDwarf()) {
2037 DwarfStrDWOSectionSym =
2038 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2039 DwarfAddrSectionSym =
2040 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2042 DwarfDebugRangeSectionSym =
2043 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2045 DwarfDebugLocSectionSym =
2046 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2049 // Recursively emits a debug information entry.
2050 void DwarfDebug::emitDIE(DIE *Die) {
2051 // Get the abbreviation for this DIE.
2052 const DIEAbbrev &Abbrev = Die->getAbbrev();
2054 // Emit the code (index) for the abbreviation.
2055 if (Asm->isVerbose())
2056 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2057 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2058 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2059 dwarf::TagString(Abbrev.getTag()));
2060 Asm->EmitULEB128(Abbrev.getNumber());
2062 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2063 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2065 // Emit the DIE attribute values.
2066 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2067 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2068 dwarf::Form Form = AbbrevData[i].getForm();
2069 assert(Form && "Too many attributes for DIE (check abbreviation)");
2071 if (Asm->isVerbose())
2072 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2075 case dwarf::DW_AT_abstract_origin:
2076 case dwarf::DW_AT_type:
2077 case dwarf::DW_AT_friend:
2078 case dwarf::DW_AT_specification:
2079 case dwarf::DW_AT_import:
2080 case dwarf::DW_AT_containing_type: {
2081 DIEEntry *E = cast<DIEEntry>(Values[i]);
2082 DIE *Origin = E->getEntry();
2083 unsigned Addr = Origin->getOffset();
2084 if (Form == dwarf::DW_FORM_ref_addr) {
2085 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2086 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2087 // section. Origin->getOffset() returns the offset from start of the
2089 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2090 assert(CU && "CUDie should belong to a CU.");
2091 Addr += CU->getDebugInfoOffset();
2092 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2093 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2094 DIEEntry::getRefAddrSize(Asm));
2096 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2097 CU->getSectionSym(),
2098 DIEEntry::getRefAddrSize(Asm));
2100 // Make sure Origin belong to the same CU.
2101 assert(Die->getUnit() == Origin->getUnit() &&
2102 "The referenced DIE should belong to the same CU in ref4");
2103 Asm->EmitInt32(Addr);
2107 case dwarf::DW_AT_location: {
2108 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2109 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2110 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2112 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2114 Values[i]->EmitValue(Asm, Form);
2118 case dwarf::DW_AT_accessibility: {
2119 if (Asm->isVerbose()) {
2120 DIEInteger *V = cast<DIEInteger>(Values[i]);
2121 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2123 Values[i]->EmitValue(Asm, Form);
2127 // Emit an attribute using the defined form.
2128 Values[i]->EmitValue(Asm, Form);
2133 // Emit the DIE children if any.
2134 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2135 const std::vector<DIE *> &Children = Die->getChildren();
2137 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2138 emitDIE(Children[j]);
2140 Asm->OutStreamer.AddComment("End Of Children Mark");
2145 // Emit the various dwarf units to the unit section USection with
2146 // the abbreviations going into ASection.
2147 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2148 const MCSymbol *ASectionSym) {
2149 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2151 DwarfUnit *TheU = *I;
2152 DIE *Die = TheU->getUnitDie();
2153 const MCSection *USection = TheU->getSection();
2154 Asm->OutStreamer.SwitchSection(USection);
2156 // Emit the compile units header.
2157 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2159 // Emit size of content not including length itself
2160 Asm->OutStreamer.AddComment("Length of Unit");
2161 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2163 TheU->emitHeader(ASection, ASectionSym);
2166 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2170 // Emit the debug info section.
2171 void DwarfDebug::emitDebugInfo() {
2172 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2174 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2175 DwarfAbbrevSectionSym);
2178 // Emit the abbreviation section.
2179 void DwarfDebug::emitAbbreviations() {
2180 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2182 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2185 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2186 // Check to see if it is worth the effort.
2187 if (!Abbreviations.empty()) {
2188 // Start the debug abbrev section.
2189 Asm->OutStreamer.SwitchSection(Section);
2191 // For each abbrevation.
2192 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2193 // Get abbreviation data
2194 const DIEAbbrev *Abbrev = Abbreviations[i];
2196 // Emit the abbrevations code (base 1 index.)
2197 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2199 // Emit the abbreviations data.
2203 // Mark end of abbreviations.
2204 Asm->EmitULEB128(0, "EOM(3)");
2208 // Emit the last address of the section and the end of the line matrix.
2209 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2210 // Define last address of section.
2211 Asm->OutStreamer.AddComment("Extended Op");
2214 Asm->OutStreamer.AddComment("Op size");
2215 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2216 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2217 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2219 Asm->OutStreamer.AddComment("Section end label");
2221 Asm->OutStreamer.EmitSymbolValue(
2222 Asm->GetTempSymbol("section_end", SectionEnd),
2223 Asm->getDataLayout().getPointerSize());
2225 // Mark end of matrix.
2226 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2232 // Emit visible names into a hashed accelerator table section.
2233 void DwarfDebug::emitAccelNames() {
2235 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2236 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2237 E = getUnits().end();
2239 DwarfUnit *TheU = *I;
2240 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2241 for (StringMap<std::vector<const DIE *> >::const_iterator
2245 StringRef Name = GI->getKey();
2246 const std::vector<const DIE *> &Entities = GI->second;
2247 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2248 DE = Entities.end();
2250 AT.AddName(Name, *DI);
2254 AT.FinalizeTable(Asm, "Names");
2255 Asm->OutStreamer.SwitchSection(
2256 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2257 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2258 Asm->OutStreamer.EmitLabel(SectionBegin);
2260 // Emit the full data.
2261 AT.Emit(Asm, SectionBegin, &InfoHolder);
2264 // Emit objective C classes and categories into a hashed accelerator table
2266 void DwarfDebug::emitAccelObjC() {
2268 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2269 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2270 E = getUnits().end();
2272 DwarfUnit *TheU = *I;
2273 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2274 for (StringMap<std::vector<const DIE *> >::const_iterator
2278 StringRef Name = GI->getKey();
2279 const std::vector<const DIE *> &Entities = GI->second;
2280 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2281 DE = Entities.end();
2283 AT.AddName(Name, *DI);
2287 AT.FinalizeTable(Asm, "ObjC");
2288 Asm->OutStreamer.SwitchSection(
2289 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2290 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2291 Asm->OutStreamer.EmitLabel(SectionBegin);
2293 // Emit the full data.
2294 AT.Emit(Asm, SectionBegin, &InfoHolder);
2297 // Emit namespace dies into a hashed accelerator table.
2298 void DwarfDebug::emitAccelNamespaces() {
2300 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2301 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2302 E = getUnits().end();
2304 DwarfUnit *TheU = *I;
2305 const StringMap<std::vector<const DIE *> > &Names =
2306 TheU->getAccelNamespace();
2307 for (StringMap<std::vector<const DIE *> >::const_iterator
2311 StringRef Name = GI->getKey();
2312 const std::vector<const DIE *> &Entities = GI->second;
2313 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2314 DE = Entities.end();
2316 AT.AddName(Name, *DI);
2320 AT.FinalizeTable(Asm, "namespac");
2321 Asm->OutStreamer.SwitchSection(
2322 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2323 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2324 Asm->OutStreamer.EmitLabel(SectionBegin);
2326 // Emit the full data.
2327 AT.Emit(Asm, SectionBegin, &InfoHolder);
2330 // Emit type dies into a hashed accelerator table.
2331 void DwarfDebug::emitAccelTypes() {
2332 std::vector<DwarfAccelTable::Atom> Atoms;
2334 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2336 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2338 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2339 DwarfAccelTable AT(Atoms);
2340 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2341 E = getUnits().end();
2343 DwarfUnit *TheU = *I;
2344 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2345 TheU->getAccelTypes();
2347 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2351 StringRef Name = GI->getKey();
2352 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2354 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2355 DI = Entities.begin(),
2356 DE = Entities.end();
2358 AT.AddName(Name, DI->first, DI->second);
2362 AT.FinalizeTable(Asm, "types");
2363 Asm->OutStreamer.SwitchSection(
2364 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2365 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2366 Asm->OutStreamer.EmitLabel(SectionBegin);
2368 // Emit the full data.
2369 AT.Emit(Asm, SectionBegin, &InfoHolder);
2372 // Public name handling.
2373 // The format for the various pubnames:
2375 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2376 // for the DIE that is named.
2378 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2379 // into the CU and the index value is computed according to the type of value
2380 // for the DIE that is named.
2382 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2383 // it's the offset within the debug_info/debug_types dwo section, however, the
2384 // reference in the pubname header doesn't change.
2386 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2387 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2389 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2391 // We could have a specification DIE that has our most of our knowledge,
2392 // look for that now.
2393 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2395 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2396 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2397 Linkage = dwarf::GIEL_EXTERNAL;
2398 } else if (Die->findAttribute(dwarf::DW_AT_external))
2399 Linkage = dwarf::GIEL_EXTERNAL;
2401 switch (Die->getTag()) {
2402 case dwarf::DW_TAG_class_type:
2403 case dwarf::DW_TAG_structure_type:
2404 case dwarf::DW_TAG_union_type:
2405 case dwarf::DW_TAG_enumeration_type:
2406 return dwarf::PubIndexEntryDescriptor(
2407 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2408 ? dwarf::GIEL_STATIC
2409 : dwarf::GIEL_EXTERNAL);
2410 case dwarf::DW_TAG_typedef:
2411 case dwarf::DW_TAG_base_type:
2412 case dwarf::DW_TAG_subrange_type:
2413 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2414 case dwarf::DW_TAG_namespace:
2415 return dwarf::GIEK_TYPE;
2416 case dwarf::DW_TAG_subprogram:
2417 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2418 case dwarf::DW_TAG_constant:
2419 case dwarf::DW_TAG_variable:
2420 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2421 case dwarf::DW_TAG_enumerator:
2422 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2423 dwarf::GIEL_STATIC);
2425 return dwarf::GIEK_NONE;
2429 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2431 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2432 const MCSection *PSec =
2433 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2434 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2436 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2437 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2438 for (unsigned i = 0; i != Units.size(); ++i) {
2439 DwarfUnit *TheU = Units[i];
2440 unsigned ID = TheU->getUniqueID();
2442 // Start the dwarf pubnames section.
2443 Asm->OutStreamer.SwitchSection(PSec);
2445 // Emit a label so we can reference the beginning of this pubname section.
2447 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2450 Asm->OutStreamer.AddComment("Length of Public Names Info");
2451 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2452 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2453 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2455 Asm->OutStreamer.EmitLabel(BeginLabel);
2457 Asm->OutStreamer.AddComment("DWARF Version");
2458 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2460 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2461 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2463 Asm->OutStreamer.AddComment("Compilation Unit Length");
2464 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2466 // Emit the pubnames for this compilation unit.
2467 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2468 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2471 const char *Name = GI->getKeyData();
2472 const DIE *Entity = GI->second;
2474 Asm->OutStreamer.AddComment("DIE offset");
2475 Asm->EmitInt32(Entity->getOffset());
2478 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2479 Asm->OutStreamer.AddComment(
2480 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2481 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2482 Asm->EmitInt8(Desc.toBits());
2485 Asm->OutStreamer.AddComment("External Name");
2486 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2489 Asm->OutStreamer.AddComment("End Mark");
2491 Asm->OutStreamer.EmitLabel(EndLabel);
2495 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2496 const MCSection *PSec =
2497 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2498 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2500 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2501 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2502 for (unsigned i = 0; i != Units.size(); ++i) {
2503 DwarfUnit *TheU = Units[i];
2504 unsigned ID = TheU->getUniqueID();
2506 // Start the dwarf pubtypes section.
2507 Asm->OutStreamer.SwitchSection(PSec);
2509 // Emit a label so we can reference the beginning of this pubtype section.
2511 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2514 Asm->OutStreamer.AddComment("Length of Public Types Info");
2515 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2516 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2517 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2519 Asm->OutStreamer.EmitLabel(BeginLabel);
2521 Asm->OutStreamer.AddComment("DWARF Version");
2522 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2524 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2525 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2527 Asm->OutStreamer.AddComment("Compilation Unit Length");
2528 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2530 // Emit the pubtypes.
2531 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2532 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2535 const char *Name = GI->getKeyData();
2536 const DIE *Entity = GI->second;
2538 Asm->OutStreamer.AddComment("DIE offset");
2539 Asm->EmitInt32(Entity->getOffset());
2542 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2543 Asm->OutStreamer.AddComment(
2544 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2545 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2546 Asm->EmitInt8(Desc.toBits());
2549 Asm->OutStreamer.AddComment("External Name");
2551 // Emit the name with a terminating null byte.
2552 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2555 Asm->OutStreamer.AddComment("End Mark");
2557 Asm->OutStreamer.EmitLabel(EndLabel);
2561 // Emit strings into a string section.
2562 void DwarfFile::emitStrings(const MCSection *StrSection,
2563 const MCSection *OffsetSection = NULL,
2564 const MCSymbol *StrSecSym = NULL) {
2566 if (StringPool.empty())
2569 // Start the dwarf str section.
2570 Asm->OutStreamer.SwitchSection(StrSection);
2572 // Get all of the string pool entries and put them in an array by their ID so
2573 // we can sort them.
2575 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2578 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2579 I = StringPool.begin(),
2580 E = StringPool.end();
2582 Entries.push_back(std::make_pair(I->second.second, &*I));
2584 array_pod_sort(Entries.begin(), Entries.end());
2586 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2587 // Emit a label for reference from debug information entries.
2588 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2590 // Emit the string itself with a terminating null byte.
2591 Asm->OutStreamer.EmitBytes(
2592 StringRef(Entries[i].second->getKeyData(),
2593 Entries[i].second->getKeyLength() + 1));
2596 // If we've got an offset section go ahead and emit that now as well.
2597 if (OffsetSection) {
2598 Asm->OutStreamer.SwitchSection(OffsetSection);
2599 unsigned offset = 0;
2600 unsigned size = 4; // FIXME: DWARF64 is 8.
2601 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2602 Asm->OutStreamer.EmitIntValue(offset, size);
2603 offset += Entries[i].second->getKeyLength() + 1;
2608 // Emit addresses into the section given.
2609 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2611 if (AddressPool.empty())
2614 // Start the dwarf addr section.
2615 Asm->OutStreamer.SwitchSection(AddrSection);
2617 // Order the address pool entries by ID
2618 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2620 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2621 E = AddressPool.end();
2623 Entries[I->second] = I->first;
2625 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2626 // Emit an expression for reference from debug information entries.
2627 if (const MCExpr *Expr = Entries[i])
2628 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2630 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2634 // Emit visible names into a debug str section.
2635 void DwarfDebug::emitDebugStr() {
2636 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2637 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2640 // Emit locations into the debug loc section.
2641 void DwarfDebug::emitDebugLoc() {
2642 if (DotDebugLocEntries.empty())
2645 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2646 I = DotDebugLocEntries.begin(),
2647 E = DotDebugLocEntries.end();
2649 DotDebugLocEntry &Entry = *I;
2650 if (I + 1 != DotDebugLocEntries.end())
2654 // Start the dwarf loc section.
2655 Asm->OutStreamer.SwitchSection(
2656 Asm->getObjFileLowering().getDwarfLocSection());
2657 unsigned char Size = Asm->getDataLayout().getPointerSize();
2658 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2660 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2661 I = DotDebugLocEntries.begin(),
2662 E = DotDebugLocEntries.end();
2663 I != E; ++I, ++index) {
2664 DotDebugLocEntry &Entry = *I;
2665 if (Entry.isMerged())
2667 if (Entry.isEmpty()) {
2668 Asm->OutStreamer.EmitIntValue(0, Size);
2669 Asm->OutStreamer.EmitIntValue(0, Size);
2670 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2672 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2673 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2674 DIVariable DV(Entry.getVariable());
2675 Asm->OutStreamer.AddComment("Loc expr size");
2676 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2677 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2678 Asm->EmitLabelDifference(end, begin, 2);
2679 Asm->OutStreamer.EmitLabel(begin);
2680 if (Entry.isInt()) {
2681 DIBasicType BTy(DV.getType());
2682 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2683 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2684 Asm->OutStreamer.AddComment("DW_OP_consts");
2685 Asm->EmitInt8(dwarf::DW_OP_consts);
2686 Asm->EmitSLEB128(Entry.getInt());
2688 Asm->OutStreamer.AddComment("DW_OP_constu");
2689 Asm->EmitInt8(dwarf::DW_OP_constu);
2690 Asm->EmitULEB128(Entry.getInt());
2692 } else if (Entry.isLocation()) {
2693 MachineLocation Loc = Entry.getLoc();
2694 if (!DV.hasComplexAddress())
2696 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2698 // Complex address entry.
2699 unsigned N = DV.getNumAddrElements();
2701 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2702 if (Loc.getOffset()) {
2704 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2705 Asm->OutStreamer.AddComment("DW_OP_deref");
2706 Asm->EmitInt8(dwarf::DW_OP_deref);
2707 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2708 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2709 Asm->EmitSLEB128(DV.getAddrElement(1));
2711 // If first address element is OpPlus then emit
2712 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2713 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2714 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2718 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2721 // Emit remaining complex address elements.
2722 for (; i < N; ++i) {
2723 uint64_t Element = DV.getAddrElement(i);
2724 if (Element == DIBuilder::OpPlus) {
2725 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2726 Asm->EmitULEB128(DV.getAddrElement(++i));
2727 } else if (Element == DIBuilder::OpDeref) {
2729 Asm->EmitInt8(dwarf::DW_OP_deref);
2731 llvm_unreachable("unknown Opcode found in complex address");
2735 // else ... ignore constant fp. There is not any good way to
2736 // to represent them here in dwarf.
2737 Asm->OutStreamer.EmitLabel(end);
2742 struct SymbolCUSorter {
2743 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2744 const MCStreamer &Streamer;
2746 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2747 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2748 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2750 // Symbols with no order assigned should be placed at the end.
2751 // (e.g. section end labels)
2753 IA = (unsigned)(-1);
2755 IB = (unsigned)(-1);
2760 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2761 return (A->getUniqueID() < B->getUniqueID());
2765 const MCSymbol *Start, *End;
2768 // Emit a debug aranges section, containing a CU lookup for any
2769 // address we can tie back to a CU.
2770 void DwarfDebug::emitDebugARanges() {
2771 // Start the dwarf aranges section.
2772 Asm->OutStreamer.SwitchSection(
2773 Asm->getObjFileLowering().getDwarfARangesSection());
2775 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2779 // Build a list of sections used.
2780 std::vector<const MCSection *> Sections;
2781 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2783 const MCSection *Section = it->first;
2784 Sections.push_back(Section);
2787 // Sort the sections into order.
2788 // This is only done to ensure consistent output order across different runs.
2789 std::sort(Sections.begin(), Sections.end(), SectionSort);
2791 // Build a set of address spans, sorted by CU.
2792 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2793 const MCSection *Section = Sections[SecIdx];
2794 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2795 if (List.size() < 2)
2798 // Sort the symbols by offset within the section.
2799 SymbolCUSorter sorter(Asm->OutStreamer);
2800 std::sort(List.begin(), List.end(), sorter);
2802 // If we have no section (e.g. common), just write out
2803 // individual spans for each symbol.
2804 if (Section == NULL) {
2805 for (size_t n = 0; n < List.size(); n++) {
2806 const SymbolCU &Cur = List[n];
2809 Span.Start = Cur.Sym;
2812 Spans[Cur.CU].push_back(Span);
2815 // Build spans between each label.
2816 const MCSymbol *StartSym = List[0].Sym;
2817 for (size_t n = 1; n < List.size(); n++) {
2818 const SymbolCU &Prev = List[n - 1];
2819 const SymbolCU &Cur = List[n];
2821 // Try and build the longest span we can within the same CU.
2822 if (Cur.CU != Prev.CU) {
2824 Span.Start = StartSym;
2826 Spans[Prev.CU].push_back(Span);
2833 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2835 // Build a list of CUs used.
2836 std::vector<DwarfCompileUnit *> CUs;
2837 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2838 DwarfCompileUnit *CU = it->first;
2842 // Sort the CU list (again, to ensure consistent output order).
2843 std::sort(CUs.begin(), CUs.end(), CUSort);
2845 // Emit an arange table for each CU we used.
2846 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2847 DwarfCompileUnit *CU = CUs[CUIdx];
2848 std::vector<ArangeSpan> &List = Spans[CU];
2850 // Emit size of content not including length itself.
2851 unsigned ContentSize =
2852 sizeof(int16_t) + // DWARF ARange version number
2853 sizeof(int32_t) + // Offset of CU in the .debug_info section
2854 sizeof(int8_t) + // Pointer Size (in bytes)
2855 sizeof(int8_t); // Segment Size (in bytes)
2857 unsigned TupleSize = PtrSize * 2;
2859 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2860 unsigned Padding = 0;
2861 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2864 ContentSize += Padding;
2865 ContentSize += (List.size() + 1) * TupleSize;
2867 // For each compile unit, write the list of spans it covers.
2868 Asm->OutStreamer.AddComment("Length of ARange Set");
2869 Asm->EmitInt32(ContentSize);
2870 Asm->OutStreamer.AddComment("DWARF Arange version number");
2871 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2872 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2873 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2874 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2875 Asm->EmitInt8(PtrSize);
2876 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2879 for (unsigned n = 0; n < Padding; n++)
2880 Asm->EmitInt8(0xff);
2882 for (unsigned n = 0; n < List.size(); n++) {
2883 const ArangeSpan &Span = List[n];
2884 Asm->EmitLabelReference(Span.Start, PtrSize);
2886 // Calculate the size as being from the span start to it's end.
2888 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2890 // For symbols without an end marker (e.g. common), we
2891 // write a single arange entry containing just that one symbol.
2892 uint64_t Size = SymSize[Span.Start];
2896 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2900 Asm->OutStreamer.AddComment("ARange terminator");
2901 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2902 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2906 // Emit visible names into a debug ranges section.
2907 void DwarfDebug::emitDebugRanges() {
2908 // Start the dwarf ranges section.
2909 Asm->OutStreamer.SwitchSection(
2910 Asm->getObjFileLowering().getDwarfRangesSection());
2912 // Size for our labels.
2913 unsigned char Size = Asm->getDataLayout().getPointerSize();
2915 // Grab the specific ranges for the compile units in the module.
2916 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2919 DwarfCompileUnit *TheCU = I->second;
2921 // Emit a symbol so we can find the beginning of our ranges.
2922 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2924 // Iterate over the misc ranges for the compile units in the module.
2925 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2926 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2927 E = RangeLists.end();
2929 const RangeSpanList &List = *I;
2931 // Emit our symbol so we can find the beginning of the range.
2932 Asm->OutStreamer.EmitLabel(List.getSym());
2934 for (SmallVectorImpl<RangeSpan>::const_iterator
2935 RI = List.getRanges().begin(),
2936 RE = List.getRanges().end();
2938 const RangeSpan &Range = *RI;
2939 const MCSymbol *Begin = Range.getStart();
2940 const MCSymbol *End = Range.getEnd();
2941 assert(Begin && "Range without a begin symbol?");
2942 assert(End && "Range without an end symbol?");
2943 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2944 Asm->OutStreamer.EmitSymbolValue(End, Size);
2947 // And terminate the list with two 0 values.
2948 Asm->OutStreamer.EmitIntValue(0, Size);
2949 Asm->OutStreamer.EmitIntValue(0, Size);
2952 // Now emit a range for the CU itself.
2953 if (DwarfCURanges) {
2954 Asm->OutStreamer.EmitLabel(
2955 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2956 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2957 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2958 RangeSpan Range = Ranges[i];
2959 const MCSymbol *Begin = Range.getStart();
2960 const MCSymbol *End = Range.getEnd();
2961 assert(Begin && "Range without a begin symbol?");
2962 assert(End && "Range without an end symbol?");
2963 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2964 Asm->OutStreamer.EmitSymbolValue(End, Size);
2966 // And terminate the list with two 0 values.
2967 Asm->OutStreamer.EmitIntValue(0, Size);
2968 Asm->OutStreamer.EmitIntValue(0, Size);
2973 // DWARF5 Experimental Separate Dwarf emitters.
2975 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2976 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2977 // DW_AT_ranges_base, DW_AT_addr_base.
2978 // TODO: Implement DW_AT_ranges_base.
2979 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2981 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2982 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2983 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2984 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2985 DwarfInfoSectionSym);
2987 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2988 CU->getNode().getSplitDebugFilename());
2990 // Relocate to the beginning of the addr_base section, else 0 for the
2991 // beginning of the one for this compile unit.
2992 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2993 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2994 DwarfAddrSectionSym);
2996 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2998 // DW_AT_stmt_list is a offset of line number information for this
2999 // compile unit in debug_line section.
3000 // FIXME: Should handle multiple compile units.
3001 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3002 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3004 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3006 if (!CompilationDir.empty())
3007 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3009 addGnuPubAttributes(NewCU, Die);
3011 SkeletonHolder.addUnit(NewCU);
3016 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3017 // compile units that would normally be in debug_info.
3018 void DwarfDebug::emitDebugInfoDWO() {
3019 assert(useSplitDwarf() && "No split dwarf debug info?");
3020 InfoHolder.emitUnits(this,
3021 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3022 DwarfAbbrevDWOSectionSym);
3025 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3026 // abbreviations for the .debug_info.dwo section.
3027 void DwarfDebug::emitDebugAbbrevDWO() {
3028 assert(useSplitDwarf() && "No split dwarf?");
3029 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3032 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3033 // string section and is identical in format to traditional .debug_str
3035 void DwarfDebug::emitDebugStrDWO() {
3036 assert(useSplitDwarf() && "No split dwarf?");
3037 const MCSection *OffSec =
3038 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3039 const MCSymbol *StrSym = DwarfStrSectionSym;
3040 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3044 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3045 DICompositeType CTy) {
3046 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3048 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3049 DwarfTypeUnit *NewTU =
3050 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3053 InfoHolder.addUnit(NewTU);
3055 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3058 DIE *Die = NewTU->createTypeDIE(CTy);
3060 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3061 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3062 dwarf::DW_FORM_data8,
3063 DIEHash().computeDIEODRSignature(*Die));
3064 // FIXME: This won't handle circularly referential structures, as the DIE
3065 // may have references to other DIEs still under construction and missing
3066 // their signature. Hashing should walk through the signatures to their
3067 // referenced type, or possibly walk the precomputed hashes of related types
3069 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3070 NewTU->setTypeSignature(Signature);
3071 NewTU->setType(Die);
3075 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3076 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3079 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);