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 DW_AT_low_pc.
1095 // FIXME: Also add a high pc if we can.
1096 // FIXME: We should use ranges if we have multiple compile units.
1097 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1098 if (DwarfCURanges && TheU->getRanges().size())
1099 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1100 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1101 DwarfDebugRangeSectionSym);
1103 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
1107 // Compute DIE offsets and sizes.
1108 InfoHolder.computeSizeAndOffsets();
1109 if (useSplitDwarf())
1110 SkeletonHolder.computeSizeAndOffsets();
1113 void DwarfDebug::endSections() {
1114 // Filter labels by section.
1115 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1116 const SymbolCU &SCU = ArangeLabels[n];
1117 if (SCU.Sym->isInSection()) {
1118 // Make a note of this symbol and it's section.
1119 const MCSection *Section = &SCU.Sym->getSection();
1120 if (!Section->getKind().isMetadata())
1121 SectionMap[Section].push_back(SCU);
1123 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1124 // appear in the output. This sucks as we rely on sections to build
1125 // arange spans. We can do it without, but it's icky.
1126 SectionMap[NULL].push_back(SCU);
1130 // Build a list of sections used.
1131 std::vector<const MCSection *> Sections;
1132 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1134 const MCSection *Section = it->first;
1135 Sections.push_back(Section);
1138 // Sort the sections into order.
1139 // This is only done to ensure consistent output order across different runs.
1140 std::sort(Sections.begin(), Sections.end(), SectionSort);
1142 // Add terminating symbols for each section.
1143 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1144 const MCSection *Section = Sections[ID];
1145 MCSymbol *Sym = NULL;
1148 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1149 // if we know the section name up-front. For user-created sections, the
1151 // label may not be valid to use as a label. (section names can use a
1153 // set of characters on some systems)
1154 Sym = Asm->GetTempSymbol("debug_end", ID);
1155 Asm->OutStreamer.SwitchSection(Section);
1156 Asm->OutStreamer.EmitLabel(Sym);
1159 // Insert a final terminator.
1160 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1164 // Emit all Dwarf sections that should come after the content.
1165 void DwarfDebug::endModule() {
1172 // End any existing sections.
1173 // TODO: Does this need to happen?
1176 // Finalize the debug info for the module.
1177 finalizeModuleInfo();
1181 // Emit all the DIEs into a debug info section.
1184 // Corresponding abbreviations into a abbrev section.
1185 emitAbbreviations();
1187 // Emit info into a debug loc section.
1190 // Emit info into a debug aranges section.
1193 // Emit info into a debug ranges section.
1196 if (useSplitDwarf()) {
1199 emitDebugAbbrevDWO();
1200 // Emit DWO addresses.
1201 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1204 // Emit info into the dwarf accelerator table sections.
1205 if (useDwarfAccelTables()) {
1208 emitAccelNamespaces();
1212 // Emit the pubnames and pubtypes sections if requested.
1213 if (HasDwarfPubSections) {
1214 emitDebugPubNames(GenerateGnuPubSections);
1215 emitDebugPubTypes(GenerateGnuPubSections);
1221 // Reset these for the next Module if we have one.
1225 // Find abstract variable, if any, associated with Var.
1226 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1227 DebugLoc ScopeLoc) {
1228 LLVMContext &Ctx = DV->getContext();
1229 // More then one inlined variable corresponds to one abstract variable.
1230 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1231 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1233 return AbsDbgVariable;
1235 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1239 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1240 addScopeVariable(Scope, AbsDbgVariable);
1241 AbstractVariables[Var] = AbsDbgVariable;
1242 return AbsDbgVariable;
1245 // If Var is a current function argument then add it to CurrentFnArguments list.
1246 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1247 if (!LScopes.isCurrentFunctionScope(Scope))
1249 DIVariable DV = Var->getVariable();
1250 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1252 unsigned ArgNo = DV.getArgNumber();
1256 size_t Size = CurrentFnArguments.size();
1258 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1259 // llvm::Function argument size is not good indicator of how many
1260 // arguments does the function have at source level.
1262 CurrentFnArguments.resize(ArgNo * 2);
1263 CurrentFnArguments[ArgNo - 1] = Var;
1267 // Collect variable information from side table maintained by MMI.
1268 void DwarfDebug::collectVariableInfoFromMMITable(
1269 SmallPtrSet<const MDNode *, 16> &Processed) {
1270 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1271 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1274 const MDNode *Var = VI->first;
1277 Processed.insert(Var);
1279 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1281 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1283 // If variable scope is not found then skip this variable.
1287 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1288 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1289 RegVar->setFrameIndex(VP.first);
1290 if (!addCurrentFnArgument(RegVar, Scope))
1291 addScopeVariable(Scope, RegVar);
1293 AbsDbgVariable->setFrameIndex(VP.first);
1297 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1299 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1300 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1301 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1302 MI->getOperand(0).getReg() &&
1303 (MI->getOperand(1).isImm() ||
1304 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1307 // Get .debug_loc entry for the instruction range starting at MI.
1308 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1309 const MCSymbol *FLabel,
1310 const MCSymbol *SLabel,
1311 const MachineInstr *MI) {
1312 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1314 assert(MI->getNumOperands() == 3);
1315 if (MI->getOperand(0).isReg()) {
1316 MachineLocation MLoc;
1317 // If the second operand is an immediate, this is a
1318 // register-indirect address.
1319 if (!MI->getOperand(1).isImm())
1320 MLoc.set(MI->getOperand(0).getReg());
1322 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1323 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1325 if (MI->getOperand(0).isImm())
1326 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1327 if (MI->getOperand(0).isFPImm())
1328 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1329 if (MI->getOperand(0).isCImm())
1330 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1332 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1335 // Find variables for each lexical scope.
1337 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1339 // Grab the variable info that was squirreled away in the MMI side-table.
1340 collectVariableInfoFromMMITable(Processed);
1342 for (SmallVectorImpl<const MDNode *>::const_iterator
1343 UVI = UserVariables.begin(),
1344 UVE = UserVariables.end();
1345 UVI != UVE; ++UVI) {
1346 const MDNode *Var = *UVI;
1347 if (Processed.count(Var))
1350 // History contains relevant DBG_VALUE instructions for Var and instructions
1352 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1353 if (History.empty())
1355 const MachineInstr *MInsn = History.front();
1358 LexicalScope *Scope = NULL;
1359 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1360 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1361 Scope = LScopes.getCurrentFunctionScope();
1362 else if (MDNode *IA = DV.getInlinedAt())
1363 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1365 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1366 // If variable scope is not found then skip this variable.
1370 Processed.insert(DV);
1371 assert(MInsn->isDebugValue() && "History must begin with debug value");
1372 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1373 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1374 if (!addCurrentFnArgument(RegVar, Scope))
1375 addScopeVariable(Scope, RegVar);
1377 AbsVar->setMInsn(MInsn);
1379 // Simplify ranges that are fully coalesced.
1380 if (History.size() <= 1 ||
1381 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1382 RegVar->setMInsn(MInsn);
1386 // Handle multiple DBG_VALUE instructions describing one variable.
1387 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1389 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1390 HI = History.begin(),
1393 const MachineInstr *Begin = *HI;
1394 assert(Begin->isDebugValue() && "Invalid History entry");
1396 // Check if DBG_VALUE is truncating a range.
1397 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1398 !Begin->getOperand(0).getReg())
1401 // Compute the range for a register location.
1402 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1403 const MCSymbol *SLabel = 0;
1406 // If Begin is the last instruction in History then its value is valid
1407 // until the end of the function.
1408 SLabel = FunctionEndSym;
1410 const MachineInstr *End = HI[1];
1411 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1412 << "\t" << *Begin << "\t" << *End << "\n");
1413 if (End->isDebugValue())
1414 SLabel = getLabelBeforeInsn(End);
1416 // End is a normal instruction clobbering the range.
1417 SLabel = getLabelAfterInsn(End);
1418 assert(SLabel && "Forgot label after clobber instruction");
1423 // The value is valid until the next DBG_VALUE or clobber.
1424 DotDebugLocEntries.push_back(
1425 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1427 DotDebugLocEntries.push_back(DotDebugLocEntry());
1430 // Collect info for variables that were optimized out.
1431 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1432 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1433 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1434 DIVariable DV(Variables.getElement(i));
1435 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1437 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1438 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1442 // Return Label preceding the instruction.
1443 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1444 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1445 assert(Label && "Didn't insert label before instruction");
1449 // Return Label immediately following the instruction.
1450 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1451 return LabelsAfterInsn.lookup(MI);
1454 // Process beginning of an instruction.
1455 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1458 // Check if source location changes, but ignore DBG_VALUE locations.
1459 if (!MI->isDebugValue()) {
1460 DebugLoc DL = MI->getDebugLoc();
1461 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1464 if (DL == PrologEndLoc) {
1465 Flags |= DWARF2_FLAG_PROLOGUE_END;
1466 PrologEndLoc = DebugLoc();
1468 if (PrologEndLoc.isUnknown())
1469 Flags |= DWARF2_FLAG_IS_STMT;
1471 if (!DL.isUnknown()) {
1472 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1473 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1475 recordSourceLine(0, 0, 0, 0);
1479 // Insert labels where requested.
1480 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1481 LabelsBeforeInsn.find(MI);
1484 if (I == LabelsBeforeInsn.end())
1487 // Label already assigned.
1492 PrevLabel = MMI->getContext().CreateTempSymbol();
1493 Asm->OutStreamer.EmitLabel(PrevLabel);
1495 I->second = PrevLabel;
1498 // Process end of an instruction.
1499 void DwarfDebug::endInstruction() {
1501 // Don't create a new label after DBG_VALUE instructions.
1502 // They don't generate code.
1503 if (!CurMI->isDebugValue())
1506 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1507 LabelsAfterInsn.find(CurMI);
1511 if (I == LabelsAfterInsn.end())
1514 // Label already assigned.
1518 // We need a label after this instruction.
1520 PrevLabel = MMI->getContext().CreateTempSymbol();
1521 Asm->OutStreamer.EmitLabel(PrevLabel);
1523 I->second = PrevLabel;
1526 // Each LexicalScope has first instruction and last instruction to mark
1527 // beginning and end of a scope respectively. Create an inverse map that list
1528 // scopes starts (and ends) with an instruction. One instruction may start (or
1529 // end) multiple scopes. Ignore scopes that are not reachable.
1530 void DwarfDebug::identifyScopeMarkers() {
1531 SmallVector<LexicalScope *, 4> WorkList;
1532 WorkList.push_back(LScopes.getCurrentFunctionScope());
1533 while (!WorkList.empty()) {
1534 LexicalScope *S = WorkList.pop_back_val();
1536 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1537 if (!Children.empty())
1538 for (SmallVectorImpl<LexicalScope *>::const_iterator
1539 SI = Children.begin(),
1540 SE = Children.end();
1542 WorkList.push_back(*SI);
1544 if (S->isAbstractScope())
1547 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1550 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1553 assert(RI->first && "InsnRange does not have first instruction!");
1554 assert(RI->second && "InsnRange does not have second instruction!");
1555 requestLabelBeforeInsn(RI->first);
1556 requestLabelAfterInsn(RI->second);
1561 // Get MDNode for DebugLoc's scope.
1562 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1563 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1564 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1565 return DL.getScope(Ctx);
1568 // Walk up the scope chain of given debug loc and find line number info
1569 // for the function.
1570 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1571 const MDNode *Scope = getScopeNode(DL, Ctx);
1572 DISubprogram SP = getDISubprogram(Scope);
1573 if (SP.isSubprogram()) {
1574 // Check for number of operands since the compatibility is
1576 if (SP->getNumOperands() > 19)
1577 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1579 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1585 // Gather pre-function debug information. Assumes being called immediately
1586 // after the function entry point has been emitted.
1587 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1590 // If there's no debug info for the function we're not going to do anything.
1591 if (!MMI->hasDebugInfo())
1594 // Grab the lexical scopes for the function, if we don't have any of those
1595 // then we're not going to be able to do anything.
1596 LScopes.initialize(*MF);
1597 if (LScopes.empty())
1600 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1602 // Make sure that each lexical scope will have a begin/end label.
1603 identifyScopeMarkers();
1605 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1606 // belongs to so that we add to the correct per-cu line table in the
1608 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1609 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1610 assert(TheCU && "Unable to find compile unit!");
1611 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1612 // Use a single line table if we are using .loc and generating assembly.
1613 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1615 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1617 // Emit a label for the function so that we have a beginning address.
1618 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1619 // Assumes in correct section after the entry point.
1620 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1622 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1623 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1624 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1626 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1628 bool AtBlockEntry = true;
1629 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1631 const MachineInstr *MI = II;
1633 if (MI->isDebugValue()) {
1634 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1636 // Keep track of user variables.
1638 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1640 // Variable is in a register, we need to check for clobbers.
1641 if (isDbgValueInDefinedReg(MI))
1642 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1644 // Check the history of this variable.
1645 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1646 if (History.empty()) {
1647 UserVariables.push_back(Var);
1648 // The first mention of a function argument gets the FunctionBeginSym
1649 // label, so arguments are visible when breaking at function entry.
1651 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1652 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1653 LabelsBeforeInsn[MI] = FunctionBeginSym;
1655 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1656 const MachineInstr *Prev = History.back();
1657 if (Prev->isDebugValue()) {
1658 // Coalesce identical entries at the end of History.
1659 if (History.size() >= 2 &&
1660 Prev->isIdenticalTo(History[History.size() - 2])) {
1661 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1662 << "\t" << *Prev << "\t"
1663 << *History[History.size() - 2] << "\n");
1667 // Terminate old register assignments that don't reach MI;
1668 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1669 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1670 isDbgValueInDefinedReg(Prev)) {
1671 // Previous register assignment needs to terminate at the end of
1673 MachineBasicBlock::const_iterator LastMI =
1674 PrevMBB->getLastNonDebugInstr();
1675 if (LastMI == PrevMBB->end()) {
1676 // Drop DBG_VALUE for empty range.
1677 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1678 << "\t" << *Prev << "\n");
1680 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1681 // Terminate after LastMI.
1682 History.push_back(LastMI);
1686 History.push_back(MI);
1688 // Not a DBG_VALUE instruction.
1690 AtBlockEntry = false;
1692 // First known non-DBG_VALUE and non-frame setup location marks
1693 // the beginning of the function body.
1694 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1695 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1696 PrologEndLoc = MI->getDebugLoc();
1698 // Check if the instruction clobbers any registers with debug vars.
1699 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1700 MOE = MI->operands_end();
1701 MOI != MOE; ++MOI) {
1702 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1704 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1707 const MDNode *Var = LiveUserVar[Reg];
1710 // Reg is now clobbered.
1711 LiveUserVar[Reg] = 0;
1713 // Was MD last defined by a DBG_VALUE referring to Reg?
1714 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1715 if (HistI == DbgValues.end())
1717 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1718 if (History.empty())
1720 const MachineInstr *Prev = History.back();
1721 // Sanity-check: Register assignments are terminated at the end of
1723 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1725 // Is the variable still in Reg?
1726 if (!isDbgValueInDefinedReg(Prev) ||
1727 Prev->getOperand(0).getReg() != Reg)
1729 // Var is clobbered. Make sure the next instruction gets a label.
1730 History.push_back(MI);
1737 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1739 SmallVectorImpl<const MachineInstr *> &History = I->second;
1740 if (History.empty())
1743 // Make sure the final register assignments are terminated.
1744 const MachineInstr *Prev = History.back();
1745 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1746 const MachineBasicBlock *PrevMBB = Prev->getParent();
1747 MachineBasicBlock::const_iterator LastMI =
1748 PrevMBB->getLastNonDebugInstr();
1749 if (LastMI == PrevMBB->end())
1750 // Drop DBG_VALUE for empty range.
1752 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1753 // Terminate after LastMI.
1754 History.push_back(LastMI);
1757 // Request labels for the full history.
1758 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1759 const MachineInstr *MI = History[i];
1760 if (MI->isDebugValue())
1761 requestLabelBeforeInsn(MI);
1763 requestLabelAfterInsn(MI);
1767 PrevInstLoc = DebugLoc();
1768 PrevLabel = FunctionBeginSym;
1770 // Record beginning of function.
1771 if (!PrologEndLoc.isUnknown()) {
1772 DebugLoc FnStartDL =
1773 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1775 FnStartDL.getLine(), FnStartDL.getCol(),
1776 FnStartDL.getScope(MF->getFunction()->getContext()),
1777 // We'd like to list the prologue as "not statements" but GDB behaves
1778 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1779 DWARF2_FLAG_IS_STMT);
1783 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1784 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1785 DIVariable DV = Var->getVariable();
1786 // Variables with positive arg numbers are parameters.
1787 if (unsigned ArgNum = DV.getArgNumber()) {
1788 // Keep all parameters in order at the start of the variable list to ensure
1789 // function types are correct (no out-of-order parameters)
1791 // This could be improved by only doing it for optimized builds (unoptimized
1792 // builds have the right order to begin with), searching from the back (this
1793 // would catch the unoptimized case quickly), or doing a binary search
1794 // rather than linear search.
1795 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1796 while (I != Vars.end()) {
1797 unsigned CurNum = (*I)->getVariable().getArgNumber();
1798 // A local (non-parameter) variable has been found, insert immediately
1802 // A later indexed parameter has been found, insert immediately before it.
1803 if (CurNum > ArgNum)
1807 Vars.insert(I, Var);
1811 Vars.push_back(Var);
1814 // Gather and emit post-function debug information.
1815 void DwarfDebug::endFunction(const MachineFunction *MF) {
1816 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1817 // though the beginFunction may not be called at all.
1818 // We should handle both cases.
1822 assert(CurFn == MF);
1825 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1830 // Define end label for subprogram.
1831 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1832 // Assumes in correct section after the entry point.
1833 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1834 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1835 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1837 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1838 collectVariableInfo(ProcessedVars);
1840 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1841 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1842 assert(TheCU && "Unable to find compile unit!");
1844 // Construct abstract scopes.
1845 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1846 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1847 LexicalScope *AScope = AList[i];
1848 DISubprogram SP(AScope->getScopeNode());
1849 if (SP.isSubprogram()) {
1850 // Collect info for variables that were optimized out.
1851 DIArray Variables = SP.getVariables();
1852 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1853 DIVariable DV(Variables.getElement(i));
1854 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1856 // Check that DbgVariable for DV wasn't created earlier, when
1857 // findAbstractVariable() was called for inlined instance of DV.
1858 LLVMContext &Ctx = DV->getContext();
1859 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1860 if (AbstractVariables.lookup(CleanDV))
1862 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1863 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1866 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1867 constructScopeDIE(TheCU, AScope);
1870 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1872 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1873 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1876 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1877 E = ScopeVariables.end();
1879 DeleteContainerPointers(I->second);
1880 ScopeVariables.clear();
1881 DeleteContainerPointers(CurrentFnArguments);
1882 UserVariables.clear();
1884 AbstractVariables.clear();
1885 LabelsBeforeInsn.clear();
1886 LabelsAfterInsn.clear();
1891 // Register a source line with debug info. Returns the unique label that was
1892 // emitted and which provides correspondence to the source line list.
1893 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1899 DIDescriptor Scope(S);
1901 if (Scope.isCompileUnit()) {
1902 DICompileUnit CU(S);
1903 Fn = CU.getFilename();
1904 Dir = CU.getDirectory();
1905 } else if (Scope.isFile()) {
1907 Fn = F.getFilename();
1908 Dir = F.getDirectory();
1909 } else if (Scope.isSubprogram()) {
1911 Fn = SP.getFilename();
1912 Dir = SP.getDirectory();
1913 } else if (Scope.isLexicalBlockFile()) {
1914 DILexicalBlockFile DBF(S);
1915 Fn = DBF.getFilename();
1916 Dir = DBF.getDirectory();
1917 } else if (Scope.isLexicalBlock()) {
1918 DILexicalBlock DB(S);
1919 Fn = DB.getFilename();
1920 Dir = DB.getDirectory();
1922 llvm_unreachable("Unexpected scope info");
1924 Src = getOrCreateSourceID(
1925 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1927 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1930 //===----------------------------------------------------------------------===//
1932 //===----------------------------------------------------------------------===//
1934 // Compute the size and offset of a DIE. The offset is relative to start of the
1935 // CU. It returns the offset after laying out the DIE.
1936 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1937 // Get the children.
1938 const std::vector<DIE *> &Children = Die->getChildren();
1940 // Record the abbreviation.
1941 assignAbbrevNumber(Die->getAbbrev());
1943 // Get the abbreviation for this DIE.
1944 const DIEAbbrev &Abbrev = Die->getAbbrev();
1947 Die->setOffset(Offset);
1949 // Start the size with the size of abbreviation code.
1950 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1952 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1953 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1955 // Size the DIE attribute values.
1956 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1957 // Size attribute value.
1958 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1960 // Size the DIE children if any.
1961 if (!Children.empty()) {
1962 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1963 "Children flag not set");
1965 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1966 Offset = computeSizeAndOffset(Children[j], Offset);
1968 // End of children marker.
1969 Offset += sizeof(int8_t);
1972 Die->setSize(Offset - Die->getOffset());
1976 // Compute the size and offset for each DIE.
1977 void DwarfFile::computeSizeAndOffsets() {
1978 // Offset from the first CU in the debug info section is 0 initially.
1979 unsigned SecOffset = 0;
1981 // Iterate over each compile unit and set the size and offsets for each
1982 // DIE within each compile unit. All offsets are CU relative.
1983 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1986 (*I)->setDebugInfoOffset(SecOffset);
1988 // CU-relative offset is reset to 0 here.
1989 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1990 (*I)->getHeaderSize(); // Unit-specific headers
1992 // EndOffset here is CU-relative, after laying out
1993 // all of the CU DIE.
1994 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1995 SecOffset += EndOffset;
1999 // Emit initial Dwarf sections with a label at the start of each one.
2000 void DwarfDebug::emitSectionLabels() {
2001 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2003 // Dwarf sections base addresses.
2004 DwarfInfoSectionSym =
2005 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2006 if (useSplitDwarf())
2007 DwarfInfoDWOSectionSym =
2008 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
2009 DwarfAbbrevSectionSym =
2010 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2011 if (useSplitDwarf())
2012 DwarfAbbrevDWOSectionSym = emitSectionSym(
2013 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
2014 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2016 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2017 emitSectionSym(Asm, MacroInfo);
2019 DwarfLineSectionSym =
2020 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2021 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2022 if (GenerateGnuPubSections) {
2023 DwarfGnuPubNamesSectionSym =
2024 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2025 DwarfGnuPubTypesSectionSym =
2026 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2027 } else if (HasDwarfPubSections) {
2028 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2029 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2032 DwarfStrSectionSym =
2033 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2034 if (useSplitDwarf()) {
2035 DwarfStrDWOSectionSym =
2036 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2037 DwarfAddrSectionSym =
2038 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2040 DwarfDebugRangeSectionSym =
2041 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2043 DwarfDebugLocSectionSym =
2044 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2047 // Recursively emits a debug information entry.
2048 void DwarfDebug::emitDIE(DIE *Die) {
2049 // Get the abbreviation for this DIE.
2050 const DIEAbbrev &Abbrev = Die->getAbbrev();
2052 // Emit the code (index) for the abbreviation.
2053 if (Asm->isVerbose())
2054 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2055 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2056 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2057 dwarf::TagString(Abbrev.getTag()));
2058 Asm->EmitULEB128(Abbrev.getNumber());
2060 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2061 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2063 // Emit the DIE attribute values.
2064 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2065 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2066 dwarf::Form Form = AbbrevData[i].getForm();
2067 assert(Form && "Too many attributes for DIE (check abbreviation)");
2069 if (Asm->isVerbose())
2070 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2073 case dwarf::DW_AT_abstract_origin:
2074 case dwarf::DW_AT_type:
2075 case dwarf::DW_AT_friend:
2076 case dwarf::DW_AT_specification:
2077 case dwarf::DW_AT_import:
2078 case dwarf::DW_AT_containing_type: {
2079 DIEEntry *E = cast<DIEEntry>(Values[i]);
2080 DIE *Origin = E->getEntry();
2081 unsigned Addr = Origin->getOffset();
2082 if (Form == dwarf::DW_FORM_ref_addr) {
2083 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2084 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2085 // section. Origin->getOffset() returns the offset from start of the
2087 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2088 assert(CU && "CUDie should belong to a CU.");
2089 Addr += CU->getDebugInfoOffset();
2090 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2091 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2092 DIEEntry::getRefAddrSize(Asm));
2094 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2095 CU->getSectionSym(),
2096 DIEEntry::getRefAddrSize(Asm));
2098 // Make sure Origin belong to the same CU.
2099 assert(Die->getUnit() == Origin->getUnit() &&
2100 "The referenced DIE should belong to the same CU in ref4");
2101 Asm->EmitInt32(Addr);
2105 case dwarf::DW_AT_location: {
2106 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2107 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2108 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2110 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2112 Values[i]->EmitValue(Asm, Form);
2116 case dwarf::DW_AT_accessibility: {
2117 if (Asm->isVerbose()) {
2118 DIEInteger *V = cast<DIEInteger>(Values[i]);
2119 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2121 Values[i]->EmitValue(Asm, Form);
2125 // Emit an attribute using the defined form.
2126 Values[i]->EmitValue(Asm, Form);
2131 // Emit the DIE children if any.
2132 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2133 const std::vector<DIE *> &Children = Die->getChildren();
2135 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2136 emitDIE(Children[j]);
2138 Asm->OutStreamer.AddComment("End Of Children Mark");
2143 // Emit the various dwarf units to the unit section USection with
2144 // the abbreviations going into ASection.
2145 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2146 const MCSymbol *ASectionSym) {
2147 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2149 DwarfUnit *TheU = *I;
2150 DIE *Die = TheU->getUnitDie();
2151 const MCSection *USection = TheU->getSection();
2152 Asm->OutStreamer.SwitchSection(USection);
2154 // Emit the compile units header.
2155 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2157 // Emit size of content not including length itself
2158 Asm->OutStreamer.AddComment("Length of Unit");
2159 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2161 TheU->emitHeader(ASection, ASectionSym);
2164 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2168 // Emit the debug info section.
2169 void DwarfDebug::emitDebugInfo() {
2170 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2172 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2173 DwarfAbbrevSectionSym);
2176 // Emit the abbreviation section.
2177 void DwarfDebug::emitAbbreviations() {
2178 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2180 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2183 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2184 // Check to see if it is worth the effort.
2185 if (!Abbreviations.empty()) {
2186 // Start the debug abbrev section.
2187 Asm->OutStreamer.SwitchSection(Section);
2189 // For each abbrevation.
2190 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2191 // Get abbreviation data
2192 const DIEAbbrev *Abbrev = Abbreviations[i];
2194 // Emit the abbrevations code (base 1 index.)
2195 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2197 // Emit the abbreviations data.
2201 // Mark end of abbreviations.
2202 Asm->EmitULEB128(0, "EOM(3)");
2206 // Emit the last address of the section and the end of the line matrix.
2207 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2208 // Define last address of section.
2209 Asm->OutStreamer.AddComment("Extended Op");
2212 Asm->OutStreamer.AddComment("Op size");
2213 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2214 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2215 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2217 Asm->OutStreamer.AddComment("Section end label");
2219 Asm->OutStreamer.EmitSymbolValue(
2220 Asm->GetTempSymbol("section_end", SectionEnd),
2221 Asm->getDataLayout().getPointerSize());
2223 // Mark end of matrix.
2224 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2230 // Emit visible names into a hashed accelerator table section.
2231 void DwarfDebug::emitAccelNames() {
2233 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2234 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2235 E = getUnits().end();
2237 DwarfUnit *TheU = *I;
2238 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2239 for (StringMap<std::vector<const DIE *> >::const_iterator
2243 StringRef Name = GI->getKey();
2244 const std::vector<const DIE *> &Entities = GI->second;
2245 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2246 DE = Entities.end();
2248 AT.AddName(Name, *DI);
2252 AT.FinalizeTable(Asm, "Names");
2253 Asm->OutStreamer.SwitchSection(
2254 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2255 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2256 Asm->OutStreamer.EmitLabel(SectionBegin);
2258 // Emit the full data.
2259 AT.Emit(Asm, SectionBegin, &InfoHolder);
2262 // Emit objective C classes and categories into a hashed accelerator table
2264 void DwarfDebug::emitAccelObjC() {
2266 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2267 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2268 E = getUnits().end();
2270 DwarfUnit *TheU = *I;
2271 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2272 for (StringMap<std::vector<const DIE *> >::const_iterator
2276 StringRef Name = GI->getKey();
2277 const std::vector<const DIE *> &Entities = GI->second;
2278 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2279 DE = Entities.end();
2281 AT.AddName(Name, *DI);
2285 AT.FinalizeTable(Asm, "ObjC");
2286 Asm->OutStreamer.SwitchSection(
2287 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2288 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2289 Asm->OutStreamer.EmitLabel(SectionBegin);
2291 // Emit the full data.
2292 AT.Emit(Asm, SectionBegin, &InfoHolder);
2295 // Emit namespace dies into a hashed accelerator table.
2296 void DwarfDebug::emitAccelNamespaces() {
2298 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2299 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2300 E = getUnits().end();
2302 DwarfUnit *TheU = *I;
2303 const StringMap<std::vector<const DIE *> > &Names =
2304 TheU->getAccelNamespace();
2305 for (StringMap<std::vector<const DIE *> >::const_iterator
2309 StringRef Name = GI->getKey();
2310 const std::vector<const DIE *> &Entities = GI->second;
2311 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2312 DE = Entities.end();
2314 AT.AddName(Name, *DI);
2318 AT.FinalizeTable(Asm, "namespac");
2319 Asm->OutStreamer.SwitchSection(
2320 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2321 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2322 Asm->OutStreamer.EmitLabel(SectionBegin);
2324 // Emit the full data.
2325 AT.Emit(Asm, SectionBegin, &InfoHolder);
2328 // Emit type dies into a hashed accelerator table.
2329 void DwarfDebug::emitAccelTypes() {
2330 std::vector<DwarfAccelTable::Atom> Atoms;
2332 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2334 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2336 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2337 DwarfAccelTable AT(Atoms);
2338 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2339 E = getUnits().end();
2341 DwarfUnit *TheU = *I;
2342 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2343 TheU->getAccelTypes();
2345 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2349 StringRef Name = GI->getKey();
2350 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2352 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2353 DI = Entities.begin(),
2354 DE = Entities.end();
2356 AT.AddName(Name, DI->first, DI->second);
2360 AT.FinalizeTable(Asm, "types");
2361 Asm->OutStreamer.SwitchSection(
2362 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2363 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2364 Asm->OutStreamer.EmitLabel(SectionBegin);
2366 // Emit the full data.
2367 AT.Emit(Asm, SectionBegin, &InfoHolder);
2370 // Public name handling.
2371 // The format for the various pubnames:
2373 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2374 // for the DIE that is named.
2376 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2377 // into the CU and the index value is computed according to the type of value
2378 // for the DIE that is named.
2380 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2381 // it's the offset within the debug_info/debug_types dwo section, however, the
2382 // reference in the pubname header doesn't change.
2384 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2385 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2387 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2389 // We could have a specification DIE that has our most of our knowledge,
2390 // look for that now.
2391 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2393 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2394 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2395 Linkage = dwarf::GIEL_EXTERNAL;
2396 } else if (Die->findAttribute(dwarf::DW_AT_external))
2397 Linkage = dwarf::GIEL_EXTERNAL;
2399 switch (Die->getTag()) {
2400 case dwarf::DW_TAG_class_type:
2401 case dwarf::DW_TAG_structure_type:
2402 case dwarf::DW_TAG_union_type:
2403 case dwarf::DW_TAG_enumeration_type:
2404 return dwarf::PubIndexEntryDescriptor(
2405 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2406 ? dwarf::GIEL_STATIC
2407 : dwarf::GIEL_EXTERNAL);
2408 case dwarf::DW_TAG_typedef:
2409 case dwarf::DW_TAG_base_type:
2410 case dwarf::DW_TAG_subrange_type:
2411 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2412 case dwarf::DW_TAG_namespace:
2413 return dwarf::GIEK_TYPE;
2414 case dwarf::DW_TAG_subprogram:
2415 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2416 case dwarf::DW_TAG_constant:
2417 case dwarf::DW_TAG_variable:
2418 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2419 case dwarf::DW_TAG_enumerator:
2420 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2421 dwarf::GIEL_STATIC);
2423 return dwarf::GIEK_NONE;
2427 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2429 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2430 const MCSection *PSec =
2431 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2432 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2434 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2435 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2436 for (unsigned i = 0; i != Units.size(); ++i) {
2437 DwarfUnit *TheU = Units[i];
2438 unsigned ID = TheU->getUniqueID();
2440 // Start the dwarf pubnames section.
2441 Asm->OutStreamer.SwitchSection(PSec);
2443 // Emit a label so we can reference the beginning of this pubname section.
2445 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2448 Asm->OutStreamer.AddComment("Length of Public Names Info");
2449 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2450 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2451 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2453 Asm->OutStreamer.EmitLabel(BeginLabel);
2455 Asm->OutStreamer.AddComment("DWARF Version");
2456 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2458 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2459 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2461 Asm->OutStreamer.AddComment("Compilation Unit Length");
2462 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2464 // Emit the pubnames for this compilation unit.
2465 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2466 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2469 const char *Name = GI->getKeyData();
2470 const DIE *Entity = GI->second;
2472 Asm->OutStreamer.AddComment("DIE offset");
2473 Asm->EmitInt32(Entity->getOffset());
2476 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2477 Asm->OutStreamer.AddComment(
2478 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2479 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2480 Asm->EmitInt8(Desc.toBits());
2483 Asm->OutStreamer.AddComment("External Name");
2484 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2487 Asm->OutStreamer.AddComment("End Mark");
2489 Asm->OutStreamer.EmitLabel(EndLabel);
2493 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2494 const MCSection *PSec =
2495 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2496 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2498 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2499 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2500 for (unsigned i = 0; i != Units.size(); ++i) {
2501 DwarfUnit *TheU = Units[i];
2502 unsigned ID = TheU->getUniqueID();
2504 // Start the dwarf pubtypes section.
2505 Asm->OutStreamer.SwitchSection(PSec);
2507 // Emit a label so we can reference the beginning of this pubtype section.
2509 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2512 Asm->OutStreamer.AddComment("Length of Public Types Info");
2513 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2514 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2515 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2517 Asm->OutStreamer.EmitLabel(BeginLabel);
2519 Asm->OutStreamer.AddComment("DWARF Version");
2520 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2522 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2523 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2525 Asm->OutStreamer.AddComment("Compilation Unit Length");
2526 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2528 // Emit the pubtypes.
2529 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2530 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2533 const char *Name = GI->getKeyData();
2534 const DIE *Entity = GI->second;
2536 Asm->OutStreamer.AddComment("DIE offset");
2537 Asm->EmitInt32(Entity->getOffset());
2540 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2541 Asm->OutStreamer.AddComment(
2542 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2543 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2544 Asm->EmitInt8(Desc.toBits());
2547 Asm->OutStreamer.AddComment("External Name");
2549 // Emit the name with a terminating null byte.
2550 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2553 Asm->OutStreamer.AddComment("End Mark");
2555 Asm->OutStreamer.EmitLabel(EndLabel);
2559 // Emit strings into a string section.
2560 void DwarfFile::emitStrings(const MCSection *StrSection,
2561 const MCSection *OffsetSection = NULL,
2562 const MCSymbol *StrSecSym = NULL) {
2564 if (StringPool.empty())
2567 // Start the dwarf str section.
2568 Asm->OutStreamer.SwitchSection(StrSection);
2570 // Get all of the string pool entries and put them in an array by their ID so
2571 // we can sort them.
2573 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2576 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2577 I = StringPool.begin(),
2578 E = StringPool.end();
2580 Entries.push_back(std::make_pair(I->second.second, &*I));
2582 array_pod_sort(Entries.begin(), Entries.end());
2584 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2585 // Emit a label for reference from debug information entries.
2586 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2588 // Emit the string itself with a terminating null byte.
2589 Asm->OutStreamer.EmitBytes(
2590 StringRef(Entries[i].second->getKeyData(),
2591 Entries[i].second->getKeyLength() + 1));
2594 // If we've got an offset section go ahead and emit that now as well.
2595 if (OffsetSection) {
2596 Asm->OutStreamer.SwitchSection(OffsetSection);
2597 unsigned offset = 0;
2598 unsigned size = 4; // FIXME: DWARF64 is 8.
2599 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2600 Asm->OutStreamer.EmitIntValue(offset, size);
2601 offset += Entries[i].second->getKeyLength() + 1;
2606 // Emit addresses into the section given.
2607 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2609 if (AddressPool.empty())
2612 // Start the dwarf addr section.
2613 Asm->OutStreamer.SwitchSection(AddrSection);
2615 // Order the address pool entries by ID
2616 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2618 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2619 E = AddressPool.end();
2621 Entries[I->second] = I->first;
2623 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2624 // Emit an expression for reference from debug information entries.
2625 if (const MCExpr *Expr = Entries[i])
2626 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2628 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2632 // Emit visible names into a debug str section.
2633 void DwarfDebug::emitDebugStr() {
2634 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2635 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2638 // Emit locations into the debug loc section.
2639 void DwarfDebug::emitDebugLoc() {
2640 if (DotDebugLocEntries.empty())
2643 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2644 I = DotDebugLocEntries.begin(),
2645 E = DotDebugLocEntries.end();
2647 DotDebugLocEntry &Entry = *I;
2648 if (I + 1 != DotDebugLocEntries.end())
2652 // Start the dwarf loc section.
2653 Asm->OutStreamer.SwitchSection(
2654 Asm->getObjFileLowering().getDwarfLocSection());
2655 unsigned char Size = Asm->getDataLayout().getPointerSize();
2656 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2658 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2659 I = DotDebugLocEntries.begin(),
2660 E = DotDebugLocEntries.end();
2661 I != E; ++I, ++index) {
2662 DotDebugLocEntry &Entry = *I;
2663 if (Entry.isMerged())
2665 if (Entry.isEmpty()) {
2666 Asm->OutStreamer.EmitIntValue(0, Size);
2667 Asm->OutStreamer.EmitIntValue(0, Size);
2668 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2670 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2671 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2672 DIVariable DV(Entry.getVariable());
2673 Asm->OutStreamer.AddComment("Loc expr size");
2674 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2675 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2676 Asm->EmitLabelDifference(end, begin, 2);
2677 Asm->OutStreamer.EmitLabel(begin);
2678 if (Entry.isInt()) {
2679 DIBasicType BTy(DV.getType());
2680 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2681 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2682 Asm->OutStreamer.AddComment("DW_OP_consts");
2683 Asm->EmitInt8(dwarf::DW_OP_consts);
2684 Asm->EmitSLEB128(Entry.getInt());
2686 Asm->OutStreamer.AddComment("DW_OP_constu");
2687 Asm->EmitInt8(dwarf::DW_OP_constu);
2688 Asm->EmitULEB128(Entry.getInt());
2690 } else if (Entry.isLocation()) {
2691 MachineLocation Loc = Entry.getLoc();
2692 if (!DV.hasComplexAddress())
2694 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2696 // Complex address entry.
2697 unsigned N = DV.getNumAddrElements();
2699 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2700 if (Loc.getOffset()) {
2702 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2703 Asm->OutStreamer.AddComment("DW_OP_deref");
2704 Asm->EmitInt8(dwarf::DW_OP_deref);
2705 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2706 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2707 Asm->EmitSLEB128(DV.getAddrElement(1));
2709 // If first address element is OpPlus then emit
2710 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2711 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2712 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2716 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2719 // Emit remaining complex address elements.
2720 for (; i < N; ++i) {
2721 uint64_t Element = DV.getAddrElement(i);
2722 if (Element == DIBuilder::OpPlus) {
2723 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2724 Asm->EmitULEB128(DV.getAddrElement(++i));
2725 } else if (Element == DIBuilder::OpDeref) {
2727 Asm->EmitInt8(dwarf::DW_OP_deref);
2729 llvm_unreachable("unknown Opcode found in complex address");
2733 // else ... ignore constant fp. There is not any good way to
2734 // to represent them here in dwarf.
2735 Asm->OutStreamer.EmitLabel(end);
2740 struct SymbolCUSorter {
2741 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2742 const MCStreamer &Streamer;
2744 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2745 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2746 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2748 // Symbols with no order assigned should be placed at the end.
2749 // (e.g. section end labels)
2751 IA = (unsigned)(-1);
2753 IB = (unsigned)(-1);
2758 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2759 return (A->getUniqueID() < B->getUniqueID());
2763 const MCSymbol *Start, *End;
2766 // Emit a debug aranges section, containing a CU lookup for any
2767 // address we can tie back to a CU.
2768 void DwarfDebug::emitDebugARanges() {
2769 // Start the dwarf aranges section.
2770 Asm->OutStreamer.SwitchSection(
2771 Asm->getObjFileLowering().getDwarfARangesSection());
2773 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2777 // Build a list of sections used.
2778 std::vector<const MCSection *> Sections;
2779 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2781 const MCSection *Section = it->first;
2782 Sections.push_back(Section);
2785 // Sort the sections into order.
2786 // This is only done to ensure consistent output order across different runs.
2787 std::sort(Sections.begin(), Sections.end(), SectionSort);
2789 // Build a set of address spans, sorted by CU.
2790 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2791 const MCSection *Section = Sections[SecIdx];
2792 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2793 if (List.size() < 2)
2796 // Sort the symbols by offset within the section.
2797 SymbolCUSorter sorter(Asm->OutStreamer);
2798 std::sort(List.begin(), List.end(), sorter);
2800 // If we have no section (e.g. common), just write out
2801 // individual spans for each symbol.
2802 if (Section == NULL) {
2803 for (size_t n = 0; n < List.size(); n++) {
2804 const SymbolCU &Cur = List[n];
2807 Span.Start = Cur.Sym;
2810 Spans[Cur.CU].push_back(Span);
2813 // Build spans between each label.
2814 const MCSymbol *StartSym = List[0].Sym;
2815 for (size_t n = 1; n < List.size(); n++) {
2816 const SymbolCU &Prev = List[n - 1];
2817 const SymbolCU &Cur = List[n];
2819 // Try and build the longest span we can within the same CU.
2820 if (Cur.CU != Prev.CU) {
2822 Span.Start = StartSym;
2824 Spans[Prev.CU].push_back(Span);
2831 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2833 // Build a list of CUs used.
2834 std::vector<DwarfCompileUnit *> CUs;
2835 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2836 DwarfCompileUnit *CU = it->first;
2840 // Sort the CU list (again, to ensure consistent output order).
2841 std::sort(CUs.begin(), CUs.end(), CUSort);
2843 // Emit an arange table for each CU we used.
2844 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2845 DwarfCompileUnit *CU = CUs[CUIdx];
2846 std::vector<ArangeSpan> &List = Spans[CU];
2848 // Emit size of content not including length itself.
2849 unsigned ContentSize =
2850 sizeof(int16_t) + // DWARF ARange version number
2851 sizeof(int32_t) + // Offset of CU in the .debug_info section
2852 sizeof(int8_t) + // Pointer Size (in bytes)
2853 sizeof(int8_t); // Segment Size (in bytes)
2855 unsigned TupleSize = PtrSize * 2;
2857 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2858 unsigned Padding = 0;
2859 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2862 ContentSize += Padding;
2863 ContentSize += (List.size() + 1) * TupleSize;
2865 // For each compile unit, write the list of spans it covers.
2866 Asm->OutStreamer.AddComment("Length of ARange Set");
2867 Asm->EmitInt32(ContentSize);
2868 Asm->OutStreamer.AddComment("DWARF Arange version number");
2869 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2870 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2871 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2872 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2873 Asm->EmitInt8(PtrSize);
2874 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2877 for (unsigned n = 0; n < Padding; n++)
2878 Asm->EmitInt8(0xff);
2880 for (unsigned n = 0; n < List.size(); n++) {
2881 const ArangeSpan &Span = List[n];
2882 Asm->EmitLabelReference(Span.Start, PtrSize);
2884 // Calculate the size as being from the span start to it's end.
2886 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2888 // For symbols without an end marker (e.g. common), we
2889 // write a single arange entry containing just that one symbol.
2890 uint64_t Size = SymSize[Span.Start];
2894 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2898 Asm->OutStreamer.AddComment("ARange terminator");
2899 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2900 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2904 // Emit visible names into a debug ranges section.
2905 void DwarfDebug::emitDebugRanges() {
2906 // Start the dwarf ranges section.
2907 Asm->OutStreamer.SwitchSection(
2908 Asm->getObjFileLowering().getDwarfRangesSection());
2910 // Size for our labels.
2911 unsigned char Size = Asm->getDataLayout().getPointerSize();
2913 // Grab the specific ranges for the compile units in the module.
2914 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2917 DwarfCompileUnit *TheCU = I->second;
2919 // Emit a symbol so we can find the beginning of our ranges.
2920 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2922 // Iterate over the misc ranges for the compile units in the module.
2923 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2924 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2925 E = RangeLists.end();
2927 const RangeSpanList &List = *I;
2929 // Emit our symbol so we can find the beginning of the range.
2930 Asm->OutStreamer.EmitLabel(List.getSym());
2932 for (SmallVectorImpl<RangeSpan>::const_iterator
2933 RI = List.getRanges().begin(),
2934 RE = List.getRanges().end();
2936 const RangeSpan &Range = *RI;
2937 const MCSymbol *Begin = Range.getStart();
2938 const MCSymbol *End = Range.getEnd();
2939 assert(Begin && "Range without a begin symbol?");
2940 assert(End && "Range without an end symbol?");
2941 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2942 Asm->OutStreamer.EmitSymbolValue(End, Size);
2945 // And terminate the list with two 0 values.
2946 Asm->OutStreamer.EmitIntValue(0, Size);
2947 Asm->OutStreamer.EmitIntValue(0, Size);
2950 // Now emit a range for the CU itself.
2951 if (DwarfCURanges) {
2952 Asm->OutStreamer.EmitLabel(
2953 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2954 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2955 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2956 RangeSpan Range = Ranges[i];
2957 const MCSymbol *Begin = Range.getStart();
2958 const MCSymbol *End = Range.getEnd();
2959 assert(Begin && "Range without a begin symbol?");
2960 assert(End && "Range without an end symbol?");
2961 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2962 Asm->OutStreamer.EmitSymbolValue(End, Size);
2964 // And terminate the list with two 0 values.
2965 Asm->OutStreamer.EmitIntValue(0, Size);
2966 Asm->OutStreamer.EmitIntValue(0, Size);
2971 // DWARF5 Experimental Separate Dwarf emitters.
2973 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2974 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2975 // DW_AT_ranges_base, DW_AT_addr_base.
2976 // TODO: Implement DW_AT_ranges_base.
2977 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2979 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2980 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2981 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2982 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2983 DwarfInfoSectionSym);
2985 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2986 CU->getNode().getSplitDebugFilename());
2988 // Relocate to the beginning of the addr_base section, else 0 for the
2989 // beginning of the one for this compile unit.
2990 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2991 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2992 DwarfAddrSectionSym);
2994 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2996 // DW_AT_stmt_list is a offset of line number information for this
2997 // compile unit in debug_line section.
2998 // FIXME: Should handle multiple compile units.
2999 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3000 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3002 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3004 if (!CompilationDir.empty())
3005 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3007 addGnuPubAttributes(NewCU, Die);
3009 SkeletonHolder.addUnit(NewCU);
3014 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3015 // compile units that would normally be in debug_info.
3016 void DwarfDebug::emitDebugInfoDWO() {
3017 assert(useSplitDwarf() && "No split dwarf debug info?");
3018 InfoHolder.emitUnits(this,
3019 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3020 DwarfAbbrevDWOSectionSym);
3023 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3024 // abbreviations for the .debug_info.dwo section.
3025 void DwarfDebug::emitDebugAbbrevDWO() {
3026 assert(useSplitDwarf() && "No split dwarf?");
3027 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3030 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3031 // string section and is identical in format to traditional .debug_str
3033 void DwarfDebug::emitDebugStrDWO() {
3034 assert(useSplitDwarf() && "No split dwarf?");
3035 const MCSection *OffSec =
3036 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3037 const MCSymbol *StrSym = DwarfStrSectionSym;
3038 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3042 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3043 DICompositeType CTy) {
3044 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3046 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3047 DwarfTypeUnit *NewTU =
3048 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3051 InfoHolder.addUnit(NewTU);
3053 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3056 DIE *Die = NewTU->createTypeDIE(CTy);
3058 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3059 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3060 dwarf::DW_FORM_data8,
3061 DIEHash().computeDIEODRSignature(*Die));
3062 // FIXME: This won't handle circularly referential structures, as the DIE
3063 // may have references to other DIEs still under construction and missing
3064 // their signature. Hashing should walk through the signatures to their
3065 // referenced type, or possibly walk the precomputed hashes of related types
3067 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3068 NewTU->setTypeSignature(Signature);
3069 NewTU->setType(Die);
3073 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3074 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3077 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);