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"),
70 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
72 cl::desc("Generate dwarf aranges"),
76 enum DefaultOnOff { Default, Enable, Disable };
79 static cl::opt<DefaultOnOff>
80 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
81 cl::desc("Output prototype dwarf accelerator tables."),
82 cl::values(clEnumVal(Default, "Default for platform"),
83 clEnumVal(Enable, "Enabled"),
84 clEnumVal(Disable, "Disabled"), clEnumValEnd),
87 static cl::opt<DefaultOnOff>
88 SplitDwarf("split-dwarf", cl::Hidden,
89 cl::desc("Output DWARF5 split debug info."),
90 cl::values(clEnumVal(Default, "Default for platform"),
91 clEnumVal(Enable, "Enabled"),
92 clEnumVal(Disable, "Disabled"), clEnumValEnd),
95 static cl::opt<DefaultOnOff>
96 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
97 cl::desc("Generate DWARF pubnames and pubtypes sections"),
98 cl::values(clEnumVal(Default, "Default for platform"),
99 clEnumVal(Enable, "Enabled"),
100 clEnumVal(Disable, "Disabled"), clEnumValEnd),
103 static cl::opt<unsigned>
104 DwarfVersionNumber("dwarf-version", cl::Hidden,
105 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
108 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
109 cl::desc("Generate DW_AT_ranges for compile units"),
112 static const char *const DWARFGroupName = "DWARF Emission";
113 static const char *const DbgTimerName = "DWARF Debug Writer";
115 //===----------------------------------------------------------------------===//
119 /// resolve - Look in the DwarfDebug map for the MDNode that
120 /// corresponds to the reference.
121 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
122 return DD->resolve(Ref);
125 DIType DbgVariable::getType() const {
126 DIType Ty = Var.getType();
127 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
128 // addresses instead.
129 if (Var.isBlockByrefVariable()) {
130 /* Byref variables, in Blocks, are declared by the programmer as
131 "SomeType VarName;", but the compiler creates a
132 __Block_byref_x_VarName struct, and gives the variable VarName
133 either the struct, or a pointer to the struct, as its type. This
134 is necessary for various behind-the-scenes things the compiler
135 needs to do with by-reference variables in blocks.
137 However, as far as the original *programmer* is concerned, the
138 variable should still have type 'SomeType', as originally declared.
140 The following function dives into the __Block_byref_x_VarName
141 struct to find the original type of the variable. This will be
142 passed back to the code generating the type for the Debug
143 Information Entry for the variable 'VarName'. 'VarName' will then
144 have the original type 'SomeType' in its debug information.
146 The original type 'SomeType' will be the type of the field named
147 'VarName' inside the __Block_byref_x_VarName struct.
149 NOTE: In order for this to not completely fail on the debugger
150 side, the Debug Information Entry for the variable VarName needs to
151 have a DW_AT_location that tells the debugger how to unwind through
152 the pointers and __Block_byref_x_VarName struct to find the actual
153 value of the variable. The function addBlockByrefType does this. */
155 uint16_t tag = Ty.getTag();
157 if (tag == dwarf::DW_TAG_pointer_type)
158 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
160 DIArray Elements = DICompositeType(subType).getTypeArray();
161 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
162 DIDerivedType DT(Elements.getElement(i));
163 if (getName() == DT.getName())
164 return (resolve(DT.getTypeDerivedFrom()));
170 } // end llvm namespace
172 /// Return Dwarf Version by checking module flags.
173 static unsigned getDwarfVersionFromModule(const Module *M) {
174 Value *Val = M->getModuleFlag("Dwarf Version");
176 return dwarf::DWARF_VERSION;
177 return cast<ConstantInt>(Val)->getZExtValue();
180 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
181 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
182 PrevLabel(NULL), GlobalRangeCount(0),
183 InfoHolder(A, "info_string", DIEValueAllocator), HasCURanges(false),
184 UsedNonDefaultText(false),
185 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
187 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
188 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
189 DwarfAddrSectionSym = 0;
190 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
191 FunctionBeginSym = FunctionEndSym = 0;
195 // Turn on accelerator tables for Darwin by default, pubnames by
196 // default for non-Darwin, and handle split dwarf.
197 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
199 if (DwarfAccelTables == Default)
200 HasDwarfAccelTables = IsDarwin;
202 HasDwarfAccelTables = DwarfAccelTables == Enable;
204 if (SplitDwarf == Default)
205 HasSplitDwarf = false;
207 HasSplitDwarf = SplitDwarf == Enable;
209 if (DwarfPubSections == Default)
210 HasDwarfPubSections = !IsDarwin;
212 HasDwarfPubSections = DwarfPubSections == Enable;
214 DwarfVersion = DwarfVersionNumber
216 : getDwarfVersionFromModule(MMI->getModule());
219 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
224 // Switch to the specified MCSection and emit an assembler
225 // temporary label to it if SymbolStem is specified.
226 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
227 const char *SymbolStem = 0) {
228 Asm->OutStreamer.SwitchSection(Section);
232 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
233 Asm->OutStreamer.EmitLabel(TmpSym);
237 DwarfFile::~DwarfFile() {
238 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
243 MCSymbol *DwarfFile::getStringPoolSym() {
244 return Asm->GetTempSymbol(StringPref);
247 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
248 std::pair<MCSymbol *, unsigned> &Entry =
249 StringPool.GetOrCreateValue(Str).getValue();
253 Entry.second = NextStringPoolNumber++;
254 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
257 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
258 std::pair<MCSymbol *, unsigned> &Entry =
259 StringPool.GetOrCreateValue(Str).getValue();
263 Entry.second = NextStringPoolNumber++;
264 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
268 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
269 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
272 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
273 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
274 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
276 ++NextAddrPoolNumber;
277 return P.first->second;
280 // Define a unique number for the abbreviation.
282 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
283 // Check the set for priors.
284 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
286 // If it's newly added.
287 if (InSet == &Abbrev) {
288 // Add to abbreviation list.
289 Abbreviations.push_back(&Abbrev);
291 // Assign the vector position + 1 as its number.
292 Abbrev.setNumber(Abbreviations.size());
294 // Assign existing abbreviation number.
295 Abbrev.setNumber(InSet->getNumber());
299 static bool isObjCClass(StringRef Name) {
300 return Name.startswith("+") || Name.startswith("-");
303 static bool hasObjCCategory(StringRef Name) {
304 if (!isObjCClass(Name))
307 return Name.find(") ") != StringRef::npos;
310 static void getObjCClassCategory(StringRef In, StringRef &Class,
311 StringRef &Category) {
312 if (!hasObjCCategory(In)) {
313 Class = In.slice(In.find('[') + 1, In.find(' '));
318 Class = In.slice(In.find('[') + 1, In.find('('));
319 Category = In.slice(In.find('[') + 1, In.find(' '));
323 static StringRef getObjCMethodName(StringRef In) {
324 return In.slice(In.find(' ') + 1, In.find(']'));
327 // Helper for sorting sections into a stable output order.
328 static bool SectionSort(const MCSection *A, const MCSection *B) {
329 std::string LA = (A ? A->getLabelBeginName() : "");
330 std::string LB = (B ? B->getLabelBeginName() : "");
334 // Add the various names to the Dwarf accelerator table names.
335 // TODO: Determine whether or not we should add names for programs
336 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
337 // is only slightly different than the lookup of non-standard ObjC names.
338 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
339 if (!SP.isDefinition())
341 TheU->addAccelName(SP.getName(), Die);
343 // If the linkage name is different than the name, go ahead and output
344 // that as well into the name table.
345 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
346 TheU->addAccelName(SP.getLinkageName(), Die);
348 // If this is an Objective-C selector name add it to the ObjC accelerator
350 if (isObjCClass(SP.getName())) {
351 StringRef Class, Category;
352 getObjCClassCategory(SP.getName(), Class, Category);
353 TheU->addAccelObjC(Class, Die);
355 TheU->addAccelObjC(Category, Die);
356 // Also add the base method name to the name table.
357 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
361 /// isSubprogramContext - Return true if Context is either a subprogram
362 /// or another context nested inside a subprogram.
363 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
366 DIDescriptor D(Context);
367 if (D.isSubprogram())
370 return isSubprogramContext(resolve(DIType(Context).getContext()));
374 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
375 // and DW_AT_high_pc attributes. If there are global variables in this
376 // scope then create and insert DIEs for these variables.
377 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
379 DIE *SPDie = SPCU->getDIE(SP);
381 assert(SPDie && "Unable to find subprogram DIE!");
383 // If we're updating an abstract DIE, then we will be adding the children and
384 // object pointer later on. But what we don't want to do is process the
385 // concrete DIE twice.
386 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
387 // Pick up abstract subprogram DIE.
389 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
390 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
392 DISubprogram SPDecl = SP.getFunctionDeclaration();
393 if (!SPDecl.isSubprogram()) {
394 // There is not any need to generate specification DIE for a function
395 // defined at compile unit level. If a function is defined inside another
396 // function then gdb prefers the definition at top level and but does not
397 // expect specification DIE in parent function. So avoid creating
398 // specification DIE for a function defined inside a function.
399 DIScope SPContext = resolve(SP.getContext());
400 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
401 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
402 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
405 DICompositeType SPTy = SP.getType();
406 DIArray Args = SPTy.getTypeArray();
407 uint16_t SPTag = SPTy.getTag();
408 if (SPTag == dwarf::DW_TAG_subroutine_type)
409 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
411 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
412 DIType ATy(Args.getElement(i));
413 SPCU->addType(Arg, ATy);
414 if (ATy.isArtificial())
415 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
416 if (ATy.isObjectPointer())
417 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
419 DIE *SPDeclDie = SPDie;
420 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
421 *SPCU->getUnitDie());
422 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
427 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
428 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
430 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
431 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
432 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
434 // Add name to the name table, we do this here because we're guaranteed
435 // to have concrete versions of our DW_TAG_subprogram nodes.
436 addSubprogramNames(SPCU, SP, SPDie);
441 /// Check whether we should create a DIE for the given Scope, return true
442 /// if we don't create a DIE (the corresponding DIE is null).
443 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
444 if (Scope->isAbstractScope())
447 // We don't create a DIE if there is no Range.
448 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
452 if (Ranges.size() > 1)
455 // We don't create a DIE if we have a single Range and the end label
457 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
458 MCSymbol *End = getLabelAfterInsn(RI->second);
462 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
463 dwarf::Attribute A, const MCSymbol *L,
464 const MCSymbol *Sec) {
465 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
466 U->addSectionLabel(D, A, L);
468 U->addSectionDelta(D, A, L, Sec);
471 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
472 const SmallVectorImpl<InsnRange> &Range) {
473 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
474 // emitting it appropriately.
475 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
476 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
477 DwarfDebugRangeSectionSym);
479 RangeSpanList List(RangeSym);
480 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
483 RangeSpan Span(getLabelBeforeInsn(RI->first),
484 getLabelAfterInsn(RI->second));
485 List.addRange(llvm_move(Span));
488 // Add the range list to the set of ranges to be emitted.
489 TheCU->addRangeList(llvm_move(List));
492 // Construct new DW_TAG_lexical_block for this scope and attach
493 // DW_AT_low_pc/DW_AT_high_pc labels.
494 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
495 LexicalScope *Scope) {
496 if (isLexicalScopeDIENull(Scope))
499 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
500 if (Scope->isAbstractScope())
503 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
505 // If we have multiple ranges, emit them into the range section.
506 if (ScopeRanges.size() > 1) {
507 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
511 // Construct the address range for this DIE.
512 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
513 MCSymbol *Start = getLabelBeforeInsn(RI->first);
514 MCSymbol *End = getLabelAfterInsn(RI->second);
515 assert(End && "End label should not be null!");
517 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
518 assert(End->isDefined() && "Invalid end label for an inlined scope!");
520 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
521 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
526 // This scope represents inlined body of a function. Construct DIE to
527 // represent this concrete inlined copy of the function.
528 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
529 LexicalScope *Scope) {
530 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
531 assert(!ScopeRanges.empty() &&
532 "LexicalScope does not have instruction markers!");
534 if (!Scope->getScopeNode())
536 DIScope DS(Scope->getScopeNode());
537 DISubprogram InlinedSP = getDISubprogram(DS);
538 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
540 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
544 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
545 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
547 // If we have multiple ranges, emit them into the range section.
548 if (ScopeRanges.size() > 1)
549 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
551 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
552 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
553 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
555 if (StartLabel == 0 || EndLabel == 0)
556 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
558 assert(StartLabel->isDefined() &&
559 "Invalid starting label for an inlined scope!");
560 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
562 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
563 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
566 InlinedSubprogramDIEs.insert(OriginDIE);
568 // Add the call site information to the DIE.
569 DILocation DL(Scope->getInlinedAt());
570 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
571 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
572 TheCU->getUniqueID()));
573 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
575 // Add name to the name table, we do this here because we're guaranteed
576 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
577 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
582 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
584 SmallVectorImpl<DIE *> &Children) {
585 DIE *ObjectPointer = NULL;
587 // Collect arguments for current function.
588 if (LScopes.isCurrentFunctionScope(Scope))
589 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
590 if (DbgVariable *ArgDV = CurrentFnArguments[i])
592 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
593 Children.push_back(Arg);
594 if (ArgDV->isObjectPointer())
598 // Collect lexical scope children first.
599 const SmallVectorImpl<DbgVariable *> &Variables =
600 ScopeVariables.lookup(Scope);
601 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
602 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
603 Scope->isAbstractScope())) {
604 Children.push_back(Variable);
605 if (Variables[i]->isObjectPointer())
606 ObjectPointer = Variable;
608 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
609 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
610 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
611 Children.push_back(Nested);
612 return ObjectPointer;
615 // Construct a DIE for this scope.
616 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
617 LexicalScope *Scope) {
618 if (!Scope || !Scope->getScopeNode())
621 DIScope DS(Scope->getScopeNode());
623 SmallVector<DIE *, 8> Children;
624 DIE *ObjectPointer = NULL;
625 bool ChildrenCreated = false;
627 // We try to create the scope DIE first, then the children DIEs. This will
628 // avoid creating un-used children then removing them later when we find out
629 // the scope DIE is null.
630 DIE *ScopeDIE = NULL;
631 if (Scope->getInlinedAt())
632 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
633 else if (DS.isSubprogram()) {
634 ProcessedSPNodes.insert(DS);
635 if (Scope->isAbstractScope()) {
636 ScopeDIE = TheCU->getDIE(DS);
637 // Note down abstract DIE.
639 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
641 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
643 // Early exit when we know the scope DIE is going to be null.
644 if (isLexicalScopeDIENull(Scope))
647 // We create children here when we know the scope DIE is not going to be
648 // null and the children will be added to the scope DIE.
649 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
650 ChildrenCreated = true;
652 // There is no need to emit empty lexical block DIE.
653 std::pair<ImportedEntityMap::const_iterator,
654 ImportedEntityMap::const_iterator> Range =
656 ScopesWithImportedEntities.begin(),
657 ScopesWithImportedEntities.end(),
658 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
660 if (Children.empty() && Range.first == Range.second)
662 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
663 assert(ScopeDIE && "Scope DIE should not be null.");
664 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
666 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
670 assert(Children.empty() &&
671 "We create children only when the scope DIE is not null.");
674 if (!ChildrenCreated)
675 // We create children when the scope DIE is not null.
676 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
679 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
682 ScopeDIE->addChild(*I);
684 if (DS.isSubprogram() && ObjectPointer != NULL)
685 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
690 // Look up the source id with the given directory and source file names.
691 // If none currently exists, create a new id and insert it in the
692 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
694 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
696 // If we print assembly, we can't separate .file entries according to
697 // compile units. Thus all files will belong to the default compile unit.
699 // FIXME: add a better feature test than hasRawTextSupport. Even better,
700 // extend .file to support this.
701 if (Asm->OutStreamer.hasRawTextSupport())
704 // If FE did not provide a file name, then assume stdin.
705 if (FileName.empty())
706 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
708 // TODO: this might not belong here. See if we can factor this better.
709 if (DirName == CompilationDir)
712 // FileIDCUMap stores the current ID for the given compile unit.
713 unsigned SrcId = FileIDCUMap[CUID] + 1;
715 // We look up the CUID/file/dir by concatenating them with a zero byte.
716 SmallString<128> NamePair;
717 NamePair += utostr(CUID);
720 NamePair += '\0'; // Zero bytes are not allowed in paths.
721 NamePair += FileName;
723 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
724 if (Ent.getValue() != SrcId)
725 return Ent.getValue();
727 FileIDCUMap[CUID] = SrcId;
728 // Print out a .file directive to specify files for .loc directives.
729 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
734 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
735 if (!GenerateGnuPubSections)
738 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
739 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
740 DwarfGnuPubNamesSectionSym);
742 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
743 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
744 DwarfGnuPubTypesSectionSym);
747 // Create new DwarfCompileUnit for the given metadata node with tag
748 // DW_TAG_compile_unit.
749 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
750 StringRef FN = DIUnit.getFilename();
751 CompilationDir = DIUnit.getDirectory();
753 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
754 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
755 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
756 InfoHolder.addUnit(NewCU);
758 FileIDCUMap[NewCU->getUniqueID()] = 0;
759 // Call this to emit a .file directive if it wasn't emitted for the source
760 // file this CU comes from yet.
761 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
763 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
764 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
765 DIUnit.getLanguage());
766 NewCU->addString(Die, dwarf::DW_AT_name, FN);
768 // Define start line table label for each Compile Unit.
769 MCSymbol *LineTableStartSym =
770 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
771 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
772 NewCU->getUniqueID());
774 // Use a single line table if we are generating assembly.
776 Asm->OutStreamer.hasRawTextSupport() || (NewCU->getUniqueID() == 0);
778 if (!useSplitDwarf()) {
779 // DW_AT_stmt_list is a offset of line number information for this
780 // compile unit in debug_line section. For split dwarf this is
781 // left in the skeleton CU and so not included.
782 // The line table entries are not always emitted in assembly, so it
783 // is not okay to use line_table_start here.
784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
785 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
786 UseTheFirstCU ? DwarfLineSectionSym
787 : LineTableStartSym);
788 else if (UseTheFirstCU)
789 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
791 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
792 DwarfLineSectionSym);
794 // If we're using split dwarf the compilation dir is going to be in the
795 // skeleton CU and so we don't need to duplicate it here.
796 if (!CompilationDir.empty())
797 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
799 addGnuPubAttributes(NewCU, Die);
802 if (DIUnit.isOptimized())
803 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
805 StringRef Flags = DIUnit.getFlags();
807 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
809 if (unsigned RVer = DIUnit.getRunTimeVersion())
810 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
811 dwarf::DW_FORM_data1, RVer);
816 if (useSplitDwarf()) {
817 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
818 DwarfInfoDWOSectionSym);
819 NewCU->setSkeleton(constructSkeletonCU(NewCU));
821 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
822 DwarfInfoSectionSym);
824 CUMap.insert(std::make_pair(DIUnit, NewCU));
825 CUDieMap.insert(std::make_pair(Die, NewCU));
829 // Construct subprogram DIE.
830 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
832 // FIXME: We should only call this routine once, however, during LTO if a
833 // program is defined in multiple CUs we could end up calling it out of
834 // beginModule as we walk the CUs.
836 DwarfCompileUnit *&CURef = SPMap[N];
842 if (!SP.isDefinition())
843 // This is a method declaration which will be handled while constructing
847 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
849 // Expose as a global name.
850 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
853 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
855 DIImportedEntity Module(N);
856 assert(Module.Verify());
857 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
858 constructImportedEntityDIE(TheCU, Module, D);
861 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
862 const MDNode *N, DIE *Context) {
863 DIImportedEntity Module(N);
864 assert(Module.Verify());
865 return constructImportedEntityDIE(TheCU, Module, Context);
868 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
869 const DIImportedEntity &Module,
871 assert(Module.Verify() &&
872 "Use one of the MDNode * overloads to handle invalid metadata");
873 assert(Context && "Should always have a context for an imported_module");
874 DIE *IMDie = new DIE(Module.getTag());
875 TheCU->insertDIE(Module, IMDie);
877 DIDescriptor Entity = Module.getEntity();
878 if (Entity.isNameSpace())
879 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
880 else if (Entity.isSubprogram())
881 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
882 else if (Entity.isType())
883 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
885 EntityDie = TheCU->getDIE(Entity);
886 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
887 Module.getContext().getDirectory(),
888 TheCU->getUniqueID());
889 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
890 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
891 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
892 StringRef Name = Module.getName();
894 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
895 Context->addChild(IMDie);
898 // Emit all Dwarf sections that should come prior to the content. Create
899 // global DIEs and emit initial debug info sections. This is invoked by
900 // the target AsmPrinter.
901 void DwarfDebug::beginModule() {
902 if (DisableDebugInfoPrinting)
905 const Module *M = MMI->getModule();
907 // If module has named metadata anchors then use them, otherwise scan the
908 // module using debug info finder to collect debug info.
909 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
912 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
914 // Emit initial sections so we can reference labels later.
917 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
918 DICompileUnit CUNode(CU_Nodes->getOperand(i));
919 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
920 DIArray ImportedEntities = CUNode.getImportedEntities();
921 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
922 ScopesWithImportedEntities.push_back(std::make_pair(
923 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
924 ImportedEntities.getElement(i)));
925 std::sort(ScopesWithImportedEntities.begin(),
926 ScopesWithImportedEntities.end(), less_first());
927 DIArray GVs = CUNode.getGlobalVariables();
928 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
929 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
930 DIArray SPs = CUNode.getSubprograms();
931 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
932 constructSubprogramDIE(CU, SPs.getElement(i));
933 DIArray EnumTypes = CUNode.getEnumTypes();
934 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
935 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
936 DIArray RetainedTypes = CUNode.getRetainedTypes();
937 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
938 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
939 // Emit imported_modules last so that the relevant context is already
941 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
942 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
945 // Tell MMI that we have debug info.
946 MMI->setDebugInfoAvailability(true);
948 // Prime section data.
949 SectionMap[Asm->getObjFileLowering().getTextSection()];
952 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
953 void DwarfDebug::computeInlinedDIEs() {
954 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
955 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
956 AE = InlinedSubprogramDIEs.end();
959 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
961 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
962 AE = AbstractSPDies.end();
964 DIE *ISP = AI->second;
965 if (InlinedSubprogramDIEs.count(ISP))
967 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
971 // Collect info for variables that were optimized out.
972 void DwarfDebug::collectDeadVariables() {
973 const Module *M = MMI->getModule();
975 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
976 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
977 DICompileUnit TheCU(CU_Nodes->getOperand(i));
978 DIArray Subprograms = TheCU.getSubprograms();
979 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
980 DISubprogram SP(Subprograms.getElement(i));
981 if (ProcessedSPNodes.count(SP) != 0)
983 if (!SP.isSubprogram())
985 if (!SP.isDefinition())
987 DIArray Variables = SP.getVariables();
988 if (Variables.getNumElements() == 0)
991 // Construct subprogram DIE and add variables DIEs.
992 DwarfCompileUnit *SPCU =
993 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
994 assert(SPCU && "Unable to find Compile Unit!");
995 // FIXME: See the comment in constructSubprogramDIE about duplicate
997 constructSubprogramDIE(SPCU, SP);
998 DIE *SPDIE = SPCU->getDIE(SP);
999 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1000 DIVariable DV(Variables.getElement(vi));
1001 if (!DV.isVariable())
1003 DbgVariable NewVar(DV, NULL, this);
1004 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1005 SPDIE->addChild(VariableDIE);
1012 void DwarfDebug::finalizeModuleInfo() {
1013 // Collect info for variables that were optimized out.
1014 collectDeadVariables();
1016 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1017 computeInlinedDIEs();
1019 // Handle anything that needs to be done on a per-unit basis after
1020 // all other generation.
1021 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1022 E = getUnits().end();
1024 DwarfUnit *TheU = *I;
1025 // Emit DW_AT_containing_type attribute to connect types with their
1026 // vtable holding type.
1027 TheU->constructContainingTypeDIEs();
1029 // Add CU specific attributes if we need to add any.
1030 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1031 // If we're splitting the dwarf out now that we've got the entire
1032 // CU then add the dwo id to it.
1033 DwarfCompileUnit *SkCU =
1034 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1035 if (useSplitDwarf()) {
1036 // This should be a unique identifier when we want to build .dwp files.
1038 if (GenerateCUHash) {
1040 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1042 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1043 dwarf::DW_FORM_data8, ID);
1044 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1045 dwarf::DW_FORM_data8, ID);
1048 // If we have code split among multiple sections or we've requested
1049 // it then emit a DW_AT_ranges attribute on the unit that will remain
1050 // in the .o file, otherwise add a DW_AT_low_pc.
1051 // FIXME: Also add a high pc if we can.
1052 // FIXME: We should use ranges if we have multiple compile units or
1053 // allow reordering of code ala .subsections_via_symbols in mach-o.
1054 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1055 if (useCURanges() && TheU->getRanges().size()) {
1056 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1057 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1058 DwarfDebugRangeSectionSym);
1060 // A DW_AT_low_pc attribute may also be specified in combination with
1061 // DW_AT_ranges to specify the default base address for use in location
1062 // lists (see Section 2.6.2) and range lists (see Section 2.17.3).
1063 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1066 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1071 // Compute DIE offsets and sizes.
1072 InfoHolder.computeSizeAndOffsets();
1073 if (useSplitDwarf())
1074 SkeletonHolder.computeSizeAndOffsets();
1077 void DwarfDebug::endSections() {
1078 // Filter labels by section.
1079 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1080 const SymbolCU &SCU = ArangeLabels[n];
1081 if (SCU.Sym->isInSection()) {
1082 // Make a note of this symbol and it's section.
1083 const MCSection *Section = &SCU.Sym->getSection();
1084 if (!Section->getKind().isMetadata())
1085 SectionMap[Section].push_back(SCU);
1087 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1088 // appear in the output. This sucks as we rely on sections to build
1089 // arange spans. We can do it without, but it's icky.
1090 SectionMap[NULL].push_back(SCU);
1094 // Build a list of sections used.
1095 std::vector<const MCSection *> Sections;
1096 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1098 const MCSection *Section = it->first;
1099 Sections.push_back(Section);
1102 // Sort the sections into order.
1103 // This is only done to ensure consistent output order across different runs.
1104 std::sort(Sections.begin(), Sections.end(), SectionSort);
1106 // Add terminating symbols for each section.
1107 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1108 const MCSection *Section = Sections[ID];
1109 MCSymbol *Sym = NULL;
1112 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1113 // if we know the section name up-front. For user-created sections, the
1114 // resulting label may not be valid to use as a label. (section names can
1115 // use a greater set of characters on some systems)
1116 Sym = Asm->GetTempSymbol("debug_end", ID);
1117 Asm->OutStreamer.SwitchSection(Section);
1118 Asm->OutStreamer.EmitLabel(Sym);
1121 // Insert a final terminator.
1122 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1125 // For now only turn on CU ranges if we've explicitly asked for it,
1126 // we have -ffunction-sections enabled, we've emitted a function
1127 // into a unique section, or we're using LTO. If we're using LTO then
1128 // we can't know that any particular function in the module is correlated
1129 // to a particular CU and so we need to be conservative. At this point all
1130 // sections should be finalized except for dwarf sections.
1131 HasCURanges = DwarfCURanges || UsedNonDefaultText || (CUMap.size() > 1) ||
1132 TargetMachine::getFunctionSections();
1135 // Emit all Dwarf sections that should come after the content.
1136 void DwarfDebug::endModule() {
1143 // End any existing sections.
1144 // TODO: Does this need to happen?
1147 // Finalize the debug info for the module.
1148 finalizeModuleInfo();
1152 // Emit all the DIEs into a debug info section.
1155 // Corresponding abbreviations into a abbrev section.
1156 emitAbbreviations();
1158 // Emit info into a debug loc section.
1161 // Emit info into a debug aranges section.
1162 if (GenerateARangeSection)
1165 // Emit info into a debug ranges section.
1168 if (useSplitDwarf()) {
1171 emitDebugAbbrevDWO();
1172 // Emit DWO addresses.
1173 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1176 // Emit info into the dwarf accelerator table sections.
1177 if (useDwarfAccelTables()) {
1180 emitAccelNamespaces();
1184 // Emit the pubnames and pubtypes sections if requested.
1185 if (HasDwarfPubSections) {
1186 emitDebugPubNames(GenerateGnuPubSections);
1187 emitDebugPubTypes(GenerateGnuPubSections);
1193 // Reset these for the next Module if we have one.
1197 // Find abstract variable, if any, associated with Var.
1198 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1199 DebugLoc ScopeLoc) {
1200 LLVMContext &Ctx = DV->getContext();
1201 // More then one inlined variable corresponds to one abstract variable.
1202 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1203 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1205 return AbsDbgVariable;
1207 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1211 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1212 addScopeVariable(Scope, AbsDbgVariable);
1213 AbstractVariables[Var] = AbsDbgVariable;
1214 return AbsDbgVariable;
1217 // If Var is a current function argument then add it to CurrentFnArguments list.
1218 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1219 if (!LScopes.isCurrentFunctionScope(Scope))
1221 DIVariable DV = Var->getVariable();
1222 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1224 unsigned ArgNo = DV.getArgNumber();
1228 size_t Size = CurrentFnArguments.size();
1230 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1231 // llvm::Function argument size is not good indicator of how many
1232 // arguments does the function have at source level.
1234 CurrentFnArguments.resize(ArgNo * 2);
1235 CurrentFnArguments[ArgNo - 1] = Var;
1239 // Collect variable information from side table maintained by MMI.
1240 void DwarfDebug::collectVariableInfoFromMMITable(
1241 SmallPtrSet<const MDNode *, 16> &Processed) {
1242 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1243 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1246 const MDNode *Var = VI->first;
1249 Processed.insert(Var);
1251 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1253 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1255 // If variable scope is not found then skip this variable.
1259 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1260 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1261 RegVar->setFrameIndex(VP.first);
1262 if (!addCurrentFnArgument(RegVar, Scope))
1263 addScopeVariable(Scope, RegVar);
1265 AbsDbgVariable->setFrameIndex(VP.first);
1269 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1271 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1272 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1273 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1274 MI->getOperand(0).getReg() &&
1275 (MI->getOperand(1).isImm() ||
1276 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1279 // Get .debug_loc entry for the instruction range starting at MI.
1280 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1281 const MCSymbol *FLabel,
1282 const MCSymbol *SLabel,
1283 const MachineInstr *MI) {
1284 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1286 assert(MI->getNumOperands() == 3);
1287 if (MI->getOperand(0).isReg()) {
1288 MachineLocation MLoc;
1289 // If the second operand is an immediate, this is a
1290 // register-indirect address.
1291 if (!MI->getOperand(1).isImm())
1292 MLoc.set(MI->getOperand(0).getReg());
1294 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1295 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1297 if (MI->getOperand(0).isImm())
1298 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1299 if (MI->getOperand(0).isFPImm())
1300 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1301 if (MI->getOperand(0).isCImm())
1302 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1304 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1307 // Find variables for each lexical scope.
1309 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1311 // Grab the variable info that was squirreled away in the MMI side-table.
1312 collectVariableInfoFromMMITable(Processed);
1314 for (SmallVectorImpl<const MDNode *>::const_iterator
1315 UVI = UserVariables.begin(),
1316 UVE = UserVariables.end();
1317 UVI != UVE; ++UVI) {
1318 const MDNode *Var = *UVI;
1319 if (Processed.count(Var))
1322 // History contains relevant DBG_VALUE instructions for Var and instructions
1324 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1325 if (History.empty())
1327 const MachineInstr *MInsn = History.front();
1330 LexicalScope *Scope = NULL;
1331 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1332 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1333 Scope = LScopes.getCurrentFunctionScope();
1334 else if (MDNode *IA = DV.getInlinedAt())
1335 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1337 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1338 // If variable scope is not found then skip this variable.
1342 Processed.insert(DV);
1343 assert(MInsn->isDebugValue() && "History must begin with debug value");
1344 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1345 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1346 if (!addCurrentFnArgument(RegVar, Scope))
1347 addScopeVariable(Scope, RegVar);
1349 AbsVar->setMInsn(MInsn);
1351 // Simplify ranges that are fully coalesced.
1352 if (History.size() <= 1 ||
1353 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1354 RegVar->setMInsn(MInsn);
1358 // Handle multiple DBG_VALUE instructions describing one variable.
1359 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1361 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1362 HI = History.begin(),
1365 const MachineInstr *Begin = *HI;
1366 assert(Begin->isDebugValue() && "Invalid History entry");
1368 // Check if DBG_VALUE is truncating a range.
1369 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1370 !Begin->getOperand(0).getReg())
1373 // Compute the range for a register location.
1374 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1375 const MCSymbol *SLabel = 0;
1378 // If Begin is the last instruction in History then its value is valid
1379 // until the end of the function.
1380 SLabel = FunctionEndSym;
1382 const MachineInstr *End = HI[1];
1383 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1384 << "\t" << *Begin << "\t" << *End << "\n");
1385 if (End->isDebugValue())
1386 SLabel = getLabelBeforeInsn(End);
1388 // End is a normal instruction clobbering the range.
1389 SLabel = getLabelAfterInsn(End);
1390 assert(SLabel && "Forgot label after clobber instruction");
1395 // The value is valid until the next DBG_VALUE or clobber.
1396 DotDebugLocEntries.push_back(
1397 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1399 DotDebugLocEntries.push_back(DotDebugLocEntry());
1402 // Collect info for variables that were optimized out.
1403 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1404 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1405 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1406 DIVariable DV(Variables.getElement(i));
1407 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1409 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1410 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1414 // Return Label preceding the instruction.
1415 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1416 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1417 assert(Label && "Didn't insert label before instruction");
1421 // Return Label immediately following the instruction.
1422 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1423 return LabelsAfterInsn.lookup(MI);
1426 // Process beginning of an instruction.
1427 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1430 // Check if source location changes, but ignore DBG_VALUE locations.
1431 if (!MI->isDebugValue()) {
1432 DebugLoc DL = MI->getDebugLoc();
1433 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1436 if (DL == PrologEndLoc) {
1437 Flags |= DWARF2_FLAG_PROLOGUE_END;
1438 PrologEndLoc = DebugLoc();
1440 if (PrologEndLoc.isUnknown())
1441 Flags |= DWARF2_FLAG_IS_STMT;
1443 if (!DL.isUnknown()) {
1444 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1445 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1447 recordSourceLine(0, 0, 0, 0);
1451 // Insert labels where requested.
1452 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1453 LabelsBeforeInsn.find(MI);
1456 if (I == LabelsBeforeInsn.end())
1459 // Label already assigned.
1464 PrevLabel = MMI->getContext().CreateTempSymbol();
1465 Asm->OutStreamer.EmitLabel(PrevLabel);
1467 I->second = PrevLabel;
1470 // Process end of an instruction.
1471 void DwarfDebug::endInstruction() {
1473 // Don't create a new label after DBG_VALUE instructions.
1474 // They don't generate code.
1475 if (!CurMI->isDebugValue())
1478 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1479 LabelsAfterInsn.find(CurMI);
1483 if (I == LabelsAfterInsn.end())
1486 // Label already assigned.
1490 // We need a label after this instruction.
1492 PrevLabel = MMI->getContext().CreateTempSymbol();
1493 Asm->OutStreamer.EmitLabel(PrevLabel);
1495 I->second = PrevLabel;
1498 // Each LexicalScope has first instruction and last instruction to mark
1499 // beginning and end of a scope respectively. Create an inverse map that list
1500 // scopes starts (and ends) with an instruction. One instruction may start (or
1501 // end) multiple scopes. Ignore scopes that are not reachable.
1502 void DwarfDebug::identifyScopeMarkers() {
1503 SmallVector<LexicalScope *, 4> WorkList;
1504 WorkList.push_back(LScopes.getCurrentFunctionScope());
1505 while (!WorkList.empty()) {
1506 LexicalScope *S = WorkList.pop_back_val();
1508 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1509 if (!Children.empty())
1510 for (SmallVectorImpl<LexicalScope *>::const_iterator
1511 SI = Children.begin(),
1512 SE = Children.end();
1514 WorkList.push_back(*SI);
1516 if (S->isAbstractScope())
1519 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1522 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1525 assert(RI->first && "InsnRange does not have first instruction!");
1526 assert(RI->second && "InsnRange does not have second instruction!");
1527 requestLabelBeforeInsn(RI->first);
1528 requestLabelAfterInsn(RI->second);
1533 // Gather pre-function debug information. Assumes being called immediately
1534 // after the function entry point has been emitted.
1535 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1538 // If there's no debug info for the function we're not going to do anything.
1539 if (!MMI->hasDebugInfo())
1542 // Grab the lexical scopes for the function, if we don't have any of those
1543 // then we're not going to be able to do anything.
1544 LScopes.initialize(*MF);
1545 if (LScopes.empty())
1548 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1550 // Make sure that each lexical scope will have a begin/end label.
1551 identifyScopeMarkers();
1553 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1554 // belongs to so that we add to the correct per-cu line table in the
1556 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1557 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1558 assert(TheCU && "Unable to find compile unit!");
1559 if (Asm->OutStreamer.hasRawTextSupport())
1560 // Use a single line table if we are generating assembly.
1561 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1563 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1565 // Check the current section against the standard text section. If different
1566 // keep track so that we will know when we're emitting functions into multiple
1568 if (Asm->getObjFileLowering().getTextSection() != Asm->getCurrentSection())
1569 UsedNonDefaultText = true;
1571 // Emit a label for the function so that we have a beginning address.
1572 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1573 // Assumes in correct section after the entry point.
1574 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1576 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1577 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1578 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1580 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1582 bool AtBlockEntry = true;
1583 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1585 const MachineInstr *MI = II;
1587 if (MI->isDebugValue()) {
1588 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1590 // Keep track of user variables.
1592 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1594 // Variable is in a register, we need to check for clobbers.
1595 if (isDbgValueInDefinedReg(MI))
1596 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1598 // Check the history of this variable.
1599 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1600 if (History.empty()) {
1601 UserVariables.push_back(Var);
1602 // The first mention of a function argument gets the FunctionBeginSym
1603 // label, so arguments are visible when breaking at function entry.
1605 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1606 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1607 LabelsBeforeInsn[MI] = FunctionBeginSym;
1609 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1610 const MachineInstr *Prev = History.back();
1611 if (Prev->isDebugValue()) {
1612 // Coalesce identical entries at the end of History.
1613 if (History.size() >= 2 &&
1614 Prev->isIdenticalTo(History[History.size() - 2])) {
1615 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1616 << "\t" << *Prev << "\t"
1617 << *History[History.size() - 2] << "\n");
1621 // Terminate old register assignments that don't reach MI;
1622 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1623 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1624 isDbgValueInDefinedReg(Prev)) {
1625 // Previous register assignment needs to terminate at the end of
1627 MachineBasicBlock::const_iterator LastMI =
1628 PrevMBB->getLastNonDebugInstr();
1629 if (LastMI == PrevMBB->end()) {
1630 // Drop DBG_VALUE for empty range.
1631 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1632 << "\t" << *Prev << "\n");
1634 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1635 // Terminate after LastMI.
1636 History.push_back(LastMI);
1640 History.push_back(MI);
1642 // Not a DBG_VALUE instruction.
1644 AtBlockEntry = false;
1646 // First known non-DBG_VALUE and non-frame setup location marks
1647 // the beginning of the function body.
1648 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1649 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1650 PrologEndLoc = MI->getDebugLoc();
1652 // Check if the instruction clobbers any registers with debug vars.
1653 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1654 MOE = MI->operands_end();
1655 MOI != MOE; ++MOI) {
1656 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1658 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1661 const MDNode *Var = LiveUserVar[Reg];
1664 // Reg is now clobbered.
1665 LiveUserVar[Reg] = 0;
1667 // Was MD last defined by a DBG_VALUE referring to Reg?
1668 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1669 if (HistI == DbgValues.end())
1671 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1672 if (History.empty())
1674 const MachineInstr *Prev = History.back();
1675 // Sanity-check: Register assignments are terminated at the end of
1677 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1679 // Is the variable still in Reg?
1680 if (!isDbgValueInDefinedReg(Prev) ||
1681 Prev->getOperand(0).getReg() != Reg)
1683 // Var is clobbered. Make sure the next instruction gets a label.
1684 History.push_back(MI);
1691 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1693 SmallVectorImpl<const MachineInstr *> &History = I->second;
1694 if (History.empty())
1697 // Make sure the final register assignments are terminated.
1698 const MachineInstr *Prev = History.back();
1699 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1700 const MachineBasicBlock *PrevMBB = Prev->getParent();
1701 MachineBasicBlock::const_iterator LastMI =
1702 PrevMBB->getLastNonDebugInstr();
1703 if (LastMI == PrevMBB->end())
1704 // Drop DBG_VALUE for empty range.
1706 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1707 // Terminate after LastMI.
1708 History.push_back(LastMI);
1711 // Request labels for the full history.
1712 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1713 const MachineInstr *MI = History[i];
1714 if (MI->isDebugValue())
1715 requestLabelBeforeInsn(MI);
1717 requestLabelAfterInsn(MI);
1721 PrevInstLoc = DebugLoc();
1722 PrevLabel = FunctionBeginSym;
1724 // Record beginning of function.
1725 if (!PrologEndLoc.isUnknown()) {
1726 DebugLoc FnStartDL =
1727 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1729 FnStartDL.getLine(), FnStartDL.getCol(),
1730 FnStartDL.getScope(MF->getFunction()->getContext()),
1731 // We'd like to list the prologue as "not statements" but GDB behaves
1732 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1733 DWARF2_FLAG_IS_STMT);
1737 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1738 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1739 DIVariable DV = Var->getVariable();
1740 // Variables with positive arg numbers are parameters.
1741 if (unsigned ArgNum = DV.getArgNumber()) {
1742 // Keep all parameters in order at the start of the variable list to ensure
1743 // function types are correct (no out-of-order parameters)
1745 // This could be improved by only doing it for optimized builds (unoptimized
1746 // builds have the right order to begin with), searching from the back (this
1747 // would catch the unoptimized case quickly), or doing a binary search
1748 // rather than linear search.
1749 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1750 while (I != Vars.end()) {
1751 unsigned CurNum = (*I)->getVariable().getArgNumber();
1752 // A local (non-parameter) variable has been found, insert immediately
1756 // A later indexed parameter has been found, insert immediately before it.
1757 if (CurNum > ArgNum)
1761 Vars.insert(I, Var);
1765 Vars.push_back(Var);
1768 // Gather and emit post-function debug information.
1769 void DwarfDebug::endFunction(const MachineFunction *MF) {
1770 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1771 // though the beginFunction may not be called at all.
1772 // We should handle both cases.
1776 assert(CurFn == MF);
1779 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1784 // Define end label for subprogram.
1785 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1786 // Assumes in correct section after the entry point.
1787 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1789 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1790 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1792 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1793 collectVariableInfo(ProcessedVars);
1795 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1796 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1797 assert(TheCU && "Unable to find compile unit!");
1799 // Construct abstract scopes.
1800 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1801 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1802 LexicalScope *AScope = AList[i];
1803 DISubprogram SP(AScope->getScopeNode());
1804 if (SP.isSubprogram()) {
1805 // Collect info for variables that were optimized out.
1806 DIArray Variables = SP.getVariables();
1807 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1808 DIVariable DV(Variables.getElement(i));
1809 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1811 // Check that DbgVariable for DV wasn't created earlier, when
1812 // findAbstractVariable() was called for inlined instance of DV.
1813 LLVMContext &Ctx = DV->getContext();
1814 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1815 if (AbstractVariables.lookup(CleanDV))
1817 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1818 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1821 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1822 constructScopeDIE(TheCU, AScope);
1825 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1826 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1827 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1829 // Add the range of this function to the list of ranges for the CU.
1830 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1831 TheCU->addRange(llvm_move(Span));
1834 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1835 E = ScopeVariables.end();
1837 DeleteContainerPointers(I->second);
1838 ScopeVariables.clear();
1839 DeleteContainerPointers(CurrentFnArguments);
1840 UserVariables.clear();
1842 AbstractVariables.clear();
1843 LabelsBeforeInsn.clear();
1844 LabelsAfterInsn.clear();
1849 // Register a source line with debug info. Returns the unique label that was
1850 // emitted and which provides correspondence to the source line list.
1851 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1857 DIDescriptor Scope(S);
1859 if (Scope.isCompileUnit()) {
1860 DICompileUnit CU(S);
1861 Fn = CU.getFilename();
1862 Dir = CU.getDirectory();
1863 } else if (Scope.isFile()) {
1865 Fn = F.getFilename();
1866 Dir = F.getDirectory();
1867 } else if (Scope.isSubprogram()) {
1869 Fn = SP.getFilename();
1870 Dir = SP.getDirectory();
1871 } else if (Scope.isLexicalBlockFile()) {
1872 DILexicalBlockFile DBF(S);
1873 Fn = DBF.getFilename();
1874 Dir = DBF.getDirectory();
1875 } else if (Scope.isLexicalBlock()) {
1876 DILexicalBlock DB(S);
1877 Fn = DB.getFilename();
1878 Dir = DB.getDirectory();
1880 llvm_unreachable("Unexpected scope info");
1882 Src = getOrCreateSourceID(
1883 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1885 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1888 //===----------------------------------------------------------------------===//
1890 //===----------------------------------------------------------------------===//
1892 // Compute the size and offset of a DIE. The offset is relative to start of the
1893 // CU. It returns the offset after laying out the DIE.
1894 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1895 // Get the children.
1896 const std::vector<DIE *> &Children = Die->getChildren();
1898 // Record the abbreviation.
1899 assignAbbrevNumber(Die->getAbbrev());
1901 // Get the abbreviation for this DIE.
1902 const DIEAbbrev &Abbrev = Die->getAbbrev();
1905 Die->setOffset(Offset);
1907 // Start the size with the size of abbreviation code.
1908 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1910 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1911 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1913 // Size the DIE attribute values.
1914 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1915 // Size attribute value.
1916 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1918 // Size the DIE children if any.
1919 if (!Children.empty()) {
1920 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1921 "Children flag not set");
1923 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1924 Offset = computeSizeAndOffset(Children[j], Offset);
1926 // End of children marker.
1927 Offset += sizeof(int8_t);
1930 Die->setSize(Offset - Die->getOffset());
1934 // Compute the size and offset for each DIE.
1935 void DwarfFile::computeSizeAndOffsets() {
1936 // Offset from the first CU in the debug info section is 0 initially.
1937 unsigned SecOffset = 0;
1939 // Iterate over each compile unit and set the size and offsets for each
1940 // DIE within each compile unit. All offsets are CU relative.
1941 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1944 (*I)->setDebugInfoOffset(SecOffset);
1946 // CU-relative offset is reset to 0 here.
1947 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1948 (*I)->getHeaderSize(); // Unit-specific headers
1950 // EndOffset here is CU-relative, after laying out
1951 // all of the CU DIE.
1952 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1953 SecOffset += EndOffset;
1957 // Emit initial Dwarf sections with a label at the start of each one.
1958 void DwarfDebug::emitSectionLabels() {
1959 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1961 // Dwarf sections base addresses.
1962 DwarfInfoSectionSym =
1963 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1964 if (useSplitDwarf())
1965 DwarfInfoDWOSectionSym =
1966 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1967 DwarfAbbrevSectionSym =
1968 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1969 if (useSplitDwarf())
1970 DwarfAbbrevDWOSectionSym = emitSectionSym(
1971 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1972 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1974 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1975 emitSectionSym(Asm, MacroInfo);
1977 DwarfLineSectionSym =
1978 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1979 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1980 if (GenerateGnuPubSections) {
1981 DwarfGnuPubNamesSectionSym =
1982 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1983 DwarfGnuPubTypesSectionSym =
1984 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1985 } else if (HasDwarfPubSections) {
1986 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1987 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1990 DwarfStrSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1992 if (useSplitDwarf()) {
1993 DwarfStrDWOSectionSym =
1994 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1995 DwarfAddrSectionSym =
1996 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1998 DwarfDebugRangeSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2001 DwarfDebugLocSectionSym =
2002 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2005 // Recursively emits a debug information entry.
2006 void DwarfDebug::emitDIE(DIE *Die) {
2007 // Get the abbreviation for this DIE.
2008 const DIEAbbrev &Abbrev = Die->getAbbrev();
2010 // Emit the code (index) for the abbreviation.
2011 if (Asm->isVerbose())
2012 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2013 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2014 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2015 dwarf::TagString(Abbrev.getTag()));
2016 Asm->EmitULEB128(Abbrev.getNumber());
2018 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2019 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2021 // Emit the DIE attribute values.
2022 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2023 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2024 dwarf::Form Form = AbbrevData[i].getForm();
2025 assert(Form && "Too many attributes for DIE (check abbreviation)");
2027 if (Asm->isVerbose())
2028 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2031 case dwarf::DW_AT_abstract_origin:
2032 case dwarf::DW_AT_type:
2033 case dwarf::DW_AT_friend:
2034 case dwarf::DW_AT_specification:
2035 case dwarf::DW_AT_import:
2036 case dwarf::DW_AT_containing_type: {
2037 DIEEntry *E = cast<DIEEntry>(Values[i]);
2038 DIE *Origin = E->getEntry();
2039 unsigned Addr = Origin->getOffset();
2040 if (Form == dwarf::DW_FORM_ref_addr) {
2041 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2042 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2043 // section. Origin->getOffset() returns the offset from start of the
2045 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2046 assert(CU && "CUDie should belong to a CU.");
2047 Addr += CU->getDebugInfoOffset();
2048 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2049 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2050 DIEEntry::getRefAddrSize(Asm));
2052 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2053 CU->getSectionSym(),
2054 DIEEntry::getRefAddrSize(Asm));
2056 // Make sure Origin belong to the same CU.
2057 assert(Die->getUnit() == Origin->getUnit() &&
2058 "The referenced DIE should belong to the same CU in ref4");
2059 Asm->EmitInt32(Addr);
2063 case dwarf::DW_AT_location: {
2064 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2065 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2066 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2068 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2070 Values[i]->EmitValue(Asm, Form);
2074 case dwarf::DW_AT_accessibility: {
2075 if (Asm->isVerbose()) {
2076 DIEInteger *V = cast<DIEInteger>(Values[i]);
2077 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2079 Values[i]->EmitValue(Asm, Form);
2083 // Emit an attribute using the defined form.
2084 Values[i]->EmitValue(Asm, Form);
2089 // Emit the DIE children if any.
2090 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2091 const std::vector<DIE *> &Children = Die->getChildren();
2093 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2094 emitDIE(Children[j]);
2096 Asm->OutStreamer.AddComment("End Of Children Mark");
2101 // Emit the various dwarf units to the unit section USection with
2102 // the abbreviations going into ASection.
2103 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2104 const MCSymbol *ASectionSym) {
2105 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2107 DwarfUnit *TheU = *I;
2108 DIE *Die = TheU->getUnitDie();
2109 const MCSection *USection = TheU->getSection();
2110 Asm->OutStreamer.SwitchSection(USection);
2112 // Emit the compile units header.
2113 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2115 // Emit size of content not including length itself
2116 Asm->OutStreamer.AddComment("Length of Unit");
2117 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2119 TheU->emitHeader(ASection, ASectionSym);
2122 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2126 // Emit the debug info section.
2127 void DwarfDebug::emitDebugInfo() {
2128 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2130 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2131 DwarfAbbrevSectionSym);
2134 // Emit the abbreviation section.
2135 void DwarfDebug::emitAbbreviations() {
2136 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2138 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2141 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2142 // Check to see if it is worth the effort.
2143 if (!Abbreviations.empty()) {
2144 // Start the debug abbrev section.
2145 Asm->OutStreamer.SwitchSection(Section);
2147 // For each abbrevation.
2148 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2149 // Get abbreviation data
2150 const DIEAbbrev *Abbrev = Abbreviations[i];
2152 // Emit the abbrevations code (base 1 index.)
2153 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2155 // Emit the abbreviations data.
2159 // Mark end of abbreviations.
2160 Asm->EmitULEB128(0, "EOM(3)");
2164 // Emit the last address of the section and the end of the line matrix.
2165 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2166 // Define last address of section.
2167 Asm->OutStreamer.AddComment("Extended Op");
2170 Asm->OutStreamer.AddComment("Op size");
2171 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2172 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2173 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2175 Asm->OutStreamer.AddComment("Section end label");
2177 Asm->OutStreamer.EmitSymbolValue(
2178 Asm->GetTempSymbol("section_end", SectionEnd),
2179 Asm->getDataLayout().getPointerSize());
2181 // Mark end of matrix.
2182 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2188 // Emit visible names into a hashed accelerator table section.
2189 void DwarfDebug::emitAccelNames() {
2191 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2192 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2193 E = getUnits().end();
2195 DwarfUnit *TheU = *I;
2196 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2197 for (StringMap<std::vector<const DIE *> >::const_iterator
2201 StringRef Name = GI->getKey();
2202 const std::vector<const DIE *> &Entities = GI->second;
2203 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2204 DE = Entities.end();
2206 AT.AddName(Name, *DI);
2210 AT.FinalizeTable(Asm, "Names");
2211 Asm->OutStreamer.SwitchSection(
2212 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2213 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2214 Asm->OutStreamer.EmitLabel(SectionBegin);
2216 // Emit the full data.
2217 AT.Emit(Asm, SectionBegin, &InfoHolder);
2220 // Emit objective C classes and categories into a hashed accelerator table
2222 void DwarfDebug::emitAccelObjC() {
2224 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2225 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2226 E = getUnits().end();
2228 DwarfUnit *TheU = *I;
2229 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2230 for (StringMap<std::vector<const DIE *> >::const_iterator
2234 StringRef Name = GI->getKey();
2235 const std::vector<const DIE *> &Entities = GI->second;
2236 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2237 DE = Entities.end();
2239 AT.AddName(Name, *DI);
2243 AT.FinalizeTable(Asm, "ObjC");
2244 Asm->OutStreamer.SwitchSection(
2245 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2246 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2247 Asm->OutStreamer.EmitLabel(SectionBegin);
2249 // Emit the full data.
2250 AT.Emit(Asm, SectionBegin, &InfoHolder);
2253 // Emit namespace dies into a hashed accelerator table.
2254 void DwarfDebug::emitAccelNamespaces() {
2256 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2257 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2258 E = getUnits().end();
2260 DwarfUnit *TheU = *I;
2261 const StringMap<std::vector<const DIE *> > &Names =
2262 TheU->getAccelNamespace();
2263 for (StringMap<std::vector<const DIE *> >::const_iterator
2267 StringRef Name = GI->getKey();
2268 const std::vector<const DIE *> &Entities = GI->second;
2269 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2270 DE = Entities.end();
2272 AT.AddName(Name, *DI);
2276 AT.FinalizeTable(Asm, "namespac");
2277 Asm->OutStreamer.SwitchSection(
2278 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2279 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2280 Asm->OutStreamer.EmitLabel(SectionBegin);
2282 // Emit the full data.
2283 AT.Emit(Asm, SectionBegin, &InfoHolder);
2286 // Emit type dies into a hashed accelerator table.
2287 void DwarfDebug::emitAccelTypes() {
2288 std::vector<DwarfAccelTable::Atom> Atoms;
2290 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2292 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2294 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2295 DwarfAccelTable AT(Atoms);
2296 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2297 E = getUnits().end();
2299 DwarfUnit *TheU = *I;
2300 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2301 TheU->getAccelTypes();
2303 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2307 StringRef Name = GI->getKey();
2308 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2310 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2311 DI = Entities.begin(),
2312 DE = Entities.end();
2314 AT.AddName(Name, DI->first, DI->second);
2318 AT.FinalizeTable(Asm, "types");
2319 Asm->OutStreamer.SwitchSection(
2320 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2321 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2322 Asm->OutStreamer.EmitLabel(SectionBegin);
2324 // Emit the full data.
2325 AT.Emit(Asm, SectionBegin, &InfoHolder);
2328 // Public name handling.
2329 // The format for the various pubnames:
2331 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2332 // for the DIE that is named.
2334 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2335 // into the CU and the index value is computed according to the type of value
2336 // for the DIE that is named.
2338 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2339 // it's the offset within the debug_info/debug_types dwo section, however, the
2340 // reference in the pubname header doesn't change.
2342 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2343 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2345 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2347 // We could have a specification DIE that has our most of our knowledge,
2348 // look for that now.
2349 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2351 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2352 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2353 Linkage = dwarf::GIEL_EXTERNAL;
2354 } else if (Die->findAttribute(dwarf::DW_AT_external))
2355 Linkage = dwarf::GIEL_EXTERNAL;
2357 switch (Die->getTag()) {
2358 case dwarf::DW_TAG_class_type:
2359 case dwarf::DW_TAG_structure_type:
2360 case dwarf::DW_TAG_union_type:
2361 case dwarf::DW_TAG_enumeration_type:
2362 return dwarf::PubIndexEntryDescriptor(
2363 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2364 ? dwarf::GIEL_STATIC
2365 : dwarf::GIEL_EXTERNAL);
2366 case dwarf::DW_TAG_typedef:
2367 case dwarf::DW_TAG_base_type:
2368 case dwarf::DW_TAG_subrange_type:
2369 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2370 case dwarf::DW_TAG_namespace:
2371 return dwarf::GIEK_TYPE;
2372 case dwarf::DW_TAG_subprogram:
2373 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2374 case dwarf::DW_TAG_constant:
2375 case dwarf::DW_TAG_variable:
2376 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2377 case dwarf::DW_TAG_enumerator:
2378 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2379 dwarf::GIEL_STATIC);
2381 return dwarf::GIEK_NONE;
2385 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2387 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2388 const MCSection *PSec =
2389 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2390 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2392 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2393 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2394 for (unsigned i = 0; i != Units.size(); ++i) {
2395 DwarfUnit *TheU = Units[i];
2396 unsigned ID = TheU->getUniqueID();
2398 // Start the dwarf pubnames section.
2399 Asm->OutStreamer.SwitchSection(PSec);
2401 // Emit a label so we can reference the beginning of this pubname section.
2403 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2406 Asm->OutStreamer.AddComment("Length of Public Names Info");
2407 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2408 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2409 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2411 Asm->OutStreamer.EmitLabel(BeginLabel);
2413 Asm->OutStreamer.AddComment("DWARF Version");
2414 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2416 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2417 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2419 Asm->OutStreamer.AddComment("Compilation Unit Length");
2420 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2422 // Emit the pubnames for this compilation unit.
2423 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2424 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2427 const char *Name = GI->getKeyData();
2428 const DIE *Entity = GI->second;
2430 Asm->OutStreamer.AddComment("DIE offset");
2431 Asm->EmitInt32(Entity->getOffset());
2434 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2435 Asm->OutStreamer.AddComment(
2436 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2437 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2438 Asm->EmitInt8(Desc.toBits());
2441 Asm->OutStreamer.AddComment("External Name");
2442 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2445 Asm->OutStreamer.AddComment("End Mark");
2447 Asm->OutStreamer.EmitLabel(EndLabel);
2451 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2452 const MCSection *PSec =
2453 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2454 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2456 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2457 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2458 for (unsigned i = 0; i != Units.size(); ++i) {
2459 DwarfUnit *TheU = Units[i];
2460 unsigned ID = TheU->getUniqueID();
2462 // Start the dwarf pubtypes section.
2463 Asm->OutStreamer.SwitchSection(PSec);
2465 // Emit a label so we can reference the beginning of this pubtype section.
2467 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2470 Asm->OutStreamer.AddComment("Length of Public Types Info");
2471 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2472 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2473 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2475 Asm->OutStreamer.EmitLabel(BeginLabel);
2477 Asm->OutStreamer.AddComment("DWARF Version");
2478 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2480 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2481 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2483 Asm->OutStreamer.AddComment("Compilation Unit Length");
2484 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2486 // Emit the pubtypes.
2487 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2488 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2491 const char *Name = GI->getKeyData();
2492 const DIE *Entity = GI->second;
2494 Asm->OutStreamer.AddComment("DIE offset");
2495 Asm->EmitInt32(Entity->getOffset());
2498 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2499 Asm->OutStreamer.AddComment(
2500 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2501 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2502 Asm->EmitInt8(Desc.toBits());
2505 Asm->OutStreamer.AddComment("External Name");
2507 // Emit the name with a terminating null byte.
2508 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2511 Asm->OutStreamer.AddComment("End Mark");
2513 Asm->OutStreamer.EmitLabel(EndLabel);
2517 // Emit strings into a string section.
2518 void DwarfFile::emitStrings(const MCSection *StrSection,
2519 const MCSection *OffsetSection = NULL,
2520 const MCSymbol *StrSecSym = NULL) {
2522 if (StringPool.empty())
2525 // Start the dwarf str section.
2526 Asm->OutStreamer.SwitchSection(StrSection);
2528 // Get all of the string pool entries and put them in an array by their ID so
2529 // we can sort them.
2531 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2534 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2535 I = StringPool.begin(),
2536 E = StringPool.end();
2538 Entries.push_back(std::make_pair(I->second.second, &*I));
2540 array_pod_sort(Entries.begin(), Entries.end());
2542 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2543 // Emit a label for reference from debug information entries.
2544 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2546 // Emit the string itself with a terminating null byte.
2547 Asm->OutStreamer.EmitBytes(
2548 StringRef(Entries[i].second->getKeyData(),
2549 Entries[i].second->getKeyLength() + 1));
2552 // If we've got an offset section go ahead and emit that now as well.
2553 if (OffsetSection) {
2554 Asm->OutStreamer.SwitchSection(OffsetSection);
2555 unsigned offset = 0;
2556 unsigned size = 4; // FIXME: DWARF64 is 8.
2557 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2558 Asm->OutStreamer.EmitIntValue(offset, size);
2559 offset += Entries[i].second->getKeyLength() + 1;
2564 // Emit addresses into the section given.
2565 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2567 if (AddressPool.empty())
2570 // Start the dwarf addr section.
2571 Asm->OutStreamer.SwitchSection(AddrSection);
2573 // Order the address pool entries by ID
2574 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2576 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2577 E = AddressPool.end();
2579 Entries[I->second] = I->first;
2581 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2582 // Emit an expression for reference from debug information entries.
2583 if (const MCExpr *Expr = Entries[i])
2584 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2586 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2590 // Emit visible names into a debug str section.
2591 void DwarfDebug::emitDebugStr() {
2592 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2593 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2596 // Emit locations into the debug loc section.
2597 void DwarfDebug::emitDebugLoc() {
2598 if (DotDebugLocEntries.empty())
2601 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2602 I = DotDebugLocEntries.begin(),
2603 E = DotDebugLocEntries.end();
2605 DotDebugLocEntry &Entry = *I;
2606 if (I + 1 != DotDebugLocEntries.end())
2610 // Start the dwarf loc section.
2611 Asm->OutStreamer.SwitchSection(
2612 Asm->getObjFileLowering().getDwarfLocSection());
2613 unsigned char Size = Asm->getDataLayout().getPointerSize();
2614 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2616 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2617 I = DotDebugLocEntries.begin(),
2618 E = DotDebugLocEntries.end();
2619 I != E; ++I, ++index) {
2620 DotDebugLocEntry &Entry = *I;
2621 if (Entry.isMerged())
2623 if (Entry.isEmpty()) {
2624 Asm->OutStreamer.EmitIntValue(0, Size);
2625 Asm->OutStreamer.EmitIntValue(0, Size);
2626 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2628 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2629 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2630 DIVariable DV(Entry.getVariable());
2631 Asm->OutStreamer.AddComment("Loc expr size");
2632 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2633 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2634 Asm->EmitLabelDifference(end, begin, 2);
2635 Asm->OutStreamer.EmitLabel(begin);
2636 if (Entry.isInt()) {
2637 DIBasicType BTy(DV.getType());
2638 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2639 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2640 Asm->OutStreamer.AddComment("DW_OP_consts");
2641 Asm->EmitInt8(dwarf::DW_OP_consts);
2642 Asm->EmitSLEB128(Entry.getInt());
2644 Asm->OutStreamer.AddComment("DW_OP_constu");
2645 Asm->EmitInt8(dwarf::DW_OP_constu);
2646 Asm->EmitULEB128(Entry.getInt());
2648 } else if (Entry.isLocation()) {
2649 MachineLocation Loc = Entry.getLoc();
2650 if (!DV.hasComplexAddress())
2652 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2654 // Complex address entry.
2655 unsigned N = DV.getNumAddrElements();
2657 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2658 if (Loc.getOffset()) {
2660 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2661 Asm->OutStreamer.AddComment("DW_OP_deref");
2662 Asm->EmitInt8(dwarf::DW_OP_deref);
2663 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2664 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2665 Asm->EmitSLEB128(DV.getAddrElement(1));
2667 // If first address element is OpPlus then emit
2668 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2669 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2670 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2674 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2677 // Emit remaining complex address elements.
2678 for (; i < N; ++i) {
2679 uint64_t Element = DV.getAddrElement(i);
2680 if (Element == DIBuilder::OpPlus) {
2681 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2682 Asm->EmitULEB128(DV.getAddrElement(++i));
2683 } else if (Element == DIBuilder::OpDeref) {
2685 Asm->EmitInt8(dwarf::DW_OP_deref);
2687 llvm_unreachable("unknown Opcode found in complex address");
2691 // else ... ignore constant fp. There is not any good way to
2692 // to represent them here in dwarf.
2693 Asm->OutStreamer.EmitLabel(end);
2698 struct SymbolCUSorter {
2699 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2700 const MCStreamer &Streamer;
2702 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2703 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2704 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2706 // Symbols with no order assigned should be placed at the end.
2707 // (e.g. section end labels)
2709 IA = (unsigned)(-1);
2711 IB = (unsigned)(-1);
2716 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2717 return (A->getUniqueID() < B->getUniqueID());
2721 const MCSymbol *Start, *End;
2724 // Emit a debug aranges section, containing a CU lookup for any
2725 // address we can tie back to a CU.
2726 void DwarfDebug::emitDebugARanges() {
2727 // Start the dwarf aranges section.
2728 Asm->OutStreamer.SwitchSection(
2729 Asm->getObjFileLowering().getDwarfARangesSection());
2731 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2735 // Build a list of sections used.
2736 std::vector<const MCSection *> Sections;
2737 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2739 const MCSection *Section = it->first;
2740 Sections.push_back(Section);
2743 // Sort the sections into order.
2744 // This is only done to ensure consistent output order across different runs.
2745 std::sort(Sections.begin(), Sections.end(), SectionSort);
2747 // Build a set of address spans, sorted by CU.
2748 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2749 const MCSection *Section = Sections[SecIdx];
2750 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2751 if (List.size() < 2)
2754 // Sort the symbols by offset within the section.
2755 SymbolCUSorter sorter(Asm->OutStreamer);
2756 std::sort(List.begin(), List.end(), sorter);
2758 // If we have no section (e.g. common), just write out
2759 // individual spans for each symbol.
2760 if (Section == NULL) {
2761 for (size_t n = 0; n < List.size(); n++) {
2762 const SymbolCU &Cur = List[n];
2765 Span.Start = Cur.Sym;
2768 Spans[Cur.CU].push_back(Span);
2771 // Build spans between each label.
2772 const MCSymbol *StartSym = List[0].Sym;
2773 for (size_t n = 1; n < List.size(); n++) {
2774 const SymbolCU &Prev = List[n - 1];
2775 const SymbolCU &Cur = List[n];
2777 // Try and build the longest span we can within the same CU.
2778 if (Cur.CU != Prev.CU) {
2780 Span.Start = StartSym;
2782 Spans[Prev.CU].push_back(Span);
2789 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2791 // Build a list of CUs used.
2792 std::vector<DwarfCompileUnit *> CUs;
2793 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2794 DwarfCompileUnit *CU = it->first;
2798 // Sort the CU list (again, to ensure consistent output order).
2799 std::sort(CUs.begin(), CUs.end(), CUSort);
2801 // Emit an arange table for each CU we used.
2802 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2803 DwarfCompileUnit *CU = CUs[CUIdx];
2804 std::vector<ArangeSpan> &List = Spans[CU];
2806 // Emit size of content not including length itself.
2807 unsigned ContentSize =
2808 sizeof(int16_t) + // DWARF ARange version number
2809 sizeof(int32_t) + // Offset of CU in the .debug_info section
2810 sizeof(int8_t) + // Pointer Size (in bytes)
2811 sizeof(int8_t); // Segment Size (in bytes)
2813 unsigned TupleSize = PtrSize * 2;
2815 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2817 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2819 ContentSize += Padding;
2820 ContentSize += (List.size() + 1) * TupleSize;
2822 // For each compile unit, write the list of spans it covers.
2823 Asm->OutStreamer.AddComment("Length of ARange Set");
2824 Asm->EmitInt32(ContentSize);
2825 Asm->OutStreamer.AddComment("DWARF Arange version number");
2826 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2827 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2828 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2829 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2830 Asm->EmitInt8(PtrSize);
2831 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2834 Asm->OutStreamer.EmitFill(Padding, 0xff);
2836 for (unsigned n = 0; n < List.size(); n++) {
2837 const ArangeSpan &Span = List[n];
2838 Asm->EmitLabelReference(Span.Start, PtrSize);
2840 // Calculate the size as being from the span start to it's end.
2842 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2844 // For symbols without an end marker (e.g. common), we
2845 // write a single arange entry containing just that one symbol.
2846 uint64_t Size = SymSize[Span.Start];
2850 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2854 Asm->OutStreamer.AddComment("ARange terminator");
2855 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2856 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2860 // Emit visible names into a debug ranges section.
2861 void DwarfDebug::emitDebugRanges() {
2862 // Start the dwarf ranges section.
2863 Asm->OutStreamer.SwitchSection(
2864 Asm->getObjFileLowering().getDwarfRangesSection());
2866 // Size for our labels.
2867 unsigned char Size = Asm->getDataLayout().getPointerSize();
2869 // Grab the specific ranges for the compile units in the module.
2870 for (MapVector<const MDNode *, DwarfCompileUnit *>::iterator
2874 DwarfCompileUnit *TheCU = I->second;
2876 // Emit a symbol so we can find the beginning of our ranges.
2877 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2879 // Iterate over the misc ranges for the compile units in the module.
2880 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2881 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2882 E = RangeLists.end();
2884 const RangeSpanList &List = *I;
2886 // Emit our symbol so we can find the beginning of the range.
2887 Asm->OutStreamer.EmitLabel(List.getSym());
2889 for (SmallVectorImpl<RangeSpan>::const_iterator
2890 RI = List.getRanges().begin(),
2891 RE = List.getRanges().end();
2893 const RangeSpan &Range = *RI;
2894 const MCSymbol *Begin = Range.getStart();
2895 const MCSymbol *End = Range.getEnd();
2896 assert(Begin && "Range without a begin symbol?");
2897 assert(End && "Range without an end symbol?");
2898 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2899 Asm->OutStreamer.EmitSymbolValue(End, Size);
2902 // And terminate the list with two 0 values.
2903 Asm->OutStreamer.EmitIntValue(0, Size);
2904 Asm->OutStreamer.EmitIntValue(0, Size);
2907 // Now emit a range for the CU itself.
2908 if (useCURanges()) {
2909 Asm->OutStreamer.EmitLabel(
2910 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2911 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2912 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2913 RangeSpan Range = Ranges[i];
2914 const MCSymbol *Begin = Range.getStart();
2915 const MCSymbol *End = Range.getEnd();
2916 assert(Begin && "Range without a begin symbol?");
2917 assert(End && "Range without an end symbol?");
2918 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2919 Asm->OutStreamer.EmitSymbolValue(End, Size);
2921 // And terminate the list with two 0 values.
2922 Asm->OutStreamer.EmitIntValue(0, Size);
2923 Asm->OutStreamer.EmitIntValue(0, Size);
2928 // DWARF5 Experimental Separate Dwarf emitters.
2930 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2932 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2933 U->getCUNode().getSplitDebugFilename());
2935 // Relocate to the beginning of the addr_base section, else 0 for the
2936 // beginning of the one for this compile unit.
2937 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2938 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2940 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2942 if (!CompilationDir.empty())
2943 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2945 addGnuPubAttributes(NewU, Die);
2947 SkeletonHolder.addUnit(NewU);
2950 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2951 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2952 // DW_AT_ranges_base, DW_AT_addr_base.
2953 // TODO: Implement DW_AT_ranges_base.
2954 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2956 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2957 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2958 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2959 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2960 DwarfInfoSectionSym);
2962 // DW_AT_stmt_list is a offset of line number information for this
2963 // compile unit in debug_line section.
2964 // FIXME: Should handle multiple compile units.
2965 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2966 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
2968 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2970 initSkeletonUnit(CU, Die, NewCU);
2975 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2977 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(DwarfTypeUnit *TU) {
2979 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2980 DwarfTypeUnit *NewTU = new DwarfTypeUnit(TU->getUniqueID(), Die, TU->getCU(),
2981 Asm, this, &SkeletonHolder);
2982 NewTU->setTypeSignature(TU->getTypeSignature());
2983 NewTU->setType(NULL);
2985 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2987 initSkeletonUnit(TU, Die, NewTU);
2991 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2992 // compile units that would normally be in debug_info.
2993 void DwarfDebug::emitDebugInfoDWO() {
2994 assert(useSplitDwarf() && "No split dwarf debug info?");
2995 InfoHolder.emitUnits(this,
2996 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2997 DwarfAbbrevDWOSectionSym);
3000 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3001 // abbreviations for the .debug_info.dwo section.
3002 void DwarfDebug::emitDebugAbbrevDWO() {
3003 assert(useSplitDwarf() && "No split dwarf?");
3004 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3007 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3008 // string section and is identical in format to traditional .debug_str
3010 void DwarfDebug::emitDebugStrDWO() {
3011 assert(useSplitDwarf() && "No split dwarf?");
3012 const MCSection *OffSec =
3013 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3014 const MCSymbol *StrSym = DwarfStrSectionSym;
3015 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3019 void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
3020 StringRef Identifier, DIE *RefDie,
3021 DICompositeType CTy) {
3022 // Flag the type unit reference as a declaration so that if it contains
3023 // members (implicit special members, static data member definitions, member
3024 // declarations for definitions in this CU, etc) consumers don't get confused
3025 // and think this is a full definition.
3026 CU.addFlag(RefDie, dwarf::DW_AT_declaration);
3028 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3030 CU.addDIETypeSignature(RefDie, *TU);
3034 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3035 DwarfTypeUnit *NewTU = new DwarfTypeUnit(InfoHolder.getUnits().size(),
3036 UnitDie, CU, Asm, this, &InfoHolder);
3038 InfoHolder.addUnit(NewTU);
3040 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3044 Hash.update(Identifier);
3045 // ... take the least significant 8 bytes and return those. Our MD5
3046 // implementation always returns its results in little endian, swap bytes
3048 MD5::MD5Result Result;
3050 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
3051 NewTU->setTypeSignature(Signature);
3052 if (useSplitDwarf())
3053 NewTU->setSkeleton(constructSkeletonTU(NewTU));
3055 NewTU->setType(NewTU->createTypeDIE(CTy));
3059 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3060 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3062 CU.addDIETypeSignature(RefDie, *NewTU);