1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
18 #include "DwarfAccelTable.h"
19 #include "DwarfUnit.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DebugInfo.h"
28 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/Module.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCSection.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/CommandLine.h"
37 #include "llvm/Support/Debug.h"
38 #include "llvm/Support/Dwarf.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FormattedStream.h"
41 #include "llvm/Support/MD5.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/ValueHandle.h"
45 #include "llvm/Target/TargetFrameLowering.h"
46 #include "llvm/Target/TargetLoweringObjectFile.h"
47 #include "llvm/Target/TargetMachine.h"
48 #include "llvm/Target/TargetOptions.h"
49 #include "llvm/Target/TargetRegisterInfo.h"
53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
54 cl::desc("Disable debug info printing"));
56 static cl::opt<bool> UnknownLocations(
57 "use-unknown-locations", cl::Hidden,
58 cl::desc("Make an absence of debug location information explicit."),
62 GenerateODRHash("generate-odr-hash", cl::Hidden,
63 cl::desc("Add an ODR hash to external type DIEs."),
66 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
67 cl::desc("Add the CU hash as the dwo_id."),
71 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
72 cl::desc("Generate GNU-style pubnames and pubtypes"),
83 static cl::opt<DefaultOnOff>
84 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
85 cl::desc("Output prototype dwarf accelerator tables."),
86 cl::values(clEnumVal(Default, "Default for platform"),
87 clEnumVal(Enable, "Enabled"),
88 clEnumVal(Disable, "Disabled"), clEnumValEnd),
91 static cl::opt<DefaultOnOff>
92 SplitDwarf("split-dwarf", cl::Hidden,
93 cl::desc("Output DWARF5 split debug info."),
94 cl::values(clEnumVal(Default, "Default for platform"),
95 clEnumVal(Enable, "Enabled"),
96 clEnumVal(Disable, "Disabled"), clEnumValEnd),
99 static cl::opt<DefaultOnOff>
100 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
101 cl::desc("Generate DWARF pubnames and pubtypes sections"),
102 cl::values(clEnumVal(Default, "Default for platform"),
103 clEnumVal(Enable, "Enabled"),
104 clEnumVal(Disable, "Disabled"), clEnumValEnd),
107 static cl::opt<unsigned>
108 DwarfVersionNumber("dwarf-version", cl::Hidden,
109 cl::desc("Generate DWARF for dwarf version."), cl::init(0));
112 DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
113 cl::desc("Generate DW_AT_ranges for compile units"),
116 static const char *const DWARFGroupName = "DWARF Emission";
117 static const char *const DbgTimerName = "DWARF Debug Writer";
119 //===----------------------------------------------------------------------===//
123 /// resolve - Look in the DwarfDebug map for the MDNode that
124 /// corresponds to the reference.
125 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
126 return DD->resolve(Ref);
129 DIType DbgVariable::getType() const {
130 DIType Ty = Var.getType();
131 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
132 // addresses instead.
133 if (Var.isBlockByrefVariable()) {
134 /* Byref variables, in Blocks, are declared by the programmer as
135 "SomeType VarName;", but the compiler creates a
136 __Block_byref_x_VarName struct, and gives the variable VarName
137 either the struct, or a pointer to the struct, as its type. This
138 is necessary for various behind-the-scenes things the compiler
139 needs to do with by-reference variables in blocks.
141 However, as far as the original *programmer* is concerned, the
142 variable should still have type 'SomeType', as originally declared.
144 The following function dives into the __Block_byref_x_VarName
145 struct to find the original type of the variable. This will be
146 passed back to the code generating the type for the Debug
147 Information Entry for the variable 'VarName'. 'VarName' will then
148 have the original type 'SomeType' in its debug information.
150 The original type 'SomeType' will be the type of the field named
151 'VarName' inside the __Block_byref_x_VarName struct.
153 NOTE: In order for this to not completely fail on the debugger
154 side, the Debug Information Entry for the variable VarName needs to
155 have a DW_AT_location that tells the debugger how to unwind through
156 the pointers and __Block_byref_x_VarName struct to find the actual
157 value of the variable. The function addBlockByrefType does this. */
159 uint16_t tag = Ty.getTag();
161 if (tag == dwarf::DW_TAG_pointer_type)
162 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
164 DIArray Elements = DICompositeType(subType).getTypeArray();
165 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
166 DIDerivedType DT(Elements.getElement(i));
167 if (getName() == DT.getName())
168 return (resolve(DT.getTypeDerivedFrom()));
174 } // end llvm namespace
176 /// Return Dwarf Version by checking module flags.
177 static unsigned getDwarfVersionFromModule(const Module *M) {
178 Value *Val = M->getModuleFlag("Dwarf Version");
180 return dwarf::DWARF_VERSION;
181 return cast<ConstantInt>(Val)->getZExtValue();
184 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
185 : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
186 PrevLabel(NULL), GlobalRangeCount(0),
187 InfoHolder(A, "info_string", DIEValueAllocator),
188 SkeletonHolder(A, "skel_string", DIEValueAllocator) {
190 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
191 DwarfStrSectionSym = TextSectionSym = 0;
192 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
193 DwarfAddrSectionSym = 0;
194 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
195 FunctionBeginSym = FunctionEndSym = 0;
199 // Turn on accelerator tables for Darwin by default, pubnames by
200 // default for non-Darwin, and handle split dwarf.
201 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
203 if (DwarfAccelTables == Default)
204 HasDwarfAccelTables = IsDarwin;
206 HasDwarfAccelTables = DwarfAccelTables == Enable;
208 if (SplitDwarf == Default)
209 HasSplitDwarf = false;
211 HasSplitDwarf = SplitDwarf == Enable;
213 if (DwarfPubSections == Default)
214 HasDwarfPubSections = !IsDarwin;
216 HasDwarfPubSections = DwarfPubSections == Enable;
218 DwarfVersion = DwarfVersionNumber
220 : getDwarfVersionFromModule(MMI->getModule());
223 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
228 // Switch to the specified MCSection and emit an assembler
229 // temporary label to it if SymbolStem is specified.
230 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
231 const char *SymbolStem = 0) {
232 Asm->OutStreamer.SwitchSection(Section);
236 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
237 Asm->OutStreamer.EmitLabel(TmpSym);
241 DwarfFile::~DwarfFile() {
242 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
247 MCSymbol *DwarfFile::getStringPoolSym() {
248 return Asm->GetTempSymbol(StringPref);
251 MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
252 std::pair<MCSymbol *, unsigned> &Entry =
253 StringPool.GetOrCreateValue(Str).getValue();
257 Entry.second = NextStringPoolNumber++;
258 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
261 unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
262 std::pair<MCSymbol *, unsigned> &Entry =
263 StringPool.GetOrCreateValue(Str).getValue();
267 Entry.second = NextStringPoolNumber++;
268 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
272 unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
273 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
276 unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
277 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
278 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
280 ++NextAddrPoolNumber;
281 return P.first->second;
284 // Define a unique number for the abbreviation.
286 void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
287 // Check the set for priors.
288 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
290 // If it's newly added.
291 if (InSet == &Abbrev) {
292 // Add to abbreviation list.
293 Abbreviations.push_back(&Abbrev);
295 // Assign the vector position + 1 as its number.
296 Abbrev.setNumber(Abbreviations.size());
298 // Assign existing abbreviation number.
299 Abbrev.setNumber(InSet->getNumber());
303 static bool isObjCClass(StringRef Name) {
304 return Name.startswith("+") || Name.startswith("-");
307 static bool hasObjCCategory(StringRef Name) {
308 if (!isObjCClass(Name))
311 return Name.find(") ") != StringRef::npos;
314 static void getObjCClassCategory(StringRef In, StringRef &Class,
315 StringRef &Category) {
316 if (!hasObjCCategory(In)) {
317 Class = In.slice(In.find('[') + 1, In.find(' '));
322 Class = In.slice(In.find('[') + 1, In.find('('));
323 Category = In.slice(In.find('[') + 1, In.find(' '));
327 static StringRef getObjCMethodName(StringRef In) {
328 return In.slice(In.find(' ') + 1, In.find(']'));
331 // Helper for sorting sections into a stable output order.
332 static bool SectionSort(const MCSection *A, const MCSection *B) {
333 std::string LA = (A ? A->getLabelBeginName() : "");
334 std::string LB = (B ? B->getLabelBeginName() : "");
338 // Add the various names to the Dwarf accelerator table names.
339 // TODO: Determine whether or not we should add names for programs
340 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
341 // is only slightly different than the lookup of non-standard ObjC names.
342 static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
343 if (!SP.isDefinition())
345 TheU->addAccelName(SP.getName(), Die);
347 // If the linkage name is different than the name, go ahead and output
348 // that as well into the name table.
349 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
350 TheU->addAccelName(SP.getLinkageName(), Die);
352 // If this is an Objective-C selector name add it to the ObjC accelerator
354 if (isObjCClass(SP.getName())) {
355 StringRef Class, Category;
356 getObjCClassCategory(SP.getName(), Class, Category);
357 TheU->addAccelObjC(Class, Die);
359 TheU->addAccelObjC(Category, Die);
360 // Also add the base method name to the name table.
361 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
365 /// isSubprogramContext - Return true if Context is either a subprogram
366 /// or another context nested inside a subprogram.
367 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
370 DIDescriptor D(Context);
371 if (D.isSubprogram())
374 return isSubprogramContext(resolve(DIType(Context).getContext()));
378 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
379 // and DW_AT_high_pc attributes. If there are global variables in this
380 // scope then create and insert DIEs for these variables.
381 DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
383 DIE *SPDie = SPCU->getDIE(SP);
385 assert(SPDie && "Unable to find subprogram DIE!");
387 // If we're updating an abstract DIE, then we will be adding the children and
388 // object pointer later on. But what we don't want to do is process the
389 // concrete DIE twice.
390 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
391 // Pick up abstract subprogram DIE.
393 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
394 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
396 DISubprogram SPDecl = SP.getFunctionDeclaration();
397 if (!SPDecl.isSubprogram()) {
398 // There is not any need to generate specification DIE for a function
399 // defined at compile unit level. If a function is defined inside another
400 // function then gdb prefers the definition at top level and but does not
401 // expect specification DIE in parent function. So avoid creating
402 // specification DIE for a function defined inside a function.
403 DIScope SPContext = resolve(SP.getContext());
404 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
405 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
406 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
409 DICompositeType SPTy = SP.getType();
410 DIArray Args = SPTy.getTypeArray();
411 uint16_t SPTag = SPTy.getTag();
412 if (SPTag == dwarf::DW_TAG_subroutine_type)
413 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
415 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
416 DIType ATy(Args.getElement(i));
417 SPCU->addType(Arg, ATy);
418 if (ATy.isArtificial())
419 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
420 if (ATy.isObjectPointer())
421 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
423 DIE *SPDeclDie = SPDie;
424 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
425 *SPCU->getUnitDie());
426 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
431 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
432 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
434 // Add this range to the list of ranges for the CU.
435 RangeSpan Span(FunctionBeginSym, FunctionEndSym);
436 SPCU->addRange(llvm_move(Span));
438 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
439 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
440 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
442 // Add name to the name table, we do this here because we're guaranteed
443 // to have concrete versions of our DW_TAG_subprogram nodes.
444 addSubprogramNames(SPCU, SP, SPDie);
449 /// Check whether we should create a DIE for the given Scope, return true
450 /// if we don't create a DIE (the corresponding DIE is null).
451 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
452 if (Scope->isAbstractScope())
455 // We don't create a DIE if there is no Range.
456 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
460 if (Ranges.size() > 1)
463 // We don't create a DIE if we have a single Range and the end label
465 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
466 MCSymbol *End = getLabelAfterInsn(RI->second);
470 static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
471 dwarf::Attribute A, const MCSymbol *L,
472 const MCSymbol *Sec) {
473 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
474 U->addSectionLabel(D, A, L);
476 U->addSectionDelta(D, A, L, Sec);
479 void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
480 const SmallVectorImpl<InsnRange> &Range) {
481 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
482 // emitting it appropriately.
483 MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
484 addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
485 DwarfDebugRangeSectionSym);
487 RangeSpanList List(RangeSym);
488 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
491 RangeSpan Span(getLabelBeforeInsn(RI->first),
492 getLabelAfterInsn(RI->second));
493 List.addRange(llvm_move(Span));
496 // Add the range list to the set of ranges to be emitted.
497 TheCU->addRangeList(llvm_move(List));
500 // Construct new DW_TAG_lexical_block for this scope and attach
501 // DW_AT_low_pc/DW_AT_high_pc labels.
502 DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
503 LexicalScope *Scope) {
504 if (isLexicalScopeDIENull(Scope))
507 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
508 if (Scope->isAbstractScope())
511 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
513 // If we have multiple ranges, emit them into the range section.
514 if (ScopeRanges.size() > 1) {
515 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
519 // Construct the address range for this DIE.
520 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
521 MCSymbol *Start = getLabelBeforeInsn(RI->first);
522 MCSymbol *End = getLabelAfterInsn(RI->second);
523 assert(End && "End label should not be null!");
525 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
526 assert(End->isDefined() && "Invalid end label for an inlined scope!");
528 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
529 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
534 // This scope represents inlined body of a function. Construct DIE to
535 // represent this concrete inlined copy of the function.
536 DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
537 LexicalScope *Scope) {
538 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
539 assert(!ScopeRanges.empty() &&
540 "LexicalScope does not have instruction markers!");
542 if (!Scope->getScopeNode())
544 DIScope DS(Scope->getScopeNode());
545 DISubprogram InlinedSP = getDISubprogram(DS);
546 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
548 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
552 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
553 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
555 // If we have multiple ranges, emit them into the range section.
556 if (ScopeRanges.size() > 1)
557 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
559 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
560 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
561 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
563 if (StartLabel == 0 || EndLabel == 0)
564 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
566 assert(StartLabel->isDefined() &&
567 "Invalid starting label for an inlined scope!");
568 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
570 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
571 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
574 InlinedSubprogramDIEs.insert(OriginDIE);
576 // Add the call site information to the DIE.
577 DILocation DL(Scope->getInlinedAt());
578 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
579 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
580 TheCU->getUniqueID()));
581 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
583 // Add name to the name table, we do this here because we're guaranteed
584 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
585 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
590 DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
592 SmallVectorImpl<DIE *> &Children) {
593 DIE *ObjectPointer = NULL;
595 // Collect arguments for current function.
596 if (LScopes.isCurrentFunctionScope(Scope))
597 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
598 if (DbgVariable *ArgDV = CurrentFnArguments[i])
600 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
601 Children.push_back(Arg);
602 if (ArgDV->isObjectPointer())
606 // Collect lexical scope children first.
607 const SmallVectorImpl<DbgVariable *> &Variables =
608 ScopeVariables.lookup(Scope);
609 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
610 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
611 Scope->isAbstractScope())) {
612 Children.push_back(Variable);
613 if (Variables[i]->isObjectPointer())
614 ObjectPointer = Variable;
616 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
617 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
618 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
619 Children.push_back(Nested);
620 return ObjectPointer;
623 // Construct a DIE for this scope.
624 DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
625 LexicalScope *Scope) {
626 if (!Scope || !Scope->getScopeNode())
629 DIScope DS(Scope->getScopeNode());
631 SmallVector<DIE *, 8> Children;
632 DIE *ObjectPointer = NULL;
633 bool ChildrenCreated = false;
635 // We try to create the scope DIE first, then the children DIEs. This will
636 // avoid creating un-used children then removing them later when we find out
637 // the scope DIE is null.
638 DIE *ScopeDIE = NULL;
639 if (Scope->getInlinedAt())
640 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
641 else if (DS.isSubprogram()) {
642 ProcessedSPNodes.insert(DS);
643 if (Scope->isAbstractScope()) {
644 ScopeDIE = TheCU->getDIE(DS);
645 // Note down abstract DIE.
647 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
649 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
651 // Early exit when we know the scope DIE is going to be null.
652 if (isLexicalScopeDIENull(Scope))
655 // We create children here when we know the scope DIE is not going to be
656 // null and the children will be added to the scope DIE.
657 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
658 ChildrenCreated = true;
660 // There is no need to emit empty lexical block DIE.
661 std::pair<ImportedEntityMap::const_iterator,
662 ImportedEntityMap::const_iterator> Range =
664 ScopesWithImportedEntities.begin(),
665 ScopesWithImportedEntities.end(),
666 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
668 if (Children.empty() && Range.first == Range.second)
670 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
671 assert(ScopeDIE && "Scope DIE should not be null.");
672 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
674 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
678 assert(Children.empty() &&
679 "We create children only when the scope DIE is not null.");
682 if (!ChildrenCreated)
683 // We create children when the scope DIE is not null.
684 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
687 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
690 ScopeDIE->addChild(*I);
692 if (DS.isSubprogram() && ObjectPointer != NULL)
693 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
698 // Look up the source id with the given directory and source file names.
699 // If none currently exists, create a new id and insert it in the
700 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
702 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
704 // If we use .loc in assembly, we can't separate .file entries according to
705 // compile units. Thus all files will belong to the default compile unit.
707 // FIXME: add a better feature test than hasRawTextSupport. Even better,
708 // extend .file to support this.
709 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
712 // If FE did not provide a file name, then assume stdin.
713 if (FileName.empty())
714 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
716 // TODO: this might not belong here. See if we can factor this better.
717 if (DirName == CompilationDir)
720 // FileIDCUMap stores the current ID for the given compile unit.
721 unsigned SrcId = FileIDCUMap[CUID] + 1;
723 // We look up the CUID/file/dir by concatenating them with a zero byte.
724 SmallString<128> NamePair;
725 NamePair += utostr(CUID);
728 NamePair += '\0'; // Zero bytes are not allowed in paths.
729 NamePair += FileName;
731 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
732 if (Ent.getValue() != SrcId)
733 return Ent.getValue();
735 FileIDCUMap[CUID] = SrcId;
736 // Print out a .file directive to specify files for .loc directives.
737 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
742 void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
743 if (!GenerateGnuPubSections)
746 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
747 Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
748 DwarfGnuPubNamesSectionSym);
750 addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
751 Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
752 DwarfGnuPubTypesSectionSym);
755 // Create new DwarfCompileUnit for the given metadata node with tag
756 // DW_TAG_compile_unit.
757 DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
758 StringRef FN = DIUnit.getFilename();
759 CompilationDir = DIUnit.getDirectory();
761 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
762 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
763 InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
764 InfoHolder.addUnit(NewCU);
766 FileIDCUMap[NewCU->getUniqueID()] = 0;
767 // Call this to emit a .file directive if it wasn't emitted for the source
768 // file this CU comes from yet.
769 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
771 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
772 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
773 DIUnit.getLanguage());
774 NewCU->addString(Die, dwarf::DW_AT_name, FN);
776 // Define start line table label for each Compile Unit.
777 MCSymbol *LineTableStartSym =
778 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
779 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
780 NewCU->getUniqueID());
782 // Use a single line table if we are using .loc and generating assembly.
784 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
785 (NewCU->getUniqueID() == 0);
787 if (!useSplitDwarf()) {
788 // DW_AT_stmt_list is a offset of line number information for this
789 // compile unit in debug_line section. For split dwarf this is
790 // left in the skeleton CU and so not included.
791 // The line table entries are not always emitted in assembly, so it
792 // is not okay to use line_table_start here.
793 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
794 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
795 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
796 : LineTableStartSym);
797 else if (UseTheFirstCU)
798 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
800 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
801 DwarfLineSectionSym);
803 // If we're using split dwarf the compilation dir is going to be in the
804 // skeleton CU and so we don't need to duplicate it here.
805 if (!CompilationDir.empty())
806 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
808 addGnuPubAttributes(NewCU, Die);
811 if (DIUnit.isOptimized())
812 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
814 StringRef Flags = DIUnit.getFlags();
816 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
818 if (unsigned RVer = DIUnit.getRunTimeVersion())
819 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
820 dwarf::DW_FORM_data1, RVer);
825 if (useSplitDwarf()) {
826 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
827 DwarfInfoDWOSectionSym);
828 // If we're splitting the dwarf then construct the skeleton CU now
829 // since we'll need to be able to reference the symbols in the skeleton
830 // CU during various emission passes - in particular aranges need
831 // to reference the skeleton CU.
832 NewCU->setSkeleton(constructSkeletonCU(NewCU));
834 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
835 DwarfInfoSectionSym);
837 CUMap.insert(std::make_pair(DIUnit, NewCU));
838 CUDieMap.insert(std::make_pair(Die, NewCU));
842 // Construct subprogram DIE.
843 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
845 // FIXME: We should only call this routine once, however, during LTO if a
846 // program is defined in multiple CUs we could end up calling it out of
847 // beginModule as we walk the CUs.
849 DwarfCompileUnit *&CURef = SPMap[N];
855 if (!SP.isDefinition())
856 // This is a method declaration which will be handled while constructing
860 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
862 // Expose as a global name.
863 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
866 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
868 DIImportedEntity Module(N);
869 if (!Module.Verify())
871 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
872 constructImportedEntityDIE(TheCU, Module, D);
875 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
876 const MDNode *N, DIE *Context) {
877 DIImportedEntity Module(N);
878 if (!Module.Verify())
880 return constructImportedEntityDIE(TheCU, Module, Context);
883 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
884 const DIImportedEntity &Module,
886 assert(Module.Verify() &&
887 "Use one of the MDNode * overloads to handle invalid metadata");
888 assert(Context && "Should always have a context for an imported_module");
889 DIE *IMDie = new DIE(Module.getTag());
890 TheCU->insertDIE(Module, IMDie);
892 DIDescriptor Entity = Module.getEntity();
893 if (Entity.isNameSpace())
894 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
895 else if (Entity.isSubprogram())
896 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
897 else if (Entity.isType())
898 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
900 EntityDie = TheCU->getDIE(Entity);
901 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
902 Module.getContext().getDirectory(),
903 TheCU->getUniqueID());
904 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
905 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
906 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
907 StringRef Name = Module.getName();
909 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
910 Context->addChild(IMDie);
913 // Emit all Dwarf sections that should come prior to the content. Create
914 // global DIEs and emit initial debug info sections. This is invoked by
915 // the target AsmPrinter.
916 void DwarfDebug::beginModule() {
917 if (DisableDebugInfoPrinting)
920 const Module *M = MMI->getModule();
922 // If module has named metadata anchors then use them, otherwise scan the
923 // module using debug info finder to collect debug info.
924 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
927 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
929 // Emit initial sections so we can reference labels later.
932 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
933 DICompileUnit CUNode(CU_Nodes->getOperand(i));
934 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
935 DIArray ImportedEntities = CUNode.getImportedEntities();
936 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
937 ScopesWithImportedEntities.push_back(std::make_pair(
938 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
939 ImportedEntities.getElement(i)));
940 std::sort(ScopesWithImportedEntities.begin(),
941 ScopesWithImportedEntities.end(), less_first());
942 DIArray GVs = CUNode.getGlobalVariables();
943 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
944 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
945 DIArray SPs = CUNode.getSubprograms();
946 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
947 constructSubprogramDIE(CU, SPs.getElement(i));
948 DIArray EnumTypes = CUNode.getEnumTypes();
949 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
950 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
951 DIArray RetainedTypes = CUNode.getRetainedTypes();
952 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
953 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
954 // Emit imported_modules last so that the relevant context is already
956 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
957 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
960 // Tell MMI that we have debug info.
961 MMI->setDebugInfoAvailability(true);
963 // Prime section data.
964 SectionMap[Asm->getObjFileLowering().getTextSection()];
967 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
968 void DwarfDebug::computeInlinedDIEs() {
969 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
970 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
971 AE = InlinedSubprogramDIEs.end();
974 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
976 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
977 AE = AbstractSPDies.end();
979 DIE *ISP = AI->second;
980 if (InlinedSubprogramDIEs.count(ISP))
982 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
986 // Collect info for variables that were optimized out.
987 void DwarfDebug::collectDeadVariables() {
988 const Module *M = MMI->getModule();
990 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
991 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
992 DICompileUnit TheCU(CU_Nodes->getOperand(i));
993 DIArray Subprograms = TheCU.getSubprograms();
994 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
995 DISubprogram SP(Subprograms.getElement(i));
996 if (ProcessedSPNodes.count(SP) != 0)
998 if (!SP.isSubprogram())
1000 if (!SP.isDefinition())
1002 DIArray Variables = SP.getVariables();
1003 if (Variables.getNumElements() == 0)
1006 // Construct subprogram DIE and add variables DIEs.
1007 DwarfCompileUnit *SPCU =
1008 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1009 assert(SPCU && "Unable to find Compile Unit!");
1010 // FIXME: See the comment in constructSubprogramDIE about duplicate
1012 constructSubprogramDIE(SPCU, SP);
1013 DIE *SPDIE = SPCU->getDIE(SP);
1014 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1015 DIVariable DV(Variables.getElement(vi));
1016 if (!DV.isVariable())
1018 DbgVariable NewVar(DV, NULL, this);
1019 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1020 SPDIE->addChild(VariableDIE);
1027 // Type Signature [7.27] and ODR Hash code.
1029 /// \brief Grabs the string in whichever attribute is passed in and returns
1030 /// a reference to it. Returns "" if the attribute doesn't exist.
1031 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1032 DIEValue *V = Die->findAttribute(Attr);
1034 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1035 return S->getString();
1037 return StringRef("");
1040 /// Return true if the current DIE is contained within an anonymous namespace.
1041 static bool isContainedInAnonNamespace(DIE *Die) {
1042 DIE *Parent = Die->getParent();
1045 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1046 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1048 Parent = Parent->getParent();
1054 /// Test if the current CU language is C++ and that we have
1055 /// a named type that is not contained in an anonymous namespace.
1056 static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
1057 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1058 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1059 !isContainedInAnonNamespace(Die);
1062 void DwarfDebug::finalizeModuleInfo() {
1063 // Collect info for variables that were optimized out.
1064 collectDeadVariables();
1066 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1067 computeInlinedDIEs();
1069 // Handle anything that needs to be done on a per-unit basis after
1070 // all other generation.
1071 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1072 E = getUnits().end();
1074 DwarfUnit *TheU = *I;
1075 // Emit DW_AT_containing_type attribute to connect types with their
1076 // vtable holding type.
1077 TheU->constructContainingTypeDIEs();
1079 // Add CU specific attributes if we need to add any.
1080 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1081 // If we're splitting the dwarf out now that we've got the entire
1082 // CU then add the dwo id to it.
1083 DwarfCompileUnit *SkCU =
1084 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1085 if (useSplitDwarf()) {
1086 // This should be a unique identifier when we want to build .dwp files.
1088 if (GenerateCUHash) {
1090 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1092 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1093 dwarf::DW_FORM_data8, ID);
1094 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1095 dwarf::DW_FORM_data8, ID);
1098 // If we've requested ranges and have them emit a DW_AT_ranges attribute
1099 // on the unit that will remain in the .o file, otherwise add a DW_AT_low_pc.
1100 // FIXME: Also add a high pc if we can.
1101 // FIXME: We should use ranges if we have multiple compile units.
1102 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1103 if (DwarfCURanges && TheU->getRanges().size())
1104 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1105 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1106 DwarfDebugRangeSectionSym);
1108 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
1112 // Compute DIE offsets and sizes.
1113 InfoHolder.computeSizeAndOffsets();
1114 if (useSplitDwarf())
1115 SkeletonHolder.computeSizeAndOffsets();
1118 void DwarfDebug::endSections() {
1119 // Filter labels by section.
1120 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1121 const SymbolCU &SCU = ArangeLabels[n];
1122 if (SCU.Sym->isInSection()) {
1123 // Make a note of this symbol and it's section.
1124 const MCSection *Section = &SCU.Sym->getSection();
1125 if (!Section->getKind().isMetadata())
1126 SectionMap[Section].push_back(SCU);
1128 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1129 // appear in the output. This sucks as we rely on sections to build
1130 // arange spans. We can do it without, but it's icky.
1131 SectionMap[NULL].push_back(SCU);
1135 // Build a list of sections used.
1136 std::vector<const MCSection *> Sections;
1137 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1139 const MCSection *Section = it->first;
1140 Sections.push_back(Section);
1143 // Sort the sections into order.
1144 // This is only done to ensure consistent output order across different runs.
1145 std::sort(Sections.begin(), Sections.end(), SectionSort);
1147 // Add terminating symbols for each section.
1148 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1149 const MCSection *Section = Sections[ID];
1150 MCSymbol *Sym = NULL;
1153 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1154 // if we know the section name up-front. For user-created sections, the
1156 // label may not be valid to use as a label. (section names can use a
1158 // set of characters on some systems)
1159 Sym = Asm->GetTempSymbol("debug_end", ID);
1160 Asm->OutStreamer.SwitchSection(Section);
1161 Asm->OutStreamer.EmitLabel(Sym);
1164 // Insert a final terminator.
1165 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1169 // Emit all Dwarf sections that should come after the content.
1170 void DwarfDebug::endModule() {
1177 // End any existing sections.
1178 // TODO: Does this need to happen?
1181 // Finalize the debug info for the module.
1182 finalizeModuleInfo();
1186 // Emit all the DIEs into a debug info section.
1189 // Corresponding abbreviations into a abbrev section.
1190 emitAbbreviations();
1192 // Emit info into a debug loc section.
1195 // Emit info into a debug aranges section.
1198 // Emit info into a debug ranges section.
1201 if (useSplitDwarf()) {
1204 emitDebugAbbrevDWO();
1205 // Emit DWO addresses.
1206 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1209 // Emit info into the dwarf accelerator table sections.
1210 if (useDwarfAccelTables()) {
1213 emitAccelNamespaces();
1217 // Emit the pubnames and pubtypes sections if requested.
1218 if (HasDwarfPubSections) {
1219 emitDebugPubNames(GenerateGnuPubSections);
1220 emitDebugPubTypes(GenerateGnuPubSections);
1226 // Reset these for the next Module if we have one.
1230 // Find abstract variable, if any, associated with Var.
1231 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1232 DebugLoc ScopeLoc) {
1233 LLVMContext &Ctx = DV->getContext();
1234 // More then one inlined variable corresponds to one abstract variable.
1235 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1236 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1238 return AbsDbgVariable;
1240 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1244 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1245 addScopeVariable(Scope, AbsDbgVariable);
1246 AbstractVariables[Var] = AbsDbgVariable;
1247 return AbsDbgVariable;
1250 // If Var is a current function argument then add it to CurrentFnArguments list.
1251 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1252 if (!LScopes.isCurrentFunctionScope(Scope))
1254 DIVariable DV = Var->getVariable();
1255 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1257 unsigned ArgNo = DV.getArgNumber();
1261 size_t Size = CurrentFnArguments.size();
1263 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1264 // llvm::Function argument size is not good indicator of how many
1265 // arguments does the function have at source level.
1267 CurrentFnArguments.resize(ArgNo * 2);
1268 CurrentFnArguments[ArgNo - 1] = Var;
1272 // Collect variable information from side table maintained by MMI.
1273 void DwarfDebug::collectVariableInfoFromMMITable(
1274 SmallPtrSet<const MDNode *, 16> &Processed) {
1275 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1276 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1279 const MDNode *Var = VI->first;
1282 Processed.insert(Var);
1284 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1286 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1288 // If variable scope is not found then skip this variable.
1292 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1293 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1294 RegVar->setFrameIndex(VP.first);
1295 if (!addCurrentFnArgument(RegVar, Scope))
1296 addScopeVariable(Scope, RegVar);
1298 AbsDbgVariable->setFrameIndex(VP.first);
1302 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1304 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1305 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1306 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1307 MI->getOperand(0).getReg() &&
1308 (MI->getOperand(1).isImm() ||
1309 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1312 // Get .debug_loc entry for the instruction range starting at MI.
1313 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1314 const MCSymbol *FLabel,
1315 const MCSymbol *SLabel,
1316 const MachineInstr *MI) {
1317 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1319 assert(MI->getNumOperands() == 3);
1320 if (MI->getOperand(0).isReg()) {
1321 MachineLocation MLoc;
1322 // If the second operand is an immediate, this is a
1323 // register-indirect address.
1324 if (!MI->getOperand(1).isImm())
1325 MLoc.set(MI->getOperand(0).getReg());
1327 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1328 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1330 if (MI->getOperand(0).isImm())
1331 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1332 if (MI->getOperand(0).isFPImm())
1333 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1334 if (MI->getOperand(0).isCImm())
1335 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1337 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1340 // Find variables for each lexical scope.
1342 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1344 // Grab the variable info that was squirreled away in the MMI side-table.
1345 collectVariableInfoFromMMITable(Processed);
1347 for (SmallVectorImpl<const MDNode *>::const_iterator
1348 UVI = UserVariables.begin(),
1349 UVE = UserVariables.end();
1350 UVI != UVE; ++UVI) {
1351 const MDNode *Var = *UVI;
1352 if (Processed.count(Var))
1355 // History contains relevant DBG_VALUE instructions for Var and instructions
1357 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1358 if (History.empty())
1360 const MachineInstr *MInsn = History.front();
1363 LexicalScope *Scope = NULL;
1364 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1365 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1366 Scope = LScopes.getCurrentFunctionScope();
1367 else if (MDNode *IA = DV.getInlinedAt())
1368 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1370 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1371 // If variable scope is not found then skip this variable.
1375 Processed.insert(DV);
1376 assert(MInsn->isDebugValue() && "History must begin with debug value");
1377 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1378 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1379 if (!addCurrentFnArgument(RegVar, Scope))
1380 addScopeVariable(Scope, RegVar);
1382 AbsVar->setMInsn(MInsn);
1384 // Simplify ranges that are fully coalesced.
1385 if (History.size() <= 1 ||
1386 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1387 RegVar->setMInsn(MInsn);
1391 // Handle multiple DBG_VALUE instructions describing one variable.
1392 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1394 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1395 HI = History.begin(),
1398 const MachineInstr *Begin = *HI;
1399 assert(Begin->isDebugValue() && "Invalid History entry");
1401 // Check if DBG_VALUE is truncating a range.
1402 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1403 !Begin->getOperand(0).getReg())
1406 // Compute the range for a register location.
1407 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1408 const MCSymbol *SLabel = 0;
1411 // If Begin is the last instruction in History then its value is valid
1412 // until the end of the function.
1413 SLabel = FunctionEndSym;
1415 const MachineInstr *End = HI[1];
1416 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1417 << "\t" << *Begin << "\t" << *End << "\n");
1418 if (End->isDebugValue())
1419 SLabel = getLabelBeforeInsn(End);
1421 // End is a normal instruction clobbering the range.
1422 SLabel = getLabelAfterInsn(End);
1423 assert(SLabel && "Forgot label after clobber instruction");
1428 // The value is valid until the next DBG_VALUE or clobber.
1429 DotDebugLocEntries.push_back(
1430 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1432 DotDebugLocEntries.push_back(DotDebugLocEntry());
1435 // Collect info for variables that were optimized out.
1436 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1437 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1438 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1439 DIVariable DV(Variables.getElement(i));
1440 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1442 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1443 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1447 // Return Label preceding the instruction.
1448 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1449 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1450 assert(Label && "Didn't insert label before instruction");
1454 // Return Label immediately following the instruction.
1455 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1456 return LabelsAfterInsn.lookup(MI);
1459 // Process beginning of an instruction.
1460 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1463 // Check if source location changes, but ignore DBG_VALUE locations.
1464 if (!MI->isDebugValue()) {
1465 DebugLoc DL = MI->getDebugLoc();
1466 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1469 if (DL == PrologEndLoc) {
1470 Flags |= DWARF2_FLAG_PROLOGUE_END;
1471 PrologEndLoc = DebugLoc();
1473 if (PrologEndLoc.isUnknown())
1474 Flags |= DWARF2_FLAG_IS_STMT;
1476 if (!DL.isUnknown()) {
1477 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1478 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1480 recordSourceLine(0, 0, 0, 0);
1484 // Insert labels where requested.
1485 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1486 LabelsBeforeInsn.find(MI);
1489 if (I == LabelsBeforeInsn.end())
1492 // Label already assigned.
1497 PrevLabel = MMI->getContext().CreateTempSymbol();
1498 Asm->OutStreamer.EmitLabel(PrevLabel);
1500 I->second = PrevLabel;
1503 // Process end of an instruction.
1504 void DwarfDebug::endInstruction() {
1506 // Don't create a new label after DBG_VALUE instructions.
1507 // They don't generate code.
1508 if (!CurMI->isDebugValue())
1511 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1512 LabelsAfterInsn.find(CurMI);
1516 if (I == LabelsAfterInsn.end())
1519 // Label already assigned.
1523 // We need a label after this instruction.
1525 PrevLabel = MMI->getContext().CreateTempSymbol();
1526 Asm->OutStreamer.EmitLabel(PrevLabel);
1528 I->second = PrevLabel;
1531 // Each LexicalScope has first instruction and last instruction to mark
1532 // beginning and end of a scope respectively. Create an inverse map that list
1533 // scopes starts (and ends) with an instruction. One instruction may start (or
1534 // end) multiple scopes. Ignore scopes that are not reachable.
1535 void DwarfDebug::identifyScopeMarkers() {
1536 SmallVector<LexicalScope *, 4> WorkList;
1537 WorkList.push_back(LScopes.getCurrentFunctionScope());
1538 while (!WorkList.empty()) {
1539 LexicalScope *S = WorkList.pop_back_val();
1541 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1542 if (!Children.empty())
1543 for (SmallVectorImpl<LexicalScope *>::const_iterator
1544 SI = Children.begin(),
1545 SE = Children.end();
1547 WorkList.push_back(*SI);
1549 if (S->isAbstractScope())
1552 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1555 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1558 assert(RI->first && "InsnRange does not have first instruction!");
1559 assert(RI->second && "InsnRange does not have second instruction!");
1560 requestLabelBeforeInsn(RI->first);
1561 requestLabelAfterInsn(RI->second);
1566 // Get MDNode for DebugLoc's scope.
1567 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1568 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1569 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1570 return DL.getScope(Ctx);
1573 // Walk up the scope chain of given debug loc and find line number info
1574 // for the function.
1575 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1576 const MDNode *Scope = getScopeNode(DL, Ctx);
1577 DISubprogram SP = getDISubprogram(Scope);
1578 if (SP.isSubprogram()) {
1579 // Check for number of operands since the compatibility is
1581 if (SP->getNumOperands() > 19)
1582 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1584 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1590 // Gather pre-function debug information. Assumes being called immediately
1591 // after the function entry point has been emitted.
1592 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1595 // If there's no debug info for the function we're not going to do anything.
1596 if (!MMI->hasDebugInfo())
1599 // Grab the lexical scopes for the function, if we don't have any of those
1600 // then we're not going to be able to do anything.
1601 LScopes.initialize(*MF);
1602 if (LScopes.empty())
1605 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1607 // Make sure that each lexical scope will have a begin/end label.
1608 identifyScopeMarkers();
1610 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1611 // belongs to so that we add to the correct per-cu line table in the
1613 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1614 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1615 assert(TheCU && "Unable to find compile unit!");
1616 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1617 // Use a single line table if we are using .loc and generating assembly.
1618 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1620 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1622 // Emit a label for the function so that we have a beginning address.
1623 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1624 // Assumes in correct section after the entry point.
1625 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1627 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1628 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1629 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1631 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1633 bool AtBlockEntry = true;
1634 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1636 const MachineInstr *MI = II;
1638 if (MI->isDebugValue()) {
1639 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1641 // Keep track of user variables.
1643 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1645 // Variable is in a register, we need to check for clobbers.
1646 if (isDbgValueInDefinedReg(MI))
1647 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1649 // Check the history of this variable.
1650 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1651 if (History.empty()) {
1652 UserVariables.push_back(Var);
1653 // The first mention of a function argument gets the FunctionBeginSym
1654 // label, so arguments are visible when breaking at function entry.
1656 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1657 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1658 LabelsBeforeInsn[MI] = FunctionBeginSym;
1660 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1661 const MachineInstr *Prev = History.back();
1662 if (Prev->isDebugValue()) {
1663 // Coalesce identical entries at the end of History.
1664 if (History.size() >= 2 &&
1665 Prev->isIdenticalTo(History[History.size() - 2])) {
1666 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1667 << "\t" << *Prev << "\t"
1668 << *History[History.size() - 2] << "\n");
1672 // Terminate old register assignments that don't reach MI;
1673 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1674 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1675 isDbgValueInDefinedReg(Prev)) {
1676 // Previous register assignment needs to terminate at the end of
1678 MachineBasicBlock::const_iterator LastMI =
1679 PrevMBB->getLastNonDebugInstr();
1680 if (LastMI == PrevMBB->end()) {
1681 // Drop DBG_VALUE for empty range.
1682 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1683 << "\t" << *Prev << "\n");
1685 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1686 // Terminate after LastMI.
1687 History.push_back(LastMI);
1691 History.push_back(MI);
1693 // Not a DBG_VALUE instruction.
1695 AtBlockEntry = false;
1697 // First known non-DBG_VALUE and non-frame setup location marks
1698 // the beginning of the function body.
1699 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1700 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1701 PrologEndLoc = MI->getDebugLoc();
1703 // Check if the instruction clobbers any registers with debug vars.
1704 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1705 MOE = MI->operands_end();
1706 MOI != MOE; ++MOI) {
1707 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1709 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1712 const MDNode *Var = LiveUserVar[Reg];
1715 // Reg is now clobbered.
1716 LiveUserVar[Reg] = 0;
1718 // Was MD last defined by a DBG_VALUE referring to Reg?
1719 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1720 if (HistI == DbgValues.end())
1722 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1723 if (History.empty())
1725 const MachineInstr *Prev = History.back();
1726 // Sanity-check: Register assignments are terminated at the end of
1728 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1730 // Is the variable still in Reg?
1731 if (!isDbgValueInDefinedReg(Prev) ||
1732 Prev->getOperand(0).getReg() != Reg)
1734 // Var is clobbered. Make sure the next instruction gets a label.
1735 History.push_back(MI);
1742 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1744 SmallVectorImpl<const MachineInstr *> &History = I->second;
1745 if (History.empty())
1748 // Make sure the final register assignments are terminated.
1749 const MachineInstr *Prev = History.back();
1750 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1751 const MachineBasicBlock *PrevMBB = Prev->getParent();
1752 MachineBasicBlock::const_iterator LastMI =
1753 PrevMBB->getLastNonDebugInstr();
1754 if (LastMI == PrevMBB->end())
1755 // Drop DBG_VALUE for empty range.
1757 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1758 // Terminate after LastMI.
1759 History.push_back(LastMI);
1762 // Request labels for the full history.
1763 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1764 const MachineInstr *MI = History[i];
1765 if (MI->isDebugValue())
1766 requestLabelBeforeInsn(MI);
1768 requestLabelAfterInsn(MI);
1772 PrevInstLoc = DebugLoc();
1773 PrevLabel = FunctionBeginSym;
1775 // Record beginning of function.
1776 if (!PrologEndLoc.isUnknown()) {
1777 DebugLoc FnStartDL =
1778 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1780 FnStartDL.getLine(), FnStartDL.getCol(),
1781 FnStartDL.getScope(MF->getFunction()->getContext()),
1782 // We'd like to list the prologue as "not statements" but GDB behaves
1783 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1784 DWARF2_FLAG_IS_STMT);
1788 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1789 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1790 DIVariable DV = Var->getVariable();
1791 // Variables with positive arg numbers are parameters.
1792 if (unsigned ArgNum = DV.getArgNumber()) {
1793 // Keep all parameters in order at the start of the variable list to ensure
1794 // function types are correct (no out-of-order parameters)
1796 // This could be improved by only doing it for optimized builds (unoptimized
1797 // builds have the right order to begin with), searching from the back (this
1798 // would catch the unoptimized case quickly), or doing a binary search
1799 // rather than linear search.
1800 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1801 while (I != Vars.end()) {
1802 unsigned CurNum = (*I)->getVariable().getArgNumber();
1803 // A local (non-parameter) variable has been found, insert immediately
1807 // A later indexed parameter has been found, insert immediately before it.
1808 if (CurNum > ArgNum)
1812 Vars.insert(I, Var);
1816 Vars.push_back(Var);
1819 // Gather and emit post-function debug information.
1820 void DwarfDebug::endFunction(const MachineFunction *MF) {
1821 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1822 // though the beginFunction may not be called at all.
1823 // We should handle both cases.
1827 assert(CurFn == MF);
1830 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1835 // Define end label for subprogram.
1836 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1837 // Assumes in correct section after the entry point.
1838 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1839 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1840 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1842 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1843 collectVariableInfo(ProcessedVars);
1845 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1846 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1847 assert(TheCU && "Unable to find compile unit!");
1849 // Construct abstract scopes.
1850 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1851 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1852 LexicalScope *AScope = AList[i];
1853 DISubprogram SP(AScope->getScopeNode());
1854 if (SP.isSubprogram()) {
1855 // Collect info for variables that were optimized out.
1856 DIArray Variables = SP.getVariables();
1857 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1858 DIVariable DV(Variables.getElement(i));
1859 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1861 // Check that DbgVariable for DV wasn't created earlier, when
1862 // findAbstractVariable() was called for inlined instance of DV.
1863 LLVMContext &Ctx = DV->getContext();
1864 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1865 if (AbstractVariables.lookup(CleanDV))
1867 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1868 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1871 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1872 constructScopeDIE(TheCU, AScope);
1875 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1877 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1878 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1881 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1882 E = ScopeVariables.end();
1884 DeleteContainerPointers(I->second);
1885 ScopeVariables.clear();
1886 DeleteContainerPointers(CurrentFnArguments);
1887 UserVariables.clear();
1889 AbstractVariables.clear();
1890 LabelsBeforeInsn.clear();
1891 LabelsAfterInsn.clear();
1896 // Register a source line with debug info. Returns the unique label that was
1897 // emitted and which provides correspondence to the source line list.
1898 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1904 DIDescriptor Scope(S);
1906 if (Scope.isCompileUnit()) {
1907 DICompileUnit CU(S);
1908 Fn = CU.getFilename();
1909 Dir = CU.getDirectory();
1910 } else if (Scope.isFile()) {
1912 Fn = F.getFilename();
1913 Dir = F.getDirectory();
1914 } else if (Scope.isSubprogram()) {
1916 Fn = SP.getFilename();
1917 Dir = SP.getDirectory();
1918 } else if (Scope.isLexicalBlockFile()) {
1919 DILexicalBlockFile DBF(S);
1920 Fn = DBF.getFilename();
1921 Dir = DBF.getDirectory();
1922 } else if (Scope.isLexicalBlock()) {
1923 DILexicalBlock DB(S);
1924 Fn = DB.getFilename();
1925 Dir = DB.getDirectory();
1927 llvm_unreachable("Unexpected scope info");
1929 Src = getOrCreateSourceID(
1930 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1932 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1935 //===----------------------------------------------------------------------===//
1937 //===----------------------------------------------------------------------===//
1939 // Compute the size and offset of a DIE. The offset is relative to start of the
1940 // CU. It returns the offset after laying out the DIE.
1941 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1942 // Get the children.
1943 const std::vector<DIE *> &Children = Die->getChildren();
1945 // Record the abbreviation.
1946 assignAbbrevNumber(Die->getAbbrev());
1948 // Get the abbreviation for this DIE.
1949 const DIEAbbrev &Abbrev = Die->getAbbrev();
1952 Die->setOffset(Offset);
1954 // Start the size with the size of abbreviation code.
1955 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1957 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1958 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1960 // Size the DIE attribute values.
1961 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1962 // Size attribute value.
1963 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1965 // Size the DIE children if any.
1966 if (!Children.empty()) {
1967 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1968 "Children flag not set");
1970 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1971 Offset = computeSizeAndOffset(Children[j], Offset);
1973 // End of children marker.
1974 Offset += sizeof(int8_t);
1977 Die->setSize(Offset - Die->getOffset());
1981 // Compute the size and offset for each DIE.
1982 void DwarfFile::computeSizeAndOffsets() {
1983 // Offset from the first CU in the debug info section is 0 initially.
1984 unsigned SecOffset = 0;
1986 // Iterate over each compile unit and set the size and offsets for each
1987 // DIE within each compile unit. All offsets are CU relative.
1988 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1991 (*I)->setDebugInfoOffset(SecOffset);
1993 // CU-relative offset is reset to 0 here.
1994 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1995 (*I)->getHeaderSize(); // Unit-specific headers
1997 // EndOffset here is CU-relative, after laying out
1998 // all of the CU DIE.
1999 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
2000 SecOffset += EndOffset;
2004 // Emit initial Dwarf sections with a label at the start of each one.
2005 void DwarfDebug::emitSectionLabels() {
2006 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2008 // Dwarf sections base addresses.
2009 DwarfInfoSectionSym =
2010 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2011 if (useSplitDwarf())
2012 DwarfInfoDWOSectionSym =
2013 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
2014 DwarfAbbrevSectionSym =
2015 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2016 if (useSplitDwarf())
2017 DwarfAbbrevDWOSectionSym = emitSectionSym(
2018 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
2019 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2021 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2022 emitSectionSym(Asm, MacroInfo);
2024 DwarfLineSectionSym =
2025 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2026 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2027 if (GenerateGnuPubSections) {
2028 DwarfGnuPubNamesSectionSym =
2029 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2030 DwarfGnuPubTypesSectionSym =
2031 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2032 } else if (HasDwarfPubSections) {
2033 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2034 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2037 DwarfStrSectionSym =
2038 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2039 if (useSplitDwarf()) {
2040 DwarfStrDWOSectionSym =
2041 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2042 DwarfAddrSectionSym =
2043 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2045 DwarfDebugRangeSectionSym =
2046 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2048 DwarfDebugLocSectionSym =
2049 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2051 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2054 // Recursively emits a debug information entry.
2055 void DwarfDebug::emitDIE(DIE *Die) {
2056 // Get the abbreviation for this DIE.
2057 const DIEAbbrev &Abbrev = Die->getAbbrev();
2059 // Emit the code (index) for the abbreviation.
2060 if (Asm->isVerbose())
2061 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2062 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2063 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2064 dwarf::TagString(Abbrev.getTag()));
2065 Asm->EmitULEB128(Abbrev.getNumber());
2067 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2068 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2070 // Emit the DIE attribute values.
2071 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2072 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2073 dwarf::Form Form = AbbrevData[i].getForm();
2074 assert(Form && "Too many attributes for DIE (check abbreviation)");
2076 if (Asm->isVerbose())
2077 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2080 case dwarf::DW_AT_abstract_origin:
2081 case dwarf::DW_AT_type:
2082 case dwarf::DW_AT_friend:
2083 case dwarf::DW_AT_specification:
2084 case dwarf::DW_AT_import:
2085 case dwarf::DW_AT_containing_type: {
2086 DIEEntry *E = cast<DIEEntry>(Values[i]);
2087 DIE *Origin = E->getEntry();
2088 unsigned Addr = Origin->getOffset();
2089 if (Form == dwarf::DW_FORM_ref_addr) {
2090 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2091 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2092 // section. Origin->getOffset() returns the offset from start of the
2094 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2095 assert(CU && "CUDie should belong to a CU.");
2096 Addr += CU->getDebugInfoOffset();
2097 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2098 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2099 DIEEntry::getRefAddrSize(Asm));
2101 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2102 CU->getSectionSym(),
2103 DIEEntry::getRefAddrSize(Asm));
2105 // Make sure Origin belong to the same CU.
2106 assert(Die->getUnit() == Origin->getUnit() &&
2107 "The referenced DIE should belong to the same CU in ref4");
2108 Asm->EmitInt32(Addr);
2112 case dwarf::DW_AT_location: {
2113 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2114 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2115 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2117 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2119 Values[i]->EmitValue(Asm, Form);
2123 case dwarf::DW_AT_accessibility: {
2124 if (Asm->isVerbose()) {
2125 DIEInteger *V = cast<DIEInteger>(Values[i]);
2126 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2128 Values[i]->EmitValue(Asm, Form);
2132 // Emit an attribute using the defined form.
2133 Values[i]->EmitValue(Asm, Form);
2138 // Emit the DIE children if any.
2139 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2140 const std::vector<DIE *> &Children = Die->getChildren();
2142 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2143 emitDIE(Children[j]);
2145 Asm->OutStreamer.AddComment("End Of Children Mark");
2150 // Emit the various dwarf units to the unit section USection with
2151 // the abbreviations going into ASection.
2152 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2153 const MCSymbol *ASectionSym) {
2154 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2156 DwarfUnit *TheU = *I;
2157 DIE *Die = TheU->getUnitDie();
2158 const MCSection *USection = TheU->getSection();
2159 Asm->OutStreamer.SwitchSection(USection);
2161 // Emit the compile units header.
2162 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2164 // Emit size of content not including length itself
2165 Asm->OutStreamer.AddComment("Length of Unit");
2166 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2168 TheU->emitHeader(ASection, ASectionSym);
2171 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2175 // Emit the debug info section.
2176 void DwarfDebug::emitDebugInfo() {
2177 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2179 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2180 DwarfAbbrevSectionSym);
2183 // Emit the abbreviation section.
2184 void DwarfDebug::emitAbbreviations() {
2185 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2187 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2190 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2191 // Check to see if it is worth the effort.
2192 if (!Abbreviations.empty()) {
2193 // Start the debug abbrev section.
2194 Asm->OutStreamer.SwitchSection(Section);
2196 // For each abbrevation.
2197 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2198 // Get abbreviation data
2199 const DIEAbbrev *Abbrev = Abbreviations[i];
2201 // Emit the abbrevations code (base 1 index.)
2202 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2204 // Emit the abbreviations data.
2208 // Mark end of abbreviations.
2209 Asm->EmitULEB128(0, "EOM(3)");
2213 // Emit the last address of the section and the end of the line matrix.
2214 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2215 // Define last address of section.
2216 Asm->OutStreamer.AddComment("Extended Op");
2219 Asm->OutStreamer.AddComment("Op size");
2220 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2221 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2222 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2224 Asm->OutStreamer.AddComment("Section end label");
2226 Asm->OutStreamer.EmitSymbolValue(
2227 Asm->GetTempSymbol("section_end", SectionEnd),
2228 Asm->getDataLayout().getPointerSize());
2230 // Mark end of matrix.
2231 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2237 // Emit visible names into a hashed accelerator table section.
2238 void DwarfDebug::emitAccelNames() {
2240 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2241 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2242 E = getUnits().end();
2244 DwarfUnit *TheU = *I;
2245 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2246 for (StringMap<std::vector<const DIE *> >::const_iterator
2250 StringRef Name = GI->getKey();
2251 const std::vector<const DIE *> &Entities = GI->second;
2252 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2253 DE = Entities.end();
2255 AT.AddName(Name, *DI);
2259 AT.FinalizeTable(Asm, "Names");
2260 Asm->OutStreamer.SwitchSection(
2261 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2262 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2263 Asm->OutStreamer.EmitLabel(SectionBegin);
2265 // Emit the full data.
2266 AT.Emit(Asm, SectionBegin, &InfoHolder);
2269 // Emit objective C classes and categories into a hashed accelerator table
2271 void DwarfDebug::emitAccelObjC() {
2273 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2274 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2275 E = getUnits().end();
2277 DwarfUnit *TheU = *I;
2278 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2279 for (StringMap<std::vector<const DIE *> >::const_iterator
2283 StringRef Name = GI->getKey();
2284 const std::vector<const DIE *> &Entities = GI->second;
2285 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2286 DE = Entities.end();
2288 AT.AddName(Name, *DI);
2292 AT.FinalizeTable(Asm, "ObjC");
2293 Asm->OutStreamer.SwitchSection(
2294 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2295 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2296 Asm->OutStreamer.EmitLabel(SectionBegin);
2298 // Emit the full data.
2299 AT.Emit(Asm, SectionBegin, &InfoHolder);
2302 // Emit namespace dies into a hashed accelerator table.
2303 void DwarfDebug::emitAccelNamespaces() {
2305 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2306 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2307 E = getUnits().end();
2309 DwarfUnit *TheU = *I;
2310 const StringMap<std::vector<const DIE *> > &Names =
2311 TheU->getAccelNamespace();
2312 for (StringMap<std::vector<const DIE *> >::const_iterator
2316 StringRef Name = GI->getKey();
2317 const std::vector<const DIE *> &Entities = GI->second;
2318 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2319 DE = Entities.end();
2321 AT.AddName(Name, *DI);
2325 AT.FinalizeTable(Asm, "namespac");
2326 Asm->OutStreamer.SwitchSection(
2327 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2328 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2329 Asm->OutStreamer.EmitLabel(SectionBegin);
2331 // Emit the full data.
2332 AT.Emit(Asm, SectionBegin, &InfoHolder);
2335 // Emit type dies into a hashed accelerator table.
2336 void DwarfDebug::emitAccelTypes() {
2337 std::vector<DwarfAccelTable::Atom> Atoms;
2339 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2341 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2343 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2344 DwarfAccelTable AT(Atoms);
2345 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2346 E = getUnits().end();
2348 DwarfUnit *TheU = *I;
2349 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2350 TheU->getAccelTypes();
2352 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2356 StringRef Name = GI->getKey();
2357 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2359 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2360 DI = Entities.begin(),
2361 DE = Entities.end();
2363 AT.AddName(Name, DI->first, DI->second);
2367 AT.FinalizeTable(Asm, "types");
2368 Asm->OutStreamer.SwitchSection(
2369 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2370 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2371 Asm->OutStreamer.EmitLabel(SectionBegin);
2373 // Emit the full data.
2374 AT.Emit(Asm, SectionBegin, &InfoHolder);
2377 // Public name handling.
2378 // The format for the various pubnames:
2380 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2381 // for the DIE that is named.
2383 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2384 // into the CU and the index value is computed according to the type of value
2385 // for the DIE that is named.
2387 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2388 // it's the offset within the debug_info/debug_types dwo section, however, the
2389 // reference in the pubname header doesn't change.
2391 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2392 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2394 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2396 // We could have a specification DIE that has our most of our knowledge,
2397 // look for that now.
2398 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2400 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2401 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2402 Linkage = dwarf::GIEL_EXTERNAL;
2403 } else if (Die->findAttribute(dwarf::DW_AT_external))
2404 Linkage = dwarf::GIEL_EXTERNAL;
2406 switch (Die->getTag()) {
2407 case dwarf::DW_TAG_class_type:
2408 case dwarf::DW_TAG_structure_type:
2409 case dwarf::DW_TAG_union_type:
2410 case dwarf::DW_TAG_enumeration_type:
2411 return dwarf::PubIndexEntryDescriptor(
2412 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2413 ? dwarf::GIEL_STATIC
2414 : dwarf::GIEL_EXTERNAL);
2415 case dwarf::DW_TAG_typedef:
2416 case dwarf::DW_TAG_base_type:
2417 case dwarf::DW_TAG_subrange_type:
2418 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2419 case dwarf::DW_TAG_namespace:
2420 return dwarf::GIEK_TYPE;
2421 case dwarf::DW_TAG_subprogram:
2422 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2423 case dwarf::DW_TAG_constant:
2424 case dwarf::DW_TAG_variable:
2425 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2426 case dwarf::DW_TAG_enumerator:
2427 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2428 dwarf::GIEL_STATIC);
2430 return dwarf::GIEK_NONE;
2434 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2436 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2437 const MCSection *PSec =
2438 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2439 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2441 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2442 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2443 for (unsigned i = 0; i != Units.size(); ++i) {
2444 DwarfUnit *TheU = Units[i];
2445 unsigned ID = TheU->getUniqueID();
2447 // Start the dwarf pubnames section.
2448 Asm->OutStreamer.SwitchSection(PSec);
2450 // Emit a label so we can reference the beginning of this pubname section.
2452 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2455 Asm->OutStreamer.AddComment("Length of Public Names Info");
2456 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2457 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2458 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2460 Asm->OutStreamer.EmitLabel(BeginLabel);
2462 Asm->OutStreamer.AddComment("DWARF Version");
2463 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2465 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2466 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2468 Asm->OutStreamer.AddComment("Compilation Unit Length");
2469 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2471 // Emit the pubnames for this compilation unit.
2472 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2473 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2476 const char *Name = GI->getKeyData();
2477 const DIE *Entity = GI->second;
2479 Asm->OutStreamer.AddComment("DIE offset");
2480 Asm->EmitInt32(Entity->getOffset());
2483 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2484 Asm->OutStreamer.AddComment(
2485 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2486 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2487 Asm->EmitInt8(Desc.toBits());
2490 Asm->OutStreamer.AddComment("External Name");
2491 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2494 Asm->OutStreamer.AddComment("End Mark");
2496 Asm->OutStreamer.EmitLabel(EndLabel);
2500 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2501 const MCSection *PSec =
2502 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2503 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2505 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2506 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2507 for (unsigned i = 0; i != Units.size(); ++i) {
2508 DwarfUnit *TheU = Units[i];
2509 unsigned ID = TheU->getUniqueID();
2511 // Start the dwarf pubtypes section.
2512 Asm->OutStreamer.SwitchSection(PSec);
2514 // Emit a label so we can reference the beginning of this pubtype section.
2516 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2519 Asm->OutStreamer.AddComment("Length of Public Types Info");
2520 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2521 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2522 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2524 Asm->OutStreamer.EmitLabel(BeginLabel);
2526 Asm->OutStreamer.AddComment("DWARF Version");
2527 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2529 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2530 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2532 Asm->OutStreamer.AddComment("Compilation Unit Length");
2533 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2535 // Emit the pubtypes.
2536 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2537 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2540 const char *Name = GI->getKeyData();
2541 const DIE *Entity = GI->second;
2543 Asm->OutStreamer.AddComment("DIE offset");
2544 Asm->EmitInt32(Entity->getOffset());
2547 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2548 Asm->OutStreamer.AddComment(
2549 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2550 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2551 Asm->EmitInt8(Desc.toBits());
2554 Asm->OutStreamer.AddComment("External Name");
2556 // Emit the name with a terminating null byte.
2557 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2560 Asm->OutStreamer.AddComment("End Mark");
2562 Asm->OutStreamer.EmitLabel(EndLabel);
2566 // Emit strings into a string section.
2567 void DwarfFile::emitStrings(const MCSection *StrSection,
2568 const MCSection *OffsetSection = NULL,
2569 const MCSymbol *StrSecSym = NULL) {
2571 if (StringPool.empty())
2574 // Start the dwarf str section.
2575 Asm->OutStreamer.SwitchSection(StrSection);
2577 // Get all of the string pool entries and put them in an array by their ID so
2578 // we can sort them.
2580 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2583 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2584 I = StringPool.begin(),
2585 E = StringPool.end();
2587 Entries.push_back(std::make_pair(I->second.second, &*I));
2589 array_pod_sort(Entries.begin(), Entries.end());
2591 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2592 // Emit a label for reference from debug information entries.
2593 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2595 // Emit the string itself with a terminating null byte.
2596 Asm->OutStreamer.EmitBytes(
2597 StringRef(Entries[i].second->getKeyData(),
2598 Entries[i].second->getKeyLength() + 1));
2601 // If we've got an offset section go ahead and emit that now as well.
2602 if (OffsetSection) {
2603 Asm->OutStreamer.SwitchSection(OffsetSection);
2604 unsigned offset = 0;
2605 unsigned size = 4; // FIXME: DWARF64 is 8.
2606 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2607 Asm->OutStreamer.EmitIntValue(offset, size);
2608 offset += Entries[i].second->getKeyLength() + 1;
2613 // Emit addresses into the section given.
2614 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2616 if (AddressPool.empty())
2619 // Start the dwarf addr section.
2620 Asm->OutStreamer.SwitchSection(AddrSection);
2622 // Order the address pool entries by ID
2623 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2625 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2626 E = AddressPool.end();
2628 Entries[I->second] = I->first;
2630 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2631 // Emit an expression for reference from debug information entries.
2632 if (const MCExpr *Expr = Entries[i])
2633 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2635 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2639 // Emit visible names into a debug str section.
2640 void DwarfDebug::emitDebugStr() {
2641 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2642 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2645 // Emit locations into the debug loc section.
2646 void DwarfDebug::emitDebugLoc() {
2647 if (DotDebugLocEntries.empty())
2650 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2651 I = DotDebugLocEntries.begin(),
2652 E = DotDebugLocEntries.end();
2654 DotDebugLocEntry &Entry = *I;
2655 if (I + 1 != DotDebugLocEntries.end())
2659 // Start the dwarf loc section.
2660 Asm->OutStreamer.SwitchSection(
2661 Asm->getObjFileLowering().getDwarfLocSection());
2662 unsigned char Size = Asm->getDataLayout().getPointerSize();
2663 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2665 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2666 I = DotDebugLocEntries.begin(),
2667 E = DotDebugLocEntries.end();
2668 I != E; ++I, ++index) {
2669 DotDebugLocEntry &Entry = *I;
2670 if (Entry.isMerged())
2672 if (Entry.isEmpty()) {
2673 Asm->OutStreamer.EmitIntValue(0, Size);
2674 Asm->OutStreamer.EmitIntValue(0, Size);
2675 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2677 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2678 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2679 DIVariable DV(Entry.getVariable());
2680 Asm->OutStreamer.AddComment("Loc expr size");
2681 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2682 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2683 Asm->EmitLabelDifference(end, begin, 2);
2684 Asm->OutStreamer.EmitLabel(begin);
2685 if (Entry.isInt()) {
2686 DIBasicType BTy(DV.getType());
2687 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2688 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2689 Asm->OutStreamer.AddComment("DW_OP_consts");
2690 Asm->EmitInt8(dwarf::DW_OP_consts);
2691 Asm->EmitSLEB128(Entry.getInt());
2693 Asm->OutStreamer.AddComment("DW_OP_constu");
2694 Asm->EmitInt8(dwarf::DW_OP_constu);
2695 Asm->EmitULEB128(Entry.getInt());
2697 } else if (Entry.isLocation()) {
2698 MachineLocation Loc = Entry.getLoc();
2699 if (!DV.hasComplexAddress())
2701 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2703 // Complex address entry.
2704 unsigned N = DV.getNumAddrElements();
2706 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2707 if (Loc.getOffset()) {
2709 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2710 Asm->OutStreamer.AddComment("DW_OP_deref");
2711 Asm->EmitInt8(dwarf::DW_OP_deref);
2712 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2713 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2714 Asm->EmitSLEB128(DV.getAddrElement(1));
2716 // If first address element is OpPlus then emit
2717 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2718 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2719 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2723 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2726 // Emit remaining complex address elements.
2727 for (; i < N; ++i) {
2728 uint64_t Element = DV.getAddrElement(i);
2729 if (Element == DIBuilder::OpPlus) {
2730 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2731 Asm->EmitULEB128(DV.getAddrElement(++i));
2732 } else if (Element == DIBuilder::OpDeref) {
2734 Asm->EmitInt8(dwarf::DW_OP_deref);
2736 llvm_unreachable("unknown Opcode found in complex address");
2740 // else ... ignore constant fp. There is not any good way to
2741 // to represent them here in dwarf.
2742 Asm->OutStreamer.EmitLabel(end);
2747 struct SymbolCUSorter {
2748 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2749 const MCStreamer &Streamer;
2751 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2752 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2753 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2755 // Symbols with no order assigned should be placed at the end.
2756 // (e.g. section end labels)
2758 IA = (unsigned)(-1);
2760 IB = (unsigned)(-1);
2765 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2766 return (A->getUniqueID() < B->getUniqueID());
2770 const MCSymbol *Start, *End;
2773 // Emit a debug aranges section, containing a CU lookup for any
2774 // address we can tie back to a CU.
2775 void DwarfDebug::emitDebugARanges() {
2776 // Start the dwarf aranges section.
2777 Asm->OutStreamer.SwitchSection(
2778 Asm->getObjFileLowering().getDwarfARangesSection());
2780 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2784 // Build a list of sections used.
2785 std::vector<const MCSection *> Sections;
2786 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2788 const MCSection *Section = it->first;
2789 Sections.push_back(Section);
2792 // Sort the sections into order.
2793 // This is only done to ensure consistent output order across different runs.
2794 std::sort(Sections.begin(), Sections.end(), SectionSort);
2796 // Build a set of address spans, sorted by CU.
2797 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2798 const MCSection *Section = Sections[SecIdx];
2799 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2800 if (List.size() < 2)
2803 // Sort the symbols by offset within the section.
2804 SymbolCUSorter sorter(Asm->OutStreamer);
2805 std::sort(List.begin(), List.end(), sorter);
2807 // If we have no section (e.g. common), just write out
2808 // individual spans for each symbol.
2809 if (Section == NULL) {
2810 for (size_t n = 0; n < List.size(); n++) {
2811 const SymbolCU &Cur = List[n];
2814 Span.Start = Cur.Sym;
2817 Spans[Cur.CU].push_back(Span);
2820 // Build spans between each label.
2821 const MCSymbol *StartSym = List[0].Sym;
2822 for (size_t n = 1; n < List.size(); n++) {
2823 const SymbolCU &Prev = List[n - 1];
2824 const SymbolCU &Cur = List[n];
2826 // Try and build the longest span we can within the same CU.
2827 if (Cur.CU != Prev.CU) {
2829 Span.Start = StartSym;
2831 Spans[Prev.CU].push_back(Span);
2838 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2840 // Build a list of CUs used.
2841 std::vector<DwarfCompileUnit *> CUs;
2842 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2843 DwarfCompileUnit *CU = it->first;
2847 // Sort the CU list (again, to ensure consistent output order).
2848 std::sort(CUs.begin(), CUs.end(), CUSort);
2850 // Emit an arange table for each CU we used.
2851 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2852 DwarfCompileUnit *CU = CUs[CUIdx];
2853 std::vector<ArangeSpan> &List = Spans[CU];
2855 // Emit size of content not including length itself.
2856 unsigned ContentSize =
2857 sizeof(int16_t) + // DWARF ARange version number
2858 sizeof(int32_t) + // Offset of CU in the .debug_info section
2859 sizeof(int8_t) + // Pointer Size (in bytes)
2860 sizeof(int8_t); // Segment Size (in bytes)
2862 unsigned TupleSize = PtrSize * 2;
2864 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2865 unsigned Padding = 0;
2866 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2869 ContentSize += Padding;
2870 ContentSize += (List.size() + 1) * TupleSize;
2872 // For each compile unit, write the list of spans it covers.
2873 Asm->OutStreamer.AddComment("Length of ARange Set");
2874 Asm->EmitInt32(ContentSize);
2875 Asm->OutStreamer.AddComment("DWARF Arange version number");
2876 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2877 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2878 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2879 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2880 Asm->EmitInt8(PtrSize);
2881 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2884 for (unsigned n = 0; n < Padding; n++)
2885 Asm->EmitInt8(0xff);
2887 for (unsigned n = 0; n < List.size(); n++) {
2888 const ArangeSpan &Span = List[n];
2889 Asm->EmitLabelReference(Span.Start, PtrSize);
2891 // Calculate the size as being from the span start to it's end.
2893 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2895 // For symbols without an end marker (e.g. common), we
2896 // write a single arange entry containing just that one symbol.
2897 uint64_t Size = SymSize[Span.Start];
2901 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2905 Asm->OutStreamer.AddComment("ARange terminator");
2906 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2907 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2911 // Emit visible names into a debug ranges section.
2912 void DwarfDebug::emitDebugRanges() {
2913 // Start the dwarf ranges section.
2914 Asm->OutStreamer.SwitchSection(
2915 Asm->getObjFileLowering().getDwarfRangesSection());
2917 // Size for our labels.
2918 unsigned char Size = Asm->getDataLayout().getPointerSize();
2920 // Grab the specific ranges for the compile units in the module.
2921 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2924 DwarfCompileUnit *TheCU = I->second;
2926 // Emit a symbol so we can find the beginning of our ranges.
2927 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2929 // Iterate over the misc ranges for the compile units in the module.
2930 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2931 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2932 E = RangeLists.end();
2934 const RangeSpanList &List = *I;
2936 // Emit our symbol so we can find the beginning of the range.
2937 Asm->OutStreamer.EmitLabel(List.getSym());
2939 for (SmallVectorImpl<RangeSpan>::const_iterator
2940 RI = List.getRanges().begin(),
2941 RE = List.getRanges().end();
2943 const RangeSpan &Range = *RI;
2944 const MCSymbol *Begin = Range.getStart();
2945 const MCSymbol *End = Range.getEnd();
2946 assert(Begin && "Range without a begin symbol?");
2947 assert(End && "Range without an end symbol?");
2948 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2949 Asm->OutStreamer.EmitSymbolValue(End, Size);
2952 // And terminate the list with two 0 values.
2953 Asm->OutStreamer.EmitIntValue(0, Size);
2954 Asm->OutStreamer.EmitIntValue(0, Size);
2957 // Now emit a range for the CU itself.
2958 if (DwarfCURanges) {
2959 Asm->OutStreamer.EmitLabel(
2960 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2961 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2962 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2963 RangeSpan Range = Ranges[i];
2964 const MCSymbol *Begin = Range.getStart();
2965 const MCSymbol *End = Range.getEnd();
2966 assert(Begin && "Range without a begin symbol?");
2967 assert(End && "Range without an end symbol?");
2968 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2969 Asm->OutStreamer.EmitSymbolValue(End, Size);
2971 // And terminate the list with two 0 values.
2972 Asm->OutStreamer.EmitIntValue(0, Size);
2973 Asm->OutStreamer.EmitIntValue(0, Size);
2978 // DWARF5 Experimental Separate Dwarf emitters.
2980 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2981 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2982 // DW_AT_ranges_base, DW_AT_addr_base.
2983 // TODO: Implement DW_AT_ranges_base.
2984 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2986 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2987 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2988 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2989 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2990 DwarfInfoSectionSym);
2992 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2993 CU->getNode().getSplitDebugFilename());
2995 // Relocate to the beginning of the addr_base section, else 0 for the
2996 // beginning of the one for this compile unit.
2997 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2998 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2999 DwarfAddrSectionSym);
3001 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3003 // DW_AT_stmt_list is a offset of line number information for this
3004 // compile unit in debug_line section.
3005 // FIXME: Should handle multiple compile units.
3006 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3007 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3009 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3011 if (!CompilationDir.empty())
3012 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3014 addGnuPubAttributes(NewCU, Die);
3016 SkeletonHolder.addUnit(NewCU);
3021 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3022 // compile units that would normally be in debug_info.
3023 void DwarfDebug::emitDebugInfoDWO() {
3024 assert(useSplitDwarf() && "No split dwarf debug info?");
3025 InfoHolder.emitUnits(this,
3026 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3027 DwarfAbbrevDWOSectionSym);
3030 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3031 // abbreviations for the .debug_info.dwo section.
3032 void DwarfDebug::emitDebugAbbrevDWO() {
3033 assert(useSplitDwarf() && "No split dwarf?");
3034 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3037 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3038 // string section and is identical in format to traditional .debug_str
3040 void DwarfDebug::emitDebugStrDWO() {
3041 assert(useSplitDwarf() && "No split dwarf?");
3042 const MCSection *OffSec =
3043 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3044 const MCSymbol *StrSym = DwarfStrSectionSym;
3045 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3049 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3050 DICompositeType CTy) {
3051 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3053 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3054 DwarfTypeUnit *NewTU =
3055 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3058 InfoHolder.addUnit(NewTU);
3060 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3063 DIE *Die = NewTU->createTypeDIE(CTy);
3065 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3066 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3067 dwarf::DW_FORM_data8,
3068 DIEHash().computeDIEODRSignature(*Die));
3069 // FIXME: This won't handle circularly referential structures, as the DIE
3070 // may have references to other DIEs still under construction and missing
3071 // their signature. Hashing should walk through the signatures to their
3072 // referenced type, or possibly walk the precomputed hashes of related types
3074 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3075 NewTU->setTypeSignature(Signature);
3076 NewTU->setType(Die);
3080 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3081 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3084 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);