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);
825 if (useSplitDwarf()) {
826 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
827 DwarfInfoDWOSectionSym);
828 NewCU->setSkeleton(constructSkeletonCU(NewCU));
830 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
831 DwarfInfoSectionSym);
833 CUMap.insert(std::make_pair(DIUnit, NewCU));
834 CUDieMap.insert(std::make_pair(Die, NewCU));
838 // Construct subprogram DIE.
839 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
841 // FIXME: We should only call this routine once, however, during LTO if a
842 // program is defined in multiple CUs we could end up calling it out of
843 // beginModule as we walk the CUs.
845 DwarfCompileUnit *&CURef = SPMap[N];
851 if (!SP.isDefinition())
852 // This is a method declaration which will be handled while constructing
856 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
858 // Expose as a global name.
859 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
862 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
864 DIImportedEntity Module(N);
865 if (!Module.Verify())
867 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
868 constructImportedEntityDIE(TheCU, Module, D);
871 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
872 const MDNode *N, DIE *Context) {
873 DIImportedEntity Module(N);
874 if (!Module.Verify())
876 return constructImportedEntityDIE(TheCU, Module, Context);
879 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
880 const DIImportedEntity &Module,
882 assert(Module.Verify() &&
883 "Use one of the MDNode * overloads to handle invalid metadata");
884 assert(Context && "Should always have a context for an imported_module");
885 DIE *IMDie = new DIE(Module.getTag());
886 TheCU->insertDIE(Module, IMDie);
888 DIDescriptor Entity = Module.getEntity();
889 if (Entity.isNameSpace())
890 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
891 else if (Entity.isSubprogram())
892 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
893 else if (Entity.isType())
894 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
896 EntityDie = TheCU->getDIE(Entity);
897 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
898 Module.getContext().getDirectory(),
899 TheCU->getUniqueID());
900 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
901 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
902 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
903 StringRef Name = Module.getName();
905 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
906 Context->addChild(IMDie);
909 // Emit all Dwarf sections that should come prior to the content. Create
910 // global DIEs and emit initial debug info sections. This is invoked by
911 // the target AsmPrinter.
912 void DwarfDebug::beginModule() {
913 if (DisableDebugInfoPrinting)
916 const Module *M = MMI->getModule();
918 // If module has named metadata anchors then use them, otherwise scan the
919 // module using debug info finder to collect debug info.
920 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
923 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
925 // Emit initial sections so we can reference labels later.
928 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
929 DICompileUnit CUNode(CU_Nodes->getOperand(i));
930 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
931 DIArray ImportedEntities = CUNode.getImportedEntities();
932 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
933 ScopesWithImportedEntities.push_back(std::make_pair(
934 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
935 ImportedEntities.getElement(i)));
936 std::sort(ScopesWithImportedEntities.begin(),
937 ScopesWithImportedEntities.end(), less_first());
938 DIArray GVs = CUNode.getGlobalVariables();
939 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
940 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
941 DIArray SPs = CUNode.getSubprograms();
942 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
943 constructSubprogramDIE(CU, SPs.getElement(i));
944 DIArray EnumTypes = CUNode.getEnumTypes();
945 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
946 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
947 DIArray RetainedTypes = CUNode.getRetainedTypes();
948 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
949 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
950 // Emit imported_modules last so that the relevant context is already
952 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
953 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
956 // Tell MMI that we have debug info.
957 MMI->setDebugInfoAvailability(true);
959 // Prime section data.
960 SectionMap[Asm->getObjFileLowering().getTextSection()];
963 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
964 void DwarfDebug::computeInlinedDIEs() {
965 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
966 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
967 AE = InlinedSubprogramDIEs.end();
970 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
972 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
973 AE = AbstractSPDies.end();
975 DIE *ISP = AI->second;
976 if (InlinedSubprogramDIEs.count(ISP))
978 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
982 // Collect info for variables that were optimized out.
983 void DwarfDebug::collectDeadVariables() {
984 const Module *M = MMI->getModule();
986 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
987 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
988 DICompileUnit TheCU(CU_Nodes->getOperand(i));
989 DIArray Subprograms = TheCU.getSubprograms();
990 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
991 DISubprogram SP(Subprograms.getElement(i));
992 if (ProcessedSPNodes.count(SP) != 0)
994 if (!SP.isSubprogram())
996 if (!SP.isDefinition())
998 DIArray Variables = SP.getVariables();
999 if (Variables.getNumElements() == 0)
1002 // Construct subprogram DIE and add variables DIEs.
1003 DwarfCompileUnit *SPCU =
1004 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1005 assert(SPCU && "Unable to find Compile Unit!");
1006 // FIXME: See the comment in constructSubprogramDIE about duplicate
1008 constructSubprogramDIE(SPCU, SP);
1009 DIE *SPDIE = SPCU->getDIE(SP);
1010 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1011 DIVariable DV(Variables.getElement(vi));
1012 if (!DV.isVariable())
1014 DbgVariable NewVar(DV, NULL, this);
1015 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1016 SPDIE->addChild(VariableDIE);
1023 // Type Signature [7.27] and ODR Hash code.
1025 /// \brief Grabs the string in whichever attribute is passed in and returns
1026 /// a reference to it. Returns "" if the attribute doesn't exist.
1027 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1028 DIEValue *V = Die->findAttribute(Attr);
1030 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1031 return S->getString();
1033 return StringRef("");
1036 /// Return true if the current DIE is contained within an anonymous namespace.
1037 static bool isContainedInAnonNamespace(DIE *Die) {
1038 DIE *Parent = Die->getParent();
1041 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1042 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1044 Parent = Parent->getParent();
1050 /// Test if the current CU language is C++ and that we have
1051 /// a named type that is not contained in an anonymous namespace.
1052 static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
1053 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1054 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1055 !isContainedInAnonNamespace(Die);
1058 void DwarfDebug::finalizeModuleInfo() {
1059 // Collect info for variables that were optimized out.
1060 collectDeadVariables();
1062 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1063 computeInlinedDIEs();
1065 // Handle anything that needs to be done on a per-unit basis after
1066 // all other generation.
1067 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1068 E = getUnits().end();
1070 DwarfUnit *TheU = *I;
1071 // Emit DW_AT_containing_type attribute to connect types with their
1072 // vtable holding type.
1073 TheU->constructContainingTypeDIEs();
1075 // Add CU specific attributes if we need to add any.
1076 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1077 // If we're splitting the dwarf out now that we've got the entire
1078 // CU then add the dwo id to it.
1079 DwarfCompileUnit *SkCU =
1080 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1081 if (useSplitDwarf()) {
1082 // This should be a unique identifier when we want to build .dwp files.
1084 if (GenerateCUHash) {
1086 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1088 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1089 dwarf::DW_FORM_data8, ID);
1090 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1091 dwarf::DW_FORM_data8, ID);
1094 // If we've requested ranges and have them emit a DW_AT_ranges attribute
1095 // on the unit that will remain in the .o file, otherwise add a DW_AT_low_pc.
1096 // FIXME: Also add a high pc if we can.
1097 // FIXME: We should use ranges if we have multiple compile units.
1098 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1099 if (DwarfCURanges && TheU->getRanges().size())
1100 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1101 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1102 DwarfDebugRangeSectionSym);
1104 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
1108 // Compute DIE offsets and sizes.
1109 InfoHolder.computeSizeAndOffsets();
1110 if (useSplitDwarf())
1111 SkeletonHolder.computeSizeAndOffsets();
1114 void DwarfDebug::endSections() {
1115 // Filter labels by section.
1116 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1117 const SymbolCU &SCU = ArangeLabels[n];
1118 if (SCU.Sym->isInSection()) {
1119 // Make a note of this symbol and it's section.
1120 const MCSection *Section = &SCU.Sym->getSection();
1121 if (!Section->getKind().isMetadata())
1122 SectionMap[Section].push_back(SCU);
1124 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1125 // appear in the output. This sucks as we rely on sections to build
1126 // arange spans. We can do it without, but it's icky.
1127 SectionMap[NULL].push_back(SCU);
1131 // Build a list of sections used.
1132 std::vector<const MCSection *> Sections;
1133 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1135 const MCSection *Section = it->first;
1136 Sections.push_back(Section);
1139 // Sort the sections into order.
1140 // This is only done to ensure consistent output order across different runs.
1141 std::sort(Sections.begin(), Sections.end(), SectionSort);
1143 // Add terminating symbols for each section.
1144 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1145 const MCSection *Section = Sections[ID];
1146 MCSymbol *Sym = NULL;
1149 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1150 // if we know the section name up-front. For user-created sections, the
1152 // label may not be valid to use as a label. (section names can use a
1154 // set of characters on some systems)
1155 Sym = Asm->GetTempSymbol("debug_end", ID);
1156 Asm->OutStreamer.SwitchSection(Section);
1157 Asm->OutStreamer.EmitLabel(Sym);
1160 // Insert a final terminator.
1161 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1165 // Emit all Dwarf sections that should come after the content.
1166 void DwarfDebug::endModule() {
1173 // End any existing sections.
1174 // TODO: Does this need to happen?
1177 // Finalize the debug info for the module.
1178 finalizeModuleInfo();
1182 // Emit all the DIEs into a debug info section.
1185 // Corresponding abbreviations into a abbrev section.
1186 emitAbbreviations();
1188 // Emit info into a debug loc section.
1191 // Emit info into a debug aranges section.
1194 // Emit info into a debug ranges section.
1197 if (useSplitDwarf()) {
1200 emitDebugAbbrevDWO();
1201 // Emit DWO addresses.
1202 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1205 // Emit info into the dwarf accelerator table sections.
1206 if (useDwarfAccelTables()) {
1209 emitAccelNamespaces();
1213 // Emit the pubnames and pubtypes sections if requested.
1214 if (HasDwarfPubSections) {
1215 emitDebugPubNames(GenerateGnuPubSections);
1216 emitDebugPubTypes(GenerateGnuPubSections);
1222 // Reset these for the next Module if we have one.
1226 // Find abstract variable, if any, associated with Var.
1227 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1228 DebugLoc ScopeLoc) {
1229 LLVMContext &Ctx = DV->getContext();
1230 // More then one inlined variable corresponds to one abstract variable.
1231 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1232 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1234 return AbsDbgVariable;
1236 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1240 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1241 addScopeVariable(Scope, AbsDbgVariable);
1242 AbstractVariables[Var] = AbsDbgVariable;
1243 return AbsDbgVariable;
1246 // If Var is a current function argument then add it to CurrentFnArguments list.
1247 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1248 if (!LScopes.isCurrentFunctionScope(Scope))
1250 DIVariable DV = Var->getVariable();
1251 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1253 unsigned ArgNo = DV.getArgNumber();
1257 size_t Size = CurrentFnArguments.size();
1259 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1260 // llvm::Function argument size is not good indicator of how many
1261 // arguments does the function have at source level.
1263 CurrentFnArguments.resize(ArgNo * 2);
1264 CurrentFnArguments[ArgNo - 1] = Var;
1268 // Collect variable information from side table maintained by MMI.
1269 void DwarfDebug::collectVariableInfoFromMMITable(
1270 SmallPtrSet<const MDNode *, 16> &Processed) {
1271 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1272 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1275 const MDNode *Var = VI->first;
1278 Processed.insert(Var);
1280 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1282 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1284 // If variable scope is not found then skip this variable.
1288 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1289 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1290 RegVar->setFrameIndex(VP.first);
1291 if (!addCurrentFnArgument(RegVar, Scope))
1292 addScopeVariable(Scope, RegVar);
1294 AbsDbgVariable->setFrameIndex(VP.first);
1298 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1300 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1301 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1302 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1303 MI->getOperand(0).getReg() &&
1304 (MI->getOperand(1).isImm() ||
1305 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1308 // Get .debug_loc entry for the instruction range starting at MI.
1309 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1310 const MCSymbol *FLabel,
1311 const MCSymbol *SLabel,
1312 const MachineInstr *MI) {
1313 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1315 assert(MI->getNumOperands() == 3);
1316 if (MI->getOperand(0).isReg()) {
1317 MachineLocation MLoc;
1318 // If the second operand is an immediate, this is a
1319 // register-indirect address.
1320 if (!MI->getOperand(1).isImm())
1321 MLoc.set(MI->getOperand(0).getReg());
1323 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1324 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1326 if (MI->getOperand(0).isImm())
1327 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1328 if (MI->getOperand(0).isFPImm())
1329 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1330 if (MI->getOperand(0).isCImm())
1331 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1333 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1336 // Find variables for each lexical scope.
1338 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1340 // Grab the variable info that was squirreled away in the MMI side-table.
1341 collectVariableInfoFromMMITable(Processed);
1343 for (SmallVectorImpl<const MDNode *>::const_iterator
1344 UVI = UserVariables.begin(),
1345 UVE = UserVariables.end();
1346 UVI != UVE; ++UVI) {
1347 const MDNode *Var = *UVI;
1348 if (Processed.count(Var))
1351 // History contains relevant DBG_VALUE instructions for Var and instructions
1353 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1354 if (History.empty())
1356 const MachineInstr *MInsn = History.front();
1359 LexicalScope *Scope = NULL;
1360 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1361 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1362 Scope = LScopes.getCurrentFunctionScope();
1363 else if (MDNode *IA = DV.getInlinedAt())
1364 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1366 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1367 // If variable scope is not found then skip this variable.
1371 Processed.insert(DV);
1372 assert(MInsn->isDebugValue() && "History must begin with debug value");
1373 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1374 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1375 if (!addCurrentFnArgument(RegVar, Scope))
1376 addScopeVariable(Scope, RegVar);
1378 AbsVar->setMInsn(MInsn);
1380 // Simplify ranges that are fully coalesced.
1381 if (History.size() <= 1 ||
1382 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1383 RegVar->setMInsn(MInsn);
1387 // Handle multiple DBG_VALUE instructions describing one variable.
1388 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1390 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1391 HI = History.begin(),
1394 const MachineInstr *Begin = *HI;
1395 assert(Begin->isDebugValue() && "Invalid History entry");
1397 // Check if DBG_VALUE is truncating a range.
1398 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1399 !Begin->getOperand(0).getReg())
1402 // Compute the range for a register location.
1403 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1404 const MCSymbol *SLabel = 0;
1407 // If Begin is the last instruction in History then its value is valid
1408 // until the end of the function.
1409 SLabel = FunctionEndSym;
1411 const MachineInstr *End = HI[1];
1412 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1413 << "\t" << *Begin << "\t" << *End << "\n");
1414 if (End->isDebugValue())
1415 SLabel = getLabelBeforeInsn(End);
1417 // End is a normal instruction clobbering the range.
1418 SLabel = getLabelAfterInsn(End);
1419 assert(SLabel && "Forgot label after clobber instruction");
1424 // The value is valid until the next DBG_VALUE or clobber.
1425 DotDebugLocEntries.push_back(
1426 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1428 DotDebugLocEntries.push_back(DotDebugLocEntry());
1431 // Collect info for variables that were optimized out.
1432 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1433 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1434 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1435 DIVariable DV(Variables.getElement(i));
1436 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1438 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1439 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1443 // Return Label preceding the instruction.
1444 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1445 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1446 assert(Label && "Didn't insert label before instruction");
1450 // Return Label immediately following the instruction.
1451 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1452 return LabelsAfterInsn.lookup(MI);
1455 // Process beginning of an instruction.
1456 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1459 // Check if source location changes, but ignore DBG_VALUE locations.
1460 if (!MI->isDebugValue()) {
1461 DebugLoc DL = MI->getDebugLoc();
1462 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1465 if (DL == PrologEndLoc) {
1466 Flags |= DWARF2_FLAG_PROLOGUE_END;
1467 PrologEndLoc = DebugLoc();
1469 if (PrologEndLoc.isUnknown())
1470 Flags |= DWARF2_FLAG_IS_STMT;
1472 if (!DL.isUnknown()) {
1473 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1474 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1476 recordSourceLine(0, 0, 0, 0);
1480 // Insert labels where requested.
1481 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1482 LabelsBeforeInsn.find(MI);
1485 if (I == LabelsBeforeInsn.end())
1488 // Label already assigned.
1493 PrevLabel = MMI->getContext().CreateTempSymbol();
1494 Asm->OutStreamer.EmitLabel(PrevLabel);
1496 I->second = PrevLabel;
1499 // Process end of an instruction.
1500 void DwarfDebug::endInstruction() {
1502 // Don't create a new label after DBG_VALUE instructions.
1503 // They don't generate code.
1504 if (!CurMI->isDebugValue())
1507 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1508 LabelsAfterInsn.find(CurMI);
1512 if (I == LabelsAfterInsn.end())
1515 // Label already assigned.
1519 // We need a label after this instruction.
1521 PrevLabel = MMI->getContext().CreateTempSymbol();
1522 Asm->OutStreamer.EmitLabel(PrevLabel);
1524 I->second = PrevLabel;
1527 // Each LexicalScope has first instruction and last instruction to mark
1528 // beginning and end of a scope respectively. Create an inverse map that list
1529 // scopes starts (and ends) with an instruction. One instruction may start (or
1530 // end) multiple scopes. Ignore scopes that are not reachable.
1531 void DwarfDebug::identifyScopeMarkers() {
1532 SmallVector<LexicalScope *, 4> WorkList;
1533 WorkList.push_back(LScopes.getCurrentFunctionScope());
1534 while (!WorkList.empty()) {
1535 LexicalScope *S = WorkList.pop_back_val();
1537 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1538 if (!Children.empty())
1539 for (SmallVectorImpl<LexicalScope *>::const_iterator
1540 SI = Children.begin(),
1541 SE = Children.end();
1543 WorkList.push_back(*SI);
1545 if (S->isAbstractScope())
1548 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1551 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1554 assert(RI->first && "InsnRange does not have first instruction!");
1555 assert(RI->second && "InsnRange does not have second instruction!");
1556 requestLabelBeforeInsn(RI->first);
1557 requestLabelAfterInsn(RI->second);
1562 // Get MDNode for DebugLoc's scope.
1563 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1564 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1565 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1566 return DL.getScope(Ctx);
1569 // Walk up the scope chain of given debug loc and find line number info
1570 // for the function.
1571 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1572 const MDNode *Scope = getScopeNode(DL, Ctx);
1573 DISubprogram SP = getDISubprogram(Scope);
1574 if (SP.isSubprogram()) {
1575 // Check for number of operands since the compatibility is
1577 if (SP->getNumOperands() > 19)
1578 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1580 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1586 // Gather pre-function debug information. Assumes being called immediately
1587 // after the function entry point has been emitted.
1588 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1591 // If there's no debug info for the function we're not going to do anything.
1592 if (!MMI->hasDebugInfo())
1595 // Grab the lexical scopes for the function, if we don't have any of those
1596 // then we're not going to be able to do anything.
1597 LScopes.initialize(*MF);
1598 if (LScopes.empty())
1601 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1603 // Make sure that each lexical scope will have a begin/end label.
1604 identifyScopeMarkers();
1606 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1607 // belongs to so that we add to the correct per-cu line table in the
1609 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1610 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1611 assert(TheCU && "Unable to find compile unit!");
1612 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1613 // Use a single line table if we are using .loc and generating assembly.
1614 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1616 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1618 // Emit a label for the function so that we have a beginning address.
1619 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1620 // Assumes in correct section after the entry point.
1621 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1623 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1624 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1625 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1627 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1629 bool AtBlockEntry = true;
1630 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1632 const MachineInstr *MI = II;
1634 if (MI->isDebugValue()) {
1635 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1637 // Keep track of user variables.
1639 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1641 // Variable is in a register, we need to check for clobbers.
1642 if (isDbgValueInDefinedReg(MI))
1643 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1645 // Check the history of this variable.
1646 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1647 if (History.empty()) {
1648 UserVariables.push_back(Var);
1649 // The first mention of a function argument gets the FunctionBeginSym
1650 // label, so arguments are visible when breaking at function entry.
1652 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1653 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1654 LabelsBeforeInsn[MI] = FunctionBeginSym;
1656 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1657 const MachineInstr *Prev = History.back();
1658 if (Prev->isDebugValue()) {
1659 // Coalesce identical entries at the end of History.
1660 if (History.size() >= 2 &&
1661 Prev->isIdenticalTo(History[History.size() - 2])) {
1662 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1663 << "\t" << *Prev << "\t"
1664 << *History[History.size() - 2] << "\n");
1668 // Terminate old register assignments that don't reach MI;
1669 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1670 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1671 isDbgValueInDefinedReg(Prev)) {
1672 // Previous register assignment needs to terminate at the end of
1674 MachineBasicBlock::const_iterator LastMI =
1675 PrevMBB->getLastNonDebugInstr();
1676 if (LastMI == PrevMBB->end()) {
1677 // Drop DBG_VALUE for empty range.
1678 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1679 << "\t" << *Prev << "\n");
1681 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1682 // Terminate after LastMI.
1683 History.push_back(LastMI);
1687 History.push_back(MI);
1689 // Not a DBG_VALUE instruction.
1691 AtBlockEntry = false;
1693 // First known non-DBG_VALUE and non-frame setup location marks
1694 // the beginning of the function body.
1695 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1696 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1697 PrologEndLoc = MI->getDebugLoc();
1699 // Check if the instruction clobbers any registers with debug vars.
1700 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1701 MOE = MI->operands_end();
1702 MOI != MOE; ++MOI) {
1703 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1705 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1708 const MDNode *Var = LiveUserVar[Reg];
1711 // Reg is now clobbered.
1712 LiveUserVar[Reg] = 0;
1714 // Was MD last defined by a DBG_VALUE referring to Reg?
1715 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1716 if (HistI == DbgValues.end())
1718 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1719 if (History.empty())
1721 const MachineInstr *Prev = History.back();
1722 // Sanity-check: Register assignments are terminated at the end of
1724 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1726 // Is the variable still in Reg?
1727 if (!isDbgValueInDefinedReg(Prev) ||
1728 Prev->getOperand(0).getReg() != Reg)
1730 // Var is clobbered. Make sure the next instruction gets a label.
1731 History.push_back(MI);
1738 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1740 SmallVectorImpl<const MachineInstr *> &History = I->second;
1741 if (History.empty())
1744 // Make sure the final register assignments are terminated.
1745 const MachineInstr *Prev = History.back();
1746 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1747 const MachineBasicBlock *PrevMBB = Prev->getParent();
1748 MachineBasicBlock::const_iterator LastMI =
1749 PrevMBB->getLastNonDebugInstr();
1750 if (LastMI == PrevMBB->end())
1751 // Drop DBG_VALUE for empty range.
1753 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1754 // Terminate after LastMI.
1755 History.push_back(LastMI);
1758 // Request labels for the full history.
1759 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1760 const MachineInstr *MI = History[i];
1761 if (MI->isDebugValue())
1762 requestLabelBeforeInsn(MI);
1764 requestLabelAfterInsn(MI);
1768 PrevInstLoc = DebugLoc();
1769 PrevLabel = FunctionBeginSym;
1771 // Record beginning of function.
1772 if (!PrologEndLoc.isUnknown()) {
1773 DebugLoc FnStartDL =
1774 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1776 FnStartDL.getLine(), FnStartDL.getCol(),
1777 FnStartDL.getScope(MF->getFunction()->getContext()),
1778 // We'd like to list the prologue as "not statements" but GDB behaves
1779 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1780 DWARF2_FLAG_IS_STMT);
1784 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1785 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1786 DIVariable DV = Var->getVariable();
1787 // Variables with positive arg numbers are parameters.
1788 if (unsigned ArgNum = DV.getArgNumber()) {
1789 // Keep all parameters in order at the start of the variable list to ensure
1790 // function types are correct (no out-of-order parameters)
1792 // This could be improved by only doing it for optimized builds (unoptimized
1793 // builds have the right order to begin with), searching from the back (this
1794 // would catch the unoptimized case quickly), or doing a binary search
1795 // rather than linear search.
1796 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1797 while (I != Vars.end()) {
1798 unsigned CurNum = (*I)->getVariable().getArgNumber();
1799 // A local (non-parameter) variable has been found, insert immediately
1803 // A later indexed parameter has been found, insert immediately before it.
1804 if (CurNum > ArgNum)
1808 Vars.insert(I, Var);
1812 Vars.push_back(Var);
1815 // Gather and emit post-function debug information.
1816 void DwarfDebug::endFunction(const MachineFunction *MF) {
1817 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1818 // though the beginFunction may not be called at all.
1819 // We should handle both cases.
1823 assert(CurFn == MF);
1826 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1831 // Define end label for subprogram.
1832 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1833 // Assumes in correct section after the entry point.
1834 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1835 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1836 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1838 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1839 collectVariableInfo(ProcessedVars);
1841 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1842 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1843 assert(TheCU && "Unable to find compile unit!");
1845 // Construct abstract scopes.
1846 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1847 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1848 LexicalScope *AScope = AList[i];
1849 DISubprogram SP(AScope->getScopeNode());
1850 if (SP.isSubprogram()) {
1851 // Collect info for variables that were optimized out.
1852 DIArray Variables = SP.getVariables();
1853 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1854 DIVariable DV(Variables.getElement(i));
1855 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1857 // Check that DbgVariable for DV wasn't created earlier, when
1858 // findAbstractVariable() was called for inlined instance of DV.
1859 LLVMContext &Ctx = DV->getContext();
1860 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1861 if (AbstractVariables.lookup(CleanDV))
1863 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1864 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1867 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1868 constructScopeDIE(TheCU, AScope);
1871 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1873 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1874 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1877 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1878 E = ScopeVariables.end();
1880 DeleteContainerPointers(I->second);
1881 ScopeVariables.clear();
1882 DeleteContainerPointers(CurrentFnArguments);
1883 UserVariables.clear();
1885 AbstractVariables.clear();
1886 LabelsBeforeInsn.clear();
1887 LabelsAfterInsn.clear();
1892 // Register a source line with debug info. Returns the unique label that was
1893 // emitted and which provides correspondence to the source line list.
1894 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1900 DIDescriptor Scope(S);
1902 if (Scope.isCompileUnit()) {
1903 DICompileUnit CU(S);
1904 Fn = CU.getFilename();
1905 Dir = CU.getDirectory();
1906 } else if (Scope.isFile()) {
1908 Fn = F.getFilename();
1909 Dir = F.getDirectory();
1910 } else if (Scope.isSubprogram()) {
1912 Fn = SP.getFilename();
1913 Dir = SP.getDirectory();
1914 } else if (Scope.isLexicalBlockFile()) {
1915 DILexicalBlockFile DBF(S);
1916 Fn = DBF.getFilename();
1917 Dir = DBF.getDirectory();
1918 } else if (Scope.isLexicalBlock()) {
1919 DILexicalBlock DB(S);
1920 Fn = DB.getFilename();
1921 Dir = DB.getDirectory();
1923 llvm_unreachable("Unexpected scope info");
1925 Src = getOrCreateSourceID(
1926 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1928 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1931 //===----------------------------------------------------------------------===//
1933 //===----------------------------------------------------------------------===//
1935 // Compute the size and offset of a DIE. The offset is relative to start of the
1936 // CU. It returns the offset after laying out the DIE.
1937 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1938 // Get the children.
1939 const std::vector<DIE *> &Children = Die->getChildren();
1941 // Record the abbreviation.
1942 assignAbbrevNumber(Die->getAbbrev());
1944 // Get the abbreviation for this DIE.
1945 const DIEAbbrev &Abbrev = Die->getAbbrev();
1948 Die->setOffset(Offset);
1950 // Start the size with the size of abbreviation code.
1951 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1953 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1954 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1956 // Size the DIE attribute values.
1957 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1958 // Size attribute value.
1959 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1961 // Size the DIE children if any.
1962 if (!Children.empty()) {
1963 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1964 "Children flag not set");
1966 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1967 Offset = computeSizeAndOffset(Children[j], Offset);
1969 // End of children marker.
1970 Offset += sizeof(int8_t);
1973 Die->setSize(Offset - Die->getOffset());
1977 // Compute the size and offset for each DIE.
1978 void DwarfFile::computeSizeAndOffsets() {
1979 // Offset from the first CU in the debug info section is 0 initially.
1980 unsigned SecOffset = 0;
1982 // Iterate over each compile unit and set the size and offsets for each
1983 // DIE within each compile unit. All offsets are CU relative.
1984 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1987 (*I)->setDebugInfoOffset(SecOffset);
1989 // CU-relative offset is reset to 0 here.
1990 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1991 (*I)->getHeaderSize(); // Unit-specific headers
1993 // EndOffset here is CU-relative, after laying out
1994 // all of the CU DIE.
1995 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1996 SecOffset += EndOffset;
2000 // Emit initial Dwarf sections with a label at the start of each one.
2001 void DwarfDebug::emitSectionLabels() {
2002 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2004 // Dwarf sections base addresses.
2005 DwarfInfoSectionSym =
2006 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2007 if (useSplitDwarf())
2008 DwarfInfoDWOSectionSym =
2009 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
2010 DwarfAbbrevSectionSym =
2011 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2012 if (useSplitDwarf())
2013 DwarfAbbrevDWOSectionSym = emitSectionSym(
2014 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
2015 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2017 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2018 emitSectionSym(Asm, MacroInfo);
2020 DwarfLineSectionSym =
2021 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2022 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2023 if (GenerateGnuPubSections) {
2024 DwarfGnuPubNamesSectionSym =
2025 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2026 DwarfGnuPubTypesSectionSym =
2027 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2028 } else if (HasDwarfPubSections) {
2029 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2030 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2033 DwarfStrSectionSym =
2034 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2035 if (useSplitDwarf()) {
2036 DwarfStrDWOSectionSym =
2037 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2038 DwarfAddrSectionSym =
2039 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2041 DwarfDebugRangeSectionSym =
2042 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2044 DwarfDebugLocSectionSym =
2045 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2047 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2050 // Recursively emits a debug information entry.
2051 void DwarfDebug::emitDIE(DIE *Die) {
2052 // Get the abbreviation for this DIE.
2053 const DIEAbbrev &Abbrev = Die->getAbbrev();
2055 // Emit the code (index) for the abbreviation.
2056 if (Asm->isVerbose())
2057 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2058 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2059 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2060 dwarf::TagString(Abbrev.getTag()));
2061 Asm->EmitULEB128(Abbrev.getNumber());
2063 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2064 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2066 // Emit the DIE attribute values.
2067 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2068 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2069 dwarf::Form Form = AbbrevData[i].getForm();
2070 assert(Form && "Too many attributes for DIE (check abbreviation)");
2072 if (Asm->isVerbose())
2073 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2076 case dwarf::DW_AT_abstract_origin:
2077 case dwarf::DW_AT_type:
2078 case dwarf::DW_AT_friend:
2079 case dwarf::DW_AT_specification:
2080 case dwarf::DW_AT_import:
2081 case dwarf::DW_AT_containing_type: {
2082 DIEEntry *E = cast<DIEEntry>(Values[i]);
2083 DIE *Origin = E->getEntry();
2084 unsigned Addr = Origin->getOffset();
2085 if (Form == dwarf::DW_FORM_ref_addr) {
2086 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2087 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2088 // section. Origin->getOffset() returns the offset from start of the
2090 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2091 assert(CU && "CUDie should belong to a CU.");
2092 Addr += CU->getDebugInfoOffset();
2093 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2094 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2095 DIEEntry::getRefAddrSize(Asm));
2097 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2098 CU->getSectionSym(),
2099 DIEEntry::getRefAddrSize(Asm));
2101 // Make sure Origin belong to the same CU.
2102 assert(Die->getUnit() == Origin->getUnit() &&
2103 "The referenced DIE should belong to the same CU in ref4");
2104 Asm->EmitInt32(Addr);
2108 case dwarf::DW_AT_location: {
2109 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2110 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2111 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2113 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2115 Values[i]->EmitValue(Asm, Form);
2119 case dwarf::DW_AT_accessibility: {
2120 if (Asm->isVerbose()) {
2121 DIEInteger *V = cast<DIEInteger>(Values[i]);
2122 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2124 Values[i]->EmitValue(Asm, Form);
2128 // Emit an attribute using the defined form.
2129 Values[i]->EmitValue(Asm, Form);
2134 // Emit the DIE children if any.
2135 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2136 const std::vector<DIE *> &Children = Die->getChildren();
2138 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2139 emitDIE(Children[j]);
2141 Asm->OutStreamer.AddComment("End Of Children Mark");
2146 // Emit the various dwarf units to the unit section USection with
2147 // the abbreviations going into ASection.
2148 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2149 const MCSymbol *ASectionSym) {
2150 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2152 DwarfUnit *TheU = *I;
2153 DIE *Die = TheU->getUnitDie();
2154 const MCSection *USection = TheU->getSection();
2155 Asm->OutStreamer.SwitchSection(USection);
2157 // Emit the compile units header.
2158 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2160 // Emit size of content not including length itself
2161 Asm->OutStreamer.AddComment("Length of Unit");
2162 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2164 TheU->emitHeader(ASection, ASectionSym);
2167 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2171 // Emit the debug info section.
2172 void DwarfDebug::emitDebugInfo() {
2173 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2175 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2176 DwarfAbbrevSectionSym);
2179 // Emit the abbreviation section.
2180 void DwarfDebug::emitAbbreviations() {
2181 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2183 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2186 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2187 // Check to see if it is worth the effort.
2188 if (!Abbreviations.empty()) {
2189 // Start the debug abbrev section.
2190 Asm->OutStreamer.SwitchSection(Section);
2192 // For each abbrevation.
2193 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2194 // Get abbreviation data
2195 const DIEAbbrev *Abbrev = Abbreviations[i];
2197 // Emit the abbrevations code (base 1 index.)
2198 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2200 // Emit the abbreviations data.
2204 // Mark end of abbreviations.
2205 Asm->EmitULEB128(0, "EOM(3)");
2209 // Emit the last address of the section and the end of the line matrix.
2210 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2211 // Define last address of section.
2212 Asm->OutStreamer.AddComment("Extended Op");
2215 Asm->OutStreamer.AddComment("Op size");
2216 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2217 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2218 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2220 Asm->OutStreamer.AddComment("Section end label");
2222 Asm->OutStreamer.EmitSymbolValue(
2223 Asm->GetTempSymbol("section_end", SectionEnd),
2224 Asm->getDataLayout().getPointerSize());
2226 // Mark end of matrix.
2227 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2233 // Emit visible names into a hashed accelerator table section.
2234 void DwarfDebug::emitAccelNames() {
2236 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2237 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2238 E = getUnits().end();
2240 DwarfUnit *TheU = *I;
2241 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2242 for (StringMap<std::vector<const DIE *> >::const_iterator
2246 StringRef Name = GI->getKey();
2247 const std::vector<const DIE *> &Entities = GI->second;
2248 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2249 DE = Entities.end();
2251 AT.AddName(Name, *DI);
2255 AT.FinalizeTable(Asm, "Names");
2256 Asm->OutStreamer.SwitchSection(
2257 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2258 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2259 Asm->OutStreamer.EmitLabel(SectionBegin);
2261 // Emit the full data.
2262 AT.Emit(Asm, SectionBegin, &InfoHolder);
2265 // Emit objective C classes and categories into a hashed accelerator table
2267 void DwarfDebug::emitAccelObjC() {
2269 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2270 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2271 E = getUnits().end();
2273 DwarfUnit *TheU = *I;
2274 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2275 for (StringMap<std::vector<const DIE *> >::const_iterator
2279 StringRef Name = GI->getKey();
2280 const std::vector<const DIE *> &Entities = GI->second;
2281 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2282 DE = Entities.end();
2284 AT.AddName(Name, *DI);
2288 AT.FinalizeTable(Asm, "ObjC");
2289 Asm->OutStreamer.SwitchSection(
2290 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2291 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2292 Asm->OutStreamer.EmitLabel(SectionBegin);
2294 // Emit the full data.
2295 AT.Emit(Asm, SectionBegin, &InfoHolder);
2298 // Emit namespace dies into a hashed accelerator table.
2299 void DwarfDebug::emitAccelNamespaces() {
2301 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2302 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2303 E = getUnits().end();
2305 DwarfUnit *TheU = *I;
2306 const StringMap<std::vector<const DIE *> > &Names =
2307 TheU->getAccelNamespace();
2308 for (StringMap<std::vector<const DIE *> >::const_iterator
2312 StringRef Name = GI->getKey();
2313 const std::vector<const DIE *> &Entities = GI->second;
2314 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2315 DE = Entities.end();
2317 AT.AddName(Name, *DI);
2321 AT.FinalizeTable(Asm, "namespac");
2322 Asm->OutStreamer.SwitchSection(
2323 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2324 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2325 Asm->OutStreamer.EmitLabel(SectionBegin);
2327 // Emit the full data.
2328 AT.Emit(Asm, SectionBegin, &InfoHolder);
2331 // Emit type dies into a hashed accelerator table.
2332 void DwarfDebug::emitAccelTypes() {
2333 std::vector<DwarfAccelTable::Atom> Atoms;
2335 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2337 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2339 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2340 DwarfAccelTable AT(Atoms);
2341 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2342 E = getUnits().end();
2344 DwarfUnit *TheU = *I;
2345 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2346 TheU->getAccelTypes();
2348 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2352 StringRef Name = GI->getKey();
2353 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2355 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2356 DI = Entities.begin(),
2357 DE = Entities.end();
2359 AT.AddName(Name, DI->first, DI->second);
2363 AT.FinalizeTable(Asm, "types");
2364 Asm->OutStreamer.SwitchSection(
2365 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2366 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2367 Asm->OutStreamer.EmitLabel(SectionBegin);
2369 // Emit the full data.
2370 AT.Emit(Asm, SectionBegin, &InfoHolder);
2373 // Public name handling.
2374 // The format for the various pubnames:
2376 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2377 // for the DIE that is named.
2379 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2380 // into the CU and the index value is computed according to the type of value
2381 // for the DIE that is named.
2383 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2384 // it's the offset within the debug_info/debug_types dwo section, however, the
2385 // reference in the pubname header doesn't change.
2387 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2388 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2390 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2392 // We could have a specification DIE that has our most of our knowledge,
2393 // look for that now.
2394 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2396 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2397 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2398 Linkage = dwarf::GIEL_EXTERNAL;
2399 } else if (Die->findAttribute(dwarf::DW_AT_external))
2400 Linkage = dwarf::GIEL_EXTERNAL;
2402 switch (Die->getTag()) {
2403 case dwarf::DW_TAG_class_type:
2404 case dwarf::DW_TAG_structure_type:
2405 case dwarf::DW_TAG_union_type:
2406 case dwarf::DW_TAG_enumeration_type:
2407 return dwarf::PubIndexEntryDescriptor(
2408 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2409 ? dwarf::GIEL_STATIC
2410 : dwarf::GIEL_EXTERNAL);
2411 case dwarf::DW_TAG_typedef:
2412 case dwarf::DW_TAG_base_type:
2413 case dwarf::DW_TAG_subrange_type:
2414 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2415 case dwarf::DW_TAG_namespace:
2416 return dwarf::GIEK_TYPE;
2417 case dwarf::DW_TAG_subprogram:
2418 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2419 case dwarf::DW_TAG_constant:
2420 case dwarf::DW_TAG_variable:
2421 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2422 case dwarf::DW_TAG_enumerator:
2423 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2424 dwarf::GIEL_STATIC);
2426 return dwarf::GIEK_NONE;
2430 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2432 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2433 const MCSection *PSec =
2434 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2435 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2437 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2438 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2439 for (unsigned i = 0; i != Units.size(); ++i) {
2440 DwarfUnit *TheU = Units[i];
2441 unsigned ID = TheU->getUniqueID();
2443 // Start the dwarf pubnames section.
2444 Asm->OutStreamer.SwitchSection(PSec);
2446 // Emit a label so we can reference the beginning of this pubname section.
2448 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2451 Asm->OutStreamer.AddComment("Length of Public Names Info");
2452 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2453 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2454 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2456 Asm->OutStreamer.EmitLabel(BeginLabel);
2458 Asm->OutStreamer.AddComment("DWARF Version");
2459 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2461 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2462 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2464 Asm->OutStreamer.AddComment("Compilation Unit Length");
2465 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2467 // Emit the pubnames for this compilation unit.
2468 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2469 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2472 const char *Name = GI->getKeyData();
2473 const DIE *Entity = GI->second;
2475 Asm->OutStreamer.AddComment("DIE offset");
2476 Asm->EmitInt32(Entity->getOffset());
2479 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2480 Asm->OutStreamer.AddComment(
2481 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2482 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2483 Asm->EmitInt8(Desc.toBits());
2486 Asm->OutStreamer.AddComment("External Name");
2487 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2490 Asm->OutStreamer.AddComment("End Mark");
2492 Asm->OutStreamer.EmitLabel(EndLabel);
2496 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2497 const MCSection *PSec =
2498 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2499 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2501 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2502 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2503 for (unsigned i = 0; i != Units.size(); ++i) {
2504 DwarfUnit *TheU = Units[i];
2505 unsigned ID = TheU->getUniqueID();
2507 // Start the dwarf pubtypes section.
2508 Asm->OutStreamer.SwitchSection(PSec);
2510 // Emit a label so we can reference the beginning of this pubtype section.
2512 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2515 Asm->OutStreamer.AddComment("Length of Public Types Info");
2516 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2517 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2518 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2520 Asm->OutStreamer.EmitLabel(BeginLabel);
2522 Asm->OutStreamer.AddComment("DWARF Version");
2523 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2525 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2526 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2528 Asm->OutStreamer.AddComment("Compilation Unit Length");
2529 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2531 // Emit the pubtypes.
2532 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2533 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2536 const char *Name = GI->getKeyData();
2537 const DIE *Entity = GI->second;
2539 Asm->OutStreamer.AddComment("DIE offset");
2540 Asm->EmitInt32(Entity->getOffset());
2543 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2544 Asm->OutStreamer.AddComment(
2545 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2546 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2547 Asm->EmitInt8(Desc.toBits());
2550 Asm->OutStreamer.AddComment("External Name");
2552 // Emit the name with a terminating null byte.
2553 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2556 Asm->OutStreamer.AddComment("End Mark");
2558 Asm->OutStreamer.EmitLabel(EndLabel);
2562 // Emit strings into a string section.
2563 void DwarfFile::emitStrings(const MCSection *StrSection,
2564 const MCSection *OffsetSection = NULL,
2565 const MCSymbol *StrSecSym = NULL) {
2567 if (StringPool.empty())
2570 // Start the dwarf str section.
2571 Asm->OutStreamer.SwitchSection(StrSection);
2573 // Get all of the string pool entries and put them in an array by their ID so
2574 // we can sort them.
2576 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2579 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2580 I = StringPool.begin(),
2581 E = StringPool.end();
2583 Entries.push_back(std::make_pair(I->second.second, &*I));
2585 array_pod_sort(Entries.begin(), Entries.end());
2587 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2588 // Emit a label for reference from debug information entries.
2589 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2591 // Emit the string itself with a terminating null byte.
2592 Asm->OutStreamer.EmitBytes(
2593 StringRef(Entries[i].second->getKeyData(),
2594 Entries[i].second->getKeyLength() + 1));
2597 // If we've got an offset section go ahead and emit that now as well.
2598 if (OffsetSection) {
2599 Asm->OutStreamer.SwitchSection(OffsetSection);
2600 unsigned offset = 0;
2601 unsigned size = 4; // FIXME: DWARF64 is 8.
2602 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2603 Asm->OutStreamer.EmitIntValue(offset, size);
2604 offset += Entries[i].second->getKeyLength() + 1;
2609 // Emit addresses into the section given.
2610 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2612 if (AddressPool.empty())
2615 // Start the dwarf addr section.
2616 Asm->OutStreamer.SwitchSection(AddrSection);
2618 // Order the address pool entries by ID
2619 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2621 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2622 E = AddressPool.end();
2624 Entries[I->second] = I->first;
2626 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2627 // Emit an expression for reference from debug information entries.
2628 if (const MCExpr *Expr = Entries[i])
2629 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2631 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2635 // Emit visible names into a debug str section.
2636 void DwarfDebug::emitDebugStr() {
2637 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2638 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2641 // Emit locations into the debug loc section.
2642 void DwarfDebug::emitDebugLoc() {
2643 if (DotDebugLocEntries.empty())
2646 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2647 I = DotDebugLocEntries.begin(),
2648 E = DotDebugLocEntries.end();
2650 DotDebugLocEntry &Entry = *I;
2651 if (I + 1 != DotDebugLocEntries.end())
2655 // Start the dwarf loc section.
2656 Asm->OutStreamer.SwitchSection(
2657 Asm->getObjFileLowering().getDwarfLocSection());
2658 unsigned char Size = Asm->getDataLayout().getPointerSize();
2659 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2661 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2662 I = DotDebugLocEntries.begin(),
2663 E = DotDebugLocEntries.end();
2664 I != E; ++I, ++index) {
2665 DotDebugLocEntry &Entry = *I;
2666 if (Entry.isMerged())
2668 if (Entry.isEmpty()) {
2669 Asm->OutStreamer.EmitIntValue(0, Size);
2670 Asm->OutStreamer.EmitIntValue(0, Size);
2671 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2673 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2674 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2675 DIVariable DV(Entry.getVariable());
2676 Asm->OutStreamer.AddComment("Loc expr size");
2677 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2678 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2679 Asm->EmitLabelDifference(end, begin, 2);
2680 Asm->OutStreamer.EmitLabel(begin);
2681 if (Entry.isInt()) {
2682 DIBasicType BTy(DV.getType());
2683 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2684 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2685 Asm->OutStreamer.AddComment("DW_OP_consts");
2686 Asm->EmitInt8(dwarf::DW_OP_consts);
2687 Asm->EmitSLEB128(Entry.getInt());
2689 Asm->OutStreamer.AddComment("DW_OP_constu");
2690 Asm->EmitInt8(dwarf::DW_OP_constu);
2691 Asm->EmitULEB128(Entry.getInt());
2693 } else if (Entry.isLocation()) {
2694 MachineLocation Loc = Entry.getLoc();
2695 if (!DV.hasComplexAddress())
2697 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2699 // Complex address entry.
2700 unsigned N = DV.getNumAddrElements();
2702 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2703 if (Loc.getOffset()) {
2705 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2706 Asm->OutStreamer.AddComment("DW_OP_deref");
2707 Asm->EmitInt8(dwarf::DW_OP_deref);
2708 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2709 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2710 Asm->EmitSLEB128(DV.getAddrElement(1));
2712 // If first address element is OpPlus then emit
2713 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2714 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2715 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2719 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2722 // Emit remaining complex address elements.
2723 for (; i < N; ++i) {
2724 uint64_t Element = DV.getAddrElement(i);
2725 if (Element == DIBuilder::OpPlus) {
2726 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2727 Asm->EmitULEB128(DV.getAddrElement(++i));
2728 } else if (Element == DIBuilder::OpDeref) {
2730 Asm->EmitInt8(dwarf::DW_OP_deref);
2732 llvm_unreachable("unknown Opcode found in complex address");
2736 // else ... ignore constant fp. There is not any good way to
2737 // to represent them here in dwarf.
2738 Asm->OutStreamer.EmitLabel(end);
2743 struct SymbolCUSorter {
2744 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2745 const MCStreamer &Streamer;
2747 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2748 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2749 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2751 // Symbols with no order assigned should be placed at the end.
2752 // (e.g. section end labels)
2754 IA = (unsigned)(-1);
2756 IB = (unsigned)(-1);
2761 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2762 return (A->getUniqueID() < B->getUniqueID());
2766 const MCSymbol *Start, *End;
2769 // Emit a debug aranges section, containing a CU lookup for any
2770 // address we can tie back to a CU.
2771 void DwarfDebug::emitDebugARanges() {
2772 // Start the dwarf aranges section.
2773 Asm->OutStreamer.SwitchSection(
2774 Asm->getObjFileLowering().getDwarfARangesSection());
2776 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2780 // Build a list of sections used.
2781 std::vector<const MCSection *> Sections;
2782 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2784 const MCSection *Section = it->first;
2785 Sections.push_back(Section);
2788 // Sort the sections into order.
2789 // This is only done to ensure consistent output order across different runs.
2790 std::sort(Sections.begin(), Sections.end(), SectionSort);
2792 // Build a set of address spans, sorted by CU.
2793 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2794 const MCSection *Section = Sections[SecIdx];
2795 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2796 if (List.size() < 2)
2799 // Sort the symbols by offset within the section.
2800 SymbolCUSorter sorter(Asm->OutStreamer);
2801 std::sort(List.begin(), List.end(), sorter);
2803 // If we have no section (e.g. common), just write out
2804 // individual spans for each symbol.
2805 if (Section == NULL) {
2806 for (size_t n = 0; n < List.size(); n++) {
2807 const SymbolCU &Cur = List[n];
2810 Span.Start = Cur.Sym;
2813 Spans[Cur.CU].push_back(Span);
2816 // Build spans between each label.
2817 const MCSymbol *StartSym = List[0].Sym;
2818 for (size_t n = 1; n < List.size(); n++) {
2819 const SymbolCU &Prev = List[n - 1];
2820 const SymbolCU &Cur = List[n];
2822 // Try and build the longest span we can within the same CU.
2823 if (Cur.CU != Prev.CU) {
2825 Span.Start = StartSym;
2827 Spans[Prev.CU].push_back(Span);
2834 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2836 // Build a list of CUs used.
2837 std::vector<DwarfCompileUnit *> CUs;
2838 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2839 DwarfCompileUnit *CU = it->first;
2843 // Sort the CU list (again, to ensure consistent output order).
2844 std::sort(CUs.begin(), CUs.end(), CUSort);
2846 // Emit an arange table for each CU we used.
2847 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2848 DwarfCompileUnit *CU = CUs[CUIdx];
2849 std::vector<ArangeSpan> &List = Spans[CU];
2851 // Emit size of content not including length itself.
2852 unsigned ContentSize =
2853 sizeof(int16_t) + // DWARF ARange version number
2854 sizeof(int32_t) + // Offset of CU in the .debug_info section
2855 sizeof(int8_t) + // Pointer Size (in bytes)
2856 sizeof(int8_t); // Segment Size (in bytes)
2858 unsigned TupleSize = PtrSize * 2;
2860 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2861 unsigned Padding = 0;
2862 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2865 ContentSize += Padding;
2866 ContentSize += (List.size() + 1) * TupleSize;
2868 // For each compile unit, write the list of spans it covers.
2869 Asm->OutStreamer.AddComment("Length of ARange Set");
2870 Asm->EmitInt32(ContentSize);
2871 Asm->OutStreamer.AddComment("DWARF Arange version number");
2872 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2873 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2874 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2875 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2876 Asm->EmitInt8(PtrSize);
2877 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2880 for (unsigned n = 0; n < Padding; n++)
2881 Asm->EmitInt8(0xff);
2883 for (unsigned n = 0; n < List.size(); n++) {
2884 const ArangeSpan &Span = List[n];
2885 Asm->EmitLabelReference(Span.Start, PtrSize);
2887 // Calculate the size as being from the span start to it's end.
2889 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2891 // For symbols without an end marker (e.g. common), we
2892 // write a single arange entry containing just that one symbol.
2893 uint64_t Size = SymSize[Span.Start];
2897 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2901 Asm->OutStreamer.AddComment("ARange terminator");
2902 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2903 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2907 // Emit visible names into a debug ranges section.
2908 void DwarfDebug::emitDebugRanges() {
2909 // Start the dwarf ranges section.
2910 Asm->OutStreamer.SwitchSection(
2911 Asm->getObjFileLowering().getDwarfRangesSection());
2913 // Size for our labels.
2914 unsigned char Size = Asm->getDataLayout().getPointerSize();
2916 // Grab the specific ranges for the compile units in the module.
2917 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2920 DwarfCompileUnit *TheCU = I->second;
2922 // Emit a symbol so we can find the beginning of our ranges.
2923 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2925 // Iterate over the misc ranges for the compile units in the module.
2926 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2927 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2928 E = RangeLists.end();
2930 const RangeSpanList &List = *I;
2932 // Emit our symbol so we can find the beginning of the range.
2933 Asm->OutStreamer.EmitLabel(List.getSym());
2935 for (SmallVectorImpl<RangeSpan>::const_iterator
2936 RI = List.getRanges().begin(),
2937 RE = List.getRanges().end();
2939 const RangeSpan &Range = *RI;
2940 const MCSymbol *Begin = Range.getStart();
2941 const MCSymbol *End = Range.getEnd();
2942 assert(Begin && "Range without a begin symbol?");
2943 assert(End && "Range without an end symbol?");
2944 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2945 Asm->OutStreamer.EmitSymbolValue(End, Size);
2948 // And terminate the list with two 0 values.
2949 Asm->OutStreamer.EmitIntValue(0, Size);
2950 Asm->OutStreamer.EmitIntValue(0, Size);
2953 // Now emit a range for the CU itself.
2954 if (DwarfCURanges) {
2955 Asm->OutStreamer.EmitLabel(
2956 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2957 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2958 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2959 RangeSpan Range = Ranges[i];
2960 const MCSymbol *Begin = Range.getStart();
2961 const MCSymbol *End = Range.getEnd();
2962 assert(Begin && "Range without a begin symbol?");
2963 assert(End && "Range without an end symbol?");
2964 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2965 Asm->OutStreamer.EmitSymbolValue(End, Size);
2967 // And terminate the list with two 0 values.
2968 Asm->OutStreamer.EmitIntValue(0, Size);
2969 Asm->OutStreamer.EmitIntValue(0, Size);
2974 // DWARF5 Experimental Separate Dwarf emitters.
2976 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2977 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2978 // DW_AT_ranges_base, DW_AT_addr_base.
2979 // TODO: Implement DW_AT_ranges_base.
2980 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2982 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2983 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2984 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2985 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2986 DwarfInfoSectionSym);
2988 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2989 CU->getNode().getSplitDebugFilename());
2991 // Relocate to the beginning of the addr_base section, else 0 for the
2992 // beginning of the one for this compile unit.
2993 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2994 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2995 DwarfAddrSectionSym);
2997 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2999 // DW_AT_stmt_list is a offset of line number information for this
3000 // compile unit in debug_line section.
3001 // FIXME: Should handle multiple compile units.
3002 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3003 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3005 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3007 if (!CompilationDir.empty())
3008 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3010 addGnuPubAttributes(NewCU, Die);
3012 SkeletonHolder.addUnit(NewCU);
3017 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3018 // compile units that would normally be in debug_info.
3019 void DwarfDebug::emitDebugInfoDWO() {
3020 assert(useSplitDwarf() && "No split dwarf debug info?");
3021 InfoHolder.emitUnits(this,
3022 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3023 DwarfAbbrevDWOSectionSym);
3026 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3027 // abbreviations for the .debug_info.dwo section.
3028 void DwarfDebug::emitDebugAbbrevDWO() {
3029 assert(useSplitDwarf() && "No split dwarf?");
3030 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3033 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3034 // string section and is identical in format to traditional .debug_str
3036 void DwarfDebug::emitDebugStrDWO() {
3037 assert(useSplitDwarf() && "No split dwarf?");
3038 const MCSection *OffSec =
3039 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3040 const MCSymbol *StrSym = DwarfStrSectionSym;
3041 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3045 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3046 DICompositeType CTy) {
3047 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3049 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3050 DwarfTypeUnit *NewTU =
3051 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3054 InfoHolder.addUnit(NewTU);
3056 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3059 DIE *Die = NewTU->createTypeDIE(CTy);
3061 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3062 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3063 dwarf::DW_FORM_data8,
3064 DIEHash().computeDIEODRSignature(*Die));
3065 // FIXME: This won't handle circularly referential structures, as the DIE
3066 // may have references to other DIEs still under construction and missing
3067 // their signature. Hashing should walk through the signatures to their
3068 // referenced type, or possibly walk the precomputed hashes of related types
3070 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3071 NewTU->setTypeSignature(Signature);
3072 NewTU->setType(Die);
3076 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3077 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3080 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);