1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
61 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
62 cl::desc("Add the CU hash as the dwo_id."),
66 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
67 cl::desc("Generate GNU-style pubnames and pubtypes"),
71 enum DefaultOnOff { Default, Enable, Disable };
74 static cl::opt<DefaultOnOff>
75 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
76 cl::desc("Output prototype dwarf accelerator tables."),
77 cl::values(clEnumVal(Default, "Default for platform"),
78 clEnumVal(Enable, "Enabled"),
79 clEnumVal(Disable, "Disabled"), clEnumValEnd),
82 static cl::opt<DefaultOnOff>
83 SplitDwarf("split-dwarf", cl::Hidden,
84 cl::desc("Output DWARF5 split debug info."),
85 cl::values(clEnumVal(Default, "Default for platform"),
86 clEnumVal(Enable, "Enabled"),
87 clEnumVal(Disable, "Disabled"), clEnumValEnd),
90 static cl::opt<DefaultOnOff>
91 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
92 cl::desc("Generate DWARF pubnames and pubtypes sections"),
93 cl::values(clEnumVal(Default, "Default for platform"),
94 clEnumVal(Enable, "Enabled"),
95 clEnumVal(Disable, "Disabled"), clEnumValEnd),
98 static cl::opt<unsigned>
99 DwarfVersionNumber("dwarf-version", cl::Hidden,
100 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
103 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
104 cl::desc("Generate DW_AT_ranges for compile units"),
107 static const char *const DWARFGroupName = "DWARF Emission";
108 static const char *const DbgTimerName = "DWARF Debug Writer";
110 //===----------------------------------------------------------------------===//
114 /// resolve - Look in the DwarfDebug map for the MDNode that
115 /// corresponds to the reference.
116 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
117 return DD->resolve(Ref);
120 DIType DbgVariable::getType() const {
121 DIType Ty = Var.getType();
122 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
123 // addresses instead.
124 if (Var.isBlockByrefVariable()) {
125 /* Byref variables, in Blocks, are declared by the programmer as
126 "SomeType VarName;", but the compiler creates a
127 __Block_byref_x_VarName struct, and gives the variable VarName
128 either the struct, or a pointer to the struct, as its type. This
129 is necessary for various behind-the-scenes things the compiler
130 needs to do with by-reference variables in blocks.
132 However, as far as the original *programmer* is concerned, the
133 variable should still have type 'SomeType', as originally declared.
135 The following function dives into the __Block_byref_x_VarName
136 struct to find the original type of the variable. This will be
137 passed back to the code generating the type for the Debug
138 Information Entry for the variable 'VarName'. 'VarName' will then
139 have the original type 'SomeType' in its debug information.
141 The original type 'SomeType' will be the type of the field named
142 'VarName' inside the __Block_byref_x_VarName struct.
144 NOTE: In order for this to not completely fail on the debugger
145 side, the Debug Information Entry for the variable VarName needs to
146 have a DW_AT_location that tells the debugger how to unwind through
147 the pointers and __Block_byref_x_VarName struct to find the actual
148 value of the variable. The function addBlockByrefType does this. */
150 uint16_t tag = Ty.getTag();
152 if (tag == dwarf::DW_TAG_pointer_type)
153 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
155 DIArray Elements = DICompositeType(subType).getTypeArray();
156 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
157 DIDerivedType DT(Elements.getElement(i));
158 if (getName() == DT.getName())
159 return (resolve(DT.getTypeDerivedFrom()));
165 } // end llvm namespace
167 /// Return Dwarf Version by checking module flags.
168 static unsigned getDwarfVersionFromModule(const Module *M) {
169 Value *Val = M->getModuleFlag("Dwarf Version");
171 return dwarf::DWARF_VERSION;
172 return cast<ConstantInt>(Val)->getZExtValue();
175 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
176 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
177 PrevLabel(NULL), GlobalRangeCount(0),
178 InfoHolder(A, "info_string", DIEValueAllocator), HasCURanges(false),
179 UsedNonDefaultText(false),
180 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
182 DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
183 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
184 DwarfAddrSectionSym = 0;
185 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
186 FunctionBeginSym = FunctionEndSym = 0;
190 // Turn on accelerator tables for Darwin by default, pubnames by
191 // default for non-Darwin, and handle split dwarf.
192 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
194 if (DwarfAccelTables == Default)
195 HasDwarfAccelTables = IsDarwin;
197 HasDwarfAccelTables = DwarfAccelTables == Enable;
199 if (SplitDwarf == Default)
200 HasSplitDwarf = false;
202 HasSplitDwarf = SplitDwarf == Enable;
204 if (DwarfPubSections == Default)
205 HasDwarfPubSections = !IsDarwin;
207 HasDwarfPubSections = DwarfPubSections == Enable;
209 DwarfVersion = DwarfVersionNumber
211 : getDwarfVersionFromModule(MMI->getModule());
214 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
219 // Switch to the specified MCSection and emit an assembler
220 // temporary label to it if SymbolStem is specified.
221 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
222 const char *SymbolStem = 0) {
223 Asm->OutStreamer.SwitchSection(Section);
227 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
228 Asm->OutStreamer.EmitLabel(TmpSym);
232 DwarfFile::~DwarfFile() {
233 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
238 MCSymbol *DwarfFile::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
242 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol *, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
248 Entry.second = NextStringPoolNumber++;
249 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
252 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
253 std::pair<MCSymbol *, unsigned> &Entry =
254 StringPool.GetOrCreateValue(Str).getValue();
258 Entry.second = NextStringPoolNumber++;
259 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
263 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
264 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
267 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
268 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
269 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
271 ++NextAddrPoolNumber;
272 return P.first->second;
275 // Define a unique number for the abbreviation.
277 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
278 // Check the set for priors.
279 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
281 // If it's newly added.
282 if (InSet == &Abbrev) {
283 // Add to abbreviation list.
284 Abbreviations.push_back(&Abbrev);
286 // Assign the vector position + 1 as its number.
287 Abbrev.setNumber(Abbreviations.size());
289 // Assign existing abbreviation number.
290 Abbrev.setNumber(InSet->getNumber());
294 static bool isObjCClass(StringRef Name) {
295 return Name.startswith("+") || Name.startswith("-");
298 static bool hasObjCCategory(StringRef Name) {
299 if (!isObjCClass(Name))
302 return Name.find(") ") != StringRef::npos;
305 static void getObjCClassCategory(StringRef In, StringRef &Class,
306 StringRef &Category) {
307 if (!hasObjCCategory(In)) {
308 Class = In.slice(In.find('[') + 1, In.find(' '));
313 Class = In.slice(In.find('[') + 1, In.find('('));
314 Category = In.slice(In.find('[') + 1, In.find(' '));
318 static StringRef getObjCMethodName(StringRef In) {
319 return In.slice(In.find(' ') + 1, In.find(']'));
322 // Helper for sorting sections into a stable output order.
323 static bool SectionSort(const MCSection *A, const MCSection *B) {
324 std::string LA = (A ? A->getLabelBeginName() : "");
325 std::string LB = (B ? B->getLabelBeginName() : "");
329 // Add the various names to the Dwarf accelerator table names.
330 // TODO: Determine whether or not we should add names for programs
331 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
332 // is only slightly different than the lookup of non-standard ObjC names.
333 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
334 if (!SP.isDefinition())
336 TheU->addAccelName(SP.getName(), Die);
338 // If the linkage name is different than the name, go ahead and output
339 // that as well into the name table.
340 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
341 TheU->addAccelName(SP.getLinkageName(), Die);
343 // If this is an Objective-C selector name add it to the ObjC accelerator
345 if (isObjCClass(SP.getName())) {
346 StringRef Class, Category;
347 getObjCClassCategory(SP.getName(), Class, Category);
348 TheU->addAccelObjC(Class, Die);
350 TheU->addAccelObjC(Category, Die);
351 // Also add the base method name to the name table.
352 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
356 /// isSubprogramContext - Return true if Context is either a subprogram
357 /// or another context nested inside a subprogram.
358 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
361 DIDescriptor D(Context);
362 if (D.isSubprogram())
365 return isSubprogramContext(resolve(DIType(Context).getContext()));
369 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
370 // and DW_AT_high_pc attributes. If there are global variables in this
371 // scope then create and insert DIEs for these variables.
372 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
374 DIE *SPDie = SPCU->getDIE(SP);
376 assert(SPDie && "Unable to find subprogram DIE!");
378 // If we're updating an abstract DIE, then we will be adding the children and
379 // object pointer later on. But what we don't want to do is process the
380 // concrete DIE twice.
381 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
382 // Pick up abstract subprogram DIE.
384 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
385 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
387 DISubprogram SPDecl = SP.getFunctionDeclaration();
388 if (!SPDecl.isSubprogram()) {
389 // There is not any need to generate specification DIE for a function
390 // defined at compile unit level. If a function is defined inside another
391 // function then gdb prefers the definition at top level and but does not
392 // expect specification DIE in parent function. So avoid creating
393 // specification DIE for a function defined inside a function.
394 DIScope SPContext = resolve(SP.getContext());
395 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
396 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
397 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
400 DICompositeType SPTy = SP.getType();
401 DIArray Args = SPTy.getTypeArray();
402 uint16_t SPTag = SPTy.getTag();
403 if (SPTag == dwarf::DW_TAG_subroutine_type)
404 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
406 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
407 DIType ATy(Args.getElement(i));
408 SPCU->addType(Arg, ATy);
409 if (ATy.isArtificial())
410 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
411 if (ATy.isObjectPointer())
412 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
414 DIE *SPDeclDie = SPDie;
415 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
416 *SPCU->getUnitDie());
417 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
422 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
423 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
425 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
426 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
427 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
429 // Add name to the name table, we do this here because we're guaranteed
430 // to have concrete versions of our DW_TAG_subprogram nodes.
431 addSubprogramNames(SPCU, SP, SPDie);
436 /// Check whether we should create a DIE for the given Scope, return true
437 /// if we don't create a DIE (the corresponding DIE is null).
438 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
439 if (Scope->isAbstractScope())
442 // We don't create a DIE if there is no Range.
443 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
447 if (Ranges.size() > 1)
450 // We don't create a DIE if we have a single Range and the end label
452 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
453 MCSymbol *End = getLabelAfterInsn(RI->second);
457 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
458 dwarf::Attribute A, const MCSymbol *L,
459 const MCSymbol *Sec) {
460 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
461 U->addSectionLabel(D, A, L);
463 U->addSectionDelta(D, A, L, Sec);
466 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
467 const SmallVectorImpl<InsnRange> &Range) {
468 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
469 // emitting it appropriately.
470 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
471 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
472 DwarfDebugRangeSectionSym);
474 RangeSpanList List(RangeSym);
475 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
478 RangeSpan Span(getLabelBeforeInsn(RI->first),
479 getLabelAfterInsn(RI->second));
480 List.addRange(llvm_move(Span));
483 // Add the range list to the set of ranges to be emitted.
484 TheCU->addRangeList(llvm_move(List));
487 // Construct new DW_TAG_lexical_block for this scope and attach
488 // DW_AT_low_pc/DW_AT_high_pc labels.
489 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
490 LexicalScope *Scope) {
491 if (isLexicalScopeDIENull(Scope))
494 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
495 if (Scope->isAbstractScope())
498 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
500 // If we have multiple ranges, emit them into the range section.
501 if (ScopeRanges.size() > 1) {
502 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
506 // Construct the address range for this DIE.
507 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
508 MCSymbol *Start = getLabelBeforeInsn(RI->first);
509 MCSymbol *End = getLabelAfterInsn(RI->second);
510 assert(End && "End label should not be null!");
512 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
513 assert(End->isDefined() && "Invalid end label for an inlined scope!");
515 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
516 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
521 // This scope represents inlined body of a function. Construct DIE to
522 // represent this concrete inlined copy of the function.
523 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
524 LexicalScope *Scope) {
525 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
526 assert(!ScopeRanges.empty() &&
527 "LexicalScope does not have instruction markers!");
529 if (!Scope->getScopeNode())
531 DIScope DS(Scope->getScopeNode());
532 DISubprogram InlinedSP = getDISubprogram(DS);
533 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
535 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
539 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
540 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
542 // If we have multiple ranges, emit them into the range section.
543 if (ScopeRanges.size() > 1)
544 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
546 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
547 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
548 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
550 if (StartLabel == 0 || EndLabel == 0)
551 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
553 assert(StartLabel->isDefined() &&
554 "Invalid starting label for an inlined scope!");
555 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
557 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
558 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
561 InlinedSubprogramDIEs.insert(OriginDIE);
563 // Add the call site information to the DIE.
564 DILocation DL(Scope->getInlinedAt());
565 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
566 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
567 TheCU->getUniqueID()));
568 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
570 // Add name to the name table, we do this here because we're guaranteed
571 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
572 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
577 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
579 SmallVectorImpl<DIE *> &Children) {
580 DIE *ObjectPointer = NULL;
582 // Collect arguments for current function.
583 if (LScopes.isCurrentFunctionScope(Scope))
584 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
585 if (DbgVariable *ArgDV = CurrentFnArguments[i])
587 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
588 Children.push_back(Arg);
589 if (ArgDV->isObjectPointer())
593 // Collect lexical scope children first.
594 const SmallVectorImpl<DbgVariable *> &Variables =
595 ScopeVariables.lookup(Scope);
596 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
597 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
598 Scope->isAbstractScope())) {
599 Children.push_back(Variable);
600 if (Variables[i]->isObjectPointer())
601 ObjectPointer = Variable;
603 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
604 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
605 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
606 Children.push_back(Nested);
607 return ObjectPointer;
610 // Construct a DIE for this scope.
611 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
612 LexicalScope *Scope) {
613 if (!Scope || !Scope->getScopeNode())
616 DIScope DS(Scope->getScopeNode());
618 SmallVector<DIE *, 8> Children;
619 DIE *ObjectPointer = NULL;
620 bool ChildrenCreated = false;
622 // We try to create the scope DIE first, then the children DIEs. This will
623 // avoid creating un-used children then removing them later when we find out
624 // the scope DIE is null.
625 DIE *ScopeDIE = NULL;
626 if (Scope->getInlinedAt())
627 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
628 else if (DS.isSubprogram()) {
629 ProcessedSPNodes.insert(DS);
630 if (Scope->isAbstractScope()) {
631 ScopeDIE = TheCU->getDIE(DS);
632 // Note down abstract DIE.
634 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
636 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
638 // Early exit when we know the scope DIE is going to be null.
639 if (isLexicalScopeDIENull(Scope))
642 // We create children here when we know the scope DIE is not going to be
643 // null and the children will be added to the scope DIE.
644 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
645 ChildrenCreated = true;
647 // There is no need to emit empty lexical block DIE.
648 std::pair<ImportedEntityMap::const_iterator,
649 ImportedEntityMap::const_iterator> Range =
651 ScopesWithImportedEntities.begin(),
652 ScopesWithImportedEntities.end(),
653 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
655 if (Children.empty() && Range.first == Range.second)
657 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
658 assert(ScopeDIE && "Scope DIE should not be null.");
659 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
661 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
665 assert(Children.empty() &&
666 "We create children only when the scope DIE is not null.");
669 if (!ChildrenCreated)
670 // We create children when the scope DIE is not null.
671 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
674 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
677 ScopeDIE->addChild(*I);
679 if (DS.isSubprogram() && ObjectPointer != NULL)
680 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
685 // Look up the source id with the given directory and source file names.
686 // If none currently exists, create a new id and insert it in the
687 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
689 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
691 // If we use .loc in assembly, we can't separate .file entries according to
692 // compile units. Thus all files will belong to the default compile unit.
694 // FIXME: add a better feature test than hasRawTextSupport. Even better,
695 // extend .file to support this.
696 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
699 // If FE did not provide a file name, then assume stdin.
700 if (FileName.empty())
701 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
703 // TODO: this might not belong here. See if we can factor this better.
704 if (DirName == CompilationDir)
707 // FileIDCUMap stores the current ID for the given compile unit.
708 unsigned SrcId = FileIDCUMap[CUID] + 1;
710 // We look up the CUID/file/dir by concatenating them with a zero byte.
711 SmallString<128> NamePair;
712 NamePair += utostr(CUID);
715 NamePair += '\0'; // Zero bytes are not allowed in paths.
716 NamePair += FileName;
718 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
719 if (Ent.getValue() != SrcId)
720 return Ent.getValue();
722 FileIDCUMap[CUID] = SrcId;
723 // Print out a .file directive to specify files for .loc directives.
724 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
729 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
730 if (!GenerateGnuPubSections)
733 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
734 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
735 DwarfGnuPubNamesSectionSym);
737 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
738 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
739 DwarfGnuPubTypesSectionSym);
742 // Create new DwarfCompileUnit for the given metadata node with tag
743 // DW_TAG_compile_unit.
744 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
745 StringRef FN = DIUnit.getFilename();
746 CompilationDir = DIUnit.getDirectory();
748 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
749 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
750 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
751 InfoHolder.addUnit(NewCU);
753 FileIDCUMap[NewCU->getUniqueID()] = 0;
754 // Call this to emit a .file directive if it wasn't emitted for the source
755 // file this CU comes from yet.
756 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
758 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
759 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
760 DIUnit.getLanguage());
761 NewCU->addString(Die, dwarf::DW_AT_name, FN);
763 // Define start line table label for each Compile Unit.
764 MCSymbol *LineTableStartSym =
765 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
766 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
767 NewCU->getUniqueID());
769 // Use a single line table if we are using .loc and generating assembly.
771 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
772 (NewCU->getUniqueID() == 0);
774 if (!useSplitDwarf()) {
775 // DW_AT_stmt_list is a offset of line number information for this
776 // compile unit in debug_line section. For split dwarf this is
777 // left in the skeleton CU and so not included.
778 // The line table entries are not always emitted in assembly, so it
779 // is not okay to use line_table_start here.
780 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
781 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
782 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
783 : LineTableStartSym);
784 else if (UseTheFirstCU)
785 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
787 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
788 DwarfLineSectionSym);
790 // If we're using split dwarf the compilation dir is going to be in the
791 // skeleton CU and so we don't need to duplicate it here.
792 if (!CompilationDir.empty())
793 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
795 addGnuPubAttributes(NewCU, Die);
798 if (DIUnit.isOptimized())
799 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
801 StringRef Flags = DIUnit.getFlags();
803 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
805 if (unsigned RVer = DIUnit.getRunTimeVersion())
806 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
807 dwarf::DW_FORM_data1, RVer);
812 if (useSplitDwarf()) {
813 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
814 DwarfInfoDWOSectionSym);
815 NewCU->setSkeleton(constructSkeletonCU(NewCU));
817 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
818 DwarfInfoSectionSym);
820 CUMap.insert(std::make_pair(DIUnit, NewCU));
821 CUDieMap.insert(std::make_pair(Die, NewCU));
825 // Construct subprogram DIE.
826 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
828 // FIXME: We should only call this routine once, however, during LTO if a
829 // program is defined in multiple CUs we could end up calling it out of
830 // beginModule as we walk the CUs.
832 DwarfCompileUnit *&CURef = SPMap[N];
838 if (!SP.isDefinition())
839 // This is a method declaration which will be handled while constructing
843 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
845 // Expose as a global name.
846 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
849 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
851 DIImportedEntity Module(N);
852 assert(Module.Verify());
853 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
854 constructImportedEntityDIE(TheCU, Module, D);
857 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
858 const MDNode *N, DIE *Context) {
859 DIImportedEntity Module(N);
860 assert(Module.Verify());
861 return constructImportedEntityDIE(TheCU, Module, Context);
864 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
865 const DIImportedEntity &Module,
867 assert(Module.Verify() &&
868 "Use one of the MDNode * overloads to handle invalid metadata");
869 assert(Context && "Should always have a context for an imported_module");
870 DIE *IMDie = new DIE(Module.getTag());
871 TheCU->insertDIE(Module, IMDie);
873 DIDescriptor Entity = Module.getEntity();
874 if (Entity.isNameSpace())
875 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
876 else if (Entity.isSubprogram())
877 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
878 else if (Entity.isType())
879 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
881 EntityDie = TheCU->getDIE(Entity);
882 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
883 Module.getContext().getDirectory(),
884 TheCU->getUniqueID());
885 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
886 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
887 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
888 StringRef Name = Module.getName();
890 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
891 Context->addChild(IMDie);
894 // Emit all Dwarf sections that should come prior to the content. Create
895 // global DIEs and emit initial debug info sections. This is invoked by
896 // the target AsmPrinter.
897 void DwarfDebug::beginModule() {
898 if (DisableDebugInfoPrinting)
901 const Module *M = MMI->getModule();
903 // If module has named metadata anchors then use them, otherwise scan the
904 // module using debug info finder to collect debug info.
905 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
908 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
910 // Emit initial sections so we can reference labels later.
913 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
914 DICompileUnit CUNode(CU_Nodes->getOperand(i));
915 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
916 DIArray ImportedEntities = CUNode.getImportedEntities();
917 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
918 ScopesWithImportedEntities.push_back(std::make_pair(
919 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
920 ImportedEntities.getElement(i)));
921 std::sort(ScopesWithImportedEntities.begin(),
922 ScopesWithImportedEntities.end(), less_first());
923 DIArray GVs = CUNode.getGlobalVariables();
924 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
925 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
926 DIArray SPs = CUNode.getSubprograms();
927 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
928 constructSubprogramDIE(CU, SPs.getElement(i));
929 DIArray EnumTypes = CUNode.getEnumTypes();
930 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
931 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
932 DIArray RetainedTypes = CUNode.getRetainedTypes();
933 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
934 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
935 // Emit imported_modules last so that the relevant context is already
937 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
938 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
941 // Tell MMI that we have debug info.
942 MMI->setDebugInfoAvailability(true);
944 // Prime section data.
945 SectionMap[Asm->getObjFileLowering().getTextSection()];
948 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
949 void DwarfDebug::computeInlinedDIEs() {
950 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
951 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
952 AE = InlinedSubprogramDIEs.end();
955 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
957 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
958 AE = AbstractSPDies.end();
960 DIE *ISP = AI->second;
961 if (InlinedSubprogramDIEs.count(ISP))
963 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
967 // Collect info for variables that were optimized out.
968 void DwarfDebug::collectDeadVariables() {
969 const Module *M = MMI->getModule();
971 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
972 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
973 DICompileUnit TheCU(CU_Nodes->getOperand(i));
974 DIArray Subprograms = TheCU.getSubprograms();
975 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
976 DISubprogram SP(Subprograms.getElement(i));
977 if (ProcessedSPNodes.count(SP) != 0)
979 if (!SP.isSubprogram())
981 if (!SP.isDefinition())
983 DIArray Variables = SP.getVariables();
984 if (Variables.getNumElements() == 0)
987 // Construct subprogram DIE and add variables DIEs.
988 DwarfCompileUnit *SPCU =
989 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
990 assert(SPCU && "Unable to find Compile Unit!");
991 // FIXME: See the comment in constructSubprogramDIE about duplicate
993 constructSubprogramDIE(SPCU, SP);
994 DIE *SPDIE = SPCU->getDIE(SP);
995 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
996 DIVariable DV(Variables.getElement(vi));
997 if (!DV.isVariable())
999 DbgVariable NewVar(DV, NULL, this);
1000 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1001 SPDIE->addChild(VariableDIE);
1008 void DwarfDebug::finalizeModuleInfo() {
1009 // Collect info for variables that were optimized out.
1010 collectDeadVariables();
1012 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1013 computeInlinedDIEs();
1015 // Handle anything that needs to be done on a per-unit basis after
1016 // all other generation.
1017 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1018 E = getUnits().end();
1020 DwarfUnit *TheU = *I;
1021 // Emit DW_AT_containing_type attribute to connect types with their
1022 // vtable holding type.
1023 TheU->constructContainingTypeDIEs();
1025 // Add CU specific attributes if we need to add any.
1026 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1027 // If we're splitting the dwarf out now that we've got the entire
1028 // CU then add the dwo id to it.
1029 DwarfCompileUnit *SkCU =
1030 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1031 if (useSplitDwarf()) {
1032 // This should be a unique identifier when we want to build .dwp files.
1034 if (GenerateCUHash) {
1036 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1038 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1039 dwarf::DW_FORM_data8, ID);
1040 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1041 dwarf::DW_FORM_data8, ID);
1044 // If we have code split among multiple sections or we've requested
1045 // it then emit a DW_AT_ranges attribute on the unit that will remain
1046 // in the .o file, otherwise add a DW_AT_low_pc.
1047 // FIXME: Also add a high pc if we can.
1048 // FIXME: We should use ranges if we have multiple compile units or
1049 // allow reordering of code ala .subsections_via_symbols in mach-o.
1050 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1051 if (useCURanges() && TheU->getRanges().size()) {
1052 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1053 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1054 DwarfDebugRangeSectionSym);
1056 // A DW_AT_low_pc attribute may also be specified in combination with
1057 // DW_AT_ranges to specify the default base address for use in location
1058 // lists (see Section 2.6.2) and range lists (see Section 2.17.3).
1059 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1062 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1067 // Compute DIE offsets and sizes.
1068 InfoHolder.computeSizeAndOffsets();
1069 if (useSplitDwarf())
1070 SkeletonHolder.computeSizeAndOffsets();
1073 void DwarfDebug::endSections() {
1074 // Filter labels by section.
1075 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1076 const SymbolCU &SCU = ArangeLabels[n];
1077 if (SCU.Sym->isInSection()) {
1078 // Make a note of this symbol and it's section.
1079 const MCSection *Section = &SCU.Sym->getSection();
1080 if (!Section->getKind().isMetadata())
1081 SectionMap[Section].push_back(SCU);
1083 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1084 // appear in the output. This sucks as we rely on sections to build
1085 // arange spans. We can do it without, but it's icky.
1086 SectionMap[NULL].push_back(SCU);
1090 // Build a list of sections used.
1091 std::vector<const MCSection *> Sections;
1092 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1094 const MCSection *Section = it->first;
1095 Sections.push_back(Section);
1098 // Sort the sections into order.
1099 // This is only done to ensure consistent output order across different runs.
1100 std::sort(Sections.begin(), Sections.end(), SectionSort);
1102 // Add terminating symbols for each section.
1103 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1104 const MCSection *Section = Sections[ID];
1105 MCSymbol *Sym = NULL;
1108 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1109 // if we know the section name up-front. For user-created sections, the
1110 // resulting label may not be valid to use as a label. (section names can
1111 // use a greater set of characters on some systems)
1112 Sym = Asm->GetTempSymbol("debug_end", ID);
1113 Asm->OutStreamer.SwitchSection(Section);
1114 Asm->OutStreamer.EmitLabel(Sym);
1117 // Insert a final terminator.
1118 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1121 // For now only turn on CU ranges if we've explicitly asked for it,
1122 // we have -ffunction-sections enabled, we've emitted a function
1123 // into a unique section, or we're using LTO. If we're using LTO then
1124 // we can't know that any particular function in the module is correlated
1125 // to a particular CU and so we need to be conservative. At this point all
1126 // sections should be finalized except for dwarf sections.
1127 HasCURanges = DwarfCURanges || UsedNonDefaultText || (CUMap.size() > 1) ||
1128 TargetMachine::getFunctionSections();
1131 // Emit all Dwarf sections that should come after the content.
1132 void DwarfDebug::endModule() {
1139 // End any existing sections.
1140 // TODO: Does this need to happen?
1143 // Finalize the debug info for the module.
1144 finalizeModuleInfo();
1148 // Emit all the DIEs into a debug info section.
1151 // Corresponding abbreviations into a abbrev section.
1152 emitAbbreviations();
1154 // Emit info into a debug loc section.
1157 // Emit info into a debug aranges section.
1160 // Emit info into a debug ranges section.
1163 if (useSplitDwarf()) {
1166 emitDebugAbbrevDWO();
1167 // Emit DWO addresses.
1168 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1171 // Emit info into the dwarf accelerator table sections.
1172 if (useDwarfAccelTables()) {
1175 emitAccelNamespaces();
1179 // Emit the pubnames and pubtypes sections if requested.
1180 if (HasDwarfPubSections) {
1181 emitDebugPubNames(GenerateGnuPubSections);
1182 emitDebugPubTypes(GenerateGnuPubSections);
1188 // Reset these for the next Module if we have one.
1192 // Find abstract variable, if any, associated with Var.
1193 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1194 DebugLoc ScopeLoc) {
1195 LLVMContext &Ctx = DV->getContext();
1196 // More then one inlined variable corresponds to one abstract variable.
1197 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1198 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1200 return AbsDbgVariable;
1202 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1206 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1207 addScopeVariable(Scope, AbsDbgVariable);
1208 AbstractVariables[Var] = AbsDbgVariable;
1209 return AbsDbgVariable;
1212 // If Var is a current function argument then add it to CurrentFnArguments list.
1213 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1214 if (!LScopes.isCurrentFunctionScope(Scope))
1216 DIVariable DV = Var->getVariable();
1217 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1219 unsigned ArgNo = DV.getArgNumber();
1223 size_t Size = CurrentFnArguments.size();
1225 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1226 // llvm::Function argument size is not good indicator of how many
1227 // arguments does the function have at source level.
1229 CurrentFnArguments.resize(ArgNo * 2);
1230 CurrentFnArguments[ArgNo - 1] = Var;
1234 // Collect variable information from side table maintained by MMI.
1235 void DwarfDebug::collectVariableInfoFromMMITable(
1236 SmallPtrSet<const MDNode *, 16> &Processed) {
1237 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1238 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1241 const MDNode *Var = VI->first;
1244 Processed.insert(Var);
1246 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1248 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1250 // If variable scope is not found then skip this variable.
1254 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1255 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1256 RegVar->setFrameIndex(VP.first);
1257 if (!addCurrentFnArgument(RegVar, Scope))
1258 addScopeVariable(Scope, RegVar);
1260 AbsDbgVariable->setFrameIndex(VP.first);
1264 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1266 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1267 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1268 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1269 MI->getOperand(0).getReg() &&
1270 (MI->getOperand(1).isImm() ||
1271 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1274 // Get .debug_loc entry for the instruction range starting at MI.
1275 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1276 const MCSymbol *FLabel,
1277 const MCSymbol *SLabel,
1278 const MachineInstr *MI) {
1279 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1281 assert(MI->getNumOperands() == 3);
1282 if (MI->getOperand(0).isReg()) {
1283 MachineLocation MLoc;
1284 // If the second operand is an immediate, this is a
1285 // register-indirect address.
1286 if (!MI->getOperand(1).isImm())
1287 MLoc.set(MI->getOperand(0).getReg());
1289 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1290 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1292 if (MI->getOperand(0).isImm())
1293 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1294 if (MI->getOperand(0).isFPImm())
1295 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1296 if (MI->getOperand(0).isCImm())
1297 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1299 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1302 // Find variables for each lexical scope.
1304 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1306 // Grab the variable info that was squirreled away in the MMI side-table.
1307 collectVariableInfoFromMMITable(Processed);
1309 for (SmallVectorImpl<const MDNode *>::const_iterator
1310 UVI = UserVariables.begin(),
1311 UVE = UserVariables.end();
1312 UVI != UVE; ++UVI) {
1313 const MDNode *Var = *UVI;
1314 if (Processed.count(Var))
1317 // History contains relevant DBG_VALUE instructions for Var and instructions
1319 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1320 if (History.empty())
1322 const MachineInstr *MInsn = History.front();
1325 LexicalScope *Scope = NULL;
1326 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1327 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1328 Scope = LScopes.getCurrentFunctionScope();
1329 else if (MDNode *IA = DV.getInlinedAt())
1330 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1332 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1333 // If variable scope is not found then skip this variable.
1337 Processed.insert(DV);
1338 assert(MInsn->isDebugValue() && "History must begin with debug value");
1339 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1340 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1341 if (!addCurrentFnArgument(RegVar, Scope))
1342 addScopeVariable(Scope, RegVar);
1344 AbsVar->setMInsn(MInsn);
1346 // Simplify ranges that are fully coalesced.
1347 if (History.size() <= 1 ||
1348 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1349 RegVar->setMInsn(MInsn);
1353 // Handle multiple DBG_VALUE instructions describing one variable.
1354 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1356 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1357 HI = History.begin(),
1360 const MachineInstr *Begin = *HI;
1361 assert(Begin->isDebugValue() && "Invalid History entry");
1363 // Check if DBG_VALUE is truncating a range.
1364 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1365 !Begin->getOperand(0).getReg())
1368 // Compute the range for a register location.
1369 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1370 const MCSymbol *SLabel = 0;
1373 // If Begin is the last instruction in History then its value is valid
1374 // until the end of the function.
1375 SLabel = FunctionEndSym;
1377 const MachineInstr *End = HI[1];
1378 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1379 << "\t" << *Begin << "\t" << *End << "\n");
1380 if (End->isDebugValue())
1381 SLabel = getLabelBeforeInsn(End);
1383 // End is a normal instruction clobbering the range.
1384 SLabel = getLabelAfterInsn(End);
1385 assert(SLabel && "Forgot label after clobber instruction");
1390 // The value is valid until the next DBG_VALUE or clobber.
1391 DotDebugLocEntries.push_back(
1392 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1394 DotDebugLocEntries.push_back(DotDebugLocEntry());
1397 // Collect info for variables that were optimized out.
1398 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1399 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1400 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1401 DIVariable DV(Variables.getElement(i));
1402 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1404 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1405 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1409 // Return Label preceding the instruction.
1410 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1411 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1412 assert(Label && "Didn't insert label before instruction");
1416 // Return Label immediately following the instruction.
1417 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1418 return LabelsAfterInsn.lookup(MI);
1421 // Process beginning of an instruction.
1422 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1425 // Check if source location changes, but ignore DBG_VALUE locations.
1426 if (!MI->isDebugValue()) {
1427 DebugLoc DL = MI->getDebugLoc();
1428 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1431 if (DL == PrologEndLoc) {
1432 Flags |= DWARF2_FLAG_PROLOGUE_END;
1433 PrologEndLoc = DebugLoc();
1435 if (PrologEndLoc.isUnknown())
1436 Flags |= DWARF2_FLAG_IS_STMT;
1438 if (!DL.isUnknown()) {
1439 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1440 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1442 recordSourceLine(0, 0, 0, 0);
1446 // Insert labels where requested.
1447 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1448 LabelsBeforeInsn.find(MI);
1451 if (I == LabelsBeforeInsn.end())
1454 // Label already assigned.
1459 PrevLabel = MMI->getContext().CreateTempSymbol();
1460 Asm->OutStreamer.EmitLabel(PrevLabel);
1462 I->second = PrevLabel;
1465 // Process end of an instruction.
1466 void DwarfDebug::endInstruction() {
1468 // Don't create a new label after DBG_VALUE instructions.
1469 // They don't generate code.
1470 if (!CurMI->isDebugValue())
1473 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1474 LabelsAfterInsn.find(CurMI);
1478 if (I == LabelsAfterInsn.end())
1481 // Label already assigned.
1485 // We need a label after this instruction.
1487 PrevLabel = MMI->getContext().CreateTempSymbol();
1488 Asm->OutStreamer.EmitLabel(PrevLabel);
1490 I->second = PrevLabel;
1493 // Each LexicalScope has first instruction and last instruction to mark
1494 // beginning and end of a scope respectively. Create an inverse map that list
1495 // scopes starts (and ends) with an instruction. One instruction may start (or
1496 // end) multiple scopes. Ignore scopes that are not reachable.
1497 void DwarfDebug::identifyScopeMarkers() {
1498 SmallVector<LexicalScope *, 4> WorkList;
1499 WorkList.push_back(LScopes.getCurrentFunctionScope());
1500 while (!WorkList.empty()) {
1501 LexicalScope *S = WorkList.pop_back_val();
1503 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1504 if (!Children.empty())
1505 for (SmallVectorImpl<LexicalScope *>::const_iterator
1506 SI = Children.begin(),
1507 SE = Children.end();
1509 WorkList.push_back(*SI);
1511 if (S->isAbstractScope())
1514 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1517 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1520 assert(RI->first && "InsnRange does not have first instruction!");
1521 assert(RI->second && "InsnRange does not have second instruction!");
1522 requestLabelBeforeInsn(RI->first);
1523 requestLabelAfterInsn(RI->second);
1528 // Gather pre-function debug information. Assumes being called immediately
1529 // after the function entry point has been emitted.
1530 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1533 // If there's no debug info for the function we're not going to do anything.
1534 if (!MMI->hasDebugInfo())
1537 // Grab the lexical scopes for the function, if we don't have any of those
1538 // then we're not going to be able to do anything.
1539 LScopes.initialize(*MF);
1540 if (LScopes.empty())
1543 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1545 // Make sure that each lexical scope will have a begin/end label.
1546 identifyScopeMarkers();
1548 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1549 // belongs to so that we add to the correct per-cu line table in the
1551 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1552 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1553 assert(TheCU && "Unable to find compile unit!");
1554 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1555 // Use a single line table if we are using .loc and generating assembly.
1556 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1558 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1560 // Check the current section against the standard text section. If different
1561 // keep track so that we will know when we're emitting functions into multiple
1563 if (Asm->getObjFileLowering().getTextSection() != Asm->getCurrentSection())
1564 UsedNonDefaultText = true;
1566 // Emit a label for the function so that we have a beginning address.
1567 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1568 // Assumes in correct section after the entry point.
1569 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1571 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1572 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1573 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1575 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1577 bool AtBlockEntry = true;
1578 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1580 const MachineInstr *MI = II;
1582 if (MI->isDebugValue()) {
1583 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1585 // Keep track of user variables.
1587 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1589 // Variable is in a register, we need to check for clobbers.
1590 if (isDbgValueInDefinedReg(MI))
1591 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1593 // Check the history of this variable.
1594 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1595 if (History.empty()) {
1596 UserVariables.push_back(Var);
1597 // The first mention of a function argument gets the FunctionBeginSym
1598 // label, so arguments are visible when breaking at function entry.
1600 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1601 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1602 LabelsBeforeInsn[MI] = FunctionBeginSym;
1604 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1605 const MachineInstr *Prev = History.back();
1606 if (Prev->isDebugValue()) {
1607 // Coalesce identical entries at the end of History.
1608 if (History.size() >= 2 &&
1609 Prev->isIdenticalTo(History[History.size() - 2])) {
1610 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1611 << "\t" << *Prev << "\t"
1612 << *History[History.size() - 2] << "\n");
1616 // Terminate old register assignments that don't reach MI;
1617 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1618 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1619 isDbgValueInDefinedReg(Prev)) {
1620 // Previous register assignment needs to terminate at the end of
1622 MachineBasicBlock::const_iterator LastMI =
1623 PrevMBB->getLastNonDebugInstr();
1624 if (LastMI == PrevMBB->end()) {
1625 // Drop DBG_VALUE for empty range.
1626 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1627 << "\t" << *Prev << "\n");
1629 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1630 // Terminate after LastMI.
1631 History.push_back(LastMI);
1635 History.push_back(MI);
1637 // Not a DBG_VALUE instruction.
1639 AtBlockEntry = false;
1641 // First known non-DBG_VALUE and non-frame setup location marks
1642 // the beginning of the function body.
1643 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1644 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1645 PrologEndLoc = MI->getDebugLoc();
1647 // Check if the instruction clobbers any registers with debug vars.
1648 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1649 MOE = MI->operands_end();
1650 MOI != MOE; ++MOI) {
1651 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1653 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1656 const MDNode *Var = LiveUserVar[Reg];
1659 // Reg is now clobbered.
1660 LiveUserVar[Reg] = 0;
1662 // Was MD last defined by a DBG_VALUE referring to Reg?
1663 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1664 if (HistI == DbgValues.end())
1666 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1667 if (History.empty())
1669 const MachineInstr *Prev = History.back();
1670 // Sanity-check: Register assignments are terminated at the end of
1672 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1674 // Is the variable still in Reg?
1675 if (!isDbgValueInDefinedReg(Prev) ||
1676 Prev->getOperand(0).getReg() != Reg)
1678 // Var is clobbered. Make sure the next instruction gets a label.
1679 History.push_back(MI);
1686 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1688 SmallVectorImpl<const MachineInstr *> &History = I->second;
1689 if (History.empty())
1692 // Make sure the final register assignments are terminated.
1693 const MachineInstr *Prev = History.back();
1694 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1695 const MachineBasicBlock *PrevMBB = Prev->getParent();
1696 MachineBasicBlock::const_iterator LastMI =
1697 PrevMBB->getLastNonDebugInstr();
1698 if (LastMI == PrevMBB->end())
1699 // Drop DBG_VALUE for empty range.
1701 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1702 // Terminate after LastMI.
1703 History.push_back(LastMI);
1706 // Request labels for the full history.
1707 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1708 const MachineInstr *MI = History[i];
1709 if (MI->isDebugValue())
1710 requestLabelBeforeInsn(MI);
1712 requestLabelAfterInsn(MI);
1716 PrevInstLoc = DebugLoc();
1717 PrevLabel = FunctionBeginSym;
1719 // Record beginning of function.
1720 if (!PrologEndLoc.isUnknown()) {
1721 DebugLoc FnStartDL =
1722 PrologEndLoc.getFnDebugLoc(MF->getFunction()->getContext());
1724 FnStartDL.getLine(), FnStartDL.getCol(),
1725 FnStartDL.getScope(MF->getFunction()->getContext()),
1726 // We'd like to list the prologue as "not statements" but GDB behaves
1727 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1728 DWARF2_FLAG_IS_STMT);
1732 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1733 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1734 DIVariable DV = Var->getVariable();
1735 // Variables with positive arg numbers are parameters.
1736 if (unsigned ArgNum = DV.getArgNumber()) {
1737 // Keep all parameters in order at the start of the variable list to ensure
1738 // function types are correct (no out-of-order parameters)
1740 // This could be improved by only doing it for optimized builds (unoptimized
1741 // builds have the right order to begin with), searching from the back (this
1742 // would catch the unoptimized case quickly), or doing a binary search
1743 // rather than linear search.
1744 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1745 while (I != Vars.end()) {
1746 unsigned CurNum = (*I)->getVariable().getArgNumber();
1747 // A local (non-parameter) variable has been found, insert immediately
1751 // A later indexed parameter has been found, insert immediately before it.
1752 if (CurNum > ArgNum)
1756 Vars.insert(I, Var);
1760 Vars.push_back(Var);
1763 // Gather and emit post-function debug information.
1764 void DwarfDebug::endFunction(const MachineFunction *MF) {
1765 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1766 // though the beginFunction may not be called at all.
1767 // We should handle both cases.
1771 assert(CurFn == MF);
1774 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1779 // Define end label for subprogram.
1780 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1781 // Assumes in correct section after the entry point.
1782 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1784 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1785 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1787 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1788 collectVariableInfo(ProcessedVars);
1790 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1791 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1792 assert(TheCU && "Unable to find compile unit!");
1794 // Construct abstract scopes.
1795 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1796 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1797 LexicalScope *AScope = AList[i];
1798 DISubprogram SP(AScope->getScopeNode());
1799 if (SP.isSubprogram()) {
1800 // Collect info for variables that were optimized out.
1801 DIArray Variables = SP.getVariables();
1802 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1803 DIVariable DV(Variables.getElement(i));
1804 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1806 // Check that DbgVariable for DV wasn't created earlier, when
1807 // findAbstractVariable() was called for inlined instance of DV.
1808 LLVMContext &Ctx = DV->getContext();
1809 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1810 if (AbstractVariables.lookup(CleanDV))
1812 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1813 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1816 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1817 constructScopeDIE(TheCU, AScope);
1820 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1821 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1822 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1824 // Add the range of this function to the list of ranges for the CU.
1825 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
1826 TheCU->addRange(llvm_move(Span));
1829 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1830 E = ScopeVariables.end();
1832 DeleteContainerPointers(I->second);
1833 ScopeVariables.clear();
1834 DeleteContainerPointers(CurrentFnArguments);
1835 UserVariables.clear();
1837 AbstractVariables.clear();
1838 LabelsBeforeInsn.clear();
1839 LabelsAfterInsn.clear();
1844 // Register a source line with debug info. Returns the unique label that was
1845 // emitted and which provides correspondence to the source line list.
1846 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1852 DIDescriptor Scope(S);
1854 if (Scope.isCompileUnit()) {
1855 DICompileUnit CU(S);
1856 Fn = CU.getFilename();
1857 Dir = CU.getDirectory();
1858 } else if (Scope.isFile()) {
1860 Fn = F.getFilename();
1861 Dir = F.getDirectory();
1862 } else if (Scope.isSubprogram()) {
1864 Fn = SP.getFilename();
1865 Dir = SP.getDirectory();
1866 } else if (Scope.isLexicalBlockFile()) {
1867 DILexicalBlockFile DBF(S);
1868 Fn = DBF.getFilename();
1869 Dir = DBF.getDirectory();
1870 } else if (Scope.isLexicalBlock()) {
1871 DILexicalBlock DB(S);
1872 Fn = DB.getFilename();
1873 Dir = DB.getDirectory();
1875 llvm_unreachable("Unexpected scope info");
1877 Src = getOrCreateSourceID(
1878 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1880 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1883 //===----------------------------------------------------------------------===//
1885 //===----------------------------------------------------------------------===//
1887 // Compute the size and offset of a DIE. The offset is relative to start of the
1888 // CU. It returns the offset after laying out the DIE.
1889 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1890 // Get the children.
1891 const std::vector<DIE *> &Children = Die->getChildren();
1893 // Record the abbreviation.
1894 assignAbbrevNumber(Die->getAbbrev());
1896 // Get the abbreviation for this DIE.
1897 const DIEAbbrev &Abbrev = Die->getAbbrev();
1900 Die->setOffset(Offset);
1902 // Start the size with the size of abbreviation code.
1903 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1905 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1906 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1908 // Size the DIE attribute values.
1909 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1910 // Size attribute value.
1911 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1913 // Size the DIE children if any.
1914 if (!Children.empty()) {
1915 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1916 "Children flag not set");
1918 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1919 Offset = computeSizeAndOffset(Children[j], Offset);
1921 // End of children marker.
1922 Offset += sizeof(int8_t);
1925 Die->setSize(Offset - Die->getOffset());
1929 // Compute the size and offset for each DIE.
1930 void DwarfFile::computeSizeAndOffsets() {
1931 // Offset from the first CU in the debug info section is 0 initially.
1932 unsigned SecOffset = 0;
1934 // Iterate over each compile unit and set the size and offsets for each
1935 // DIE within each compile unit. All offsets are CU relative.
1936 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1939 (*I)->setDebugInfoOffset(SecOffset);
1941 // CU-relative offset is reset to 0 here.
1942 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1943 (*I)->getHeaderSize(); // Unit-specific headers
1945 // EndOffset here is CU-relative, after laying out
1946 // all of the CU DIE.
1947 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1948 SecOffset += EndOffset;
1952 // Emit initial Dwarf sections with a label at the start of each one.
1953 void DwarfDebug::emitSectionLabels() {
1954 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1956 // Dwarf sections base addresses.
1957 DwarfInfoSectionSym =
1958 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1959 if (useSplitDwarf())
1960 DwarfInfoDWOSectionSym =
1961 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
1962 DwarfAbbrevSectionSym =
1963 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1964 if (useSplitDwarf())
1965 DwarfAbbrevDWOSectionSym = emitSectionSym(
1966 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1967 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1969 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1970 emitSectionSym(Asm, MacroInfo);
1972 DwarfLineSectionSym =
1973 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1974 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1975 if (GenerateGnuPubSections) {
1976 DwarfGnuPubNamesSectionSym =
1977 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1978 DwarfGnuPubTypesSectionSym =
1979 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1980 } else if (HasDwarfPubSections) {
1981 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1982 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1985 DwarfStrSectionSym =
1986 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1987 if (useSplitDwarf()) {
1988 DwarfStrDWOSectionSym =
1989 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1990 DwarfAddrSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1993 DwarfDebugRangeSectionSym =
1994 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
1996 DwarfDebugLocSectionSym =
1997 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2000 // Recursively emits a debug information entry.
2001 void DwarfDebug::emitDIE(DIE *Die) {
2002 // Get the abbreviation for this DIE.
2003 const DIEAbbrev &Abbrev = Die->getAbbrev();
2005 // Emit the code (index) for the abbreviation.
2006 if (Asm->isVerbose())
2007 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2008 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2009 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2010 dwarf::TagString(Abbrev.getTag()));
2011 Asm->EmitULEB128(Abbrev.getNumber());
2013 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2014 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2016 // Emit the DIE attribute values.
2017 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2018 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2019 dwarf::Form Form = AbbrevData[i].getForm();
2020 assert(Form && "Too many attributes for DIE (check abbreviation)");
2022 if (Asm->isVerbose())
2023 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2026 case dwarf::DW_AT_abstract_origin:
2027 case dwarf::DW_AT_type:
2028 case dwarf::DW_AT_friend:
2029 case dwarf::DW_AT_specification:
2030 case dwarf::DW_AT_import:
2031 case dwarf::DW_AT_containing_type: {
2032 DIEEntry *E = cast<DIEEntry>(Values[i]);
2033 DIE *Origin = E->getEntry();
2034 unsigned Addr = Origin->getOffset();
2035 if (Form == dwarf::DW_FORM_ref_addr) {
2036 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2037 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2038 // section. Origin->getOffset() returns the offset from start of the
2040 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2041 assert(CU && "CUDie should belong to a CU.");
2042 Addr += CU->getDebugInfoOffset();
2043 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2044 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2045 DIEEntry::getRefAddrSize(Asm));
2047 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2048 CU->getSectionSym(),
2049 DIEEntry::getRefAddrSize(Asm));
2051 // Make sure Origin belong to the same CU.
2052 assert(Die->getUnit() == Origin->getUnit() &&
2053 "The referenced DIE should belong to the same CU in ref4");
2054 Asm->EmitInt32(Addr);
2058 case dwarf::DW_AT_location: {
2059 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2060 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2061 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2063 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2065 Values[i]->EmitValue(Asm, Form);
2069 case dwarf::DW_AT_accessibility: {
2070 if (Asm->isVerbose()) {
2071 DIEInteger *V = cast<DIEInteger>(Values[i]);
2072 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2074 Values[i]->EmitValue(Asm, Form);
2078 // Emit an attribute using the defined form.
2079 Values[i]->EmitValue(Asm, Form);
2084 // Emit the DIE children if any.
2085 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2086 const std::vector<DIE *> &Children = Die->getChildren();
2088 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2089 emitDIE(Children[j]);
2091 Asm->OutStreamer.AddComment("End Of Children Mark");
2096 // Emit the various dwarf units to the unit section USection with
2097 // the abbreviations going into ASection.
2098 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2099 const MCSymbol *ASectionSym) {
2100 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2102 DwarfUnit *TheU = *I;
2103 DIE *Die = TheU->getUnitDie();
2104 const MCSection *USection = TheU->getSection();
2105 Asm->OutStreamer.SwitchSection(USection);
2107 // Emit the compile units header.
2108 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2110 // Emit size of content not including length itself
2111 Asm->OutStreamer.AddComment("Length of Unit");
2112 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2114 TheU->emitHeader(ASection, ASectionSym);
2117 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2121 // Emit the debug info section.
2122 void DwarfDebug::emitDebugInfo() {
2123 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2125 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2126 DwarfAbbrevSectionSym);
2129 // Emit the abbreviation section.
2130 void DwarfDebug::emitAbbreviations() {
2131 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2133 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2136 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2137 // Check to see if it is worth the effort.
2138 if (!Abbreviations.empty()) {
2139 // Start the debug abbrev section.
2140 Asm->OutStreamer.SwitchSection(Section);
2142 // For each abbrevation.
2143 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2144 // Get abbreviation data
2145 const DIEAbbrev *Abbrev = Abbreviations[i];
2147 // Emit the abbrevations code (base 1 index.)
2148 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2150 // Emit the abbreviations data.
2154 // Mark end of abbreviations.
2155 Asm->EmitULEB128(0, "EOM(3)");
2159 // Emit the last address of the section and the end of the line matrix.
2160 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2161 // Define last address of section.
2162 Asm->OutStreamer.AddComment("Extended Op");
2165 Asm->OutStreamer.AddComment("Op size");
2166 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2167 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2168 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2170 Asm->OutStreamer.AddComment("Section end label");
2172 Asm->OutStreamer.EmitSymbolValue(
2173 Asm->GetTempSymbol("section_end", SectionEnd),
2174 Asm->getDataLayout().getPointerSize());
2176 // Mark end of matrix.
2177 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2183 // Emit visible names into a hashed accelerator table section.
2184 void DwarfDebug::emitAccelNames() {
2186 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2187 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2188 E = getUnits().end();
2190 DwarfUnit *TheU = *I;
2191 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2192 for (StringMap<std::vector<const DIE *> >::const_iterator
2196 StringRef Name = GI->getKey();
2197 const std::vector<const DIE *> &Entities = GI->second;
2198 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2199 DE = Entities.end();
2201 AT.AddName(Name, *DI);
2205 AT.FinalizeTable(Asm, "Names");
2206 Asm->OutStreamer.SwitchSection(
2207 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2208 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2209 Asm->OutStreamer.EmitLabel(SectionBegin);
2211 // Emit the full data.
2212 AT.Emit(Asm, SectionBegin, &InfoHolder);
2215 // Emit objective C classes and categories into a hashed accelerator table
2217 void DwarfDebug::emitAccelObjC() {
2219 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2220 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2221 E = getUnits().end();
2223 DwarfUnit *TheU = *I;
2224 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2225 for (StringMap<std::vector<const DIE *> >::const_iterator
2229 StringRef Name = GI->getKey();
2230 const std::vector<const DIE *> &Entities = GI->second;
2231 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2232 DE = Entities.end();
2234 AT.AddName(Name, *DI);
2238 AT.FinalizeTable(Asm, "ObjC");
2239 Asm->OutStreamer.SwitchSection(
2240 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2241 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2242 Asm->OutStreamer.EmitLabel(SectionBegin);
2244 // Emit the full data.
2245 AT.Emit(Asm, SectionBegin, &InfoHolder);
2248 // Emit namespace dies into a hashed accelerator table.
2249 void DwarfDebug::emitAccelNamespaces() {
2251 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2252 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2253 E = getUnits().end();
2255 DwarfUnit *TheU = *I;
2256 const StringMap<std::vector<const DIE *> > &Names =
2257 TheU->getAccelNamespace();
2258 for (StringMap<std::vector<const DIE *> >::const_iterator
2262 StringRef Name = GI->getKey();
2263 const std::vector<const DIE *> &Entities = GI->second;
2264 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2265 DE = Entities.end();
2267 AT.AddName(Name, *DI);
2271 AT.FinalizeTable(Asm, "namespac");
2272 Asm->OutStreamer.SwitchSection(
2273 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2274 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2275 Asm->OutStreamer.EmitLabel(SectionBegin);
2277 // Emit the full data.
2278 AT.Emit(Asm, SectionBegin, &InfoHolder);
2281 // Emit type dies into a hashed accelerator table.
2282 void DwarfDebug::emitAccelTypes() {
2283 std::vector<DwarfAccelTable::Atom> Atoms;
2285 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2287 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2289 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2290 DwarfAccelTable AT(Atoms);
2291 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2292 E = getUnits().end();
2294 DwarfUnit *TheU = *I;
2295 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2296 TheU->getAccelTypes();
2298 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2302 StringRef Name = GI->getKey();
2303 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2305 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2306 DI = Entities.begin(),
2307 DE = Entities.end();
2309 AT.AddName(Name, DI->first, DI->second);
2313 AT.FinalizeTable(Asm, "types");
2314 Asm->OutStreamer.SwitchSection(
2315 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2316 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2317 Asm->OutStreamer.EmitLabel(SectionBegin);
2319 // Emit the full data.
2320 AT.Emit(Asm, SectionBegin, &InfoHolder);
2323 // Public name handling.
2324 // The format for the various pubnames:
2326 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2327 // for the DIE that is named.
2329 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2330 // into the CU and the index value is computed according to the type of value
2331 // for the DIE that is named.
2333 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2334 // it's the offset within the debug_info/debug_types dwo section, however, the
2335 // reference in the pubname header doesn't change.
2337 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2338 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2340 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2342 // We could have a specification DIE that has our most of our knowledge,
2343 // look for that now.
2344 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2346 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2347 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2348 Linkage = dwarf::GIEL_EXTERNAL;
2349 } else if (Die->findAttribute(dwarf::DW_AT_external))
2350 Linkage = dwarf::GIEL_EXTERNAL;
2352 switch (Die->getTag()) {
2353 case dwarf::DW_TAG_class_type:
2354 case dwarf::DW_TAG_structure_type:
2355 case dwarf::DW_TAG_union_type:
2356 case dwarf::DW_TAG_enumeration_type:
2357 return dwarf::PubIndexEntryDescriptor(
2358 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2359 ? dwarf::GIEL_STATIC
2360 : dwarf::GIEL_EXTERNAL);
2361 case dwarf::DW_TAG_typedef:
2362 case dwarf::DW_TAG_base_type:
2363 case dwarf::DW_TAG_subrange_type:
2364 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2365 case dwarf::DW_TAG_namespace:
2366 return dwarf::GIEK_TYPE;
2367 case dwarf::DW_TAG_subprogram:
2368 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2369 case dwarf::DW_TAG_constant:
2370 case dwarf::DW_TAG_variable:
2371 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2372 case dwarf::DW_TAG_enumerator:
2373 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2374 dwarf::GIEL_STATIC);
2376 return dwarf::GIEK_NONE;
2380 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2382 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2383 const MCSection *PSec =
2384 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2385 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2387 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2388 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2389 for (unsigned i = 0; i != Units.size(); ++i) {
2390 DwarfUnit *TheU = Units[i];
2391 unsigned ID = TheU->getUniqueID();
2393 // Start the dwarf pubnames section.
2394 Asm->OutStreamer.SwitchSection(PSec);
2396 // Emit a label so we can reference the beginning of this pubname section.
2398 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2401 Asm->OutStreamer.AddComment("Length of Public Names Info");
2402 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2403 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2404 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2406 Asm->OutStreamer.EmitLabel(BeginLabel);
2408 Asm->OutStreamer.AddComment("DWARF Version");
2409 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2411 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2412 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2414 Asm->OutStreamer.AddComment("Compilation Unit Length");
2415 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2417 // Emit the pubnames for this compilation unit.
2418 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2419 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2422 const char *Name = GI->getKeyData();
2423 const DIE *Entity = GI->second;
2425 Asm->OutStreamer.AddComment("DIE offset");
2426 Asm->EmitInt32(Entity->getOffset());
2429 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2430 Asm->OutStreamer.AddComment(
2431 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2432 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2433 Asm->EmitInt8(Desc.toBits());
2436 Asm->OutStreamer.AddComment("External Name");
2437 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2440 Asm->OutStreamer.AddComment("End Mark");
2442 Asm->OutStreamer.EmitLabel(EndLabel);
2446 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2447 const MCSection *PSec =
2448 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2449 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2451 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2452 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2453 for (unsigned i = 0; i != Units.size(); ++i) {
2454 DwarfUnit *TheU = Units[i];
2455 unsigned ID = TheU->getUniqueID();
2457 // Start the dwarf pubtypes section.
2458 Asm->OutStreamer.SwitchSection(PSec);
2460 // Emit a label so we can reference the beginning of this pubtype section.
2462 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2465 Asm->OutStreamer.AddComment("Length of Public Types Info");
2466 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2467 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2468 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2470 Asm->OutStreamer.EmitLabel(BeginLabel);
2472 Asm->OutStreamer.AddComment("DWARF Version");
2473 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2475 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2476 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2478 Asm->OutStreamer.AddComment("Compilation Unit Length");
2479 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2481 // Emit the pubtypes.
2482 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2483 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2486 const char *Name = GI->getKeyData();
2487 const DIE *Entity = GI->second;
2489 Asm->OutStreamer.AddComment("DIE offset");
2490 Asm->EmitInt32(Entity->getOffset());
2493 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2494 Asm->OutStreamer.AddComment(
2495 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2496 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2497 Asm->EmitInt8(Desc.toBits());
2500 Asm->OutStreamer.AddComment("External Name");
2502 // Emit the name with a terminating null byte.
2503 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2506 Asm->OutStreamer.AddComment("End Mark");
2508 Asm->OutStreamer.EmitLabel(EndLabel);
2512 // Emit strings into a string section.
2513 void DwarfFile::emitStrings(const MCSection *StrSection,
2514 const MCSection *OffsetSection = NULL,
2515 const MCSymbol *StrSecSym = NULL) {
2517 if (StringPool.empty())
2520 // Start the dwarf str section.
2521 Asm->OutStreamer.SwitchSection(StrSection);
2523 // Get all of the string pool entries and put them in an array by their ID so
2524 // we can sort them.
2526 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2529 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2530 I = StringPool.begin(),
2531 E = StringPool.end();
2533 Entries.push_back(std::make_pair(I->second.second, &*I));
2535 array_pod_sort(Entries.begin(), Entries.end());
2537 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2538 // Emit a label for reference from debug information entries.
2539 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2541 // Emit the string itself with a terminating null byte.
2542 Asm->OutStreamer.EmitBytes(
2543 StringRef(Entries[i].second->getKeyData(),
2544 Entries[i].second->getKeyLength() + 1));
2547 // If we've got an offset section go ahead and emit that now as well.
2548 if (OffsetSection) {
2549 Asm->OutStreamer.SwitchSection(OffsetSection);
2550 unsigned offset = 0;
2551 unsigned size = 4; // FIXME: DWARF64 is 8.
2552 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2553 Asm->OutStreamer.EmitIntValue(offset, size);
2554 offset += Entries[i].second->getKeyLength() + 1;
2559 // Emit addresses into the section given.
2560 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2562 if (AddressPool.empty())
2565 // Start the dwarf addr section.
2566 Asm->OutStreamer.SwitchSection(AddrSection);
2568 // Order the address pool entries by ID
2569 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2571 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2572 E = AddressPool.end();
2574 Entries[I->second] = I->first;
2576 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2577 // Emit an expression for reference from debug information entries.
2578 if (const MCExpr *Expr = Entries[i])
2579 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2581 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2585 // Emit visible names into a debug str section.
2586 void DwarfDebug::emitDebugStr() {
2587 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2588 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2591 // Emit locations into the debug loc section.
2592 void DwarfDebug::emitDebugLoc() {
2593 if (DotDebugLocEntries.empty())
2596 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2597 I = DotDebugLocEntries.begin(),
2598 E = DotDebugLocEntries.end();
2600 DotDebugLocEntry &Entry = *I;
2601 if (I + 1 != DotDebugLocEntries.end())
2605 // Start the dwarf loc section.
2606 Asm->OutStreamer.SwitchSection(
2607 Asm->getObjFileLowering().getDwarfLocSection());
2608 unsigned char Size = Asm->getDataLayout().getPointerSize();
2609 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2611 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2612 I = DotDebugLocEntries.begin(),
2613 E = DotDebugLocEntries.end();
2614 I != E; ++I, ++index) {
2615 DotDebugLocEntry &Entry = *I;
2616 if (Entry.isMerged())
2618 if (Entry.isEmpty()) {
2619 Asm->OutStreamer.EmitIntValue(0, Size);
2620 Asm->OutStreamer.EmitIntValue(0, Size);
2621 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2623 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2624 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2625 DIVariable DV(Entry.getVariable());
2626 Asm->OutStreamer.AddComment("Loc expr size");
2627 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2628 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2629 Asm->EmitLabelDifference(end, begin, 2);
2630 Asm->OutStreamer.EmitLabel(begin);
2631 if (Entry.isInt()) {
2632 DIBasicType BTy(DV.getType());
2633 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2634 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2635 Asm->OutStreamer.AddComment("DW_OP_consts");
2636 Asm->EmitInt8(dwarf::DW_OP_consts);
2637 Asm->EmitSLEB128(Entry.getInt());
2639 Asm->OutStreamer.AddComment("DW_OP_constu");
2640 Asm->EmitInt8(dwarf::DW_OP_constu);
2641 Asm->EmitULEB128(Entry.getInt());
2643 } else if (Entry.isLocation()) {
2644 MachineLocation Loc = Entry.getLoc();
2645 if (!DV.hasComplexAddress())
2647 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2649 // Complex address entry.
2650 unsigned N = DV.getNumAddrElements();
2652 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2653 if (Loc.getOffset()) {
2655 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2656 Asm->OutStreamer.AddComment("DW_OP_deref");
2657 Asm->EmitInt8(dwarf::DW_OP_deref);
2658 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2659 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2660 Asm->EmitSLEB128(DV.getAddrElement(1));
2662 // If first address element is OpPlus then emit
2663 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2664 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2665 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2669 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2672 // Emit remaining complex address elements.
2673 for (; i < N; ++i) {
2674 uint64_t Element = DV.getAddrElement(i);
2675 if (Element == DIBuilder::OpPlus) {
2676 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2677 Asm->EmitULEB128(DV.getAddrElement(++i));
2678 } else if (Element == DIBuilder::OpDeref) {
2680 Asm->EmitInt8(dwarf::DW_OP_deref);
2682 llvm_unreachable("unknown Opcode found in complex address");
2686 // else ... ignore constant fp. There is not any good way to
2687 // to represent them here in dwarf.
2688 Asm->OutStreamer.EmitLabel(end);
2693 struct SymbolCUSorter {
2694 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2695 const MCStreamer &Streamer;
2697 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2698 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2699 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2701 // Symbols with no order assigned should be placed at the end.
2702 // (e.g. section end labels)
2704 IA = (unsigned)(-1);
2706 IB = (unsigned)(-1);
2711 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2712 return (A->getUniqueID() < B->getUniqueID());
2716 const MCSymbol *Start, *End;
2719 // Emit a debug aranges section, containing a CU lookup for any
2720 // address we can tie back to a CU.
2721 void DwarfDebug::emitDebugARanges() {
2722 // Start the dwarf aranges section.
2723 Asm->OutStreamer.SwitchSection(
2724 Asm->getObjFileLowering().getDwarfARangesSection());
2726 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2730 // Build a list of sections used.
2731 std::vector<const MCSection *> Sections;
2732 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2734 const MCSection *Section = it->first;
2735 Sections.push_back(Section);
2738 // Sort the sections into order.
2739 // This is only done to ensure consistent output order across different runs.
2740 std::sort(Sections.begin(), Sections.end(), SectionSort);
2742 // Build a set of address spans, sorted by CU.
2743 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2744 const MCSection *Section = Sections[SecIdx];
2745 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2746 if (List.size() < 2)
2749 // Sort the symbols by offset within the section.
2750 SymbolCUSorter sorter(Asm->OutStreamer);
2751 std::sort(List.begin(), List.end(), sorter);
2753 // If we have no section (e.g. common), just write out
2754 // individual spans for each symbol.
2755 if (Section == NULL) {
2756 for (size_t n = 0; n < List.size(); n++) {
2757 const SymbolCU &Cur = List[n];
2760 Span.Start = Cur.Sym;
2763 Spans[Cur.CU].push_back(Span);
2766 // Build spans between each label.
2767 const MCSymbol *StartSym = List[0].Sym;
2768 for (size_t n = 1; n < List.size(); n++) {
2769 const SymbolCU &Prev = List[n - 1];
2770 const SymbolCU &Cur = List[n];
2772 // Try and build the longest span we can within the same CU.
2773 if (Cur.CU != Prev.CU) {
2775 Span.Start = StartSym;
2777 Spans[Prev.CU].push_back(Span);
2784 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2786 // Build a list of CUs used.
2787 std::vector<DwarfCompileUnit *> CUs;
2788 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2789 DwarfCompileUnit *CU = it->first;
2793 // Sort the CU list (again, to ensure consistent output order).
2794 std::sort(CUs.begin(), CUs.end(), CUSort);
2796 // Emit an arange table for each CU we used.
2797 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2798 DwarfCompileUnit *CU = CUs[CUIdx];
2799 std::vector<ArangeSpan> &List = Spans[CU];
2801 // Emit size of content not including length itself.
2802 unsigned ContentSize =
2803 sizeof(int16_t) + // DWARF ARange version number
2804 sizeof(int32_t) + // Offset of CU in the .debug_info section
2805 sizeof(int8_t) + // Pointer Size (in bytes)
2806 sizeof(int8_t); // Segment Size (in bytes)
2808 unsigned TupleSize = PtrSize * 2;
2810 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2812 OffsetToAlignment(sizeof(int32_t) + ContentSize, TupleSize);
2814 ContentSize += Padding;
2815 ContentSize += (List.size() + 1) * TupleSize;
2817 // For each compile unit, write the list of spans it covers.
2818 Asm->OutStreamer.AddComment("Length of ARange Set");
2819 Asm->EmitInt32(ContentSize);
2820 Asm->OutStreamer.AddComment("DWARF Arange version number");
2821 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2822 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2823 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2824 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2825 Asm->EmitInt8(PtrSize);
2826 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2829 Asm->OutStreamer.EmitFill(Padding, 0xff);
2831 for (unsigned n = 0; n < List.size(); n++) {
2832 const ArangeSpan &Span = List[n];
2833 Asm->EmitLabelReference(Span.Start, PtrSize);
2835 // Calculate the size as being from the span start to it's end.
2837 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2839 // For symbols without an end marker (e.g. common), we
2840 // write a single arange entry containing just that one symbol.
2841 uint64_t Size = SymSize[Span.Start];
2845 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2849 Asm->OutStreamer.AddComment("ARange terminator");
2850 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2851 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2855 // Emit visible names into a debug ranges section.
2856 void DwarfDebug::emitDebugRanges() {
2857 // Start the dwarf ranges section.
2858 Asm->OutStreamer.SwitchSection(
2859 Asm->getObjFileLowering().getDwarfRangesSection());
2861 // Size for our labels.
2862 unsigned char Size = Asm->getDataLayout().getPointerSize();
2864 // Grab the specific ranges for the compile units in the module.
2865 for (MapVector<const MDNode *, DwarfCompileUnit *>::iterator
2869 DwarfCompileUnit *TheCU = I->second;
2871 // Emit a symbol so we can find the beginning of our ranges.
2872 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2874 // Iterate over the misc ranges for the compile units in the module.
2875 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2876 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2877 E = RangeLists.end();
2879 const RangeSpanList &List = *I;
2881 // Emit our symbol so we can find the beginning of the range.
2882 Asm->OutStreamer.EmitLabel(List.getSym());
2884 for (SmallVectorImpl<RangeSpan>::const_iterator
2885 RI = List.getRanges().begin(),
2886 RE = List.getRanges().end();
2888 const RangeSpan &Range = *RI;
2889 const MCSymbol *Begin = Range.getStart();
2890 const MCSymbol *End = Range.getEnd();
2891 assert(Begin && "Range without a begin symbol?");
2892 assert(End && "Range without an end symbol?");
2893 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2894 Asm->OutStreamer.EmitSymbolValue(End, Size);
2897 // And terminate the list with two 0 values.
2898 Asm->OutStreamer.EmitIntValue(0, Size);
2899 Asm->OutStreamer.EmitIntValue(0, Size);
2902 // Now emit a range for the CU itself.
2903 if (useCURanges()) {
2904 Asm->OutStreamer.EmitLabel(
2905 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2906 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2907 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2908 RangeSpan Range = Ranges[i];
2909 const MCSymbol *Begin = Range.getStart();
2910 const MCSymbol *End = Range.getEnd();
2911 assert(Begin && "Range without a begin symbol?");
2912 assert(End && "Range without an end symbol?");
2913 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2914 Asm->OutStreamer.EmitSymbolValue(End, Size);
2916 // And terminate the list with two 0 values.
2917 Asm->OutStreamer.EmitIntValue(0, Size);
2918 Asm->OutStreamer.EmitIntValue(0, Size);
2923 // DWARF5 Experimental Separate Dwarf emitters.
2925 void DwarfDebug::initSkeletonUnit(const DwarfUnit *U, DIE *Die,
2927 NewU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2928 U->getCUNode().getSplitDebugFilename());
2930 // Relocate to the beginning of the addr_base section, else 0 for the
2931 // beginning of the one for this compile unit.
2932 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2933 NewU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base, DwarfAddrSectionSym);
2935 NewU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2937 if (!CompilationDir.empty())
2938 NewU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2940 addGnuPubAttributes(NewU, Die);
2942 SkeletonHolder.addUnit(NewU);
2945 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2946 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2947 // DW_AT_ranges_base, DW_AT_addr_base.
2948 // TODO: Implement DW_AT_ranges_base.
2949 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2951 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2952 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2953 CU->getUniqueID(), Die, CU->getCUNode(), Asm, this, &SkeletonHolder);
2954 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2955 DwarfInfoSectionSym);
2957 // DW_AT_stmt_list is a offset of line number information for this
2958 // compile unit in debug_line section.
2959 // FIXME: Should handle multiple compile units.
2960 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2961 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
2963 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2965 initSkeletonUnit(CU, Die, NewCU);
2970 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_dwo_name,
2972 DwarfTypeUnit *DwarfDebug::constructSkeletonTU(const DwarfTypeUnit *TU) {
2974 DIE *Die = new DIE(dwarf::DW_TAG_type_unit);
2975 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
2976 TU->getUniqueID(), Die, TU->getCUNode(), Asm, this, &SkeletonHolder);
2977 NewTU->setTypeSignature(TU->getTypeSignature());
2978 NewTU->setType(NULL);
2980 Asm->getObjFileLowering().getDwarfTypesSection(TU->getTypeSignature()));
2982 initSkeletonUnit(TU, Die, NewTU);
2986 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2987 // compile units that would normally be in debug_info.
2988 void DwarfDebug::emitDebugInfoDWO() {
2989 assert(useSplitDwarf() && "No split dwarf debug info?");
2990 InfoHolder.emitUnits(this,
2991 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2992 DwarfAbbrevDWOSectionSym);
2995 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2996 // abbreviations for the .debug_info.dwo section.
2997 void DwarfDebug::emitDebugAbbrevDWO() {
2998 assert(useSplitDwarf() && "No split dwarf?");
2999 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3002 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3003 // string section and is identical in format to traditional .debug_str
3005 void DwarfDebug::emitDebugStrDWO() {
3006 assert(useSplitDwarf() && "No split dwarf?");
3007 const MCSection *OffSec =
3008 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3009 const MCSymbol *StrSym = DwarfStrSectionSym;
3010 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3014 void DwarfDebug::addDwarfTypeUnitType(DICompileUnit CUNode,
3015 StringRef Identifier, DIE *RefDie,
3016 DICompositeType CTy) {
3017 // Flag the type unit reference as a declaration so that if it contains
3018 // members (implicit special members, static data member definitions, member
3019 // declarations for definitions in this CU, etc) consumers don't get confused
3020 // and think this is a full definition.
3021 CUMap.begin()->second->addFlag(RefDie, dwarf::DW_AT_declaration);
3023 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3025 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
3029 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3030 DwarfTypeUnit *NewTU = new DwarfTypeUnit(
3031 InfoHolder.getUnits().size(), UnitDie, CUNode, Asm, this, &InfoHolder);
3033 InfoHolder.addUnit(NewTU);
3035 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3036 CUNode.getLanguage());
3039 Hash.update(Identifier);
3040 // ... take the least significant 8 bytes and return those. Our MD5
3041 // implementation always returns its results in little endian, swap bytes
3043 MD5::MD5Result Result;
3045 uint64_t Signature = *reinterpret_cast<support::ulittle64_t *>(Result + 8);
3046 NewTU->setTypeSignature(Signature);
3047 if (useSplitDwarf())
3048 NewTU->setSkeleton(constructSkeletonTU(NewTU));
3050 NewTU->setType(NewTU->createTypeDIE(CTy));
3054 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3055 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3057 CUMap.begin()->second->addDIETypeSignature(RefDie, *NewTU);