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 NewCU->setSkeleton(constructSkeletonCU(NewCU));
831 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
832 DwarfInfoSectionSym);
834 CUMap.insert(std::make_pair(DIUnit, NewCU));
835 CUDieMap.insert(std::make_pair(Die, NewCU));
839 // Construct subprogram DIE.
840 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
842 // FIXME: We should only call this routine once, however, during LTO if a
843 // program is defined in multiple CUs we could end up calling it out of
844 // beginModule as we walk the CUs.
846 DwarfCompileUnit *&CURef = SPMap[N];
852 if (!SP.isDefinition())
853 // This is a method declaration which will be handled while constructing
857 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
859 // Expose as a global name.
860 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
863 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
865 DIImportedEntity Module(N);
866 if (!Module.Verify())
868 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
869 constructImportedEntityDIE(TheCU, Module, D);
872 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
873 const MDNode *N, DIE *Context) {
874 DIImportedEntity Module(N);
875 if (!Module.Verify())
877 return constructImportedEntityDIE(TheCU, Module, Context);
880 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
881 const DIImportedEntity &Module,
883 assert(Module.Verify() &&
884 "Use one of the MDNode * overloads to handle invalid metadata");
885 assert(Context && "Should always have a context for an imported_module");
886 DIE *IMDie = new DIE(Module.getTag());
887 TheCU->insertDIE(Module, IMDie);
889 DIDescriptor Entity = Module.getEntity();
890 if (Entity.isNameSpace())
891 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
892 else if (Entity.isSubprogram())
893 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
894 else if (Entity.isType())
895 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
897 EntityDie = TheCU->getDIE(Entity);
898 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
899 Module.getContext().getDirectory(),
900 TheCU->getUniqueID());
901 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
902 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
903 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
904 StringRef Name = Module.getName();
906 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
907 Context->addChild(IMDie);
910 // Emit all Dwarf sections that should come prior to the content. Create
911 // global DIEs and emit initial debug info sections. This is invoked by
912 // the target AsmPrinter.
913 void DwarfDebug::beginModule() {
914 if (DisableDebugInfoPrinting)
917 const Module *M = MMI->getModule();
919 // If module has named metadata anchors then use them, otherwise scan the
920 // module using debug info finder to collect debug info.
921 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
924 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
926 // Emit initial sections so we can reference labels later.
929 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
930 DICompileUnit CUNode(CU_Nodes->getOperand(i));
931 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
932 DIArray ImportedEntities = CUNode.getImportedEntities();
933 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
934 ScopesWithImportedEntities.push_back(std::make_pair(
935 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
936 ImportedEntities.getElement(i)));
937 std::sort(ScopesWithImportedEntities.begin(),
938 ScopesWithImportedEntities.end(), less_first());
939 DIArray GVs = CUNode.getGlobalVariables();
940 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
941 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
942 DIArray SPs = CUNode.getSubprograms();
943 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
944 constructSubprogramDIE(CU, SPs.getElement(i));
945 DIArray EnumTypes = CUNode.getEnumTypes();
946 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
947 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
948 DIArray RetainedTypes = CUNode.getRetainedTypes();
949 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
950 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
951 // Emit imported_modules last so that the relevant context is already
953 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
954 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
957 // Tell MMI that we have debug info.
958 MMI->setDebugInfoAvailability(true);
960 // Prime section data.
961 SectionMap[Asm->getObjFileLowering().getTextSection()];
964 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
965 void DwarfDebug::computeInlinedDIEs() {
966 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
967 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
968 AE = InlinedSubprogramDIEs.end();
971 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
973 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
974 AE = AbstractSPDies.end();
976 DIE *ISP = AI->second;
977 if (InlinedSubprogramDIEs.count(ISP))
979 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
983 // Collect info for variables that were optimized out.
984 void DwarfDebug::collectDeadVariables() {
985 const Module *M = MMI->getModule();
987 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
988 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
989 DICompileUnit TheCU(CU_Nodes->getOperand(i));
990 DIArray Subprograms = TheCU.getSubprograms();
991 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
992 DISubprogram SP(Subprograms.getElement(i));
993 if (ProcessedSPNodes.count(SP) != 0)
995 if (!SP.isSubprogram())
997 if (!SP.isDefinition())
999 DIArray Variables = SP.getVariables();
1000 if (Variables.getNumElements() == 0)
1003 // Construct subprogram DIE and add variables DIEs.
1004 DwarfCompileUnit *SPCU =
1005 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1006 assert(SPCU && "Unable to find Compile Unit!");
1007 // FIXME: See the comment in constructSubprogramDIE about duplicate
1009 constructSubprogramDIE(SPCU, SP);
1010 DIE *SPDIE = SPCU->getDIE(SP);
1011 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1012 DIVariable DV(Variables.getElement(vi));
1013 if (!DV.isVariable())
1015 DbgVariable NewVar(DV, NULL, this);
1016 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1017 SPDIE->addChild(VariableDIE);
1024 // Type Signature [7.27] and ODR Hash code.
1026 /// \brief Grabs the string in whichever attribute is passed in and returns
1027 /// a reference to it. Returns "" if the attribute doesn't exist.
1028 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1029 DIEValue *V = Die->findAttribute(Attr);
1031 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1032 return S->getString();
1034 return StringRef("");
1037 /// Return true if the current DIE is contained within an anonymous namespace.
1038 static bool isContainedInAnonNamespace(DIE *Die) {
1039 DIE *Parent = Die->getParent();
1042 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1043 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1045 Parent = Parent->getParent();
1051 /// Test if the current CU language is C++ and that we have
1052 /// a named type that is not contained in an anonymous namespace.
1053 static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
1054 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1055 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1056 !isContainedInAnonNamespace(Die);
1059 void DwarfDebug::finalizeModuleInfo() {
1060 // Collect info for variables that were optimized out.
1061 collectDeadVariables();
1063 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1064 computeInlinedDIEs();
1066 // Handle anything that needs to be done on a per-unit basis after
1067 // all other generation.
1068 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1069 E = getUnits().end();
1071 DwarfUnit *TheU = *I;
1072 // Emit DW_AT_containing_type attribute to connect types with their
1073 // vtable holding type.
1074 TheU->constructContainingTypeDIEs();
1076 // Add CU specific attributes if we need to add any.
1077 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1078 // If we're splitting the dwarf out now that we've got the entire
1079 // CU then add the dwo id to it.
1080 DwarfCompileUnit *SkCU =
1081 static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
1082 if (useSplitDwarf()) {
1083 // This should be a unique identifier when we want to build .dwp files.
1085 if (GenerateCUHash) {
1087 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1089 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1090 dwarf::DW_FORM_data8, ID);
1091 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1092 dwarf::DW_FORM_data8, ID);
1095 // If we've requested ranges and have them emit a DW_AT_ranges attribute
1096 // on the unit that will remain in the .o file, otherwise add a DW_AT_low_pc.
1097 // FIXME: Also add a high pc if we can.
1098 // FIXME: We should use ranges if we have multiple compile units.
1099 DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
1100 if (DwarfCURanges && TheU->getRanges().size())
1101 addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
1102 Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
1103 DwarfDebugRangeSectionSym);
1105 U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
1109 // Compute DIE offsets and sizes.
1110 InfoHolder.computeSizeAndOffsets();
1111 if (useSplitDwarf())
1112 SkeletonHolder.computeSizeAndOffsets();
1115 void DwarfDebug::endSections() {
1116 // Filter labels by section.
1117 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1118 const SymbolCU &SCU = ArangeLabels[n];
1119 if (SCU.Sym->isInSection()) {
1120 // Make a note of this symbol and it's section.
1121 const MCSection *Section = &SCU.Sym->getSection();
1122 if (!Section->getKind().isMetadata())
1123 SectionMap[Section].push_back(SCU);
1125 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1126 // appear in the output. This sucks as we rely on sections to build
1127 // arange spans. We can do it without, but it's icky.
1128 SectionMap[NULL].push_back(SCU);
1132 // Build a list of sections used.
1133 std::vector<const MCSection *> Sections;
1134 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1136 const MCSection *Section = it->first;
1137 Sections.push_back(Section);
1140 // Sort the sections into order.
1141 // This is only done to ensure consistent output order across different runs.
1142 std::sort(Sections.begin(), Sections.end(), SectionSort);
1144 // Add terminating symbols for each section.
1145 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1146 const MCSection *Section = Sections[ID];
1147 MCSymbol *Sym = NULL;
1150 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1151 // if we know the section name up-front. For user-created sections, the
1153 // label may not be valid to use as a label. (section names can use a
1155 // set of characters on some systems)
1156 Sym = Asm->GetTempSymbol("debug_end", ID);
1157 Asm->OutStreamer.SwitchSection(Section);
1158 Asm->OutStreamer.EmitLabel(Sym);
1161 // Insert a final terminator.
1162 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1166 // Emit all Dwarf sections that should come after the content.
1167 void DwarfDebug::endModule() {
1174 // End any existing sections.
1175 // TODO: Does this need to happen?
1178 // Finalize the debug info for the module.
1179 finalizeModuleInfo();
1183 // Emit all the DIEs into a debug info section.
1186 // Corresponding abbreviations into a abbrev section.
1187 emitAbbreviations();
1189 // Emit info into a debug loc section.
1192 // Emit info into a debug aranges section.
1195 // Emit info into a debug ranges section.
1198 if (useSplitDwarf()) {
1201 emitDebugAbbrevDWO();
1202 // Emit DWO addresses.
1203 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1206 // Emit info into the dwarf accelerator table sections.
1207 if (useDwarfAccelTables()) {
1210 emitAccelNamespaces();
1214 // Emit the pubnames and pubtypes sections if requested.
1215 if (HasDwarfPubSections) {
1216 emitDebugPubNames(GenerateGnuPubSections);
1217 emitDebugPubTypes(GenerateGnuPubSections);
1223 // Reset these for the next Module if we have one.
1227 // Find abstract variable, if any, associated with Var.
1228 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1229 DebugLoc ScopeLoc) {
1230 LLVMContext &Ctx = DV->getContext();
1231 // More then one inlined variable corresponds to one abstract variable.
1232 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1233 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1235 return AbsDbgVariable;
1237 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1241 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1242 addScopeVariable(Scope, AbsDbgVariable);
1243 AbstractVariables[Var] = AbsDbgVariable;
1244 return AbsDbgVariable;
1247 // If Var is a current function argument then add it to CurrentFnArguments list.
1248 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1249 if (!LScopes.isCurrentFunctionScope(Scope))
1251 DIVariable DV = Var->getVariable();
1252 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1254 unsigned ArgNo = DV.getArgNumber();
1258 size_t Size = CurrentFnArguments.size();
1260 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1261 // llvm::Function argument size is not good indicator of how many
1262 // arguments does the function have at source level.
1264 CurrentFnArguments.resize(ArgNo * 2);
1265 CurrentFnArguments[ArgNo - 1] = Var;
1269 // Collect variable information from side table maintained by MMI.
1270 void DwarfDebug::collectVariableInfoFromMMITable(
1271 SmallPtrSet<const MDNode *, 16> &Processed) {
1272 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1273 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1276 const MDNode *Var = VI->first;
1279 Processed.insert(Var);
1281 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1283 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1285 // If variable scope is not found then skip this variable.
1289 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1290 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1291 RegVar->setFrameIndex(VP.first);
1292 if (!addCurrentFnArgument(RegVar, Scope))
1293 addScopeVariable(Scope, RegVar);
1295 AbsDbgVariable->setFrameIndex(VP.first);
1299 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1301 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1302 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1303 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1304 MI->getOperand(0).getReg() &&
1305 (MI->getOperand(1).isImm() ||
1306 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1309 // Get .debug_loc entry for the instruction range starting at MI.
1310 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1311 const MCSymbol *FLabel,
1312 const MCSymbol *SLabel,
1313 const MachineInstr *MI) {
1314 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1316 assert(MI->getNumOperands() == 3);
1317 if (MI->getOperand(0).isReg()) {
1318 MachineLocation MLoc;
1319 // If the second operand is an immediate, this is a
1320 // register-indirect address.
1321 if (!MI->getOperand(1).isImm())
1322 MLoc.set(MI->getOperand(0).getReg());
1324 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1325 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1327 if (MI->getOperand(0).isImm())
1328 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1329 if (MI->getOperand(0).isFPImm())
1330 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1331 if (MI->getOperand(0).isCImm())
1332 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1334 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1337 // Find variables for each lexical scope.
1339 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1341 // Grab the variable info that was squirreled away in the MMI side-table.
1342 collectVariableInfoFromMMITable(Processed);
1344 for (SmallVectorImpl<const MDNode *>::const_iterator
1345 UVI = UserVariables.begin(),
1346 UVE = UserVariables.end();
1347 UVI != UVE; ++UVI) {
1348 const MDNode *Var = *UVI;
1349 if (Processed.count(Var))
1352 // History contains relevant DBG_VALUE instructions for Var and instructions
1354 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1355 if (History.empty())
1357 const MachineInstr *MInsn = History.front();
1360 LexicalScope *Scope = NULL;
1361 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1362 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1363 Scope = LScopes.getCurrentFunctionScope();
1364 else if (MDNode *IA = DV.getInlinedAt())
1365 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1367 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1368 // If variable scope is not found then skip this variable.
1372 Processed.insert(DV);
1373 assert(MInsn->isDebugValue() && "History must begin with debug value");
1374 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1375 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1376 if (!addCurrentFnArgument(RegVar, Scope))
1377 addScopeVariable(Scope, RegVar);
1379 AbsVar->setMInsn(MInsn);
1381 // Simplify ranges that are fully coalesced.
1382 if (History.size() <= 1 ||
1383 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1384 RegVar->setMInsn(MInsn);
1388 // Handle multiple DBG_VALUE instructions describing one variable.
1389 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1391 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1392 HI = History.begin(),
1395 const MachineInstr *Begin = *HI;
1396 assert(Begin->isDebugValue() && "Invalid History entry");
1398 // Check if DBG_VALUE is truncating a range.
1399 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1400 !Begin->getOperand(0).getReg())
1403 // Compute the range for a register location.
1404 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1405 const MCSymbol *SLabel = 0;
1408 // If Begin is the last instruction in History then its value is valid
1409 // until the end of the function.
1410 SLabel = FunctionEndSym;
1412 const MachineInstr *End = HI[1];
1413 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1414 << "\t" << *Begin << "\t" << *End << "\n");
1415 if (End->isDebugValue())
1416 SLabel = getLabelBeforeInsn(End);
1418 // End is a normal instruction clobbering the range.
1419 SLabel = getLabelAfterInsn(End);
1420 assert(SLabel && "Forgot label after clobber instruction");
1425 // The value is valid until the next DBG_VALUE or clobber.
1426 DotDebugLocEntries.push_back(
1427 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1429 DotDebugLocEntries.push_back(DotDebugLocEntry());
1432 // Collect info for variables that were optimized out.
1433 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1434 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1435 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1436 DIVariable DV(Variables.getElement(i));
1437 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1439 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1440 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1444 // Return Label preceding the instruction.
1445 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1446 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1447 assert(Label && "Didn't insert label before instruction");
1451 // Return Label immediately following the instruction.
1452 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1453 return LabelsAfterInsn.lookup(MI);
1456 // Process beginning of an instruction.
1457 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1460 // Check if source location changes, but ignore DBG_VALUE locations.
1461 if (!MI->isDebugValue()) {
1462 DebugLoc DL = MI->getDebugLoc();
1463 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1466 if (DL == PrologEndLoc) {
1467 Flags |= DWARF2_FLAG_PROLOGUE_END;
1468 PrologEndLoc = DebugLoc();
1470 if (PrologEndLoc.isUnknown())
1471 Flags |= DWARF2_FLAG_IS_STMT;
1473 if (!DL.isUnknown()) {
1474 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1475 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1477 recordSourceLine(0, 0, 0, 0);
1481 // Insert labels where requested.
1482 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1483 LabelsBeforeInsn.find(MI);
1486 if (I == LabelsBeforeInsn.end())
1489 // Label already assigned.
1494 PrevLabel = MMI->getContext().CreateTempSymbol();
1495 Asm->OutStreamer.EmitLabel(PrevLabel);
1497 I->second = PrevLabel;
1500 // Process end of an instruction.
1501 void DwarfDebug::endInstruction() {
1503 // Don't create a new label after DBG_VALUE instructions.
1504 // They don't generate code.
1505 if (!CurMI->isDebugValue())
1508 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1509 LabelsAfterInsn.find(CurMI);
1513 if (I == LabelsAfterInsn.end())
1516 // Label already assigned.
1520 // We need a label after this instruction.
1522 PrevLabel = MMI->getContext().CreateTempSymbol();
1523 Asm->OutStreamer.EmitLabel(PrevLabel);
1525 I->second = PrevLabel;
1528 // Each LexicalScope has first instruction and last instruction to mark
1529 // beginning and end of a scope respectively. Create an inverse map that list
1530 // scopes starts (and ends) with an instruction. One instruction may start (or
1531 // end) multiple scopes. Ignore scopes that are not reachable.
1532 void DwarfDebug::identifyScopeMarkers() {
1533 SmallVector<LexicalScope *, 4> WorkList;
1534 WorkList.push_back(LScopes.getCurrentFunctionScope());
1535 while (!WorkList.empty()) {
1536 LexicalScope *S = WorkList.pop_back_val();
1538 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1539 if (!Children.empty())
1540 for (SmallVectorImpl<LexicalScope *>::const_iterator
1541 SI = Children.begin(),
1542 SE = Children.end();
1544 WorkList.push_back(*SI);
1546 if (S->isAbstractScope())
1549 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1552 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1555 assert(RI->first && "InsnRange does not have first instruction!");
1556 assert(RI->second && "InsnRange does not have second instruction!");
1557 requestLabelBeforeInsn(RI->first);
1558 requestLabelAfterInsn(RI->second);
1563 // Get MDNode for DebugLoc's scope.
1564 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1565 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1566 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1567 return DL.getScope(Ctx);
1570 // Walk up the scope chain of given debug loc and find line number info
1571 // for the function.
1572 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1573 const MDNode *Scope = getScopeNode(DL, Ctx);
1574 DISubprogram SP = getDISubprogram(Scope);
1575 if (SP.isSubprogram()) {
1576 // Check for number of operands since the compatibility is
1578 if (SP->getNumOperands() > 19)
1579 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1581 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1587 // Gather pre-function debug information. Assumes being called immediately
1588 // after the function entry point has been emitted.
1589 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1592 // If there's no debug info for the function we're not going to do anything.
1593 if (!MMI->hasDebugInfo())
1596 // Grab the lexical scopes for the function, if we don't have any of those
1597 // then we're not going to be able to do anything.
1598 LScopes.initialize(*MF);
1599 if (LScopes.empty())
1602 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1604 // Make sure that each lexical scope will have a begin/end label.
1605 identifyScopeMarkers();
1607 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1608 // belongs to so that we add to the correct per-cu line table in the
1610 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1611 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1612 assert(TheCU && "Unable to find compile unit!");
1613 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1614 // Use a single line table if we are using .loc and generating assembly.
1615 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1617 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1619 // Emit a label for the function so that we have a beginning address.
1620 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1621 // Assumes in correct section after the entry point.
1622 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1624 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1625 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1626 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1628 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1630 bool AtBlockEntry = true;
1631 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1633 const MachineInstr *MI = II;
1635 if (MI->isDebugValue()) {
1636 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1638 // Keep track of user variables.
1640 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1642 // Variable is in a register, we need to check for clobbers.
1643 if (isDbgValueInDefinedReg(MI))
1644 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1646 // Check the history of this variable.
1647 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1648 if (History.empty()) {
1649 UserVariables.push_back(Var);
1650 // The first mention of a function argument gets the FunctionBeginSym
1651 // label, so arguments are visible when breaking at function entry.
1653 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1654 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1655 LabelsBeforeInsn[MI] = FunctionBeginSym;
1657 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1658 const MachineInstr *Prev = History.back();
1659 if (Prev->isDebugValue()) {
1660 // Coalesce identical entries at the end of History.
1661 if (History.size() >= 2 &&
1662 Prev->isIdenticalTo(History[History.size() - 2])) {
1663 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1664 << "\t" << *Prev << "\t"
1665 << *History[History.size() - 2] << "\n");
1669 // Terminate old register assignments that don't reach MI;
1670 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1671 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1672 isDbgValueInDefinedReg(Prev)) {
1673 // Previous register assignment needs to terminate at the end of
1675 MachineBasicBlock::const_iterator LastMI =
1676 PrevMBB->getLastNonDebugInstr();
1677 if (LastMI == PrevMBB->end()) {
1678 // Drop DBG_VALUE for empty range.
1679 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1680 << "\t" << *Prev << "\n");
1682 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1683 // Terminate after LastMI.
1684 History.push_back(LastMI);
1688 History.push_back(MI);
1690 // Not a DBG_VALUE instruction.
1692 AtBlockEntry = false;
1694 // First known non-DBG_VALUE and non-frame setup location marks
1695 // the beginning of the function body.
1696 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1697 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1698 PrologEndLoc = MI->getDebugLoc();
1700 // Check if the instruction clobbers any registers with debug vars.
1701 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1702 MOE = MI->operands_end();
1703 MOI != MOE; ++MOI) {
1704 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1706 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1709 const MDNode *Var = LiveUserVar[Reg];
1712 // Reg is now clobbered.
1713 LiveUserVar[Reg] = 0;
1715 // Was MD last defined by a DBG_VALUE referring to Reg?
1716 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1717 if (HistI == DbgValues.end())
1719 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1720 if (History.empty())
1722 const MachineInstr *Prev = History.back();
1723 // Sanity-check: Register assignments are terminated at the end of
1725 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1727 // Is the variable still in Reg?
1728 if (!isDbgValueInDefinedReg(Prev) ||
1729 Prev->getOperand(0).getReg() != Reg)
1731 // Var is clobbered. Make sure the next instruction gets a label.
1732 History.push_back(MI);
1739 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1741 SmallVectorImpl<const MachineInstr *> &History = I->second;
1742 if (History.empty())
1745 // Make sure the final register assignments are terminated.
1746 const MachineInstr *Prev = History.back();
1747 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1748 const MachineBasicBlock *PrevMBB = Prev->getParent();
1749 MachineBasicBlock::const_iterator LastMI =
1750 PrevMBB->getLastNonDebugInstr();
1751 if (LastMI == PrevMBB->end())
1752 // Drop DBG_VALUE for empty range.
1754 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1755 // Terminate after LastMI.
1756 History.push_back(LastMI);
1759 // Request labels for the full history.
1760 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1761 const MachineInstr *MI = History[i];
1762 if (MI->isDebugValue())
1763 requestLabelBeforeInsn(MI);
1765 requestLabelAfterInsn(MI);
1769 PrevInstLoc = DebugLoc();
1770 PrevLabel = FunctionBeginSym;
1772 // Record beginning of function.
1773 if (!PrologEndLoc.isUnknown()) {
1774 DebugLoc FnStartDL =
1775 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1777 FnStartDL.getLine(), FnStartDL.getCol(),
1778 FnStartDL.getScope(MF->getFunction()->getContext()),
1779 // We'd like to list the prologue as "not statements" but GDB behaves
1780 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1781 DWARF2_FLAG_IS_STMT);
1785 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1786 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1787 DIVariable DV = Var->getVariable();
1788 // Variables with positive arg numbers are parameters.
1789 if (unsigned ArgNum = DV.getArgNumber()) {
1790 // Keep all parameters in order at the start of the variable list to ensure
1791 // function types are correct (no out-of-order parameters)
1793 // This could be improved by only doing it for optimized builds (unoptimized
1794 // builds have the right order to begin with), searching from the back (this
1795 // would catch the unoptimized case quickly), or doing a binary search
1796 // rather than linear search.
1797 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1798 while (I != Vars.end()) {
1799 unsigned CurNum = (*I)->getVariable().getArgNumber();
1800 // A local (non-parameter) variable has been found, insert immediately
1804 // A later indexed parameter has been found, insert immediately before it.
1805 if (CurNum > ArgNum)
1809 Vars.insert(I, Var);
1813 Vars.push_back(Var);
1816 // Gather and emit post-function debug information.
1817 void DwarfDebug::endFunction(const MachineFunction *MF) {
1818 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1819 // though the beginFunction may not be called at all.
1820 // We should handle both cases.
1824 assert(CurFn == MF);
1827 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1832 // Define end label for subprogram.
1833 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1834 // Assumes in correct section after the entry point.
1835 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1836 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1837 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1839 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1840 collectVariableInfo(ProcessedVars);
1842 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1843 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1844 assert(TheCU && "Unable to find compile unit!");
1846 // Construct abstract scopes.
1847 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1848 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1849 LexicalScope *AScope = AList[i];
1850 DISubprogram SP(AScope->getScopeNode());
1851 if (SP.isSubprogram()) {
1852 // Collect info for variables that were optimized out.
1853 DIArray Variables = SP.getVariables();
1854 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1855 DIVariable DV(Variables.getElement(i));
1856 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1858 // Check that DbgVariable for DV wasn't created earlier, when
1859 // findAbstractVariable() was called for inlined instance of DV.
1860 LLVMContext &Ctx = DV->getContext();
1861 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1862 if (AbstractVariables.lookup(CleanDV))
1864 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1865 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1868 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1869 constructScopeDIE(TheCU, AScope);
1872 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1874 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1875 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1878 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1879 E = ScopeVariables.end();
1881 DeleteContainerPointers(I->second);
1882 ScopeVariables.clear();
1883 DeleteContainerPointers(CurrentFnArguments);
1884 UserVariables.clear();
1886 AbstractVariables.clear();
1887 LabelsBeforeInsn.clear();
1888 LabelsAfterInsn.clear();
1893 // Register a source line with debug info. Returns the unique label that was
1894 // emitted and which provides correspondence to the source line list.
1895 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1901 DIDescriptor Scope(S);
1903 if (Scope.isCompileUnit()) {
1904 DICompileUnit CU(S);
1905 Fn = CU.getFilename();
1906 Dir = CU.getDirectory();
1907 } else if (Scope.isFile()) {
1909 Fn = F.getFilename();
1910 Dir = F.getDirectory();
1911 } else if (Scope.isSubprogram()) {
1913 Fn = SP.getFilename();
1914 Dir = SP.getDirectory();
1915 } else if (Scope.isLexicalBlockFile()) {
1916 DILexicalBlockFile DBF(S);
1917 Fn = DBF.getFilename();
1918 Dir = DBF.getDirectory();
1919 } else if (Scope.isLexicalBlock()) {
1920 DILexicalBlock DB(S);
1921 Fn = DB.getFilename();
1922 Dir = DB.getDirectory();
1924 llvm_unreachable("Unexpected scope info");
1926 Src = getOrCreateSourceID(
1927 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1929 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1932 //===----------------------------------------------------------------------===//
1934 //===----------------------------------------------------------------------===//
1936 // Compute the size and offset of a DIE. The offset is relative to start of the
1937 // CU. It returns the offset after laying out the DIE.
1938 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1939 // Get the children.
1940 const std::vector<DIE *> &Children = Die->getChildren();
1942 // Record the abbreviation.
1943 assignAbbrevNumber(Die->getAbbrev());
1945 // Get the abbreviation for this DIE.
1946 const DIEAbbrev &Abbrev = Die->getAbbrev();
1949 Die->setOffset(Offset);
1951 // Start the size with the size of abbreviation code.
1952 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1954 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1955 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1957 // Size the DIE attribute values.
1958 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1959 // Size attribute value.
1960 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1962 // Size the DIE children if any.
1963 if (!Children.empty()) {
1964 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1965 "Children flag not set");
1967 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1968 Offset = computeSizeAndOffset(Children[j], Offset);
1970 // End of children marker.
1971 Offset += sizeof(int8_t);
1974 Die->setSize(Offset - Die->getOffset());
1978 // Compute the size and offset for each DIE.
1979 void DwarfFile::computeSizeAndOffsets() {
1980 // Offset from the first CU in the debug info section is 0 initially.
1981 unsigned SecOffset = 0;
1983 // Iterate over each compile unit and set the size and offsets for each
1984 // DIE within each compile unit. All offsets are CU relative.
1985 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1988 (*I)->setDebugInfoOffset(SecOffset);
1990 // CU-relative offset is reset to 0 here.
1991 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1992 (*I)->getHeaderSize(); // Unit-specific headers
1994 // EndOffset here is CU-relative, after laying out
1995 // all of the CU DIE.
1996 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1997 SecOffset += EndOffset;
2001 // Emit initial Dwarf sections with a label at the start of each one.
2002 void DwarfDebug::emitSectionLabels() {
2003 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2005 // Dwarf sections base addresses.
2006 DwarfInfoSectionSym =
2007 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2008 if (useSplitDwarf())
2009 DwarfInfoDWOSectionSym =
2010 emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
2011 DwarfAbbrevSectionSym =
2012 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2013 if (useSplitDwarf())
2014 DwarfAbbrevDWOSectionSym = emitSectionSym(
2015 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
2016 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2018 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2019 emitSectionSym(Asm, MacroInfo);
2021 DwarfLineSectionSym =
2022 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2023 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2024 if (GenerateGnuPubSections) {
2025 DwarfGnuPubNamesSectionSym =
2026 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2027 DwarfGnuPubTypesSectionSym =
2028 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2029 } else if (HasDwarfPubSections) {
2030 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2031 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2034 DwarfStrSectionSym =
2035 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2036 if (useSplitDwarf()) {
2037 DwarfStrDWOSectionSym =
2038 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2039 DwarfAddrSectionSym =
2040 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2042 DwarfDebugRangeSectionSym =
2043 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2045 DwarfDebugLocSectionSym =
2046 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2048 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2051 // Recursively emits a debug information entry.
2052 void DwarfDebug::emitDIE(DIE *Die) {
2053 // Get the abbreviation for this DIE.
2054 const DIEAbbrev &Abbrev = Die->getAbbrev();
2056 // Emit the code (index) for the abbreviation.
2057 if (Asm->isVerbose())
2058 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2059 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2060 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2061 dwarf::TagString(Abbrev.getTag()));
2062 Asm->EmitULEB128(Abbrev.getNumber());
2064 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2065 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2067 // Emit the DIE attribute values.
2068 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2069 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2070 dwarf::Form Form = AbbrevData[i].getForm();
2071 assert(Form && "Too many attributes for DIE (check abbreviation)");
2073 if (Asm->isVerbose())
2074 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2077 case dwarf::DW_AT_abstract_origin:
2078 case dwarf::DW_AT_type:
2079 case dwarf::DW_AT_friend:
2080 case dwarf::DW_AT_specification:
2081 case dwarf::DW_AT_import:
2082 case dwarf::DW_AT_containing_type: {
2083 DIEEntry *E = cast<DIEEntry>(Values[i]);
2084 DIE *Origin = E->getEntry();
2085 unsigned Addr = Origin->getOffset();
2086 if (Form == dwarf::DW_FORM_ref_addr) {
2087 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2088 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2089 // section. Origin->getOffset() returns the offset from start of the
2091 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2092 assert(CU && "CUDie should belong to a CU.");
2093 Addr += CU->getDebugInfoOffset();
2094 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2095 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2096 DIEEntry::getRefAddrSize(Asm));
2098 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2099 CU->getSectionSym(),
2100 DIEEntry::getRefAddrSize(Asm));
2102 // Make sure Origin belong to the same CU.
2103 assert(Die->getUnit() == Origin->getUnit() &&
2104 "The referenced DIE should belong to the same CU in ref4");
2105 Asm->EmitInt32(Addr);
2109 case dwarf::DW_AT_location: {
2110 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2111 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2112 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2114 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2116 Values[i]->EmitValue(Asm, Form);
2120 case dwarf::DW_AT_accessibility: {
2121 if (Asm->isVerbose()) {
2122 DIEInteger *V = cast<DIEInteger>(Values[i]);
2123 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2125 Values[i]->EmitValue(Asm, Form);
2129 // Emit an attribute using the defined form.
2130 Values[i]->EmitValue(Asm, Form);
2135 // Emit the DIE children if any.
2136 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2137 const std::vector<DIE *> &Children = Die->getChildren();
2139 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2140 emitDIE(Children[j]);
2142 Asm->OutStreamer.AddComment("End Of Children Mark");
2147 // Emit the various dwarf units to the unit section USection with
2148 // the abbreviations going into ASection.
2149 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2150 const MCSymbol *ASectionSym) {
2151 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2153 DwarfUnit *TheU = *I;
2154 DIE *Die = TheU->getUnitDie();
2155 const MCSection *USection = TheU->getSection();
2156 Asm->OutStreamer.SwitchSection(USection);
2158 // Emit the compile units header.
2159 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2161 // Emit size of content not including length itself
2162 Asm->OutStreamer.AddComment("Length of Unit");
2163 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2165 TheU->emitHeader(ASection, ASectionSym);
2168 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2172 // Emit the debug info section.
2173 void DwarfDebug::emitDebugInfo() {
2174 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2176 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2177 DwarfAbbrevSectionSym);
2180 // Emit the abbreviation section.
2181 void DwarfDebug::emitAbbreviations() {
2182 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2184 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2187 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2188 // Check to see if it is worth the effort.
2189 if (!Abbreviations.empty()) {
2190 // Start the debug abbrev section.
2191 Asm->OutStreamer.SwitchSection(Section);
2193 // For each abbrevation.
2194 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2195 // Get abbreviation data
2196 const DIEAbbrev *Abbrev = Abbreviations[i];
2198 // Emit the abbrevations code (base 1 index.)
2199 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2201 // Emit the abbreviations data.
2205 // Mark end of abbreviations.
2206 Asm->EmitULEB128(0, "EOM(3)");
2210 // Emit the last address of the section and the end of the line matrix.
2211 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2212 // Define last address of section.
2213 Asm->OutStreamer.AddComment("Extended Op");
2216 Asm->OutStreamer.AddComment("Op size");
2217 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2218 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2219 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2221 Asm->OutStreamer.AddComment("Section end label");
2223 Asm->OutStreamer.EmitSymbolValue(
2224 Asm->GetTempSymbol("section_end", SectionEnd),
2225 Asm->getDataLayout().getPointerSize());
2227 // Mark end of matrix.
2228 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2234 // Emit visible names into a hashed accelerator table section.
2235 void DwarfDebug::emitAccelNames() {
2237 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2238 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2239 E = getUnits().end();
2241 DwarfUnit *TheU = *I;
2242 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2243 for (StringMap<std::vector<const DIE *> >::const_iterator
2247 StringRef Name = GI->getKey();
2248 const std::vector<const DIE *> &Entities = GI->second;
2249 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2250 DE = Entities.end();
2252 AT.AddName(Name, *DI);
2256 AT.FinalizeTable(Asm, "Names");
2257 Asm->OutStreamer.SwitchSection(
2258 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2259 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2260 Asm->OutStreamer.EmitLabel(SectionBegin);
2262 // Emit the full data.
2263 AT.Emit(Asm, SectionBegin, &InfoHolder);
2266 // Emit objective C classes and categories into a hashed accelerator table
2268 void DwarfDebug::emitAccelObjC() {
2270 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2271 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2272 E = getUnits().end();
2274 DwarfUnit *TheU = *I;
2275 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2276 for (StringMap<std::vector<const DIE *> >::const_iterator
2280 StringRef Name = GI->getKey();
2281 const std::vector<const DIE *> &Entities = GI->second;
2282 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2283 DE = Entities.end();
2285 AT.AddName(Name, *DI);
2289 AT.FinalizeTable(Asm, "ObjC");
2290 Asm->OutStreamer.SwitchSection(
2291 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2292 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2293 Asm->OutStreamer.EmitLabel(SectionBegin);
2295 // Emit the full data.
2296 AT.Emit(Asm, SectionBegin, &InfoHolder);
2299 // Emit namespace dies into a hashed accelerator table.
2300 void DwarfDebug::emitAccelNamespaces() {
2302 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2303 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2304 E = getUnits().end();
2306 DwarfUnit *TheU = *I;
2307 const StringMap<std::vector<const DIE *> > &Names =
2308 TheU->getAccelNamespace();
2309 for (StringMap<std::vector<const DIE *> >::const_iterator
2313 StringRef Name = GI->getKey();
2314 const std::vector<const DIE *> &Entities = GI->second;
2315 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2316 DE = Entities.end();
2318 AT.AddName(Name, *DI);
2322 AT.FinalizeTable(Asm, "namespac");
2323 Asm->OutStreamer.SwitchSection(
2324 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2325 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2326 Asm->OutStreamer.EmitLabel(SectionBegin);
2328 // Emit the full data.
2329 AT.Emit(Asm, SectionBegin, &InfoHolder);
2332 // Emit type dies into a hashed accelerator table.
2333 void DwarfDebug::emitAccelTypes() {
2334 std::vector<DwarfAccelTable::Atom> Atoms;
2336 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2338 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2340 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2341 DwarfAccelTable AT(Atoms);
2342 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2343 E = getUnits().end();
2345 DwarfUnit *TheU = *I;
2346 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2347 TheU->getAccelTypes();
2349 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2353 StringRef Name = GI->getKey();
2354 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2356 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2357 DI = Entities.begin(),
2358 DE = Entities.end();
2360 AT.AddName(Name, DI->first, DI->second);
2364 AT.FinalizeTable(Asm, "types");
2365 Asm->OutStreamer.SwitchSection(
2366 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2367 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2368 Asm->OutStreamer.EmitLabel(SectionBegin);
2370 // Emit the full data.
2371 AT.Emit(Asm, SectionBegin, &InfoHolder);
2374 // Public name handling.
2375 // The format for the various pubnames:
2377 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2378 // for the DIE that is named.
2380 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2381 // into the CU and the index value is computed according to the type of value
2382 // for the DIE that is named.
2384 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2385 // it's the offset within the debug_info/debug_types dwo section, however, the
2386 // reference in the pubname header doesn't change.
2388 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2389 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2391 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2393 // We could have a specification DIE that has our most of our knowledge,
2394 // look for that now.
2395 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2397 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2398 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2399 Linkage = dwarf::GIEL_EXTERNAL;
2400 } else if (Die->findAttribute(dwarf::DW_AT_external))
2401 Linkage = dwarf::GIEL_EXTERNAL;
2403 switch (Die->getTag()) {
2404 case dwarf::DW_TAG_class_type:
2405 case dwarf::DW_TAG_structure_type:
2406 case dwarf::DW_TAG_union_type:
2407 case dwarf::DW_TAG_enumeration_type:
2408 return dwarf::PubIndexEntryDescriptor(
2409 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2410 ? dwarf::GIEL_STATIC
2411 : dwarf::GIEL_EXTERNAL);
2412 case dwarf::DW_TAG_typedef:
2413 case dwarf::DW_TAG_base_type:
2414 case dwarf::DW_TAG_subrange_type:
2415 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2416 case dwarf::DW_TAG_namespace:
2417 return dwarf::GIEK_TYPE;
2418 case dwarf::DW_TAG_subprogram:
2419 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2420 case dwarf::DW_TAG_constant:
2421 case dwarf::DW_TAG_variable:
2422 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2423 case dwarf::DW_TAG_enumerator:
2424 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2425 dwarf::GIEL_STATIC);
2427 return dwarf::GIEK_NONE;
2431 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2433 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2434 const MCSection *PSec =
2435 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2436 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2438 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2439 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2440 for (unsigned i = 0; i != Units.size(); ++i) {
2441 DwarfUnit *TheU = Units[i];
2442 unsigned ID = TheU->getUniqueID();
2444 // Start the dwarf pubnames section.
2445 Asm->OutStreamer.SwitchSection(PSec);
2447 // Emit a label so we can reference the beginning of this pubname section.
2449 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2452 Asm->OutStreamer.AddComment("Length of Public Names Info");
2453 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2454 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2455 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2457 Asm->OutStreamer.EmitLabel(BeginLabel);
2459 Asm->OutStreamer.AddComment("DWARF Version");
2460 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2462 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2463 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2465 Asm->OutStreamer.AddComment("Compilation Unit Length");
2466 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2468 // Emit the pubnames for this compilation unit.
2469 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2470 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2473 const char *Name = GI->getKeyData();
2474 const DIE *Entity = GI->second;
2476 Asm->OutStreamer.AddComment("DIE offset");
2477 Asm->EmitInt32(Entity->getOffset());
2480 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2481 Asm->OutStreamer.AddComment(
2482 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2483 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2484 Asm->EmitInt8(Desc.toBits());
2487 Asm->OutStreamer.AddComment("External Name");
2488 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2491 Asm->OutStreamer.AddComment("End Mark");
2493 Asm->OutStreamer.EmitLabel(EndLabel);
2497 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2498 const MCSection *PSec =
2499 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2500 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2502 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2503 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2504 for (unsigned i = 0; i != Units.size(); ++i) {
2505 DwarfUnit *TheU = Units[i];
2506 unsigned ID = TheU->getUniqueID();
2508 // Start the dwarf pubtypes section.
2509 Asm->OutStreamer.SwitchSection(PSec);
2511 // Emit a label so we can reference the beginning of this pubtype section.
2513 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2516 Asm->OutStreamer.AddComment("Length of Public Types Info");
2517 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2518 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2519 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2521 Asm->OutStreamer.EmitLabel(BeginLabel);
2523 Asm->OutStreamer.AddComment("DWARF Version");
2524 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2526 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2527 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2529 Asm->OutStreamer.AddComment("Compilation Unit Length");
2530 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2532 // Emit the pubtypes.
2533 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2534 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2537 const char *Name = GI->getKeyData();
2538 const DIE *Entity = GI->second;
2540 Asm->OutStreamer.AddComment("DIE offset");
2541 Asm->EmitInt32(Entity->getOffset());
2544 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2545 Asm->OutStreamer.AddComment(
2546 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2547 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2548 Asm->EmitInt8(Desc.toBits());
2551 Asm->OutStreamer.AddComment("External Name");
2553 // Emit the name with a terminating null byte.
2554 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2557 Asm->OutStreamer.AddComment("End Mark");
2559 Asm->OutStreamer.EmitLabel(EndLabel);
2563 // Emit strings into a string section.
2564 void DwarfFile::emitStrings(const MCSection *StrSection,
2565 const MCSection *OffsetSection = NULL,
2566 const MCSymbol *StrSecSym = NULL) {
2568 if (StringPool.empty())
2571 // Start the dwarf str section.
2572 Asm->OutStreamer.SwitchSection(StrSection);
2574 // Get all of the string pool entries and put them in an array by their ID so
2575 // we can sort them.
2577 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2580 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2581 I = StringPool.begin(),
2582 E = StringPool.end();
2584 Entries.push_back(std::make_pair(I->second.second, &*I));
2586 array_pod_sort(Entries.begin(), Entries.end());
2588 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2589 // Emit a label for reference from debug information entries.
2590 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2592 // Emit the string itself with a terminating null byte.
2593 Asm->OutStreamer.EmitBytes(
2594 StringRef(Entries[i].second->getKeyData(),
2595 Entries[i].second->getKeyLength() + 1));
2598 // If we've got an offset section go ahead and emit that now as well.
2599 if (OffsetSection) {
2600 Asm->OutStreamer.SwitchSection(OffsetSection);
2601 unsigned offset = 0;
2602 unsigned size = 4; // FIXME: DWARF64 is 8.
2603 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2604 Asm->OutStreamer.EmitIntValue(offset, size);
2605 offset += Entries[i].second->getKeyLength() + 1;
2610 // Emit addresses into the section given.
2611 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2613 if (AddressPool.empty())
2616 // Start the dwarf addr section.
2617 Asm->OutStreamer.SwitchSection(AddrSection);
2619 // Order the address pool entries by ID
2620 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2622 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2623 E = AddressPool.end();
2625 Entries[I->second] = I->first;
2627 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2628 // Emit an expression for reference from debug information entries.
2629 if (const MCExpr *Expr = Entries[i])
2630 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2632 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2636 // Emit visible names into a debug str section.
2637 void DwarfDebug::emitDebugStr() {
2638 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2639 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2642 // Emit locations into the debug loc section.
2643 void DwarfDebug::emitDebugLoc() {
2644 if (DotDebugLocEntries.empty())
2647 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2648 I = DotDebugLocEntries.begin(),
2649 E = DotDebugLocEntries.end();
2651 DotDebugLocEntry &Entry = *I;
2652 if (I + 1 != DotDebugLocEntries.end())
2656 // Start the dwarf loc section.
2657 Asm->OutStreamer.SwitchSection(
2658 Asm->getObjFileLowering().getDwarfLocSection());
2659 unsigned char Size = Asm->getDataLayout().getPointerSize();
2660 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2662 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2663 I = DotDebugLocEntries.begin(),
2664 E = DotDebugLocEntries.end();
2665 I != E; ++I, ++index) {
2666 DotDebugLocEntry &Entry = *I;
2667 if (Entry.isMerged())
2669 if (Entry.isEmpty()) {
2670 Asm->OutStreamer.EmitIntValue(0, Size);
2671 Asm->OutStreamer.EmitIntValue(0, Size);
2672 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2674 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2675 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2676 DIVariable DV(Entry.getVariable());
2677 Asm->OutStreamer.AddComment("Loc expr size");
2678 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2679 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2680 Asm->EmitLabelDifference(end, begin, 2);
2681 Asm->OutStreamer.EmitLabel(begin);
2682 if (Entry.isInt()) {
2683 DIBasicType BTy(DV.getType());
2684 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2685 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2686 Asm->OutStreamer.AddComment("DW_OP_consts");
2687 Asm->EmitInt8(dwarf::DW_OP_consts);
2688 Asm->EmitSLEB128(Entry.getInt());
2690 Asm->OutStreamer.AddComment("DW_OP_constu");
2691 Asm->EmitInt8(dwarf::DW_OP_constu);
2692 Asm->EmitULEB128(Entry.getInt());
2694 } else if (Entry.isLocation()) {
2695 MachineLocation Loc = Entry.getLoc();
2696 if (!DV.hasComplexAddress())
2698 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2700 // Complex address entry.
2701 unsigned N = DV.getNumAddrElements();
2703 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2704 if (Loc.getOffset()) {
2706 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2707 Asm->OutStreamer.AddComment("DW_OP_deref");
2708 Asm->EmitInt8(dwarf::DW_OP_deref);
2709 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2710 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2711 Asm->EmitSLEB128(DV.getAddrElement(1));
2713 // If first address element is OpPlus then emit
2714 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2715 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2716 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2720 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2723 // Emit remaining complex address elements.
2724 for (; i < N; ++i) {
2725 uint64_t Element = DV.getAddrElement(i);
2726 if (Element == DIBuilder::OpPlus) {
2727 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2728 Asm->EmitULEB128(DV.getAddrElement(++i));
2729 } else if (Element == DIBuilder::OpDeref) {
2731 Asm->EmitInt8(dwarf::DW_OP_deref);
2733 llvm_unreachable("unknown Opcode found in complex address");
2737 // else ... ignore constant fp. There is not any good way to
2738 // to represent them here in dwarf.
2739 Asm->OutStreamer.EmitLabel(end);
2744 struct SymbolCUSorter {
2745 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2746 const MCStreamer &Streamer;
2748 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2749 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2750 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2752 // Symbols with no order assigned should be placed at the end.
2753 // (e.g. section end labels)
2755 IA = (unsigned)(-1);
2757 IB = (unsigned)(-1);
2762 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2763 return (A->getUniqueID() < B->getUniqueID());
2767 const MCSymbol *Start, *End;
2770 // Emit a debug aranges section, containing a CU lookup for any
2771 // address we can tie back to a CU.
2772 void DwarfDebug::emitDebugARanges() {
2773 // Start the dwarf aranges section.
2774 Asm->OutStreamer.SwitchSection(
2775 Asm->getObjFileLowering().getDwarfARangesSection());
2777 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2781 // Build a list of sections used.
2782 std::vector<const MCSection *> Sections;
2783 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2785 const MCSection *Section = it->first;
2786 Sections.push_back(Section);
2789 // Sort the sections into order.
2790 // This is only done to ensure consistent output order across different runs.
2791 std::sort(Sections.begin(), Sections.end(), SectionSort);
2793 // Build a set of address spans, sorted by CU.
2794 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2795 const MCSection *Section = Sections[SecIdx];
2796 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2797 if (List.size() < 2)
2800 // Sort the symbols by offset within the section.
2801 SymbolCUSorter sorter(Asm->OutStreamer);
2802 std::sort(List.begin(), List.end(), sorter);
2804 // If we have no section (e.g. common), just write out
2805 // individual spans for each symbol.
2806 if (Section == NULL) {
2807 for (size_t n = 0; n < List.size(); n++) {
2808 const SymbolCU &Cur = List[n];
2811 Span.Start = Cur.Sym;
2814 Spans[Cur.CU].push_back(Span);
2817 // Build spans between each label.
2818 const MCSymbol *StartSym = List[0].Sym;
2819 for (size_t n = 1; n < List.size(); n++) {
2820 const SymbolCU &Prev = List[n - 1];
2821 const SymbolCU &Cur = List[n];
2823 // Try and build the longest span we can within the same CU.
2824 if (Cur.CU != Prev.CU) {
2826 Span.Start = StartSym;
2828 Spans[Prev.CU].push_back(Span);
2835 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2837 // Build a list of CUs used.
2838 std::vector<DwarfCompileUnit *> CUs;
2839 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2840 DwarfCompileUnit *CU = it->first;
2844 // Sort the CU list (again, to ensure consistent output order).
2845 std::sort(CUs.begin(), CUs.end(), CUSort);
2847 // Emit an arange table for each CU we used.
2848 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2849 DwarfCompileUnit *CU = CUs[CUIdx];
2850 std::vector<ArangeSpan> &List = Spans[CU];
2852 // Emit size of content not including length itself.
2853 unsigned ContentSize =
2854 sizeof(int16_t) + // DWARF ARange version number
2855 sizeof(int32_t) + // Offset of CU in the .debug_info section
2856 sizeof(int8_t) + // Pointer Size (in bytes)
2857 sizeof(int8_t); // Segment Size (in bytes)
2859 unsigned TupleSize = PtrSize * 2;
2861 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2862 unsigned Padding = 0;
2863 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2866 ContentSize += Padding;
2867 ContentSize += (List.size() + 1) * TupleSize;
2869 // For each compile unit, write the list of spans it covers.
2870 Asm->OutStreamer.AddComment("Length of ARange Set");
2871 Asm->EmitInt32(ContentSize);
2872 Asm->OutStreamer.AddComment("DWARF Arange version number");
2873 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2874 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2875 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2876 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2877 Asm->EmitInt8(PtrSize);
2878 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2881 for (unsigned n = 0; n < Padding; n++)
2882 Asm->EmitInt8(0xff);
2884 for (unsigned n = 0; n < List.size(); n++) {
2885 const ArangeSpan &Span = List[n];
2886 Asm->EmitLabelReference(Span.Start, PtrSize);
2888 // Calculate the size as being from the span start to it's end.
2890 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2892 // For symbols without an end marker (e.g. common), we
2893 // write a single arange entry containing just that one symbol.
2894 uint64_t Size = SymSize[Span.Start];
2898 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2902 Asm->OutStreamer.AddComment("ARange terminator");
2903 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2904 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2908 // Emit visible names into a debug ranges section.
2909 void DwarfDebug::emitDebugRanges() {
2910 // Start the dwarf ranges section.
2911 Asm->OutStreamer.SwitchSection(
2912 Asm->getObjFileLowering().getDwarfRangesSection());
2914 // Size for our labels.
2915 unsigned char Size = Asm->getDataLayout().getPointerSize();
2917 // Grab the specific ranges for the compile units in the module.
2918 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2921 DwarfCompileUnit *TheCU = I->second;
2923 // Emit a symbol so we can find the beginning of our ranges.
2924 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2926 // Iterate over the misc ranges for the compile units in the module.
2927 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2928 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2929 E = RangeLists.end();
2931 const RangeSpanList &List = *I;
2933 // Emit our symbol so we can find the beginning of the range.
2934 Asm->OutStreamer.EmitLabel(List.getSym());
2936 for (SmallVectorImpl<RangeSpan>::const_iterator
2937 RI = List.getRanges().begin(),
2938 RE = List.getRanges().end();
2940 const RangeSpan &Range = *RI;
2941 const MCSymbol *Begin = Range.getStart();
2942 const MCSymbol *End = Range.getEnd();
2943 assert(Begin && "Range without a begin symbol?");
2944 assert(End && "Range without an end symbol?");
2945 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2946 Asm->OutStreamer.EmitSymbolValue(End, Size);
2949 // And terminate the list with two 0 values.
2950 Asm->OutStreamer.EmitIntValue(0, Size);
2951 Asm->OutStreamer.EmitIntValue(0, Size);
2954 // Now emit a range for the CU itself.
2955 if (DwarfCURanges) {
2956 Asm->OutStreamer.EmitLabel(
2957 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2958 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2959 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2960 RangeSpan Range = Ranges[i];
2961 const MCSymbol *Begin = Range.getStart();
2962 const MCSymbol *End = Range.getEnd();
2963 assert(Begin && "Range without a begin symbol?");
2964 assert(End && "Range without an end symbol?");
2965 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2966 Asm->OutStreamer.EmitSymbolValue(End, Size);
2968 // And terminate the list with two 0 values.
2969 Asm->OutStreamer.EmitIntValue(0, Size);
2970 Asm->OutStreamer.EmitIntValue(0, Size);
2975 // DWARF5 Experimental Separate Dwarf emitters.
2977 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2978 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2979 // DW_AT_ranges_base, DW_AT_addr_base.
2980 // TODO: Implement DW_AT_ranges_base.
2981 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2983 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2984 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2985 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2986 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2987 DwarfInfoSectionSym);
2989 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2990 CU->getNode().getSplitDebugFilename());
2992 // Relocate to the beginning of the addr_base section, else 0 for the
2993 // beginning of the one for this compile unit.
2994 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2995 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2996 DwarfAddrSectionSym);
2998 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3000 // DW_AT_stmt_list is a offset of line number information for this
3001 // compile unit in debug_line section.
3002 // FIXME: Should handle multiple compile units.
3003 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3004 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3006 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3008 if (!CompilationDir.empty())
3009 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3011 addGnuPubAttributes(NewCU, Die);
3013 SkeletonHolder.addUnit(NewCU);
3018 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3019 // compile units that would normally be in debug_info.
3020 void DwarfDebug::emitDebugInfoDWO() {
3021 assert(useSplitDwarf() && "No split dwarf debug info?");
3022 InfoHolder.emitUnits(this,
3023 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3024 DwarfAbbrevDWOSectionSym);
3027 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3028 // abbreviations for the .debug_info.dwo section.
3029 void DwarfDebug::emitDebugAbbrevDWO() {
3030 assert(useSplitDwarf() && "No split dwarf?");
3031 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3034 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3035 // string section and is identical in format to traditional .debug_str
3037 void DwarfDebug::emitDebugStrDWO() {
3038 assert(useSplitDwarf() && "No split dwarf?");
3039 const MCSection *OffSec =
3040 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3041 const MCSymbol *StrSym = DwarfStrSectionSym;
3042 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3046 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3047 DICompositeType CTy) {
3048 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3050 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3051 DwarfTypeUnit *NewTU =
3052 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3055 InfoHolder.addUnit(NewTU);
3057 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3060 DIE *Die = NewTU->createTypeDIE(CTy);
3062 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3063 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3064 dwarf::DW_FORM_data8,
3065 DIEHash().computeDIEODRSignature(*Die));
3066 // FIXME: This won't handle circularly referential structures, as the DIE
3067 // may have references to other DIEs still under construction and missing
3068 // their signature. Hashing should walk through the signatures to their
3069 // referenced type, or possibly walk the precomputed hashes of related types
3071 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3072 NewTU->setTypeSignature(Signature);
3073 NewTU->setType(Die);
3077 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3078 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3081 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);