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"),
71 enum DefaultOnOff { Default, Enable, Disable };
74 static cl::opt<DefaultOnOff>
75 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
76 cl::desc("Output prototype dwarf accelerator tables."),
77 cl::values(clEnumVal(Default, "Default for platform"),
78 clEnumVal(Enable, "Enabled"),
79 clEnumVal(Disable, "Disabled"), clEnumValEnd),
82 static cl::opt<DefaultOnOff>
83 SplitDwarf("split-dwarf", cl::Hidden,
84 cl::desc("Output DWARF5 split debug info."),
85 cl::values(clEnumVal(Default, "Default for platform"),
86 clEnumVal(Enable, "Enabled"),
87 clEnumVal(Disable, "Disabled"), clEnumValEnd),
90 static cl::opt<DefaultOnOff>
91 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
92 cl::desc("Generate DWARF pubnames and pubtypes sections"),
93 cl::values(clEnumVal(Default, "Default for platform"),
94 clEnumVal(Enable, "Enabled"),
95 clEnumVal(Disable, "Disabled"), clEnumValEnd),
98 static cl::opt<unsigned>
99 DwarfVersionNumber("dwarf-version", cl::Hidden,
100 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
103 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
104 cl::desc("Generate DW_AT_ranges for compile units"),
107 static const char *const DWARFGroupName = "DWARF Emission";
108 static const char *const DbgTimerName = "DWARF Debug Writer";
110 //===----------------------------------------------------------------------===//
114 /// resolve - Look in the DwarfDebug map for the MDNode that
115 /// corresponds to the reference.
116 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
117 return DD->resolve(Ref);
120 DIType DbgVariable::getType() const {
121 DIType Ty = Var.getType();
122 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
123 // addresses instead.
124 if (Var.isBlockByrefVariable()) {
125 /* Byref variables, in Blocks, are declared by the programmer as
126 "SomeType VarName;", but the compiler creates a
127 __Block_byref_x_VarName struct, and gives the variable VarName
128 either the struct, or a pointer to the struct, as its type. This
129 is necessary for various behind-the-scenes things the compiler
130 needs to do with by-reference variables in blocks.
132 However, as far as the original *programmer* is concerned, the
133 variable should still have type 'SomeType', as originally declared.
135 The following function dives into the __Block_byref_x_VarName
136 struct to find the original type of the variable. This will be
137 passed back to the code generating the type for the Debug
138 Information Entry for the variable 'VarName'. 'VarName' will then
139 have the original type 'SomeType' in its debug information.
141 The original type 'SomeType' will be the type of the field named
142 'VarName' inside the __Block_byref_x_VarName struct.
144 NOTE: In order for this to not completely fail on the debugger
145 side, the Debug Information Entry for the variable VarName needs to
146 have a DW_AT_location that tells the debugger how to unwind through
147 the pointers and __Block_byref_x_VarName struct to find the actual
148 value of the variable. The function addBlockByrefType does this. */
150 uint16_t tag = Ty.getTag();
152 if (tag == dwarf::DW_TAG_pointer_type)
153 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
155 DIArray Elements = DICompositeType(subType).getTypeArray();
156 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
157 DIDerivedType DT(Elements.getElement(i));
158 if (getName() == DT.getName())
159 return (resolve(DT.getTypeDerivedFrom()));
165 } // end llvm namespace
167 /// Return Dwarf Version by checking module flags.
168 static unsigned getDwarfVersionFromModule(const Module *M) {
169 Value *Val = M->getModuleFlag("Dwarf Version");
171 return dwarf::DWARF_VERSION;
172 return cast<ConstantInt>(Val)->getZExtValue();
175 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
176 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
177 PrevLabel(NULL), GlobalRangeCount(0),
178 InfoHolder(A, "info_string", DIEValueAllocator), HasCURanges(false),
179 UsedNonDefaultText(false),
180 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
182 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
183 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
184 DwarfAddrSectionSym = 0;
185 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
186 FunctionBeginSym = FunctionEndSym = 0;
190 // Turn on accelerator tables for Darwin by default, pubnames by
191 // default for non-Darwin, and handle split dwarf.
192 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
194 if (DwarfAccelTables == Default)
195 HasDwarfAccelTables = IsDarwin;
197 HasDwarfAccelTables = DwarfAccelTables == Enable;
199 if (SplitDwarf == Default)
200 HasSplitDwarf = false;
202 HasSplitDwarf = SplitDwarf == Enable;
204 if (DwarfPubSections == Default)
205 HasDwarfPubSections = !IsDarwin;
207 HasDwarfPubSections = DwarfPubSections == Enable;
209 DwarfVersion = DwarfVersionNumber
211 : getDwarfVersionFromModule(MMI->getModule());
214 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
219 // Switch to the specified MCSection and emit an assembler
220 // temporary label to it if SymbolStem is specified.
221 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
222 const char *SymbolStem = 0) {
223 Asm->OutStreamer.SwitchSection(Section);
227 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
228 Asm->OutStreamer.EmitLabel(TmpSym);
232 DwarfFile::~DwarfFile() {
233 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
238 MCSymbol *DwarfFile::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
242 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol *, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
248 Entry.second = NextStringPoolNumber++;
249 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
252 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
253 std::pair<MCSymbol *, unsigned> &Entry =
254 StringPool.GetOrCreateValue(Str).getValue();
258 Entry.second = NextStringPoolNumber++;
259 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
263 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
264 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
267 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
268 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
269 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
271 ++NextAddrPoolNumber;
272 return P.first->second;
275 // Define a unique number for the abbreviation.
277 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
278 // Check the set for priors.
279 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
281 // If it's newly added.
282 if (InSet == &Abbrev) {
283 // Add to abbreviation list.
284 Abbreviations.push_back(&Abbrev);
286 // Assign the vector position + 1 as its number.
287 Abbrev.setNumber(Abbreviations.size());
289 // Assign existing abbreviation number.
290 Abbrev.setNumber(InSet->getNumber());
294 static bool isObjCClass(StringRef Name) {
295 return Name.startswith("+") || Name.startswith("-");
298 static bool hasObjCCategory(StringRef Name) {
299 if (!isObjCClass(Name))
302 return Name.find(") ") != StringRef::npos;
305 static void getObjCClassCategory(StringRef In, StringRef &Class,
306 StringRef &Category) {
307 if (!hasObjCCategory(In)) {
308 Class = In.slice(In.find('[') + 1, In.find(' '));
313 Class = In.slice(In.find('[') + 1, In.find('('));
314 Category = In.slice(In.find('[') + 1, In.find(' '));
318 static StringRef getObjCMethodName(StringRef In) {
319 return In.slice(In.find(' ') + 1, In.find(']'));
322 // Helper for sorting sections into a stable output order.
323 static bool SectionSort(const MCSection *A, const MCSection *B) {
324 std::string LA = (A ? A->getLabelBeginName() : "");
325 std::string LB = (B ? B->getLabelBeginName() : "");
329 // Add the various names to the Dwarf accelerator table names.
330 // TODO: Determine whether or not we should add names for programs
331 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
332 // is only slightly different than the lookup of non-standard ObjC names.
333 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
334 if (!SP.isDefinition())
336 TheU->addAccelName(SP.getName(), Die);
338 // If the linkage name is different than the name, go ahead and output
339 // that as well into the name table.
340 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
341 TheU->addAccelName(SP.getLinkageName(), Die);
343 // If this is an Objective-C selector name add it to the ObjC accelerator
345 if (isObjCClass(SP.getName())) {
346 StringRef Class, Category;
347 getObjCClassCategory(SP.getName(), Class, Category);
348 TheU->addAccelObjC(Class, Die);
350 TheU->addAccelObjC(Category, Die);
351 // Also add the base method name to the name table.
352 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
356 /// isSubprogramContext - Return true if Context is either a subprogram
357 /// or another context nested inside a subprogram.
358 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
361 DIDescriptor D(Context);
362 if (D.isSubprogram())
365 return isSubprogramContext(resolve(DIType(Context).getContext()));
369 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
370 // and DW_AT_high_pc attributes. If there are global variables in this
371 // scope then create and insert DIEs for these variables.
372 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
374 DIE *SPDie = SPCU->getDIE(SP);
376 assert(SPDie && "Unable to find subprogram DIE!");
378 // If we're updating an abstract DIE, then we will be adding the children and
379 // object pointer later on. But what we don't want to do is process the
380 // concrete DIE twice.
381 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
382 // Pick up abstract subprogram DIE.
384 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
385 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
387 DISubprogram SPDecl = SP.getFunctionDeclaration();
388 if (!SPDecl.isSubprogram()) {
389 // There is not any need to generate specification DIE for a function
390 // defined at compile unit level. If a function is defined inside another
391 // function then gdb prefers the definition at top level and but does not
392 // expect specification DIE in parent function. So avoid creating
393 // specification DIE for a function defined inside a function.
394 DIScope SPContext = resolve(SP.getContext());
395 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
396 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
397 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
400 DICompositeType SPTy = SP.getType();
401 DIArray Args = SPTy.getTypeArray();
402 uint16_t SPTag = SPTy.getTag();
403 if (SPTag == dwarf::DW_TAG_subroutine_type)
404 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
406 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
407 DIType ATy(Args.getElement(i));
408 SPCU->addType(Arg, ATy);
409 if (ATy.isArtificial())
410 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
411 if (ATy.isObjectPointer())
412 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
414 DIE *SPDeclDie = SPDie;
415 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
416 *SPCU->getUnitDie());
417 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
422 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
423 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
425 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
426 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
427 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
429 // Add name to the name table, we do this here because we're guaranteed
430 // to have concrete versions of our DW_TAG_subprogram nodes.
431 addSubprogramNames(SPCU, SP, SPDie);
436 /// Check whether we should create a DIE for the given Scope, return true
437 /// if we don't create a DIE (the corresponding DIE is null).
438 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
439 if (Scope->isAbstractScope())
442 // We don't create a DIE if there is no Range.
443 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
447 if (Ranges.size() > 1)
450 // We don't create a DIE if we have a single Range and the end label
452 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
453 MCSymbol *End = getLabelAfterInsn(RI->second);
457 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
458 dwarf::Attribute A, const MCSymbol *L,
459 const MCSymbol *Sec) {
460 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
461 U->addSectionLabel(D, A, L);
463 U->addSectionDelta(D, A, L, Sec);
466 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
467 const SmallVectorImpl<InsnRange> &Range) {
468 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
469 // emitting it appropriately.
470 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
471 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
472 DwarfDebugRangeSectionSym);
474 RangeSpanList List(RangeSym);
475 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
478 RangeSpan Span(getLabelBeforeInsn(RI->first),
479 getLabelAfterInsn(RI->second));
480 List.addRange(llvm_move(Span));
483 // Add the range list to the set of ranges to be emitted.
484 TheCU->addRangeList(llvm_move(List));
487 // Construct new DW_TAG_lexical_block for this scope and attach
488 // DW_AT_low_pc/DW_AT_high_pc labels.
489 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
490 LexicalScope *Scope) {
491 if (isLexicalScopeDIENull(Scope))
494 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
495 if (Scope->isAbstractScope())
498 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
500 // If we have multiple ranges, emit them into the range section.
501 if (ScopeRanges.size() > 1) {
502 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
506 // Construct the address range for this DIE.
507 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
508 MCSymbol *Start = getLabelBeforeInsn(RI->first);
509 MCSymbol *End = getLabelAfterInsn(RI->second);
510 assert(End && "End label should not be null!");
512 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
513 assert(End->isDefined() && "Invalid end label for an inlined scope!");
515 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
516 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
521 // This scope represents inlined body of a function. Construct DIE to
522 // represent this concrete inlined copy of the function.
523 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
524 LexicalScope *Scope) {
525 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
526 assert(!ScopeRanges.empty() &&
527 "LexicalScope does not have instruction markers!");
529 if (!Scope->getScopeNode())
531 DIScope DS(Scope->getScopeNode());
532 DISubprogram InlinedSP = getDISubprogram(DS);
533 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
535 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
539 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
540 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
542 // If we have multiple ranges, emit them into the range section.
543 if (ScopeRanges.size() > 1)
544 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
546 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
547 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
548 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
550 if (StartLabel == 0 || EndLabel == 0)
551 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
553 assert(StartLabel->isDefined() &&
554 "Invalid starting label for an inlined scope!");
555 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
557 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
558 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
561 InlinedSubprogramDIEs.insert(OriginDIE);
563 // Add the call site information to the DIE.
564 DILocation DL(Scope->getInlinedAt());
565 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
566 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
567 TheCU->getUniqueID()));
568 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
570 // Add name to the name table, we do this here because we're guaranteed
571 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
572 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
577 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
579 SmallVectorImpl<DIE *> &Children) {
580 DIE *ObjectPointer = NULL;
582 // Collect arguments for current function.
583 if (LScopes.isCurrentFunctionScope(Scope))
584 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
585 if (DbgVariable *ArgDV = CurrentFnArguments[i])
587 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
588 Children.push_back(Arg);
589 if (ArgDV->isObjectPointer())
593 // Collect lexical scope children first.
594 const SmallVectorImpl<DbgVariable *> &Variables =
595 ScopeVariables.lookup(Scope);
596 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
597 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
598 Scope->isAbstractScope())) {
599 Children.push_back(Variable);
600 if (Variables[i]->isObjectPointer())
601 ObjectPointer = Variable;
603 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
604 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
605 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
606 Children.push_back(Nested);
607 return ObjectPointer;
610 // Construct a DIE for this scope.
611 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
612 LexicalScope *Scope) {
613 if (!Scope || !Scope->getScopeNode())
616 DIScope DS(Scope->getScopeNode());
618 SmallVector<DIE *, 8> Children;
619 DIE *ObjectPointer = NULL;
620 bool ChildrenCreated = false;
622 // We try to create the scope DIE first, then the children DIEs. This will
623 // avoid creating un-used children then removing them later when we find out
624 // the scope DIE is null.
625 DIE *ScopeDIE = NULL;
626 if (Scope->getInlinedAt())
627 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
628 else if (DS.isSubprogram()) {
629 ProcessedSPNodes.insert(DS);
630 if (Scope->isAbstractScope()) {
631 ScopeDIE = TheCU->getDIE(DS);
632 // Note down abstract DIE.
634 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
636 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
638 // Early exit when we know the scope DIE is going to be null.
639 if (isLexicalScopeDIENull(Scope))
642 // We create children here when we know the scope DIE is not going to be
643 // null and the children will be added to the scope DIE.
644 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
645 ChildrenCreated = true;
647 // There is no need to emit empty lexical block DIE.
648 std::pair<ImportedEntityMap::const_iterator,
649 ImportedEntityMap::const_iterator> Range =
651 ScopesWithImportedEntities.begin(),
652 ScopesWithImportedEntities.end(),
653 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
655 if (Children.empty() && Range.first == Range.second)
657 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
658 assert(ScopeDIE && "Scope DIE should not be null.");
659 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
661 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
665 assert(Children.empty() &&
666 "We create children only when the scope DIE is not null.");
669 if (!ChildrenCreated)
670 // We create children when the scope DIE is not null.
671 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
674 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
677 ScopeDIE->addChild(*I);
679 if (DS.isSubprogram() && ObjectPointer != NULL)
680 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
685 // Look up the source id with the given directory and source file names.
686 // If none currently exists, create a new id and insert it in the
687 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
689 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
691 // If we print assembly, we can't separate .file entries according to
692 // compile units. Thus all files will belong to the default compile unit.
694 // FIXME: add a better feature test than hasRawTextSupport. Even better,
695 // extend .file to support this.
696 if (Asm->OutStreamer.hasRawTextSupport())
699 // If FE did not provide a file name, then assume stdin.
700 if (FileName.empty())
701 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
703 // TODO: this might not belong here. See if we can factor this better.
704 if (DirName == CompilationDir)
707 // FileIDCUMap stores the current ID for the given compile unit.
708 unsigned SrcId = FileIDCUMap[CUID] + 1;
710 // We look up the CUID/file/dir by concatenating them with a zero byte.
711 SmallString<128> NamePair;
712 NamePair += utostr(CUID);
715 NamePair += '\0'; // Zero bytes are not allowed in paths.
716 NamePair += FileName;
718 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
719 if (Ent.getValue() != SrcId)
720 return Ent.getValue();
722 FileIDCUMap[CUID] = SrcId;
723 // Print out a .file directive to specify files for .loc directives.
724 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
729 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
730 if (!GenerateGnuPubSections)
733 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
734 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
735 DwarfGnuPubNamesSectionSym);
737 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
738 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
739 DwarfGnuPubTypesSectionSym);
742 // Create new DwarfCompileUnit for the given metadata node with tag
743 // DW_TAG_compile_unit.
744 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
745 StringRef FN = DIUnit.getFilename();
746 CompilationDir = DIUnit.getDirectory();
748 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
749 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
750 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
751 InfoHolder.addUnit(NewCU);
753 FileIDCUMap[NewCU->getUniqueID()] = 0;
755 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
756 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
757 DIUnit.getLanguage());
758 NewCU->addString(Die, dwarf::DW_AT_name, FN);
760 // Define start line table label for each Compile Unit.
761 MCSymbol *LineTableStartSym =
762 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
763 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
764 NewCU->getUniqueID());
766 // Use a single line table if we are generating assembly.
768 Asm->OutStreamer.hasRawTextSupport() || (NewCU->getUniqueID() == 0);
770 if (!useSplitDwarf()) {
771 // DW_AT_stmt_list is a offset of line number information for this
772 // compile unit in debug_line section. For split dwarf this is
773 // left in the skeleton CU and so not included.
774 // The line table entries are not always emitted in assembly, so it
775 // is not okay to use line_table_start here.
776 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
777 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
778 UseTheFirstCU ? DwarfLineSectionSym
779 : LineTableStartSym);
780 else if (UseTheFirstCU)
781 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
783 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
784 DwarfLineSectionSym);
786 // If we're using split dwarf the compilation dir is going to be in the
787 // skeleton CU and so we don't need to duplicate it here.
788 if (!CompilationDir.empty())
789 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
791 addGnuPubAttributes(NewCU, Die);
794 if (DIUnit.isOptimized())
795 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
797 StringRef Flags = DIUnit.getFlags();
799 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
801 if (unsigned RVer = DIUnit.getRunTimeVersion())
802 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
803 dwarf::DW_FORM_data1, RVer);
808 if (useSplitDwarf()) {
809 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
810 DwarfInfoDWOSectionSym);
811 NewCU->setSkeleton(constructSkeletonCU(NewCU));
813 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
814 DwarfInfoSectionSym);
816 CUMap.insert(std::make_pair(DIUnit, NewCU));
817 CUDieMap.insert(std::make_pair(Die, NewCU));
821 // Construct subprogram DIE.
822 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
824 // FIXME: We should only call this routine once, however, during LTO if a
825 // program is defined in multiple CUs we could end up calling it out of
826 // beginModule as we walk the CUs.
828 DwarfCompileUnit *&CURef = SPMap[N];
834 if (!SP.isDefinition())
835 // This is a method declaration which will be handled while constructing
839 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
841 // Expose as a global name.
842 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
845 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
847 DIImportedEntity Module(N);
848 assert(Module.Verify());
849 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
850 constructImportedEntityDIE(TheCU, Module, D);
853 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
854 const MDNode *N, DIE *Context) {
855 DIImportedEntity Module(N);
856 assert(Module.Verify());
857 return constructImportedEntityDIE(TheCU, Module, Context);
860 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
861 const DIImportedEntity &Module,
863 assert(Module.Verify() &&
864 "Use one of the MDNode * overloads to handle invalid metadata");
865 assert(Context && "Should always have a context for an imported_module");
866 DIE *IMDie = new DIE(Module.getTag());
867 TheCU->insertDIE(Module, IMDie);
869 DIDescriptor Entity = Module.getEntity();
870 if (Entity.isNameSpace())
871 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
872 else if (Entity.isSubprogram())
873 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
874 else if (Entity.isType())
875 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
877 EntityDie = TheCU->getDIE(Entity);
878 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
879 Module.getContext().getDirectory(),
880 TheCU->getUniqueID());
881 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
882 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
883 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
884 StringRef Name = Module.getName();
886 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
887 Context->addChild(IMDie);
890 // Emit all Dwarf sections that should come prior to the content. Create
891 // global DIEs and emit initial debug info sections. This is invoked by
892 // the target AsmPrinter.
893 void DwarfDebug::beginModule() {
894 if (DisableDebugInfoPrinting)
897 const Module *M = MMI->getModule();
899 // If module has named metadata anchors then use them, otherwise scan the
900 // module using debug info finder to collect debug info.
901 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
904 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
906 // Emit initial sections so we can reference labels later.
909 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
910 DICompileUnit CUNode(CU_Nodes->getOperand(i));
911 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
912 DIArray ImportedEntities = CUNode.getImportedEntities();
913 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
914 ScopesWithImportedEntities.push_back(std::make_pair(
915 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
916 ImportedEntities.getElement(i)));
917 std::sort(ScopesWithImportedEntities.begin(),
918 ScopesWithImportedEntities.end(), less_first());
919 DIArray GVs = CUNode.getGlobalVariables();
920 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
921 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
922 DIArray SPs = CUNode.getSubprograms();
923 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
924 constructSubprogramDIE(CU, SPs.getElement(i));
925 DIArray EnumTypes = CUNode.getEnumTypes();
926 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
927 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
928 DIArray RetainedTypes = CUNode.getRetainedTypes();
929 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
930 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
931 // Emit imported_modules last so that the relevant context is already
933 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
934 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
937 // Tell MMI that we have debug info.
938 MMI->setDebugInfoAvailability(true);
940 // Prime section data.
941 SectionMap[Asm->getObjFileLowering().getTextSection()];
944 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
945 void DwarfDebug::computeInlinedDIEs() {
946 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
947 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
948 AE = InlinedSubprogramDIEs.end();
951 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
953 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
954 AE = AbstractSPDies.end();
956 DIE *ISP = AI->second;
957 if (InlinedSubprogramDIEs.count(ISP))
959 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
963 // Collect info for variables that were optimized out.
964 void DwarfDebug::collectDeadVariables() {
965 const Module *M = MMI->getModule();
967 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
968 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
969 DICompileUnit TheCU(CU_Nodes->getOperand(i));
970 DIArray Subprograms = TheCU.getSubprograms();
971 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
972 DISubprogram SP(Subprograms.getElement(i));
973 if (ProcessedSPNodes.count(SP) != 0)
975 if (!SP.isSubprogram())
977 if (!SP.isDefinition())
979 DIArray Variables = SP.getVariables();
980 if (Variables.getNumElements() == 0)
983 // Construct subprogram DIE and add variables DIEs.
984 DwarfCompileUnit *SPCU =
985 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
986 assert(SPCU && "Unable to find Compile Unit!");
987 // FIXME: See the comment in constructSubprogramDIE about duplicate
989 constructSubprogramDIE(SPCU, SP);
990 DIE *SPDIE = SPCU->getDIE(SP);
991 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
992 DIVariable DV(Variables.getElement(vi));
993 if (!DV.isVariable())
995 DbgVariable NewVar(DV, NULL, this);
996 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
997 SPDIE->addChild(VariableDIE);
1004 void DwarfDebug::finalizeModuleInfo() {
1005 // Collect info for variables that were optimized out.
1006 collectDeadVariables();
1008 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1009 computeInlinedDIEs();
1011 // Handle anything that needs to be done on a per-unit basis after
1012 // all other generation.
1013 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1014 E = getUnits().end();
1016 DwarfUnit *TheU = *I;
1017 // Emit DW_AT_containing_type attribute to connect types with their
1018 // vtable holding type.
1019 TheU->constructContainingTypeDIEs();
1021 // Add CU specific attributes if we need to add any.
1022 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1023 // If we're splitting the dwarf out now that we've got the entire
1024 // CU then add the dwo id to it.
1025 DwarfCompileUnit *SkCU =
1026 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1027 if (useSplitDwarf()) {
1028 // This should be a unique identifier when we want to build .dwp files.
1030 if (GenerateCUHash) {
1032 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1034 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1035 dwarf::DW_FORM_data8, ID);
1036 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1037 dwarf::DW_FORM_data8, ID);
1040 // If we have code split among multiple sections or we've requested
1041 // it then emit a DW_AT_ranges attribute on the unit that will remain
1042 // in the .o file, otherwise add a DW_AT_low_pc.
1043 // FIXME: Also add a high pc if we can.
1044 // FIXME: We should use ranges if we have multiple compile units or
1045 // allow reordering of code ala .subsections_via_symbols in mach-o.
1046 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1047 if (useCURanges() && TheU->getRanges().size()) {
1048 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1049 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1050 DwarfDebugRangeSectionSym);
1052 // A DW_AT_low_pc attribute may also be specified in combination with
1053 // DW_AT_ranges to specify the default base address for use in location
1054 // lists (see Section 2.6.2) and range lists (see Section 2.17.3).
1055 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1058 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1063 // Compute DIE offsets and sizes.
1064 InfoHolder.computeSizeAndOffsets();
1065 if (useSplitDwarf())
1066 SkeletonHolder.computeSizeAndOffsets();
1069 void DwarfDebug::endSections() {
1070 // Filter labels by section.
1071 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1072 const SymbolCU &SCU = ArangeLabels[n];
1073 if (SCU.Sym->isInSection()) {
1074 // Make a note of this symbol and it's section.
1075 const MCSection *Section = &SCU.Sym->getSection();
1076 if (!Section->getKind().isMetadata())
1077 SectionMap[Section].push_back(SCU);
1079 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1080 // appear in the output. This sucks as we rely on sections to build
1081 // arange spans. We can do it without, but it's icky.
1082 SectionMap[NULL].push_back(SCU);
1086 // Build a list of sections used.
1087 std::vector<const MCSection *> Sections;
1088 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1090 const MCSection *Section = it->first;
1091 Sections.push_back(Section);
1094 // Sort the sections into order.
1095 // This is only done to ensure consistent output order across different runs.
1096 std::sort(Sections.begin(), Sections.end(), SectionSort);
1098 // Add terminating symbols for each section.
1099 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1100 const MCSection *Section = Sections[ID];
1101 MCSymbol *Sym = NULL;
1104 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1105 // if we know the section name up-front. For user-created sections, the
1106 // resulting label may not be valid to use as a label. (section names can
1107 // use a greater set of characters on some systems)
1108 Sym = Asm->GetTempSymbol("debug_end", ID);
1109 Asm->OutStreamer.SwitchSection(Section);
1110 Asm->OutStreamer.EmitLabel(Sym);
1113 // Insert a final terminator.
1114 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1117 // For now only turn on CU ranges if we've explicitly asked for it,
1118 // we have -ffunction-sections enabled, we've emitted a function
1119 // into a unique section, or we're using LTO. If we're using LTO then
1120 // we can't know that any particular function in the module is correlated
1121 // to a particular CU and so we need to be conservative. At this point all
1122 // sections should be finalized except for dwarf sections.
1123 HasCURanges = DwarfCURanges || UsedNonDefaultText || (CUMap.size() > 1) ||
1124 TargetMachine::getFunctionSections();
1127 // Emit all Dwarf sections that should come after the content.
1128 void DwarfDebug::endModule() {
1135 // End any existing sections.
1136 // TODO: Does this need to happen?
1139 // Finalize the debug info for the module.
1140 finalizeModuleInfo();
1144 // Emit all the DIEs into a debug info section.
1147 // Corresponding abbreviations into a abbrev section.
1148 emitAbbreviations();
1150 // Emit info into a debug loc section.
1153 // Emit info into a debug aranges section.
1156 // Emit info into a debug ranges section.
1159 if (useSplitDwarf()) {
1162 emitDebugAbbrevDWO();
1163 // Emit DWO addresses.
1164 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1167 // Emit info into the dwarf accelerator table sections.
1168 if (useDwarfAccelTables()) {
1171 emitAccelNamespaces();
1175 // Emit the pubnames and pubtypes sections if requested.
1176 if (HasDwarfPubSections) {
1177 emitDebugPubNames(GenerateGnuPubSections);
1178 emitDebugPubTypes(GenerateGnuPubSections);
1184 // Reset these for the next Module if we have one.
1188 // Find abstract variable, if any, associated with Var.
1189 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1190 DebugLoc ScopeLoc) {
1191 LLVMContext &Ctx = DV->getContext();
1192 // More then one inlined variable corresponds to one abstract variable.
1193 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1194 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1196 return AbsDbgVariable;
1198 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1202 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1203 addScopeVariable(Scope, AbsDbgVariable);
1204 AbstractVariables[Var] = AbsDbgVariable;
1205 return AbsDbgVariable;
1208 // If Var is a current function argument then add it to CurrentFnArguments list.
1209 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1210 if (!LScopes.isCurrentFunctionScope(Scope))
1212 DIVariable DV = Var->getVariable();
1213 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1215 unsigned ArgNo = DV.getArgNumber();
1219 size_t Size = CurrentFnArguments.size();
1221 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1222 // llvm::Function argument size is not good indicator of how many
1223 // arguments does the function have at source level.
1225 CurrentFnArguments.resize(ArgNo * 2);
1226 CurrentFnArguments[ArgNo - 1] = Var;
1230 // Collect variable information from side table maintained by MMI.
1231 void DwarfDebug::collectVariableInfoFromMMITable(
1232 SmallPtrSet<const MDNode *, 16> &Processed) {
1233 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1234 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1237 const MDNode *Var = VI->first;
1240 Processed.insert(Var);
1242 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1244 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1246 // If variable scope is not found then skip this variable.
1250 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1251 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1252 RegVar->setFrameIndex(VP.first);
1253 if (!addCurrentFnArgument(RegVar, Scope))
1254 addScopeVariable(Scope, RegVar);
1256 AbsDbgVariable->setFrameIndex(VP.first);
1260 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1262 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1263 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1264 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1265 MI->getOperand(0).getReg() &&
1266 (MI->getOperand(1).isImm() ||
1267 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1270 // Get .debug_loc entry for the instruction range starting at MI.
1271 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1272 const MCSymbol *FLabel,
1273 const MCSymbol *SLabel,
1274 const MachineInstr *MI) {
1275 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1277 assert(MI->getNumOperands() == 3);
1278 if (MI->getOperand(0).isReg()) {
1279 MachineLocation MLoc;
1280 // If the second operand is an immediate, this is a
1281 // register-indirect address.
1282 if (!MI->getOperand(1).isImm())
1283 MLoc.set(MI->getOperand(0).getReg());
1285 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1286 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1288 if (MI->getOperand(0).isImm())
1289 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1290 if (MI->getOperand(0).isFPImm())
1291 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1292 if (MI->getOperand(0).isCImm())
1293 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1295 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1298 // Find variables for each lexical scope.
1300 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1302 // Grab the variable info that was squirreled away in the MMI side-table.
1303 collectVariableInfoFromMMITable(Processed);
1305 for (SmallVectorImpl<const MDNode *>::const_iterator
1306 UVI = UserVariables.begin(),
1307 UVE = UserVariables.end();
1308 UVI != UVE; ++UVI) {
1309 const MDNode *Var = *UVI;
1310 if (Processed.count(Var))
1313 // History contains relevant DBG_VALUE instructions for Var and instructions
1315 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1316 if (History.empty())
1318 const MachineInstr *MInsn = History.front();
1321 LexicalScope *Scope = NULL;
1322 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1323 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1324 Scope = LScopes.getCurrentFunctionScope();
1325 else if (MDNode *IA = DV.getInlinedAt())
1326 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1328 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1329 // If variable scope is not found then skip this variable.
1333 Processed.insert(DV);
1334 assert(MInsn->isDebugValue() && "History must begin with debug value");
1335 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1336 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1337 if (!addCurrentFnArgument(RegVar, Scope))
1338 addScopeVariable(Scope, RegVar);
1340 AbsVar->setMInsn(MInsn);
1342 // Simplify ranges that are fully coalesced.
1343 if (History.size() <= 1 ||
1344 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1345 RegVar->setMInsn(MInsn);
1349 // Handle multiple DBG_VALUE instructions describing one variable.
1350 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1352 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1353 HI = History.begin(),
1356 const MachineInstr *Begin = *HI;
1357 assert(Begin->isDebugValue() && "Invalid History entry");
1359 // Check if DBG_VALUE is truncating a range.
1360 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1361 !Begin->getOperand(0).getReg())
1364 // Compute the range for a register location.
1365 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1366 const MCSymbol *SLabel = 0;
1369 // If Begin is the last instruction in History then its value is valid
1370 // until the end of the function.
1371 SLabel = FunctionEndSym;
1373 const MachineInstr *End = HI[1];
1374 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1375 << "\t" << *Begin << "\t" << *End << "\n");
1376 if (End->isDebugValue())
1377 SLabel = getLabelBeforeInsn(End);
1379 // End is a normal instruction clobbering the range.
1380 SLabel = getLabelAfterInsn(End);
1381 assert(SLabel && "Forgot label after clobber instruction");
1386 // The value is valid until the next DBG_VALUE or clobber.
1387 DotDebugLocEntries.push_back(
1388 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1390 DotDebugLocEntries.push_back(DotDebugLocEntry());
1393 // Collect info for variables that were optimized out.
1394 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1395 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1396 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1397 DIVariable DV(Variables.getElement(i));
1398 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1400 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1401 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1405 // Return Label preceding the instruction.
1406 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1407 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1408 assert(Label && "Didn't insert label before instruction");
1412 // Return Label immediately following the instruction.
1413 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1414 return LabelsAfterInsn.lookup(MI);
1417 // Process beginning of an instruction.
1418 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1421 // Check if source location changes, but ignore DBG_VALUE locations.
1422 if (!MI->isDebugValue()) {
1423 DebugLoc DL = MI->getDebugLoc();
1424 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1427 if (DL == PrologEndLoc) {
1428 Flags |= DWARF2_FLAG_PROLOGUE_END;
1429 PrologEndLoc = DebugLoc();
1431 if (PrologEndLoc.isUnknown())
1432 Flags |= DWARF2_FLAG_IS_STMT;
1434 if (!DL.isUnknown()) {
1435 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1436 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1438 recordSourceLine(0, 0, 0, 0);
1442 // Insert labels where requested.
1443 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1444 LabelsBeforeInsn.find(MI);
1447 if (I == LabelsBeforeInsn.end())
1450 // Label already assigned.
1455 PrevLabel = MMI->getContext().CreateTempSymbol();
1456 Asm->OutStreamer.EmitLabel(PrevLabel);
1458 I->second = PrevLabel;
1461 // Process end of an instruction.
1462 void DwarfDebug::endInstruction() {
1464 // Don't create a new label after DBG_VALUE instructions.
1465 // They don't generate code.
1466 if (!CurMI->isDebugValue())
1469 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1470 LabelsAfterInsn.find(CurMI);
1474 if (I == LabelsAfterInsn.end())
1477 // Label already assigned.
1481 // We need a label after this instruction.
1483 PrevLabel = MMI->getContext().CreateTempSymbol();
1484 Asm->OutStreamer.EmitLabel(PrevLabel);
1486 I->second = PrevLabel;
1489 // Each LexicalScope has first instruction and last instruction to mark
1490 // beginning and end of a scope respectively. Create an inverse map that list
1491 // scopes starts (and ends) with an instruction. One instruction may start (or
1492 // end) multiple scopes. Ignore scopes that are not reachable.
1493 void DwarfDebug::identifyScopeMarkers() {
1494 SmallVector<LexicalScope *, 4> WorkList;
1495 WorkList.push_back(LScopes.getCurrentFunctionScope());
1496 while (!WorkList.empty()) {
1497 LexicalScope *S = WorkList.pop_back_val();
1499 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1500 if (!Children.empty())
1501 for (SmallVectorImpl<LexicalScope *>::const_iterator
1502 SI = Children.begin(),
1503 SE = Children.end();
1505 WorkList.push_back(*SI);
1507 if (S->isAbstractScope())
1510 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1513 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1516 assert(RI->first && "InsnRange does not have first instruction!");
1517 assert(RI->second && "InsnRange does not have second instruction!");
1518 requestLabelBeforeInsn(RI->first);
1519 requestLabelAfterInsn(RI->second);
1524 // Gather pre-function debug information. Assumes being called immediately
1525 // after the function entry point has been emitted.
1526 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1529 // If there's no debug info for the function we're not going to do anything.
1530 if (!MMI->hasDebugInfo())
1533 // Grab the lexical scopes for the function, if we don't have any of those
1534 // then we're not going to be able to do anything.
1535 LScopes.initialize(*MF);
1536 if (LScopes.empty())
1539 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1541 // Make sure that each lexical scope will have a begin/end label.
1542 identifyScopeMarkers();
1544 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1545 // belongs to so that we add to the correct per-cu line table in the
1547 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1548 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1549 assert(TheCU && "Unable to find compile unit!");
1550 if (Asm->OutStreamer.hasRawTextSupport())
1551 // Use a single line table if we are generating assembly.
1552 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1554 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1556 // Check the current section against the standard text section. If different
1557 // keep track so that we will know when we're emitting functions into multiple
1559 if (Asm->getObjFileLowering().getTextSection() != Asm->getCurrentSection())
1560 UsedNonDefaultText = true;
1562 // Emit a label for the function so that we have a beginning address.
1563 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1564 // Assumes in correct section after the entry point.
1565 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1567 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1568 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1569 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1571 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1573 bool AtBlockEntry = true;
1574 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1576 const MachineInstr *MI = II;
1578 if (MI->isDebugValue()) {
1579 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1581 // Keep track of user variables.
1583 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1585 // Variable is in a register, we need to check for clobbers.
1586 if (isDbgValueInDefinedReg(MI))
1587 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1589 // Check the history of this variable.
1590 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1591 if (History.empty()) {
1592 UserVariables.push_back(Var);
1593 // The first mention of a function argument gets the FunctionBeginSym
1594 // label, so arguments are visible when breaking at function entry.
1596 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1597 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1598 LabelsBeforeInsn[MI] = FunctionBeginSym;
1600 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1601 const MachineInstr *Prev = History.back();
1602 if (Prev->isDebugValue()) {
1603 // Coalesce identical entries at the end of History.
1604 if (History.size() >= 2 &&
1605 Prev->isIdenticalTo(History[History.size() - 2])) {
1606 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1607 << "\t" << *Prev << "\t"
1608 << *History[History.size() - 2] << "\n");
1612 // Terminate old register assignments that don't reach MI;
1613 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1614 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1615 isDbgValueInDefinedReg(Prev)) {
1616 // Previous register assignment needs to terminate at the end of
1618 MachineBasicBlock::const_iterator LastMI =
1619 PrevMBB->getLastNonDebugInstr();
1620 if (LastMI == PrevMBB->end()) {
1621 // Drop DBG_VALUE for empty range.
1622 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1623 << "\t" << *Prev << "\n");
1625 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1626 // Terminate after LastMI.
1627 History.push_back(LastMI);
1631 History.push_back(MI);
1633 // Not a DBG_VALUE instruction.
1635 AtBlockEntry = false;
1637 // First known non-DBG_VALUE and non-frame setup location marks
1638 // the beginning of the function body.
1639 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1640 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1641 PrologEndLoc = MI->getDebugLoc();
1643 // Check if the instruction clobbers any registers with debug vars.
1644 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1645 MOE = MI->operands_end();
1646 MOI != MOE; ++MOI) {
1647 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1649 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1652 const MDNode *Var = LiveUserVar[Reg];
1655 // Reg is now clobbered.
1656 LiveUserVar[Reg] = 0;
1658 // Was MD last defined by a DBG_VALUE referring to Reg?
1659 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1660 if (HistI == DbgValues.end())
1662 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1663 if (History.empty())
1665 const MachineInstr *Prev = History.back();
1666 // Sanity-check: Register assignments are terminated at the end of
1668 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1670 // Is the variable still in Reg?
1671 if (!isDbgValueInDefinedReg(Prev) ||
1672 Prev->getOperand(0).getReg() != Reg)
1674 // Var is clobbered. Make sure the next instruction gets a label.
1675 History.push_back(MI);
1682 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1684 SmallVectorImpl<const MachineInstr *> &History = I->second;
1685 if (History.empty())
1688 // Make sure the final register assignments are terminated.
1689 const MachineInstr *Prev = History.back();
1690 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1691 const MachineBasicBlock *PrevMBB = Prev->getParent();
1692 MachineBasicBlock::const_iterator LastMI =
1693 PrevMBB->getLastNonDebugInstr();
1694 if (LastMI == PrevMBB->end())
1695 // Drop DBG_VALUE for empty range.
1697 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1698 // Terminate after LastMI.
1699 History.push_back(LastMI);
1702 // Request labels for the full history.
1703 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1704 const MachineInstr *MI = History[i];
1705 if (MI->isDebugValue())
1706 requestLabelBeforeInsn(MI);
1708 requestLabelAfterInsn(MI);
1712 PrevInstLoc = DebugLoc();
1713 PrevLabel = FunctionBeginSym;
1715 // Record beginning of function.
1716 if (!PrologEndLoc.isUnknown()) {
1717 DebugLoc FnStartDL =
1718 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1720 FnStartDL.getLine(), FnStartDL.getCol(),
1721 FnStartDL.getScope(MF->getFunction()->getContext()),
1722 // We'd like to list the prologue as "not statements" but GDB behaves
1723 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1724 DWARF2_FLAG_IS_STMT);
1728 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1729 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1730 DIVariable DV = Var->getVariable();
1731 // Variables with positive arg numbers are parameters.
1732 if (unsigned ArgNum = DV.getArgNumber()) {
1733 // Keep all parameters in order at the start of the variable list to ensure
1734 // function types are correct (no out-of-order parameters)
1736 // This could be improved by only doing it for optimized builds (unoptimized
1737 // builds have the right order to begin with), searching from the back (this
1738 // would catch the unoptimized case quickly), or doing a binary search
1739 // rather than linear search.
1740 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1741 while (I != Vars.end()) {
1742 unsigned CurNum = (*I)->getVariable().getArgNumber();
1743 // A local (non-parameter) variable has been found, insert immediately
1747 // A later indexed parameter has been found, insert immediately before it.
1748 if (CurNum > ArgNum)
1752 Vars.insert(I, Var);
1756 Vars.push_back(Var);
1759 // Gather and emit post-function debug information.
1760 void DwarfDebug::endFunction(const MachineFunction *MF) {
1761 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1762 // though the beginFunction may not be called at all.
1763 // We should handle both cases.
1767 assert(CurFn == MF);
1770 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1775 // Define end label for subprogram.
1776 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1777 // Assumes in correct section after the entry point.
1778 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1780 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1781 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1783 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1784 collectVariableInfo(ProcessedVars);
1786 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1787 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1788 assert(TheCU && "Unable to find compile unit!");
1790 // Construct abstract scopes.
1791 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1792 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1793 LexicalScope *AScope = AList[i];
1794 DISubprogram SP(AScope->getScopeNode());
1795 if (SP.isSubprogram()) {
1796 // Collect info for variables that were optimized out.
1797 DIArray Variables = SP.getVariables();
1798 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1799 DIVariable DV(Variables.getElement(i));
1800 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1802 // Check that DbgVariable for DV wasn't created earlier, when
1803 // findAbstractVariable() was called for inlined instance of DV.
1804 LLVMContext &Ctx = DV->getContext();
1805 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1806 if (AbstractVariables.lookup(CleanDV))
1808 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1809 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1812 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1813 constructScopeDIE(TheCU, AScope);
1816 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1817 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1818 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1820 // Add the range of this function to the list of ranges for the CU.
1821 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1822 TheCU->addRange(llvm_move(Span));
1825 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1826 E = ScopeVariables.end();
1828 DeleteContainerPointers(I->second);
1829 ScopeVariables.clear();
1830 DeleteContainerPointers(CurrentFnArguments);
1831 UserVariables.clear();
1833 AbstractVariables.clear();
1834 LabelsBeforeInsn.clear();
1835 LabelsAfterInsn.clear();
1840 // Register a source line with debug info. Returns the unique label that was
1841 // emitted and which provides correspondence to the source line list.
1842 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1848 DIDescriptor Scope(S);
1850 if (Scope.isCompileUnit()) {
1851 DICompileUnit CU(S);
1852 Fn = CU.getFilename();
1853 Dir = CU.getDirectory();
1854 } else if (Scope.isFile()) {
1856 Fn = F.getFilename();
1857 Dir = F.getDirectory();
1858 } else if (Scope.isSubprogram()) {
1860 Fn = SP.getFilename();
1861 Dir = SP.getDirectory();
1862 } else if (Scope.isLexicalBlockFile()) {
1863 DILexicalBlockFile DBF(S);
1864 Fn = DBF.getFilename();
1865 Dir = DBF.getDirectory();
1866 } else if (Scope.isLexicalBlock()) {
1867 DILexicalBlock DB(S);
1868 Fn = DB.getFilename();
1869 Dir = DB.getDirectory();
1871 llvm_unreachable("Unexpected scope info");
1873 Src = getOrCreateSourceID(
1874 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1876 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1879 //===----------------------------------------------------------------------===//
1881 //===----------------------------------------------------------------------===//
1883 // Compute the size and offset of a DIE. The offset is relative to start of the
1884 // CU. It returns the offset after laying out the DIE.
1885 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1886 // Get the children.
1887 const std::vector<DIE *> &Children = Die->getChildren();
1889 // Record the abbreviation.
1890 assignAbbrevNumber(Die->getAbbrev());
1892 // Get the abbreviation for this DIE.
1893 const DIEAbbrev &Abbrev = Die->getAbbrev();
1896 Die->setOffset(Offset);
1898 // Start the size with the size of abbreviation code.
1899 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1901 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1902 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1904 // Size the DIE attribute values.
1905 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1906 // Size attribute value.
1907 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1909 // Size the DIE children if any.
1910 if (!Children.empty()) {
1911 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1912 "Children flag not set");
1914 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1915 Offset = computeSizeAndOffset(Children[j], Offset);
1917 // End of children marker.
1918 Offset += sizeof(int8_t);
1921 Die->setSize(Offset - Die->getOffset());
1925 // Compute the size and offset for each DIE.
1926 void DwarfFile::computeSizeAndOffsets() {
1927 // Offset from the first CU in the debug info section is 0 initially.
1928 unsigned SecOffset = 0;
1930 // Iterate over each compile unit and set the size and offsets for each
1931 // DIE within each compile unit. All offsets are CU relative.
1932 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1935 (*I)->setDebugInfoOffset(SecOffset);
1937 // CU-relative offset is reset to 0 here.
1938 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1939 (*I)->getHeaderSize(); // Unit-specific headers
1941 // EndOffset here is CU-relative, after laying out
1942 // all of the CU DIE.
1943 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1944 SecOffset += EndOffset;
1948 // Emit initial Dwarf sections with a label at the start of each one.
1949 void DwarfDebug::emitSectionLabels() {
1950 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1952 // Dwarf sections base addresses.
1953 DwarfInfoSectionSym =
1954 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1955 if (useSplitDwarf())
1956 DwarfInfoDWOSectionSym =
1957 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1958 DwarfAbbrevSectionSym =
1959 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1960 if (useSplitDwarf())
1961 DwarfAbbrevDWOSectionSym = emitSectionSym(
1962 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1963 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1965 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1966 emitSectionSym(Asm, MacroInfo);
1968 DwarfLineSectionSym =
1969 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1970 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1971 if (GenerateGnuPubSections) {
1972 DwarfGnuPubNamesSectionSym =
1973 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1974 DwarfGnuPubTypesSectionSym =
1975 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1976 } else if (HasDwarfPubSections) {
1977 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1978 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1981 DwarfStrSectionSym =
1982 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1983 if (useSplitDwarf()) {
1984 DwarfStrDWOSectionSym =
1985 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1986 DwarfAddrSectionSym =
1987 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1989 DwarfDebugRangeSectionSym =
1990 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1992 DwarfDebugLocSectionSym =
1993 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
1996 // Recursively emits a debug information entry.
1997 void DwarfDebug::emitDIE(DIE *Die) {
1998 // Get the abbreviation for this DIE.
1999 const DIEAbbrev &Abbrev = Die->getAbbrev();
2001 // Emit the code (index) for the abbreviation.
2002 if (Asm->isVerbose())
2003 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2004 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2005 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2006 dwarf::TagString(Abbrev.getTag()));
2007 Asm->EmitULEB128(Abbrev.getNumber());
2009 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2010 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2012 // Emit the DIE attribute values.
2013 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2014 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2015 dwarf::Form Form = AbbrevData[i].getForm();
2016 assert(Form && "Too many attributes for DIE (check abbreviation)");
2018 if (Asm->isVerbose())
2019 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2022 case dwarf::DW_AT_abstract_origin:
2023 case dwarf::DW_AT_type:
2024 case dwarf::DW_AT_friend:
2025 case dwarf::DW_AT_specification:
2026 case dwarf::DW_AT_import:
2027 case dwarf::DW_AT_containing_type: {
2028 DIEEntry *E = cast<DIEEntry>(Values[i]);
2029 DIE *Origin = E->getEntry();
2030 unsigned Addr = Origin->getOffset();
2031 if (Form == dwarf::DW_FORM_ref_addr) {
2032 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2033 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2034 // section. Origin->getOffset() returns the offset from start of the
2036 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2037 assert(CU && "CUDie should belong to a CU.");
2038 Addr += CU->getDebugInfoOffset();
2039 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2040 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2041 DIEEntry::getRefAddrSize(Asm));
2043 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2044 CU->getSectionSym(),
2045 DIEEntry::getRefAddrSize(Asm));
2047 // Make sure Origin belong to the same CU.
2048 assert(Die->getUnit() == Origin->getUnit() &&
2049 "The referenced DIE should belong to the same CU in ref4");
2050 Asm->EmitInt32(Addr);
2054 case dwarf::DW_AT_location: {
2055 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2056 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2057 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2059 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2061 Values[i]->EmitValue(Asm, Form);
2065 case dwarf::DW_AT_accessibility: {
2066 if (Asm->isVerbose()) {
2067 DIEInteger *V = cast<DIEInteger>(Values[i]);
2068 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2070 Values[i]->EmitValue(Asm, Form);
2074 // Emit an attribute using the defined form.
2075 Values[i]->EmitValue(Asm, Form);
2080 // Emit the DIE children if any.
2081 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2082 const std::vector<DIE *> &Children = Die->getChildren();
2084 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2085 emitDIE(Children[j]);
2087 Asm->OutStreamer.AddComment("End Of Children Mark");
2092 // Emit the various dwarf units to the unit section USection with
2093 // the abbreviations going into ASection.
2094 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2095 const MCSymbol *ASectionSym) {
2096 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2098 DwarfUnit *TheU = *I;
2099 DIE *Die = TheU->getUnitDie();
2100 const MCSection *USection = TheU->getSection();
2101 Asm->OutStreamer.SwitchSection(USection);
2103 // Emit the compile units header.
2104 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2106 // Emit size of content not including length itself
2107 Asm->OutStreamer.AddComment("Length of Unit");
2108 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2110 TheU->emitHeader(ASection, ASectionSym);
2113 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2117 // Emit the debug info section.
2118 void DwarfDebug::emitDebugInfo() {
2119 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2121 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2122 DwarfAbbrevSectionSym);
2125 // Emit the abbreviation section.
2126 void DwarfDebug::emitAbbreviations() {
2127 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2129 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2132 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2133 // Check to see if it is worth the effort.
2134 if (!Abbreviations.empty()) {
2135 // Start the debug abbrev section.
2136 Asm->OutStreamer.SwitchSection(Section);
2138 // For each abbrevation.
2139 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2140 // Get abbreviation data
2141 const DIEAbbrev *Abbrev = Abbreviations[i];
2143 // Emit the abbrevations code (base 1 index.)
2144 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2146 // Emit the abbreviations data.
2150 // Mark end of abbreviations.
2151 Asm->EmitULEB128(0, "EOM(3)");
2155 // Emit the last address of the section and the end of the line matrix.
2156 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2157 // Define last address of section.
2158 Asm->OutStreamer.AddComment("Extended Op");
2161 Asm->OutStreamer.AddComment("Op size");
2162 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2163 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2164 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2166 Asm->OutStreamer.AddComment("Section end label");
2168 Asm->OutStreamer.EmitSymbolValue(
2169 Asm->GetTempSymbol("section_end", SectionEnd),
2170 Asm->getDataLayout().getPointerSize());
2172 // Mark end of matrix.
2173 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2179 // Emit visible names into a hashed accelerator table section.
2180 void DwarfDebug::emitAccelNames() {
2182 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2183 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2184 E = getUnits().end();
2186 DwarfUnit *TheU = *I;
2187 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2188 for (StringMap<std::vector<const DIE *> >::const_iterator
2192 StringRef Name = GI->getKey();
2193 const std::vector<const DIE *> &Entities = GI->second;
2194 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2195 DE = Entities.end();
2197 AT.AddName(Name, *DI);
2201 AT.FinalizeTable(Asm, "Names");
2202 Asm->OutStreamer.SwitchSection(
2203 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2204 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2205 Asm->OutStreamer.EmitLabel(SectionBegin);
2207 // Emit the full data.
2208 AT.Emit(Asm, SectionBegin, &InfoHolder);
2211 // Emit objective C classes and categories into a hashed accelerator table
2213 void DwarfDebug::emitAccelObjC() {
2215 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2216 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2217 E = getUnits().end();
2219 DwarfUnit *TheU = *I;
2220 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2221 for (StringMap<std::vector<const DIE *> >::const_iterator
2225 StringRef Name = GI->getKey();
2226 const std::vector<const DIE *> &Entities = GI->second;
2227 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2228 DE = Entities.end();
2230 AT.AddName(Name, *DI);
2234 AT.FinalizeTable(Asm, "ObjC");
2235 Asm->OutStreamer.SwitchSection(
2236 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2237 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2238 Asm->OutStreamer.EmitLabel(SectionBegin);
2240 // Emit the full data.
2241 AT.Emit(Asm, SectionBegin, &InfoHolder);
2244 // Emit namespace dies into a hashed accelerator table.
2245 void DwarfDebug::emitAccelNamespaces() {
2247 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2248 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2249 E = getUnits().end();
2251 DwarfUnit *TheU = *I;
2252 const StringMap<std::vector<const DIE *> > &Names =
2253 TheU->getAccelNamespace();
2254 for (StringMap<std::vector<const DIE *> >::const_iterator
2258 StringRef Name = GI->getKey();
2259 const std::vector<const DIE *> &Entities = GI->second;
2260 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2261 DE = Entities.end();
2263 AT.AddName(Name, *DI);
2267 AT.FinalizeTable(Asm, "namespac");
2268 Asm->OutStreamer.SwitchSection(
2269 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2270 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2271 Asm->OutStreamer.EmitLabel(SectionBegin);
2273 // Emit the full data.
2274 AT.Emit(Asm, SectionBegin, &InfoHolder);
2277 // Emit type dies into a hashed accelerator table.
2278 void DwarfDebug::emitAccelTypes() {
2279 std::vector<DwarfAccelTable::Atom> Atoms;
2281 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2283 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2285 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2286 DwarfAccelTable AT(Atoms);
2287 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2288 E = getUnits().end();
2290 DwarfUnit *TheU = *I;
2291 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2292 TheU->getAccelTypes();
2294 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2298 StringRef Name = GI->getKey();
2299 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2301 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2302 DI = Entities.begin(),
2303 DE = Entities.end();
2305 AT.AddName(Name, DI->first, DI->second);
2309 AT.FinalizeTable(Asm, "types");
2310 Asm->OutStreamer.SwitchSection(
2311 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2312 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2313 Asm->OutStreamer.EmitLabel(SectionBegin);
2315 // Emit the full data.
2316 AT.Emit(Asm, SectionBegin, &InfoHolder);
2319 // Public name handling.
2320 // The format for the various pubnames:
2322 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2323 // for the DIE that is named.
2325 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2326 // into the CU and the index value is computed according to the type of value
2327 // for the DIE that is named.
2329 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2330 // it's the offset within the debug_info/debug_types dwo section, however, the
2331 // reference in the pubname header doesn't change.
2333 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2334 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2336 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2338 // We could have a specification DIE that has our most of our knowledge,
2339 // look for that now.
2340 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2342 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2343 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2344 Linkage = dwarf::GIEL_EXTERNAL;
2345 } else if (Die->findAttribute(dwarf::DW_AT_external))
2346 Linkage = dwarf::GIEL_EXTERNAL;
2348 switch (Die->getTag()) {
2349 case dwarf::DW_TAG_class_type:
2350 case dwarf::DW_TAG_structure_type:
2351 case dwarf::DW_TAG_union_type:
2352 case dwarf::DW_TAG_enumeration_type:
2353 return dwarf::PubIndexEntryDescriptor(
2354 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2355 ? dwarf::GIEL_STATIC
2356 : dwarf::GIEL_EXTERNAL);
2357 case dwarf::DW_TAG_typedef:
2358 case dwarf::DW_TAG_base_type:
2359 case dwarf::DW_TAG_subrange_type:
2360 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2361 case dwarf::DW_TAG_namespace:
2362 return dwarf::GIEK_TYPE;
2363 case dwarf::DW_TAG_subprogram:
2364 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2365 case dwarf::DW_TAG_constant:
2366 case dwarf::DW_TAG_variable:
2367 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2368 case dwarf::DW_TAG_enumerator:
2369 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2370 dwarf::GIEL_STATIC);
2372 return dwarf::GIEK_NONE;
2376 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2378 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2379 const MCSection *PSec =
2380 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2381 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2383 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2384 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2385 for (unsigned i = 0; i != Units.size(); ++i) {
2386 DwarfUnit *TheU = Units[i];
2387 unsigned ID = TheU->getUniqueID();
2389 // Start the dwarf pubnames section.
2390 Asm->OutStreamer.SwitchSection(PSec);
2392 // Emit a label so we can reference the beginning of this pubname section.
2394 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2397 Asm->OutStreamer.AddComment("Length of Public Names Info");
2398 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2399 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2400 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2402 Asm->OutStreamer.EmitLabel(BeginLabel);
2404 Asm->OutStreamer.AddComment("DWARF Version");
2405 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2407 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2408 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2410 Asm->OutStreamer.AddComment("Compilation Unit Length");
2411 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2413 // Emit the pubnames for this compilation unit.
2414 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2415 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2418 const char *Name = GI->getKeyData();
2419 const DIE *Entity = GI->second;
2421 Asm->OutStreamer.AddComment("DIE offset");
2422 Asm->EmitInt32(Entity->getOffset());
2425 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2426 Asm->OutStreamer.AddComment(
2427 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2428 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2429 Asm->EmitInt8(Desc.toBits());
2432 Asm->OutStreamer.AddComment("External Name");
2433 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2436 Asm->OutStreamer.AddComment("End Mark");
2438 Asm->OutStreamer.EmitLabel(EndLabel);
2442 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2443 const MCSection *PSec =
2444 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2445 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2447 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2448 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2449 for (unsigned i = 0; i != Units.size(); ++i) {
2450 DwarfUnit *TheU = Units[i];
2451 unsigned ID = TheU->getUniqueID();
2453 // Start the dwarf pubtypes section.
2454 Asm->OutStreamer.SwitchSection(PSec);
2456 // Emit a label so we can reference the beginning of this pubtype section.
2458 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2461 Asm->OutStreamer.AddComment("Length of Public Types Info");
2462 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2463 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2464 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2466 Asm->OutStreamer.EmitLabel(BeginLabel);
2468 Asm->OutStreamer.AddComment("DWARF Version");
2469 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2471 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2472 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2474 Asm->OutStreamer.AddComment("Compilation Unit Length");
2475 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2477 // Emit the pubtypes.
2478 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2479 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2482 const char *Name = GI->getKeyData();
2483 const DIE *Entity = GI->second;
2485 Asm->OutStreamer.AddComment("DIE offset");
2486 Asm->EmitInt32(Entity->getOffset());
2489 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2490 Asm->OutStreamer.AddComment(
2491 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2492 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2493 Asm->EmitInt8(Desc.toBits());
2496 Asm->OutStreamer.AddComment("External Name");
2498 // Emit the name with a terminating null byte.
2499 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2502 Asm->OutStreamer.AddComment("End Mark");
2504 Asm->OutStreamer.EmitLabel(EndLabel);
2508 // Emit strings into a string section.
2509 void DwarfFile::emitStrings(const MCSection *StrSection,
2510 const MCSection *OffsetSection = NULL,
2511 const MCSymbol *StrSecSym = NULL) {
2513 if (StringPool.empty())
2516 // Start the dwarf str section.
2517 Asm->OutStreamer.SwitchSection(StrSection);
2519 // Get all of the string pool entries and put them in an array by their ID so
2520 // we can sort them.
2522 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2525 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2526 I = StringPool.begin(),
2527 E = StringPool.end();
2529 Entries.push_back(std::make_pair(I->second.second, &*I));
2531 array_pod_sort(Entries.begin(), Entries.end());
2533 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2534 // Emit a label for reference from debug information entries.
2535 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2537 // Emit the string itself with a terminating null byte.
2538 Asm->OutStreamer.EmitBytes(
2539 StringRef(Entries[i].second->getKeyData(),
2540 Entries[i].second->getKeyLength() + 1));
2543 // If we've got an offset section go ahead and emit that now as well.
2544 if (OffsetSection) {
2545 Asm->OutStreamer.SwitchSection(OffsetSection);
2546 unsigned offset = 0;
2547 unsigned size = 4; // FIXME: DWARF64 is 8.
2548 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2549 Asm->OutStreamer.EmitIntValue(offset, size);
2550 offset += Entries[i].second->getKeyLength() + 1;
2555 // Emit addresses into the section given.
2556 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2558 if (AddressPool.empty())
2561 // Start the dwarf addr section.
2562 Asm->OutStreamer.SwitchSection(AddrSection);
2564 // Order the address pool entries by ID
2565 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2567 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2568 E = AddressPool.end();
2570 Entries[I->second] = I->first;
2572 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2573 // Emit an expression for reference from debug information entries.
2574 if (const MCExpr *Expr = Entries[i])
2575 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2577 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2581 // Emit visible names into a debug str section.
2582 void DwarfDebug::emitDebugStr() {
2583 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2584 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2587 // Emit locations into the debug loc section.
2588 void DwarfDebug::emitDebugLoc() {
2589 if (DotDebugLocEntries.empty())
2592 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2593 I = DotDebugLocEntries.begin(),
2594 E = DotDebugLocEntries.end();
2596 DotDebugLocEntry &Entry = *I;
2597 if (I + 1 != DotDebugLocEntries.end())
2601 // Start the dwarf loc section.
2602 Asm->OutStreamer.SwitchSection(
2603 Asm->getObjFileLowering().getDwarfLocSection());
2604 unsigned char Size = Asm->getDataLayout().getPointerSize();
2605 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2607 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2608 I = DotDebugLocEntries.begin(),
2609 E = DotDebugLocEntries.end();
2610 I != E; ++I, ++index) {
2611 DotDebugLocEntry &Entry = *I;
2612 if (Entry.isMerged())
2614 if (Entry.isEmpty()) {
2615 Asm->OutStreamer.EmitIntValue(0, Size);
2616 Asm->OutStreamer.EmitIntValue(0, Size);
2617 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2619 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2620 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2621 DIVariable DV(Entry.getVariable());
2622 Asm->OutStreamer.AddComment("Loc expr size");
2623 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2624 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2625 Asm->EmitLabelDifference(end, begin, 2);
2626 Asm->OutStreamer.EmitLabel(begin);
2627 if (Entry.isInt()) {
2628 DIBasicType BTy(DV.getType());
2629 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2630 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2631 Asm->OutStreamer.AddComment("DW_OP_consts");
2632 Asm->EmitInt8(dwarf::DW_OP_consts);
2633 Asm->EmitSLEB128(Entry.getInt());
2635 Asm->OutStreamer.AddComment("DW_OP_constu");
2636 Asm->EmitInt8(dwarf::DW_OP_constu);
2637 Asm->EmitULEB128(Entry.getInt());
2639 } else if (Entry.isLocation()) {
2640 MachineLocation Loc = Entry.getLoc();
2641 if (!DV.hasComplexAddress())
2643 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2645 // Complex address entry.
2646 unsigned N = DV.getNumAddrElements();
2648 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2649 if (Loc.getOffset()) {
2651 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2652 Asm->OutStreamer.AddComment("DW_OP_deref");
2653 Asm->EmitInt8(dwarf::DW_OP_deref);
2654 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2655 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2656 Asm->EmitSLEB128(DV.getAddrElement(1));
2658 // If first address element is OpPlus then emit
2659 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2660 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2661 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2665 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2668 // Emit remaining complex address elements.
2669 for (; i < N; ++i) {
2670 uint64_t Element = DV.getAddrElement(i);
2671 if (Element == DIBuilder::OpPlus) {
2672 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2673 Asm->EmitULEB128(DV.getAddrElement(++i));
2674 } else if (Element == DIBuilder::OpDeref) {
2676 Asm->EmitInt8(dwarf::DW_OP_deref);
2678 llvm_unreachable("unknown Opcode found in complex address");
2682 // else ... ignore constant fp. There is not any good way to
2683 // to represent them here in dwarf.
2684 Asm->OutStreamer.EmitLabel(end);
2689 struct SymbolCUSorter {
2690 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2691 const MCStreamer &Streamer;
2693 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2694 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2695 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2697 // Symbols with no order assigned should be placed at the end.
2698 // (e.g. section end labels)
2700 IA = (unsigned)(-1);
2702 IB = (unsigned)(-1);
2707 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2708 return (A->getUniqueID() < B->getUniqueID());
2712 const MCSymbol *Start, *End;
2715 // Emit a debug aranges section, containing a CU lookup for any
2716 // address we can tie back to a CU.
2717 void DwarfDebug::emitDebugARanges() {
2718 // Start the dwarf aranges section.
2719 Asm->OutStreamer.SwitchSection(
2720 Asm->getObjFileLowering().getDwarfARangesSection());
2722 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2726 // Build a list of sections used.
2727 std::vector<const MCSection *> Sections;
2728 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2730 const MCSection *Section = it->first;
2731 Sections.push_back(Section);
2734 // Sort the sections into order.
2735 // This is only done to ensure consistent output order across different runs.
2736 std::sort(Sections.begin(), Sections.end(), SectionSort);
2738 // Build a set of address spans, sorted by CU.
2739 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2740 const MCSection *Section = Sections[SecIdx];
2741 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2742 if (List.size() < 2)
2745 // Sort the symbols by offset within the section.
2746 SymbolCUSorter sorter(Asm->OutStreamer);
2747 std::sort(List.begin(), List.end(), sorter);
2749 // If we have no section (e.g. common), just write out
2750 // individual spans for each symbol.
2751 if (Section == NULL) {
2752 for (size_t n = 0; n < List.size(); n++) {
2753 const SymbolCU &Cur = List[n];
2756 Span.Start = Cur.Sym;
2759 Spans[Cur.CU].push_back(Span);
2762 // Build spans between each label.
2763 const MCSymbol *StartSym = List[0].Sym;
2764 for (size_t n = 1; n < List.size(); n++) {
2765 const SymbolCU &Prev = List[n - 1];
2766 const SymbolCU &Cur = List[n];
2768 // Try and build the longest span we can within the same CU.
2769 if (Cur.CU != Prev.CU) {
2771 Span.Start = StartSym;
2773 Spans[Prev.CU].push_back(Span);
2780 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2782 // Build a list of CUs used.
2783 std::vector<DwarfCompileUnit *> CUs;
2784 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2785 DwarfCompileUnit *CU = it->first;
2789 // Sort the CU list (again, to ensure consistent output order).
2790 std::sort(CUs.begin(), CUs.end(), CUSort);
2792 // Emit an arange table for each CU we used.
2793 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2794 DwarfCompileUnit *CU = CUs[CUIdx];
2795 std::vector<ArangeSpan> &List = Spans[CU];
2797 // Emit size of content not including length itself.
2798 unsigned ContentSize =
2799 sizeof(int16_t) + // DWARF ARange version number
2800 sizeof(int32_t) + // Offset of CU in the .debug_info section
2801 sizeof(int8_t) + // Pointer Size (in bytes)
2802 sizeof(int8_t); // Segment Size (in bytes)
2804 unsigned TupleSize = PtrSize * 2;
2806 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2808 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2810 ContentSize += Padding;
2811 ContentSize += (List.size() + 1) * TupleSize;
2813 // For each compile unit, write the list of spans it covers.
2814 Asm->OutStreamer.AddComment("Length of ARange Set");
2815 Asm->EmitInt32(ContentSize);
2816 Asm->OutStreamer.AddComment("DWARF Arange version number");
2817 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2818 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2819 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2820 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2821 Asm->EmitInt8(PtrSize);
2822 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2825 Asm->OutStreamer.EmitFill(Padding, 0xff);
2827 for (unsigned n = 0; n < List.size(); n++) {
2828 const ArangeSpan &Span = List[n];
2829 Asm->EmitLabelReference(Span.Start, PtrSize);
2831 // Calculate the size as being from the span start to it's end.
2833 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2835 // For symbols without an end marker (e.g. common), we
2836 // write a single arange entry containing just that one symbol.
2837 uint64_t Size = SymSize[Span.Start];
2841 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2845 Asm->OutStreamer.AddComment("ARange terminator");
2846 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2847 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2851 // Emit visible names into a debug ranges section.
2852 void DwarfDebug::emitDebugRanges() {
2853 // Start the dwarf ranges section.
2854 Asm->OutStreamer.SwitchSection(
2855 Asm->getObjFileLowering().getDwarfRangesSection());
2857 // Size for our labels.
2858 unsigned char Size = Asm->getDataLayout().getPointerSize();
2860 // Grab the specific ranges for the compile units in the module.
2861 for (MapVector<const MDNode *, DwarfCompileUnit *>::iterator
2865 DwarfCompileUnit *TheCU = I->second;
2867 // Emit a symbol so we can find the beginning of our ranges.
2868 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2870 // Iterate over the misc ranges for the compile units in the module.
2871 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2872 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2873 E = RangeLists.end();
2875 const RangeSpanList &List = *I;
2877 // Emit our symbol so we can find the beginning of the range.
2878 Asm->OutStreamer.EmitLabel(List.getSym());
2880 for (SmallVectorImpl<RangeSpan>::const_iterator
2881 RI = List.getRanges().begin(),
2882 RE = List.getRanges().end();
2884 const RangeSpan &Range = *RI;
2885 const MCSymbol *Begin = Range.getStart();
2886 const MCSymbol *End = Range.getEnd();
2887 assert(Begin && "Range without a begin symbol?");
2888 assert(End && "Range without an end symbol?");
2889 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2890 Asm->OutStreamer.EmitSymbolValue(End, Size);
2893 // And terminate the list with two 0 values.
2894 Asm->OutStreamer.EmitIntValue(0, Size);
2895 Asm->OutStreamer.EmitIntValue(0, Size);
2898 // Now emit a range for the CU itself.
2899 if (useCURanges()) {
2900 Asm->OutStreamer.EmitLabel(
2901 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2902 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2903 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2904 RangeSpan Range = Ranges[i];
2905 const MCSymbol *Begin = Range.getStart();
2906 const MCSymbol *End = Range.getEnd();
2907 assert(Begin && "Range without a begin symbol?");
2908 assert(End && "Range without an end symbol?");
2909 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2910 Asm->OutStreamer.EmitSymbolValue(End, Size);
2912 // And terminate the list with two 0 values.
2913 Asm->OutStreamer.EmitIntValue(0, Size);
2914 Asm->OutStreamer.EmitIntValue(0, Size);
2919 // DWARF5 Experimental Separate Dwarf emitters.
2921 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2923 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2924 U->getCUNode().getSplitDebugFilename());
2926 // Relocate to the beginning of the addr_base section, else 0 for the
2927 // beginning of the one for this compile unit.
2928 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2929 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2931 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2933 if (!CompilationDir.empty())
2934 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2936 addGnuPubAttributes(NewU, Die);
2938 SkeletonHolder.addUnit(NewU);
2941 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2942 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2943 // DW_AT_ranges_base, DW_AT_addr_base.
2944 // TODO: Implement DW_AT_ranges_base.
2945 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2947 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2948 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2949 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2950 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2951 DwarfInfoSectionSym);
2953 // DW_AT_stmt_list is a offset of line number information for this
2954 // compile unit in debug_line section.
2955 // FIXME: Should handle multiple compile units.
2956 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2957 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
2959 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2961 initSkeletonUnit(CU, Die, NewCU);
2966 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2968 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(const DwarfTypeUnit *TU) {
2970 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2971 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
2972 TU->getUniqueID(), Die, TU->getCUNode(), Asm, this, &SkeletonHolder);
2973 NewTU->setTypeSignature(TU->getTypeSignature());
2974 NewTU->setType(NULL);
2976 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2978 initSkeletonUnit(TU, Die, NewTU);
2982 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2983 // compile units that would normally be in debug_info.
2984 void DwarfDebug::emitDebugInfoDWO() {
2985 assert(useSplitDwarf() && "No split dwarf debug info?");
2986 InfoHolder.emitUnits(this,
2987 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2988 DwarfAbbrevDWOSectionSym);
2991 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2992 // abbreviations for the .debug_info.dwo section.
2993 void DwarfDebug::emitDebugAbbrevDWO() {
2994 assert(useSplitDwarf() && "No split dwarf?");
2995 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
2998 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2999 // string section and is identical in format to traditional .debug_str
3001 void DwarfDebug::emitDebugStrDWO() {
3002 assert(useSplitDwarf() && "No split dwarf?");
3003 const MCSection *OffSec =
3004 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3005 const MCSymbol *StrSym = DwarfStrSectionSym;
3006 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3010 void DwarfDebug::addDwarfTypeUnitType(DICompileUnit CUNode,
3011 StringRef Identifier, DIE *RefDie,
3012 DICompositeType CTy) {
3013 // Flag the type unit reference as a declaration so that if it contains
3014 // members (implicit special members, static data member definitions, member
3015 // declarations for definitions in this CU, etc) consumers don't get confused
3016 // and think this is a full definition.
3017 CUMap.begin()->second->addFlag(RefDie, dwarf::DW_AT_declaration);
3019 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3021 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
3025 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3026 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
3027 InfoHolder.getUnits().size(), UnitDie, CUNode, Asm, this, &InfoHolder);
3029 InfoHolder.addUnit(NewTU);
3031 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3032 CUNode.getLanguage());
3035 Hash.update(Identifier);
3036 // ... take the least significant 8 bytes and return those. Our MD5
3037 // implementation always returns its results in little endian, swap bytes
3039 MD5::MD5Result Result;
3041 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
3042 NewTU->setTypeSignature(Signature);
3043 if (useSplitDwarf())
3044 NewTU->setSkeleton(constructSkeletonTU(NewTU));
3046 NewTU->setType(NewTU->createTypeDIE(CTy));
3050 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3051 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3053 CUMap.begin()->second->addDIETypeSignature(RefDie, *NewTU);