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");
2049 emitSectionSym(Asm, TLOF.getDataSection());
2052 // Recursively emits a debug information entry.
2053 void DwarfDebug::emitDIE(DIE *Die) {
2054 // Get the abbreviation for this DIE.
2055 const DIEAbbrev &Abbrev = Die->getAbbrev();
2057 // Emit the code (index) for the abbreviation.
2058 if (Asm->isVerbose())
2059 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2060 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2061 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2062 dwarf::TagString(Abbrev.getTag()));
2063 Asm->EmitULEB128(Abbrev.getNumber());
2065 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2066 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2068 // Emit the DIE attribute values.
2069 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2070 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2071 dwarf::Form Form = AbbrevData[i].getForm();
2072 assert(Form && "Too many attributes for DIE (check abbreviation)");
2074 if (Asm->isVerbose())
2075 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2078 case dwarf::DW_AT_abstract_origin:
2079 case dwarf::DW_AT_type:
2080 case dwarf::DW_AT_friend:
2081 case dwarf::DW_AT_specification:
2082 case dwarf::DW_AT_import:
2083 case dwarf::DW_AT_containing_type: {
2084 DIEEntry *E = cast<DIEEntry>(Values[i]);
2085 DIE *Origin = E->getEntry();
2086 unsigned Addr = Origin->getOffset();
2087 if (Form == dwarf::DW_FORM_ref_addr) {
2088 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2089 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2090 // section. Origin->getOffset() returns the offset from start of the
2092 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2093 assert(CU && "CUDie should belong to a CU.");
2094 Addr += CU->getDebugInfoOffset();
2095 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2096 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2097 DIEEntry::getRefAddrSize(Asm));
2099 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2100 CU->getSectionSym(),
2101 DIEEntry::getRefAddrSize(Asm));
2103 // Make sure Origin belong to the same CU.
2104 assert(Die->getUnit() == Origin->getUnit() &&
2105 "The referenced DIE should belong to the same CU in ref4");
2106 Asm->EmitInt32(Addr);
2110 case dwarf::DW_AT_location: {
2111 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2112 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2113 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2115 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2117 Values[i]->EmitValue(Asm, Form);
2121 case dwarf::DW_AT_accessibility: {
2122 if (Asm->isVerbose()) {
2123 DIEInteger *V = cast<DIEInteger>(Values[i]);
2124 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2126 Values[i]->EmitValue(Asm, Form);
2130 // Emit an attribute using the defined form.
2131 Values[i]->EmitValue(Asm, Form);
2136 // Emit the DIE children if any.
2137 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2138 const std::vector<DIE *> &Children = Die->getChildren();
2140 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2141 emitDIE(Children[j]);
2143 Asm->OutStreamer.AddComment("End Of Children Mark");
2148 // Emit the various dwarf units to the unit section USection with
2149 // the abbreviations going into ASection.
2150 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2151 const MCSymbol *ASectionSym) {
2152 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2154 DwarfUnit *TheU = *I;
2155 DIE *Die = TheU->getUnitDie();
2156 const MCSection *USection = TheU->getSection();
2157 Asm->OutStreamer.SwitchSection(USection);
2159 // Emit the compile units header.
2160 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2162 // Emit size of content not including length itself
2163 Asm->OutStreamer.AddComment("Length of Unit");
2164 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2166 TheU->emitHeader(ASection, ASectionSym);
2169 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2173 // Emit the debug info section.
2174 void DwarfDebug::emitDebugInfo() {
2175 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2177 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2178 DwarfAbbrevSectionSym);
2181 // Emit the abbreviation section.
2182 void DwarfDebug::emitAbbreviations() {
2183 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2185 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2188 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2189 // Check to see if it is worth the effort.
2190 if (!Abbreviations.empty()) {
2191 // Start the debug abbrev section.
2192 Asm->OutStreamer.SwitchSection(Section);
2194 // For each abbrevation.
2195 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2196 // Get abbreviation data
2197 const DIEAbbrev *Abbrev = Abbreviations[i];
2199 // Emit the abbrevations code (base 1 index.)
2200 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2202 // Emit the abbreviations data.
2206 // Mark end of abbreviations.
2207 Asm->EmitULEB128(0, "EOM(3)");
2211 // Emit the last address of the section and the end of the line matrix.
2212 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2213 // Define last address of section.
2214 Asm->OutStreamer.AddComment("Extended Op");
2217 Asm->OutStreamer.AddComment("Op size");
2218 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2219 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2220 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2222 Asm->OutStreamer.AddComment("Section end label");
2224 Asm->OutStreamer.EmitSymbolValue(
2225 Asm->GetTempSymbol("section_end", SectionEnd),
2226 Asm->getDataLayout().getPointerSize());
2228 // Mark end of matrix.
2229 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2235 // Emit visible names into a hashed accelerator table section.
2236 void DwarfDebug::emitAccelNames() {
2238 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2239 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2240 E = getUnits().end();
2242 DwarfUnit *TheU = *I;
2243 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2244 for (StringMap<std::vector<const DIE *> >::const_iterator
2248 StringRef Name = GI->getKey();
2249 const std::vector<const DIE *> &Entities = GI->second;
2250 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2251 DE = Entities.end();
2253 AT.AddName(Name, *DI);
2257 AT.FinalizeTable(Asm, "Names");
2258 Asm->OutStreamer.SwitchSection(
2259 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2260 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2261 Asm->OutStreamer.EmitLabel(SectionBegin);
2263 // Emit the full data.
2264 AT.Emit(Asm, SectionBegin, &InfoHolder);
2267 // Emit objective C classes and categories into a hashed accelerator table
2269 void DwarfDebug::emitAccelObjC() {
2271 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2272 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2273 E = getUnits().end();
2275 DwarfUnit *TheU = *I;
2276 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2277 for (StringMap<std::vector<const DIE *> >::const_iterator
2281 StringRef Name = GI->getKey();
2282 const std::vector<const DIE *> &Entities = GI->second;
2283 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2284 DE = Entities.end();
2286 AT.AddName(Name, *DI);
2290 AT.FinalizeTable(Asm, "ObjC");
2291 Asm->OutStreamer.SwitchSection(
2292 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2293 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2294 Asm->OutStreamer.EmitLabel(SectionBegin);
2296 // Emit the full data.
2297 AT.Emit(Asm, SectionBegin, &InfoHolder);
2300 // Emit namespace dies into a hashed accelerator table.
2301 void DwarfDebug::emitAccelNamespaces() {
2303 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2304 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2305 E = getUnits().end();
2307 DwarfUnit *TheU = *I;
2308 const StringMap<std::vector<const DIE *> > &Names =
2309 TheU->getAccelNamespace();
2310 for (StringMap<std::vector<const DIE *> >::const_iterator
2314 StringRef Name = GI->getKey();
2315 const std::vector<const DIE *> &Entities = GI->second;
2316 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2317 DE = Entities.end();
2319 AT.AddName(Name, *DI);
2323 AT.FinalizeTable(Asm, "namespac");
2324 Asm->OutStreamer.SwitchSection(
2325 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2326 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2327 Asm->OutStreamer.EmitLabel(SectionBegin);
2329 // Emit the full data.
2330 AT.Emit(Asm, SectionBegin, &InfoHolder);
2333 // Emit type dies into a hashed accelerator table.
2334 void DwarfDebug::emitAccelTypes() {
2335 std::vector<DwarfAccelTable::Atom> Atoms;
2337 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2339 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2341 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2342 DwarfAccelTable AT(Atoms);
2343 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2344 E = getUnits().end();
2346 DwarfUnit *TheU = *I;
2347 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2348 TheU->getAccelTypes();
2350 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2354 StringRef Name = GI->getKey();
2355 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2357 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2358 DI = Entities.begin(),
2359 DE = Entities.end();
2361 AT.AddName(Name, DI->first, DI->second);
2365 AT.FinalizeTable(Asm, "types");
2366 Asm->OutStreamer.SwitchSection(
2367 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2368 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2369 Asm->OutStreamer.EmitLabel(SectionBegin);
2371 // Emit the full data.
2372 AT.Emit(Asm, SectionBegin, &InfoHolder);
2375 // Public name handling.
2376 // The format for the various pubnames:
2378 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2379 // for the DIE that is named.
2381 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2382 // into the CU and the index value is computed according to the type of value
2383 // for the DIE that is named.
2385 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2386 // it's the offset within the debug_info/debug_types dwo section, however, the
2387 // reference in the pubname header doesn't change.
2389 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2390 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2392 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2394 // We could have a specification DIE that has our most of our knowledge,
2395 // look for that now.
2396 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2398 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2399 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2400 Linkage = dwarf::GIEL_EXTERNAL;
2401 } else if (Die->findAttribute(dwarf::DW_AT_external))
2402 Linkage = dwarf::GIEL_EXTERNAL;
2404 switch (Die->getTag()) {
2405 case dwarf::DW_TAG_class_type:
2406 case dwarf::DW_TAG_structure_type:
2407 case dwarf::DW_TAG_union_type:
2408 case dwarf::DW_TAG_enumeration_type:
2409 return dwarf::PubIndexEntryDescriptor(
2410 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2411 ? dwarf::GIEL_STATIC
2412 : dwarf::GIEL_EXTERNAL);
2413 case dwarf::DW_TAG_typedef:
2414 case dwarf::DW_TAG_base_type:
2415 case dwarf::DW_TAG_subrange_type:
2416 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2417 case dwarf::DW_TAG_namespace:
2418 return dwarf::GIEK_TYPE;
2419 case dwarf::DW_TAG_subprogram:
2420 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2421 case dwarf::DW_TAG_constant:
2422 case dwarf::DW_TAG_variable:
2423 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2424 case dwarf::DW_TAG_enumerator:
2425 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2426 dwarf::GIEL_STATIC);
2428 return dwarf::GIEK_NONE;
2432 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2434 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2435 const MCSection *PSec =
2436 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2437 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2439 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2440 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2441 for (unsigned i = 0; i != Units.size(); ++i) {
2442 DwarfUnit *TheU = Units[i];
2443 unsigned ID = TheU->getUniqueID();
2445 // Start the dwarf pubnames section.
2446 Asm->OutStreamer.SwitchSection(PSec);
2448 // Emit a label so we can reference the beginning of this pubname section.
2450 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2453 Asm->OutStreamer.AddComment("Length of Public Names Info");
2454 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2455 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2456 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2458 Asm->OutStreamer.EmitLabel(BeginLabel);
2460 Asm->OutStreamer.AddComment("DWARF Version");
2461 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2463 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2464 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2466 Asm->OutStreamer.AddComment("Compilation Unit Length");
2467 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2469 // Emit the pubnames for this compilation unit.
2470 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2471 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2474 const char *Name = GI->getKeyData();
2475 const DIE *Entity = GI->second;
2477 Asm->OutStreamer.AddComment("DIE offset");
2478 Asm->EmitInt32(Entity->getOffset());
2481 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2482 Asm->OutStreamer.AddComment(
2483 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2484 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2485 Asm->EmitInt8(Desc.toBits());
2488 Asm->OutStreamer.AddComment("External Name");
2489 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2492 Asm->OutStreamer.AddComment("End Mark");
2494 Asm->OutStreamer.EmitLabel(EndLabel);
2498 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2499 const MCSection *PSec =
2500 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2501 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2503 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2504 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2505 for (unsigned i = 0; i != Units.size(); ++i) {
2506 DwarfUnit *TheU = Units[i];
2507 unsigned ID = TheU->getUniqueID();
2509 // Start the dwarf pubtypes section.
2510 Asm->OutStreamer.SwitchSection(PSec);
2512 // Emit a label so we can reference the beginning of this pubtype section.
2514 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2517 Asm->OutStreamer.AddComment("Length of Public Types Info");
2518 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2519 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2520 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2522 Asm->OutStreamer.EmitLabel(BeginLabel);
2524 Asm->OutStreamer.AddComment("DWARF Version");
2525 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2527 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2528 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2530 Asm->OutStreamer.AddComment("Compilation Unit Length");
2531 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2533 // Emit the pubtypes.
2534 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2535 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2538 const char *Name = GI->getKeyData();
2539 const DIE *Entity = GI->second;
2541 Asm->OutStreamer.AddComment("DIE offset");
2542 Asm->EmitInt32(Entity->getOffset());
2545 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2546 Asm->OutStreamer.AddComment(
2547 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2548 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2549 Asm->EmitInt8(Desc.toBits());
2552 Asm->OutStreamer.AddComment("External Name");
2554 // Emit the name with a terminating null byte.
2555 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2558 Asm->OutStreamer.AddComment("End Mark");
2560 Asm->OutStreamer.EmitLabel(EndLabel);
2564 // Emit strings into a string section.
2565 void DwarfFile::emitStrings(const MCSection *StrSection,
2566 const MCSection *OffsetSection = NULL,
2567 const MCSymbol *StrSecSym = NULL) {
2569 if (StringPool.empty())
2572 // Start the dwarf str section.
2573 Asm->OutStreamer.SwitchSection(StrSection);
2575 // Get all of the string pool entries and put them in an array by their ID so
2576 // we can sort them.
2578 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2581 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2582 I = StringPool.begin(),
2583 E = StringPool.end();
2585 Entries.push_back(std::make_pair(I->second.second, &*I));
2587 array_pod_sort(Entries.begin(), Entries.end());
2589 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2590 // Emit a label for reference from debug information entries.
2591 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2593 // Emit the string itself with a terminating null byte.
2594 Asm->OutStreamer.EmitBytes(
2595 StringRef(Entries[i].second->getKeyData(),
2596 Entries[i].second->getKeyLength() + 1));
2599 // If we've got an offset section go ahead and emit that now as well.
2600 if (OffsetSection) {
2601 Asm->OutStreamer.SwitchSection(OffsetSection);
2602 unsigned offset = 0;
2603 unsigned size = 4; // FIXME: DWARF64 is 8.
2604 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2605 Asm->OutStreamer.EmitIntValue(offset, size);
2606 offset += Entries[i].second->getKeyLength() + 1;
2611 // Emit addresses into the section given.
2612 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2614 if (AddressPool.empty())
2617 // Start the dwarf addr section.
2618 Asm->OutStreamer.SwitchSection(AddrSection);
2620 // Order the address pool entries by ID
2621 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2623 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2624 E = AddressPool.end();
2626 Entries[I->second] = I->first;
2628 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2629 // Emit an expression for reference from debug information entries.
2630 if (const MCExpr *Expr = Entries[i])
2631 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2633 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2637 // Emit visible names into a debug str section.
2638 void DwarfDebug::emitDebugStr() {
2639 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2640 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2643 // Emit locations into the debug loc section.
2644 void DwarfDebug::emitDebugLoc() {
2645 if (DotDebugLocEntries.empty())
2648 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2649 I = DotDebugLocEntries.begin(),
2650 E = DotDebugLocEntries.end();
2652 DotDebugLocEntry &Entry = *I;
2653 if (I + 1 != DotDebugLocEntries.end())
2657 // Start the dwarf loc section.
2658 Asm->OutStreamer.SwitchSection(
2659 Asm->getObjFileLowering().getDwarfLocSection());
2660 unsigned char Size = Asm->getDataLayout().getPointerSize();
2661 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2663 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2664 I = DotDebugLocEntries.begin(),
2665 E = DotDebugLocEntries.end();
2666 I != E; ++I, ++index) {
2667 DotDebugLocEntry &Entry = *I;
2668 if (Entry.isMerged())
2670 if (Entry.isEmpty()) {
2671 Asm->OutStreamer.EmitIntValue(0, Size);
2672 Asm->OutStreamer.EmitIntValue(0, Size);
2673 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2675 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2676 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2677 DIVariable DV(Entry.getVariable());
2678 Asm->OutStreamer.AddComment("Loc expr size");
2679 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2680 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2681 Asm->EmitLabelDifference(end, begin, 2);
2682 Asm->OutStreamer.EmitLabel(begin);
2683 if (Entry.isInt()) {
2684 DIBasicType BTy(DV.getType());
2685 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2686 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2687 Asm->OutStreamer.AddComment("DW_OP_consts");
2688 Asm->EmitInt8(dwarf::DW_OP_consts);
2689 Asm->EmitSLEB128(Entry.getInt());
2691 Asm->OutStreamer.AddComment("DW_OP_constu");
2692 Asm->EmitInt8(dwarf::DW_OP_constu);
2693 Asm->EmitULEB128(Entry.getInt());
2695 } else if (Entry.isLocation()) {
2696 MachineLocation Loc = Entry.getLoc();
2697 if (!DV.hasComplexAddress())
2699 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2701 // Complex address entry.
2702 unsigned N = DV.getNumAddrElements();
2704 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2705 if (Loc.getOffset()) {
2707 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2708 Asm->OutStreamer.AddComment("DW_OP_deref");
2709 Asm->EmitInt8(dwarf::DW_OP_deref);
2710 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2711 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2712 Asm->EmitSLEB128(DV.getAddrElement(1));
2714 // If first address element is OpPlus then emit
2715 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2716 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2717 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2721 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2724 // Emit remaining complex address elements.
2725 for (; i < N; ++i) {
2726 uint64_t Element = DV.getAddrElement(i);
2727 if (Element == DIBuilder::OpPlus) {
2728 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2729 Asm->EmitULEB128(DV.getAddrElement(++i));
2730 } else if (Element == DIBuilder::OpDeref) {
2732 Asm->EmitInt8(dwarf::DW_OP_deref);
2734 llvm_unreachable("unknown Opcode found in complex address");
2738 // else ... ignore constant fp. There is not any good way to
2739 // to represent them here in dwarf.
2740 Asm->OutStreamer.EmitLabel(end);
2745 struct SymbolCUSorter {
2746 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2747 const MCStreamer &Streamer;
2749 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2750 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2751 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2753 // Symbols with no order assigned should be placed at the end.
2754 // (e.g. section end labels)
2756 IA = (unsigned)(-1);
2758 IB = (unsigned)(-1);
2763 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2764 return (A->getUniqueID() < B->getUniqueID());
2768 const MCSymbol *Start, *End;
2771 // Emit a debug aranges section, containing a CU lookup for any
2772 // address we can tie back to a CU.
2773 void DwarfDebug::emitDebugARanges() {
2774 // Start the dwarf aranges section.
2775 Asm->OutStreamer.SwitchSection(
2776 Asm->getObjFileLowering().getDwarfARangesSection());
2778 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2782 // Build a list of sections used.
2783 std::vector<const MCSection *> Sections;
2784 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2786 const MCSection *Section = it->first;
2787 Sections.push_back(Section);
2790 // Sort the sections into order.
2791 // This is only done to ensure consistent output order across different runs.
2792 std::sort(Sections.begin(), Sections.end(), SectionSort);
2794 // Build a set of address spans, sorted by CU.
2795 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2796 const MCSection *Section = Sections[SecIdx];
2797 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2798 if (List.size() < 2)
2801 // Sort the symbols by offset within the section.
2802 SymbolCUSorter sorter(Asm->OutStreamer);
2803 std::sort(List.begin(), List.end(), sorter);
2805 // If we have no section (e.g. common), just write out
2806 // individual spans for each symbol.
2807 if (Section == NULL) {
2808 for (size_t n = 0; n < List.size(); n++) {
2809 const SymbolCU &Cur = List[n];
2812 Span.Start = Cur.Sym;
2815 Spans[Cur.CU].push_back(Span);
2818 // Build spans between each label.
2819 const MCSymbol *StartSym = List[0].Sym;
2820 for (size_t n = 1; n < List.size(); n++) {
2821 const SymbolCU &Prev = List[n - 1];
2822 const SymbolCU &Cur = List[n];
2824 // Try and build the longest span we can within the same CU.
2825 if (Cur.CU != Prev.CU) {
2827 Span.Start = StartSym;
2829 Spans[Prev.CU].push_back(Span);
2836 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2838 // Build a list of CUs used.
2839 std::vector<DwarfCompileUnit *> CUs;
2840 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2841 DwarfCompileUnit *CU = it->first;
2845 // Sort the CU list (again, to ensure consistent output order).
2846 std::sort(CUs.begin(), CUs.end(), CUSort);
2848 // Emit an arange table for each CU we used.
2849 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2850 DwarfCompileUnit *CU = CUs[CUIdx];
2851 std::vector<ArangeSpan> &List = Spans[CU];
2853 // Emit size of content not including length itself.
2854 unsigned ContentSize =
2855 sizeof(int16_t) + // DWARF ARange version number
2856 sizeof(int32_t) + // Offset of CU in the .debug_info section
2857 sizeof(int8_t) + // Pointer Size (in bytes)
2858 sizeof(int8_t); // Segment Size (in bytes)
2860 unsigned TupleSize = PtrSize * 2;
2862 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2863 unsigned Padding = 0;
2864 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2867 ContentSize += Padding;
2868 ContentSize += (List.size() + 1) * TupleSize;
2870 // For each compile unit, write the list of spans it covers.
2871 Asm->OutStreamer.AddComment("Length of ARange Set");
2872 Asm->EmitInt32(ContentSize);
2873 Asm->OutStreamer.AddComment("DWARF Arange version number");
2874 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2875 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2876 Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
2877 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2878 Asm->EmitInt8(PtrSize);
2879 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2882 for (unsigned n = 0; n < Padding; n++)
2883 Asm->EmitInt8(0xff);
2885 for (unsigned n = 0; n < List.size(); n++) {
2886 const ArangeSpan &Span = List[n];
2887 Asm->EmitLabelReference(Span.Start, PtrSize);
2889 // Calculate the size as being from the span start to it's end.
2891 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2893 // For symbols without an end marker (e.g. common), we
2894 // write a single arange entry containing just that one symbol.
2895 uint64_t Size = SymSize[Span.Start];
2899 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2903 Asm->OutStreamer.AddComment("ARange terminator");
2904 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2905 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2909 // Emit visible names into a debug ranges section.
2910 void DwarfDebug::emitDebugRanges() {
2911 // Start the dwarf ranges section.
2912 Asm->OutStreamer.SwitchSection(
2913 Asm->getObjFileLowering().getDwarfRangesSection());
2915 // Size for our labels.
2916 unsigned char Size = Asm->getDataLayout().getPointerSize();
2918 // Grab the specific ranges for the compile units in the module.
2919 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2922 DwarfCompileUnit *TheCU = I->second;
2924 // Emit a symbol so we can find the beginning of our ranges.
2925 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2927 // Iterate over the misc ranges for the compile units in the module.
2928 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2929 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2930 E = RangeLists.end();
2932 const RangeSpanList &List = *I;
2934 // Emit our symbol so we can find the beginning of the range.
2935 Asm->OutStreamer.EmitLabel(List.getSym());
2937 for (SmallVectorImpl<RangeSpan>::const_iterator
2938 RI = List.getRanges().begin(),
2939 RE = List.getRanges().end();
2941 const RangeSpan &Range = *RI;
2942 const MCSymbol *Begin = Range.getStart();
2943 const MCSymbol *End = Range.getEnd();
2944 assert(Begin && "Range without a begin symbol?");
2945 assert(End && "Range without an end symbol?");
2946 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2947 Asm->OutStreamer.EmitSymbolValue(End, Size);
2950 // And terminate the list with two 0 values.
2951 Asm->OutStreamer.EmitIntValue(0, Size);
2952 Asm->OutStreamer.EmitIntValue(0, Size);
2955 // Now emit a range for the CU itself.
2956 if (DwarfCURanges) {
2957 Asm->OutStreamer.EmitLabel(
2958 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2959 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2960 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2961 RangeSpan Range = Ranges[i];
2962 const MCSymbol *Begin = Range.getStart();
2963 const MCSymbol *End = Range.getEnd();
2964 assert(Begin && "Range without a begin symbol?");
2965 assert(End && "Range without an end symbol?");
2966 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2967 Asm->OutStreamer.EmitSymbolValue(End, Size);
2969 // And terminate the list with two 0 values.
2970 Asm->OutStreamer.EmitIntValue(0, Size);
2971 Asm->OutStreamer.EmitIntValue(0, Size);
2976 // DWARF5 Experimental Separate Dwarf emitters.
2978 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2979 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2980 // DW_AT_ranges_base, DW_AT_addr_base.
2981 // TODO: Implement DW_AT_ranges_base.
2982 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2984 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2985 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2986 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2987 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2988 DwarfInfoSectionSym);
2990 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2991 CU->getNode().getSplitDebugFilename());
2993 // Relocate to the beginning of the addr_base section, else 0 for the
2994 // beginning of the one for this compile unit.
2995 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2996 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2997 DwarfAddrSectionSym);
2999 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3001 // DW_AT_stmt_list is a offset of line number information for this
3002 // compile unit in debug_line section.
3003 // FIXME: Should handle multiple compile units.
3004 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3005 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3007 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3009 if (!CompilationDir.empty())
3010 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3012 addGnuPubAttributes(NewCU, Die);
3014 SkeletonHolder.addUnit(NewCU);
3019 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3020 // compile units that would normally be in debug_info.
3021 void DwarfDebug::emitDebugInfoDWO() {
3022 assert(useSplitDwarf() && "No split dwarf debug info?");
3023 InfoHolder.emitUnits(this,
3024 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3025 DwarfAbbrevDWOSectionSym);
3028 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3029 // abbreviations for the .debug_info.dwo section.
3030 void DwarfDebug::emitDebugAbbrevDWO() {
3031 assert(useSplitDwarf() && "No split dwarf?");
3032 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3035 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3036 // string section and is identical in format to traditional .debug_str
3038 void DwarfDebug::emitDebugStrDWO() {
3039 assert(useSplitDwarf() && "No split dwarf?");
3040 const MCSection *OffSec =
3041 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3042 const MCSymbol *StrSym = DwarfStrSectionSym;
3043 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3047 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3048 DICompositeType CTy) {
3049 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3051 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3052 DwarfTypeUnit *NewTU =
3053 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3056 InfoHolder.addUnit(NewTU);
3058 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3061 DIE *Die = NewTU->createTypeDIE(CTy);
3063 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3064 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3065 dwarf::DW_FORM_data8,
3066 DIEHash().computeDIEODRSignature(*Die));
3067 // FIXME: This won't handle circularly referential structures, as the DIE
3068 // may have references to other DIEs still under construction and missing
3069 // their signature. Hashing should walk through the signatures to their
3070 // referenced type, or possibly walk the precomputed hashes of related types
3072 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3073 NewTU->setTypeSignature(Signature);
3074 NewTU->setType(Die);
3078 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3079 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3082 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);