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 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
777 // into an entity. We're using 0 (or a NULL label) for this. For
778 // split dwarf it's in the skeleton CU so omit it here.
779 if (!useSplitDwarf())
780 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
782 // Define start line table label for each Compile Unit.
783 MCSymbol *LineTableStartSym =
784 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
785 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
786 NewCU->getUniqueID());
788 // Use a single line table if we are using .loc and generating assembly.
790 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
791 (NewCU->getUniqueID() == 0);
793 if (!useSplitDwarf()) {
794 // DW_AT_stmt_list is a offset of line number information for this
795 // compile unit in debug_line section. For split dwarf this is
796 // left in the skeleton CU and so not included.
797 // The line table entries are not always emitted in assembly, so it
798 // is not okay to use line_table_start here.
799 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
800 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
801 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
802 : LineTableStartSym);
803 else if (UseTheFirstCU)
804 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
806 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
807 DwarfLineSectionSym);
809 // If we're using split dwarf the compilation dir is going to be in the
810 // skeleton CU and so we don't need to duplicate it here.
811 if (!CompilationDir.empty())
812 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
814 addGnuPubAttributes(NewCU, Die);
817 if (DIUnit.isOptimized())
818 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
820 StringRef Flags = DIUnit.getFlags();
822 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
824 if (unsigned RVer = DIUnit.getRunTimeVersion())
825 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
826 dwarf::DW_FORM_data1, RVer);
832 useSplitDwarf() ? Asm->getObjFileLowering().getDwarfInfoDWOSection()
833 : Asm->getObjFileLowering().getDwarfInfoSection(),
834 // FIXME: This is subtle (using the info section even when
835 // this CU is in the dwo section) and necessary for the
836 // current arange code - ideally it should iterate
837 // skeleton units, not full units, if it's going to reference skeletons
838 DwarfInfoSectionSym);
840 CUMap.insert(std::make_pair(DIUnit, NewCU));
841 CUDieMap.insert(std::make_pair(Die, NewCU));
845 // Construct subprogram DIE.
846 void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
848 // FIXME: We should only call this routine once, however, during LTO if a
849 // program is defined in multiple CUs we could end up calling it out of
850 // beginModule as we walk the CUs.
852 DwarfCompileUnit *&CURef = SPMap[N];
858 if (!SP.isDefinition())
859 // This is a method declaration which will be handled while constructing
863 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
865 // Expose as a global name.
866 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
869 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
871 DIImportedEntity Module(N);
872 if (!Module.Verify())
874 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
875 constructImportedEntityDIE(TheCU, Module, D);
878 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
879 const MDNode *N, DIE *Context) {
880 DIImportedEntity Module(N);
881 if (!Module.Verify())
883 return constructImportedEntityDIE(TheCU, Module, Context);
886 void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
887 const DIImportedEntity &Module,
889 assert(Module.Verify() &&
890 "Use one of the MDNode * overloads to handle invalid metadata");
891 assert(Context && "Should always have a context for an imported_module");
892 DIE *IMDie = new DIE(Module.getTag());
893 TheCU->insertDIE(Module, IMDie);
895 DIDescriptor Entity = Module.getEntity();
896 if (Entity.isNameSpace())
897 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
898 else if (Entity.isSubprogram())
899 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
900 else if (Entity.isType())
901 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
903 EntityDie = TheCU->getDIE(Entity);
904 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
905 Module.getContext().getDirectory(),
906 TheCU->getUniqueID());
907 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
908 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
909 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
910 StringRef Name = Module.getName();
912 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
913 Context->addChild(IMDie);
916 // Emit all Dwarf sections that should come prior to the content. Create
917 // global DIEs and emit initial debug info sections. This is invoked by
918 // the target AsmPrinter.
919 void DwarfDebug::beginModule() {
920 if (DisableDebugInfoPrinting)
923 const Module *M = MMI->getModule();
925 // If module has named metadata anchors then use them, otherwise scan the
926 // module using debug info finder to collect debug info.
927 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
930 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
932 // Emit initial sections so we can reference labels later.
935 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
936 DICompileUnit CUNode(CU_Nodes->getOperand(i));
937 DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
938 DIArray ImportedEntities = CUNode.getImportedEntities();
939 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
940 ScopesWithImportedEntities.push_back(std::make_pair(
941 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
942 ImportedEntities.getElement(i)));
943 std::sort(ScopesWithImportedEntities.begin(),
944 ScopesWithImportedEntities.end(), less_first());
945 DIArray GVs = CUNode.getGlobalVariables();
946 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
947 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
948 DIArray SPs = CUNode.getSubprograms();
949 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
950 constructSubprogramDIE(CU, SPs.getElement(i));
951 DIArray EnumTypes = CUNode.getEnumTypes();
952 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
953 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
954 DIArray RetainedTypes = CUNode.getRetainedTypes();
955 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
956 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
957 // Emit imported_modules last so that the relevant context is already
959 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
960 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
963 // Tell MMI that we have debug info.
964 MMI->setDebugInfoAvailability(true);
966 // Prime section data.
967 SectionMap[Asm->getObjFileLowering().getTextSection()];
970 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
971 void DwarfDebug::computeInlinedDIEs() {
972 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
973 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
974 AE = InlinedSubprogramDIEs.end();
977 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
979 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
980 AE = AbstractSPDies.end();
982 DIE *ISP = AI->second;
983 if (InlinedSubprogramDIEs.count(ISP))
985 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
989 // Collect info for variables that were optimized out.
990 void DwarfDebug::collectDeadVariables() {
991 const Module *M = MMI->getModule();
993 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
994 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
995 DICompileUnit TheCU(CU_Nodes->getOperand(i));
996 DIArray Subprograms = TheCU.getSubprograms();
997 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
998 DISubprogram SP(Subprograms.getElement(i));
999 if (ProcessedSPNodes.count(SP) != 0)
1001 if (!SP.isSubprogram())
1003 if (!SP.isDefinition())
1005 DIArray Variables = SP.getVariables();
1006 if (Variables.getNumElements() == 0)
1009 // Construct subprogram DIE and add variables DIEs.
1010 DwarfCompileUnit *SPCU =
1011 static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
1012 assert(SPCU && "Unable to find Compile Unit!");
1013 // FIXME: See the comment in constructSubprogramDIE about duplicate
1015 constructSubprogramDIE(SPCU, SP);
1016 DIE *SPDIE = SPCU->getDIE(SP);
1017 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1018 DIVariable DV(Variables.getElement(vi));
1019 if (!DV.isVariable())
1021 DbgVariable NewVar(DV, NULL, this);
1022 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1023 SPDIE->addChild(VariableDIE);
1030 // Type Signature [7.27] and ODR Hash code.
1032 /// \brief Grabs the string in whichever attribute is passed in and returns
1033 /// a reference to it. Returns "" if the attribute doesn't exist.
1034 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1035 DIEValue *V = Die->findAttribute(Attr);
1037 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1038 return S->getString();
1040 return StringRef("");
1043 /// Return true if the current DIE is contained within an anonymous namespace.
1044 static bool isContainedInAnonNamespace(DIE *Die) {
1045 DIE *Parent = Die->getParent();
1048 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1049 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1051 Parent = Parent->getParent();
1057 /// Test if the current CU language is C++ and that we have
1058 /// a named type that is not contained in an anonymous namespace.
1059 static bool shouldAddODRHash(DwarfTypeUnit *CU, DIE *Die) {
1060 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1061 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1062 !isContainedInAnonNamespace(Die);
1065 void DwarfDebug::finalizeModuleInfo() {
1066 // Collect info for variables that were optimized out.
1067 collectDeadVariables();
1069 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1070 computeInlinedDIEs();
1072 // Handle anything that needs to be done on a per-unit basis after
1073 // all other generation.
1074 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
1075 E = getUnits().end();
1077 DwarfUnit *TheU = *I;
1078 // Emit DW_AT_containing_type attribute to connect types with their
1079 // vtable holding type.
1080 TheU->constructContainingTypeDIEs();
1082 // Add CU specific attributes if we need to add any.
1083 if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1084 // If we're splitting the dwarf out now that we've got the entire
1085 // CU then construct a skeleton CU based upon it.
1086 if (useSplitDwarf()) {
1087 // This should be a unique identifier when we want to build .dwp files.
1089 if (GenerateCUHash) {
1091 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1093 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1094 dwarf::DW_FORM_data8, ID);
1095 // Now construct the skeleton CU associated.
1096 DwarfCompileUnit *SkCU =
1097 constructSkeletonCU(static_cast<DwarfCompileUnit *>(TheU));
1098 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1099 dwarf::DW_FORM_data8, ID);
1101 // Attribute if we've emitted a range list for the compile unit, this
1102 // will get constructed for the skeleton CU separately if we have one.
1103 if (DwarfCURanges && TheU->getRanges().size())
1104 addSectionLabel(Asm, TheU, TheU->getUnitDie(), dwarf::DW_AT_ranges,
1105 Asm->GetTempSymbol("cu_ranges", TheU->getUniqueID()),
1106 DwarfDebugRangeSectionSym);
1111 // Compute DIE offsets and sizes.
1112 InfoHolder.computeSizeAndOffsets();
1113 if (useSplitDwarf())
1114 SkeletonHolder.computeSizeAndOffsets();
1117 void DwarfDebug::endSections() {
1118 // Filter labels by section.
1119 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1120 const SymbolCU &SCU = ArangeLabels[n];
1121 if (SCU.Sym->isInSection()) {
1122 // Make a note of this symbol and it's section.
1123 const MCSection *Section = &SCU.Sym->getSection();
1124 if (!Section->getKind().isMetadata())
1125 SectionMap[Section].push_back(SCU);
1127 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1128 // appear in the output. This sucks as we rely on sections to build
1129 // arange spans. We can do it without, but it's icky.
1130 SectionMap[NULL].push_back(SCU);
1134 // Build a list of sections used.
1135 std::vector<const MCSection *> Sections;
1136 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1138 const MCSection *Section = it->first;
1139 Sections.push_back(Section);
1142 // Sort the sections into order.
1143 // This is only done to ensure consistent output order across different runs.
1144 std::sort(Sections.begin(), Sections.end(), SectionSort);
1146 // Add terminating symbols for each section.
1147 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1148 const MCSection *Section = Sections[ID];
1149 MCSymbol *Sym = NULL;
1152 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1153 // if we know the section name up-front. For user-created sections, the
1155 // label may not be valid to use as a label. (section names can use a
1157 // set of characters on some systems)
1158 Sym = Asm->GetTempSymbol("debug_end", ID);
1159 Asm->OutStreamer.SwitchSection(Section);
1160 Asm->OutStreamer.EmitLabel(Sym);
1163 // Insert a final terminator.
1164 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1168 // Emit all Dwarf sections that should come after the content.
1169 void DwarfDebug::endModule() {
1176 // End any existing sections.
1177 // TODO: Does this need to happen?
1180 // Finalize the debug info for the module.
1181 finalizeModuleInfo();
1185 // Emit all the DIEs into a debug info section.
1188 // Corresponding abbreviations into a abbrev section.
1189 emitAbbreviations();
1191 // Emit info into a debug loc section.
1194 // Emit info into a debug aranges section.
1197 // Emit info into a debug ranges section.
1200 if (useSplitDwarf()) {
1203 emitDebugAbbrevDWO();
1204 // Emit DWO addresses.
1205 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1208 // Emit info into the dwarf accelerator table sections.
1209 if (useDwarfAccelTables()) {
1212 emitAccelNamespaces();
1216 // Emit the pubnames and pubtypes sections if requested.
1217 if (HasDwarfPubSections) {
1218 emitDebugPubNames(GenerateGnuPubSections);
1219 emitDebugPubTypes(GenerateGnuPubSections);
1225 // Reset these for the next Module if we have one.
1229 // Find abstract variable, if any, associated with Var.
1230 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1231 DebugLoc ScopeLoc) {
1232 LLVMContext &Ctx = DV->getContext();
1233 // More then one inlined variable corresponds to one abstract variable.
1234 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1235 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1237 return AbsDbgVariable;
1239 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1243 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1244 addScopeVariable(Scope, AbsDbgVariable);
1245 AbstractVariables[Var] = AbsDbgVariable;
1246 return AbsDbgVariable;
1249 // If Var is a current function argument then add it to CurrentFnArguments list.
1250 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1251 if (!LScopes.isCurrentFunctionScope(Scope))
1253 DIVariable DV = Var->getVariable();
1254 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1256 unsigned ArgNo = DV.getArgNumber();
1260 size_t Size = CurrentFnArguments.size();
1262 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1263 // llvm::Function argument size is not good indicator of how many
1264 // arguments does the function have at source level.
1266 CurrentFnArguments.resize(ArgNo * 2);
1267 CurrentFnArguments[ArgNo - 1] = Var;
1271 // Collect variable information from side table maintained by MMI.
1272 void DwarfDebug::collectVariableInfoFromMMITable(
1273 SmallPtrSet<const MDNode *, 16> &Processed) {
1274 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1275 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1278 const MDNode *Var = VI->first;
1281 Processed.insert(Var);
1283 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1285 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1287 // If variable scope is not found then skip this variable.
1291 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1292 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1293 RegVar->setFrameIndex(VP.first);
1294 if (!addCurrentFnArgument(RegVar, Scope))
1295 addScopeVariable(Scope, RegVar);
1297 AbsDbgVariable->setFrameIndex(VP.first);
1301 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1303 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1304 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1305 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1306 MI->getOperand(0).getReg() &&
1307 (MI->getOperand(1).isImm() ||
1308 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1311 // Get .debug_loc entry for the instruction range starting at MI.
1312 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1313 const MCSymbol *FLabel,
1314 const MCSymbol *SLabel,
1315 const MachineInstr *MI) {
1316 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1318 assert(MI->getNumOperands() == 3);
1319 if (MI->getOperand(0).isReg()) {
1320 MachineLocation MLoc;
1321 // If the second operand is an immediate, this is a
1322 // register-indirect address.
1323 if (!MI->getOperand(1).isImm())
1324 MLoc.set(MI->getOperand(0).getReg());
1326 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1327 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1329 if (MI->getOperand(0).isImm())
1330 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1331 if (MI->getOperand(0).isFPImm())
1332 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1333 if (MI->getOperand(0).isCImm())
1334 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1336 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1339 // Find variables for each lexical scope.
1341 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1343 // Grab the variable info that was squirreled away in the MMI side-table.
1344 collectVariableInfoFromMMITable(Processed);
1346 for (SmallVectorImpl<const MDNode *>::const_iterator
1347 UVI = UserVariables.begin(),
1348 UVE = UserVariables.end();
1349 UVI != UVE; ++UVI) {
1350 const MDNode *Var = *UVI;
1351 if (Processed.count(Var))
1354 // History contains relevant DBG_VALUE instructions for Var and instructions
1356 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1357 if (History.empty())
1359 const MachineInstr *MInsn = History.front();
1362 LexicalScope *Scope = NULL;
1363 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1364 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1365 Scope = LScopes.getCurrentFunctionScope();
1366 else if (MDNode *IA = DV.getInlinedAt())
1367 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1369 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1370 // If variable scope is not found then skip this variable.
1374 Processed.insert(DV);
1375 assert(MInsn->isDebugValue() && "History must begin with debug value");
1376 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1377 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1378 if (!addCurrentFnArgument(RegVar, Scope))
1379 addScopeVariable(Scope, RegVar);
1381 AbsVar->setMInsn(MInsn);
1383 // Simplify ranges that are fully coalesced.
1384 if (History.size() <= 1 ||
1385 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1386 RegVar->setMInsn(MInsn);
1390 // Handle multiple DBG_VALUE instructions describing one variable.
1391 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1393 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1394 HI = History.begin(),
1397 const MachineInstr *Begin = *HI;
1398 assert(Begin->isDebugValue() && "Invalid History entry");
1400 // Check if DBG_VALUE is truncating a range.
1401 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1402 !Begin->getOperand(0).getReg())
1405 // Compute the range for a register location.
1406 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1407 const MCSymbol *SLabel = 0;
1410 // If Begin is the last instruction in History then its value is valid
1411 // until the end of the function.
1412 SLabel = FunctionEndSym;
1414 const MachineInstr *End = HI[1];
1415 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1416 << "\t" << *Begin << "\t" << *End << "\n");
1417 if (End->isDebugValue())
1418 SLabel = getLabelBeforeInsn(End);
1420 // End is a normal instruction clobbering the range.
1421 SLabel = getLabelAfterInsn(End);
1422 assert(SLabel && "Forgot label after clobber instruction");
1427 // The value is valid until the next DBG_VALUE or clobber.
1428 DotDebugLocEntries.push_back(
1429 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1431 DotDebugLocEntries.push_back(DotDebugLocEntry());
1434 // Collect info for variables that were optimized out.
1435 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1436 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1437 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1438 DIVariable DV(Variables.getElement(i));
1439 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1441 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1442 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1446 // Return Label preceding the instruction.
1447 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1448 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1449 assert(Label && "Didn't insert label before instruction");
1453 // Return Label immediately following the instruction.
1454 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1455 return LabelsAfterInsn.lookup(MI);
1458 // Process beginning of an instruction.
1459 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1462 // Check if source location changes, but ignore DBG_VALUE locations.
1463 if (!MI->isDebugValue()) {
1464 DebugLoc DL = MI->getDebugLoc();
1465 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1468 if (DL == PrologEndLoc) {
1469 Flags |= DWARF2_FLAG_PROLOGUE_END;
1470 PrologEndLoc = DebugLoc();
1472 if (PrologEndLoc.isUnknown())
1473 Flags |= DWARF2_FLAG_IS_STMT;
1475 if (!DL.isUnknown()) {
1476 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1477 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1479 recordSourceLine(0, 0, 0, 0);
1483 // Insert labels where requested.
1484 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1485 LabelsBeforeInsn.find(MI);
1488 if (I == LabelsBeforeInsn.end())
1491 // Label already assigned.
1496 PrevLabel = MMI->getContext().CreateTempSymbol();
1497 Asm->OutStreamer.EmitLabel(PrevLabel);
1499 I->second = PrevLabel;
1502 // Process end of an instruction.
1503 void DwarfDebug::endInstruction() {
1505 // Don't create a new label after DBG_VALUE instructions.
1506 // They don't generate code.
1507 if (!CurMI->isDebugValue())
1510 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1511 LabelsAfterInsn.find(CurMI);
1515 if (I == LabelsAfterInsn.end())
1518 // Label already assigned.
1522 // We need a label after this instruction.
1524 PrevLabel = MMI->getContext().CreateTempSymbol();
1525 Asm->OutStreamer.EmitLabel(PrevLabel);
1527 I->second = PrevLabel;
1530 // Each LexicalScope has first instruction and last instruction to mark
1531 // beginning and end of a scope respectively. Create an inverse map that list
1532 // scopes starts (and ends) with an instruction. One instruction may start (or
1533 // end) multiple scopes. Ignore scopes that are not reachable.
1534 void DwarfDebug::identifyScopeMarkers() {
1535 SmallVector<LexicalScope *, 4> WorkList;
1536 WorkList.push_back(LScopes.getCurrentFunctionScope());
1537 while (!WorkList.empty()) {
1538 LexicalScope *S = WorkList.pop_back_val();
1540 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1541 if (!Children.empty())
1542 for (SmallVectorImpl<LexicalScope *>::const_iterator
1543 SI = Children.begin(),
1544 SE = Children.end();
1546 WorkList.push_back(*SI);
1548 if (S->isAbstractScope())
1551 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1554 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1557 assert(RI->first && "InsnRange does not have first instruction!");
1558 assert(RI->second && "InsnRange does not have second instruction!");
1559 requestLabelBeforeInsn(RI->first);
1560 requestLabelAfterInsn(RI->second);
1565 // Get MDNode for DebugLoc's scope.
1566 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1567 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1568 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1569 return DL.getScope(Ctx);
1572 // Walk up the scope chain of given debug loc and find line number info
1573 // for the function.
1574 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1575 const MDNode *Scope = getScopeNode(DL, Ctx);
1576 DISubprogram SP = getDISubprogram(Scope);
1577 if (SP.isSubprogram()) {
1578 // Check for number of operands since the compatibility is
1580 if (SP->getNumOperands() > 19)
1581 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1583 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1589 // Gather pre-function debug information. Assumes being called immediately
1590 // after the function entry point has been emitted.
1591 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1594 // If there's no debug info for the function we're not going to do anything.
1595 if (!MMI->hasDebugInfo())
1598 // Grab the lexical scopes for the function, if we don't have any of those
1599 // then we're not going to be able to do anything.
1600 LScopes.initialize(*MF);
1601 if (LScopes.empty())
1604 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1606 // Make sure that each lexical scope will have a begin/end label.
1607 identifyScopeMarkers();
1609 // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
1610 // belongs to so that we add to the correct per-cu line table in the
1612 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1613 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1614 assert(TheCU && "Unable to find compile unit!");
1615 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1616 // Use a single line table if we are using .loc and generating assembly.
1617 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1619 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1621 // Emit a label for the function so that we have a beginning address.
1622 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1623 // Assumes in correct section after the entry point.
1624 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1626 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1627 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1628 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1630 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1632 bool AtBlockEntry = true;
1633 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1635 const MachineInstr *MI = II;
1637 if (MI->isDebugValue()) {
1638 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1640 // Keep track of user variables.
1642 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1644 // Variable is in a register, we need to check for clobbers.
1645 if (isDbgValueInDefinedReg(MI))
1646 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1648 // Check the history of this variable.
1649 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1650 if (History.empty()) {
1651 UserVariables.push_back(Var);
1652 // The first mention of a function argument gets the FunctionBeginSym
1653 // label, so arguments are visible when breaking at function entry.
1655 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1656 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1657 LabelsBeforeInsn[MI] = FunctionBeginSym;
1659 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1660 const MachineInstr *Prev = History.back();
1661 if (Prev->isDebugValue()) {
1662 // Coalesce identical entries at the end of History.
1663 if (History.size() >= 2 &&
1664 Prev->isIdenticalTo(History[History.size() - 2])) {
1665 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1666 << "\t" << *Prev << "\t"
1667 << *History[History.size() - 2] << "\n");
1671 // Terminate old register assignments that don't reach MI;
1672 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1673 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1674 isDbgValueInDefinedReg(Prev)) {
1675 // Previous register assignment needs to terminate at the end of
1677 MachineBasicBlock::const_iterator LastMI =
1678 PrevMBB->getLastNonDebugInstr();
1679 if (LastMI == PrevMBB->end()) {
1680 // Drop DBG_VALUE for empty range.
1681 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1682 << "\t" << *Prev << "\n");
1684 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1685 // Terminate after LastMI.
1686 History.push_back(LastMI);
1690 History.push_back(MI);
1692 // Not a DBG_VALUE instruction.
1694 AtBlockEntry = false;
1696 // First known non-DBG_VALUE and non-frame setup location marks
1697 // the beginning of the function body.
1698 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1699 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1700 PrologEndLoc = MI->getDebugLoc();
1702 // Check if the instruction clobbers any registers with debug vars.
1703 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1704 MOE = MI->operands_end();
1705 MOI != MOE; ++MOI) {
1706 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1708 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1711 const MDNode *Var = LiveUserVar[Reg];
1714 // Reg is now clobbered.
1715 LiveUserVar[Reg] = 0;
1717 // Was MD last defined by a DBG_VALUE referring to Reg?
1718 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1719 if (HistI == DbgValues.end())
1721 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1722 if (History.empty())
1724 const MachineInstr *Prev = History.back();
1725 // Sanity-check: Register assignments are terminated at the end of
1727 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1729 // Is the variable still in Reg?
1730 if (!isDbgValueInDefinedReg(Prev) ||
1731 Prev->getOperand(0).getReg() != Reg)
1733 // Var is clobbered. Make sure the next instruction gets a label.
1734 History.push_back(MI);
1741 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1743 SmallVectorImpl<const MachineInstr *> &History = I->second;
1744 if (History.empty())
1747 // Make sure the final register assignments are terminated.
1748 const MachineInstr *Prev = History.back();
1749 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1750 const MachineBasicBlock *PrevMBB = Prev->getParent();
1751 MachineBasicBlock::const_iterator LastMI =
1752 PrevMBB->getLastNonDebugInstr();
1753 if (LastMI == PrevMBB->end())
1754 // Drop DBG_VALUE for empty range.
1756 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1757 // Terminate after LastMI.
1758 History.push_back(LastMI);
1761 // Request labels for the full history.
1762 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1763 const MachineInstr *MI = History[i];
1764 if (MI->isDebugValue())
1765 requestLabelBeforeInsn(MI);
1767 requestLabelAfterInsn(MI);
1771 PrevInstLoc = DebugLoc();
1772 PrevLabel = FunctionBeginSym;
1774 // Record beginning of function.
1775 if (!PrologEndLoc.isUnknown()) {
1776 DebugLoc FnStartDL =
1777 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1779 FnStartDL.getLine(), FnStartDL.getCol(),
1780 FnStartDL.getScope(MF->getFunction()->getContext()),
1781 // We'd like to list the prologue as "not statements" but GDB behaves
1782 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1783 DWARF2_FLAG_IS_STMT);
1787 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1788 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1789 DIVariable DV = Var->getVariable();
1790 // Variables with positive arg numbers are parameters.
1791 if (unsigned ArgNum = DV.getArgNumber()) {
1792 // Keep all parameters in order at the start of the variable list to ensure
1793 // function types are correct (no out-of-order parameters)
1795 // This could be improved by only doing it for optimized builds (unoptimized
1796 // builds have the right order to begin with), searching from the back (this
1797 // would catch the unoptimized case quickly), or doing a binary search
1798 // rather than linear search.
1799 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1800 while (I != Vars.end()) {
1801 unsigned CurNum = (*I)->getVariable().getArgNumber();
1802 // A local (non-parameter) variable has been found, insert immediately
1806 // A later indexed parameter has been found, insert immediately before it.
1807 if (CurNum > ArgNum)
1811 Vars.insert(I, Var);
1815 Vars.push_back(Var);
1818 // Gather and emit post-function debug information.
1819 void DwarfDebug::endFunction(const MachineFunction *MF) {
1820 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1821 // though the beginFunction may not be called at all.
1822 // We should handle both cases.
1826 assert(CurFn == MF);
1829 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1834 // Define end label for subprogram.
1835 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1836 // Assumes in correct section after the entry point.
1837 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1838 // Set DwarfDwarfCompileUnitID in MCContext to default value.
1839 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1841 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1842 collectVariableInfo(ProcessedVars);
1844 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1845 DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1846 assert(TheCU && "Unable to find compile unit!");
1848 // Construct abstract scopes.
1849 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1850 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1851 LexicalScope *AScope = AList[i];
1852 DISubprogram SP(AScope->getScopeNode());
1853 if (SP.isSubprogram()) {
1854 // Collect info for variables that were optimized out.
1855 DIArray Variables = SP.getVariables();
1856 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1857 DIVariable DV(Variables.getElement(i));
1858 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1860 // Check that DbgVariable for DV wasn't created earlier, when
1861 // findAbstractVariable() was called for inlined instance of DV.
1862 LLVMContext &Ctx = DV->getContext();
1863 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1864 if (AbstractVariables.lookup(CleanDV))
1866 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1867 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1870 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1871 constructScopeDIE(TheCU, AScope);
1874 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1876 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1877 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1880 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1881 E = ScopeVariables.end();
1883 DeleteContainerPointers(I->second);
1884 ScopeVariables.clear();
1885 DeleteContainerPointers(CurrentFnArguments);
1886 UserVariables.clear();
1888 AbstractVariables.clear();
1889 LabelsBeforeInsn.clear();
1890 LabelsAfterInsn.clear();
1895 // Register a source line with debug info. Returns the unique label that was
1896 // emitted and which provides correspondence to the source line list.
1897 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1903 DIDescriptor Scope(S);
1905 if (Scope.isCompileUnit()) {
1906 DICompileUnit CU(S);
1907 Fn = CU.getFilename();
1908 Dir = CU.getDirectory();
1909 } else if (Scope.isFile()) {
1911 Fn = F.getFilename();
1912 Dir = F.getDirectory();
1913 } else if (Scope.isSubprogram()) {
1915 Fn = SP.getFilename();
1916 Dir = SP.getDirectory();
1917 } else if (Scope.isLexicalBlockFile()) {
1918 DILexicalBlockFile DBF(S);
1919 Fn = DBF.getFilename();
1920 Dir = DBF.getDirectory();
1921 } else if (Scope.isLexicalBlock()) {
1922 DILexicalBlock DB(S);
1923 Fn = DB.getFilename();
1924 Dir = DB.getDirectory();
1926 llvm_unreachable("Unexpected scope info");
1928 Src = getOrCreateSourceID(
1929 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1931 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1934 //===----------------------------------------------------------------------===//
1936 //===----------------------------------------------------------------------===//
1938 // Compute the size and offset of a DIE. The offset is relative to start of the
1939 // CU. It returns the offset after laying out the DIE.
1940 unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1941 // Get the children.
1942 const std::vector<DIE *> &Children = Die->getChildren();
1944 // Record the abbreviation.
1945 assignAbbrevNumber(Die->getAbbrev());
1947 // Get the abbreviation for this DIE.
1948 const DIEAbbrev &Abbrev = Die->getAbbrev();
1951 Die->setOffset(Offset);
1953 // Start the size with the size of abbreviation code.
1954 Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
1956 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1957 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
1959 // Size the DIE attribute values.
1960 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1961 // Size attribute value.
1962 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1964 // Size the DIE children if any.
1965 if (!Children.empty()) {
1966 assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1967 "Children flag not set");
1969 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1970 Offset = computeSizeAndOffset(Children[j], Offset);
1972 // End of children marker.
1973 Offset += sizeof(int8_t);
1976 Die->setSize(Offset - Die->getOffset());
1980 // Compute the size and offset for each DIE.
1981 void DwarfFile::computeSizeAndOffsets() {
1982 // Offset from the first CU in the debug info section is 0 initially.
1983 unsigned SecOffset = 0;
1985 // Iterate over each compile unit and set the size and offsets for each
1986 // DIE within each compile unit. All offsets are CU relative.
1987 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
1990 (*I)->setDebugInfoOffset(SecOffset);
1992 // CU-relative offset is reset to 0 here.
1993 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1994 (*I)->getHeaderSize(); // Unit-specific headers
1996 // EndOffset here is CU-relative, after laying out
1997 // all of the CU DIE.
1998 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1999 SecOffset += EndOffset;
2003 // Emit initial Dwarf sections with a label at the start of each one.
2004 void DwarfDebug::emitSectionLabels() {
2005 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2007 // Dwarf sections base addresses.
2008 DwarfInfoSectionSym =
2009 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2010 DwarfAbbrevSectionSym =
2011 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2012 if (useSplitDwarf())
2013 DwarfAbbrevDWOSectionSym = emitSectionSym(
2014 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
2015 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
2017 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2018 emitSectionSym(Asm, MacroInfo);
2020 DwarfLineSectionSym =
2021 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2022 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2023 if (GenerateGnuPubSections) {
2024 DwarfGnuPubNamesSectionSym =
2025 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2026 DwarfGnuPubTypesSectionSym =
2027 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2028 } else if (HasDwarfPubSections) {
2029 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2030 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2033 DwarfStrSectionSym =
2034 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2035 if (useSplitDwarf()) {
2036 DwarfStrDWOSectionSym =
2037 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2038 DwarfAddrSectionSym =
2039 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2041 DwarfDebugRangeSectionSym =
2042 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2044 DwarfDebugLocSectionSym =
2045 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2047 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2048 emitSectionSym(Asm, TLOF.getDataSection());
2051 // Recursively emits a debug information entry.
2052 void DwarfDebug::emitDIE(DIE *Die) {
2053 // Get the abbreviation for this DIE.
2054 const DIEAbbrev &Abbrev = Die->getAbbrev();
2056 // Emit the code (index) for the abbreviation.
2057 if (Asm->isVerbose())
2058 Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
2059 "] 0x" + Twine::utohexstr(Die->getOffset()) +
2060 ":0x" + Twine::utohexstr(Die->getSize()) + " " +
2061 dwarf::TagString(Abbrev.getTag()));
2062 Asm->EmitULEB128(Abbrev.getNumber());
2064 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2065 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
2067 // Emit the DIE attribute values.
2068 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2069 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2070 dwarf::Form Form = AbbrevData[i].getForm();
2071 assert(Form && "Too many attributes for DIE (check abbreviation)");
2073 if (Asm->isVerbose())
2074 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2077 case dwarf::DW_AT_abstract_origin:
2078 case dwarf::DW_AT_type:
2079 case dwarf::DW_AT_friend:
2080 case dwarf::DW_AT_specification:
2081 case dwarf::DW_AT_import:
2082 case dwarf::DW_AT_containing_type: {
2083 DIEEntry *E = cast<DIEEntry>(Values[i]);
2084 DIE *Origin = E->getEntry();
2085 unsigned Addr = Origin->getOffset();
2086 if (Form == dwarf::DW_FORM_ref_addr) {
2087 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2088 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2089 // section. Origin->getOffset() returns the offset from start of the
2091 DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2092 assert(CU && "CUDie should belong to a CU.");
2093 Addr += CU->getDebugInfoOffset();
2094 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2095 Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
2096 DIEEntry::getRefAddrSize(Asm));
2098 Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
2099 CU->getSectionSym(),
2100 DIEEntry::getRefAddrSize(Asm));
2102 // Make sure Origin belong to the same CU.
2103 assert(Die->getUnit() == Origin->getUnit() &&
2104 "The referenced DIE should belong to the same CU in ref4");
2105 Asm->EmitInt32(Addr);
2109 case dwarf::DW_AT_location: {
2110 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2111 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2112 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2114 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2116 Values[i]->EmitValue(Asm, Form);
2120 case dwarf::DW_AT_accessibility: {
2121 if (Asm->isVerbose()) {
2122 DIEInteger *V = cast<DIEInteger>(Values[i]);
2123 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2125 Values[i]->EmitValue(Asm, Form);
2129 // Emit an attribute using the defined form.
2130 Values[i]->EmitValue(Asm, Form);
2135 // Emit the DIE children if any.
2136 if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2137 const std::vector<DIE *> &Children = Die->getChildren();
2139 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2140 emitDIE(Children[j]);
2142 Asm->OutStreamer.AddComment("End Of Children Mark");
2147 // Emit the various dwarf units to the unit section USection with
2148 // the abbreviations going into ASection.
2149 void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
2150 const MCSymbol *ASectionSym) {
2151 for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
2153 DwarfUnit *TheU = *I;
2154 DIE *Die = TheU->getUnitDie();
2155 const MCSection *USection = TheU->getSection();
2156 Asm->OutStreamer.SwitchSection(USection);
2158 // Emit the compile units header.
2159 Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
2161 // Emit size of content not including length itself
2162 Asm->OutStreamer.AddComment("Length of Unit");
2163 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2165 TheU->emitHeader(ASection, ASectionSym);
2168 Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
2172 // Emit the debug info section.
2173 void DwarfDebug::emitDebugInfo() {
2174 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2176 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
2177 DwarfAbbrevSectionSym);
2180 // Emit the abbreviation section.
2181 void DwarfDebug::emitAbbreviations() {
2182 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2184 Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2187 void DwarfFile::emitAbbrevs(const MCSection *Section) {
2188 // Check to see if it is worth the effort.
2189 if (!Abbreviations.empty()) {
2190 // Start the debug abbrev section.
2191 Asm->OutStreamer.SwitchSection(Section);
2193 // For each abbrevation.
2194 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2195 // Get abbreviation data
2196 const DIEAbbrev *Abbrev = Abbreviations[i];
2198 // Emit the abbrevations code (base 1 index.)
2199 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2201 // Emit the abbreviations data.
2205 // Mark end of abbreviations.
2206 Asm->EmitULEB128(0, "EOM(3)");
2210 // Emit the last address of the section and the end of the line matrix.
2211 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2212 // Define last address of section.
2213 Asm->OutStreamer.AddComment("Extended Op");
2216 Asm->OutStreamer.AddComment("Op size");
2217 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2218 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2219 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2221 Asm->OutStreamer.AddComment("Section end label");
2223 Asm->OutStreamer.EmitSymbolValue(
2224 Asm->GetTempSymbol("section_end", SectionEnd),
2225 Asm->getDataLayout().getPointerSize());
2227 // Mark end of matrix.
2228 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2234 // Emit visible names into a hashed accelerator table section.
2235 void DwarfDebug::emitAccelNames() {
2237 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2238 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2239 E = getUnits().end();
2241 DwarfUnit *TheU = *I;
2242 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2243 for (StringMap<std::vector<const DIE *> >::const_iterator
2247 StringRef Name = GI->getKey();
2248 const std::vector<const DIE *> &Entities = GI->second;
2249 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2250 DE = Entities.end();
2252 AT.AddName(Name, *DI);
2256 AT.FinalizeTable(Asm, "Names");
2257 Asm->OutStreamer.SwitchSection(
2258 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2259 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2260 Asm->OutStreamer.EmitLabel(SectionBegin);
2262 // Emit the full data.
2263 AT.Emit(Asm, SectionBegin, &InfoHolder);
2266 // Emit objective C classes and categories into a hashed accelerator table
2268 void DwarfDebug::emitAccelObjC() {
2270 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2271 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2272 E = getUnits().end();
2274 DwarfUnit *TheU = *I;
2275 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2276 for (StringMap<std::vector<const DIE *> >::const_iterator
2280 StringRef Name = GI->getKey();
2281 const std::vector<const DIE *> &Entities = GI->second;
2282 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2283 DE = Entities.end();
2285 AT.AddName(Name, *DI);
2289 AT.FinalizeTable(Asm, "ObjC");
2290 Asm->OutStreamer.SwitchSection(
2291 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2292 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2293 Asm->OutStreamer.EmitLabel(SectionBegin);
2295 // Emit the full data.
2296 AT.Emit(Asm, SectionBegin, &InfoHolder);
2299 // Emit namespace dies into a hashed accelerator table.
2300 void DwarfDebug::emitAccelNamespaces() {
2302 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2303 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2304 E = getUnits().end();
2306 DwarfUnit *TheU = *I;
2307 const StringMap<std::vector<const DIE *> > &Names =
2308 TheU->getAccelNamespace();
2309 for (StringMap<std::vector<const DIE *> >::const_iterator
2313 StringRef Name = GI->getKey();
2314 const std::vector<const DIE *> &Entities = GI->second;
2315 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2316 DE = Entities.end();
2318 AT.AddName(Name, *DI);
2322 AT.FinalizeTable(Asm, "namespac");
2323 Asm->OutStreamer.SwitchSection(
2324 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2325 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2326 Asm->OutStreamer.EmitLabel(SectionBegin);
2328 // Emit the full data.
2329 AT.Emit(Asm, SectionBegin, &InfoHolder);
2332 // Emit type dies into a hashed accelerator table.
2333 void DwarfDebug::emitAccelTypes() {
2334 std::vector<DwarfAccelTable::Atom> Atoms;
2336 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2338 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2340 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2341 DwarfAccelTable AT(Atoms);
2342 for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
2343 E = getUnits().end();
2345 DwarfUnit *TheU = *I;
2346 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2347 TheU->getAccelTypes();
2349 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2353 StringRef Name = GI->getKey();
2354 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2356 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2357 DI = Entities.begin(),
2358 DE = Entities.end();
2360 AT.AddName(Name, DI->first, DI->second);
2364 AT.FinalizeTable(Asm, "types");
2365 Asm->OutStreamer.SwitchSection(
2366 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2367 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2368 Asm->OutStreamer.EmitLabel(SectionBegin);
2370 // Emit the full data.
2371 AT.Emit(Asm, SectionBegin, &InfoHolder);
2374 // Public name handling.
2375 // The format for the various pubnames:
2377 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2378 // for the DIE that is named.
2380 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2381 // into the CU and the index value is computed according to the type of value
2382 // for the DIE that is named.
2384 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2385 // it's the offset within the debug_info/debug_types dwo section, however, the
2386 // reference in the pubname header doesn't change.
2388 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2389 static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
2391 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2393 // We could have a specification DIE that has our most of our knowledge,
2394 // look for that now.
2395 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2397 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2398 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2399 Linkage = dwarf::GIEL_EXTERNAL;
2400 } else if (Die->findAttribute(dwarf::DW_AT_external))
2401 Linkage = dwarf::GIEL_EXTERNAL;
2403 switch (Die->getTag()) {
2404 case dwarf::DW_TAG_class_type:
2405 case dwarf::DW_TAG_structure_type:
2406 case dwarf::DW_TAG_union_type:
2407 case dwarf::DW_TAG_enumeration_type:
2408 return dwarf::PubIndexEntryDescriptor(
2409 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2410 ? dwarf::GIEL_STATIC
2411 : dwarf::GIEL_EXTERNAL);
2412 case dwarf::DW_TAG_typedef:
2413 case dwarf::DW_TAG_base_type:
2414 case dwarf::DW_TAG_subrange_type:
2415 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2416 case dwarf::DW_TAG_namespace:
2417 return dwarf::GIEK_TYPE;
2418 case dwarf::DW_TAG_subprogram:
2419 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2420 case dwarf::DW_TAG_constant:
2421 case dwarf::DW_TAG_variable:
2422 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2423 case dwarf::DW_TAG_enumerator:
2424 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2425 dwarf::GIEL_STATIC);
2427 return dwarf::GIEK_NONE;
2431 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2433 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2434 const MCSection *PSec =
2435 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2436 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2438 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2439 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2440 for (unsigned i = 0; i != Units.size(); ++i) {
2441 DwarfUnit *TheU = Units[i];
2442 unsigned ID = TheU->getUniqueID();
2444 // Start the dwarf pubnames section.
2445 Asm->OutStreamer.SwitchSection(PSec);
2447 // Emit a label so we can reference the beginning of this pubname section.
2449 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2452 Asm->OutStreamer.AddComment("Length of Public Names Info");
2453 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2454 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2455 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2457 Asm->OutStreamer.EmitLabel(BeginLabel);
2459 Asm->OutStreamer.AddComment("DWARF Version");
2460 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2462 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2463 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2465 Asm->OutStreamer.AddComment("Compilation Unit Length");
2466 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2468 // Emit the pubnames for this compilation unit.
2469 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
2470 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2473 const char *Name = GI->getKeyData();
2474 const DIE *Entity = GI->second;
2476 Asm->OutStreamer.AddComment("DIE offset");
2477 Asm->EmitInt32(Entity->getOffset());
2480 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2481 Asm->OutStreamer.AddComment(
2482 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2483 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2484 Asm->EmitInt8(Desc.toBits());
2487 Asm->OutStreamer.AddComment("External Name");
2488 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2491 Asm->OutStreamer.AddComment("End Mark");
2493 Asm->OutStreamer.EmitLabel(EndLabel);
2497 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2498 const MCSection *PSec =
2499 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2500 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2502 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2503 const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
2504 for (unsigned i = 0; i != Units.size(); ++i) {
2505 DwarfUnit *TheU = Units[i];
2506 unsigned ID = TheU->getUniqueID();
2508 // Start the dwarf pubtypes section.
2509 Asm->OutStreamer.SwitchSection(PSec);
2511 // Emit a label so we can reference the beginning of this pubtype section.
2513 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2516 Asm->OutStreamer.AddComment("Length of Public Types Info");
2517 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2518 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2519 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2521 Asm->OutStreamer.EmitLabel(BeginLabel);
2523 Asm->OutStreamer.AddComment("DWARF Version");
2524 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2526 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2527 Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
2529 Asm->OutStreamer.AddComment("Compilation Unit Length");
2530 Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
2532 // Emit the pubtypes.
2533 const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
2534 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2537 const char *Name = GI->getKeyData();
2538 const DIE *Entity = GI->second;
2540 Asm->OutStreamer.AddComment("DIE offset");
2541 Asm->EmitInt32(Entity->getOffset());
2544 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2545 Asm->OutStreamer.AddComment(
2546 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2547 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2548 Asm->EmitInt8(Desc.toBits());
2551 Asm->OutStreamer.AddComment("External Name");
2553 // Emit the name with a terminating null byte.
2554 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2557 Asm->OutStreamer.AddComment("End Mark");
2559 Asm->OutStreamer.EmitLabel(EndLabel);
2563 // Emit strings into a string section.
2564 void DwarfFile::emitStrings(const MCSection *StrSection,
2565 const MCSection *OffsetSection = NULL,
2566 const MCSymbol *StrSecSym = NULL) {
2568 if (StringPool.empty())
2571 // Start the dwarf str section.
2572 Asm->OutStreamer.SwitchSection(StrSection);
2574 // Get all of the string pool entries and put them in an array by their ID so
2575 // we can sort them.
2577 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2580 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2581 I = StringPool.begin(),
2582 E = StringPool.end();
2584 Entries.push_back(std::make_pair(I->second.second, &*I));
2586 array_pod_sort(Entries.begin(), Entries.end());
2588 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2589 // Emit a label for reference from debug information entries.
2590 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2592 // Emit the string itself with a terminating null byte.
2593 Asm->OutStreamer.EmitBytes(
2594 StringRef(Entries[i].second->getKeyData(),
2595 Entries[i].second->getKeyLength() + 1));
2598 // If we've got an offset section go ahead and emit that now as well.
2599 if (OffsetSection) {
2600 Asm->OutStreamer.SwitchSection(OffsetSection);
2601 unsigned offset = 0;
2602 unsigned size = 4; // FIXME: DWARF64 is 8.
2603 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2604 Asm->OutStreamer.EmitIntValue(offset, size);
2605 offset += Entries[i].second->getKeyLength() + 1;
2610 // Emit addresses into the section given.
2611 void DwarfFile::emitAddresses(const MCSection *AddrSection) {
2613 if (AddressPool.empty())
2616 // Start the dwarf addr section.
2617 Asm->OutStreamer.SwitchSection(AddrSection);
2619 // Order the address pool entries by ID
2620 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2622 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2623 E = AddressPool.end();
2625 Entries[I->second] = I->first;
2627 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2628 // Emit an expression for reference from debug information entries.
2629 if (const MCExpr *Expr = Entries[i])
2630 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2632 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2636 // Emit visible names into a debug str section.
2637 void DwarfDebug::emitDebugStr() {
2638 DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2639 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2642 // Emit locations into the debug loc section.
2643 void DwarfDebug::emitDebugLoc() {
2644 if (DotDebugLocEntries.empty())
2647 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2648 I = DotDebugLocEntries.begin(),
2649 E = DotDebugLocEntries.end();
2651 DotDebugLocEntry &Entry = *I;
2652 if (I + 1 != DotDebugLocEntries.end())
2656 // Start the dwarf loc section.
2657 Asm->OutStreamer.SwitchSection(
2658 Asm->getObjFileLowering().getDwarfLocSection());
2659 unsigned char Size = Asm->getDataLayout().getPointerSize();
2660 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2662 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2663 I = DotDebugLocEntries.begin(),
2664 E = DotDebugLocEntries.end();
2665 I != E; ++I, ++index) {
2666 DotDebugLocEntry &Entry = *I;
2667 if (Entry.isMerged())
2669 if (Entry.isEmpty()) {
2670 Asm->OutStreamer.EmitIntValue(0, Size);
2671 Asm->OutStreamer.EmitIntValue(0, Size);
2672 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2674 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2675 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2676 DIVariable DV(Entry.getVariable());
2677 Asm->OutStreamer.AddComment("Loc expr size");
2678 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2679 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2680 Asm->EmitLabelDifference(end, begin, 2);
2681 Asm->OutStreamer.EmitLabel(begin);
2682 if (Entry.isInt()) {
2683 DIBasicType BTy(DV.getType());
2684 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2685 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2686 Asm->OutStreamer.AddComment("DW_OP_consts");
2687 Asm->EmitInt8(dwarf::DW_OP_consts);
2688 Asm->EmitSLEB128(Entry.getInt());
2690 Asm->OutStreamer.AddComment("DW_OP_constu");
2691 Asm->EmitInt8(dwarf::DW_OP_constu);
2692 Asm->EmitULEB128(Entry.getInt());
2694 } else if (Entry.isLocation()) {
2695 MachineLocation Loc = Entry.getLoc();
2696 if (!DV.hasComplexAddress())
2698 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2700 // Complex address entry.
2701 unsigned N = DV.getNumAddrElements();
2703 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2704 if (Loc.getOffset()) {
2706 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2707 Asm->OutStreamer.AddComment("DW_OP_deref");
2708 Asm->EmitInt8(dwarf::DW_OP_deref);
2709 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2710 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2711 Asm->EmitSLEB128(DV.getAddrElement(1));
2713 // If first address element is OpPlus then emit
2714 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2715 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2716 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2720 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2723 // Emit remaining complex address elements.
2724 for (; i < N; ++i) {
2725 uint64_t Element = DV.getAddrElement(i);
2726 if (Element == DIBuilder::OpPlus) {
2727 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2728 Asm->EmitULEB128(DV.getAddrElement(++i));
2729 } else if (Element == DIBuilder::OpDeref) {
2731 Asm->EmitInt8(dwarf::DW_OP_deref);
2733 llvm_unreachable("unknown Opcode found in complex address");
2737 // else ... ignore constant fp. There is not any good way to
2738 // to represent them here in dwarf.
2739 Asm->OutStreamer.EmitLabel(end);
2744 struct SymbolCUSorter {
2745 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2746 const MCStreamer &Streamer;
2748 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2749 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2750 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2752 // Symbols with no order assigned should be placed at the end.
2753 // (e.g. section end labels)
2755 IA = (unsigned)(-1);
2757 IB = (unsigned)(-1);
2762 static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
2763 return (A->getUniqueID() < B->getUniqueID());
2767 const MCSymbol *Start, *End;
2770 // Emit a debug aranges section, containing a CU lookup for any
2771 // address we can tie back to a CU.
2772 void DwarfDebug::emitDebugARanges() {
2773 // Start the dwarf aranges section.
2774 Asm->OutStreamer.SwitchSection(
2775 Asm->getObjFileLowering().getDwarfARangesSection());
2777 typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
2781 // Build a list of sections used.
2782 std::vector<const MCSection *> Sections;
2783 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2785 const MCSection *Section = it->first;
2786 Sections.push_back(Section);
2789 // Sort the sections into order.
2790 // This is only done to ensure consistent output order across different runs.
2791 std::sort(Sections.begin(), Sections.end(), SectionSort);
2793 // Build a set of address spans, sorted by CU.
2794 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2795 const MCSection *Section = Sections[SecIdx];
2796 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2797 if (List.size() < 2)
2800 // Sort the symbols by offset within the section.
2801 SymbolCUSorter sorter(Asm->OutStreamer);
2802 std::sort(List.begin(), List.end(), sorter);
2804 // If we have no section (e.g. common), just write out
2805 // individual spans for each symbol.
2806 if (Section == NULL) {
2807 for (size_t n = 0; n < List.size(); n++) {
2808 const SymbolCU &Cur = List[n];
2811 Span.Start = Cur.Sym;
2814 Spans[Cur.CU].push_back(Span);
2817 // Build spans between each label.
2818 const MCSymbol *StartSym = List[0].Sym;
2819 for (size_t n = 1; n < List.size(); n++) {
2820 const SymbolCU &Prev = List[n - 1];
2821 const SymbolCU &Cur = List[n];
2823 // Try and build the longest span we can within the same CU.
2824 if (Cur.CU != Prev.CU) {
2826 Span.Start = StartSym;
2828 Spans[Prev.CU].push_back(Span);
2835 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2837 // Build a list of CUs used.
2838 std::vector<DwarfCompileUnit *> CUs;
2839 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2840 DwarfCompileUnit *CU = it->first;
2844 // Sort the CU list (again, to ensure consistent output order).
2845 std::sort(CUs.begin(), CUs.end(), CUSort);
2847 // Emit an arange table for each CU we used.
2848 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2849 DwarfCompileUnit *CU = CUs[CUIdx];
2850 std::vector<ArangeSpan> &List = Spans[CU];
2852 // Emit size of content not including length itself.
2853 unsigned ContentSize =
2854 sizeof(int16_t) + // DWARF ARange version number
2855 sizeof(int32_t) + // Offset of CU in the .debug_info section
2856 sizeof(int8_t) + // Pointer Size (in bytes)
2857 sizeof(int8_t); // Segment Size (in bytes)
2859 unsigned TupleSize = PtrSize * 2;
2861 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2862 unsigned Padding = 0;
2863 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2866 ContentSize += Padding;
2867 ContentSize += (List.size() + 1) * TupleSize;
2869 // For each compile unit, write the list of spans it covers.
2870 Asm->OutStreamer.AddComment("Length of ARange Set");
2871 Asm->EmitInt32(ContentSize);
2872 Asm->OutStreamer.AddComment("DWARF Arange version number");
2873 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2874 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2875 Asm->EmitSectionOffset(CU->getLabelBegin(), CU->getSectionSym());
2876 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2877 Asm->EmitInt8(PtrSize);
2878 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2881 for (unsigned n = 0; n < Padding; n++)
2882 Asm->EmitInt8(0xff);
2884 for (unsigned n = 0; n < List.size(); n++) {
2885 const ArangeSpan &Span = List[n];
2886 Asm->EmitLabelReference(Span.Start, PtrSize);
2888 // Calculate the size as being from the span start to it's end.
2890 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2892 // For symbols without an end marker (e.g. common), we
2893 // write a single arange entry containing just that one symbol.
2894 uint64_t Size = SymSize[Span.Start];
2898 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2902 Asm->OutStreamer.AddComment("ARange terminator");
2903 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2904 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2908 // Emit visible names into a debug ranges section.
2909 void DwarfDebug::emitDebugRanges() {
2910 // Start the dwarf ranges section.
2911 Asm->OutStreamer.SwitchSection(
2912 Asm->getObjFileLowering().getDwarfRangesSection());
2914 // Size for our labels.
2915 unsigned char Size = Asm->getDataLayout().getPointerSize();
2917 // Grab the specific ranges for the compile units in the module.
2918 for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
2921 DwarfCompileUnit *TheCU = I->second;
2923 // Emit a symbol so we can find the beginning of our ranges.
2924 Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
2926 // Iterate over the misc ranges for the compile units in the module.
2927 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2928 for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
2929 E = RangeLists.end();
2931 const RangeSpanList &List = *I;
2933 // Emit our symbol so we can find the beginning of the range.
2934 Asm->OutStreamer.EmitLabel(List.getSym());
2936 for (SmallVectorImpl<RangeSpan>::const_iterator
2937 RI = List.getRanges().begin(),
2938 RE = List.getRanges().end();
2940 const RangeSpan &Range = *RI;
2941 const MCSymbol *Begin = Range.getStart();
2942 const MCSymbol *End = Range.getEnd();
2943 assert(Begin && "Range without a begin symbol?");
2944 assert(End && "Range without an end symbol?");
2945 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2946 Asm->OutStreamer.EmitSymbolValue(End, Size);
2949 // And terminate the list with two 0 values.
2950 Asm->OutStreamer.EmitIntValue(0, Size);
2951 Asm->OutStreamer.EmitIntValue(0, Size);
2954 // Now emit a range for the CU itself.
2955 if (DwarfCURanges) {
2956 Asm->OutStreamer.EmitLabel(
2957 Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
2958 const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
2959 for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
2960 RangeSpan Range = Ranges[i];
2961 const MCSymbol *Begin = Range.getStart();
2962 const MCSymbol *End = Range.getEnd();
2963 assert(Begin && "Range without a begin symbol?");
2964 assert(End && "Range without an end symbol?");
2965 Asm->OutStreamer.EmitSymbolValue(Begin, Size);
2966 Asm->OutStreamer.EmitSymbolValue(End, Size);
2968 // And terminate the list with two 0 values.
2969 Asm->OutStreamer.EmitIntValue(0, Size);
2970 Asm->OutStreamer.EmitIntValue(0, Size);
2975 // DWARF5 Experimental Separate Dwarf emitters.
2977 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2978 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2979 // DW_AT_ranges_base, DW_AT_addr_base.
2980 // TODO: Implement DW_AT_ranges_base.
2981 DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
2983 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2984 DwarfCompileUnit *NewCU = new DwarfCompileUnit(
2985 CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
2986 NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
2987 DwarfInfoSectionSym);
2989 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2990 CU->getNode().getSplitDebugFilename());
2992 // Relocate to the beginning of the addr_base section, else 0 for the
2993 // beginning of the one for this compile unit.
2994 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2995 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2996 DwarfAddrSectionSym);
2998 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3000 // Attribute if we've emitted a range list for the compile unit, this
3001 // will get constructed for the skeleton CU separately if we have one.
3002 if (DwarfCURanges && CU->getRanges().size())
3003 addSectionLabel(Asm, NewCU, Die, dwarf::DW_AT_ranges,
3004 Asm->GetTempSymbol("cu_ranges", CU->getUniqueID()),
3005 DwarfDebugRangeSectionSym);
3007 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
3009 // DW_AT_stmt_list is a offset of line number information for this
3010 // compile unit in debug_line section.
3011 // FIXME: Should handle multiple compile units.
3012 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3013 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
3015 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3017 if (!CompilationDir.empty())
3018 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3020 addGnuPubAttributes(NewCU, Die);
3022 SkeletonHolder.addUnit(NewCU);
3027 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3028 // compile units that would normally be in debug_info.
3029 void DwarfDebug::emitDebugInfoDWO() {
3030 assert(useSplitDwarf() && "No split dwarf debug info?");
3031 InfoHolder.emitUnits(this,
3032 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3033 DwarfAbbrevDWOSectionSym);
3036 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3037 // abbreviations for the .debug_info.dwo section.
3038 void DwarfDebug::emitDebugAbbrevDWO() {
3039 assert(useSplitDwarf() && "No split dwarf?");
3040 InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
3043 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3044 // string section and is identical in format to traditional .debug_str
3046 void DwarfDebug::emitDebugStrDWO() {
3047 assert(useSplitDwarf() && "No split dwarf?");
3048 const MCSection *OffSec =
3049 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3050 const MCSymbol *StrSym = DwarfStrSectionSym;
3051 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3055 void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
3056 DICompositeType CTy) {
3057 const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
3059 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3060 DwarfTypeUnit *NewTU =
3061 new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
3064 InfoHolder.addUnit(NewTU);
3066 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3069 DIE *Die = NewTU->createTypeDIE(CTy);
3071 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3072 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3073 dwarf::DW_FORM_data8,
3074 DIEHash().computeDIEODRSignature(*Die));
3075 // FIXME: This won't handle circularly referential structures, as the DIE
3076 // may have references to other DIEs still under construction and missing
3077 // their signature. Hashing should walk through the signatures to their
3078 // referenced type, or possibly walk the precomputed hashes of related types
3080 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3081 NewTU->setTypeSignature(Signature);
3082 NewTU->setType(Die);
3086 ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
3087 : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
3090 CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);