1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
62 GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
66 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
67 cl::desc("Add the CU hash as the dwo_id."),
71 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
72 cl::desc("Generate GNU-style pubnames and pubtypes"),
83 static cl::opt<DefaultOnOff>
84 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
85 cl::desc("Output prototype dwarf accelerator tables."),
86 cl::values(clEnumVal(Default, "Default for platform"),
87 clEnumVal(Enable, "Enabled"),
88 clEnumVal(Disable, "Disabled"), clEnumValEnd),
91 static cl::opt<DefaultOnOff>
92 SplitDwarf("split-dwarf", cl::Hidden,
93 cl::desc("Output DWARF5 split debug info."),
94 cl::values(clEnumVal(Default, "Default for platform"),
95 clEnumVal(Enable, "Enabled"),
96 clEnumVal(Disable, "Disabled"), clEnumValEnd),
99 static cl::opt<DefaultOnOff>
100 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
101 cl::desc("Generate DWARF pubnames and pubtypes sections"),
102 cl::values(clEnumVal(Default, "Default for platform"),
103 clEnumVal(Enable, "Enabled"),
104 clEnumVal(Disable, "Disabled"), clEnumValEnd),
107 static cl::opt<unsigned>
108 DwarfVersionNumber("dwarf-version", cl::Hidden,
109 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
112 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
113 cl::desc("Generate DW_AT_ranges for compile units"),
116 static const char *const DWARFGroupName = "DWARF Emission";
117 static const char *const DbgTimerName = "DWARF Debug Writer";
119 //===----------------------------------------------------------------------===//
123 /// resolve - Look in the DwarfDebug map for the MDNode that
124 /// corresponds to the reference.
125 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
126 return DD->resolve(Ref);
129 DIType DbgVariable::getType() const {
130 DIType Ty = Var.getType();
131 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
132 // addresses instead.
133 if (Var.isBlockByrefVariable()) {
134 /* Byref variables, in Blocks, are declared by the programmer as
135 "SomeType VarName;", but the compiler creates a
136 __Block_byref_x_VarName struct, and gives the variable VarName
137 either the struct, or a pointer to the struct, as its type. This
138 is necessary for various behind-the-scenes things the compiler
139 needs to do with by-reference variables in blocks.
141 However, as far as the original *programmer* is concerned, the
142 variable should still have type 'SomeType', as originally declared.
144 The following function dives into the __Block_byref_x_VarName
145 struct to find the original type of the variable. This will be
146 passed back to the code generating the type for the Debug
147 Information Entry for the variable 'VarName'. 'VarName' will then
148 have the original type 'SomeType' in its debug information.
150 The original type 'SomeType' will be the type of the field named
151 'VarName' inside the __Block_byref_x_VarName struct.
153 NOTE: In order for this to not completely fail on the debugger
154 side, the Debug Information Entry for the variable VarName needs to
155 have a DW_AT_location that tells the debugger how to unwind through
156 the pointers and __Block_byref_x_VarName struct to find the actual
157 value of the variable. The function addBlockByrefType does this. */
159 uint16_t tag = Ty.getTag();
161 if (tag == dwarf::DW_TAG_pointer_type)
162 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
164 DIArray Elements = DICompositeType(subType).getTypeArray();
165 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
166 DIDerivedType DT(Elements.getElement(i));
167 if (getName() == DT.getName())
168 return (resolve(DT.getTypeDerivedFrom()));
174 } // end llvm namespace
176 /// Return Dwarf Version by checking module flags.
177 static unsigned getDwarfVersionFromModule(const Module *M) {
178 Value *Val = M->getModuleFlag("Dwarf Version");
180 return dwarf::DWARF_VERSION;
181 return cast<ConstantInt>(Val)->getZExtValue();
184 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
185 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
186 PrevLabel(NULL), GlobalRangeCount(0),
187 InfoHolder(A, "info_string", DIEValueAllocator),
188 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
190 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
191 DwarfStrSectionSym = TextSectionSym = 0;
192 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
193 DwarfAddrSectionSym = 0;
194 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
195 FunctionBeginSym = FunctionEndSym = 0;
199 // Turn on accelerator tables for Darwin by default, pubnames by
200 // default for non-Darwin, and handle split dwarf.
201 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
203 if (DwarfAccelTables == Default)
204 HasDwarfAccelTables = IsDarwin;
206 HasDwarfAccelTables = DwarfAccelTables == Enable;
208 if (SplitDwarf == Default)
209 HasSplitDwarf = false;
211 HasSplitDwarf = SplitDwarf == Enable;
213 if (DwarfPubSections == Default)
214 HasDwarfPubSections = !IsDarwin;
216 HasDwarfPubSections = DwarfPubSections == Enable;
218 DwarfVersion = DwarfVersionNumber
220 : getDwarfVersionFromModule(MMI->getModule());
223 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
228 // Switch to the specified MCSection and emit an assembler
229 // temporary label to it if SymbolStem is specified.
230 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
231 const char *SymbolStem = 0) {
232 Asm->OutStreamer.SwitchSection(Section);
236 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
237 Asm->OutStreamer.EmitLabel(TmpSym);
241 DwarfFile::~DwarfFile() {
242 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
247 MCSymbol *DwarfFile::getStringPoolSym() {
248 return Asm->GetTempSymbol(StringPref);
251 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
252 std::pair<MCSymbol *, unsigned> &Entry =
253 StringPool.GetOrCreateValue(Str).getValue();
257 Entry.second = NextStringPoolNumber++;
258 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
261 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
262 std::pair<MCSymbol *, unsigned> &Entry =
263 StringPool.GetOrCreateValue(Str).getValue();
267 Entry.second = NextStringPoolNumber++;
268 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
272 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
273 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
276 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
277 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
278 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
280 ++NextAddrPoolNumber;
281 return P.first->second;
284 // Define a unique number for the abbreviation.
286 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
287 // Check the set for priors.
288 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
290 // If it's newly added.
291 if (InSet == &Abbrev) {
292 // Add to abbreviation list.
293 Abbreviations.push_back(&Abbrev);
295 // Assign the vector position + 1 as its number.
296 Abbrev.setNumber(Abbreviations.size());
298 // Assign existing abbreviation number.
299 Abbrev.setNumber(InSet->getNumber());
303 static bool isObjCClass(StringRef Name) {
304 return Name.startswith("+") || Name.startswith("-");
307 static bool hasObjCCategory(StringRef Name) {
308 if (!isObjCClass(Name))
311 return Name.find(") ") != StringRef::npos;
314 static void getObjCClassCategory(StringRef In, StringRef &Class,
315 StringRef &Category) {
316 if (!hasObjCCategory(In)) {
317 Class = In.slice(In.find('[') + 1, In.find(' '));
322 Class = In.slice(In.find('[') + 1, In.find('('));
323 Category = In.slice(In.find('[') + 1, In.find(' '));
327 static StringRef getObjCMethodName(StringRef In) {
328 return In.slice(In.find(' ') + 1, In.find(']'));
331 // Helper for sorting sections into a stable output order.
332 static bool SectionSort(const MCSection *A, const MCSection *B) {
333 std::string LA = (A ? A->getLabelBeginName() : "");
334 std::string LB = (B ? B->getLabelBeginName() : "");
338 // Add the various names to the Dwarf accelerator table names.
339 // TODO: Determine whether or not we should add names for programs
340 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
341 // is only slightly different than the lookup of non-standard ObjC names.
342 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
343 if (!SP.isDefinition())
345 TheU->addAccelName(SP.getName(), Die);
347 // If the linkage name is different than the name, go ahead and output
348 // that as well into the name table.
349 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
350 TheU->addAccelName(SP.getLinkageName(), Die);
352 // If this is an Objective-C selector name add it to the ObjC accelerator
354 if (isObjCClass(SP.getName())) {
355 StringRef Class, Category;
356 getObjCClassCategory(SP.getName(), Class, Category);
357 TheU->addAccelObjC(Class, Die);
359 TheU->addAccelObjC(Category, Die);
360 // Also add the base method name to the name table.
361 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
365 /// isSubprogramContext - Return true if Context is either a subprogram
366 /// or another context nested inside a subprogram.
367 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
370 DIDescriptor D(Context);
371 if (D.isSubprogram())
374 return isSubprogramContext(resolve(DIType(Context).getContext()));
378 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
379 // and DW_AT_high_pc attributes. If there are global variables in this
380 // scope then create and insert DIEs for these variables.
381 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
383 DIE *SPDie = SPCU->getDIE(SP);
385 assert(SPDie && "Unable to find subprogram DIE!");
387 // If we're updating an abstract DIE, then we will be adding the children and
388 // object pointer later on. But what we don't want to do is process the
389 // concrete DIE twice.
390 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
391 // Pick up abstract subprogram DIE.
393 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
394 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
396 DISubprogram SPDecl = SP.getFunctionDeclaration();
397 if (!SPDecl.isSubprogram()) {
398 // There is not any need to generate specification DIE for a function
399 // defined at compile unit level. If a function is defined inside another
400 // function then gdb prefers the definition at top level and but does not
401 // expect specification DIE in parent function. So avoid creating
402 // specification DIE for a function defined inside a function.
403 DIScope SPContext = resolve(SP.getContext());
404 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
405 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
406 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
409 DICompositeType SPTy = SP.getType();
410 DIArray Args = SPTy.getTypeArray();
411 uint16_t SPTag = SPTy.getTag();
412 if (SPTag == dwarf::DW_TAG_subroutine_type)
413 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
415 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
416 DIType ATy(Args.getElement(i));
417 SPCU->addType(Arg, ATy);
418 if (ATy.isArtificial())
419 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
420 if (ATy.isObjectPointer())
421 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
423 DIE *SPDeclDie = SPDie;
424 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
425 *SPCU->getUnitDie());
426 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
431 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
432 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
434 // Add this range to the list of ranges for the CU.
435 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
436 SPCU->addRange(llvm_move(Span));
438 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
439 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
440 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
442 // Add name to the name table, we do this here because we're guaranteed
443 // to have concrete versions of our DW_TAG_subprogram nodes.
444 addSubprogramNames(SPCU, SP, SPDie);
449 /// Check whether we should create a DIE for the given Scope, return true
450 /// if we don't create a DIE (the corresponding DIE is null).
451 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
452 if (Scope->isAbstractScope())
455 // We don't create a DIE if there is no Range.
456 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
460 if (Ranges.size() > 1)
463 // We don't create a DIE if we have a single Range and the end label
465 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
466 MCSymbol *End = getLabelAfterInsn(RI->second);
470 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
471 dwarf::Attribute A, const MCSymbol *L,
472 const MCSymbol *Sec) {
473 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
474 U->addSectionLabel(D, A, L);
476 U->addSectionDelta(D, A, L, Sec);
479 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
480 const SmallVectorImpl<InsnRange> &Range) {
481 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
482 // emitting it appropriately.
483 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
484 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
485 DwarfDebugRangeSectionSym);
487 RangeSpanList List(RangeSym);
488 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
491 RangeSpan Span(getLabelBeforeInsn(RI->first),
492 getLabelAfterInsn(RI->second));
493 List.addRange(llvm_move(Span));
496 // Add the range list to the set of ranges to be emitted.
497 TheCU->addRangeList(llvm_move(List));
500 // Construct new DW_TAG_lexical_block for this scope and attach
501 // DW_AT_low_pc/DW_AT_high_pc labels.
502 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
503 LexicalScope *Scope) {
504 if (isLexicalScopeDIENull(Scope))
507 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
508 if (Scope->isAbstractScope())
511 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
513 // If we have multiple ranges, emit them into the range section.
514 if (ScopeRanges.size() > 1) {
515 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
519 // Construct the address range for this DIE.
520 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
521 MCSymbol *Start = getLabelBeforeInsn(RI->first);
522 MCSymbol *End = getLabelAfterInsn(RI->second);
523 assert(End && "End label should not be null!");
525 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
526 assert(End->isDefined() && "Invalid end label for an inlined scope!");
528 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
529 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
534 // This scope represents inlined body of a function. Construct DIE to
535 // represent this concrete inlined copy of the function.
536 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
537 LexicalScope *Scope) {
538 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
539 assert(!ScopeRanges.empty() &&
540 "LexicalScope does not have instruction markers!");
542 if (!Scope->getScopeNode())
544 DIScope DS(Scope->getScopeNode());
545 DISubprogram InlinedSP = getDISubprogram(DS);
546 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
548 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
552 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
553 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
555 // If we have multiple ranges, emit them into the range section.
556 if (ScopeRanges.size() > 1)
557 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
559 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
560 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
561 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
563 if (StartLabel == 0 || EndLabel == 0)
564 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
566 assert(StartLabel->isDefined() &&
567 "Invalid starting label for an inlined scope!");
568 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
570 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
571 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
574 InlinedSubprogramDIEs.insert(OriginDIE);
576 // Add the call site information to the DIE.
577 DILocation DL(Scope->getInlinedAt());
578 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
579 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
580 TheCU->getUniqueID()));
581 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
583 // Add name to the name table, we do this here because we're guaranteed
584 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
585 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
590 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
592 SmallVectorImpl<DIE *> &Children) {
593 DIE *ObjectPointer = NULL;
595 // Collect arguments for current function.
596 if (LScopes.isCurrentFunctionScope(Scope))
597 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
598 if (DbgVariable *ArgDV = CurrentFnArguments[i])
600 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
601 Children.push_back(Arg);
602 if (ArgDV->isObjectPointer())
606 // Collect lexical scope children first.
607 const SmallVectorImpl<DbgVariable *> &Variables =
608 ScopeVariables.lookup(Scope);
609 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
610 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
611 Scope->isAbstractScope())) {
612 Children.push_back(Variable);
613 if (Variables[i]->isObjectPointer())
614 ObjectPointer = Variable;
616 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
617 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
618 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
619 Children.push_back(Nested);
620 return ObjectPointer;
623 // Construct a DIE for this scope.
624 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
625 LexicalScope *Scope) {
626 if (!Scope || !Scope->getScopeNode())
629 DIScope DS(Scope->getScopeNode());
631 SmallVector<DIE *, 8> Children;
632 DIE *ObjectPointer = NULL;
633 bool ChildrenCreated = false;
635 // We try to create the scope DIE first, then the children DIEs. This will
636 // avoid creating un-used children then removing them later when we find out
637 // the scope DIE is null.
638 DIE *ScopeDIE = NULL;
639 if (Scope->getInlinedAt())
640 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
641 else if (DS.isSubprogram()) {
642 ProcessedSPNodes.insert(DS);
643 if (Scope->isAbstractScope()) {
644 ScopeDIE = TheCU->getDIE(DS);
645 // Note down abstract DIE.
647 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
649 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
651 // Early exit when we know the scope DIE is going to be null.
652 if (isLexicalScopeDIENull(Scope))
655 // We create children here when we know the scope DIE is not going to be
656 // null and the children will be added to the scope DIE.
657 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
658 ChildrenCreated = true;
660 // There is no need to emit empty lexical block DIE.
661 std::pair<ImportedEntityMap::const_iterator,
662 ImportedEntityMap::const_iterator> Range =
664 ScopesWithImportedEntities.begin(),
665 ScopesWithImportedEntities.end(),
666 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
668 if (Children.empty() && Range.first == Range.second)
670 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
671 assert(ScopeDIE && "Scope DIE should not be null.");
672 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
674 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
678 assert(Children.empty() &&
679 "We create children only when the scope DIE is not null.");
682 if (!ChildrenCreated)
683 // We create children when the scope DIE is not null.
684 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
687 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
690 ScopeDIE->addChild(*I);
692 if (DS.isSubprogram() && ObjectPointer != NULL)
693 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
698 // Look up the source id with the given directory and source file names.
699 // If none currently exists, create a new id and insert it in the
700 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
702 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
704 // If we use .loc in assembly, we can't separate .file entries according to
705 // compile units. Thus all files will belong to the default compile unit.
707 // FIXME: add a better feature test than hasRawTextSupport. Even better,
708 // extend .file to support this.
709 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
712 // If FE did not provide a file name, then assume stdin.
713 if (FileName.empty())
714 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
716 // TODO: this might not belong here. See if we can factor this better.
717 if (DirName == CompilationDir)
720 // FileIDCUMap stores the current ID for the given compile unit.
721 unsigned SrcId = FileIDCUMap[CUID] + 1;
723 // We look up the CUID/file/dir by concatenating them with a zero byte.
724 SmallString<128> NamePair;
725 NamePair += utostr(CUID);
728 NamePair += '\0'; // Zero bytes are not allowed in paths.
729 NamePair += FileName;
731 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
732 if (Ent.getValue() != SrcId)
733 return Ent.getValue();
735 FileIDCUMap[CUID] = SrcId;
736 // Print out a .file directive to specify files for .loc directives.
737 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
742 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
743 if (!GenerateGnuPubSections)
746 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
747 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
748 DwarfGnuPubNamesSectionSym);
750 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
751 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
752 DwarfGnuPubTypesSectionSym);
755 // Create new DwarfCompileUnit for the given metadata node with tag
756 // DW_TAG_compile_unit.
757 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
758 StringRef FN = DIUnit.getFilename();
759 CompilationDir = DIUnit.getDirectory();
761 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
762 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
763 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
764 InfoHolder.addUnit(NewCU);
766 FileIDCUMap[NewCU->getUniqueID()] = 0;
767 // Call this to emit a .file directive if it wasn't emitted for the source
768 // file this CU comes from yet.
769 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
771 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
772 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
773 DIUnit.getLanguage());
774 NewCU->addString(Die, dwarf::DW_AT_name, FN);
776 // Define start line table label for each Compile Unit.
777 MCSymbol *LineTableStartSym =
778 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
779 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
780 NewCU->getUniqueID());
782 // Use a single line table if we are using .loc and generating assembly.
784 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
785 (NewCU->getUniqueID() == 0);
787 if (!useSplitDwarf()) {
788 // DW_AT_stmt_list is a offset of line number information for this
789 // compile unit in debug_line section. For split dwarf this is
790 // left in the skeleton CU and so not included.
791 // The line table entries are not always emitted in assembly, so it
792 // is not okay to use line_table_start here.
793 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
794 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
795 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
796 : LineTableStartSym);
797 else if (UseTheFirstCU)
798 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
800 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
801 DwarfLineSectionSym);
803 // If we're using split dwarf the compilation dir is going to be in the
804 // skeleton CU and so we don't need to duplicate it here.
805 if (!CompilationDir.empty())
806 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
808 addGnuPubAttributes(NewCU, Die);
811 if (DIUnit.isOptimized())
812 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
814 StringRef Flags = DIUnit.getFlags();
816 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
818 if (unsigned RVer = DIUnit.getRunTimeVersion())
819 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
820 dwarf::DW_FORM_data1, RVer);
826 useSplitDwarf() ? Asm->getObjFileLowering().getDwarfInfoDWOSection()
827 : Asm->getObjFileLowering().getDwarfInfoSection(),
828 // FIXME: This is subtle (using the info section even when
829 // this CU is in the dwo section) and necessary for the
830 // current arange code - ideally it should iterate
831 // skeleton units, not full units, if it's going to reference skeletons
832 DwarfInfoSectionSym);
834 // If we're splitting the dwarf then construct the skeleton CU now.
836 NewCU->setSkeleton(constructSkeletonCU(NewCU));
838 CUMap.insert(std::make_pair(DIUnit, NewCU));
839 CUDieMap.insert(std::make_pair(Die, NewCU));
843 // Construct subprogram DIE.
844 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
846 // FIXME: We should only call this routine once, however, during LTO if a
847 // program is defined in multiple CUs we could end up calling it out of
848 // beginModule as we walk the CUs.
850 DwarfCompileUnit *&CURef = SPMap[N];
856 if (!SP.isDefinition())
857 // This is a method declaration which will be handled while constructing
861 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
863 // Expose as a global name.
864 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
867 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
869 DIImportedEntity Module(N);
870 if (!Module.Verify())
872 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
873 constructImportedEntityDIE(TheCU, Module, D);
876 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
877 const MDNode *N, DIE *Context) {
878 DIImportedEntity Module(N);
879 if (!Module.Verify())
881 return constructImportedEntityDIE(TheCU, Module, Context);
884 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
885 const DIImportedEntity &Module,
887 assert(Module.Verify() &&
888 "Use one of the MDNode * overloads to handle invalid metadata");
889 assert(Context && "Should always have a context for an imported_module");
890 DIE *IMDie = new DIE(Module.getTag());
891 TheCU->insertDIE(Module, IMDie);
893 DIDescriptor Entity = Module.getEntity();
894 if (Entity.isNameSpace())
895 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
896 else if (Entity.isSubprogram())
897 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
898 else if (Entity.isType())
899 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
901 EntityDie = TheCU->getDIE(Entity);
902 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
903 Module.getContext().getDirectory(),
904 TheCU->getUniqueID());
905 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
906 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
907 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
908 StringRef Name = Module.getName();
910 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
911 Context->addChild(IMDie);
914 // Emit all Dwarf sections that should come prior to the content. Create
915 // global DIEs and emit initial debug info sections. This is invoked by
916 // the target AsmPrinter.
917 void DwarfDebug::beginModule() {
918 if (DisableDebugInfoPrinting)
921 const Module *M = MMI->getModule();
923 // If module has named metadata anchors then use them, otherwise scan the
924 // module using debug info finder to collect debug info.
925 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
928 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
930 // Emit initial sections so we can reference labels later.
933 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
934 DICompileUnit CUNode(CU_Nodes->getOperand(i));
935 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
936 DIArray ImportedEntities = CUNode.getImportedEntities();
937 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
938 ScopesWithImportedEntities.push_back(std::make_pair(
939 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
940 ImportedEntities.getElement(i)));
941 std::sort(ScopesWithImportedEntities.begin(),
942 ScopesWithImportedEntities.end(), less_first());
943 DIArray GVs = CUNode.getGlobalVariables();
944 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
945 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
946 DIArray SPs = CUNode.getSubprograms();
947 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
948 constructSubprogramDIE(CU, SPs.getElement(i));
949 DIArray EnumTypes = CUNode.getEnumTypes();
950 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
951 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
952 DIArray RetainedTypes = CUNode.getRetainedTypes();
953 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
954 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
955 // Emit imported_modules last so that the relevant context is already
957 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
958 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
961 // Tell MMI that we have debug info.
962 MMI->setDebugInfoAvailability(true);
964 // Prime section data.
965 SectionMap[Asm->getObjFileLowering().getTextSection()];
968 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
969 void DwarfDebug::computeInlinedDIEs() {
970 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
971 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
972 AE = InlinedSubprogramDIEs.end();
975 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
977 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
978 AE = AbstractSPDies.end();
980 DIE *ISP = AI->second;
981 if (InlinedSubprogramDIEs.count(ISP))
983 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
987 // Collect info for variables that were optimized out.
988 void DwarfDebug::collectDeadVariables() {
989 const Module *M = MMI->getModule();
991 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
992 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
993 DICompileUnit TheCU(CU_Nodes->getOperand(i));
994 DIArray Subprograms = TheCU.getSubprograms();
995 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
996 DISubprogram SP(Subprograms.getElement(i));
997 if (ProcessedSPNodes.count(SP) != 0)
999 if (!SP.isSubprogram())
1001 if (!SP.isDefinition())
1003 DIArray Variables = SP.getVariables();
1004 if (Variables.getNumElements() == 0)
1007 // Construct subprogram DIE and add variables DIEs.
1008 DwarfCompileUnit *SPCU =
1009 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1010 assert(SPCU && "Unable to find Compile Unit!");
1011 // FIXME: See the comment in constructSubprogramDIE about duplicate
1013 constructSubprogramDIE(SPCU, SP);
1014 DIE *SPDIE = SPCU->getDIE(SP);
1015 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1016 DIVariable DV(Variables.getElement(vi));
1017 if (!DV.isVariable())
1019 DbgVariable NewVar(DV, NULL, this);
1020 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1021 SPDIE->addChild(VariableDIE);
1028 // Type Signature [7.27] and ODR Hash code.
1030 /// \brief Grabs the string in whichever attribute is passed in and returns
1031 /// a reference to it. Returns "" if the attribute doesn't exist.
1032 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1033 DIEValue *V = Die->findAttribute(Attr);
1035 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1036 return S->getString();
1038 return StringRef("");
1041 /// Return true if the current DIE is contained within an anonymous namespace.
1042 static bool isContainedInAnonNamespace(DIE *Die) {
1043 DIE *Parent = Die->getParent();
1046 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1047 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1049 Parent = Parent->getParent();
1055 /// Test if the current CU language is C++ and that we have
1056 /// a named type that is not contained in an anonymous namespace.
1057 static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
1058 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1059 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1060 !isContainedInAnonNamespace(Die);
1063 void DwarfDebug::finalizeModuleInfo() {
1064 // Collect info for variables that were optimized out.
1065 collectDeadVariables();
1067 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1068 computeInlinedDIEs();
1070 // Handle anything that needs to be done on a per-unit basis after
1071 // all other generation.
1072 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1073 E = getUnits().end();
1075 DwarfUnit *TheU = *I;
1076 // Emit DW_AT_containing_type attribute to connect types with their
1077 // vtable holding type.
1078 TheU->constructContainingTypeDIEs();
1080 // Add CU specific attributes if we need to add any.
1081 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1082 // If we're splitting the dwarf out now that we've got the entire
1083 // CU then add the dwo id to it.
1084 DwarfCompileUnit *SkCU =
1085 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1086 if (useSplitDwarf()) {
1087 // This should be a unique identifier when we want to build .dwp files.
1089 if (GenerateCUHash) {
1091 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1093 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1094 dwarf::DW_FORM_data8, ID);
1095 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1096 dwarf::DW_FORM_data8, ID);
1099 // If we've requested ranges and have them emit a DW_AT_ranges attribute
1100 // on the unit that will remain in the .o file, otherwise add a DW_AT_low_pc.
1101 // FIXME: Also add a high pc if we can.
1102 // FIXME: We should use ranges if we have multiple compile units.
1103 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1104 if (DwarfCURanges && TheU->getRanges().size())
1105 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1106 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1107 DwarfDebugRangeSectionSym);
1109 U->addLocalLabelAddress(U->getUnitDie(), dwarf::DW_AT_low_pc,
1114 // Compute DIE offsets and sizes.
1115 InfoHolder.computeSizeAndOffsets();
1116 if (useSplitDwarf())
1117 SkeletonHolder.computeSizeAndOffsets();
1120 void DwarfDebug::endSections() {
1121 // Filter labels by section.
1122 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1123 const SymbolCU &SCU = ArangeLabels[n];
1124 if (SCU.Sym->isInSection()) {
1125 // Make a note of this symbol and it's section.
1126 const MCSection *Section = &SCU.Sym->getSection();
1127 if (!Section->getKind().isMetadata())
1128 SectionMap[Section].push_back(SCU);
1130 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1131 // appear in the output. This sucks as we rely on sections to build
1132 // arange spans. We can do it without, but it's icky.
1133 SectionMap[NULL].push_back(SCU);
1137 // Build a list of sections used.
1138 std::vector<const MCSection *> Sections;
1139 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1141 const MCSection *Section = it->first;
1142 Sections.push_back(Section);
1145 // Sort the sections into order.
1146 // This is only done to ensure consistent output order across different runs.
1147 std::sort(Sections.begin(), Sections.end(), SectionSort);
1149 // Add terminating symbols for each section.
1150 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1151 const MCSection *Section = Sections[ID];
1152 MCSymbol *Sym = NULL;
1155 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1156 // if we know the section name up-front. For user-created sections, the
1158 // label may not be valid to use as a label. (section names can use a
1160 // set of characters on some systems)
1161 Sym = Asm->GetTempSymbol("debug_end", ID);
1162 Asm->OutStreamer.SwitchSection(Section);
1163 Asm->OutStreamer.EmitLabel(Sym);
1166 // Insert a final terminator.
1167 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1171 // Emit all Dwarf sections that should come after the content.
1172 void DwarfDebug::endModule() {
1179 // End any existing sections.
1180 // TODO: Does this need to happen?
1183 // Finalize the debug info for the module.
1184 finalizeModuleInfo();
1188 // Emit all the DIEs into a debug info section.
1191 // Corresponding abbreviations into a abbrev section.
1192 emitAbbreviations();
1194 // Emit info into a debug loc section.
1197 // Emit info into a debug aranges section.
1200 // Emit info into a debug ranges section.
1203 if (useSplitDwarf()) {
1206 emitDebugAbbrevDWO();
1207 // Emit DWO addresses.
1208 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1211 // Emit info into the dwarf accelerator table sections.
1212 if (useDwarfAccelTables()) {
1215 emitAccelNamespaces();
1219 // Emit the pubnames and pubtypes sections if requested.
1220 if (HasDwarfPubSections) {
1221 emitDebugPubNames(GenerateGnuPubSections);
1222 emitDebugPubTypes(GenerateGnuPubSections);
1228 // Reset these for the next Module if we have one.
1232 // Find abstract variable, if any, associated with Var.
1233 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1234 DebugLoc ScopeLoc) {
1235 LLVMContext &Ctx = DV->getContext();
1236 // More then one inlined variable corresponds to one abstract variable.
1237 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1238 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1240 return AbsDbgVariable;
1242 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1246 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1247 addScopeVariable(Scope, AbsDbgVariable);
1248 AbstractVariables[Var] = AbsDbgVariable;
1249 return AbsDbgVariable;
1252 // If Var is a current function argument then add it to CurrentFnArguments list.
1253 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1254 if (!LScopes.isCurrentFunctionScope(Scope))
1256 DIVariable DV = Var->getVariable();
1257 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1259 unsigned ArgNo = DV.getArgNumber();
1263 size_t Size = CurrentFnArguments.size();
1265 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1266 // llvm::Function argument size is not good indicator of how many
1267 // arguments does the function have at source level.
1269 CurrentFnArguments.resize(ArgNo * 2);
1270 CurrentFnArguments[ArgNo - 1] = Var;
1274 // Collect variable information from side table maintained by MMI.
1275 void DwarfDebug::collectVariableInfoFromMMITable(
1276 SmallPtrSet<const MDNode *, 16> &Processed) {
1277 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1278 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1281 const MDNode *Var = VI->first;
1284 Processed.insert(Var);
1286 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1288 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1290 // If variable scope is not found then skip this variable.
1294 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1295 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1296 RegVar->setFrameIndex(VP.first);
1297 if (!addCurrentFnArgument(RegVar, Scope))
1298 addScopeVariable(Scope, RegVar);
1300 AbsDbgVariable->setFrameIndex(VP.first);
1304 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1306 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1307 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1308 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1309 MI->getOperand(0).getReg() &&
1310 (MI->getOperand(1).isImm() ||
1311 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1314 // Get .debug_loc entry for the instruction range starting at MI.
1315 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1316 const MCSymbol *FLabel,
1317 const MCSymbol *SLabel,
1318 const MachineInstr *MI) {
1319 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1321 assert(MI->getNumOperands() == 3);
1322 if (MI->getOperand(0).isReg()) {
1323 MachineLocation MLoc;
1324 // If the second operand is an immediate, this is a
1325 // register-indirect address.
1326 if (!MI->getOperand(1).isImm())
1327 MLoc.set(MI->getOperand(0).getReg());
1329 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1330 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1332 if (MI->getOperand(0).isImm())
1333 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1334 if (MI->getOperand(0).isFPImm())
1335 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1336 if (MI->getOperand(0).isCImm())
1337 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1339 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1342 // Find variables for each lexical scope.
1344 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1346 // Grab the variable info that was squirreled away in the MMI side-table.
1347 collectVariableInfoFromMMITable(Processed);
1349 for (SmallVectorImpl<const MDNode *>::const_iterator
1350 UVI = UserVariables.begin(),
1351 UVE = UserVariables.end();
1352 UVI != UVE; ++UVI) {
1353 const MDNode *Var = *UVI;
1354 if (Processed.count(Var))
1357 // History contains relevant DBG_VALUE instructions for Var and instructions
1359 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1360 if (History.empty())
1362 const MachineInstr *MInsn = History.front();
1365 LexicalScope *Scope = NULL;
1366 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1367 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1368 Scope = LScopes.getCurrentFunctionScope();
1369 else if (MDNode *IA = DV.getInlinedAt())
1370 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1372 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1373 // If variable scope is not found then skip this variable.
1377 Processed.insert(DV);
1378 assert(MInsn->isDebugValue() && "History must begin with debug value");
1379 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1380 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1381 if (!addCurrentFnArgument(RegVar, Scope))
1382 addScopeVariable(Scope, RegVar);
1384 AbsVar->setMInsn(MInsn);
1386 // Simplify ranges that are fully coalesced.
1387 if (History.size() <= 1 ||
1388 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1389 RegVar->setMInsn(MInsn);
1393 // Handle multiple DBG_VALUE instructions describing one variable.
1394 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1396 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1397 HI = History.begin(),
1400 const MachineInstr *Begin = *HI;
1401 assert(Begin->isDebugValue() && "Invalid History entry");
1403 // Check if DBG_VALUE is truncating a range.
1404 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1405 !Begin->getOperand(0).getReg())
1408 // Compute the range for a register location.
1409 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1410 const MCSymbol *SLabel = 0;
1413 // If Begin is the last instruction in History then its value is valid
1414 // until the end of the function.
1415 SLabel = FunctionEndSym;
1417 const MachineInstr *End = HI[1];
1418 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1419 << "\t" << *Begin << "\t" << *End << "\n");
1420 if (End->isDebugValue())
1421 SLabel = getLabelBeforeInsn(End);
1423 // End is a normal instruction clobbering the range.
1424 SLabel = getLabelAfterInsn(End);
1425 assert(SLabel && "Forgot label after clobber instruction");
1430 // The value is valid until the next DBG_VALUE or clobber.
1431 DotDebugLocEntries.push_back(
1432 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1434 DotDebugLocEntries.push_back(DotDebugLocEntry());
1437 // Collect info for variables that were optimized out.
1438 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1439 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1440 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1441 DIVariable DV(Variables.getElement(i));
1442 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1444 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1445 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1449 // Return Label preceding the instruction.
1450 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1451 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1452 assert(Label && "Didn't insert label before instruction");
1456 // Return Label immediately following the instruction.
1457 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1458 return LabelsAfterInsn.lookup(MI);
1461 // Process beginning of an instruction.
1462 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1465 // Check if source location changes, but ignore DBG_VALUE locations.
1466 if (!MI->isDebugValue()) {
1467 DebugLoc DL = MI->getDebugLoc();
1468 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1471 if (DL == PrologEndLoc) {
1472 Flags |= DWARF2_FLAG_PROLOGUE_END;
1473 PrologEndLoc = DebugLoc();
1475 if (PrologEndLoc.isUnknown())
1476 Flags |= DWARF2_FLAG_IS_STMT;
1478 if (!DL.isUnknown()) {
1479 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1480 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1482 recordSourceLine(0, 0, 0, 0);
1486 // Insert labels where requested.
1487 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1488 LabelsBeforeInsn.find(MI);
1491 if (I == LabelsBeforeInsn.end())
1494 // Label already assigned.
1499 PrevLabel = MMI->getContext().CreateTempSymbol();
1500 Asm->OutStreamer.EmitLabel(PrevLabel);
1502 I->second = PrevLabel;
1505 // Process end of an instruction.
1506 void DwarfDebug::endInstruction() {
1508 // Don't create a new label after DBG_VALUE instructions.
1509 // They don't generate code.
1510 if (!CurMI->isDebugValue())
1513 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1514 LabelsAfterInsn.find(CurMI);
1518 if (I == LabelsAfterInsn.end())
1521 // Label already assigned.
1525 // We need a label after this instruction.
1527 PrevLabel = MMI->getContext().CreateTempSymbol();
1528 Asm->OutStreamer.EmitLabel(PrevLabel);
1530 I->second = PrevLabel;
1533 // Each LexicalScope has first instruction and last instruction to mark
1534 // beginning and end of a scope respectively. Create an inverse map that list
1535 // scopes starts (and ends) with an instruction. One instruction may start (or
1536 // end) multiple scopes. Ignore scopes that are not reachable.
1537 void DwarfDebug::identifyScopeMarkers() {
1538 SmallVector<LexicalScope *, 4> WorkList;
1539 WorkList.push_back(LScopes.getCurrentFunctionScope());
1540 while (!WorkList.empty()) {
1541 LexicalScope *S = WorkList.pop_back_val();
1543 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1544 if (!Children.empty())
1545 for (SmallVectorImpl<LexicalScope *>::const_iterator
1546 SI = Children.begin(),
1547 SE = Children.end();
1549 WorkList.push_back(*SI);
1551 if (S->isAbstractScope())
1554 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1557 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1560 assert(RI->first && "InsnRange does not have first instruction!");
1561 assert(RI->second && "InsnRange does not have second instruction!");
1562 requestLabelBeforeInsn(RI->first);
1563 requestLabelAfterInsn(RI->second);
1568 // Get MDNode for DebugLoc's scope.
1569 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1570 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1571 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1572 return DL.getScope(Ctx);
1575 // Walk up the scope chain of given debug loc and find line number info
1576 // for the function.
1577 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1578 const MDNode *Scope = getScopeNode(DL, Ctx);
1579 DISubprogram SP = getDISubprogram(Scope);
1580 if (SP.isSubprogram()) {
1581 // Check for number of operands since the compatibility is
1583 if (SP->getNumOperands() > 19)
1584 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1586 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1592 // Gather pre-function debug information. Assumes being called immediately
1593 // after the function entry point has been emitted.
1594 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1597 // If there's no debug info for the function we're not going to do anything.
1598 if (!MMI->hasDebugInfo())
1601 // Grab the lexical scopes for the function, if we don't have any of those
1602 // then we're not going to be able to do anything.
1603 LScopes.initialize(*MF);
1604 if (LScopes.empty())
1607 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1609 // Make sure that each lexical scope will have a begin/end label.
1610 identifyScopeMarkers();
1612 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1613 // belongs to so that we add to the correct per-cu line table in the
1615 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1616 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1617 assert(TheCU && "Unable to find compile unit!");
1618 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1619 // Use a single line table if we are using .loc and generating assembly.
1620 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1622 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1624 // Emit a label for the function so that we have a beginning address.
1625 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1626 // Assumes in correct section after the entry point.
1627 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1629 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1630 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1631 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1633 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1635 bool AtBlockEntry = true;
1636 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1638 const MachineInstr *MI = II;
1640 if (MI->isDebugValue()) {
1641 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1643 // Keep track of user variables.
1645 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1647 // Variable is in a register, we need to check for clobbers.
1648 if (isDbgValueInDefinedReg(MI))
1649 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1651 // Check the history of this variable.
1652 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1653 if (History.empty()) {
1654 UserVariables.push_back(Var);
1655 // The first mention of a function argument gets the FunctionBeginSym
1656 // label, so arguments are visible when breaking at function entry.
1658 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1659 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1660 LabelsBeforeInsn[MI] = FunctionBeginSym;
1662 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1663 const MachineInstr *Prev = History.back();
1664 if (Prev->isDebugValue()) {
1665 // Coalesce identical entries at the end of History.
1666 if (History.size() >= 2 &&
1667 Prev->isIdenticalTo(History[History.size() - 2])) {
1668 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1669 << "\t" << *Prev << "\t"
1670 << *History[History.size() - 2] << "\n");
1674 // Terminate old register assignments that don't reach MI;
1675 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1676 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1677 isDbgValueInDefinedReg(Prev)) {
1678 // Previous register assignment needs to terminate at the end of
1680 MachineBasicBlock::const_iterator LastMI =
1681 PrevMBB->getLastNonDebugInstr();
1682 if (LastMI == PrevMBB->end()) {
1683 // Drop DBG_VALUE for empty range.
1684 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1685 << "\t" << *Prev << "\n");
1687 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1688 // Terminate after LastMI.
1689 History.push_back(LastMI);
1693 History.push_back(MI);
1695 // Not a DBG_VALUE instruction.
1697 AtBlockEntry = false;
1699 // First known non-DBG_VALUE and non-frame setup location marks
1700 // the beginning of the function body.
1701 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1702 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1703 PrologEndLoc = MI->getDebugLoc();
1705 // Check if the instruction clobbers any registers with debug vars.
1706 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1707 MOE = MI->operands_end();
1708 MOI != MOE; ++MOI) {
1709 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1711 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1714 const MDNode *Var = LiveUserVar[Reg];
1717 // Reg is now clobbered.
1718 LiveUserVar[Reg] = 0;
1720 // Was MD last defined by a DBG_VALUE referring to Reg?
1721 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1722 if (HistI == DbgValues.end())
1724 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1725 if (History.empty())
1727 const MachineInstr *Prev = History.back();
1728 // Sanity-check: Register assignments are terminated at the end of
1730 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1732 // Is the variable still in Reg?
1733 if (!isDbgValueInDefinedReg(Prev) ||
1734 Prev->getOperand(0).getReg() != Reg)
1736 // Var is clobbered. Make sure the next instruction gets a label.
1737 History.push_back(MI);
1744 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1746 SmallVectorImpl<const MachineInstr *> &History = I->second;
1747 if (History.empty())
1750 // Make sure the final register assignments are terminated.
1751 const MachineInstr *Prev = History.back();
1752 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1753 const MachineBasicBlock *PrevMBB = Prev->getParent();
1754 MachineBasicBlock::const_iterator LastMI =
1755 PrevMBB->getLastNonDebugInstr();
1756 if (LastMI == PrevMBB->end())
1757 // Drop DBG_VALUE for empty range.
1759 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1760 // Terminate after LastMI.
1761 History.push_back(LastMI);
1764 // Request labels for the full history.
1765 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1766 const MachineInstr *MI = History[i];
1767 if (MI->isDebugValue())
1768 requestLabelBeforeInsn(MI);
1770 requestLabelAfterInsn(MI);
1774 PrevInstLoc = DebugLoc();
1775 PrevLabel = FunctionBeginSym;
1777 // Record beginning of function.
1778 if (!PrologEndLoc.isUnknown()) {
1779 DebugLoc FnStartDL =
1780 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1782 FnStartDL.getLine(), FnStartDL.getCol(),
1783 FnStartDL.getScope(MF->getFunction()->getContext()),
1784 // We'd like to list the prologue as "not statements" but GDB behaves
1785 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1786 DWARF2_FLAG_IS_STMT);
1790 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1791 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1792 DIVariable DV = Var->getVariable();
1793 // Variables with positive arg numbers are parameters.
1794 if (unsigned ArgNum = DV.getArgNumber()) {
1795 // Keep all parameters in order at the start of the variable list to ensure
1796 // function types are correct (no out-of-order parameters)
1798 // This could be improved by only doing it for optimized builds (unoptimized
1799 // builds have the right order to begin with), searching from the back (this
1800 // would catch the unoptimized case quickly), or doing a binary search
1801 // rather than linear search.
1802 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1803 while (I != Vars.end()) {
1804 unsigned CurNum = (*I)->getVariable().getArgNumber();
1805 // A local (non-parameter) variable has been found, insert immediately
1809 // A later indexed parameter has been found, insert immediately before it.
1810 if (CurNum > ArgNum)
1814 Vars.insert(I, Var);
1818 Vars.push_back(Var);
1821 // Gather and emit post-function debug information.
1822 void DwarfDebug::endFunction(const MachineFunction *MF) {
1823 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1824 // though the beginFunction may not be called at all.
1825 // We should handle both cases.
1829 assert(CurFn == MF);
1832 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1837 // Define end label for subprogram.
1838 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1839 // Assumes in correct section after the entry point.
1840 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1841 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1842 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1844 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1845 collectVariableInfo(ProcessedVars);
1847 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1848 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1849 assert(TheCU && "Unable to find compile unit!");
1851 // Construct abstract scopes.
1852 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1853 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1854 LexicalScope *AScope = AList[i];
1855 DISubprogram SP(AScope->getScopeNode());
1856 if (SP.isSubprogram()) {
1857 // Collect info for variables that were optimized out.
1858 DIArray Variables = SP.getVariables();
1859 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1860 DIVariable DV(Variables.getElement(i));
1861 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1863 // Check that DbgVariable for DV wasn't created earlier, when
1864 // findAbstractVariable() was called for inlined instance of DV.
1865 LLVMContext &Ctx = DV->getContext();
1866 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1867 if (AbstractVariables.lookup(CleanDV))
1869 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1870 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1873 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1874 constructScopeDIE(TheCU, AScope);
1877 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1879 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1880 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1883 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1884 E = ScopeVariables.end();
1886 DeleteContainerPointers(I->second);
1887 ScopeVariables.clear();
1888 DeleteContainerPointers(CurrentFnArguments);
1889 UserVariables.clear();
1891 AbstractVariables.clear();
1892 LabelsBeforeInsn.clear();
1893 LabelsAfterInsn.clear();
1898 // Register a source line with debug info. Returns the unique label that was
1899 // emitted and which provides correspondence to the source line list.
1900 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1906 DIDescriptor Scope(S);
1908 if (Scope.isCompileUnit()) {
1909 DICompileUnit CU(S);
1910 Fn = CU.getFilename();
1911 Dir = CU.getDirectory();
1912 } else if (Scope.isFile()) {
1914 Fn = F.getFilename();
1915 Dir = F.getDirectory();
1916 } else if (Scope.isSubprogram()) {
1918 Fn = SP.getFilename();
1919 Dir = SP.getDirectory();
1920 } else if (Scope.isLexicalBlockFile()) {
1921 DILexicalBlockFile DBF(S);
1922 Fn = DBF.getFilename();
1923 Dir = DBF.getDirectory();
1924 } else if (Scope.isLexicalBlock()) {
1925 DILexicalBlock DB(S);
1926 Fn = DB.getFilename();
1927 Dir = DB.getDirectory();
1929 llvm_unreachable("Unexpected scope info");
1931 Src = getOrCreateSourceID(
1932 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1934 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1937 //===----------------------------------------------------------------------===//
1939 //===----------------------------------------------------------------------===//
1941 // Compute the size and offset of a DIE. The offset is relative to start of the
1942 // CU. It returns the offset after laying out the DIE.
1943 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1944 // Get the children.
1945 const std::vector<DIE *> &Children = Die->getChildren();
1947 // Record the abbreviation.
1948 assignAbbrevNumber(Die->getAbbrev());
1950 // Get the abbreviation for this DIE.
1951 const DIEAbbrev &Abbrev = Die->getAbbrev();
1954 Die->setOffset(Offset);
1956 // Start the size with the size of abbreviation code.
1957 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1959 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1960 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1962 // Size the DIE attribute values.
1963 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1964 // Size attribute value.
1965 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1967 // Size the DIE children if any.
1968 if (!Children.empty()) {
1969 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1970 "Children flag not set");
1972 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1973 Offset = computeSizeAndOffset(Children[j], Offset);
1975 // End of children marker.
1976 Offset += sizeof(int8_t);
1979 Die->setSize(Offset - Die->getOffset());
1983 // Compute the size and offset for each DIE.
1984 void DwarfFile::computeSizeAndOffsets() {
1985 // Offset from the first CU in the debug info section is 0 initially.
1986 unsigned SecOffset = 0;
1988 // Iterate over each compile unit and set the size and offsets for each
1989 // DIE within each compile unit. All offsets are CU relative.
1990 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1993 (*I)->setDebugInfoOffset(SecOffset);
1995 // CU-relative offset is reset to 0 here.
1996 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1997 (*I)->getHeaderSize(); // Unit-specific headers
1999 // EndOffset here is CU-relative, after laying out
2000 // all of the CU DIE.
2001 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
2002 SecOffset += EndOffset;
2006 // Emit initial Dwarf sections with a label at the start of each one.
2007 void DwarfDebug::emitSectionLabels() {
2008 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2010 // Dwarf sections base addresses.
2011 DwarfInfoSectionSym =
2012 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2013 DwarfAbbrevSectionSym =
2014 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2015 if (useSplitDwarf())
2016 DwarfAbbrevDWOSectionSym = emitSectionSym(
2017 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
2018 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2020 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2021 emitSectionSym(Asm, MacroInfo);
2023 DwarfLineSectionSym =
2024 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2025 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2026 if (GenerateGnuPubSections) {
2027 DwarfGnuPubNamesSectionSym =
2028 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2029 DwarfGnuPubTypesSectionSym =
2030 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2031 } else if (HasDwarfPubSections) {
2032 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2033 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2036 DwarfStrSectionSym =
2037 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2038 if (useSplitDwarf()) {
2039 DwarfStrDWOSectionSym =
2040 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2041 DwarfAddrSectionSym =
2042 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2044 DwarfDebugRangeSectionSym =
2045 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2047 DwarfDebugLocSectionSym =
2048 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2050 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2051 emitSectionSym(Asm, TLOF.getDataSection());
2054 // Recursively emits a debug information entry.
2055 void DwarfDebug::emitDIE(DIE *Die) {
2056 // Get the abbreviation for this DIE.
2057 const DIEAbbrev &Abbrev = Die->getAbbrev();
2059 // Emit the code (index) for the abbreviation.
2060 if (Asm->isVerbose())
2061 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2062 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2063 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2064 dwarf::TagString(Abbrev.getTag()));
2065 Asm->EmitULEB128(Abbrev.getNumber());
2067 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2068 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2070 // Emit the DIE attribute values.
2071 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2072 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2073 dwarf::Form Form = AbbrevData[i].getForm();
2074 assert(Form && "Too many attributes for DIE (check abbreviation)");
2076 if (Asm->isVerbose())
2077 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2080 case dwarf::DW_AT_abstract_origin:
2081 case dwarf::DW_AT_type:
2082 case dwarf::DW_AT_friend:
2083 case dwarf::DW_AT_specification:
2084 case dwarf::DW_AT_import:
2085 case dwarf::DW_AT_containing_type: {
2086 DIEEntry *E = cast<DIEEntry>(Values[i]);
2087 DIE *Origin = E->getEntry();
2088 unsigned Addr = Origin->getOffset();
2089 if (Form == dwarf::DW_FORM_ref_addr) {
2090 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2091 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2092 // section. Origin->getOffset() returns the offset from start of the
2094 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2095 assert(CU && "CUDie should belong to a CU.");
2096 Addr += CU->getDebugInfoOffset();
2097 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2098 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2099 DIEEntry::getRefAddrSize(Asm));
2101 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2102 CU->getSectionSym(),
2103 DIEEntry::getRefAddrSize(Asm));
2105 // Make sure Origin belong to the same CU.
2106 assert(Die->getUnit() == Origin->getUnit() &&
2107 "The referenced DIE should belong to the same CU in ref4");
2108 Asm->EmitInt32(Addr);
2112 case dwarf::DW_AT_location: {
2113 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2114 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2115 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2117 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2119 Values[i]->EmitValue(Asm, Form);
2123 case dwarf::DW_AT_accessibility: {
2124 if (Asm->isVerbose()) {
2125 DIEInteger *V = cast<DIEInteger>(Values[i]);
2126 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2128 Values[i]->EmitValue(Asm, Form);
2132 // Emit an attribute using the defined form.
2133 Values[i]->EmitValue(Asm, Form);
2138 // Emit the DIE children if any.
2139 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2140 const std::vector<DIE *> &Children = Die->getChildren();
2142 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2143 emitDIE(Children[j]);
2145 Asm->OutStreamer.AddComment("End Of Children Mark");
2150 // Emit the various dwarf units to the unit section USection with
2151 // the abbreviations going into ASection.
2152 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2153 const MCSymbol *ASectionSym) {
2154 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2156 DwarfUnit *TheU = *I;
2157 DIE *Die = TheU->getUnitDie();
2158 const MCSection *USection = TheU->getSection();
2159 Asm->OutStreamer.SwitchSection(USection);
2161 // Emit the compile units header.
2162 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2164 // Emit size of content not including length itself
2165 Asm->OutStreamer.AddComment("Length of Unit");
2166 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2168 TheU->emitHeader(ASection, ASectionSym);
2171 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2175 // Emit the debug info section.
2176 void DwarfDebug::emitDebugInfo() {
2177 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2179 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2180 DwarfAbbrevSectionSym);
2183 // Emit the abbreviation section.
2184 void DwarfDebug::emitAbbreviations() {
2185 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2187 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2190 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2191 // Check to see if it is worth the effort.
2192 if (!Abbreviations.empty()) {
2193 // Start the debug abbrev section.
2194 Asm->OutStreamer.SwitchSection(Section);
2196 // For each abbrevation.
2197 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2198 // Get abbreviation data
2199 const DIEAbbrev *Abbrev = Abbreviations[i];
2201 // Emit the abbrevations code (base 1 index.)
2202 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2204 // Emit the abbreviations data.
2208 // Mark end of abbreviations.
2209 Asm->EmitULEB128(0, "EOM(3)");
2213 // Emit the last address of the section and the end of the line matrix.
2214 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2215 // Define last address of section.
2216 Asm->OutStreamer.AddComment("Extended Op");
2219 Asm->OutStreamer.AddComment("Op size");
2220 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2221 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2222 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2224 Asm->OutStreamer.AddComment("Section end label");
2226 Asm->OutStreamer.EmitSymbolValue(
2227 Asm->GetTempSymbol("section_end", SectionEnd),
2228 Asm->getDataLayout().getPointerSize());
2230 // Mark end of matrix.
2231 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2237 // Emit visible names into a hashed accelerator table section.
2238 void DwarfDebug::emitAccelNames() {
2240 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2241 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2242 E = getUnits().end();
2244 DwarfUnit *TheU = *I;
2245 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2246 for (StringMap<std::vector<const DIE *> >::const_iterator
2250 StringRef Name = GI->getKey();
2251 const std::vector<const DIE *> &Entities = GI->second;
2252 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2253 DE = Entities.end();
2255 AT.AddName(Name, *DI);
2259 AT.FinalizeTable(Asm, "Names");
2260 Asm->OutStreamer.SwitchSection(
2261 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2262 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2263 Asm->OutStreamer.EmitLabel(SectionBegin);
2265 // Emit the full data.
2266 AT.Emit(Asm, SectionBegin, &InfoHolder);
2269 // Emit objective C classes and categories into a hashed accelerator table
2271 void DwarfDebug::emitAccelObjC() {
2273 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2274 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2275 E = getUnits().end();
2277 DwarfUnit *TheU = *I;
2278 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2279 for (StringMap<std::vector<const DIE *> >::const_iterator
2283 StringRef Name = GI->getKey();
2284 const std::vector<const DIE *> &Entities = GI->second;
2285 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2286 DE = Entities.end();
2288 AT.AddName(Name, *DI);
2292 AT.FinalizeTable(Asm, "ObjC");
2293 Asm->OutStreamer.SwitchSection(
2294 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2295 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2296 Asm->OutStreamer.EmitLabel(SectionBegin);
2298 // Emit the full data.
2299 AT.Emit(Asm, SectionBegin, &InfoHolder);
2302 // Emit namespace dies into a hashed accelerator table.
2303 void DwarfDebug::emitAccelNamespaces() {
2305 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2306 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2307 E = getUnits().end();
2309 DwarfUnit *TheU = *I;
2310 const StringMap<std::vector<const DIE *> > &Names =
2311 TheU->getAccelNamespace();
2312 for (StringMap<std::vector<const DIE *> >::const_iterator
2316 StringRef Name = GI->getKey();
2317 const std::vector<const DIE *> &Entities = GI->second;
2318 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2319 DE = Entities.end();
2321 AT.AddName(Name, *DI);
2325 AT.FinalizeTable(Asm, "namespac");
2326 Asm->OutStreamer.SwitchSection(
2327 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2328 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2329 Asm->OutStreamer.EmitLabel(SectionBegin);
2331 // Emit the full data.
2332 AT.Emit(Asm, SectionBegin, &InfoHolder);
2335 // Emit type dies into a hashed accelerator table.
2336 void DwarfDebug::emitAccelTypes() {
2337 std::vector<DwarfAccelTable::Atom> Atoms;
2339 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2341 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2343 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2344 DwarfAccelTable AT(Atoms);
2345 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2346 E = getUnits().end();
2348 DwarfUnit *TheU = *I;
2349 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2350 TheU->getAccelTypes();
2352 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2356 StringRef Name = GI->getKey();
2357 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2359 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2360 DI = Entities.begin(),
2361 DE = Entities.end();
2363 AT.AddName(Name, DI->first, DI->second);
2367 AT.FinalizeTable(Asm, "types");
2368 Asm->OutStreamer.SwitchSection(
2369 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2370 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2371 Asm->OutStreamer.EmitLabel(SectionBegin);
2373 // Emit the full data.
2374 AT.Emit(Asm, SectionBegin, &InfoHolder);
2377 // Public name handling.
2378 // The format for the various pubnames:
2380 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2381 // for the DIE that is named.
2383 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2384 // into the CU and the index value is computed according to the type of value
2385 // for the DIE that is named.
2387 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2388 // it's the offset within the debug_info/debug_types dwo section, however, the
2389 // reference in the pubname header doesn't change.
2391 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2392 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2394 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2396 // We could have a specification DIE that has our most of our knowledge,
2397 // look for that now.
2398 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2400 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2401 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2402 Linkage = dwarf::GIEL_EXTERNAL;
2403 } else if (Die->findAttribute(dwarf::DW_AT_external))
2404 Linkage = dwarf::GIEL_EXTERNAL;
2406 switch (Die->getTag()) {
2407 case dwarf::DW_TAG_class_type:
2408 case dwarf::DW_TAG_structure_type:
2409 case dwarf::DW_TAG_union_type:
2410 case dwarf::DW_TAG_enumeration_type:
2411 return dwarf::PubIndexEntryDescriptor(
2412 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2413 ? dwarf::GIEL_STATIC
2414 : dwarf::GIEL_EXTERNAL);
2415 case dwarf::DW_TAG_typedef:
2416 case dwarf::DW_TAG_base_type:
2417 case dwarf::DW_TAG_subrange_type:
2418 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2419 case dwarf::DW_TAG_namespace:
2420 return dwarf::GIEK_TYPE;
2421 case dwarf::DW_TAG_subprogram:
2422 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2423 case dwarf::DW_TAG_constant:
2424 case dwarf::DW_TAG_variable:
2425 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2426 case dwarf::DW_TAG_enumerator:
2427 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2428 dwarf::GIEL_STATIC);
2430 return dwarf::GIEK_NONE;
2434 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2436 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2437 const MCSection *PSec =
2438 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2439 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2441 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2442 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2443 for (unsigned i = 0; i != Units.size(); ++i) {
2444 DwarfUnit *TheU = Units[i];
2445 unsigned ID = TheU->getUniqueID();
2447 // Start the dwarf pubnames section.
2448 Asm->OutStreamer.SwitchSection(PSec);
2450 // Emit a label so we can reference the beginning of this pubname section.
2452 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2455 Asm->OutStreamer.AddComment("Length of Public Names Info");
2456 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2457 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2458 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2460 Asm->OutStreamer.EmitLabel(BeginLabel);
2462 Asm->OutStreamer.AddComment("DWARF Version");
2463 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2465 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2466 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2468 Asm->OutStreamer.AddComment("Compilation Unit Length");
2469 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2471 // Emit the pubnames for this compilation unit.
2472 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2473 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2476 const char *Name = GI->getKeyData();
2477 const DIE *Entity = GI->second;
2479 Asm->OutStreamer.AddComment("DIE offset");
2480 Asm->EmitInt32(Entity->getOffset());
2483 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2484 Asm->OutStreamer.AddComment(
2485 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2486 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2487 Asm->EmitInt8(Desc.toBits());
2490 Asm->OutStreamer.AddComment("External Name");
2491 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2494 Asm->OutStreamer.AddComment("End Mark");
2496 Asm->OutStreamer.EmitLabel(EndLabel);
2500 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2501 const MCSection *PSec =
2502 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2503 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2505 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2506 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2507 for (unsigned i = 0; i != Units.size(); ++i) {
2508 DwarfUnit *TheU = Units[i];
2509 unsigned ID = TheU->getUniqueID();
2511 // Start the dwarf pubtypes section.
2512 Asm->OutStreamer.SwitchSection(PSec);
2514 // Emit a label so we can reference the beginning of this pubtype section.
2516 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2519 Asm->OutStreamer.AddComment("Length of Public Types Info");
2520 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2521 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2522 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2524 Asm->OutStreamer.EmitLabel(BeginLabel);
2526 Asm->OutStreamer.AddComment("DWARF Version");
2527 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2529 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2530 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2532 Asm->OutStreamer.AddComment("Compilation Unit Length");
2533 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2535 // Emit the pubtypes.
2536 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2537 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2540 const char *Name = GI->getKeyData();
2541 const DIE *Entity = GI->second;
2543 Asm->OutStreamer.AddComment("DIE offset");
2544 Asm->EmitInt32(Entity->getOffset());
2547 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2548 Asm->OutStreamer.AddComment(
2549 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2550 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2551 Asm->EmitInt8(Desc.toBits());
2554 Asm->OutStreamer.AddComment("External Name");
2556 // Emit the name with a terminating null byte.
2557 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2560 Asm->OutStreamer.AddComment("End Mark");
2562 Asm->OutStreamer.EmitLabel(EndLabel);
2566 // Emit strings into a string section.
2567 void DwarfFile::emitStrings(const MCSection *StrSection,
2568 const MCSection *OffsetSection = NULL,
2569 const MCSymbol *StrSecSym = NULL) {
2571 if (StringPool.empty())
2574 // Start the dwarf str section.
2575 Asm->OutStreamer.SwitchSection(StrSection);
2577 // Get all of the string pool entries and put them in an array by their ID so
2578 // we can sort them.
2580 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2583 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2584 I = StringPool.begin(),
2585 E = StringPool.end();
2587 Entries.push_back(std::make_pair(I->second.second, &*I));
2589 array_pod_sort(Entries.begin(), Entries.end());
2591 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2592 // Emit a label for reference from debug information entries.
2593 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2595 // Emit the string itself with a terminating null byte.
2596 Asm->OutStreamer.EmitBytes(
2597 StringRef(Entries[i].second->getKeyData(),
2598 Entries[i].second->getKeyLength() + 1));
2601 // If we've got an offset section go ahead and emit that now as well.
2602 if (OffsetSection) {
2603 Asm->OutStreamer.SwitchSection(OffsetSection);
2604 unsigned offset = 0;
2605 unsigned size = 4; // FIXME: DWARF64 is 8.
2606 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2607 Asm->OutStreamer.EmitIntValue(offset, size);
2608 offset += Entries[i].second->getKeyLength() + 1;
2613 // Emit addresses into the section given.
2614 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2616 if (AddressPool.empty())
2619 // Start the dwarf addr section.
2620 Asm->OutStreamer.SwitchSection(AddrSection);
2622 // Order the address pool entries by ID
2623 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2625 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2626 E = AddressPool.end();
2628 Entries[I->second] = I->first;
2630 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2631 // Emit an expression for reference from debug information entries.
2632 if (const MCExpr *Expr = Entries[i])
2633 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2635 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2639 // Emit visible names into a debug str section.
2640 void DwarfDebug::emitDebugStr() {
2641 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2642 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2645 // Emit locations into the debug loc section.
2646 void DwarfDebug::emitDebugLoc() {
2647 if (DotDebugLocEntries.empty())
2650 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2651 I = DotDebugLocEntries.begin(),
2652 E = DotDebugLocEntries.end();
2654 DotDebugLocEntry &Entry = *I;
2655 if (I + 1 != DotDebugLocEntries.end())
2659 // Start the dwarf loc section.
2660 Asm->OutStreamer.SwitchSection(
2661 Asm->getObjFileLowering().getDwarfLocSection());
2662 unsigned char Size = Asm->getDataLayout().getPointerSize();
2663 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2665 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2666 I = DotDebugLocEntries.begin(),
2667 E = DotDebugLocEntries.end();
2668 I != E; ++I, ++index) {
2669 DotDebugLocEntry &Entry = *I;
2670 if (Entry.isMerged())
2672 if (Entry.isEmpty()) {
2673 Asm->OutStreamer.EmitIntValue(0, Size);
2674 Asm->OutStreamer.EmitIntValue(0, Size);
2675 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2677 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2678 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2679 DIVariable DV(Entry.getVariable());
2680 Asm->OutStreamer.AddComment("Loc expr size");
2681 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2682 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2683 Asm->EmitLabelDifference(end, begin, 2);
2684 Asm->OutStreamer.EmitLabel(begin);
2685 if (Entry.isInt()) {
2686 DIBasicType BTy(DV.getType());
2687 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2688 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2689 Asm->OutStreamer.AddComment("DW_OP_consts");
2690 Asm->EmitInt8(dwarf::DW_OP_consts);
2691 Asm->EmitSLEB128(Entry.getInt());
2693 Asm->OutStreamer.AddComment("DW_OP_constu");
2694 Asm->EmitInt8(dwarf::DW_OP_constu);
2695 Asm->EmitULEB128(Entry.getInt());
2697 } else if (Entry.isLocation()) {
2698 MachineLocation Loc = Entry.getLoc();
2699 if (!DV.hasComplexAddress())
2701 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2703 // Complex address entry.
2704 unsigned N = DV.getNumAddrElements();
2706 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2707 if (Loc.getOffset()) {
2709 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2710 Asm->OutStreamer.AddComment("DW_OP_deref");
2711 Asm->EmitInt8(dwarf::DW_OP_deref);
2712 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2713 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2714 Asm->EmitSLEB128(DV.getAddrElement(1));
2716 // If first address element is OpPlus then emit
2717 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2718 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2719 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2723 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2726 // Emit remaining complex address elements.
2727 for (; i < N; ++i) {
2728 uint64_t Element = DV.getAddrElement(i);
2729 if (Element == DIBuilder::OpPlus) {
2730 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2731 Asm->EmitULEB128(DV.getAddrElement(++i));
2732 } else if (Element == DIBuilder::OpDeref) {
2734 Asm->EmitInt8(dwarf::DW_OP_deref);
2736 llvm_unreachable("unknown Opcode found in complex address");
2740 // else ... ignore constant fp. There is not any good way to
2741 // to represent them here in dwarf.
2742 Asm->OutStreamer.EmitLabel(end);
2747 struct SymbolCUSorter {
2748 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2749 const MCStreamer &Streamer;
2751 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2752 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2753 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2755 // Symbols with no order assigned should be placed at the end.
2756 // (e.g. section end labels)
2758 IA = (unsigned)(-1);
2760 IB = (unsigned)(-1);
2765 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2766 return (A->getUniqueID() < B->getUniqueID());
2770 const MCSymbol *Start, *End;
2773 // Emit a debug aranges section, containing a CU lookup for any
2774 // address we can tie back to a CU.
2775 void DwarfDebug::emitDebugARanges() {
2776 // Start the dwarf aranges section.
2777 Asm->OutStreamer.SwitchSection(
2778 Asm->getObjFileLowering().getDwarfARangesSection());
2780 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2784 // Build a list of sections used.
2785 std::vector<const MCSection *> Sections;
2786 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2788 const MCSection *Section = it->first;
2789 Sections.push_back(Section);
2792 // Sort the sections into order.
2793 // This is only done to ensure consistent output order across different runs.
2794 std::sort(Sections.begin(), Sections.end(), SectionSort);
2796 // Build a set of address spans, sorted by CU.
2797 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2798 const MCSection *Section = Sections[SecIdx];
2799 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2800 if (List.size() < 2)
2803 // Sort the symbols by offset within the section.
2804 SymbolCUSorter sorter(Asm->OutStreamer);
2805 std::sort(List.begin(), List.end(), sorter);
2807 // If we have no section (e.g. common), just write out
2808 // individual spans for each symbol.
2809 if (Section == NULL) {
2810 for (size_t n = 0; n < List.size(); n++) {
2811 const SymbolCU &Cur = List[n];
2814 Span.Start = Cur.Sym;
2817 Spans[Cur.CU].push_back(Span);
2820 // Build spans between each label.
2821 const MCSymbol *StartSym = List[0].Sym;
2822 for (size_t n = 1; n < List.size(); n++) {
2823 const SymbolCU &Prev = List[n - 1];
2824 const SymbolCU &Cur = List[n];
2826 // Try and build the longest span we can within the same CU.
2827 if (Cur.CU != Prev.CU) {
2829 Span.Start = StartSym;
2831 Spans[Prev.CU].push_back(Span);
2838 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2840 // Build a list of CUs used.
2841 std::vector<DwarfCompileUnit *> CUs;
2842 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2843 DwarfCompileUnit *CU = it->first;
2847 // Sort the CU list (again, to ensure consistent output order).
2848 std::sort(CUs.begin(), CUs.end(), CUSort);
2850 // Emit an arange table for each CU we used.
2851 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2852 DwarfCompileUnit *CU = CUs[CUIdx];
2853 std::vector<ArangeSpan> &List = Spans[CU];
2855 // Emit size of content not including length itself.
2856 unsigned ContentSize =
2857 sizeof(int16_t) + // DWARF ARange version number
2858 sizeof(int32_t) + // Offset of CU in the .debug_info section
2859 sizeof(int8_t) + // Pointer Size (in bytes)
2860 sizeof(int8_t); // Segment Size (in bytes)
2862 unsigned TupleSize = PtrSize * 2;
2864 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2865 unsigned Padding = 0;
2866 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2869 ContentSize += Padding;
2870 ContentSize += (List.size() + 1) * TupleSize;
2872 // For each compile unit, write the list of spans it covers.
2873 Asm->OutStreamer.AddComment("Length of ARange Set");
2874 Asm->EmitInt32(ContentSize);
2875 Asm->OutStreamer.AddComment("DWARF Arange version number");
2876 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2877 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2878 Asm->EmitSectionOffset(CU->getLabelBegin(), CU->getSectionSym());
2879 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2880 Asm->EmitInt8(PtrSize);
2881 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2884 for (unsigned n = 0; n < Padding; n++)
2885 Asm->EmitInt8(0xff);
2887 for (unsigned n = 0; n < List.size(); n++) {
2888 const ArangeSpan &Span = List[n];
2889 Asm->EmitLabelReference(Span.Start, PtrSize);
2891 // Calculate the size as being from the span start to it's end.
2893 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2895 // For symbols without an end marker (e.g. common), we
2896 // write a single arange entry containing just that one symbol.
2897 uint64_t Size = SymSize[Span.Start];
2901 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2905 Asm->OutStreamer.AddComment("ARange terminator");
2906 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2907 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2911 // Emit visible names into a debug ranges section.
2912 void DwarfDebug::emitDebugRanges() {
2913 // Start the dwarf ranges section.
2914 Asm->OutStreamer.SwitchSection(
2915 Asm->getObjFileLowering().getDwarfRangesSection());
2917 // Size for our labels.
2918 unsigned char Size = Asm->getDataLayout().getPointerSize();
2920 // Grab the specific ranges for the compile units in the module.
2921 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2924 DwarfCompileUnit *TheCU = I->second;
2926 // Emit a symbol so we can find the beginning of our ranges.
2927 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2929 // Iterate over the misc ranges for the compile units in the module.
2930 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2931 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2932 E = RangeLists.end();
2934 const RangeSpanList &List = *I;
2936 // Emit our symbol so we can find the beginning of the range.
2937 Asm->OutStreamer.EmitLabel(List.getSym());
2939 for (SmallVectorImpl<RangeSpan>::const_iterator
2940 RI = List.getRanges().begin(),
2941 RE = List.getRanges().end();
2943 const RangeSpan &Range = *RI;
2944 const MCSymbol *Begin = Range.getStart();
2945 const MCSymbol *End = Range.getEnd();
2946 assert(Begin && "Range without a begin symbol?");
2947 assert(End && "Range without an end symbol?");
2948 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2949 Asm->OutStreamer.EmitSymbolValue(End, Size);
2952 // And terminate the list with two 0 values.
2953 Asm->OutStreamer.EmitIntValue(0, Size);
2954 Asm->OutStreamer.EmitIntValue(0, Size);
2957 // Now emit a range for the CU itself.
2958 if (DwarfCURanges) {
2959 Asm->OutStreamer.EmitLabel(
2960 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2961 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2962 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2963 RangeSpan Range = Ranges[i];
2964 const MCSymbol *Begin = Range.getStart();
2965 const MCSymbol *End = Range.getEnd();
2966 assert(Begin && "Range without a begin symbol?");
2967 assert(End && "Range without an end symbol?");
2968 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2969 Asm->OutStreamer.EmitSymbolValue(End, Size);
2971 // And terminate the list with two 0 values.
2972 Asm->OutStreamer.EmitIntValue(0, Size);
2973 Asm->OutStreamer.EmitIntValue(0, Size);
2978 // DWARF5 Experimental Separate Dwarf emitters.
2980 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2981 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2982 // DW_AT_ranges_base, DW_AT_addr_base.
2983 // TODO: Implement DW_AT_ranges_base.
2984 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2986 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2987 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2988 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2989 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2990 DwarfInfoSectionSym);
2992 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2993 CU->getNode().getSplitDebugFilename());
2995 // Relocate to the beginning of the addr_base section, else 0 for the
2996 // beginning of the one for this compile unit.
2997 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2998 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2999 DwarfAddrSectionSym);
3001 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3003 // DW_AT_stmt_list is a offset of line number information for this
3004 // compile unit in debug_line section.
3005 // FIXME: Should handle multiple compile units.
3006 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3007 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3009 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3011 if (!CompilationDir.empty())
3012 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3014 addGnuPubAttributes(NewCU, Die);
3016 SkeletonHolder.addUnit(NewCU);
3021 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3022 // compile units that would normally be in debug_info.
3023 void DwarfDebug::emitDebugInfoDWO() {
3024 assert(useSplitDwarf() && "No split dwarf debug info?");
3025 InfoHolder.emitUnits(this,
3026 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3027 DwarfAbbrevDWOSectionSym);
3030 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3031 // abbreviations for the .debug_info.dwo section.
3032 void DwarfDebug::emitDebugAbbrevDWO() {
3033 assert(useSplitDwarf() && "No split dwarf?");
3034 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3037 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3038 // string section and is identical in format to traditional .debug_str
3040 void DwarfDebug::emitDebugStrDWO() {
3041 assert(useSplitDwarf() && "No split dwarf?");
3042 const MCSection *OffSec =
3043 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3044 const MCSymbol *StrSym = DwarfStrSectionSym;
3045 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3049 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3050 DICompositeType CTy) {
3051 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3053 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3054 DwarfTypeUnit *NewTU =
3055 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3058 InfoHolder.addUnit(NewTU);
3060 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3063 DIE *Die = NewTU->createTypeDIE(CTy);
3065 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3066 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3067 dwarf::DW_FORM_data8,
3068 DIEHash().computeDIEODRSignature(*Die));
3069 // FIXME: This won't handle circularly referential structures, as the DIE
3070 // may have references to other DIEs still under construction and missing
3071 // their signature. Hashing should walk through the signatures to their
3072 // referenced type, or possibly walk the precomputed hashes of related types
3074 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3075 NewTU->setTypeSignature(Signature);
3076 NewTU->setType(Die);
3080 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3081 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3084 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);