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."),
112 static const char *const DWARFGroupName = "DWARF Emission";
113 static const char *const DbgTimerName = "DWARF Debug Writer";
115 //===----------------------------------------------------------------------===//
119 /// resolve - Look in the DwarfDebug map for the MDNode that
120 /// corresponds to the reference.
121 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
122 return DD->resolve(Ref);
125 DIType DbgVariable::getType() const {
126 DIType Ty = Var.getType();
127 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
128 // addresses instead.
129 if (Var.isBlockByrefVariable()) {
130 /* Byref variables, in Blocks, are declared by the programmer as
131 "SomeType VarName;", but the compiler creates a
132 __Block_byref_x_VarName struct, and gives the variable VarName
133 either the struct, or a pointer to the struct, as its type. This
134 is necessary for various behind-the-scenes things the compiler
135 needs to do with by-reference variables in blocks.
137 However, as far as the original *programmer* is concerned, the
138 variable should still have type 'SomeType', as originally declared.
140 The following function dives into the __Block_byref_x_VarName
141 struct to find the original type of the variable. This will be
142 passed back to the code generating the type for the Debug
143 Information Entry for the variable 'VarName'. 'VarName' will then
144 have the original type 'SomeType' in its debug information.
146 The original type 'SomeType' will be the type of the field named
147 'VarName' inside the __Block_byref_x_VarName struct.
149 NOTE: In order for this to not completely fail on the debugger
150 side, the Debug Information Entry for the variable VarName needs to
151 have a DW_AT_location that tells the debugger how to unwind through
152 the pointers and __Block_byref_x_VarName struct to find the actual
153 value of the variable. The function addBlockByrefType does this. */
155 uint16_t tag = Ty.getTag();
157 if (tag == dwarf::DW_TAG_pointer_type)
158 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
160 DIArray Elements = DICompositeType(subType).getTypeArray();
161 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
162 DIDerivedType DT(Elements.getElement(i));
163 if (getName() == DT.getName())
164 return (resolve(DT.getTypeDerivedFrom()));
170 } // end llvm namespace
172 /// Return Dwarf Version by checking module flags.
173 static unsigned getDwarfVersionFromModule(const Module *M) {
174 Value *Val = M->getModuleFlag("Dwarf Version");
176 return dwarf::DWARF_VERSION;
177 return cast<ConstantInt>(Val)->getZExtValue();
180 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
181 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
182 PrevLabel(NULL), GlobalCUIndexCount(0), GlobalRangeCount(0),
183 InfoHolder(A, "info_string", DIEValueAllocator),
184 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
186 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
187 DwarfStrSectionSym = TextSectionSym = 0;
188 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
189 DwarfAddrSectionSym = 0;
190 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
191 FunctionBeginSym = FunctionEndSym = 0;
192 CurFn = 0; CurMI = 0;
194 // Turn on accelerator tables for Darwin by default, pubnames by
195 // default for non-Darwin, and handle split dwarf.
196 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
198 if (DwarfAccelTables == Default)
199 HasDwarfAccelTables = IsDarwin;
201 HasDwarfAccelTables = DwarfAccelTables == Enable;
203 if (SplitDwarf == Default)
204 HasSplitDwarf = false;
206 HasSplitDwarf = SplitDwarf == Enable;
208 if (DwarfPubSections == Default)
209 HasDwarfPubSections = !IsDarwin;
211 HasDwarfPubSections = DwarfPubSections == Enable;
213 DwarfVersion = DwarfVersionNumber
215 : getDwarfVersionFromModule(MMI->getModule());
218 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
223 // Switch to the specified MCSection and emit an assembler
224 // temporary label to it if SymbolStem is specified.
225 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
226 const char *SymbolStem = 0) {
227 Asm->OutStreamer.SwitchSection(Section);
231 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
232 Asm->OutStreamer.EmitLabel(TmpSym);
236 DwarfUnits::~DwarfUnits() {
237 for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
242 MCSymbol *DwarfUnits::getStringPoolSym() {
243 return Asm->GetTempSymbol(StringPref);
246 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
247 std::pair<MCSymbol *, unsigned> &Entry =
248 StringPool.GetOrCreateValue(Str).getValue();
252 Entry.second = NextStringPoolNumber++;
253 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
256 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
257 std::pair<MCSymbol *, unsigned> &Entry =
258 StringPool.GetOrCreateValue(Str).getValue();
262 Entry.second = NextStringPoolNumber++;
263 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
267 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
268 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
271 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
272 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
273 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
275 ++NextAddrPoolNumber;
276 return P.first->second;
279 // Define a unique number for the abbreviation.
281 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
282 // Check the set for priors.
283 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
285 // If it's newly added.
286 if (InSet == &Abbrev) {
287 // Add to abbreviation list.
288 Abbreviations.push_back(&Abbrev);
290 // Assign the vector position + 1 as its number.
291 Abbrev.setNumber(Abbreviations.size());
293 // Assign existing abbreviation number.
294 Abbrev.setNumber(InSet->getNumber());
298 static bool isObjCClass(StringRef Name) {
299 return Name.startswith("+") || Name.startswith("-");
302 static bool hasObjCCategory(StringRef Name) {
303 if (!isObjCClass(Name))
306 return Name.find(") ") != StringRef::npos;
309 static void getObjCClassCategory(StringRef In, StringRef &Class,
310 StringRef &Category) {
311 if (!hasObjCCategory(In)) {
312 Class = In.slice(In.find('[') + 1, In.find(' '));
317 Class = In.slice(In.find('[') + 1, In.find('('));
318 Category = In.slice(In.find('[') + 1, In.find(' '));
322 static StringRef getObjCMethodName(StringRef In) {
323 return In.slice(In.find(' ') + 1, In.find(']'));
326 // Helper for sorting sections into a stable output order.
327 static bool SectionSort(const MCSection *A, const MCSection *B) {
328 std::string LA = (A ? A->getLabelBeginName() : "");
329 std::string LB = (B ? B->getLabelBeginName() : "");
333 // Add the various names to the Dwarf accelerator table names.
334 // TODO: Determine whether or not we should add names for programs
335 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
336 // is only slightly different than the lookup of non-standard ObjC names.
337 static void addSubprogramNames(Unit *TheU, DISubprogram SP, DIE *Die) {
338 if (!SP.isDefinition())
340 TheU->addAccelName(SP.getName(), Die);
342 // If the linkage name is different than the name, go ahead and output
343 // that as well into the name table.
344 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
345 TheU->addAccelName(SP.getLinkageName(), Die);
347 // If this is an Objective-C selector name add it to the ObjC accelerator
349 if (isObjCClass(SP.getName())) {
350 StringRef Class, Category;
351 getObjCClassCategory(SP.getName(), Class, Category);
352 TheU->addAccelObjC(Class, Die);
354 TheU->addAccelObjC(Category, Die);
355 // Also add the base method name to the name table.
356 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
360 /// isSubprogramContext - Return true if Context is either a subprogram
361 /// or another context nested inside a subprogram.
362 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
365 DIDescriptor D(Context);
366 if (D.isSubprogram())
369 return isSubprogramContext(resolve(DIType(Context).getContext()));
373 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
374 // and DW_AT_high_pc attributes. If there are global variables in this
375 // scope then create and insert DIEs for these variables.
376 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DISubprogram SP) {
377 DIE *SPDie = SPCU->getDIE(SP);
379 assert(SPDie && "Unable to find subprogram DIE!");
381 // If we're updating an abstract DIE, then we will be adding the children and
382 // object pointer later on. But what we don't want to do is process the
383 // concrete DIE twice.
384 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
385 // Pick up abstract subprogram DIE.
387 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
388 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
390 DISubprogram SPDecl = SP.getFunctionDeclaration();
391 if (!SPDecl.isSubprogram()) {
392 // There is not any need to generate specification DIE for a function
393 // defined at compile unit level. If a function is defined inside another
394 // function then gdb prefers the definition at top level and but does not
395 // expect specification DIE in parent function. So avoid creating
396 // specification DIE for a function defined inside a function.
397 DIScope SPContext = resolve(SP.getContext());
398 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
399 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
400 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
403 DICompositeType SPTy = SP.getType();
404 DIArray Args = SPTy.getTypeArray();
405 uint16_t SPTag = SPTy.getTag();
406 if (SPTag == dwarf::DW_TAG_subroutine_type)
407 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
409 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
410 DIType ATy(Args.getElement(i));
411 SPCU->addType(Arg, ATy);
412 if (ATy.isArtificial())
413 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
414 if (ATy.isObjectPointer())
415 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
417 DIE *SPDeclDie = SPDie;
418 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
419 *SPCU->getUnitDie());
420 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
425 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
426 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
428 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
429 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
430 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
432 // Add name to the name table, we do this here because we're guaranteed
433 // to have concrete versions of our DW_TAG_subprogram nodes.
434 addSubprogramNames(SPCU, SP, SPDie);
439 /// Check whether we should create a DIE for the given Scope, return true
440 /// if we don't create a DIE (the corresponding DIE is null).
441 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
442 if (Scope->isAbstractScope())
445 // We don't create a DIE if there is no Range.
446 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
450 if (Ranges.size() > 1)
453 // We don't create a DIE if we have a single Range and the end label
455 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
456 MCSymbol *End = getLabelAfterInsn(RI->second);
460 static void addSectionLabel(AsmPrinter *Asm, Unit *U, DIE *D,
461 dwarf::Attribute A, const MCSymbol *L,
462 const MCSymbol *Sec) {
463 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
464 U->addSectionLabel(D, A, L);
466 U->addSectionDelta(D, A, L, Sec);
469 void DwarfDebug::addScopeRangeList(CompileUnit *TheCU, DIE *ScopeDIE,
470 const SmallVectorImpl<InsnRange> &Range) {
471 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
472 // emitting it appropriately.
473 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
474 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
475 DwarfDebugRangeSectionSym);
477 RangeSpanList List(RangeSym);
478 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
481 RangeSpan Span(getLabelBeforeInsn(RI->first),
482 getLabelAfterInsn(RI->second));
483 List.addRange(llvm_move(Span));
486 // Add the range list to the set of ranges to be emitted.
487 TheCU->addRangeList(llvm_move(List));
490 // Construct new DW_TAG_lexical_block for this scope and attach
491 // DW_AT_low_pc/DW_AT_high_pc labels.
492 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
493 LexicalScope *Scope) {
494 if (isLexicalScopeDIENull(Scope))
497 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
498 if (Scope->isAbstractScope())
501 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
503 // If we have multiple ranges, emit them into the range section.
504 if (ScopeRanges.size() > 1) {
505 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
509 // Construct the address range for this DIE.
510 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
511 MCSymbol *Start = getLabelBeforeInsn(RI->first);
512 MCSymbol *End = getLabelAfterInsn(RI->second);
513 assert(End && "End label should not be null!");
515 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
516 assert(End->isDefined() && "Invalid end label for an inlined scope!");
518 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
519 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
524 // This scope represents inlined body of a function. Construct DIE to
525 // represent this concrete inlined copy of the function.
526 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
527 LexicalScope *Scope) {
528 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
529 assert(!ScopeRanges.empty() &&
530 "LexicalScope does not have instruction markers!");
532 if (!Scope->getScopeNode())
534 DIScope DS(Scope->getScopeNode());
535 DISubprogram InlinedSP = getDISubprogram(DS);
536 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
538 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
542 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
543 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
545 // If we have multiple ranges, emit them into the range section.
546 if (ScopeRanges.size() > 1)
547 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
549 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
550 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
551 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
553 if (StartLabel == 0 || EndLabel == 0)
554 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
556 assert(StartLabel->isDefined() &&
557 "Invalid starting label for an inlined scope!");
558 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
560 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
561 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
564 InlinedSubprogramDIEs.insert(OriginDIE);
566 // Add the call site information to the DIE.
567 DILocation DL(Scope->getInlinedAt());
568 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
569 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
570 TheCU->getUniqueID()));
571 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
573 // Add name to the name table, we do this here because we're guaranteed
574 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
575 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
580 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
581 SmallVectorImpl<DIE *> &Children) {
582 DIE *ObjectPointer = NULL;
584 // Collect arguments for current function.
585 if (LScopes.isCurrentFunctionScope(Scope))
586 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
587 if (DbgVariable *ArgDV = CurrentFnArguments[i])
589 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
590 Children.push_back(Arg);
591 if (ArgDV->isObjectPointer())
595 // Collect lexical scope children first.
596 const SmallVectorImpl<DbgVariable *> &Variables =
597 ScopeVariables.lookup(Scope);
598 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
599 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
600 Scope->isAbstractScope())) {
601 Children.push_back(Variable);
602 if (Variables[i]->isObjectPointer())
603 ObjectPointer = Variable;
605 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
606 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
607 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
608 Children.push_back(Nested);
609 return ObjectPointer;
612 // Construct a DIE for this scope.
613 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
614 if (!Scope || !Scope->getScopeNode())
617 DIScope DS(Scope->getScopeNode());
619 SmallVector<DIE *, 8> Children;
620 DIE *ObjectPointer = NULL;
621 bool ChildrenCreated = false;
623 // We try to create the scope DIE first, then the children DIEs. This will
624 // avoid creating un-used children then removing them later when we find out
625 // the scope DIE is null.
626 DIE *ScopeDIE = NULL;
627 if (Scope->getInlinedAt())
628 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
629 else if (DS.isSubprogram()) {
630 ProcessedSPNodes.insert(DS);
631 if (Scope->isAbstractScope()) {
632 ScopeDIE = TheCU->getDIE(DS);
633 // Note down abstract DIE.
635 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
637 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
639 // Early exit when we know the scope DIE is going to be null.
640 if (isLexicalScopeDIENull(Scope))
643 // We create children here when we know the scope DIE is not going to be
644 // null and the children will be added to the scope DIE.
645 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
646 ChildrenCreated = true;
648 // There is no need to emit empty lexical block DIE.
649 std::pair<ImportedEntityMap::const_iterator,
650 ImportedEntityMap::const_iterator> Range =
652 ScopesWithImportedEntities.begin(),
653 ScopesWithImportedEntities.end(),
654 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
656 if (Children.empty() && Range.first == Range.second)
658 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
659 assert(ScopeDIE && "Scope DIE should not be null.");
660 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
662 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
666 assert(Children.empty() &&
667 "We create children only when the scope DIE is not null.");
670 if (!ChildrenCreated)
671 // We create children when the scope DIE is not null.
672 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
675 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
678 ScopeDIE->addChild(*I);
680 if (DS.isSubprogram() && ObjectPointer != NULL)
681 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
686 // Look up the source id with the given directory and source file names.
687 // If none currently exists, create a new id and insert it in the
688 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
690 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
692 // If we use .loc in assembly, we can't separate .file entries according to
693 // compile units. Thus all files will belong to the default compile unit.
695 // FIXME: add a better feature test than hasRawTextSupport. Even better,
696 // extend .file to support this.
697 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
700 // If FE did not provide a file name, then assume stdin.
701 if (FileName.empty())
702 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
704 // TODO: this might not belong here. See if we can factor this better.
705 if (DirName == CompilationDir)
708 // FileIDCUMap stores the current ID for the given compile unit.
709 unsigned SrcId = FileIDCUMap[CUID] + 1;
711 // We look up the CUID/file/dir by concatenating them with a zero byte.
712 SmallString<128> NamePair;
713 NamePair += utostr(CUID);
716 NamePair += '\0'; // Zero bytes are not allowed in paths.
717 NamePair += FileName;
719 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
720 if (Ent.getValue() != SrcId)
721 return Ent.getValue();
723 FileIDCUMap[CUID] = SrcId;
724 // Print out a .file directive to specify files for .loc directives.
725 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
730 void DwarfDebug::addGnuPubAttributes(Unit *U, DIE *D) const {
731 if (!GenerateGnuPubSections)
734 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
735 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
736 DwarfGnuPubNamesSectionSym);
738 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
739 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
740 DwarfGnuPubTypesSectionSym);
743 // Create new CompileUnit for the given metadata node with tag
744 // DW_TAG_compile_unit.
745 CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
746 StringRef FN = DIUnit.getFilename();
747 CompilationDir = DIUnit.getDirectory();
749 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
750 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++, Die, DIUnit, Asm,
753 FileIDCUMap[NewCU->getUniqueID()] = 0;
754 // Call this to emit a .file directive if it wasn't emitted for the source
755 // file this CU comes from yet.
756 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
758 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
759 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
760 DIUnit.getLanguage());
761 NewCU->addString(Die, dwarf::DW_AT_name, FN);
763 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
764 // into an entity. We're using 0 (or a NULL label) for this. For
765 // split dwarf it's in the skeleton CU so omit it here.
766 if (!useSplitDwarf())
767 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
769 // Define start line table label for each Compile Unit.
770 MCSymbol *LineTableStartSym =
771 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
772 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
773 NewCU->getUniqueID());
775 // Use a single line table if we are using .loc and generating assembly.
777 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
778 (NewCU->getUniqueID() == 0);
780 if (!useSplitDwarf()) {
781 // DW_AT_stmt_list is a offset of line number information for this
782 // compile unit in debug_line section. For split dwarf this is
783 // left in the skeleton CU and so not included.
784 // The line table entries are not always emitted in assembly, so it
785 // is not okay to use line_table_start here.
786 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
787 NewCU->addSectionLabel(
788 Die, dwarf::DW_AT_stmt_list,
789 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
790 : LineTableStartSym);
791 else if (UseTheFirstCU)
792 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
794 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list,
795 LineTableStartSym, DwarfLineSectionSym);
797 // If we're using split dwarf the compilation dir is going to be in the
798 // skeleton CU and so we don't need to duplicate it here.
799 if (!CompilationDir.empty())
800 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
802 addGnuPubAttributes(NewCU, Die);
805 if (DIUnit.isOptimized())
806 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
808 StringRef Flags = DIUnit.getFlags();
810 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
812 if (unsigned RVer = DIUnit.getRunTimeVersion())
813 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
814 dwarf::DW_FORM_data1, RVer);
819 InfoHolder.addUnit(NewCU);
821 CUMap.insert(std::make_pair(DIUnit, NewCU));
822 CUDieMap.insert(std::make_pair(Die, NewCU));
826 // Construct subprogram DIE.
827 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
828 // FIXME: We should only call this routine once, however, during LTO if a
829 // program is defined in multiple CUs we could end up calling it out of
830 // beginModule as we walk the CUs.
832 CompileUnit *&CURef = SPMap[N];
838 if (!SP.isDefinition())
839 // This is a method declaration which will be handled while constructing
843 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
845 // Expose as a global name.
846 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
849 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
851 DIImportedEntity Module(N);
852 if (!Module.Verify())
854 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
855 constructImportedEntityDIE(TheCU, Module, D);
858 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
860 DIImportedEntity Module(N);
861 if (!Module.Verify())
863 return constructImportedEntityDIE(TheCU, Module, Context);
866 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
867 const DIImportedEntity &Module,
869 assert(Module.Verify() &&
870 "Use one of the MDNode * overloads to handle invalid metadata");
871 assert(Context && "Should always have a context for an imported_module");
872 DIE *IMDie = new DIE(Module.getTag());
873 TheCU->insertDIE(Module, IMDie);
875 DIDescriptor Entity = Module.getEntity();
876 if (Entity.isNameSpace())
877 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
878 else if (Entity.isSubprogram())
879 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
880 else if (Entity.isType())
881 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
883 EntityDie = TheCU->getDIE(Entity);
884 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
885 Module.getContext().getDirectory(),
886 TheCU->getUniqueID());
887 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
888 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
889 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
890 StringRef Name = Module.getName();
892 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
893 Context->addChild(IMDie);
896 // Emit all Dwarf sections that should come prior to the content. Create
897 // global DIEs and emit initial debug info sections. This is invoked by
898 // the target AsmPrinter.
899 void DwarfDebug::beginModule() {
900 if (DisableDebugInfoPrinting)
903 const Module *M = MMI->getModule();
905 // If module has named metadata anchors then use them, otherwise scan the
906 // module using debug info finder to collect debug info.
907 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
910 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
912 // Emit initial sections so we can reference labels later.
915 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
916 DICompileUnit CUNode(CU_Nodes->getOperand(i));
917 CompileUnit *CU = constructCompileUnit(CUNode);
918 DIArray ImportedEntities = CUNode.getImportedEntities();
919 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
920 ScopesWithImportedEntities.push_back(std::make_pair(
921 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
922 ImportedEntities.getElement(i)));
923 std::sort(ScopesWithImportedEntities.begin(),
924 ScopesWithImportedEntities.end(), less_first());
925 DIArray GVs = CUNode.getGlobalVariables();
926 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
927 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
928 DIArray SPs = CUNode.getSubprograms();
929 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
930 constructSubprogramDIE(CU, SPs.getElement(i));
931 DIArray EnumTypes = CUNode.getEnumTypes();
932 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
933 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
934 DIArray RetainedTypes = CUNode.getRetainedTypes();
935 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
936 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
937 // Emit imported_modules last so that the relevant context is already
939 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
940 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
943 // Tell MMI that we have debug info.
944 MMI->setDebugInfoAvailability(true);
946 // Prime section data.
947 SectionMap[Asm->getObjFileLowering().getTextSection()];
950 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
951 void DwarfDebug::computeInlinedDIEs() {
952 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
953 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
954 AE = InlinedSubprogramDIEs.end();
957 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
959 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
960 AE = AbstractSPDies.end();
962 DIE *ISP = AI->second;
963 if (InlinedSubprogramDIEs.count(ISP))
965 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
969 // Collect info for variables that were optimized out.
970 void DwarfDebug::collectDeadVariables() {
971 const Module *M = MMI->getModule();
973 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
974 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
975 DICompileUnit TheCU(CU_Nodes->getOperand(i));
976 DIArray Subprograms = TheCU.getSubprograms();
977 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
978 DISubprogram SP(Subprograms.getElement(i));
979 if (ProcessedSPNodes.count(SP) != 0)
981 if (!SP.isSubprogram())
983 if (!SP.isDefinition())
985 DIArray Variables = SP.getVariables();
986 if (Variables.getNumElements() == 0)
989 // Construct subprogram DIE and add variables DIEs.
990 CompileUnit *SPCU = static_cast<CompileUnit *>(CUMap.lookup(TheCU));
991 assert(SPCU && "Unable to find Compile Unit!");
992 // FIXME: See the comment in constructSubprogramDIE about duplicate
994 constructSubprogramDIE(SPCU, SP);
995 DIE *SPDIE = SPCU->getDIE(SP);
996 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
997 DIVariable DV(Variables.getElement(vi));
998 if (!DV.isVariable())
1000 DbgVariable NewVar(DV, NULL, this);
1001 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1002 SPDIE->addChild(VariableDIE);
1009 // Type Signature [7.27] and ODR Hash code.
1011 /// \brief Grabs the string in whichever attribute is passed in and returns
1012 /// a reference to it. Returns "" if the attribute doesn't exist.
1013 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1014 DIEValue *V = Die->findAttribute(Attr);
1016 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1017 return S->getString();
1019 return StringRef("");
1022 /// Return true if the current DIE is contained within an anonymous namespace.
1023 static bool isContainedInAnonNamespace(DIE *Die) {
1024 DIE *Parent = Die->getParent();
1027 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1028 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1030 Parent = Parent->getParent();
1036 /// Test if the current CU language is C++ and that we have
1037 /// a named type that is not contained in an anonymous namespace.
1038 static bool shouldAddODRHash(TypeUnit *CU, DIE *Die) {
1039 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1040 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1041 !isContainedInAnonNamespace(Die);
1044 void DwarfDebug::finalizeModuleInfo() {
1045 // Collect info for variables that were optimized out.
1046 collectDeadVariables();
1048 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1049 computeInlinedDIEs();
1051 // Handle anything that needs to be done on a per-unit basis after
1052 // all other generation.
1053 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
1054 E = getUnits().end();
1057 // Emit DW_AT_containing_type attribute to connect types with their
1058 // vtable holding type.
1059 TheU->constructContainingTypeDIEs();
1061 // If we're splitting the dwarf out now that we've got the entire
1062 // CU then construct a skeleton CU based upon it.
1063 if (useSplitDwarf() &&
1064 TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1066 if (GenerateCUHash) {
1068 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1070 // This should be a unique identifier when we want to build .dwp files.
1071 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1072 dwarf::DW_FORM_data8, ID);
1073 // Now construct the skeleton CU associated.
1074 CompileUnit *SkCU = constructSkeletonCU(static_cast<CompileUnit *>(TheU));
1075 // This should be a unique identifier when we want to build .dwp files.
1076 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1077 dwarf::DW_FORM_data8, ID);
1081 // Compute DIE offsets and sizes.
1082 InfoHolder.computeSizeAndOffsets();
1083 if (useSplitDwarf())
1084 SkeletonHolder.computeSizeAndOffsets();
1087 void DwarfDebug::endSections() {
1088 // Filter labels by section.
1089 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1090 const SymbolCU &SCU = ArangeLabels[n];
1091 if (SCU.Sym->isInSection()) {
1092 // Make a note of this symbol and it's section.
1093 const MCSection *Section = &SCU.Sym->getSection();
1094 if (!Section->getKind().isMetadata())
1095 SectionMap[Section].push_back(SCU);
1097 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1098 // appear in the output. This sucks as we rely on sections to build
1099 // arange spans. We can do it without, but it's icky.
1100 SectionMap[NULL].push_back(SCU);
1104 // Build a list of sections used.
1105 std::vector<const MCSection *> Sections;
1106 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1108 const MCSection *Section = it->first;
1109 Sections.push_back(Section);
1112 // Sort the sections into order.
1113 // This is only done to ensure consistent output order across different runs.
1114 std::sort(Sections.begin(), Sections.end(), SectionSort);
1116 // Add terminating symbols for each section.
1117 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1118 const MCSection *Section = Sections[ID];
1119 MCSymbol *Sym = NULL;
1122 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1123 // if we know the section name up-front. For user-created sections, the
1125 // label may not be valid to use as a label. (section names can use a
1127 // set of characters on some systems)
1128 Sym = Asm->GetTempSymbol("debug_end", ID);
1129 Asm->OutStreamer.SwitchSection(Section);
1130 Asm->OutStreamer.EmitLabel(Sym);
1133 // Insert a final terminator.
1134 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1138 // Emit all Dwarf sections that should come after the content.
1139 void DwarfDebug::endModule() {
1146 // End any existing sections.
1147 // TODO: Does this need to happen?
1150 // Finalize the debug info for the module.
1151 finalizeModuleInfo();
1155 // Emit all the DIEs into a debug info section.
1158 // Corresponding abbreviations into a abbrev section.
1159 emitAbbreviations();
1161 // Emit info into a debug loc section.
1164 // Emit info into a debug aranges section.
1167 // Emit info into a debug ranges section.
1170 // Emit info into a debug macinfo section.
1173 if (useSplitDwarf()) {
1176 emitDebugAbbrevDWO();
1177 // Emit DWO addresses.
1178 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1181 // Emit info into the dwarf accelerator table sections.
1182 if (useDwarfAccelTables()) {
1185 emitAccelNamespaces();
1189 // Emit the pubnames and pubtypes sections if requested.
1190 if (HasDwarfPubSections) {
1191 emitDebugPubNames(GenerateGnuPubSections);
1192 emitDebugPubTypes(GenerateGnuPubSections);
1198 // Reset these for the next Module if we have one.
1202 // Find abstract variable, if any, associated with Var.
1203 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1204 DebugLoc ScopeLoc) {
1205 LLVMContext &Ctx = DV->getContext();
1206 // More then one inlined variable corresponds to one abstract variable.
1207 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1208 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1210 return AbsDbgVariable;
1212 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1216 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1217 addScopeVariable(Scope, AbsDbgVariable);
1218 AbstractVariables[Var] = AbsDbgVariable;
1219 return AbsDbgVariable;
1222 // If Var is a current function argument then add it to CurrentFnArguments list.
1223 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1224 if (!LScopes.isCurrentFunctionScope(Scope))
1226 DIVariable DV = Var->getVariable();
1227 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1229 unsigned ArgNo = DV.getArgNumber();
1233 size_t Size = CurrentFnArguments.size();
1235 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1236 // llvm::Function argument size is not good indicator of how many
1237 // arguments does the function have at source level.
1239 CurrentFnArguments.resize(ArgNo * 2);
1240 CurrentFnArguments[ArgNo - 1] = Var;
1244 // Collect variable information from side table maintained by MMI.
1245 void DwarfDebug::collectVariableInfoFromMMITable(
1246 SmallPtrSet<const MDNode *, 16> &Processed) {
1247 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1248 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1251 const MDNode *Var = VI->first;
1254 Processed.insert(Var);
1256 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1258 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1260 // If variable scope is not found then skip this variable.
1264 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1265 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1266 RegVar->setFrameIndex(VP.first);
1267 if (!addCurrentFnArgument(RegVar, Scope))
1268 addScopeVariable(Scope, RegVar);
1270 AbsDbgVariable->setFrameIndex(VP.first);
1274 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1276 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1277 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1278 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1279 MI->getOperand(0).getReg() &&
1280 (MI->getOperand(1).isImm() ||
1281 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1284 // Get .debug_loc entry for the instruction range starting at MI.
1285 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1286 const MCSymbol *FLabel,
1287 const MCSymbol *SLabel,
1288 const MachineInstr *MI) {
1289 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1291 assert(MI->getNumOperands() == 3);
1292 if (MI->getOperand(0).isReg()) {
1293 MachineLocation MLoc;
1294 // If the second operand is an immediate, this is a
1295 // register-indirect address.
1296 if (!MI->getOperand(1).isImm())
1297 MLoc.set(MI->getOperand(0).getReg());
1299 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1300 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1302 if (MI->getOperand(0).isImm())
1303 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1304 if (MI->getOperand(0).isFPImm())
1305 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1306 if (MI->getOperand(0).isCImm())
1307 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1309 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1312 // Find variables for each lexical scope.
1314 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1316 // Grab the variable info that was squirreled away in the MMI side-table.
1317 collectVariableInfoFromMMITable(Processed);
1319 for (SmallVectorImpl<const MDNode *>::const_iterator
1320 UVI = UserVariables.begin(),
1321 UVE = UserVariables.end();
1322 UVI != UVE; ++UVI) {
1323 const MDNode *Var = *UVI;
1324 if (Processed.count(Var))
1327 // History contains relevant DBG_VALUE instructions for Var and instructions
1329 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1330 if (History.empty())
1332 const MachineInstr *MInsn = History.front();
1335 LexicalScope *Scope = NULL;
1336 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1337 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1338 Scope = LScopes.getCurrentFunctionScope();
1339 else if (MDNode *IA = DV.getInlinedAt())
1340 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1342 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1343 // If variable scope is not found then skip this variable.
1347 Processed.insert(DV);
1348 assert(MInsn->isDebugValue() && "History must begin with debug value");
1349 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1350 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1351 if (!addCurrentFnArgument(RegVar, Scope))
1352 addScopeVariable(Scope, RegVar);
1354 AbsVar->setMInsn(MInsn);
1356 // Simplify ranges that are fully coalesced.
1357 if (History.size() <= 1 ||
1358 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1359 RegVar->setMInsn(MInsn);
1363 // Handle multiple DBG_VALUE instructions describing one variable.
1364 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1366 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1367 HI = History.begin(),
1370 const MachineInstr *Begin = *HI;
1371 assert(Begin->isDebugValue() && "Invalid History entry");
1373 // Check if DBG_VALUE is truncating a range.
1374 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1375 !Begin->getOperand(0).getReg())
1378 // Compute the range for a register location.
1379 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1380 const MCSymbol *SLabel = 0;
1383 // If Begin is the last instruction in History then its value is valid
1384 // until the end of the function.
1385 SLabel = FunctionEndSym;
1387 const MachineInstr *End = HI[1];
1388 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1389 << "\t" << *Begin << "\t" << *End << "\n");
1390 if (End->isDebugValue())
1391 SLabel = getLabelBeforeInsn(End);
1393 // End is a normal instruction clobbering the range.
1394 SLabel = getLabelAfterInsn(End);
1395 assert(SLabel && "Forgot label after clobber instruction");
1400 // The value is valid until the next DBG_VALUE or clobber.
1401 DotDebugLocEntries.push_back(
1402 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1404 DotDebugLocEntries.push_back(DotDebugLocEntry());
1407 // Collect info for variables that were optimized out.
1408 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1409 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1410 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1411 DIVariable DV(Variables.getElement(i));
1412 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1414 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1415 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1419 // Return Label preceding the instruction.
1420 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1421 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1422 assert(Label && "Didn't insert label before instruction");
1426 // Return Label immediately following the instruction.
1427 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1428 return LabelsAfterInsn.lookup(MI);
1431 // Process beginning of an instruction.
1432 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1435 // Check if source location changes, but ignore DBG_VALUE locations.
1436 if (!MI->isDebugValue()) {
1437 DebugLoc DL = MI->getDebugLoc();
1438 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1441 if (DL == PrologEndLoc) {
1442 Flags |= DWARF2_FLAG_PROLOGUE_END;
1443 PrologEndLoc = DebugLoc();
1445 if (PrologEndLoc.isUnknown())
1446 Flags |= DWARF2_FLAG_IS_STMT;
1448 if (!DL.isUnknown()) {
1449 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1450 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1452 recordSourceLine(0, 0, 0, 0);
1456 // Insert labels where requested.
1457 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1458 LabelsBeforeInsn.find(MI);
1461 if (I == LabelsBeforeInsn.end())
1464 // Label already assigned.
1469 PrevLabel = MMI->getContext().CreateTempSymbol();
1470 Asm->OutStreamer.EmitLabel(PrevLabel);
1472 I->second = PrevLabel;
1475 // Process end of an instruction.
1476 void DwarfDebug::endInstruction() {
1478 // Don't create a new label after DBG_VALUE instructions.
1479 // They don't generate code.
1480 if (!CurMI->isDebugValue())
1483 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1484 LabelsAfterInsn.find(CurMI);
1488 if (I == LabelsAfterInsn.end())
1491 // Label already assigned.
1495 // We need a label after this instruction.
1497 PrevLabel = MMI->getContext().CreateTempSymbol();
1498 Asm->OutStreamer.EmitLabel(PrevLabel);
1500 I->second = PrevLabel;
1503 // Each LexicalScope has first instruction and last instruction to mark
1504 // beginning and end of a scope respectively. Create an inverse map that list
1505 // scopes starts (and ends) with an instruction. One instruction may start (or
1506 // end) multiple scopes. Ignore scopes that are not reachable.
1507 void DwarfDebug::identifyScopeMarkers() {
1508 SmallVector<LexicalScope *, 4> WorkList;
1509 WorkList.push_back(LScopes.getCurrentFunctionScope());
1510 while (!WorkList.empty()) {
1511 LexicalScope *S = WorkList.pop_back_val();
1513 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1514 if (!Children.empty())
1515 for (SmallVectorImpl<LexicalScope *>::const_iterator
1516 SI = Children.begin(),
1517 SE = Children.end();
1519 WorkList.push_back(*SI);
1521 if (S->isAbstractScope())
1524 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1527 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1530 assert(RI->first && "InsnRange does not have first instruction!");
1531 assert(RI->second && "InsnRange does not have second instruction!");
1532 requestLabelBeforeInsn(RI->first);
1533 requestLabelAfterInsn(RI->second);
1538 // Get MDNode for DebugLoc's scope.
1539 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1540 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1541 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1542 return DL.getScope(Ctx);
1545 // Walk up the scope chain of given debug loc and find line number info
1546 // for the function.
1547 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1548 const MDNode *Scope = getScopeNode(DL, Ctx);
1549 DISubprogram SP = getDISubprogram(Scope);
1550 if (SP.isSubprogram()) {
1551 // Check for number of operands since the compatibility is
1553 if (SP->getNumOperands() > 19)
1554 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1556 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1562 // Gather pre-function debug information. Assumes being called immediately
1563 // after the function entry point has been emitted.
1564 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1567 // If there's no debug info for the function we're not going to do anything.
1568 if (!MMI->hasDebugInfo())
1571 // Grab the lexical scopes for the function, if we don't have any of those
1572 // then we're not going to be able to do anything.
1573 LScopes.initialize(*MF);
1574 if (LScopes.empty())
1577 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1579 // Make sure that each lexical scope will have a begin/end label.
1580 identifyScopeMarkers();
1582 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1583 // belongs to so that we add to the correct per-cu line table in the
1585 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1586 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1587 assert(TheCU && "Unable to find compile unit!");
1588 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1589 // Use a single line table if we are using .loc and generating assembly.
1590 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1592 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1594 // Emit a label for the function so that we have a beginning address.
1595 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1596 // Assumes in correct section after the entry point.
1597 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1599 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1600 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1601 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1603 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1605 bool AtBlockEntry = true;
1606 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1608 const MachineInstr *MI = II;
1610 if (MI->isDebugValue()) {
1611 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1613 // Keep track of user variables.
1615 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1617 // Variable is in a register, we need to check for clobbers.
1618 if (isDbgValueInDefinedReg(MI))
1619 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1621 // Check the history of this variable.
1622 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1623 if (History.empty()) {
1624 UserVariables.push_back(Var);
1625 // The first mention of a function argument gets the FunctionBeginSym
1626 // label, so arguments are visible when breaking at function entry.
1628 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1629 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1630 LabelsBeforeInsn[MI] = FunctionBeginSym;
1632 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1633 const MachineInstr *Prev = History.back();
1634 if (Prev->isDebugValue()) {
1635 // Coalesce identical entries at the end of History.
1636 if (History.size() >= 2 &&
1637 Prev->isIdenticalTo(History[History.size() - 2])) {
1638 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1639 << "\t" << *Prev << "\t"
1640 << *History[History.size() - 2] << "\n");
1644 // Terminate old register assignments that don't reach MI;
1645 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1646 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1647 isDbgValueInDefinedReg(Prev)) {
1648 // Previous register assignment needs to terminate at the end of
1650 MachineBasicBlock::const_iterator LastMI =
1651 PrevMBB->getLastNonDebugInstr();
1652 if (LastMI == PrevMBB->end()) {
1653 // Drop DBG_VALUE for empty range.
1654 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1655 << "\t" << *Prev << "\n");
1657 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1658 // Terminate after LastMI.
1659 History.push_back(LastMI);
1663 History.push_back(MI);
1665 // Not a DBG_VALUE instruction.
1667 AtBlockEntry = false;
1669 // First known non-DBG_VALUE and non-frame setup location marks
1670 // the beginning of the function body.
1671 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1672 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1673 PrologEndLoc = MI->getDebugLoc();
1675 // Check if the instruction clobbers any registers with debug vars.
1676 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1677 MOE = MI->operands_end();
1678 MOI != MOE; ++MOI) {
1679 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1681 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1684 const MDNode *Var = LiveUserVar[Reg];
1687 // Reg is now clobbered.
1688 LiveUserVar[Reg] = 0;
1690 // Was MD last defined by a DBG_VALUE referring to Reg?
1691 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1692 if (HistI == DbgValues.end())
1694 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1695 if (History.empty())
1697 const MachineInstr *Prev = History.back();
1698 // Sanity-check: Register assignments are terminated at the end of
1700 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1702 // Is the variable still in Reg?
1703 if (!isDbgValueInDefinedReg(Prev) ||
1704 Prev->getOperand(0).getReg() != Reg)
1706 // Var is clobbered. Make sure the next instruction gets a label.
1707 History.push_back(MI);
1714 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1716 SmallVectorImpl<const MachineInstr *> &History = I->second;
1717 if (History.empty())
1720 // Make sure the final register assignments are terminated.
1721 const MachineInstr *Prev = History.back();
1722 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1723 const MachineBasicBlock *PrevMBB = Prev->getParent();
1724 MachineBasicBlock::const_iterator LastMI =
1725 PrevMBB->getLastNonDebugInstr();
1726 if (LastMI == PrevMBB->end())
1727 // Drop DBG_VALUE for empty range.
1729 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1730 // Terminate after LastMI.
1731 History.push_back(LastMI);
1734 // Request labels for the full history.
1735 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1736 const MachineInstr *MI = History[i];
1737 if (MI->isDebugValue())
1738 requestLabelBeforeInsn(MI);
1740 requestLabelAfterInsn(MI);
1744 PrevInstLoc = DebugLoc();
1745 PrevLabel = FunctionBeginSym;
1747 // Record beginning of function.
1748 if (!PrologEndLoc.isUnknown()) {
1749 DebugLoc FnStartDL =
1750 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1752 FnStartDL.getLine(), FnStartDL.getCol(),
1753 FnStartDL.getScope(MF->getFunction()->getContext()),
1754 // We'd like to list the prologue as "not statements" but GDB behaves
1755 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1756 DWARF2_FLAG_IS_STMT);
1760 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1761 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1762 DIVariable DV = Var->getVariable();
1763 // Variables with positive arg numbers are parameters.
1764 if (unsigned ArgNum = DV.getArgNumber()) {
1765 // Keep all parameters in order at the start of the variable list to ensure
1766 // function types are correct (no out-of-order parameters)
1768 // This could be improved by only doing it for optimized builds (unoptimized
1769 // builds have the right order to begin with), searching from the back (this
1770 // would catch the unoptimized case quickly), or doing a binary search
1771 // rather than linear search.
1772 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1773 while (I != Vars.end()) {
1774 unsigned CurNum = (*I)->getVariable().getArgNumber();
1775 // A local (non-parameter) variable has been found, insert immediately
1779 // A later indexed parameter has been found, insert immediately before it.
1780 if (CurNum > ArgNum)
1784 Vars.insert(I, Var);
1788 Vars.push_back(Var);
1791 // Gather and emit post-function debug information.
1792 void DwarfDebug::endFunction(const MachineFunction *MF) {
1793 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1794 // though the beginFunction may not be called at all.
1795 // We should handle both cases.
1799 assert(CurFn == MF);
1802 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1807 // Define end label for subprogram.
1808 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1809 // Assumes in correct section after the entry point.
1810 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1811 // Set DwarfCompileUnitID in MCContext to default value.
1812 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1814 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1815 collectVariableInfo(ProcessedVars);
1817 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1818 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1819 assert(TheCU && "Unable to find compile unit!");
1821 // Construct abstract scopes.
1822 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1823 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1824 LexicalScope *AScope = AList[i];
1825 DISubprogram SP(AScope->getScopeNode());
1826 if (SP.isSubprogram()) {
1827 // Collect info for variables that were optimized out.
1828 DIArray Variables = SP.getVariables();
1829 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1830 DIVariable DV(Variables.getElement(i));
1831 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1833 // Check that DbgVariable for DV wasn't created earlier, when
1834 // findAbstractVariable() was called for inlined instance of DV.
1835 LLVMContext &Ctx = DV->getContext();
1836 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1837 if (AbstractVariables.lookup(CleanDV))
1839 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1840 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1843 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1844 constructScopeDIE(TheCU, AScope);
1847 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1849 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1850 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1853 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1854 E = ScopeVariables.end();
1856 DeleteContainerPointers(I->second);
1857 ScopeVariables.clear();
1858 DeleteContainerPointers(CurrentFnArguments);
1859 UserVariables.clear();
1861 AbstractVariables.clear();
1862 LabelsBeforeInsn.clear();
1863 LabelsAfterInsn.clear();
1868 // Register a source line with debug info. Returns the unique label that was
1869 // emitted and which provides correspondence to the source line list.
1870 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1876 DIDescriptor Scope(S);
1878 if (Scope.isCompileUnit()) {
1879 DICompileUnit CU(S);
1880 Fn = CU.getFilename();
1881 Dir = CU.getDirectory();
1882 } else if (Scope.isFile()) {
1884 Fn = F.getFilename();
1885 Dir = F.getDirectory();
1886 } else if (Scope.isSubprogram()) {
1888 Fn = SP.getFilename();
1889 Dir = SP.getDirectory();
1890 } else if (Scope.isLexicalBlockFile()) {
1891 DILexicalBlockFile DBF(S);
1892 Fn = DBF.getFilename();
1893 Dir = DBF.getDirectory();
1894 } else if (Scope.isLexicalBlock()) {
1895 DILexicalBlock DB(S);
1896 Fn = DB.getFilename();
1897 Dir = DB.getDirectory();
1899 llvm_unreachable("Unexpected scope info");
1901 Src = getOrCreateSourceID(
1902 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1904 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1907 //===----------------------------------------------------------------------===//
1909 //===----------------------------------------------------------------------===//
1911 // Compute the size and offset of a DIE. The offset is relative to start of the
1912 // CU. It returns the offset after laying out the DIE.
1913 unsigned DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1914 // Get the children.
1915 const std::vector<DIE *> &Children = Die->getChildren();
1917 // Record the abbreviation.
1918 assignAbbrevNumber(Die->getAbbrev());
1920 // Get the abbreviation for this DIE.
1921 const DIEAbbrev &Abbrev = Die->getAbbrev();
1924 Die->setOffset(Offset);
1926 // Start the size with the size of abbreviation code.
1927 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1929 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1930 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1932 // Size the DIE attribute values.
1933 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1934 // Size attribute value.
1935 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1937 // Size the DIE children if any.
1938 if (!Children.empty()) {
1939 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1940 "Children flag not set");
1942 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1943 Offset = computeSizeAndOffset(Children[j], Offset);
1945 // End of children marker.
1946 Offset += sizeof(int8_t);
1949 Die->setSize(Offset - Die->getOffset());
1953 // Compute the size and offset for each DIE.
1954 void DwarfUnits::computeSizeAndOffsets() {
1955 // Offset from the first CU in the debug info section is 0 initially.
1956 unsigned SecOffset = 0;
1958 // Iterate over each compile unit and set the size and offsets for each
1959 // DIE within each compile unit. All offsets are CU relative.
1960 for (SmallVectorImpl<Unit *>::const_iterator I = CUs.begin(), E = CUs.end();
1962 (*I)->setDebugInfoOffset(SecOffset);
1964 // CU-relative offset is reset to 0 here.
1965 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1966 (*I)->getHeaderSize(); // Unit-specific headers
1968 // EndOffset here is CU-relative, after laying out
1969 // all of the CU DIE.
1970 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1971 SecOffset += EndOffset;
1975 // Emit initial Dwarf sections with a label at the start of each one.
1976 void DwarfDebug::emitSectionLabels() {
1977 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1979 // Dwarf sections base addresses.
1980 DwarfInfoSectionSym =
1981 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1982 DwarfAbbrevSectionSym =
1983 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1984 if (useSplitDwarf())
1985 DwarfAbbrevDWOSectionSym = emitSectionSym(
1986 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1987 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1989 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1990 emitSectionSym(Asm, MacroInfo);
1992 DwarfLineSectionSym =
1993 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1994 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1995 if (GenerateGnuPubSections) {
1996 DwarfGnuPubNamesSectionSym =
1997 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1998 DwarfGnuPubTypesSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2000 } else if (HasDwarfPubSections) {
2001 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2002 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2005 DwarfStrSectionSym =
2006 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2007 if (useSplitDwarf()) {
2008 DwarfStrDWOSectionSym =
2009 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2010 DwarfAddrSectionSym =
2011 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2013 DwarfDebugRangeSectionSym =
2014 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2016 DwarfDebugLocSectionSym =
2017 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2019 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2020 emitSectionSym(Asm, TLOF.getDataSection());
2023 // Recursively emits a debug information entry.
2024 void DwarfDebug::emitDIE(DIE *Die) {
2025 // Get the abbreviation for this DIE.
2026 const DIEAbbrev &Abbrev = Die->getAbbrev();
2028 // Emit the code (index) for the abbreviation.
2029 if (Asm->isVerbose())
2030 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2031 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2032 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2033 dwarf::TagString(Abbrev.getTag()));
2034 Asm->EmitULEB128(Abbrev.getNumber());
2036 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2037 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2039 // Emit the DIE attribute values.
2040 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2041 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2042 dwarf::Form Form = AbbrevData[i].getForm();
2043 assert(Form && "Too many attributes for DIE (check abbreviation)");
2045 if (Asm->isVerbose())
2046 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2049 case dwarf::DW_AT_abstract_origin:
2050 case dwarf::DW_AT_type:
2051 case dwarf::DW_AT_friend:
2052 case dwarf::DW_AT_specification:
2053 case dwarf::DW_AT_import:
2054 case dwarf::DW_AT_containing_type: {
2055 DIEEntry *E = cast<DIEEntry>(Values[i]);
2056 DIE *Origin = E->getEntry();
2057 unsigned Addr = Origin->getOffset();
2058 if (Form == dwarf::DW_FORM_ref_addr) {
2059 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2060 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2061 // section. Origin->getOffset() returns the offset from start of the
2063 CompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2064 assert(CU && "CUDie should belong to a CU.");
2065 Addr += CU->getDebugInfoOffset();
2066 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2067 Asm->EmitLabelPlusOffset(DwarfInfoSectionSym, Addr,
2068 DIEEntry::getRefAddrSize(Asm));
2070 Asm->EmitLabelOffsetDifference(DwarfInfoSectionSym, Addr,
2071 DwarfInfoSectionSym,
2072 DIEEntry::getRefAddrSize(Asm));
2074 // Make sure Origin belong to the same CU.
2075 assert(Die->getUnit() == Origin->getUnit() &&
2076 "The referenced DIE should belong to the same CU in ref4");
2077 Asm->EmitInt32(Addr);
2081 case dwarf::DW_AT_location: {
2082 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2083 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2084 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2086 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2088 Values[i]->EmitValue(Asm, Form);
2092 case dwarf::DW_AT_accessibility: {
2093 if (Asm->isVerbose()) {
2094 DIEInteger *V = cast<DIEInteger>(Values[i]);
2095 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2097 Values[i]->EmitValue(Asm, Form);
2101 // Emit an attribute using the defined form.
2102 Values[i]->EmitValue(Asm, Form);
2107 // Emit the DIE children if any.
2108 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2109 const std::vector<DIE *> &Children = Die->getChildren();
2111 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2112 emitDIE(Children[j]);
2114 Asm->OutStreamer.AddComment("End Of Children Mark");
2119 // Emit the various dwarf units to the unit section USection with
2120 // the abbreviations going into ASection.
2121 void DwarfUnits::emitUnits(DwarfDebug *DD, const MCSection *USection,
2122 const MCSection *ASection,
2123 const MCSymbol *ASectionSym) {
2124 Asm->OutStreamer.SwitchSection(USection);
2125 for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
2128 DIE *Die = TheU->getUnitDie();
2130 // Emit the compile units header.
2131 Asm->OutStreamer.EmitLabel(
2132 Asm->GetTempSymbol(USection->getLabelBeginName(), TheU->getUniqueID()));
2134 // Emit size of content not including length itself
2135 Asm->OutStreamer.AddComment("Length of Unit");
2136 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2138 TheU->emitHeader(ASection, ASectionSym);
2141 Asm->OutStreamer.EmitLabel(
2142 Asm->GetTempSymbol(USection->getLabelEndName(), TheU->getUniqueID()));
2146 // Emit the debug info section.
2147 void DwarfDebug::emitDebugInfo() {
2148 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2150 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2151 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2152 DwarfAbbrevSectionSym);
2155 // Emit the abbreviation section.
2156 void DwarfDebug::emitAbbreviations() {
2157 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2159 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2162 void DwarfUnits::emitAbbrevs(const MCSection *Section) {
2163 // Check to see if it is worth the effort.
2164 if (!Abbreviations.empty()) {
2165 // Start the debug abbrev section.
2166 Asm->OutStreamer.SwitchSection(Section);
2168 // For each abbrevation.
2169 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2170 // Get abbreviation data
2171 const DIEAbbrev *Abbrev = Abbreviations[i];
2173 // Emit the abbrevations code (base 1 index.)
2174 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2176 // Emit the abbreviations data.
2180 // Mark end of abbreviations.
2181 Asm->EmitULEB128(0, "EOM(3)");
2185 // Emit the last address of the section and the end of the line matrix.
2186 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2187 // Define last address of section.
2188 Asm->OutStreamer.AddComment("Extended Op");
2191 Asm->OutStreamer.AddComment("Op size");
2192 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2193 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2194 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2196 Asm->OutStreamer.AddComment("Section end label");
2198 Asm->OutStreamer.EmitSymbolValue(
2199 Asm->GetTempSymbol("section_end", SectionEnd),
2200 Asm->getDataLayout().getPointerSize());
2202 // Mark end of matrix.
2203 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2209 // Emit visible names into a hashed accelerator table section.
2210 void DwarfDebug::emitAccelNames() {
2212 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2213 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2214 E = getUnits().end();
2217 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2218 for (StringMap<std::vector<const DIE *> >::const_iterator
2222 StringRef Name = GI->getKey();
2223 const std::vector<const DIE *> &Entities = GI->second;
2224 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2225 DE = Entities.end();
2227 AT.AddName(Name, *DI);
2231 AT.FinalizeTable(Asm, "Names");
2232 Asm->OutStreamer.SwitchSection(
2233 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2234 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2235 Asm->OutStreamer.EmitLabel(SectionBegin);
2237 // Emit the full data.
2238 AT.Emit(Asm, SectionBegin, &InfoHolder);
2241 // Emit objective C classes and categories into a hashed accelerator table
2243 void DwarfDebug::emitAccelObjC() {
2245 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2246 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2247 E = getUnits().end();
2250 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2251 for (StringMap<std::vector<const DIE *> >::const_iterator
2255 StringRef Name = GI->getKey();
2256 const std::vector<const DIE *> &Entities = GI->second;
2257 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2258 DE = Entities.end();
2260 AT.AddName(Name, *DI);
2264 AT.FinalizeTable(Asm, "ObjC");
2265 Asm->OutStreamer.SwitchSection(
2266 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2267 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2268 Asm->OutStreamer.EmitLabel(SectionBegin);
2270 // Emit the full data.
2271 AT.Emit(Asm, SectionBegin, &InfoHolder);
2274 // Emit namespace dies into a hashed accelerator table.
2275 void DwarfDebug::emitAccelNamespaces() {
2277 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2278 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2279 E = getUnits().end();
2282 const StringMap<std::vector<const DIE *> > &Names =
2283 TheU->getAccelNamespace();
2284 for (StringMap<std::vector<const DIE *> >::const_iterator
2288 StringRef Name = GI->getKey();
2289 const std::vector<const DIE *> &Entities = GI->second;
2290 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2291 DE = Entities.end();
2293 AT.AddName(Name, *DI);
2297 AT.FinalizeTable(Asm, "namespac");
2298 Asm->OutStreamer.SwitchSection(
2299 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2300 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2301 Asm->OutStreamer.EmitLabel(SectionBegin);
2303 // Emit the full data.
2304 AT.Emit(Asm, SectionBegin, &InfoHolder);
2307 // Emit type dies into a hashed accelerator table.
2308 void DwarfDebug::emitAccelTypes() {
2309 std::vector<DwarfAccelTable::Atom> Atoms;
2311 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2313 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2315 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2316 DwarfAccelTable AT(Atoms);
2317 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2318 E = getUnits().end();
2321 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2322 TheU->getAccelTypes();
2324 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2328 StringRef Name = GI->getKey();
2329 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2331 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2332 DI = Entities.begin(),
2333 DE = Entities.end();
2335 AT.AddName(Name, DI->first, DI->second);
2339 AT.FinalizeTable(Asm, "types");
2340 Asm->OutStreamer.SwitchSection(
2341 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2342 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2343 Asm->OutStreamer.EmitLabel(SectionBegin);
2345 // Emit the full data.
2346 AT.Emit(Asm, SectionBegin, &InfoHolder);
2349 // Public name handling.
2350 // The format for the various pubnames:
2352 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2353 // for the DIE that is named.
2355 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2356 // into the CU and the index value is computed according to the type of value
2357 // for the DIE that is named.
2359 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2360 // it's the offset within the debug_info/debug_types dwo section, however, the
2361 // reference in the pubname header doesn't change.
2363 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2364 static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
2366 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2368 // We could have a specification DIE that has our most of our knowledge,
2369 // look for that now.
2370 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2372 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2373 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2374 Linkage = dwarf::GIEL_EXTERNAL;
2375 } else if (Die->findAttribute(dwarf::DW_AT_external))
2376 Linkage = dwarf::GIEL_EXTERNAL;
2378 switch (Die->getTag()) {
2379 case dwarf::DW_TAG_class_type:
2380 case dwarf::DW_TAG_structure_type:
2381 case dwarf::DW_TAG_union_type:
2382 case dwarf::DW_TAG_enumeration_type:
2383 return dwarf::PubIndexEntryDescriptor(
2384 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2385 ? dwarf::GIEL_STATIC
2386 : dwarf::GIEL_EXTERNAL);
2387 case dwarf::DW_TAG_typedef:
2388 case dwarf::DW_TAG_base_type:
2389 case dwarf::DW_TAG_subrange_type:
2390 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2391 case dwarf::DW_TAG_namespace:
2392 return dwarf::GIEK_TYPE;
2393 case dwarf::DW_TAG_subprogram:
2394 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2395 case dwarf::DW_TAG_constant:
2396 case dwarf::DW_TAG_variable:
2397 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2398 case dwarf::DW_TAG_enumerator:
2399 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2400 dwarf::GIEL_STATIC);
2402 return dwarf::GIEK_NONE;
2406 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2408 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2409 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2410 const MCSection *PSec =
2411 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2412 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2414 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2415 E = getUnits().end();
2418 unsigned ID = TheU->getUniqueID();
2420 // Start the dwarf pubnames section.
2421 Asm->OutStreamer.SwitchSection(PSec);
2423 // Emit a label so we can reference the beginning of this pubname section.
2425 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2428 Asm->OutStreamer.AddComment("Length of Public Names Info");
2429 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2430 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2431 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2433 Asm->OutStreamer.EmitLabel(BeginLabel);
2435 Asm->OutStreamer.AddComment("DWARF Version");
2436 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2438 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2439 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2440 DwarfInfoSectionSym);
2442 Asm->OutStreamer.AddComment("Compilation Unit Length");
2443 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2444 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2447 // Emit the pubnames for this compilation unit.
2448 const StringMap<const DIE *> &Globals = TheU->getGlobalNames();
2449 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2452 const char *Name = GI->getKeyData();
2453 const DIE *Entity = GI->second;
2455 Asm->OutStreamer.AddComment("DIE offset");
2456 Asm->EmitInt32(Entity->getOffset());
2459 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2460 Asm->OutStreamer.AddComment(
2461 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2462 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2463 Asm->EmitInt8(Desc.toBits());
2466 Asm->OutStreamer.AddComment("External Name");
2467 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2470 Asm->OutStreamer.AddComment("End Mark");
2472 Asm->OutStreamer.EmitLabel(EndLabel);
2476 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2477 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2478 const MCSection *PSec =
2479 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2480 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2482 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2483 E = getUnits().end();
2486 unsigned ID = TheU->getUniqueID();
2488 // Start the dwarf pubtypes section.
2489 Asm->OutStreamer.SwitchSection(PSec);
2491 // Emit a label so we can reference the beginning of this pubtype section.
2493 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2496 Asm->OutStreamer.AddComment("Length of Public Types Info");
2497 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2498 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2499 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2501 Asm->OutStreamer.EmitLabel(BeginLabel);
2503 Asm->OutStreamer.AddComment("DWARF Version");
2504 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2506 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2507 Asm->EmitSectionOffset(
2508 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()),
2509 DwarfInfoSectionSym);
2511 Asm->OutStreamer.AddComment("Compilation Unit Length");
2512 Asm->EmitLabelDifference(
2513 Asm->GetTempSymbol(ISec->getLabelEndName(), TheU->getUniqueID()),
2514 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()), 4);
2516 // Emit the pubtypes.
2517 const StringMap<const DIE *> &Globals = TheU->getGlobalTypes();
2518 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2521 const char *Name = GI->getKeyData();
2522 const DIE *Entity = GI->second;
2524 Asm->OutStreamer.AddComment("DIE offset");
2525 Asm->EmitInt32(Entity->getOffset());
2528 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2529 Asm->OutStreamer.AddComment(
2530 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2531 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2532 Asm->EmitInt8(Desc.toBits());
2535 Asm->OutStreamer.AddComment("External Name");
2537 // Emit the name with a terminating null byte.
2538 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2541 Asm->OutStreamer.AddComment("End Mark");
2543 Asm->OutStreamer.EmitLabel(EndLabel);
2547 // Emit strings into a string section.
2548 void DwarfUnits::emitStrings(const MCSection *StrSection,
2549 const MCSection *OffsetSection = NULL,
2550 const MCSymbol *StrSecSym = NULL) {
2552 if (StringPool.empty())
2555 // Start the dwarf str section.
2556 Asm->OutStreamer.SwitchSection(StrSection);
2558 // Get all of the string pool entries and put them in an array by their ID so
2559 // we can sort them.
2561 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2564 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2565 I = StringPool.begin(),
2566 E = StringPool.end();
2568 Entries.push_back(std::make_pair(I->second.second, &*I));
2570 array_pod_sort(Entries.begin(), Entries.end());
2572 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2573 // Emit a label for reference from debug information entries.
2574 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2576 // Emit the string itself with a terminating null byte.
2577 Asm->OutStreamer.EmitBytes(
2578 StringRef(Entries[i].second->getKeyData(),
2579 Entries[i].second->getKeyLength() + 1));
2582 // If we've got an offset section go ahead and emit that now as well.
2583 if (OffsetSection) {
2584 Asm->OutStreamer.SwitchSection(OffsetSection);
2585 unsigned offset = 0;
2586 unsigned size = 4; // FIXME: DWARF64 is 8.
2587 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2588 Asm->OutStreamer.EmitIntValue(offset, size);
2589 offset += Entries[i].second->getKeyLength() + 1;
2595 // Emit addresses into the section given.
2596 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2598 if (AddressPool.empty())
2601 // Start the dwarf addr section.
2602 Asm->OutStreamer.SwitchSection(AddrSection);
2604 // Order the address pool entries by ID
2605 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2607 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2608 E = AddressPool.end();
2610 Entries[I->second] = I->first;
2612 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2613 // Emit an expression for reference from debug information entries.
2614 if (const MCExpr *Expr = Entries[i])
2615 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2617 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2621 // Emit visible names into a debug str section.
2622 void DwarfDebug::emitDebugStr() {
2623 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2624 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2627 // Emit locations into the debug loc section.
2628 void DwarfDebug::emitDebugLoc() {
2629 if (DotDebugLocEntries.empty())
2632 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2633 I = DotDebugLocEntries.begin(),
2634 E = DotDebugLocEntries.end();
2636 DotDebugLocEntry &Entry = *I;
2637 if (I + 1 != DotDebugLocEntries.end())
2641 // Start the dwarf loc section.
2642 Asm->OutStreamer.SwitchSection(
2643 Asm->getObjFileLowering().getDwarfLocSection());
2644 unsigned char Size = Asm->getDataLayout().getPointerSize();
2645 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2647 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2648 I = DotDebugLocEntries.begin(),
2649 E = DotDebugLocEntries.end();
2650 I != E; ++I, ++index) {
2651 DotDebugLocEntry &Entry = *I;
2652 if (Entry.isMerged())
2654 if (Entry.isEmpty()) {
2655 Asm->OutStreamer.EmitIntValue(0, Size);
2656 Asm->OutStreamer.EmitIntValue(0, Size);
2657 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2659 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2660 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2661 DIVariable DV(Entry.getVariable());
2662 Asm->OutStreamer.AddComment("Loc expr size");
2663 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2664 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2665 Asm->EmitLabelDifference(end, begin, 2);
2666 Asm->OutStreamer.EmitLabel(begin);
2667 if (Entry.isInt()) {
2668 DIBasicType BTy(DV.getType());
2669 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2670 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2671 Asm->OutStreamer.AddComment("DW_OP_consts");
2672 Asm->EmitInt8(dwarf::DW_OP_consts);
2673 Asm->EmitSLEB128(Entry.getInt());
2675 Asm->OutStreamer.AddComment("DW_OP_constu");
2676 Asm->EmitInt8(dwarf::DW_OP_constu);
2677 Asm->EmitULEB128(Entry.getInt());
2679 } else if (Entry.isLocation()) {
2680 MachineLocation Loc = Entry.getLoc();
2681 if (!DV.hasComplexAddress())
2683 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2685 // Complex address entry.
2686 unsigned N = DV.getNumAddrElements();
2688 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2689 if (Loc.getOffset()) {
2691 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2692 Asm->OutStreamer.AddComment("DW_OP_deref");
2693 Asm->EmitInt8(dwarf::DW_OP_deref);
2694 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2695 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2696 Asm->EmitSLEB128(DV.getAddrElement(1));
2698 // If first address element is OpPlus then emit
2699 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2700 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2701 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2705 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2708 // Emit remaining complex address elements.
2709 for (; i < N; ++i) {
2710 uint64_t Element = DV.getAddrElement(i);
2711 if (Element == DIBuilder::OpPlus) {
2712 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2713 Asm->EmitULEB128(DV.getAddrElement(++i));
2714 } else if (Element == DIBuilder::OpDeref) {
2716 Asm->EmitInt8(dwarf::DW_OP_deref);
2718 llvm_unreachable("unknown Opcode found in complex address");
2722 // else ... ignore constant fp. There is not any good way to
2723 // to represent them here in dwarf.
2724 Asm->OutStreamer.EmitLabel(end);
2729 struct SymbolCUSorter {
2730 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2731 const MCStreamer &Streamer;
2733 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2734 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2735 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2737 // Symbols with no order assigned should be placed at the end.
2738 // (e.g. section end labels)
2740 IA = (unsigned)(-1);
2742 IB = (unsigned)(-1);
2747 static bool CUSort(const Unit *A, const Unit *B) {
2748 return (A->getUniqueID() < B->getUniqueID());
2752 const MCSymbol *Start, *End;
2755 // Emit a debug aranges section, containing a CU lookup for any
2756 // address we can tie back to a CU.
2757 void DwarfDebug::emitDebugARanges() {
2758 // Start the dwarf aranges section.
2759 Asm->OutStreamer.SwitchSection(
2760 Asm->getObjFileLowering().getDwarfARangesSection());
2762 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2766 // Build a list of sections used.
2767 std::vector<const MCSection *> Sections;
2768 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2770 const MCSection *Section = it->first;
2771 Sections.push_back(Section);
2774 // Sort the sections into order.
2775 // This is only done to ensure consistent output order across different runs.
2776 std::sort(Sections.begin(), Sections.end(), SectionSort);
2778 // Build a set of address spans, sorted by CU.
2779 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2780 const MCSection *Section = Sections[SecIdx];
2781 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2782 if (List.size() < 2)
2785 // Sort the symbols by offset within the section.
2786 SymbolCUSorter sorter(Asm->OutStreamer);
2787 std::sort(List.begin(), List.end(), sorter);
2789 // If we have no section (e.g. common), just write out
2790 // individual spans for each symbol.
2791 if (Section == NULL) {
2792 for (size_t n = 0; n < List.size(); n++) {
2793 const SymbolCU &Cur = List[n];
2796 Span.Start = Cur.Sym;
2799 Spans[Cur.CU].push_back(Span);
2802 // Build spans between each label.
2803 const MCSymbol *StartSym = List[0].Sym;
2804 for (size_t n = 1; n < List.size(); n++) {
2805 const SymbolCU &Prev = List[n - 1];
2806 const SymbolCU &Cur = List[n];
2808 // Try and build the longest span we can within the same CU.
2809 if (Cur.CU != Prev.CU) {
2811 Span.Start = StartSym;
2813 Spans[Prev.CU].push_back(Span);
2820 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2821 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2823 // Build a list of CUs used.
2824 std::vector<CompileUnit *> CUs;
2825 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2826 CompileUnit *CU = it->first;
2830 // Sort the CU list (again, to ensure consistent output order).
2831 std::sort(CUs.begin(), CUs.end(), CUSort);
2833 // Emit an arange table for each CU we used.
2834 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2835 CompileUnit *CU = CUs[CUIdx];
2836 std::vector<ArangeSpan> &List = Spans[CU];
2838 // Emit size of content not including length itself.
2839 unsigned ContentSize =
2840 sizeof(int16_t) + // DWARF ARange version number
2841 sizeof(int32_t) + // Offset of CU in the .debug_info section
2842 sizeof(int8_t) + // Pointer Size (in bytes)
2843 sizeof(int8_t); // Segment Size (in bytes)
2845 unsigned TupleSize = PtrSize * 2;
2847 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2848 unsigned Padding = 0;
2849 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2852 ContentSize += Padding;
2853 ContentSize += (List.size() + 1) * TupleSize;
2855 // For each compile unit, write the list of spans it covers.
2856 Asm->OutStreamer.AddComment("Length of ARange Set");
2857 Asm->EmitInt32(ContentSize);
2858 Asm->OutStreamer.AddComment("DWARF Arange version number");
2859 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2860 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2861 Asm->EmitSectionOffset(
2862 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2863 DwarfInfoSectionSym);
2864 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2865 Asm->EmitInt8(PtrSize);
2866 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2869 for (unsigned n = 0; n < Padding; n++)
2870 Asm->EmitInt8(0xff);
2872 for (unsigned n = 0; n < List.size(); n++) {
2873 const ArangeSpan &Span = List[n];
2874 Asm->EmitLabelReference(Span.Start, PtrSize);
2876 // Calculate the size as being from the span start to it's end.
2878 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2880 // For symbols without an end marker (e.g. common), we
2881 // write a single arange entry containing just that one symbol.
2882 uint64_t Size = SymSize[Span.Start];
2886 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2890 Asm->OutStreamer.AddComment("ARange terminator");
2891 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2892 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2896 // Emit visible names into a debug ranges section.
2897 void DwarfDebug::emitDebugRanges() {
2898 // Start the dwarf ranges section.
2899 Asm->OutStreamer.SwitchSection(
2900 Asm->getObjFileLowering().getDwarfRangesSection());
2902 // Size for our labels.
2903 unsigned char Size = Asm->getDataLayout().getPointerSize();
2905 // Grab the specific ranges for the compile units in the module.
2906 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2909 CompileUnit *TheCU = I->second;
2910 unsigned ID = TheCU->getUniqueID();
2912 // Emit a symbol so we can find the beginning of our ranges.
2913 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_ranges", ID));
2915 // Iterate over the misc ranges for the compile units in the module.
2916 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2917 for (SmallVectorImpl<RangeSpanList>::const_iterator
2918 I = RangeLists.begin(),
2919 E = RangeLists.end();
2921 const RangeSpanList &List = *I;
2923 // Emit our symbol so we can find the beginning of the range.
2924 Asm->OutStreamer.EmitLabel(List.getSym());
2926 for (SmallVectorImpl<RangeSpan>::const_iterator
2927 RI = List.getRanges().begin(),
2928 RE = List.getRanges().end();
2930 const RangeSpan &Range = *RI;
2931 // We occasionally have ranges without begin/end labels.
2932 // FIXME: Verify and fix.
2933 const MCSymbol *Begin = Range.getStart();
2934 const MCSymbol *End = Range.getEnd();
2935 Begin ? Asm->OutStreamer.EmitSymbolValue(Begin, Size)
2936 : Asm->OutStreamer.EmitIntValue(0, Size);
2937 End ? Asm->OutStreamer.EmitSymbolValue(End, Size)
2938 : Asm->OutStreamer.EmitIntValue(0, Size);
2941 // And terminate the list with two 0 values.
2942 Asm->OutStreamer.EmitIntValue(0, Size);
2943 Asm->OutStreamer.EmitIntValue(0, Size);
2948 // Emit visible names into a debug macinfo section.
2949 void DwarfDebug::emitDebugMacInfo() {
2950 if (const MCSection *LineInfo =
2951 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2952 // Start the dwarf macinfo section.
2953 Asm->OutStreamer.SwitchSection(LineInfo);
2957 // DWARF5 Experimental Separate Dwarf emitters.
2959 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2960 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2961 // DW_AT_ranges_base, DW_AT_addr_base.
2962 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2964 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2965 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2966 Asm, this, &SkeletonHolder);
2968 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2969 CU->getNode().getSplitDebugFilename());
2971 // Relocate to the beginning of the addr_base section, else 0 for the
2972 // beginning of the one for this compile unit.
2973 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2974 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2975 DwarfAddrSectionSym);
2977 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2979 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2980 // into an entity. We're using 0, or a NULL label for this.
2981 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2983 // DW_AT_stmt_list is a offset of line number information for this
2984 // compile unit in debug_line section.
2985 // FIXME: Should handle multiple compile units.
2986 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2987 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
2988 DwarfLineSectionSym);
2990 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2992 if (!CompilationDir.empty())
2993 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2995 addGnuPubAttributes(NewCU, Die);
2997 // Attribute if we've emitted any ranges and their location for the compile
2999 if (!CU->getRangeLists().empty())
3000 addSectionLabel(Asm, NewCU, Die, dwarf::DW_AT_GNU_ranges_base,
3001 Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()),
3002 DwarfDebugRangeSectionSym);
3004 SkeletonHolder.addUnit(NewCU);
3009 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3010 // compile units that would normally be in debug_info.
3011 void DwarfDebug::emitDebugInfoDWO() {
3012 assert(useSplitDwarf() && "No split dwarf debug info?");
3013 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3014 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3015 DwarfAbbrevDWOSectionSym);
3018 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3019 // abbreviations for the .debug_info.dwo section.
3020 void DwarfDebug::emitDebugAbbrevDWO() {
3021 assert(useSplitDwarf() && "No split dwarf?");
3022 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3025 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3026 // string section and is identical in format to traditional .debug_str
3028 void DwarfDebug::emitDebugStrDWO() {
3029 assert(useSplitDwarf() && "No split dwarf?");
3030 const MCSection *OffSec =
3031 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3032 const MCSymbol *StrSym = DwarfStrSectionSym;
3033 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3037 void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
3038 DICompositeType CTy) {
3039 DenseMap<const MDNode *,
3040 std::pair<uint64_t, SmallVectorImpl<DIE *> *> >::iterator I =
3041 TypeUnits.find(CTy);
3042 SmallVector<DIE *, 8> References;
3043 References.push_back(RefDie);
3044 if (I != TypeUnits.end()) {
3045 if (I->second.second) {
3046 I->second.second->push_back(RefDie);
3050 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3051 TypeUnit *NewTU = new TypeUnit(GlobalCUIndexCount++, UnitDie, Language, Asm,
3053 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3056 // Register the type in the TypeUnits map with a vector of references to be
3057 // populated whenever a reference is required.
3058 I = TypeUnits.insert(std::make_pair(CTy, std::make_pair(0, &References)))
3061 // Construct the type, this may, recursively, require more type units that
3062 // may in turn require this type again - in which case they will add DIEs to
3063 // the References vector.
3064 DIE *Die = NewTU->createTypeDIE(CTy);
3066 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3067 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3068 dwarf::DW_FORM_data8,
3069 DIEHash().computeDIEODRSignature(*Die));
3070 // FIXME: This won't handle circularly referential structures, as the DIE
3071 // may have references to other DIEs still under construction and missing
3072 // their signature. Hashing should walk through the signatures to their
3073 // referenced type, or possibly walk the precomputed hashes of related types
3075 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3077 // Remove the References vector and add the type hash.
3078 I->second.first = Signature;
3079 I->second.second = NULL;
3081 InfoHolder.addUnit(NewTU);
3084 // Populate all the signatures.
3085 for (unsigned i = 0, e = References.size(); i != e; ++i) {
3086 CUMap.begin()->second->addUInt(References[i], dwarf::DW_AT_signature,
3087 dwarf::DW_FORM_ref_sig8, I->second.first);