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 prototype dwarf 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."),
112 static const char *const DWARFGroupName = "DWARF Emission";
113 static const char *const DbgTimerName = "DWARF Debug Writer";
115 //===----------------------------------------------------------------------===//
117 // Configuration values for initial hash set sizes (log2).
119 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
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),
186 AbbreviationsSet(InitAbbreviationsSetSize),
187 SourceIdMap(DIEValueAllocator), PrevLabel(NULL), GlobalCUIndexCount(0),
188 GlobalRangeCount(0), InfoHolder(A, &AbbreviationsSet, Abbreviations,
189 "info_string", DIEValueAllocator),
190 SkeletonAbbrevSet(InitAbbreviationsSetSize),
191 SkeletonHolder(A, &SkeletonAbbrevSet, SkeletonAbbrevs, "skel_string",
194 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
195 DwarfStrSectionSym = TextSectionSym = 0;
196 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
197 DwarfAddrSectionSym = 0;
198 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
199 FunctionBeginSym = FunctionEndSym = 0;
200 CurFn = 0; CurMI = 0;
202 // Turn on accelerator tables for Darwin by default, pubnames by
203 // default for non-Darwin, and handle split dwarf.
204 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
206 if (DwarfAccelTables == Default)
207 HasDwarfAccelTables = IsDarwin;
209 HasDwarfAccelTables = DwarfAccelTables == Enable;
211 if (SplitDwarf == Default)
212 HasSplitDwarf = false;
214 HasSplitDwarf = SplitDwarf == Enable;
216 if (DwarfPubSections == Default)
217 HasDwarfPubSections = !IsDarwin;
219 HasDwarfPubSections = DwarfPubSections == Enable;
221 DwarfVersion = DwarfVersionNumber
223 : getDwarfVersionFromModule(MMI->getModule());
226 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
231 // Switch to the specified MCSection and emit an assembler
232 // temporary label to it if SymbolStem is specified.
233 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
234 const char *SymbolStem = 0) {
235 Asm->OutStreamer.SwitchSection(Section);
239 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
240 Asm->OutStreamer.EmitLabel(TmpSym);
244 DwarfUnits::~DwarfUnits() {
245 for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
250 MCSymbol *DwarfUnits::getStringPoolSym() {
251 return Asm->GetTempSymbol(StringPref);
254 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
255 std::pair<MCSymbol *, unsigned> &Entry =
256 StringPool.GetOrCreateValue(Str).getValue();
260 Entry.second = NextStringPoolNumber++;
261 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
264 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
265 std::pair<MCSymbol *, unsigned> &Entry =
266 StringPool.GetOrCreateValue(Str).getValue();
270 Entry.second = NextStringPoolNumber++;
271 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
275 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
276 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
279 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
280 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
281 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
283 ++NextAddrPoolNumber;
284 return P.first->second;
287 // Define a unique number for the abbreviation.
289 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
290 // Check the set for priors.
291 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
293 // If it's newly added.
294 if (InSet == &Abbrev) {
295 // Add to abbreviation list.
296 Abbreviations.push_back(&Abbrev);
298 // Assign the vector position + 1 as its number.
299 Abbrev.setNumber(Abbreviations.size());
301 // Assign existing abbreviation number.
302 Abbrev.setNumber(InSet->getNumber());
306 static bool isObjCClass(StringRef Name) {
307 return Name.startswith("+") || Name.startswith("-");
310 static bool hasObjCCategory(StringRef Name) {
311 if (!isObjCClass(Name))
314 return Name.find(") ") != StringRef::npos;
317 static void getObjCClassCategory(StringRef In, StringRef &Class,
318 StringRef &Category) {
319 if (!hasObjCCategory(In)) {
320 Class = In.slice(In.find('[') + 1, In.find(' '));
325 Class = In.slice(In.find('[') + 1, In.find('('));
326 Category = In.slice(In.find('[') + 1, In.find(' '));
330 static StringRef getObjCMethodName(StringRef In) {
331 return In.slice(In.find(' ') + 1, In.find(']'));
334 // Helper for sorting sections into a stable output order.
335 static bool SectionSort(const MCSection *A, const MCSection *B) {
336 std::string LA = (A ? A->getLabelBeginName() : "");
337 std::string LB = (B ? B->getLabelBeginName() : "");
341 // Add the various names to the Dwarf accelerator table names.
342 // TODO: Determine whether or not we should add names for programs
343 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
344 // is only slightly different than the lookup of non-standard ObjC names.
345 static void addSubprogramNames(Unit *TheU, DISubprogram SP, DIE *Die) {
346 if (!SP.isDefinition())
348 TheU->addAccelName(SP.getName(), Die);
350 // If the linkage name is different than the name, go ahead and output
351 // that as well into the name table.
352 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
353 TheU->addAccelName(SP.getLinkageName(), Die);
355 // If this is an Objective-C selector name add it to the ObjC accelerator
357 if (isObjCClass(SP.getName())) {
358 StringRef Class, Category;
359 getObjCClassCategory(SP.getName(), Class, Category);
360 TheU->addAccelObjC(Class, Die);
362 TheU->addAccelObjC(Category, Die);
363 // Also add the base method name to the name table.
364 TheU->addAccelName(getObjCMethodName(SP.getName()), Die);
368 /// isSubprogramContext - Return true if Context is either a subprogram
369 /// or another context nested inside a subprogram.
370 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
373 DIDescriptor D(Context);
374 if (D.isSubprogram())
377 return isSubprogramContext(resolve(DIType(Context).getContext()));
381 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
382 // and DW_AT_high_pc attributes. If there are global variables in this
383 // scope then create and insert DIEs for these variables.
384 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DISubprogram SP) {
385 DIE *SPDie = SPCU->getDIE(SP);
387 assert(SPDie && "Unable to find subprogram DIE!");
389 // If we're updating an abstract DIE, then we will be adding the children and
390 // object pointer later on. But what we don't want to do is process the
391 // concrete DIE twice.
392 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
393 // Pick up abstract subprogram DIE.
395 SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getUnitDie());
396 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
398 DISubprogram SPDecl = SP.getFunctionDeclaration();
399 if (!SPDecl.isSubprogram()) {
400 // There is not any need to generate specification DIE for a function
401 // defined at compile unit level. If a function is defined inside another
402 // function then gdb prefers the definition at top level and but does not
403 // expect specification DIE in parent function. So avoid creating
404 // specification DIE for a function defined inside a function.
405 DIScope SPContext = resolve(SP.getContext());
406 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
407 !SPContext.isFile() && !isSubprogramContext(SPContext)) {
408 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
411 DICompositeType SPTy = SP.getType();
412 DIArray Args = SPTy.getTypeArray();
413 uint16_t SPTag = SPTy.getTag();
414 if (SPTag == dwarf::DW_TAG_subroutine_type)
415 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
417 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
418 DIType ATy(Args.getElement(i));
419 SPCU->addType(Arg, ATy);
420 if (ATy.isArtificial())
421 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
422 if (ATy.isObjectPointer())
423 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
425 DIE *SPDeclDie = SPDie;
426 SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
427 *SPCU->getUnitDie());
428 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
433 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
434 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
436 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
437 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
438 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
440 // Add name to the name table, we do this here because we're guaranteed
441 // to have concrete versions of our DW_TAG_subprogram nodes.
442 addSubprogramNames(SPCU, SP, SPDie);
447 /// Check whether we should create a DIE for the given Scope, return true
448 /// if we don't create a DIE (the corresponding DIE is null).
449 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
450 if (Scope->isAbstractScope())
453 // We don't create a DIE if there is no Range.
454 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
458 if (Ranges.size() > 1)
461 // We don't create a DIE if we have a single Range and the end label
463 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
464 MCSymbol *End = getLabelAfterInsn(RI->second);
468 void DwarfDebug::addScopeRangeList(CompileUnit *TheCU, DIE *ScopeDIE,
469 const SmallVectorImpl<InsnRange> &Range) {
470 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
471 // emitting it appropriately.
472 TheCU->addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges,
473 Asm->GetTempSymbol("debug_ranges", GlobalRangeCount));
474 RangeSpanList List(GlobalRangeCount++);
475 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
478 RangeSpan Span(getLabelBeforeInsn(RI->first),
479 getLabelAfterInsn(RI->second));
480 List.addRange(llvm_move(Span));
483 // Add the range list to the set of ranges to be emitted.
484 TheCU->addRangeList(llvm_move(List));
487 // Construct new DW_TAG_lexical_block for this scope and attach
488 // DW_AT_low_pc/DW_AT_high_pc labels.
489 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
490 LexicalScope *Scope) {
491 if (isLexicalScopeDIENull(Scope))
494 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
495 if (Scope->isAbstractScope())
498 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
500 // If we have multiple ranges, emit them into the range section.
501 if (ScopeRanges.size() > 1) {
502 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
506 // Construct the address range for this DIE.
507 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
508 MCSymbol *Start = getLabelBeforeInsn(RI->first);
509 MCSymbol *End = getLabelAfterInsn(RI->second);
510 assert(End && "End label should not be null!");
512 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
513 assert(End->isDefined() && "Invalid end label for an inlined scope!");
515 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
516 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
521 // This scope represents inlined body of a function. Construct DIE to
522 // represent this concrete inlined copy of the function.
523 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
524 LexicalScope *Scope) {
525 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
526 assert(!ScopeRanges.empty() &&
527 "LexicalScope does not have instruction markers!");
529 if (!Scope->getScopeNode())
531 DIScope DS(Scope->getScopeNode());
532 DISubprogram InlinedSP = getDISubprogram(DS);
533 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
535 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
539 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
540 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
542 // If we have multiple ranges, emit them into the range section.
543 if (ScopeRanges.size() > 1)
544 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
546 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
547 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
548 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
550 if (StartLabel == 0 || EndLabel == 0)
551 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
553 assert(StartLabel->isDefined() &&
554 "Invalid starting label for an inlined scope!");
555 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
557 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
558 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
561 InlinedSubprogramDIEs.insert(OriginDIE);
563 // Add the call site information to the DIE.
564 DILocation DL(Scope->getInlinedAt());
565 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
566 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
567 TheCU->getUniqueID()));
568 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
570 // Add name to the name table, we do this here because we're guaranteed
571 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
572 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
577 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
578 SmallVectorImpl<DIE *> &Children) {
579 DIE *ObjectPointer = NULL;
581 // Collect arguments for current function.
582 if (LScopes.isCurrentFunctionScope(Scope))
583 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
584 if (DbgVariable *ArgDV = CurrentFnArguments[i])
586 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
587 Children.push_back(Arg);
588 if (ArgDV->isObjectPointer())
592 // Collect lexical scope children first.
593 const SmallVectorImpl<DbgVariable *> &Variables =
594 ScopeVariables.lookup(Scope);
595 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
596 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
597 Scope->isAbstractScope())) {
598 Children.push_back(Variable);
599 if (Variables[i]->isObjectPointer())
600 ObjectPointer = Variable;
602 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
603 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
604 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
605 Children.push_back(Nested);
606 return ObjectPointer;
609 // Construct a DIE for this scope.
610 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
611 if (!Scope || !Scope->getScopeNode())
614 DIScope DS(Scope->getScopeNode());
616 SmallVector<DIE *, 8> Children;
617 DIE *ObjectPointer = NULL;
618 bool ChildrenCreated = false;
620 // We try to create the scope DIE first, then the children DIEs. This will
621 // avoid creating un-used children then removing them later when we find out
622 // the scope DIE is null.
623 DIE *ScopeDIE = NULL;
624 if (Scope->getInlinedAt())
625 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
626 else if (DS.isSubprogram()) {
627 ProcessedSPNodes.insert(DS);
628 if (Scope->isAbstractScope()) {
629 ScopeDIE = TheCU->getDIE(DS);
630 // Note down abstract DIE.
632 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
634 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
636 // Early exit when we know the scope DIE is going to be null.
637 if (isLexicalScopeDIENull(Scope))
640 // We create children here when we know the scope DIE is not going to be
641 // null and the children will be added to the scope DIE.
642 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
643 ChildrenCreated = true;
645 // There is no need to emit empty lexical block DIE.
646 std::pair<ImportedEntityMap::const_iterator,
647 ImportedEntityMap::const_iterator> Range =
649 ScopesWithImportedEntities.begin(),
650 ScopesWithImportedEntities.end(),
651 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
653 if (Children.empty() && Range.first == Range.second)
655 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
656 assert(ScopeDIE && "Scope DIE should not be null.");
657 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
659 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
663 assert(Children.empty() &&
664 "We create children only when the scope DIE is not null.");
667 if (!ChildrenCreated)
668 // We create children when the scope DIE is not null.
669 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
672 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
675 ScopeDIE->addChild(*I);
677 if (DS.isSubprogram() && ObjectPointer != NULL)
678 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
683 // Look up the source id with the given directory and source file names.
684 // If none currently exists, create a new id and insert it in the
685 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
687 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
689 // If we use .loc in assembly, we can't separate .file entries according to
690 // compile units. Thus all files will belong to the default compile unit.
692 // FIXME: add a better feature test than hasRawTextSupport. Even better,
693 // extend .file to support this.
694 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
697 // If FE did not provide a file name, then assume stdin.
698 if (FileName.empty())
699 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
701 // TODO: this might not belong here. See if we can factor this better.
702 if (DirName == CompilationDir)
705 // FileIDCUMap stores the current ID for the given compile unit.
706 unsigned SrcId = FileIDCUMap[CUID] + 1;
708 // We look up the CUID/file/dir by concatenating them with a zero byte.
709 SmallString<128> NamePair;
710 NamePair += utostr(CUID);
713 NamePair += '\0'; // Zero bytes are not allowed in paths.
714 NamePair += FileName;
716 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
717 if (Ent.getValue() != SrcId)
718 return Ent.getValue();
720 FileIDCUMap[CUID] = SrcId;
721 // Print out a .file directive to specify files for .loc directives.
722 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
727 // Create new CompileUnit for the given metadata node with tag
728 // DW_TAG_compile_unit.
729 CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
730 StringRef FN = DIUnit.getFilename();
731 CompilationDir = DIUnit.getDirectory();
733 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
734 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++, Die, DIUnit, Asm,
737 FileIDCUMap[NewCU->getUniqueID()] = 0;
738 // Call this to emit a .file directive if it wasn't emitted for the source
739 // file this CU comes from yet.
740 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
742 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
743 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
744 DIUnit.getLanguage());
745 NewCU->addString(Die, dwarf::DW_AT_name, FN);
747 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
748 // into an entity. We're using 0 (or a NULL label) for this. For
749 // split dwarf it's in the skeleton CU so omit it here.
750 if (!useSplitDwarf())
751 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
753 // Define start line table label for each Compile Unit.
754 MCSymbol *LineTableStartSym =
755 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
756 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
757 NewCU->getUniqueID());
759 // Use a single line table if we are using .loc and generating assembly.
761 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
762 (NewCU->getUniqueID() == 0);
764 if (!useSplitDwarf()) {
765 // DW_AT_stmt_list is a offset of line number information for this
766 // compile unit in debug_line section. For split dwarf this is
767 // left in the skeleton CU and so not included.
768 // The line table entries are not always emitted in assembly, so it
769 // is not okay to use line_table_start here.
770 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
771 NewCU->addSectionLabel(
772 Die, dwarf::DW_AT_stmt_list,
773 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
774 : LineTableStartSym);
775 else if (UseTheFirstCU)
776 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
778 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list,
779 LineTableStartSym, DwarfLineSectionSym);
781 // If we're using split dwarf the compilation dir is going to be in the
782 // skeleton CU and so we don't need to duplicate it here.
783 if (!CompilationDir.empty())
784 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
786 // Flags to let the linker know we have emitted new style pubnames. Only
787 // emit it here if we don't have a skeleton CU for split dwarf.
788 if (GenerateGnuPubSections) {
789 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
790 NewCU->addSectionLabel(
791 Die, dwarf::DW_AT_GNU_pubnames,
792 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
794 NewCU->addSectionDelta(
795 Die, dwarf::DW_AT_GNU_pubnames,
796 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
797 DwarfGnuPubNamesSectionSym);
799 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
800 NewCU->addSectionLabel(
801 Die, dwarf::DW_AT_GNU_pubtypes,
802 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
804 NewCU->addSectionDelta(
805 Die, dwarf::DW_AT_GNU_pubtypes,
806 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
807 DwarfGnuPubTypesSectionSym);
811 if (DIUnit.isOptimized())
812 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
814 StringRef Flags = DIUnit.getFlags();
816 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
818 if (unsigned RVer = DIUnit.getRunTimeVersion())
819 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
820 dwarf::DW_FORM_data1, RVer);
825 InfoHolder.addUnit(NewCU);
827 CUMap.insert(std::make_pair(DIUnit, NewCU));
828 CUDieMap.insert(std::make_pair(Die, NewCU));
832 // Construct subprogram DIE.
833 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
834 // FIXME: We should only call this routine once, however, during LTO if a
835 // program is defined in multiple CUs we could end up calling it out of
836 // beginModule as we walk the CUs.
838 CompileUnit *&CURef = SPMap[N];
844 if (!SP.isDefinition())
845 // This is a method declaration which will be handled while constructing
849 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
851 // Expose as a global name.
852 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
855 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
857 DIImportedEntity Module(N);
858 if (!Module.Verify())
860 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
861 constructImportedEntityDIE(TheCU, Module, D);
864 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
866 DIImportedEntity Module(N);
867 if (!Module.Verify())
869 return constructImportedEntityDIE(TheCU, Module, Context);
872 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
873 const DIImportedEntity &Module,
875 assert(Module.Verify() &&
876 "Use one of the MDNode * overloads to handle invalid metadata");
877 assert(Context && "Should always have a context for an imported_module");
878 DIE *IMDie = new DIE(Module.getTag());
879 TheCU->insertDIE(Module, IMDie);
881 DIDescriptor Entity = Module.getEntity();
882 if (Entity.isNameSpace())
883 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
884 else if (Entity.isSubprogram())
885 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
886 else if (Entity.isType())
887 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
889 EntityDie = TheCU->getDIE(Entity);
890 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
891 Module.getContext().getDirectory(),
892 TheCU->getUniqueID());
893 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
894 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
895 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
896 StringRef Name = Module.getName();
898 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
899 Context->addChild(IMDie);
902 // Emit all Dwarf sections that should come prior to the content. Create
903 // global DIEs and emit initial debug info sections. This is invoked by
904 // the target AsmPrinter.
905 void DwarfDebug::beginModule() {
906 if (DisableDebugInfoPrinting)
909 const Module *M = MMI->getModule();
911 // If module has named metadata anchors then use them, otherwise scan the
912 // module using debug info finder to collect debug info.
913 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
916 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
918 // Emit initial sections so we can reference labels later.
921 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
922 DICompileUnit CUNode(CU_Nodes->getOperand(i));
923 CompileUnit *CU = constructCompileUnit(CUNode);
924 DIArray ImportedEntities = CUNode.getImportedEntities();
925 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
926 ScopesWithImportedEntities.push_back(std::make_pair(
927 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
928 ImportedEntities.getElement(i)));
929 std::sort(ScopesWithImportedEntities.begin(),
930 ScopesWithImportedEntities.end(), less_first());
931 DIArray GVs = CUNode.getGlobalVariables();
932 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
933 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
934 DIArray SPs = CUNode.getSubprograms();
935 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
936 constructSubprogramDIE(CU, SPs.getElement(i));
937 DIArray EnumTypes = CUNode.getEnumTypes();
938 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
939 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
940 DIArray RetainedTypes = CUNode.getRetainedTypes();
941 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
942 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
943 // Emit imported_modules last so that the relevant context is already
945 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
946 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
949 // Tell MMI that we have debug info.
950 MMI->setDebugInfoAvailability(true);
952 // Prime section data.
953 SectionMap[Asm->getObjFileLowering().getTextSection()];
956 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
957 void DwarfDebug::computeInlinedDIEs() {
958 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
959 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
960 AE = InlinedSubprogramDIEs.end();
963 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
965 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
966 AE = AbstractSPDies.end();
968 DIE *ISP = AI->second;
969 if (InlinedSubprogramDIEs.count(ISP))
971 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
975 // Collect info for variables that were optimized out.
976 void DwarfDebug::collectDeadVariables() {
977 const Module *M = MMI->getModule();
979 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
980 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
981 DICompileUnit TheCU(CU_Nodes->getOperand(i));
982 DIArray Subprograms = TheCU.getSubprograms();
983 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
984 DISubprogram SP(Subprograms.getElement(i));
985 if (ProcessedSPNodes.count(SP) != 0)
987 if (!SP.isSubprogram())
989 if (!SP.isDefinition())
991 DIArray Variables = SP.getVariables();
992 if (Variables.getNumElements() == 0)
995 // Construct subprogram DIE and add variables DIEs.
996 CompileUnit *SPCU = static_cast<CompileUnit *>(CUMap.lookup(TheCU));
997 assert(SPCU && "Unable to find Compile Unit!");
998 // FIXME: See the comment in constructSubprogramDIE about duplicate
1000 constructSubprogramDIE(SPCU, SP);
1001 DIE *SPDIE = SPCU->getDIE(SP);
1002 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1003 DIVariable DV(Variables.getElement(vi));
1004 if (!DV.isVariable())
1006 DbgVariable NewVar(DV, NULL, this);
1007 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1008 SPDIE->addChild(VariableDIE);
1015 // Type Signature [7.27] and ODR Hash code.
1017 /// \brief Grabs the string in whichever attribute is passed in and returns
1018 /// a reference to it. Returns "" if the attribute doesn't exist.
1019 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1020 DIEValue *V = Die->findAttribute(Attr);
1022 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1023 return S->getString();
1025 return StringRef("");
1028 /// Return true if the current DIE is contained within an anonymous namespace.
1029 static bool isContainedInAnonNamespace(DIE *Die) {
1030 DIE *Parent = Die->getParent();
1033 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1034 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1036 Parent = Parent->getParent();
1042 /// Test if the current CU language is C++ and that we have
1043 /// a named type that is not contained in an anonymous namespace.
1044 static bool shouldAddODRHash(TypeUnit *CU, DIE *Die) {
1045 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1046 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1047 !isContainedInAnonNamespace(Die);
1050 void DwarfDebug::finalizeModuleInfo() {
1051 // Collect info for variables that were optimized out.
1052 collectDeadVariables();
1054 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1055 computeInlinedDIEs();
1057 // Handle anything that needs to be done on a per-cu basis.
1058 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
1059 E = getUnits().end();
1062 // Emit DW_AT_containing_type attribute to connect types with their
1063 // vtable holding type.
1064 TheU->constructContainingTypeDIEs();
1066 // If we're splitting the dwarf out now that we've got the entire
1067 // CU then construct a skeleton CU based upon it.
1068 if (useSplitDwarf() &&
1069 TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1071 if (GenerateCUHash) {
1073 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1075 // This should be a unique identifier when we want to build .dwp files.
1076 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1077 dwarf::DW_FORM_data8, ID);
1078 // Now construct the skeleton CU associated.
1079 CompileUnit *SkCU = constructSkeletonCU(static_cast<CompileUnit *>(TheU));
1080 // This should be a unique identifier when we want to build .dwp files.
1081 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1082 dwarf::DW_FORM_data8, ID);
1086 // Compute DIE offsets and sizes.
1087 InfoHolder.computeSizeAndOffsets();
1088 if (useSplitDwarf())
1089 SkeletonHolder.computeSizeAndOffsets();
1092 void DwarfDebug::endSections() {
1093 // Filter labels by section.
1094 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1095 const SymbolCU &SCU = ArangeLabels[n];
1096 if (SCU.Sym->isInSection()) {
1097 // Make a note of this symbol and it's section.
1098 const MCSection *Section = &SCU.Sym->getSection();
1099 if (!Section->getKind().isMetadata())
1100 SectionMap[Section].push_back(SCU);
1102 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1103 // appear in the output. This sucks as we rely on sections to build
1104 // arange spans. We can do it without, but it's icky.
1105 SectionMap[NULL].push_back(SCU);
1109 // Build a list of sections used.
1110 std::vector<const MCSection *> Sections;
1111 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1113 const MCSection *Section = it->first;
1114 Sections.push_back(Section);
1117 // Sort the sections into order.
1118 // This is only done to ensure consistent output order across different runs.
1119 std::sort(Sections.begin(), Sections.end(), SectionSort);
1121 // Add terminating symbols for each section.
1122 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1123 const MCSection *Section = Sections[ID];
1124 MCSymbol *Sym = NULL;
1127 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1128 // if we know the section name up-front. For user-created sections, the
1130 // label may not be valid to use as a label. (section names can use a
1132 // set of characters on some systems)
1133 Sym = Asm->GetTempSymbol("debug_end", ID);
1134 Asm->OutStreamer.SwitchSection(Section);
1135 Asm->OutStreamer.EmitLabel(Sym);
1138 // Insert a final terminator.
1139 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1143 // Emit all Dwarf sections that should come after the content.
1144 void DwarfDebug::endModule() {
1151 // End any existing sections.
1152 // TODO: Does this need to happen?
1155 // Finalize the debug info for the module.
1156 finalizeModuleInfo();
1160 // Emit all the DIEs into a debug info section.
1163 // Corresponding abbreviations into a abbrev section.
1164 emitAbbreviations();
1166 // Emit info into a debug loc section.
1169 // Emit info into a debug aranges section.
1172 // Emit info into a debug ranges section.
1175 // Emit info into a debug macinfo section.
1178 if (useSplitDwarf()) {
1181 emitDebugAbbrevDWO();
1182 // Emit DWO addresses.
1183 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1186 // Emit info into the dwarf accelerator table sections.
1187 if (useDwarfAccelTables()) {
1190 emitAccelNamespaces();
1194 // Emit the pubnames and pubtypes sections if requested.
1195 if (HasDwarfPubSections) {
1196 emitDebugPubNames(GenerateGnuPubSections);
1197 emitDebugPubTypes(GenerateGnuPubSections);
1203 // Reset these for the next Module if we have one.
1207 // Find abstract variable, if any, associated with Var.
1208 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1209 DebugLoc ScopeLoc) {
1210 LLVMContext &Ctx = DV->getContext();
1211 // More then one inlined variable corresponds to one abstract variable.
1212 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1213 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1215 return AbsDbgVariable;
1217 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1221 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1222 addScopeVariable(Scope, AbsDbgVariable);
1223 AbstractVariables[Var] = AbsDbgVariable;
1224 return AbsDbgVariable;
1227 // If Var is a current function argument then add it to CurrentFnArguments list.
1228 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1229 if (!LScopes.isCurrentFunctionScope(Scope))
1231 DIVariable DV = Var->getVariable();
1232 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1234 unsigned ArgNo = DV.getArgNumber();
1238 size_t Size = CurrentFnArguments.size();
1240 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1241 // llvm::Function argument size is not good indicator of how many
1242 // arguments does the function have at source level.
1244 CurrentFnArguments.resize(ArgNo * 2);
1245 CurrentFnArguments[ArgNo - 1] = Var;
1249 // Collect variable information from side table maintained by MMI.
1250 void DwarfDebug::collectVariableInfoFromMMITable(
1251 SmallPtrSet<const MDNode *, 16> &Processed) {
1252 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1253 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1256 const MDNode *Var = VI->first;
1259 Processed.insert(Var);
1261 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1263 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1265 // If variable scope is not found then skip this variable.
1269 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1270 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1271 RegVar->setFrameIndex(VP.first);
1272 if (!addCurrentFnArgument(RegVar, Scope))
1273 addScopeVariable(Scope, RegVar);
1275 AbsDbgVariable->setFrameIndex(VP.first);
1279 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1281 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1282 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1283 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1284 MI->getOperand(0).getReg() &&
1285 (MI->getOperand(1).isImm() ||
1286 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1289 // Get .debug_loc entry for the instruction range starting at MI.
1290 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1291 const MCSymbol *FLabel,
1292 const MCSymbol *SLabel,
1293 const MachineInstr *MI) {
1294 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1296 assert(MI->getNumOperands() == 3);
1297 if (MI->getOperand(0).isReg()) {
1298 MachineLocation MLoc;
1299 // If the second operand is an immediate, this is a
1300 // register-indirect address.
1301 if (!MI->getOperand(1).isImm())
1302 MLoc.set(MI->getOperand(0).getReg());
1304 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1305 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1307 if (MI->getOperand(0).isImm())
1308 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1309 if (MI->getOperand(0).isFPImm())
1310 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1311 if (MI->getOperand(0).isCImm())
1312 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1314 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1317 // Find variables for each lexical scope.
1319 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1321 // Grab the variable info that was squirreled away in the MMI side-table.
1322 collectVariableInfoFromMMITable(Processed);
1324 for (SmallVectorImpl<const MDNode *>::const_iterator
1325 UVI = UserVariables.begin(),
1326 UVE = UserVariables.end();
1327 UVI != UVE; ++UVI) {
1328 const MDNode *Var = *UVI;
1329 if (Processed.count(Var))
1332 // History contains relevant DBG_VALUE instructions for Var and instructions
1334 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1335 if (History.empty())
1337 const MachineInstr *MInsn = History.front();
1340 LexicalScope *Scope = NULL;
1341 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1342 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1343 Scope = LScopes.getCurrentFunctionScope();
1344 else if (MDNode *IA = DV.getInlinedAt())
1345 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1347 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1348 // If variable scope is not found then skip this variable.
1352 Processed.insert(DV);
1353 assert(MInsn->isDebugValue() && "History must begin with debug value");
1354 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1355 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1356 if (!addCurrentFnArgument(RegVar, Scope))
1357 addScopeVariable(Scope, RegVar);
1359 AbsVar->setMInsn(MInsn);
1361 // Simplify ranges that are fully coalesced.
1362 if (History.size() <= 1 ||
1363 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1364 RegVar->setMInsn(MInsn);
1368 // Handle multiple DBG_VALUE instructions describing one variable.
1369 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1371 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1372 HI = History.begin(),
1375 const MachineInstr *Begin = *HI;
1376 assert(Begin->isDebugValue() && "Invalid History entry");
1378 // Check if DBG_VALUE is truncating a range.
1379 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1380 !Begin->getOperand(0).getReg())
1383 // Compute the range for a register location.
1384 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1385 const MCSymbol *SLabel = 0;
1388 // If Begin is the last instruction in History then its value is valid
1389 // until the end of the function.
1390 SLabel = FunctionEndSym;
1392 const MachineInstr *End = HI[1];
1393 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1394 << "\t" << *Begin << "\t" << *End << "\n");
1395 if (End->isDebugValue())
1396 SLabel = getLabelBeforeInsn(End);
1398 // End is a normal instruction clobbering the range.
1399 SLabel = getLabelAfterInsn(End);
1400 assert(SLabel && "Forgot label after clobber instruction");
1405 // The value is valid until the next DBG_VALUE or clobber.
1406 DotDebugLocEntries.push_back(
1407 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1409 DotDebugLocEntries.push_back(DotDebugLocEntry());
1412 // Collect info for variables that were optimized out.
1413 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1414 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1415 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1416 DIVariable DV(Variables.getElement(i));
1417 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1419 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1420 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1424 // Return Label preceding the instruction.
1425 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1426 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1427 assert(Label && "Didn't insert label before instruction");
1431 // Return Label immediately following the instruction.
1432 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1433 return LabelsAfterInsn.lookup(MI);
1436 // Process beginning of an instruction.
1437 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1440 // Check if source location changes, but ignore DBG_VALUE locations.
1441 if (!MI->isDebugValue()) {
1442 DebugLoc DL = MI->getDebugLoc();
1443 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1446 if (DL == PrologEndLoc) {
1447 Flags |= DWARF2_FLAG_PROLOGUE_END;
1448 PrologEndLoc = DebugLoc();
1450 if (PrologEndLoc.isUnknown())
1451 Flags |= DWARF2_FLAG_IS_STMT;
1453 if (!DL.isUnknown()) {
1454 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1455 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1457 recordSourceLine(0, 0, 0, 0);
1461 // Insert labels where requested.
1462 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1463 LabelsBeforeInsn.find(MI);
1466 if (I == LabelsBeforeInsn.end())
1469 // Label already assigned.
1474 PrevLabel = MMI->getContext().CreateTempSymbol();
1475 Asm->OutStreamer.EmitLabel(PrevLabel);
1477 I->second = PrevLabel;
1480 // Process end of an instruction.
1481 void DwarfDebug::endInstruction() {
1483 // Don't create a new label after DBG_VALUE instructions.
1484 // They don't generate code.
1485 if (!CurMI->isDebugValue())
1488 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1489 LabelsAfterInsn.find(CurMI);
1493 if (I == LabelsAfterInsn.end())
1496 // Label already assigned.
1500 // We need a label after this instruction.
1502 PrevLabel = MMI->getContext().CreateTempSymbol();
1503 Asm->OutStreamer.EmitLabel(PrevLabel);
1505 I->second = PrevLabel;
1508 // Each LexicalScope has first instruction and last instruction to mark
1509 // beginning and end of a scope respectively. Create an inverse map that list
1510 // scopes starts (and ends) with an instruction. One instruction may start (or
1511 // end) multiple scopes. Ignore scopes that are not reachable.
1512 void DwarfDebug::identifyScopeMarkers() {
1513 SmallVector<LexicalScope *, 4> WorkList;
1514 WorkList.push_back(LScopes.getCurrentFunctionScope());
1515 while (!WorkList.empty()) {
1516 LexicalScope *S = WorkList.pop_back_val();
1518 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1519 if (!Children.empty())
1520 for (SmallVectorImpl<LexicalScope *>::const_iterator
1521 SI = Children.begin(),
1522 SE = Children.end();
1524 WorkList.push_back(*SI);
1526 if (S->isAbstractScope())
1529 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1532 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1535 assert(RI->first && "InsnRange does not have first instruction!");
1536 assert(RI->second && "InsnRange does not have second instruction!");
1537 requestLabelBeforeInsn(RI->first);
1538 requestLabelAfterInsn(RI->second);
1543 // Get MDNode for DebugLoc's scope.
1544 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1545 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1546 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1547 return DL.getScope(Ctx);
1550 // Walk up the scope chain of given debug loc and find line number info
1551 // for the function.
1552 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1553 const MDNode *Scope = getScopeNode(DL, Ctx);
1554 DISubprogram SP = getDISubprogram(Scope);
1555 if (SP.isSubprogram()) {
1556 // Check for number of operands since the compatibility is
1558 if (SP->getNumOperands() > 19)
1559 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1561 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1567 // Gather pre-function debug information. Assumes being called immediately
1568 // after the function entry point has been emitted.
1569 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1572 // If there's no debug info for the function we're not going to do anything.
1573 if (!MMI->hasDebugInfo())
1576 // Grab the lexical scopes for the function, if we don't have any of those
1577 // then we're not going to be able to do anything.
1578 LScopes.initialize(*MF);
1579 if (LScopes.empty())
1582 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1584 // Make sure that each lexical scope will have a begin/end label.
1585 identifyScopeMarkers();
1587 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1588 // belongs to so that we add to the correct per-cu line table in the
1590 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1591 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1592 assert(TheCU && "Unable to find compile unit!");
1593 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1594 // Use a single line table if we are using .loc and generating assembly.
1595 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1597 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1599 // Emit a label for the function so that we have a beginning address.
1600 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1601 // Assumes in correct section after the entry point.
1602 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1604 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1605 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1606 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1608 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1610 bool AtBlockEntry = true;
1611 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1613 const MachineInstr *MI = II;
1615 if (MI->isDebugValue()) {
1616 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1618 // Keep track of user variables.
1620 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1622 // Variable is in a register, we need to check for clobbers.
1623 if (isDbgValueInDefinedReg(MI))
1624 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1626 // Check the history of this variable.
1627 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1628 if (History.empty()) {
1629 UserVariables.push_back(Var);
1630 // The first mention of a function argument gets the FunctionBeginSym
1631 // label, so arguments are visible when breaking at function entry.
1633 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1634 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1635 LabelsBeforeInsn[MI] = FunctionBeginSym;
1637 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1638 const MachineInstr *Prev = History.back();
1639 if (Prev->isDebugValue()) {
1640 // Coalesce identical entries at the end of History.
1641 if (History.size() >= 2 &&
1642 Prev->isIdenticalTo(History[History.size() - 2])) {
1643 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1644 << "\t" << *Prev << "\t"
1645 << *History[History.size() - 2] << "\n");
1649 // Terminate old register assignments that don't reach MI;
1650 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1651 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1652 isDbgValueInDefinedReg(Prev)) {
1653 // Previous register assignment needs to terminate at the end of
1655 MachineBasicBlock::const_iterator LastMI =
1656 PrevMBB->getLastNonDebugInstr();
1657 if (LastMI == PrevMBB->end()) {
1658 // Drop DBG_VALUE for empty range.
1659 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1660 << "\t" << *Prev << "\n");
1662 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1663 // Terminate after LastMI.
1664 History.push_back(LastMI);
1668 History.push_back(MI);
1670 // Not a DBG_VALUE instruction.
1672 AtBlockEntry = false;
1674 // First known non-DBG_VALUE and non-frame setup location marks
1675 // the beginning of the function body.
1676 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1677 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1678 PrologEndLoc = MI->getDebugLoc();
1680 // Check if the instruction clobbers any registers with debug vars.
1681 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1682 MOE = MI->operands_end();
1683 MOI != MOE; ++MOI) {
1684 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1686 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1689 const MDNode *Var = LiveUserVar[Reg];
1692 // Reg is now clobbered.
1693 LiveUserVar[Reg] = 0;
1695 // Was MD last defined by a DBG_VALUE referring to Reg?
1696 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1697 if (HistI == DbgValues.end())
1699 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1700 if (History.empty())
1702 const MachineInstr *Prev = History.back();
1703 // Sanity-check: Register assignments are terminated at the end of
1705 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1707 // Is the variable still in Reg?
1708 if (!isDbgValueInDefinedReg(Prev) ||
1709 Prev->getOperand(0).getReg() != Reg)
1711 // Var is clobbered. Make sure the next instruction gets a label.
1712 History.push_back(MI);
1719 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1721 SmallVectorImpl<const MachineInstr *> &History = I->second;
1722 if (History.empty())
1725 // Make sure the final register assignments are terminated.
1726 const MachineInstr *Prev = History.back();
1727 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1728 const MachineBasicBlock *PrevMBB = Prev->getParent();
1729 MachineBasicBlock::const_iterator LastMI =
1730 PrevMBB->getLastNonDebugInstr();
1731 if (LastMI == PrevMBB->end())
1732 // Drop DBG_VALUE for empty range.
1734 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1735 // Terminate after LastMI.
1736 History.push_back(LastMI);
1739 // Request labels for the full history.
1740 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1741 const MachineInstr *MI = History[i];
1742 if (MI->isDebugValue())
1743 requestLabelBeforeInsn(MI);
1745 requestLabelAfterInsn(MI);
1749 PrevInstLoc = DebugLoc();
1750 PrevLabel = FunctionBeginSym;
1752 // Record beginning of function.
1753 if (!PrologEndLoc.isUnknown()) {
1754 DebugLoc FnStartDL =
1755 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1757 FnStartDL.getLine(), FnStartDL.getCol(),
1758 FnStartDL.getScope(MF->getFunction()->getContext()),
1759 // We'd like to list the prologue as "not statements" but GDB behaves
1760 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1761 DWARF2_FLAG_IS_STMT);
1765 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1766 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1767 DIVariable DV = Var->getVariable();
1768 // Variables with positive arg numbers are parameters.
1769 if (unsigned ArgNum = DV.getArgNumber()) {
1770 // Keep all parameters in order at the start of the variable list to ensure
1771 // function types are correct (no out-of-order parameters)
1773 // This could be improved by only doing it for optimized builds (unoptimized
1774 // builds have the right order to begin with), searching from the back (this
1775 // would catch the unoptimized case quickly), or doing a binary search
1776 // rather than linear search.
1777 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1778 while (I != Vars.end()) {
1779 unsigned CurNum = (*I)->getVariable().getArgNumber();
1780 // A local (non-parameter) variable has been found, insert immediately
1784 // A later indexed parameter has been found, insert immediately before it.
1785 if (CurNum > ArgNum)
1789 Vars.insert(I, Var);
1793 Vars.push_back(Var);
1796 // Gather and emit post-function debug information.
1797 void DwarfDebug::endFunction(const MachineFunction *MF) {
1798 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1799 // though the beginFunction may not be called at all.
1800 // We should handle both cases.
1804 assert(CurFn == MF);
1807 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1812 // Define end label for subprogram.
1813 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1814 // Assumes in correct section after the entry point.
1815 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1816 // Set DwarfCompileUnitID in MCContext to default value.
1817 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1819 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1820 collectVariableInfo(ProcessedVars);
1822 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1823 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1824 assert(TheCU && "Unable to find compile unit!");
1826 // Construct abstract scopes.
1827 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1828 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1829 LexicalScope *AScope = AList[i];
1830 DISubprogram SP(AScope->getScopeNode());
1831 if (SP.isSubprogram()) {
1832 // Collect info for variables that were optimized out.
1833 DIArray Variables = SP.getVariables();
1834 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1835 DIVariable DV(Variables.getElement(i));
1836 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1838 // Check that DbgVariable for DV wasn't created earlier, when
1839 // findAbstractVariable() was called for inlined instance of DV.
1840 LLVMContext &Ctx = DV->getContext();
1841 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1842 if (AbstractVariables.lookup(CleanDV))
1844 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1845 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1848 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1849 constructScopeDIE(TheCU, AScope);
1852 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1854 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1855 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1858 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1859 E = ScopeVariables.end();
1861 DeleteContainerPointers(I->second);
1862 ScopeVariables.clear();
1863 DeleteContainerPointers(CurrentFnArguments);
1864 UserVariables.clear();
1866 AbstractVariables.clear();
1867 LabelsBeforeInsn.clear();
1868 LabelsAfterInsn.clear();
1873 // Register a source line with debug info. Returns the unique label that was
1874 // emitted and which provides correspondence to the source line list.
1875 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1881 DIDescriptor Scope(S);
1883 if (Scope.isCompileUnit()) {
1884 DICompileUnit CU(S);
1885 Fn = CU.getFilename();
1886 Dir = CU.getDirectory();
1887 } else if (Scope.isFile()) {
1889 Fn = F.getFilename();
1890 Dir = F.getDirectory();
1891 } else if (Scope.isSubprogram()) {
1893 Fn = SP.getFilename();
1894 Dir = SP.getDirectory();
1895 } else if (Scope.isLexicalBlockFile()) {
1896 DILexicalBlockFile DBF(S);
1897 Fn = DBF.getFilename();
1898 Dir = DBF.getDirectory();
1899 } else if (Scope.isLexicalBlock()) {
1900 DILexicalBlock DB(S);
1901 Fn = DB.getFilename();
1902 Dir = DB.getDirectory();
1904 llvm_unreachable("Unexpected scope info");
1906 Src = getOrCreateSourceID(
1907 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1909 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1912 //===----------------------------------------------------------------------===//
1914 //===----------------------------------------------------------------------===//
1916 // Compute the size and offset of a DIE. The offset is relative to start of the
1917 // CU. It returns the offset after laying out the DIE.
1918 unsigned DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1919 // Get the children.
1920 const std::vector<DIE *> &Children = Die->getChildren();
1922 // Record the abbreviation.
1923 assignAbbrevNumber(Die->getAbbrev());
1925 // Get the abbreviation for this DIE.
1926 unsigned AbbrevNumber = Die->getAbbrevNumber();
1927 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1930 Die->setOffset(Offset);
1932 // Start the size with the size of abbreviation code.
1933 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1935 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1936 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1938 // Size the DIE attribute values.
1939 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1940 // Size attribute value.
1941 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1943 // Size the DIE children if any.
1944 if (!Children.empty()) {
1945 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1946 "Children flag not set");
1948 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1949 Offset = computeSizeAndOffset(Children[j], Offset);
1951 // End of children marker.
1952 Offset += sizeof(int8_t);
1955 Die->setSize(Offset - Die->getOffset());
1959 // Compute the size and offset for each DIE.
1960 void DwarfUnits::computeSizeAndOffsets() {
1961 // Offset from the first CU in the debug info section is 0 initially.
1962 unsigned SecOffset = 0;
1964 // Iterate over each compile unit and set the size and offsets for each
1965 // DIE within each compile unit. All offsets are CU relative.
1966 for (SmallVectorImpl<Unit *>::const_iterator I = CUs.begin(), E = CUs.end();
1968 (*I)->setDebugInfoOffset(SecOffset);
1970 // CU-relative offset is reset to 0 here.
1971 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1972 (*I)->getHeaderSize(); // Unit-specific headers
1974 // EndOffset here is CU-relative, after laying out
1975 // all of the CU DIE.
1976 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1977 SecOffset += EndOffset;
1981 // Emit initial Dwarf sections with a label at the start of each one.
1982 void DwarfDebug::emitSectionLabels() {
1983 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1985 // Dwarf sections base addresses.
1986 DwarfInfoSectionSym =
1987 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1988 DwarfAbbrevSectionSym =
1989 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1990 if (useSplitDwarf())
1991 DwarfAbbrevDWOSectionSym = emitSectionSym(
1992 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1993 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1995 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1996 emitSectionSym(Asm, MacroInfo);
1998 DwarfLineSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2000 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2001 if (GenerateGnuPubSections) {
2002 DwarfGnuPubNamesSectionSym =
2003 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2004 DwarfGnuPubTypesSectionSym =
2005 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2006 } else if (HasDwarfPubSections) {
2007 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2008 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2011 DwarfStrSectionSym =
2012 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2013 if (useSplitDwarf()) {
2014 DwarfStrDWOSectionSym =
2015 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2016 DwarfAddrSectionSym =
2017 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2019 DwarfDebugRangeSectionSym =
2020 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2022 DwarfDebugLocSectionSym =
2023 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2025 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2026 emitSectionSym(Asm, TLOF.getDataSection());
2029 // Recursively emits a debug information entry.
2030 void DwarfDebug::emitDIE(DIE *Die, ArrayRef<DIEAbbrev *> Abbrevs) {
2031 // Get the abbreviation for this DIE.
2032 unsigned AbbrevNumber = Die->getAbbrevNumber();
2033 const DIEAbbrev *Abbrev = Abbrevs[AbbrevNumber - 1];
2035 // Emit the code (index) for the abbreviation.
2036 if (Asm->isVerbose())
2037 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2038 Twine::utohexstr(Die->getOffset()) + ":0x" +
2039 Twine::utohexstr(Die->getSize()) + " " +
2040 dwarf::TagString(Abbrev->getTag()));
2041 Asm->EmitULEB128(AbbrevNumber);
2043 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2044 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2046 // Emit the DIE attribute values.
2047 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2048 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2049 dwarf::Form Form = AbbrevData[i].getForm();
2050 assert(Form && "Too many attributes for DIE (check abbreviation)");
2052 if (Asm->isVerbose())
2053 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2056 case dwarf::DW_AT_abstract_origin:
2057 case dwarf::DW_AT_type:
2058 case dwarf::DW_AT_friend:
2059 case dwarf::DW_AT_specification:
2060 case dwarf::DW_AT_import:
2061 case dwarf::DW_AT_containing_type: {
2062 DIEEntry *E = cast<DIEEntry>(Values[i]);
2063 DIE *Origin = E->getEntry();
2064 unsigned Addr = Origin->getOffset();
2065 if (Form == dwarf::DW_FORM_ref_addr) {
2066 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2067 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2068 // section. Origin->getOffset() returns the offset from start of the
2070 CompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2071 assert(CU && "CUDie should belong to a CU.");
2072 Addr += CU->getDebugInfoOffset();
2073 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2074 Asm->EmitLabelPlusOffset(DwarfInfoSectionSym, Addr,
2075 DIEEntry::getRefAddrSize(Asm));
2077 Asm->EmitLabelOffsetDifference(DwarfInfoSectionSym, Addr,
2078 DwarfInfoSectionSym,
2079 DIEEntry::getRefAddrSize(Asm));
2081 // Make sure Origin belong to the same CU.
2082 assert(Die->getUnit() == Origin->getUnit() &&
2083 "The referenced DIE should belong to the same CU in ref4");
2084 Asm->EmitInt32(Addr);
2088 case dwarf::DW_AT_ranges: {
2089 // DW_AT_range Value encodes offset in debug_range section.
2090 DIELabel *V = cast<DIELabel>(Values[i]);
2092 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2093 Asm->EmitSectionOffset(V->getValue(), DwarfDebugRangeSectionSym);
2095 Asm->EmitLabelDifference(V->getValue(), DwarfDebugRangeSectionSym, 4);
2098 case dwarf::DW_AT_location: {
2099 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2100 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2101 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2103 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2105 Values[i]->EmitValue(Asm, Form);
2109 case dwarf::DW_AT_accessibility: {
2110 if (Asm->isVerbose()) {
2111 DIEInteger *V = cast<DIEInteger>(Values[i]);
2112 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2114 Values[i]->EmitValue(Asm, Form);
2118 // Emit an attribute using the defined form.
2119 Values[i]->EmitValue(Asm, Form);
2124 // Emit the DIE children if any.
2125 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2126 const std::vector<DIE *> &Children = Die->getChildren();
2128 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2129 emitDIE(Children[j], Abbrevs);
2131 if (Asm->isVerbose())
2132 Asm->OutStreamer.AddComment("End Of Children Mark");
2137 // Emit the various dwarf units to the unit section USection with
2138 // the abbreviations going into ASection.
2139 void DwarfUnits::emitUnits(DwarfDebug *DD, const MCSection *USection,
2140 const MCSection *ASection,
2141 const MCSymbol *ASectionSym) {
2142 Asm->OutStreamer.SwitchSection(USection);
2143 for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
2146 DIE *Die = TheU->getUnitDie();
2148 // Emit the compile units header.
2149 Asm->OutStreamer.EmitLabel(
2150 Asm->GetTempSymbol(USection->getLabelBeginName(), TheU->getUniqueID()));
2152 // Emit size of content not including length itself
2153 Asm->OutStreamer.AddComment("Length of Unit");
2154 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2156 TheU->emitHeader(ASection, ASectionSym);
2158 DD->emitDIE(Die, Abbreviations);
2159 Asm->OutStreamer.EmitLabel(
2160 Asm->GetTempSymbol(USection->getLabelEndName(), TheU->getUniqueID()));
2164 // Emit the debug info section.
2165 void DwarfDebug::emitDebugInfo() {
2166 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2168 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2169 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2170 DwarfAbbrevSectionSym);
2173 // Emit the abbreviation section.
2174 void DwarfDebug::emitAbbreviations() {
2175 if (!useSplitDwarf())
2176 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2179 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2182 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2183 std::vector<DIEAbbrev *> *Abbrevs) {
2184 // Check to see if it is worth the effort.
2185 if (!Abbrevs->empty()) {
2186 // Start the debug abbrev section.
2187 Asm->OutStreamer.SwitchSection(Section);
2189 // For each abbrevation.
2190 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2191 // Get abbreviation data
2192 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2194 // Emit the abbrevations code (base 1 index.)
2195 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2197 // Emit the abbreviations data.
2201 // Mark end of abbreviations.
2202 Asm->EmitULEB128(0, "EOM(3)");
2206 // Emit the last address of the section and the end of the line matrix.
2207 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2208 // Define last address of section.
2209 Asm->OutStreamer.AddComment("Extended Op");
2212 Asm->OutStreamer.AddComment("Op size");
2213 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2214 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2215 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2217 Asm->OutStreamer.AddComment("Section end label");
2219 Asm->OutStreamer.EmitSymbolValue(
2220 Asm->GetTempSymbol("section_end", SectionEnd),
2221 Asm->getDataLayout().getPointerSize());
2223 // Mark end of matrix.
2224 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2230 // Emit visible names into a hashed accelerator table section.
2231 void DwarfDebug::emitAccelNames() {
2233 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2234 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2235 E = getUnits().end();
2238 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2239 for (StringMap<std::vector<const DIE *> >::const_iterator
2243 StringRef Name = GI->getKey();
2244 const std::vector<const DIE *> &Entities = GI->second;
2245 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2246 DE = Entities.end();
2248 AT.AddName(Name, *DI);
2252 AT.FinalizeTable(Asm, "Names");
2253 Asm->OutStreamer.SwitchSection(
2254 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2255 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2256 Asm->OutStreamer.EmitLabel(SectionBegin);
2258 // Emit the full data.
2259 AT.Emit(Asm, SectionBegin, &InfoHolder);
2262 // Emit objective C classes and categories into a hashed accelerator table
2264 void DwarfDebug::emitAccelObjC() {
2266 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2267 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2268 E = getUnits().end();
2271 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2272 for (StringMap<std::vector<const DIE *> >::const_iterator
2276 StringRef Name = GI->getKey();
2277 const std::vector<const DIE *> &Entities = GI->second;
2278 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2279 DE = Entities.end();
2281 AT.AddName(Name, *DI);
2285 AT.FinalizeTable(Asm, "ObjC");
2286 Asm->OutStreamer.SwitchSection(
2287 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2288 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2289 Asm->OutStreamer.EmitLabel(SectionBegin);
2291 // Emit the full data.
2292 AT.Emit(Asm, SectionBegin, &InfoHolder);
2295 // Emit namespace dies into a hashed accelerator table.
2296 void DwarfDebug::emitAccelNamespaces() {
2298 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2299 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2300 E = getUnits().end();
2303 const StringMap<std::vector<const DIE *> > &Names =
2304 TheU->getAccelNamespace();
2305 for (StringMap<std::vector<const DIE *> >::const_iterator
2309 StringRef Name = GI->getKey();
2310 const std::vector<const DIE *> &Entities = GI->second;
2311 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2312 DE = Entities.end();
2314 AT.AddName(Name, *DI);
2318 AT.FinalizeTable(Asm, "namespac");
2319 Asm->OutStreamer.SwitchSection(
2320 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2321 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2322 Asm->OutStreamer.EmitLabel(SectionBegin);
2324 // Emit the full data.
2325 AT.Emit(Asm, SectionBegin, &InfoHolder);
2328 // Emit type dies into a hashed accelerator table.
2329 void DwarfDebug::emitAccelTypes() {
2330 std::vector<DwarfAccelTable::Atom> Atoms;
2332 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2334 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2336 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2337 DwarfAccelTable AT(Atoms);
2338 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2339 E = getUnits().end();
2342 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2343 TheU->getAccelTypes();
2345 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2349 StringRef Name = GI->getKey();
2350 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2352 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2353 DI = Entities.begin(),
2354 DE = Entities.end();
2356 AT.AddName(Name, DI->first, DI->second);
2360 AT.FinalizeTable(Asm, "types");
2361 Asm->OutStreamer.SwitchSection(
2362 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2363 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2364 Asm->OutStreamer.EmitLabel(SectionBegin);
2366 // Emit the full data.
2367 AT.Emit(Asm, SectionBegin, &InfoHolder);
2370 // Public name handling.
2371 // The format for the various pubnames:
2373 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2374 // for the DIE that is named.
2376 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2377 // into the CU and the index value is computed according to the type of value
2378 // for the DIE that is named.
2380 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2381 // it's the offset within the debug_info/debug_types dwo section, however, the
2382 // reference in the pubname header doesn't change.
2384 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2385 static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
2387 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2389 // We could have a specification DIE that has our most of our knowledge,
2390 // look for that now.
2391 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2393 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2394 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2395 Linkage = dwarf::GIEL_EXTERNAL;
2396 } else if (Die->findAttribute(dwarf::DW_AT_external))
2397 Linkage = dwarf::GIEL_EXTERNAL;
2399 switch (Die->getTag()) {
2400 case dwarf::DW_TAG_class_type:
2401 case dwarf::DW_TAG_structure_type:
2402 case dwarf::DW_TAG_union_type:
2403 case dwarf::DW_TAG_enumeration_type:
2404 return dwarf::PubIndexEntryDescriptor(
2405 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2406 ? dwarf::GIEL_STATIC
2407 : dwarf::GIEL_EXTERNAL);
2408 case dwarf::DW_TAG_typedef:
2409 case dwarf::DW_TAG_base_type:
2410 case dwarf::DW_TAG_subrange_type:
2411 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2412 case dwarf::DW_TAG_namespace:
2413 return dwarf::GIEK_TYPE;
2414 case dwarf::DW_TAG_subprogram:
2415 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2416 case dwarf::DW_TAG_constant:
2417 case dwarf::DW_TAG_variable:
2418 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2419 case dwarf::DW_TAG_enumerator:
2420 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2421 dwarf::GIEL_STATIC);
2423 return dwarf::GIEK_NONE;
2427 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2429 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2430 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2431 const MCSection *PSec =
2432 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2433 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2435 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2436 E = getUnits().end();
2439 unsigned ID = TheU->getUniqueID();
2441 // Start the dwarf pubnames section.
2442 Asm->OutStreamer.SwitchSection(PSec);
2444 // Emit a label so we can reference the beginning of this pubname section.
2446 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2449 Asm->OutStreamer.AddComment("Length of Public Names Info");
2450 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2451 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2452 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2454 Asm->OutStreamer.EmitLabel(BeginLabel);
2456 Asm->OutStreamer.AddComment("DWARF Version");
2457 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2459 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2460 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2461 DwarfInfoSectionSym);
2463 Asm->OutStreamer.AddComment("Compilation Unit Length");
2464 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2465 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2468 // Emit the pubnames for this compilation unit.
2469 const StringMap<const DIE *> &Globals = TheU->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 if (Asm->isVerbose())
2488 Asm->OutStreamer.AddComment("External Name");
2489 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2492 Asm->OutStreamer.AddComment("End Mark");
2494 Asm->OutStreamer.EmitLabel(EndLabel);
2498 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2499 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2500 const MCSection *PSec =
2501 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2502 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2504 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2505 E = getUnits().end();
2508 unsigned ID = TheU->getUniqueID();
2510 // Start the dwarf pubtypes section.
2511 Asm->OutStreamer.SwitchSection(PSec);
2513 // Emit a label so we can reference the beginning of this pubtype section.
2515 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2518 Asm->OutStreamer.AddComment("Length of Public Types Info");
2519 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2520 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2521 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2523 Asm->OutStreamer.EmitLabel(BeginLabel);
2525 if (Asm->isVerbose())
2526 Asm->OutStreamer.AddComment("DWARF Version");
2527 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2529 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2530 Asm->EmitSectionOffset(
2531 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()),
2532 DwarfInfoSectionSym);
2534 Asm->OutStreamer.AddComment("Compilation Unit Length");
2535 Asm->EmitLabelDifference(
2536 Asm->GetTempSymbol(ISec->getLabelEndName(), TheU->getUniqueID()),
2537 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()), 4);
2539 // Emit the pubtypes.
2540 const StringMap<const DIE *> &Globals = TheU->getGlobalTypes();
2541 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2544 const char *Name = GI->getKeyData();
2545 const DIE *Entity = GI->second;
2547 if (Asm->isVerbose())
2548 Asm->OutStreamer.AddComment("DIE offset");
2549 Asm->EmitInt32(Entity->getOffset());
2552 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2553 Asm->OutStreamer.AddComment(
2554 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2555 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2556 Asm->EmitInt8(Desc.toBits());
2559 if (Asm->isVerbose())
2560 Asm->OutStreamer.AddComment("External Name");
2562 // Emit the name with a terminating null byte.
2563 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2566 Asm->OutStreamer.AddComment("End Mark");
2568 Asm->OutStreamer.EmitLabel(EndLabel);
2572 // Emit strings into a string section.
2573 void DwarfUnits::emitStrings(const MCSection *StrSection,
2574 const MCSection *OffsetSection = NULL,
2575 const MCSymbol *StrSecSym = NULL) {
2577 if (StringPool.empty())
2580 // Start the dwarf str section.
2581 Asm->OutStreamer.SwitchSection(StrSection);
2583 // Get all of the string pool entries and put them in an array by their ID so
2584 // we can sort them.
2586 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2589 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2590 I = StringPool.begin(),
2591 E = StringPool.end();
2593 Entries.push_back(std::make_pair(I->second.second, &*I));
2595 array_pod_sort(Entries.begin(), Entries.end());
2597 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2598 // Emit a label for reference from debug information entries.
2599 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2601 // Emit the string itself with a terminating null byte.
2602 Asm->OutStreamer.EmitBytes(
2603 StringRef(Entries[i].second->getKeyData(),
2604 Entries[i].second->getKeyLength() + 1));
2607 // If we've got an offset section go ahead and emit that now as well.
2608 if (OffsetSection) {
2609 Asm->OutStreamer.SwitchSection(OffsetSection);
2610 unsigned offset = 0;
2611 unsigned size = 4; // FIXME: DWARF64 is 8.
2612 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2613 Asm->OutStreamer.EmitIntValue(offset, size);
2614 offset += Entries[i].second->getKeyLength() + 1;
2620 // Emit addresses into the section given.
2621 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2623 if (AddressPool.empty())
2626 // Start the dwarf addr section.
2627 Asm->OutStreamer.SwitchSection(AddrSection);
2629 // Order the address pool entries by ID
2630 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2632 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2633 E = AddressPool.end();
2635 Entries[I->second] = I->first;
2637 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2638 // Emit an expression for reference from debug information entries.
2639 if (const MCExpr *Expr = Entries[i])
2640 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2642 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2646 // Emit visible names into a debug str section.
2647 void DwarfDebug::emitDebugStr() {
2648 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2649 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2652 // Emit locations into the debug loc section.
2653 void DwarfDebug::emitDebugLoc() {
2654 if (DotDebugLocEntries.empty())
2657 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2658 I = DotDebugLocEntries.begin(),
2659 E = DotDebugLocEntries.end();
2661 DotDebugLocEntry &Entry = *I;
2662 if (I + 1 != DotDebugLocEntries.end())
2666 // Start the dwarf loc section.
2667 Asm->OutStreamer.SwitchSection(
2668 Asm->getObjFileLowering().getDwarfLocSection());
2669 unsigned char Size = Asm->getDataLayout().getPointerSize();
2670 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2672 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2673 I = DotDebugLocEntries.begin(),
2674 E = DotDebugLocEntries.end();
2675 I != E; ++I, ++index) {
2676 DotDebugLocEntry &Entry = *I;
2677 if (Entry.isMerged())
2679 if (Entry.isEmpty()) {
2680 Asm->OutStreamer.EmitIntValue(0, Size);
2681 Asm->OutStreamer.EmitIntValue(0, Size);
2682 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2684 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2685 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2686 DIVariable DV(Entry.getVariable());
2687 Asm->OutStreamer.AddComment("Loc expr size");
2688 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2689 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2690 Asm->EmitLabelDifference(end, begin, 2);
2691 Asm->OutStreamer.EmitLabel(begin);
2692 if (Entry.isInt()) {
2693 DIBasicType BTy(DV.getType());
2694 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2695 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2696 Asm->OutStreamer.AddComment("DW_OP_consts");
2697 Asm->EmitInt8(dwarf::DW_OP_consts);
2698 Asm->EmitSLEB128(Entry.getInt());
2700 Asm->OutStreamer.AddComment("DW_OP_constu");
2701 Asm->EmitInt8(dwarf::DW_OP_constu);
2702 Asm->EmitULEB128(Entry.getInt());
2704 } else if (Entry.isLocation()) {
2705 MachineLocation Loc = Entry.getLoc();
2706 if (!DV.hasComplexAddress())
2708 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2710 // Complex address entry.
2711 unsigned N = DV.getNumAddrElements();
2713 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2714 if (Loc.getOffset()) {
2716 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2717 Asm->OutStreamer.AddComment("DW_OP_deref");
2718 Asm->EmitInt8(dwarf::DW_OP_deref);
2719 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2720 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2721 Asm->EmitSLEB128(DV.getAddrElement(1));
2723 // If first address element is OpPlus then emit
2724 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2725 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2726 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2730 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2733 // Emit remaining complex address elements.
2734 for (; i < N; ++i) {
2735 uint64_t Element = DV.getAddrElement(i);
2736 if (Element == DIBuilder::OpPlus) {
2737 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2738 Asm->EmitULEB128(DV.getAddrElement(++i));
2739 } else if (Element == DIBuilder::OpDeref) {
2741 Asm->EmitInt8(dwarf::DW_OP_deref);
2743 llvm_unreachable("unknown Opcode found in complex address");
2747 // else ... ignore constant fp. There is not any good way to
2748 // to represent them here in dwarf.
2749 Asm->OutStreamer.EmitLabel(end);
2754 struct SymbolCUSorter {
2755 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2756 const MCStreamer &Streamer;
2758 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2759 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2760 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2762 // Symbols with no order assigned should be placed at the end.
2763 // (e.g. section end labels)
2765 IA = (unsigned)(-1);
2767 IB = (unsigned)(-1);
2772 static bool CUSort(const Unit *A, const Unit *B) {
2773 return (A->getUniqueID() < B->getUniqueID());
2777 const MCSymbol *Start, *End;
2780 // Emit a debug aranges section, containing a CU lookup for any
2781 // address we can tie back to a CU.
2782 void DwarfDebug::emitDebugARanges() {
2783 // Start the dwarf aranges section.
2784 Asm->OutStreamer.SwitchSection(
2785 Asm->getObjFileLowering().getDwarfARangesSection());
2787 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2791 // Build a list of sections used.
2792 std::vector<const MCSection *> Sections;
2793 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2795 const MCSection *Section = it->first;
2796 Sections.push_back(Section);
2799 // Sort the sections into order.
2800 // This is only done to ensure consistent output order across different runs.
2801 std::sort(Sections.begin(), Sections.end(), SectionSort);
2803 // Build a set of address spans, sorted by CU.
2804 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2805 const MCSection *Section = Sections[SecIdx];
2806 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2807 if (List.size() < 2)
2810 // Sort the symbols by offset within the section.
2811 SymbolCUSorter sorter(Asm->OutStreamer);
2812 std::sort(List.begin(), List.end(), sorter);
2814 // If we have no section (e.g. common), just write out
2815 // individual spans for each symbol.
2816 if (Section == NULL) {
2817 for (size_t n = 0; n < List.size(); n++) {
2818 const SymbolCU &Cur = List[n];
2821 Span.Start = Cur.Sym;
2824 Spans[Cur.CU].push_back(Span);
2827 // Build spans between each label.
2828 const MCSymbol *StartSym = List[0].Sym;
2829 for (size_t n = 1; n < List.size(); n++) {
2830 const SymbolCU &Prev = List[n - 1];
2831 const SymbolCU &Cur = List[n];
2833 // Try and build the longest span we can within the same CU.
2834 if (Cur.CU != Prev.CU) {
2836 Span.Start = StartSym;
2838 Spans[Prev.CU].push_back(Span);
2845 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2846 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2848 // Build a list of CUs used.
2849 std::vector<CompileUnit *> CUs;
2850 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2851 CompileUnit *CU = it->first;
2855 // Sort the CU list (again, to ensure consistent output order).
2856 std::sort(CUs.begin(), CUs.end(), CUSort);
2858 // Emit an arange table for each CU we used.
2859 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2860 CompileUnit *CU = CUs[CUIdx];
2861 std::vector<ArangeSpan> &List = Spans[CU];
2863 // Emit size of content not including length itself.
2864 unsigned ContentSize =
2865 sizeof(int16_t) + // DWARF ARange version number
2866 sizeof(int32_t) + // Offset of CU in the .debug_info section
2867 sizeof(int8_t) + // Pointer Size (in bytes)
2868 sizeof(int8_t); // Segment Size (in bytes)
2870 unsigned TupleSize = PtrSize * 2;
2872 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2873 unsigned Padding = 0;
2874 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2877 ContentSize += Padding;
2878 ContentSize += (List.size() + 1) * TupleSize;
2880 // For each compile unit, write the list of spans it covers.
2881 Asm->OutStreamer.AddComment("Length of ARange Set");
2882 Asm->EmitInt32(ContentSize);
2883 Asm->OutStreamer.AddComment("DWARF Arange version number");
2884 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2885 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2886 Asm->EmitSectionOffset(
2887 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2888 DwarfInfoSectionSym);
2889 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2890 Asm->EmitInt8(PtrSize);
2891 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2894 for (unsigned n = 0; n < Padding; n++)
2895 Asm->EmitInt8(0xff);
2897 for (unsigned n = 0; n < List.size(); n++) {
2898 const ArangeSpan &Span = List[n];
2899 Asm->EmitLabelReference(Span.Start, PtrSize);
2901 // Calculate the size as being from the span start to it's end.
2903 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2905 // For symbols without an end marker (e.g. common), we
2906 // write a single arange entry containing just that one symbol.
2907 uint64_t Size = SymSize[Span.Start];
2911 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2915 Asm->OutStreamer.AddComment("ARange terminator");
2916 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2917 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2921 // Emit visible names into a debug ranges section.
2922 void DwarfDebug::emitDebugRanges() {
2923 // Start the dwarf ranges section.
2924 Asm->OutStreamer.SwitchSection(
2925 Asm->getObjFileLowering().getDwarfRangesSection());
2927 // Size for our labels.
2928 unsigned char Size = Asm->getDataLayout().getPointerSize();
2930 // Grab the specific ranges for the compile units in the module.
2931 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2934 CompileUnit *TheCU = I->second;
2935 unsigned ID = TheCU->getUniqueID();
2937 // Emit a symbol so we can find the beginning of our ranges.
2938 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_ranges", ID));
2940 // Iterate over the misc ranges for the compile units in the module.
2941 const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
2942 for (SmallVectorImpl<RangeSpanList>::const_iterator
2943 I = RangeLists.begin(),
2944 E = RangeLists.end();
2946 const RangeSpanList &List = *I;
2948 // Emit a symbol so we can find the beginning of the range.
2949 Asm->OutStreamer.EmitLabel(
2950 Asm->GetTempSymbol("debug_ranges", List.getIndex()));
2952 for (SmallVectorImpl<RangeSpan>::const_iterator
2953 RI = List.getRanges().begin(),
2954 RE = List.getRanges().end();
2956 const RangeSpan &Range = *RI;
2957 // We occasionally have ranges without begin/end labels.
2958 // FIXME: Verify and fix.
2959 const MCSymbol *Begin = Range.getStart();
2960 const MCSymbol *End = Range.getEnd();
2961 Begin ? Asm->OutStreamer.EmitSymbolValue(Begin, Size)
2962 : Asm->OutStreamer.EmitIntValue(0, Size);
2963 End ? Asm->OutStreamer.EmitSymbolValue(End, Size)
2964 : Asm->OutStreamer.EmitIntValue(0, Size);
2967 // And terminate the list with two 0 values.
2968 Asm->OutStreamer.EmitIntValue(0, Size);
2969 Asm->OutStreamer.EmitIntValue(0, Size);
2974 // Emit visible names into a debug macinfo section.
2975 void DwarfDebug::emitDebugMacInfo() {
2976 if (const MCSection *LineInfo =
2977 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2978 // Start the dwarf macinfo section.
2979 Asm->OutStreamer.SwitchSection(LineInfo);
2983 // DWARF5 Experimental Separate Dwarf emitters.
2985 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2986 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2987 // DW_AT_ranges_base, DW_AT_addr_base.
2988 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2990 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2991 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2992 Asm, this, &SkeletonHolder);
2994 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2995 CU->getNode().getSplitDebugFilename());
2997 // Relocate to the beginning of the addr_base section, else 0 for the
2998 // beginning of the one for this compile unit.
2999 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3000 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
3001 DwarfAddrSectionSym);
3003 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3005 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
3006 // into an entity. We're using 0, or a NULL label for this.
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,
3014 DwarfLineSectionSym);
3016 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3018 if (!CompilationDir.empty())
3019 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3021 // Flags to let the linker know we have emitted new style pubnames.
3022 if (GenerateGnuPubSections) {
3023 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3024 NewCU->addSectionLabel(
3025 Die, dwarf::DW_AT_GNU_pubnames,
3026 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
3028 NewCU->addSectionDelta(
3029 Die, dwarf::DW_AT_GNU_pubnames,
3030 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
3031 DwarfGnuPubNamesSectionSym);
3033 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3034 NewCU->addSectionLabel(
3035 Die, dwarf::DW_AT_GNU_pubtypes,
3036 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
3038 NewCU->addSectionDelta(
3039 Die, dwarf::DW_AT_GNU_pubtypes,
3040 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
3041 DwarfGnuPubTypesSectionSym);
3044 // Attribute if we've emitted any ranges and their location for the compile unit.
3045 if (!CU->getRangeLists().empty()) {
3046 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3047 NewCU->addSectionLabel(
3048 Die, dwarf::DW_AT_GNU_ranges_base,
3049 Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()));
3051 NewCU->addSectionDelta(
3052 Die, dwarf::DW_AT_GNU_ranges_base,
3053 Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()),
3054 DwarfDebugRangeSectionSym);
3057 SkeletonHolder.addUnit(NewCU);
3062 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
3063 assert(useSplitDwarf() && "No split dwarf debug info?");
3064 emitAbbrevs(Section, &SkeletonAbbrevs);
3067 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3068 // compile units that would normally be in debug_info.
3069 void DwarfDebug::emitDebugInfoDWO() {
3070 assert(useSplitDwarf() && "No split dwarf debug info?");
3071 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3072 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3073 DwarfAbbrevDWOSectionSym);
3076 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3077 // abbreviations for the .debug_info.dwo section.
3078 void DwarfDebug::emitDebugAbbrevDWO() {
3079 assert(useSplitDwarf() && "No split dwarf?");
3080 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3084 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3085 // string section and is identical in format to traditional .debug_str
3087 void DwarfDebug::emitDebugStrDWO() {
3088 assert(useSplitDwarf() && "No split dwarf?");
3089 const MCSection *OffSec =
3090 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3091 const MCSymbol *StrSym = DwarfStrSectionSym;
3092 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3096 void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
3097 DICompositeType CTy) {
3098 DenseMap<const MDNode *,
3099 std::pair<uint64_t, SmallVectorImpl<DIE *> *> >::iterator I =
3100 TypeUnits.find(CTy);
3101 SmallVector<DIE *, 8> References;
3102 References.push_back(RefDie);
3103 if (I != TypeUnits.end()) {
3104 if (I->second.second) {
3105 I->second.second->push_back(RefDie);
3109 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3110 TypeUnit *NewTU = new TypeUnit(GlobalCUIndexCount++, UnitDie, Language, Asm,
3112 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3115 // Register the type in the TypeUnits map with a vector of references to be
3116 // populated whenever a reference is required.
3117 I = TypeUnits.insert(std::make_pair(CTy, std::make_pair(0, &References)))
3120 // Construct the type, this may, recursively, require more type units that
3121 // may in turn require this type again - in which case they will add DIEs to
3122 // the References vector.
3123 DIE *Die = NewTU->createTypeDIE(CTy);
3125 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3126 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3127 dwarf::DW_FORM_data8,
3128 DIEHash().computeDIEODRSignature(*Die));
3129 // FIXME: This won't handle circularly referential structures, as the DIE
3130 // may have references to other DIEs still under construction and missing
3131 // their signature. Hashing should walk through the signatures to their
3132 // referenced type, or possibly walk the precomputed hashes of related types
3134 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3136 // Remove the References vector and add the type hash.
3137 I->second.first = Signature;
3138 I->second.second = NULL;
3140 InfoHolder.addUnit(NewTU);
3143 // Populate all the signatures.
3144 for (unsigned i = 0, e = References.size(); i != e; ++i) {
3145 CUMap.begin()->second->addUInt(References[i], dwarf::DW_AT_signature,
3146 dwarf::DW_FORM_ref_sig8, I->second.first);