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."),
61 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
62 cl::desc("Add the CU hash as the dwo_id."),
66 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
67 cl::desc("Generate GNU-style pubnames and pubtypes"),
78 static cl::opt<DefaultOnOff>
79 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
80 cl::desc("Output prototype dwarf accelerator tables."),
81 cl::values(clEnumVal(Default, "Default for platform"),
82 clEnumVal(Enable, "Enabled"),
83 clEnumVal(Disable, "Disabled"), clEnumValEnd),
86 static cl::opt<DefaultOnOff>
87 SplitDwarf("split-dwarf", cl::Hidden,
88 cl::desc("Output DWARF5 split debug info."),
89 cl::values(clEnumVal(Default, "Default for platform"),
90 clEnumVal(Enable, "Enabled"),
91 clEnumVal(Disable, "Disabled"), clEnumValEnd),
94 static cl::opt<DefaultOnOff>
95 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
96 cl::desc("Generate DWARF pubnames and pubtypes sections"),
97 cl::values(clEnumVal(Default, "Default for platform"),
98 clEnumVal(Enable, "Enabled"),
99 clEnumVal(Disable, "Disabled"), clEnumValEnd),
102 static cl::opt<unsigned>
103 DwarfVersionNumber("dwarf-version", cl::Hidden,
104 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
107 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
108 cl::desc("Generate DW_AT_ranges for compile units"),
111 static const char *const DWARFGroupName = "DWARF Emission";
112 static const char *const DbgTimerName = "DWARF Debug Writer";
114 //===----------------------------------------------------------------------===//
118 /// resolve - Look in the DwarfDebug map for the MDNode that
119 /// corresponds to the reference.
120 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
121 return DD->resolve(Ref);
124 DIType DbgVariable::getType() const {
125 DIType Ty = Var.getType();
126 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
127 // addresses instead.
128 if (Var.isBlockByrefVariable()) {
129 /* Byref variables, in Blocks, are declared by the programmer as
130 "SomeType VarName;", but the compiler creates a
131 __Block_byref_x_VarName struct, and gives the variable VarName
132 either the struct, or a pointer to the struct, as its type. This
133 is necessary for various behind-the-scenes things the compiler
134 needs to do with by-reference variables in blocks.
136 However, as far as the original *programmer* is concerned, the
137 variable should still have type 'SomeType', as originally declared.
139 The following function dives into the __Block_byref_x_VarName
140 struct to find the original type of the variable. This will be
141 passed back to the code generating the type for the Debug
142 Information Entry for the variable 'VarName'. 'VarName' will then
143 have the original type 'SomeType' in its debug information.
145 The original type 'SomeType' will be the type of the field named
146 'VarName' inside the __Block_byref_x_VarName struct.
148 NOTE: In order for this to not completely fail on the debugger
149 side, the Debug Information Entry for the variable VarName needs to
150 have a DW_AT_location that tells the debugger how to unwind through
151 the pointers and __Block_byref_x_VarName struct to find the actual
152 value of the variable. The function addBlockByrefType does this. */
154 uint16_t tag = Ty.getTag();
156 if (tag == dwarf::DW_TAG_pointer_type)
157 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
159 DIArray Elements = DICompositeType(subType).getTypeArray();
160 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
161 DIDerivedType DT(Elements.getElement(i));
162 if (getName() == DT.getName())
163 return (resolve(DT.getTypeDerivedFrom()));
169 } // end llvm namespace
171 /// Return Dwarf Version by checking module flags.
172 static unsigned getDwarfVersionFromModule(const Module *M) {
173 Value *Val = M->getModuleFlag("Dwarf Version");
175 return dwarf::DWARF_VERSION;
176 return cast<ConstantInt>(Val)->getZExtValue();
179 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
180 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
181 PrevLabel(NULL), GlobalRangeCount(0),
182 InfoHolder(A, "info_string", DIEValueAllocator),
183 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
186 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
187 DwarfAddrSectionSym = 0;
188 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
189 FunctionBeginSym = FunctionEndSym = 0;
193 // Turn on accelerator tables for Darwin by default, pubnames by
194 // default for non-Darwin, and handle split dwarf.
195 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
197 if (DwarfAccelTables == Default)
198 HasDwarfAccelTables = IsDarwin;
200 HasDwarfAccelTables = DwarfAccelTables == Enable;
202 if (SplitDwarf == Default)
203 HasSplitDwarf = false;
205 HasSplitDwarf = SplitDwarf == Enable;
207 if (DwarfPubSections == Default)
208 HasDwarfPubSections = !IsDarwin;
210 HasDwarfPubSections = DwarfPubSections == Enable;
212 // For now only turn on CU ranges if we've explicitly asked for it
213 // or we have -ffunction-sections enabled.
214 HasCURanges = DwarfCURanges || TargetMachine::getFunctionSections();
216 DwarfVersion = DwarfVersionNumber
218 : getDwarfVersionFromModule(MMI->getModule());
221 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
226 // Switch to the specified MCSection and emit an assembler
227 // temporary label to it if SymbolStem is specified.
228 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
229 const char *SymbolStem = 0) {
230 Asm->OutStreamer.SwitchSection(Section);
234 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
235 Asm->OutStreamer.EmitLabel(TmpSym);
239 DwarfFile::~DwarfFile() {
240 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
245 MCSymbol *DwarfFile::getStringPoolSym() {
246 return Asm->GetTempSymbol(StringPref);
249 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
250 std::pair<MCSymbol *, unsigned> &Entry =
251 StringPool.GetOrCreateValue(Str).getValue();
255 Entry.second = NextStringPoolNumber++;
256 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
259 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
260 std::pair<MCSymbol *, unsigned> &Entry =
261 StringPool.GetOrCreateValue(Str).getValue();
265 Entry.second = NextStringPoolNumber++;
266 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
270 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
271 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
274 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
275 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
276 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
278 ++NextAddrPoolNumber;
279 return P.first->second;
282 // Define a unique number for the abbreviation.
284 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
285 // Check the set for priors.
286 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
288 // If it's newly added.
289 if (InSet == &Abbrev) {
290 // Add to abbreviation list.
291 Abbreviations.push_back(&Abbrev);
293 // Assign the vector position + 1 as its number.
294 Abbrev.setNumber(Abbreviations.size());
296 // Assign existing abbreviation number.
297 Abbrev.setNumber(InSet->getNumber());
301 static bool isObjCClass(StringRef Name) {
302 return Name.startswith("+") || Name.startswith("-");
305 static bool hasObjCCategory(StringRef Name) {
306 if (!isObjCClass(Name))
309 return Name.find(") ") != StringRef::npos;
312 static void getObjCClassCategory(StringRef In, StringRef &Class,
313 StringRef &Category) {
314 if (!hasObjCCategory(In)) {
315 Class = In.slice(In.find('[') + 1, In.find(' '));
320 Class = In.slice(In.find('[') + 1, In.find('('));
321 Category = In.slice(In.find('[') + 1, In.find(' '));
325 static StringRef getObjCMethodName(StringRef In) {
326 return In.slice(In.find(' ') + 1, In.find(']'));
329 // Helper for sorting sections into a stable output order.
330 static bool SectionSort(const MCSection *A, const MCSection *B) {
331 std::string LA = (A ? A->getLabelBeginName() : "");
332 std::string LB = (B ? B->getLabelBeginName() : "");
336 // Add the various names to the Dwarf accelerator table names.
337 // TODO: Determine whether or not we should add names for programs
338 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
339 // is only slightly different than the lookup of non-standard ObjC names.
340 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
341 if (!SP.isDefinition())
343 TheU->addAccelName(SP.getName(), Die);
345 // If the linkage name is different than the name, go ahead and output
346 // that as well into the name table.
347 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
348 TheU->addAccelName(SP.getLinkageName(), Die);
350 // If this is an Objective-C selector name add it to the ObjC accelerator
352 if (isObjCClass(SP.getName())) {
353 StringRef Class, Category;
354 getObjCClassCategory(SP.getName(), Class, Category);
355 TheU->addAccelObjC(Class, Die);
357 TheU->addAccelObjC(Category, Die);
358 // Also add the base method name to the name table.
359 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
363 /// isSubprogramContext - Return true if Context is either a subprogram
364 /// or another context nested inside a subprogram.
365 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
368 DIDescriptor D(Context);
369 if (D.isSubprogram())
372 return isSubprogramContext(resolve(DIType(Context).getContext()));
376 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
377 // and DW_AT_high_pc attributes. If there are global variables in this
378 // scope then create and insert DIEs for these variables.
379 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
381 DIE *SPDie = SPCU->getDIE(SP);
383 assert(SPDie && "Unable to find subprogram DIE!");
385 // If we're updating an abstract DIE, then we will be adding the children and
386 // object pointer later on. But what we don't want to do is process the
387 // concrete DIE twice.
388 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
389 // Pick up abstract subprogram DIE.
391 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
392 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
394 DISubprogram SPDecl = SP.getFunctionDeclaration();
395 if (!SPDecl.isSubprogram()) {
396 // There is not any need to generate specification DIE for a function
397 // defined at compile unit level. If a function is defined inside another
398 // function then gdb prefers the definition at top level and but does not
399 // expect specification DIE in parent function. So avoid creating
400 // specification DIE for a function defined inside a function.
401 DIScope SPContext = resolve(SP.getContext());
402 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
403 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
404 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
407 DICompositeType SPTy = SP.getType();
408 DIArray Args = SPTy.getTypeArray();
409 uint16_t SPTag = SPTy.getTag();
410 if (SPTag == dwarf::DW_TAG_subroutine_type)
411 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
413 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
414 DIType ATy(Args.getElement(i));
415 SPCU->addType(Arg, ATy);
416 if (ATy.isArtificial())
417 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
418 if (ATy.isObjectPointer())
419 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
421 DIE *SPDeclDie = SPDie;
422 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
423 *SPCU->getUnitDie());
424 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
429 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
430 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
432 // Add this range to the list of ranges for the CU.
433 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
434 SPCU->addRange(llvm_move(Span));
436 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
437 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
438 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
440 // Add name to the name table, we do this here because we're guaranteed
441 // to have concrete versions of our DW_TAG_subprogram nodes.
442 addSubprogramNames(SPCU, SP, SPDie);
447 /// Check whether we should create a DIE for the given Scope, return true
448 /// if we don't create a DIE (the corresponding DIE is null).
449 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
450 if (Scope->isAbstractScope())
453 // We don't create a DIE if there is no Range.
454 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
458 if (Ranges.size() > 1)
461 // We don't create a DIE if we have a single Range and the end label
463 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
464 MCSymbol *End = getLabelAfterInsn(RI->second);
468 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
469 dwarf::Attribute A, const MCSymbol *L,
470 const MCSymbol *Sec) {
471 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
472 U->addSectionLabel(D, A, L);
474 U->addSectionDelta(D, A, L, Sec);
477 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
478 const SmallVectorImpl<InsnRange> &Range) {
479 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
480 // emitting it appropriately.
481 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
482 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
483 DwarfDebugRangeSectionSym);
485 RangeSpanList List(RangeSym);
486 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
489 RangeSpan Span(getLabelBeforeInsn(RI->first),
490 getLabelAfterInsn(RI->second));
491 List.addRange(llvm_move(Span));
494 // Add the range list to the set of ranges to be emitted.
495 TheCU->addRangeList(llvm_move(List));
498 // Construct new DW_TAG_lexical_block for this scope and attach
499 // DW_AT_low_pc/DW_AT_high_pc labels.
500 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
501 LexicalScope *Scope) {
502 if (isLexicalScopeDIENull(Scope))
505 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
506 if (Scope->isAbstractScope())
509 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
511 // If we have multiple ranges, emit them into the range section.
512 if (ScopeRanges.size() > 1) {
513 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
517 // Construct the address range for this DIE.
518 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
519 MCSymbol *Start = getLabelBeforeInsn(RI->first);
520 MCSymbol *End = getLabelAfterInsn(RI->second);
521 assert(End && "End label should not be null!");
523 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
524 assert(End->isDefined() && "Invalid end label for an inlined scope!");
526 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
527 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
532 // This scope represents inlined body of a function. Construct DIE to
533 // represent this concrete inlined copy of the function.
534 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
535 LexicalScope *Scope) {
536 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
537 assert(!ScopeRanges.empty() &&
538 "LexicalScope does not have instruction markers!");
540 if (!Scope->getScopeNode())
542 DIScope DS(Scope->getScopeNode());
543 DISubprogram InlinedSP = getDISubprogram(DS);
544 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
546 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
550 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
551 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
553 // If we have multiple ranges, emit them into the range section.
554 if (ScopeRanges.size() > 1)
555 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
557 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
558 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
559 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
561 if (StartLabel == 0 || EndLabel == 0)
562 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
564 assert(StartLabel->isDefined() &&
565 "Invalid starting label for an inlined scope!");
566 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
568 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
569 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
572 InlinedSubprogramDIEs.insert(OriginDIE);
574 // Add the call site information to the DIE.
575 DILocation DL(Scope->getInlinedAt());
576 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
577 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
578 TheCU->getUniqueID()));
579 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
581 // Add name to the name table, we do this here because we're guaranteed
582 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
583 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
588 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
590 SmallVectorImpl<DIE *> &Children) {
591 DIE *ObjectPointer = NULL;
593 // Collect arguments for current function.
594 if (LScopes.isCurrentFunctionScope(Scope))
595 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
596 if (DbgVariable *ArgDV = CurrentFnArguments[i])
598 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
599 Children.push_back(Arg);
600 if (ArgDV->isObjectPointer())
604 // Collect lexical scope children first.
605 const SmallVectorImpl<DbgVariable *> &Variables =
606 ScopeVariables.lookup(Scope);
607 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
608 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
609 Scope->isAbstractScope())) {
610 Children.push_back(Variable);
611 if (Variables[i]->isObjectPointer())
612 ObjectPointer = Variable;
614 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
615 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
616 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
617 Children.push_back(Nested);
618 return ObjectPointer;
621 // Construct a DIE for this scope.
622 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
623 LexicalScope *Scope) {
624 if (!Scope || !Scope->getScopeNode())
627 DIScope DS(Scope->getScopeNode());
629 SmallVector<DIE *, 8> Children;
630 DIE *ObjectPointer = NULL;
631 bool ChildrenCreated = false;
633 // We try to create the scope DIE first, then the children DIEs. This will
634 // avoid creating un-used children then removing them later when we find out
635 // the scope DIE is null.
636 DIE *ScopeDIE = NULL;
637 if (Scope->getInlinedAt())
638 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
639 else if (DS.isSubprogram()) {
640 ProcessedSPNodes.insert(DS);
641 if (Scope->isAbstractScope()) {
642 ScopeDIE = TheCU->getDIE(DS);
643 // Note down abstract DIE.
645 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
647 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
649 // Early exit when we know the scope DIE is going to be null.
650 if (isLexicalScopeDIENull(Scope))
653 // We create children here when we know the scope DIE is not going to be
654 // null and the children will be added to the scope DIE.
655 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
656 ChildrenCreated = true;
658 // There is no need to emit empty lexical block DIE.
659 std::pair<ImportedEntityMap::const_iterator,
660 ImportedEntityMap::const_iterator> Range =
662 ScopesWithImportedEntities.begin(),
663 ScopesWithImportedEntities.end(),
664 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
666 if (Children.empty() && Range.first == Range.second)
668 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
669 assert(ScopeDIE && "Scope DIE should not be null.");
670 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
672 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
676 assert(Children.empty() &&
677 "We create children only when the scope DIE is not null.");
680 if (!ChildrenCreated)
681 // We create children when the scope DIE is not null.
682 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
685 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
688 ScopeDIE->addChild(*I);
690 if (DS.isSubprogram() && ObjectPointer != NULL)
691 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
696 // Look up the source id with the given directory and source file names.
697 // If none currently exists, create a new id and insert it in the
698 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
700 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
702 // If we use .loc in assembly, we can't separate .file entries according to
703 // compile units. Thus all files will belong to the default compile unit.
705 // FIXME: add a better feature test than hasRawTextSupport. Even better,
706 // extend .file to support this.
707 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
710 // If FE did not provide a file name, then assume stdin.
711 if (FileName.empty())
712 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
714 // TODO: this might not belong here. See if we can factor this better.
715 if (DirName == CompilationDir)
718 // FileIDCUMap stores the current ID for the given compile unit.
719 unsigned SrcId = FileIDCUMap[CUID] + 1;
721 // We look up the CUID/file/dir by concatenating them with a zero byte.
722 SmallString<128> NamePair;
723 NamePair += utostr(CUID);
726 NamePair += '\0'; // Zero bytes are not allowed in paths.
727 NamePair += FileName;
729 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
730 if (Ent.getValue() != SrcId)
731 return Ent.getValue();
733 FileIDCUMap[CUID] = SrcId;
734 // Print out a .file directive to specify files for .loc directives.
735 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
740 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
741 if (!GenerateGnuPubSections)
744 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
745 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
746 DwarfGnuPubNamesSectionSym);
748 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
749 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
750 DwarfGnuPubTypesSectionSym);
753 // Create new DwarfCompileUnit for the given metadata node with tag
754 // DW_TAG_compile_unit.
755 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
756 StringRef FN = DIUnit.getFilename();
757 CompilationDir = DIUnit.getDirectory();
759 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
760 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
761 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
762 InfoHolder.addUnit(NewCU);
764 FileIDCUMap[NewCU->getUniqueID()] = 0;
765 // Call this to emit a .file directive if it wasn't emitted for the source
766 // file this CU comes from yet.
767 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
769 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
770 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
771 DIUnit.getLanguage());
772 NewCU->addString(Die, dwarf::DW_AT_name, FN);
774 // Define start line table label for each Compile Unit.
775 MCSymbol *LineTableStartSym =
776 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
777 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
778 NewCU->getUniqueID());
780 // Use a single line table if we are using .loc and generating assembly.
782 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
783 (NewCU->getUniqueID() == 0);
785 if (!useSplitDwarf()) {
786 // DW_AT_stmt_list is a offset of line number information for this
787 // compile unit in debug_line section. For split dwarf this is
788 // left in the skeleton CU and so not included.
789 // The line table entries are not always emitted in assembly, so it
790 // is not okay to use line_table_start here.
791 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
792 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
793 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
794 : LineTableStartSym);
795 else if (UseTheFirstCU)
796 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
798 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
799 DwarfLineSectionSym);
801 // If we're using split dwarf the compilation dir is going to be in the
802 // skeleton CU and so we don't need to duplicate it here.
803 if (!CompilationDir.empty())
804 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
806 addGnuPubAttributes(NewCU, Die);
809 if (DIUnit.isOptimized())
810 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
812 StringRef Flags = DIUnit.getFlags();
814 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
816 if (unsigned RVer = DIUnit.getRunTimeVersion())
817 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
818 dwarf::DW_FORM_data1, RVer);
823 if (useSplitDwarf()) {
824 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
825 DwarfInfoDWOSectionSym);
826 NewCU->setSkeleton(constructSkeletonCU(NewCU));
828 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
829 DwarfInfoSectionSym);
831 CUMap.insert(std::make_pair(DIUnit, NewCU));
832 CUDieMap.insert(std::make_pair(Die, NewCU));
836 // Construct subprogram DIE.
837 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
839 // FIXME: We should only call this routine once, however, during LTO if a
840 // program is defined in multiple CUs we could end up calling it out of
841 // beginModule as we walk the CUs.
843 DwarfCompileUnit *&CURef = SPMap[N];
849 if (!SP.isDefinition())
850 // This is a method declaration which will be handled while constructing
854 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
856 // Expose as a global name.
857 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
860 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
862 DIImportedEntity Module(N);
863 if (!Module.Verify())
865 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
866 constructImportedEntityDIE(TheCU, Module, D);
869 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
870 const MDNode *N, DIE *Context) {
871 DIImportedEntity Module(N);
872 if (!Module.Verify())
874 return constructImportedEntityDIE(TheCU, Module, Context);
877 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
878 const DIImportedEntity &Module,
880 assert(Module.Verify() &&
881 "Use one of the MDNode * overloads to handle invalid metadata");
882 assert(Context && "Should always have a context for an imported_module");
883 DIE *IMDie = new DIE(Module.getTag());
884 TheCU->insertDIE(Module, IMDie);
886 DIDescriptor Entity = Module.getEntity();
887 if (Entity.isNameSpace())
888 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
889 else if (Entity.isSubprogram())
890 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
891 else if (Entity.isType())
892 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
894 EntityDie = TheCU->getDIE(Entity);
895 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
896 Module.getContext().getDirectory(),
897 TheCU->getUniqueID());
898 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
899 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
900 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
901 StringRef Name = Module.getName();
903 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
904 Context->addChild(IMDie);
907 // Emit all Dwarf sections that should come prior to the content. Create
908 // global DIEs and emit initial debug info sections. This is invoked by
909 // the target AsmPrinter.
910 void DwarfDebug::beginModule() {
911 if (DisableDebugInfoPrinting)
914 const Module *M = MMI->getModule();
916 // If module has named metadata anchors then use them, otherwise scan the
917 // module using debug info finder to collect debug info.
918 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
921 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
923 // Emit initial sections so we can reference labels later.
926 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
927 DICompileUnit CUNode(CU_Nodes->getOperand(i));
928 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
929 DIArray ImportedEntities = CUNode.getImportedEntities();
930 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
931 ScopesWithImportedEntities.push_back(std::make_pair(
932 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
933 ImportedEntities.getElement(i)));
934 std::sort(ScopesWithImportedEntities.begin(),
935 ScopesWithImportedEntities.end(), less_first());
936 DIArray GVs = CUNode.getGlobalVariables();
937 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
938 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
939 DIArray SPs = CUNode.getSubprograms();
940 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
941 constructSubprogramDIE(CU, SPs.getElement(i));
942 DIArray EnumTypes = CUNode.getEnumTypes();
943 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
944 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
945 DIArray RetainedTypes = CUNode.getRetainedTypes();
946 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
947 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
948 // Emit imported_modules last so that the relevant context is already
950 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
951 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
954 // Tell MMI that we have debug info.
955 MMI->setDebugInfoAvailability(true);
957 // Prime section data.
958 SectionMap[Asm->getObjFileLowering().getTextSection()];
961 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
962 void DwarfDebug::computeInlinedDIEs() {
963 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
964 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
965 AE = InlinedSubprogramDIEs.end();
968 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
970 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
971 AE = AbstractSPDies.end();
973 DIE *ISP = AI->second;
974 if (InlinedSubprogramDIEs.count(ISP))
976 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
980 // Collect info for variables that were optimized out.
981 void DwarfDebug::collectDeadVariables() {
982 const Module *M = MMI->getModule();
984 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
985 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
986 DICompileUnit TheCU(CU_Nodes->getOperand(i));
987 DIArray Subprograms = TheCU.getSubprograms();
988 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
989 DISubprogram SP(Subprograms.getElement(i));
990 if (ProcessedSPNodes.count(SP) != 0)
992 if (!SP.isSubprogram())
994 if (!SP.isDefinition())
996 DIArray Variables = SP.getVariables();
997 if (Variables.getNumElements() == 0)
1000 // Construct subprogram DIE and add variables DIEs.
1001 DwarfCompileUnit *SPCU =
1002 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1003 assert(SPCU && "Unable to find Compile Unit!");
1004 // FIXME: See the comment in constructSubprogramDIE about duplicate
1006 constructSubprogramDIE(SPCU, SP);
1007 DIE *SPDIE = SPCU->getDIE(SP);
1008 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1009 DIVariable DV(Variables.getElement(vi));
1010 if (!DV.isVariable())
1012 DbgVariable NewVar(DV, NULL, this);
1013 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1014 SPDIE->addChild(VariableDIE);
1021 void DwarfDebug::finalizeModuleInfo() {
1022 // Collect info for variables that were optimized out.
1023 collectDeadVariables();
1025 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1026 computeInlinedDIEs();
1028 // Handle anything that needs to be done on a per-unit basis after
1029 // all other generation.
1030 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1031 E = getUnits().end();
1033 DwarfUnit *TheU = *I;
1034 // Emit DW_AT_containing_type attribute to connect types with their
1035 // vtable holding type.
1036 TheU->constructContainingTypeDIEs();
1038 // Add CU specific attributes if we need to add any.
1039 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1040 // If we're splitting the dwarf out now that we've got the entire
1041 // CU then add the dwo id to it.
1042 DwarfCompileUnit *SkCU =
1043 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1044 if (useSplitDwarf()) {
1045 // This should be a unique identifier when we want to build .dwp files.
1047 if (GenerateCUHash) {
1049 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1051 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1052 dwarf::DW_FORM_data8, ID);
1053 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1054 dwarf::DW_FORM_data8, ID);
1057 // If we have code split among multiple sections or we've requested
1058 // it then emit a DW_AT_ranges attribute on the unit that will remain
1059 // in the .o file, otherwise add a DW_AT_low_pc.
1060 // FIXME: Also add a high pc if we can.
1061 // FIXME: We should use ranges if we have multiple compile units or
1062 // allow reordering of code ala .subsections_via_symbols in mach-o.
1063 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1064 if (useCURanges() && TheU->getRanges().size())
1065 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1066 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1067 DwarfDebugRangeSectionSym);
1069 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1074 // Compute DIE offsets and sizes.
1075 InfoHolder.computeSizeAndOffsets();
1076 if (useSplitDwarf())
1077 SkeletonHolder.computeSizeAndOffsets();
1080 void DwarfDebug::endSections() {
1081 // Filter labels by section.
1082 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1083 const SymbolCU &SCU = ArangeLabels[n];
1084 if (SCU.Sym->isInSection()) {
1085 // Make a note of this symbol and it's section.
1086 const MCSection *Section = &SCU.Sym->getSection();
1087 if (!Section->getKind().isMetadata())
1088 SectionMap[Section].push_back(SCU);
1090 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1091 // appear in the output. This sucks as we rely on sections to build
1092 // arange spans. We can do it without, but it's icky.
1093 SectionMap[NULL].push_back(SCU);
1097 // Build a list of sections used.
1098 std::vector<const MCSection *> Sections;
1099 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1101 const MCSection *Section = it->first;
1102 Sections.push_back(Section);
1105 // Sort the sections into order.
1106 // This is only done to ensure consistent output order across different runs.
1107 std::sort(Sections.begin(), Sections.end(), SectionSort);
1109 // Add terminating symbols for each section.
1110 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1111 const MCSection *Section = Sections[ID];
1112 MCSymbol *Sym = NULL;
1115 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1116 // if we know the section name up-front. For user-created sections, the
1118 // label may not be valid to use as a label. (section names can use a
1120 // set of characters on some systems)
1121 Sym = Asm->GetTempSymbol("debug_end", ID);
1122 Asm->OutStreamer.SwitchSection(Section);
1123 Asm->OutStreamer.EmitLabel(Sym);
1126 // Insert a final terminator.
1127 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1131 // Emit all Dwarf sections that should come after the content.
1132 void DwarfDebug::endModule() {
1139 // End any existing sections.
1140 // TODO: Does this need to happen?
1143 // Finalize the debug info for the module.
1144 finalizeModuleInfo();
1148 // Emit all the DIEs into a debug info section.
1151 // Corresponding abbreviations into a abbrev section.
1152 emitAbbreviations();
1154 // Emit info into a debug loc section.
1157 // Emit info into a debug aranges section.
1160 // Emit info into a debug ranges section.
1163 if (useSplitDwarf()) {
1166 emitDebugAbbrevDWO();
1167 // Emit DWO addresses.
1168 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1171 // Emit info into the dwarf accelerator table sections.
1172 if (useDwarfAccelTables()) {
1175 emitAccelNamespaces();
1179 // Emit the pubnames and pubtypes sections if requested.
1180 if (HasDwarfPubSections) {
1181 emitDebugPubNames(GenerateGnuPubSections);
1182 emitDebugPubTypes(GenerateGnuPubSections);
1188 // Reset these for the next Module if we have one.
1192 // Find abstract variable, if any, associated with Var.
1193 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1194 DebugLoc ScopeLoc) {
1195 LLVMContext &Ctx = DV->getContext();
1196 // More then one inlined variable corresponds to one abstract variable.
1197 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1198 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1200 return AbsDbgVariable;
1202 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1206 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1207 addScopeVariable(Scope, AbsDbgVariable);
1208 AbstractVariables[Var] = AbsDbgVariable;
1209 return AbsDbgVariable;
1212 // If Var is a current function argument then add it to CurrentFnArguments list.
1213 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1214 if (!LScopes.isCurrentFunctionScope(Scope))
1216 DIVariable DV = Var->getVariable();
1217 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1219 unsigned ArgNo = DV.getArgNumber();
1223 size_t Size = CurrentFnArguments.size();
1225 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1226 // llvm::Function argument size is not good indicator of how many
1227 // arguments does the function have at source level.
1229 CurrentFnArguments.resize(ArgNo * 2);
1230 CurrentFnArguments[ArgNo - 1] = Var;
1234 // Collect variable information from side table maintained by MMI.
1235 void DwarfDebug::collectVariableInfoFromMMITable(
1236 SmallPtrSet<const MDNode *, 16> &Processed) {
1237 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1238 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1241 const MDNode *Var = VI->first;
1244 Processed.insert(Var);
1246 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1248 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1250 // If variable scope is not found then skip this variable.
1254 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1255 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1256 RegVar->setFrameIndex(VP.first);
1257 if (!addCurrentFnArgument(RegVar, Scope))
1258 addScopeVariable(Scope, RegVar);
1260 AbsDbgVariable->setFrameIndex(VP.first);
1264 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1266 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1267 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1268 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1269 MI->getOperand(0).getReg() &&
1270 (MI->getOperand(1).isImm() ||
1271 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1274 // Get .debug_loc entry for the instruction range starting at MI.
1275 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1276 const MCSymbol *FLabel,
1277 const MCSymbol *SLabel,
1278 const MachineInstr *MI) {
1279 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1281 assert(MI->getNumOperands() == 3);
1282 if (MI->getOperand(0).isReg()) {
1283 MachineLocation MLoc;
1284 // If the second operand is an immediate, this is a
1285 // register-indirect address.
1286 if (!MI->getOperand(1).isImm())
1287 MLoc.set(MI->getOperand(0).getReg());
1289 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1290 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1292 if (MI->getOperand(0).isImm())
1293 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1294 if (MI->getOperand(0).isFPImm())
1295 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1296 if (MI->getOperand(0).isCImm())
1297 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1299 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1302 // Find variables for each lexical scope.
1304 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1306 // Grab the variable info that was squirreled away in the MMI side-table.
1307 collectVariableInfoFromMMITable(Processed);
1309 for (SmallVectorImpl<const MDNode *>::const_iterator
1310 UVI = UserVariables.begin(),
1311 UVE = UserVariables.end();
1312 UVI != UVE; ++UVI) {
1313 const MDNode *Var = *UVI;
1314 if (Processed.count(Var))
1317 // History contains relevant DBG_VALUE instructions for Var and instructions
1319 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1320 if (History.empty())
1322 const MachineInstr *MInsn = History.front();
1325 LexicalScope *Scope = NULL;
1326 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1327 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1328 Scope = LScopes.getCurrentFunctionScope();
1329 else if (MDNode *IA = DV.getInlinedAt())
1330 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1332 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1333 // If variable scope is not found then skip this variable.
1337 Processed.insert(DV);
1338 assert(MInsn->isDebugValue() && "History must begin with debug value");
1339 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1340 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1341 if (!addCurrentFnArgument(RegVar, Scope))
1342 addScopeVariable(Scope, RegVar);
1344 AbsVar->setMInsn(MInsn);
1346 // Simplify ranges that are fully coalesced.
1347 if (History.size() <= 1 ||
1348 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1349 RegVar->setMInsn(MInsn);
1353 // Handle multiple DBG_VALUE instructions describing one variable.
1354 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1356 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1357 HI = History.begin(),
1360 const MachineInstr *Begin = *HI;
1361 assert(Begin->isDebugValue() && "Invalid History entry");
1363 // Check if DBG_VALUE is truncating a range.
1364 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1365 !Begin->getOperand(0).getReg())
1368 // Compute the range for a register location.
1369 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1370 const MCSymbol *SLabel = 0;
1373 // If Begin is the last instruction in History then its value is valid
1374 // until the end of the function.
1375 SLabel = FunctionEndSym;
1377 const MachineInstr *End = HI[1];
1378 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1379 << "\t" << *Begin << "\t" << *End << "\n");
1380 if (End->isDebugValue())
1381 SLabel = getLabelBeforeInsn(End);
1383 // End is a normal instruction clobbering the range.
1384 SLabel = getLabelAfterInsn(End);
1385 assert(SLabel && "Forgot label after clobber instruction");
1390 // The value is valid until the next DBG_VALUE or clobber.
1391 DotDebugLocEntries.push_back(
1392 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1394 DotDebugLocEntries.push_back(DotDebugLocEntry());
1397 // Collect info for variables that were optimized out.
1398 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1399 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1400 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1401 DIVariable DV(Variables.getElement(i));
1402 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1404 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1405 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1409 // Return Label preceding the instruction.
1410 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1411 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1412 assert(Label && "Didn't insert label before instruction");
1416 // Return Label immediately following the instruction.
1417 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1418 return LabelsAfterInsn.lookup(MI);
1421 // Process beginning of an instruction.
1422 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1425 // Check if source location changes, but ignore DBG_VALUE locations.
1426 if (!MI->isDebugValue()) {
1427 DebugLoc DL = MI->getDebugLoc();
1428 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1431 if (DL == PrologEndLoc) {
1432 Flags |= DWARF2_FLAG_PROLOGUE_END;
1433 PrologEndLoc = DebugLoc();
1435 if (PrologEndLoc.isUnknown())
1436 Flags |= DWARF2_FLAG_IS_STMT;
1438 if (!DL.isUnknown()) {
1439 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1440 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1442 recordSourceLine(0, 0, 0, 0);
1446 // Insert labels where requested.
1447 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1448 LabelsBeforeInsn.find(MI);
1451 if (I == LabelsBeforeInsn.end())
1454 // Label already assigned.
1459 PrevLabel = MMI->getContext().CreateTempSymbol();
1460 Asm->OutStreamer.EmitLabel(PrevLabel);
1462 I->second = PrevLabel;
1465 // Process end of an instruction.
1466 void DwarfDebug::endInstruction() {
1468 // Don't create a new label after DBG_VALUE instructions.
1469 // They don't generate code.
1470 if (!CurMI->isDebugValue())
1473 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1474 LabelsAfterInsn.find(CurMI);
1478 if (I == LabelsAfterInsn.end())
1481 // Label already assigned.
1485 // We need a label after this instruction.
1487 PrevLabel = MMI->getContext().CreateTempSymbol();
1488 Asm->OutStreamer.EmitLabel(PrevLabel);
1490 I->second = PrevLabel;
1493 // Each LexicalScope has first instruction and last instruction to mark
1494 // beginning and end of a scope respectively. Create an inverse map that list
1495 // scopes starts (and ends) with an instruction. One instruction may start (or
1496 // end) multiple scopes. Ignore scopes that are not reachable.
1497 void DwarfDebug::identifyScopeMarkers() {
1498 SmallVector<LexicalScope *, 4> WorkList;
1499 WorkList.push_back(LScopes.getCurrentFunctionScope());
1500 while (!WorkList.empty()) {
1501 LexicalScope *S = WorkList.pop_back_val();
1503 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1504 if (!Children.empty())
1505 for (SmallVectorImpl<LexicalScope *>::const_iterator
1506 SI = Children.begin(),
1507 SE = Children.end();
1509 WorkList.push_back(*SI);
1511 if (S->isAbstractScope())
1514 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1517 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1520 assert(RI->first && "InsnRange does not have first instruction!");
1521 assert(RI->second && "InsnRange does not have second instruction!");
1522 requestLabelBeforeInsn(RI->first);
1523 requestLabelAfterInsn(RI->second);
1528 // Get MDNode for DebugLoc's scope.
1529 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1530 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1531 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1532 return DL.getScope(Ctx);
1535 // Walk up the scope chain of given debug loc and find line number info
1536 // for the function.
1537 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1538 const MDNode *Scope = getScopeNode(DL, Ctx);
1539 DISubprogram SP = getDISubprogram(Scope);
1540 if (SP.isSubprogram()) {
1541 // Check for number of operands since the compatibility is
1543 if (SP->getNumOperands() > 19)
1544 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1546 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1552 // Gather pre-function debug information. Assumes being called immediately
1553 // after the function entry point has been emitted.
1554 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1557 // If there's no debug info for the function we're not going to do anything.
1558 if (!MMI->hasDebugInfo())
1561 // Grab the lexical scopes for the function, if we don't have any of those
1562 // then we're not going to be able to do anything.
1563 LScopes.initialize(*MF);
1564 if (LScopes.empty())
1567 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1569 // Make sure that each lexical scope will have a begin/end label.
1570 identifyScopeMarkers();
1572 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1573 // belongs to so that we add to the correct per-cu line table in the
1575 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1576 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1577 assert(TheCU && "Unable to find compile unit!");
1578 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1579 // Use a single line table if we are using .loc and generating assembly.
1580 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1582 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1584 // Emit a label for the function so that we have a beginning address.
1585 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1586 // Assumes in correct section after the entry point.
1587 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1589 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1590 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1591 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1593 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1595 bool AtBlockEntry = true;
1596 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1598 const MachineInstr *MI = II;
1600 if (MI->isDebugValue()) {
1601 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1603 // Keep track of user variables.
1605 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1607 // Variable is in a register, we need to check for clobbers.
1608 if (isDbgValueInDefinedReg(MI))
1609 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1611 // Check the history of this variable.
1612 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1613 if (History.empty()) {
1614 UserVariables.push_back(Var);
1615 // The first mention of a function argument gets the FunctionBeginSym
1616 // label, so arguments are visible when breaking at function entry.
1618 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1619 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1620 LabelsBeforeInsn[MI] = FunctionBeginSym;
1622 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1623 const MachineInstr *Prev = History.back();
1624 if (Prev->isDebugValue()) {
1625 // Coalesce identical entries at the end of History.
1626 if (History.size() >= 2 &&
1627 Prev->isIdenticalTo(History[History.size() - 2])) {
1628 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1629 << "\t" << *Prev << "\t"
1630 << *History[History.size() - 2] << "\n");
1634 // Terminate old register assignments that don't reach MI;
1635 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1636 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1637 isDbgValueInDefinedReg(Prev)) {
1638 // Previous register assignment needs to terminate at the end of
1640 MachineBasicBlock::const_iterator LastMI =
1641 PrevMBB->getLastNonDebugInstr();
1642 if (LastMI == PrevMBB->end()) {
1643 // Drop DBG_VALUE for empty range.
1644 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1645 << "\t" << *Prev << "\n");
1647 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1648 // Terminate after LastMI.
1649 History.push_back(LastMI);
1653 History.push_back(MI);
1655 // Not a DBG_VALUE instruction.
1657 AtBlockEntry = false;
1659 // First known non-DBG_VALUE and non-frame setup location marks
1660 // the beginning of the function body.
1661 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1662 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1663 PrologEndLoc = MI->getDebugLoc();
1665 // Check if the instruction clobbers any registers with debug vars.
1666 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1667 MOE = MI->operands_end();
1668 MOI != MOE; ++MOI) {
1669 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1671 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1674 const MDNode *Var = LiveUserVar[Reg];
1677 // Reg is now clobbered.
1678 LiveUserVar[Reg] = 0;
1680 // Was MD last defined by a DBG_VALUE referring to Reg?
1681 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1682 if (HistI == DbgValues.end())
1684 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1685 if (History.empty())
1687 const MachineInstr *Prev = History.back();
1688 // Sanity-check: Register assignments are terminated at the end of
1690 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1692 // Is the variable still in Reg?
1693 if (!isDbgValueInDefinedReg(Prev) ||
1694 Prev->getOperand(0).getReg() != Reg)
1696 // Var is clobbered. Make sure the next instruction gets a label.
1697 History.push_back(MI);
1704 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1706 SmallVectorImpl<const MachineInstr *> &History = I->second;
1707 if (History.empty())
1710 // Make sure the final register assignments are terminated.
1711 const MachineInstr *Prev = History.back();
1712 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1713 const MachineBasicBlock *PrevMBB = Prev->getParent();
1714 MachineBasicBlock::const_iterator LastMI =
1715 PrevMBB->getLastNonDebugInstr();
1716 if (LastMI == PrevMBB->end())
1717 // Drop DBG_VALUE for empty range.
1719 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1720 // Terminate after LastMI.
1721 History.push_back(LastMI);
1724 // Request labels for the full history.
1725 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1726 const MachineInstr *MI = History[i];
1727 if (MI->isDebugValue())
1728 requestLabelBeforeInsn(MI);
1730 requestLabelAfterInsn(MI);
1734 PrevInstLoc = DebugLoc();
1735 PrevLabel = FunctionBeginSym;
1737 // Record beginning of function.
1738 if (!PrologEndLoc.isUnknown()) {
1739 DebugLoc FnStartDL =
1740 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1742 FnStartDL.getLine(), FnStartDL.getCol(),
1743 FnStartDL.getScope(MF->getFunction()->getContext()),
1744 // We'd like to list the prologue as "not statements" but GDB behaves
1745 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1746 DWARF2_FLAG_IS_STMT);
1750 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1751 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1752 DIVariable DV = Var->getVariable();
1753 // Variables with positive arg numbers are parameters.
1754 if (unsigned ArgNum = DV.getArgNumber()) {
1755 // Keep all parameters in order at the start of the variable list to ensure
1756 // function types are correct (no out-of-order parameters)
1758 // This could be improved by only doing it for optimized builds (unoptimized
1759 // builds have the right order to begin with), searching from the back (this
1760 // would catch the unoptimized case quickly), or doing a binary search
1761 // rather than linear search.
1762 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1763 while (I != Vars.end()) {
1764 unsigned CurNum = (*I)->getVariable().getArgNumber();
1765 // A local (non-parameter) variable has been found, insert immediately
1769 // A later indexed parameter has been found, insert immediately before it.
1770 if (CurNum > ArgNum)
1774 Vars.insert(I, Var);
1778 Vars.push_back(Var);
1781 // Gather and emit post-function debug information.
1782 void DwarfDebug::endFunction(const MachineFunction *MF) {
1783 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1784 // though the beginFunction may not be called at all.
1785 // We should handle both cases.
1789 assert(CurFn == MF);
1792 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1797 // Define end label for subprogram.
1798 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1799 // Assumes in correct section after the entry point.
1800 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1801 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1802 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1804 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1805 collectVariableInfo(ProcessedVars);
1807 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1808 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1809 assert(TheCU && "Unable to find compile unit!");
1811 // Construct abstract scopes.
1812 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1813 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1814 LexicalScope *AScope = AList[i];
1815 DISubprogram SP(AScope->getScopeNode());
1816 if (SP.isSubprogram()) {
1817 // Collect info for variables that were optimized out.
1818 DIArray Variables = SP.getVariables();
1819 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1820 DIVariable DV(Variables.getElement(i));
1821 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1823 // Check that DbgVariable for DV wasn't created earlier, when
1824 // findAbstractVariable() was called for inlined instance of DV.
1825 LLVMContext &Ctx = DV->getContext();
1826 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1827 if (AbstractVariables.lookup(CleanDV))
1829 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1830 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1833 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1834 constructScopeDIE(TheCU, AScope);
1837 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1839 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1840 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1843 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1844 E = ScopeVariables.end();
1846 DeleteContainerPointers(I->second);
1847 ScopeVariables.clear();
1848 DeleteContainerPointers(CurrentFnArguments);
1849 UserVariables.clear();
1851 AbstractVariables.clear();
1852 LabelsBeforeInsn.clear();
1853 LabelsAfterInsn.clear();
1858 // Register a source line with debug info. Returns the unique label that was
1859 // emitted and which provides correspondence to the source line list.
1860 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1866 DIDescriptor Scope(S);
1868 if (Scope.isCompileUnit()) {
1869 DICompileUnit CU(S);
1870 Fn = CU.getFilename();
1871 Dir = CU.getDirectory();
1872 } else if (Scope.isFile()) {
1874 Fn = F.getFilename();
1875 Dir = F.getDirectory();
1876 } else if (Scope.isSubprogram()) {
1878 Fn = SP.getFilename();
1879 Dir = SP.getDirectory();
1880 } else if (Scope.isLexicalBlockFile()) {
1881 DILexicalBlockFile DBF(S);
1882 Fn = DBF.getFilename();
1883 Dir = DBF.getDirectory();
1884 } else if (Scope.isLexicalBlock()) {
1885 DILexicalBlock DB(S);
1886 Fn = DB.getFilename();
1887 Dir = DB.getDirectory();
1889 llvm_unreachable("Unexpected scope info");
1891 Src = getOrCreateSourceID(
1892 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1894 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1897 //===----------------------------------------------------------------------===//
1899 //===----------------------------------------------------------------------===//
1901 // Compute the size and offset of a DIE. The offset is relative to start of the
1902 // CU. It returns the offset after laying out the DIE.
1903 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1904 // Get the children.
1905 const std::vector<DIE *> &Children = Die->getChildren();
1907 // Record the abbreviation.
1908 assignAbbrevNumber(Die->getAbbrev());
1910 // Get the abbreviation for this DIE.
1911 const DIEAbbrev &Abbrev = Die->getAbbrev();
1914 Die->setOffset(Offset);
1916 // Start the size with the size of abbreviation code.
1917 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1919 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1920 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1922 // Size the DIE attribute values.
1923 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1924 // Size attribute value.
1925 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1927 // Size the DIE children if any.
1928 if (!Children.empty()) {
1929 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1930 "Children flag not set");
1932 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1933 Offset = computeSizeAndOffset(Children[j], Offset);
1935 // End of children marker.
1936 Offset += sizeof(int8_t);
1939 Die->setSize(Offset - Die->getOffset());
1943 // Compute the size and offset for each DIE.
1944 void DwarfFile::computeSizeAndOffsets() {
1945 // Offset from the first CU in the debug info section is 0 initially.
1946 unsigned SecOffset = 0;
1948 // Iterate over each compile unit and set the size and offsets for each
1949 // DIE within each compile unit. All offsets are CU relative.
1950 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1953 (*I)->setDebugInfoOffset(SecOffset);
1955 // CU-relative offset is reset to 0 here.
1956 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1957 (*I)->getHeaderSize(); // Unit-specific headers
1959 // EndOffset here is CU-relative, after laying out
1960 // all of the CU DIE.
1961 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1962 SecOffset += EndOffset;
1966 // Emit initial Dwarf sections with a label at the start of each one.
1967 void DwarfDebug::emitSectionLabels() {
1968 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1970 // Dwarf sections base addresses.
1971 DwarfInfoSectionSym =
1972 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1973 if (useSplitDwarf())
1974 DwarfInfoDWOSectionSym =
1975 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1976 DwarfAbbrevSectionSym =
1977 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1978 if (useSplitDwarf())
1979 DwarfAbbrevDWOSectionSym = emitSectionSym(
1980 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1981 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1983 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1984 emitSectionSym(Asm, MacroInfo);
1986 DwarfLineSectionSym =
1987 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1988 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1989 if (GenerateGnuPubSections) {
1990 DwarfGnuPubNamesSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1992 DwarfGnuPubTypesSectionSym =
1993 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1994 } else if (HasDwarfPubSections) {
1995 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1996 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1999 DwarfStrSectionSym =
2000 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2001 if (useSplitDwarf()) {
2002 DwarfStrDWOSectionSym =
2003 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2004 DwarfAddrSectionSym =
2005 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2007 DwarfDebugRangeSectionSym =
2008 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2010 DwarfDebugLocSectionSym =
2011 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2014 // Recursively emits a debug information entry.
2015 void DwarfDebug::emitDIE(DIE *Die) {
2016 // Get the abbreviation for this DIE.
2017 const DIEAbbrev &Abbrev = Die->getAbbrev();
2019 // Emit the code (index) for the abbreviation.
2020 if (Asm->isVerbose())
2021 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2022 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2023 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2024 dwarf::TagString(Abbrev.getTag()));
2025 Asm->EmitULEB128(Abbrev.getNumber());
2027 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2028 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2030 // Emit the DIE attribute values.
2031 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2032 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2033 dwarf::Form Form = AbbrevData[i].getForm();
2034 assert(Form && "Too many attributes for DIE (check abbreviation)");
2036 if (Asm->isVerbose())
2037 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2040 case dwarf::DW_AT_abstract_origin:
2041 case dwarf::DW_AT_type:
2042 case dwarf::DW_AT_friend:
2043 case dwarf::DW_AT_specification:
2044 case dwarf::DW_AT_import:
2045 case dwarf::DW_AT_containing_type: {
2046 DIEEntry *E = cast<DIEEntry>(Values[i]);
2047 DIE *Origin = E->getEntry();
2048 unsigned Addr = Origin->getOffset();
2049 if (Form == dwarf::DW_FORM_ref_addr) {
2050 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2051 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2052 // section. Origin->getOffset() returns the offset from start of the
2054 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2055 assert(CU && "CUDie should belong to a CU.");
2056 Addr += CU->getDebugInfoOffset();
2057 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2058 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2059 DIEEntry::getRefAddrSize(Asm));
2061 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2062 CU->getSectionSym(),
2063 DIEEntry::getRefAddrSize(Asm));
2065 // Make sure Origin belong to the same CU.
2066 assert(Die->getUnit() == Origin->getUnit() &&
2067 "The referenced DIE should belong to the same CU in ref4");
2068 Asm->EmitInt32(Addr);
2072 case dwarf::DW_AT_location: {
2073 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2074 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2075 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2077 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2079 Values[i]->EmitValue(Asm, Form);
2083 case dwarf::DW_AT_accessibility: {
2084 if (Asm->isVerbose()) {
2085 DIEInteger *V = cast<DIEInteger>(Values[i]);
2086 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2088 Values[i]->EmitValue(Asm, Form);
2092 // Emit an attribute using the defined form.
2093 Values[i]->EmitValue(Asm, Form);
2098 // Emit the DIE children if any.
2099 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2100 const std::vector<DIE *> &Children = Die->getChildren();
2102 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2103 emitDIE(Children[j]);
2105 Asm->OutStreamer.AddComment("End Of Children Mark");
2110 // Emit the various dwarf units to the unit section USection with
2111 // the abbreviations going into ASection.
2112 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2113 const MCSymbol *ASectionSym) {
2114 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2116 DwarfUnit *TheU = *I;
2117 DIE *Die = TheU->getUnitDie();
2118 const MCSection *USection = TheU->getSection();
2119 Asm->OutStreamer.SwitchSection(USection);
2121 // Emit the compile units header.
2122 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2124 // Emit size of content not including length itself
2125 Asm->OutStreamer.AddComment("Length of Unit");
2126 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2128 TheU->emitHeader(ASection, ASectionSym);
2131 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2135 // Emit the debug info section.
2136 void DwarfDebug::emitDebugInfo() {
2137 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2139 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2140 DwarfAbbrevSectionSym);
2143 // Emit the abbreviation section.
2144 void DwarfDebug::emitAbbreviations() {
2145 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2147 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2150 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2151 // Check to see if it is worth the effort.
2152 if (!Abbreviations.empty()) {
2153 // Start the debug abbrev section.
2154 Asm->OutStreamer.SwitchSection(Section);
2156 // For each abbrevation.
2157 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2158 // Get abbreviation data
2159 const DIEAbbrev *Abbrev = Abbreviations[i];
2161 // Emit the abbrevations code (base 1 index.)
2162 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2164 // Emit the abbreviations data.
2168 // Mark end of abbreviations.
2169 Asm->EmitULEB128(0, "EOM(3)");
2173 // Emit the last address of the section and the end of the line matrix.
2174 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2175 // Define last address of section.
2176 Asm->OutStreamer.AddComment("Extended Op");
2179 Asm->OutStreamer.AddComment("Op size");
2180 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2181 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2182 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2184 Asm->OutStreamer.AddComment("Section end label");
2186 Asm->OutStreamer.EmitSymbolValue(
2187 Asm->GetTempSymbol("section_end", SectionEnd),
2188 Asm->getDataLayout().getPointerSize());
2190 // Mark end of matrix.
2191 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2197 // Emit visible names into a hashed accelerator table section.
2198 void DwarfDebug::emitAccelNames() {
2200 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2201 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2202 E = getUnits().end();
2204 DwarfUnit *TheU = *I;
2205 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2206 for (StringMap<std::vector<const DIE *> >::const_iterator
2210 StringRef Name = GI->getKey();
2211 const std::vector<const DIE *> &Entities = GI->second;
2212 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2213 DE = Entities.end();
2215 AT.AddName(Name, *DI);
2219 AT.FinalizeTable(Asm, "Names");
2220 Asm->OutStreamer.SwitchSection(
2221 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2222 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2223 Asm->OutStreamer.EmitLabel(SectionBegin);
2225 // Emit the full data.
2226 AT.Emit(Asm, SectionBegin, &InfoHolder);
2229 // Emit objective C classes and categories into a hashed accelerator table
2231 void DwarfDebug::emitAccelObjC() {
2233 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2234 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2235 E = getUnits().end();
2237 DwarfUnit *TheU = *I;
2238 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2239 for (StringMap<std::vector<const DIE *> >::const_iterator
2243 StringRef Name = GI->getKey();
2244 const std::vector<const DIE *> &Entities = GI->second;
2245 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2246 DE = Entities.end();
2248 AT.AddName(Name, *DI);
2252 AT.FinalizeTable(Asm, "ObjC");
2253 Asm->OutStreamer.SwitchSection(
2254 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2255 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2256 Asm->OutStreamer.EmitLabel(SectionBegin);
2258 // Emit the full data.
2259 AT.Emit(Asm, SectionBegin, &InfoHolder);
2262 // Emit namespace dies into a hashed accelerator table.
2263 void DwarfDebug::emitAccelNamespaces() {
2265 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2266 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2267 E = getUnits().end();
2269 DwarfUnit *TheU = *I;
2270 const StringMap<std::vector<const DIE *> > &Names =
2271 TheU->getAccelNamespace();
2272 for (StringMap<std::vector<const DIE *> >::const_iterator
2276 StringRef Name = GI->getKey();
2277 const std::vector<const DIE *> &Entities = GI->second;
2278 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2279 DE = Entities.end();
2281 AT.AddName(Name, *DI);
2285 AT.FinalizeTable(Asm, "namespac");
2286 Asm->OutStreamer.SwitchSection(
2287 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2288 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2289 Asm->OutStreamer.EmitLabel(SectionBegin);
2291 // Emit the full data.
2292 AT.Emit(Asm, SectionBegin, &InfoHolder);
2295 // Emit type dies into a hashed accelerator table.
2296 void DwarfDebug::emitAccelTypes() {
2297 std::vector<DwarfAccelTable::Atom> Atoms;
2299 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2301 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2303 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2304 DwarfAccelTable AT(Atoms);
2305 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2306 E = getUnits().end();
2308 DwarfUnit *TheU = *I;
2309 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2310 TheU->getAccelTypes();
2312 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2316 StringRef Name = GI->getKey();
2317 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2319 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2320 DI = Entities.begin(),
2321 DE = Entities.end();
2323 AT.AddName(Name, DI->first, DI->second);
2327 AT.FinalizeTable(Asm, "types");
2328 Asm->OutStreamer.SwitchSection(
2329 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2330 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2331 Asm->OutStreamer.EmitLabel(SectionBegin);
2333 // Emit the full data.
2334 AT.Emit(Asm, SectionBegin, &InfoHolder);
2337 // Public name handling.
2338 // The format for the various pubnames:
2340 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2341 // for the DIE that is named.
2343 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2344 // into the CU and the index value is computed according to the type of value
2345 // for the DIE that is named.
2347 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2348 // it's the offset within the debug_info/debug_types dwo section, however, the
2349 // reference in the pubname header doesn't change.
2351 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2352 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2354 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2356 // We could have a specification DIE that has our most of our knowledge,
2357 // look for that now.
2358 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2360 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2361 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2362 Linkage = dwarf::GIEL_EXTERNAL;
2363 } else if (Die->findAttribute(dwarf::DW_AT_external))
2364 Linkage = dwarf::GIEL_EXTERNAL;
2366 switch (Die->getTag()) {
2367 case dwarf::DW_TAG_class_type:
2368 case dwarf::DW_TAG_structure_type:
2369 case dwarf::DW_TAG_union_type:
2370 case dwarf::DW_TAG_enumeration_type:
2371 return dwarf::PubIndexEntryDescriptor(
2372 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2373 ? dwarf::GIEL_STATIC
2374 : dwarf::GIEL_EXTERNAL);
2375 case dwarf::DW_TAG_typedef:
2376 case dwarf::DW_TAG_base_type:
2377 case dwarf::DW_TAG_subrange_type:
2378 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2379 case dwarf::DW_TAG_namespace:
2380 return dwarf::GIEK_TYPE;
2381 case dwarf::DW_TAG_subprogram:
2382 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2383 case dwarf::DW_TAG_constant:
2384 case dwarf::DW_TAG_variable:
2385 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2386 case dwarf::DW_TAG_enumerator:
2387 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2388 dwarf::GIEL_STATIC);
2390 return dwarf::GIEK_NONE;
2394 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2396 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2397 const MCSection *PSec =
2398 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2399 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2401 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2402 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2403 for (unsigned i = 0; i != Units.size(); ++i) {
2404 DwarfUnit *TheU = Units[i];
2405 unsigned ID = TheU->getUniqueID();
2407 // Start the dwarf pubnames section.
2408 Asm->OutStreamer.SwitchSection(PSec);
2410 // Emit a label so we can reference the beginning of this pubname section.
2412 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2415 Asm->OutStreamer.AddComment("Length of Public Names Info");
2416 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2417 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2418 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2420 Asm->OutStreamer.EmitLabel(BeginLabel);
2422 Asm->OutStreamer.AddComment("DWARF Version");
2423 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2425 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2426 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2428 Asm->OutStreamer.AddComment("Compilation Unit Length");
2429 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2431 // Emit the pubnames for this compilation unit.
2432 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2433 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2436 const char *Name = GI->getKeyData();
2437 const DIE *Entity = GI->second;
2439 Asm->OutStreamer.AddComment("DIE offset");
2440 Asm->EmitInt32(Entity->getOffset());
2443 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2444 Asm->OutStreamer.AddComment(
2445 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2446 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2447 Asm->EmitInt8(Desc.toBits());
2450 Asm->OutStreamer.AddComment("External Name");
2451 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2454 Asm->OutStreamer.AddComment("End Mark");
2456 Asm->OutStreamer.EmitLabel(EndLabel);
2460 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2461 const MCSection *PSec =
2462 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2463 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2465 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2466 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2467 for (unsigned i = 0; i != Units.size(); ++i) {
2468 DwarfUnit *TheU = Units[i];
2469 unsigned ID = TheU->getUniqueID();
2471 // Start the dwarf pubtypes section.
2472 Asm->OutStreamer.SwitchSection(PSec);
2474 // Emit a label so we can reference the beginning of this pubtype section.
2476 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2479 Asm->OutStreamer.AddComment("Length of Public Types Info");
2480 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2481 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2482 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2484 Asm->OutStreamer.EmitLabel(BeginLabel);
2486 Asm->OutStreamer.AddComment("DWARF Version");
2487 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2489 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2490 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2492 Asm->OutStreamer.AddComment("Compilation Unit Length");
2493 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2495 // Emit the pubtypes.
2496 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2497 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2500 const char *Name = GI->getKeyData();
2501 const DIE *Entity = GI->second;
2503 Asm->OutStreamer.AddComment("DIE offset");
2504 Asm->EmitInt32(Entity->getOffset());
2507 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2508 Asm->OutStreamer.AddComment(
2509 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2510 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2511 Asm->EmitInt8(Desc.toBits());
2514 Asm->OutStreamer.AddComment("External Name");
2516 // Emit the name with a terminating null byte.
2517 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2520 Asm->OutStreamer.AddComment("End Mark");
2522 Asm->OutStreamer.EmitLabel(EndLabel);
2526 // Emit strings into a string section.
2527 void DwarfFile::emitStrings(const MCSection *StrSection,
2528 const MCSection *OffsetSection = NULL,
2529 const MCSymbol *StrSecSym = NULL) {
2531 if (StringPool.empty())
2534 // Start the dwarf str section.
2535 Asm->OutStreamer.SwitchSection(StrSection);
2537 // Get all of the string pool entries and put them in an array by their ID so
2538 // we can sort them.
2540 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2543 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2544 I = StringPool.begin(),
2545 E = StringPool.end();
2547 Entries.push_back(std::make_pair(I->second.second, &*I));
2549 array_pod_sort(Entries.begin(), Entries.end());
2551 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2552 // Emit a label for reference from debug information entries.
2553 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2555 // Emit the string itself with a terminating null byte.
2556 Asm->OutStreamer.EmitBytes(
2557 StringRef(Entries[i].second->getKeyData(),
2558 Entries[i].second->getKeyLength() + 1));
2561 // If we've got an offset section go ahead and emit that now as well.
2562 if (OffsetSection) {
2563 Asm->OutStreamer.SwitchSection(OffsetSection);
2564 unsigned offset = 0;
2565 unsigned size = 4; // FIXME: DWARF64 is 8.
2566 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2567 Asm->OutStreamer.EmitIntValue(offset, size);
2568 offset += Entries[i].second->getKeyLength() + 1;
2573 // Emit addresses into the section given.
2574 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2576 if (AddressPool.empty())
2579 // Start the dwarf addr section.
2580 Asm->OutStreamer.SwitchSection(AddrSection);
2582 // Order the address pool entries by ID
2583 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2585 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2586 E = AddressPool.end();
2588 Entries[I->second] = I->first;
2590 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2591 // Emit an expression for reference from debug information entries.
2592 if (const MCExpr *Expr = Entries[i])
2593 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2595 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2599 // Emit visible names into a debug str section.
2600 void DwarfDebug::emitDebugStr() {
2601 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2602 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2605 // Emit locations into the debug loc section.
2606 void DwarfDebug::emitDebugLoc() {
2607 if (DotDebugLocEntries.empty())
2610 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2611 I = DotDebugLocEntries.begin(),
2612 E = DotDebugLocEntries.end();
2614 DotDebugLocEntry &Entry = *I;
2615 if (I + 1 != DotDebugLocEntries.end())
2619 // Start the dwarf loc section.
2620 Asm->OutStreamer.SwitchSection(
2621 Asm->getObjFileLowering().getDwarfLocSection());
2622 unsigned char Size = Asm->getDataLayout().getPointerSize();
2623 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2625 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2626 I = DotDebugLocEntries.begin(),
2627 E = DotDebugLocEntries.end();
2628 I != E; ++I, ++index) {
2629 DotDebugLocEntry &Entry = *I;
2630 if (Entry.isMerged())
2632 if (Entry.isEmpty()) {
2633 Asm->OutStreamer.EmitIntValue(0, Size);
2634 Asm->OutStreamer.EmitIntValue(0, Size);
2635 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2637 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2638 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2639 DIVariable DV(Entry.getVariable());
2640 Asm->OutStreamer.AddComment("Loc expr size");
2641 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2642 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2643 Asm->EmitLabelDifference(end, begin, 2);
2644 Asm->OutStreamer.EmitLabel(begin);
2645 if (Entry.isInt()) {
2646 DIBasicType BTy(DV.getType());
2647 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2648 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2649 Asm->OutStreamer.AddComment("DW_OP_consts");
2650 Asm->EmitInt8(dwarf::DW_OP_consts);
2651 Asm->EmitSLEB128(Entry.getInt());
2653 Asm->OutStreamer.AddComment("DW_OP_constu");
2654 Asm->EmitInt8(dwarf::DW_OP_constu);
2655 Asm->EmitULEB128(Entry.getInt());
2657 } else if (Entry.isLocation()) {
2658 MachineLocation Loc = Entry.getLoc();
2659 if (!DV.hasComplexAddress())
2661 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2663 // Complex address entry.
2664 unsigned N = DV.getNumAddrElements();
2666 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2667 if (Loc.getOffset()) {
2669 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2670 Asm->OutStreamer.AddComment("DW_OP_deref");
2671 Asm->EmitInt8(dwarf::DW_OP_deref);
2672 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2673 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2674 Asm->EmitSLEB128(DV.getAddrElement(1));
2676 // If first address element is OpPlus then emit
2677 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2678 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2679 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2683 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2686 // Emit remaining complex address elements.
2687 for (; i < N; ++i) {
2688 uint64_t Element = DV.getAddrElement(i);
2689 if (Element == DIBuilder::OpPlus) {
2690 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2691 Asm->EmitULEB128(DV.getAddrElement(++i));
2692 } else if (Element == DIBuilder::OpDeref) {
2694 Asm->EmitInt8(dwarf::DW_OP_deref);
2696 llvm_unreachable("unknown Opcode found in complex address");
2700 // else ... ignore constant fp. There is not any good way to
2701 // to represent them here in dwarf.
2702 Asm->OutStreamer.EmitLabel(end);
2707 struct SymbolCUSorter {
2708 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2709 const MCStreamer &Streamer;
2711 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2712 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2713 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2715 // Symbols with no order assigned should be placed at the end.
2716 // (e.g. section end labels)
2718 IA = (unsigned)(-1);
2720 IB = (unsigned)(-1);
2725 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2726 return (A->getUniqueID() < B->getUniqueID());
2730 const MCSymbol *Start, *End;
2733 // Emit a debug aranges section, containing a CU lookup for any
2734 // address we can tie back to a CU.
2735 void DwarfDebug::emitDebugARanges() {
2736 // Start the dwarf aranges section.
2737 Asm->OutStreamer.SwitchSection(
2738 Asm->getObjFileLowering().getDwarfARangesSection());
2740 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2744 // Build a list of sections used.
2745 std::vector<const MCSection *> Sections;
2746 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2748 const MCSection *Section = it->first;
2749 Sections.push_back(Section);
2752 // Sort the sections into order.
2753 // This is only done to ensure consistent output order across different runs.
2754 std::sort(Sections.begin(), Sections.end(), SectionSort);
2756 // Build a set of address spans, sorted by CU.
2757 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2758 const MCSection *Section = Sections[SecIdx];
2759 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2760 if (List.size() < 2)
2763 // Sort the symbols by offset within the section.
2764 SymbolCUSorter sorter(Asm->OutStreamer);
2765 std::sort(List.begin(), List.end(), sorter);
2767 // If we have no section (e.g. common), just write out
2768 // individual spans for each symbol.
2769 if (Section == NULL) {
2770 for (size_t n = 0; n < List.size(); n++) {
2771 const SymbolCU &Cur = List[n];
2774 Span.Start = Cur.Sym;
2777 Spans[Cur.CU].push_back(Span);
2780 // Build spans between each label.
2781 const MCSymbol *StartSym = List[0].Sym;
2782 for (size_t n = 1; n < List.size(); n++) {
2783 const SymbolCU &Prev = List[n - 1];
2784 const SymbolCU &Cur = List[n];
2786 // Try and build the longest span we can within the same CU.
2787 if (Cur.CU != Prev.CU) {
2789 Span.Start = StartSym;
2791 Spans[Prev.CU].push_back(Span);
2798 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2800 // Build a list of CUs used.
2801 std::vector<DwarfCompileUnit *> CUs;
2802 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2803 DwarfCompileUnit *CU = it->first;
2807 // Sort the CU list (again, to ensure consistent output order).
2808 std::sort(CUs.begin(), CUs.end(), CUSort);
2810 // Emit an arange table for each CU we used.
2811 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2812 DwarfCompileUnit *CU = CUs[CUIdx];
2813 std::vector<ArangeSpan> &List = Spans[CU];
2815 // Emit size of content not including length itself.
2816 unsigned ContentSize =
2817 sizeof(int16_t) + // DWARF ARange version number
2818 sizeof(int32_t) + // Offset of CU in the .debug_info section
2819 sizeof(int8_t) + // Pointer Size (in bytes)
2820 sizeof(int8_t); // Segment Size (in bytes)
2822 unsigned TupleSize = PtrSize * 2;
2824 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2826 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2828 ContentSize += Padding;
2829 ContentSize += (List.size() + 1) * TupleSize;
2831 // For each compile unit, write the list of spans it covers.
2832 Asm->OutStreamer.AddComment("Length of ARange Set");
2833 Asm->EmitInt32(ContentSize);
2834 Asm->OutStreamer.AddComment("DWARF Arange version number");
2835 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2836 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2837 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2838 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2839 Asm->EmitInt8(PtrSize);
2840 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2843 Asm->OutStreamer.EmitFill(Padding, 0xff);
2845 for (unsigned n = 0; n < List.size(); n++) {
2846 const ArangeSpan &Span = List[n];
2847 Asm->EmitLabelReference(Span.Start, PtrSize);
2849 // Calculate the size as being from the span start to it's end.
2851 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2853 // For symbols without an end marker (e.g. common), we
2854 // write a single arange entry containing just that one symbol.
2855 uint64_t Size = SymSize[Span.Start];
2859 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2863 Asm->OutStreamer.AddComment("ARange terminator");
2864 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2865 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2869 // Emit visible names into a debug ranges section.
2870 void DwarfDebug::emitDebugRanges() {
2871 // Start the dwarf ranges section.
2872 Asm->OutStreamer.SwitchSection(
2873 Asm->getObjFileLowering().getDwarfRangesSection());
2875 // Size for our labels.
2876 unsigned char Size = Asm->getDataLayout().getPointerSize();
2878 // Grab the specific ranges for the compile units in the module.
2879 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2882 DwarfCompileUnit *TheCU = I->second;
2884 // Emit a symbol so we can find the beginning of our ranges.
2885 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2887 // Iterate over the misc ranges for the compile units in the module.
2888 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2889 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2890 E = RangeLists.end();
2892 const RangeSpanList &List = *I;
2894 // Emit our symbol so we can find the beginning of the range.
2895 Asm->OutStreamer.EmitLabel(List.getSym());
2897 for (SmallVectorImpl<RangeSpan>::const_iterator
2898 RI = List.getRanges().begin(),
2899 RE = List.getRanges().end();
2901 const RangeSpan &Range = *RI;
2902 const MCSymbol *Begin = Range.getStart();
2903 const MCSymbol *End = Range.getEnd();
2904 assert(Begin && "Range without a begin symbol?");
2905 assert(End && "Range without an end symbol?");
2906 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2907 Asm->OutStreamer.EmitSymbolValue(End, Size);
2910 // And terminate the list with two 0 values.
2911 Asm->OutStreamer.EmitIntValue(0, Size);
2912 Asm->OutStreamer.EmitIntValue(0, Size);
2915 // Now emit a range for the CU itself.
2916 if (useCURanges()) {
2917 Asm->OutStreamer.EmitLabel(
2918 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2919 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2920 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2921 RangeSpan Range = Ranges[i];
2922 const MCSymbol *Begin = Range.getStart();
2923 const MCSymbol *End = Range.getEnd();
2924 assert(Begin && "Range without a begin symbol?");
2925 assert(End && "Range without an end symbol?");
2926 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2927 Asm->OutStreamer.EmitSymbolValue(End, Size);
2929 // And terminate the list with two 0 values.
2930 Asm->OutStreamer.EmitIntValue(0, Size);
2931 Asm->OutStreamer.EmitIntValue(0, Size);
2936 // DWARF5 Experimental Separate Dwarf emitters.
2938 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2940 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2941 U->getCUNode().getSplitDebugFilename());
2943 // Relocate to the beginning of the addr_base section, else 0 for the
2944 // beginning of the one for this compile unit.
2945 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2946 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2948 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2950 if (!CompilationDir.empty())
2951 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2953 addGnuPubAttributes(NewU, Die);
2955 SkeletonHolder.addUnit(NewU);
2958 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2959 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2960 // DW_AT_ranges_base, DW_AT_addr_base.
2961 // TODO: Implement DW_AT_ranges_base.
2962 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2964 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2965 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2966 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2967 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2968 DwarfInfoSectionSym);
2970 // DW_AT_stmt_list is a offset of line number information for this
2971 // compile unit in debug_line section.
2972 // FIXME: Should handle multiple compile units.
2973 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2974 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
2976 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2978 initSkeletonUnit(CU, Die, NewCU);
2983 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2985 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(const DwarfTypeUnit *TU) {
2987 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2988 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
2989 TU->getUniqueID(), Die, TU->getCUNode(), Asm, this, &SkeletonHolder);
2990 NewTU->setTypeSignature(TU->getTypeSignature());
2991 NewTU->setType(NULL);
2993 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2995 initSkeletonUnit(TU, Die, NewTU);
2999 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3000 // compile units that would normally be in debug_info.
3001 void DwarfDebug::emitDebugInfoDWO() {
3002 assert(useSplitDwarf() && "No split dwarf debug info?");
3003 InfoHolder.emitUnits(this,
3004 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3005 DwarfAbbrevDWOSectionSym);
3008 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3009 // abbreviations for the .debug_info.dwo section.
3010 void DwarfDebug::emitDebugAbbrevDWO() {
3011 assert(useSplitDwarf() && "No split dwarf?");
3012 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3015 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3016 // string section and is identical in format to traditional .debug_str
3018 void DwarfDebug::emitDebugStrDWO() {
3019 assert(useSplitDwarf() && "No split dwarf?");
3020 const MCSection *OffSec =
3021 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3022 const MCSymbol *StrSym = DwarfStrSectionSym;
3023 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3027 void DwarfDebug::addDwarfTypeUnitType(DICompileUnit CUNode,
3028 StringRef Identifier, DIE *RefDie,
3029 DICompositeType CTy) {
3031 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3033 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
3037 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3038 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
3039 InfoHolder.getUnits().size(), UnitDie, CUNode, Asm, this, &InfoHolder);
3041 InfoHolder.addUnit(NewTU);
3043 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3044 CUNode.getLanguage());
3047 Hash.update(Identifier);
3048 // ... take the least significant 8 bytes and return those. Our MD5
3049 // implementation always returns its results in little endian, swap bytes
3051 MD5::MD5Result Result;
3053 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
3054 NewTU->setTypeSignature(Signature);
3055 if (useSplitDwarf())
3056 NewTU->setSkeleton(constructSkeletonTU(NewTU));
3058 NewTU->setType(NewTU->createTypeDIE(CTy));
3062 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3063 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3065 CUMap.begin()->second->addDIETypeSignature(RefDie, *NewTU);