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 = new RangeSpanList(GlobalRangeCount++);
475 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
478 RangeSpan Span(getLabelBeforeInsn(RI->first),
479 getLabelAfterInsn(RI->second));
480 List->addRange(Span);
483 // Add the range list to the set of ranges to be emitted.
484 TheCU->addRangeList(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() == false &&
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 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2190 Asm->OutStreamer.EmitLabel(Begin);
2192 // For each abbrevation.
2193 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2194 // Get abbreviation data
2195 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2197 // Emit the abbrevations code (base 1 index.)
2198 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2200 // Emit the abbreviations data.
2204 // Mark end of abbreviations.
2205 Asm->EmitULEB128(0, "EOM(3)");
2207 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2208 Asm->OutStreamer.EmitLabel(End);
2212 // Emit the last address of the section and the end of the line matrix.
2213 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2214 // Define last address of section.
2215 Asm->OutStreamer.AddComment("Extended Op");
2218 Asm->OutStreamer.AddComment("Op size");
2219 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2220 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2221 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2223 Asm->OutStreamer.AddComment("Section end label");
2225 Asm->OutStreamer.EmitSymbolValue(
2226 Asm->GetTempSymbol("section_end", SectionEnd),
2227 Asm->getDataLayout().getPointerSize());
2229 // Mark end of matrix.
2230 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2236 // Emit visible names into a hashed accelerator table section.
2237 void DwarfDebug::emitAccelNames() {
2239 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2240 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2241 E = getUnits().end();
2244 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2245 for (StringMap<std::vector<const DIE *> >::const_iterator
2249 StringRef Name = GI->getKey();
2250 const std::vector<const DIE *> &Entities = GI->second;
2251 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2252 DE = Entities.end();
2254 AT.AddName(Name, *DI);
2258 AT.FinalizeTable(Asm, "Names");
2259 Asm->OutStreamer.SwitchSection(
2260 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2261 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2262 Asm->OutStreamer.EmitLabel(SectionBegin);
2264 // Emit the full data.
2265 AT.Emit(Asm, SectionBegin, &InfoHolder);
2268 // Emit objective C classes and categories into a hashed accelerator table
2270 void DwarfDebug::emitAccelObjC() {
2272 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2273 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2274 E = getUnits().end();
2277 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2278 for (StringMap<std::vector<const DIE *> >::const_iterator
2282 StringRef Name = GI->getKey();
2283 const std::vector<const DIE *> &Entities = GI->second;
2284 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2285 DE = Entities.end();
2287 AT.AddName(Name, *DI);
2291 AT.FinalizeTable(Asm, "ObjC");
2292 Asm->OutStreamer.SwitchSection(
2293 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2294 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2295 Asm->OutStreamer.EmitLabel(SectionBegin);
2297 // Emit the full data.
2298 AT.Emit(Asm, SectionBegin, &InfoHolder);
2301 // Emit namespace dies into a hashed accelerator table.
2302 void DwarfDebug::emitAccelNamespaces() {
2304 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2305 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2306 E = getUnits().end();
2309 const StringMap<std::vector<const DIE *> > &Names =
2310 TheU->getAccelNamespace();
2311 for (StringMap<std::vector<const DIE *> >::const_iterator
2315 StringRef Name = GI->getKey();
2316 const std::vector<const DIE *> &Entities = GI->second;
2317 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2318 DE = Entities.end();
2320 AT.AddName(Name, *DI);
2324 AT.FinalizeTable(Asm, "namespac");
2325 Asm->OutStreamer.SwitchSection(
2326 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2327 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2328 Asm->OutStreamer.EmitLabel(SectionBegin);
2330 // Emit the full data.
2331 AT.Emit(Asm, SectionBegin, &InfoHolder);
2334 // Emit type dies into a hashed accelerator table.
2335 void DwarfDebug::emitAccelTypes() {
2336 std::vector<DwarfAccelTable::Atom> Atoms;
2338 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2340 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2342 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2343 DwarfAccelTable AT(Atoms);
2344 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2345 E = getUnits().end();
2348 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2349 TheU->getAccelTypes();
2351 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2355 StringRef Name = GI->getKey();
2356 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2358 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2359 DI = Entities.begin(),
2360 DE = Entities.end();
2362 AT.AddName(Name, DI->first, DI->second);
2366 AT.FinalizeTable(Asm, "types");
2367 Asm->OutStreamer.SwitchSection(
2368 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2369 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2370 Asm->OutStreamer.EmitLabel(SectionBegin);
2372 // Emit the full data.
2373 AT.Emit(Asm, SectionBegin, &InfoHolder);
2376 // Public name handling.
2377 // The format for the various pubnames:
2379 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2380 // for the DIE that is named.
2382 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2383 // into the CU and the index value is computed according to the type of value
2384 // for the DIE that is named.
2386 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2387 // it's the offset within the debug_info/debug_types dwo section, however, the
2388 // reference in the pubname header doesn't change.
2390 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2391 static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
2393 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2395 // We could have a specification DIE that has our most of our knowledge,
2396 // look for that now.
2397 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2399 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2400 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2401 Linkage = dwarf::GIEL_EXTERNAL;
2402 } else if (Die->findAttribute(dwarf::DW_AT_external))
2403 Linkage = dwarf::GIEL_EXTERNAL;
2405 switch (Die->getTag()) {
2406 case dwarf::DW_TAG_class_type:
2407 case dwarf::DW_TAG_structure_type:
2408 case dwarf::DW_TAG_union_type:
2409 case dwarf::DW_TAG_enumeration_type:
2410 return dwarf::PubIndexEntryDescriptor(
2411 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2412 ? dwarf::GIEL_STATIC
2413 : dwarf::GIEL_EXTERNAL);
2414 case dwarf::DW_TAG_typedef:
2415 case dwarf::DW_TAG_base_type:
2416 case dwarf::DW_TAG_subrange_type:
2417 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2418 case dwarf::DW_TAG_namespace:
2419 return dwarf::GIEK_TYPE;
2420 case dwarf::DW_TAG_subprogram:
2421 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2422 case dwarf::DW_TAG_constant:
2423 case dwarf::DW_TAG_variable:
2424 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2425 case dwarf::DW_TAG_enumerator:
2426 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2427 dwarf::GIEL_STATIC);
2429 return dwarf::GIEK_NONE;
2433 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2435 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2436 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2437 const MCSection *PSec =
2438 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2439 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2441 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2442 E = getUnits().end();
2445 unsigned ID = TheU->getUniqueID();
2447 // Start the dwarf pubnames section.
2448 Asm->OutStreamer.SwitchSection(PSec);
2450 // Emit a label so we can reference the beginning of this pubname section.
2452 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
2455 Asm->OutStreamer.AddComment("Length of Public Names Info");
2456 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
2457 MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
2458 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2460 Asm->OutStreamer.EmitLabel(BeginLabel);
2462 Asm->OutStreamer.AddComment("DWARF Version");
2463 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2465 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2466 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2467 DwarfInfoSectionSym);
2469 Asm->OutStreamer.AddComment("Compilation Unit Length");
2470 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2471 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2474 // Emit the pubnames for this compilation unit.
2475 const StringMap<const DIE *> &Globals = TheU->getGlobalNames();
2476 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2479 const char *Name = GI->getKeyData();
2480 const DIE *Entity = GI->second;
2482 Asm->OutStreamer.AddComment("DIE offset");
2483 Asm->EmitInt32(Entity->getOffset());
2486 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2487 Asm->OutStreamer.AddComment(
2488 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2489 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2490 Asm->EmitInt8(Desc.toBits());
2493 if (Asm->isVerbose())
2494 Asm->OutStreamer.AddComment("External Name");
2495 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2498 Asm->OutStreamer.AddComment("End Mark");
2500 Asm->OutStreamer.EmitLabel(EndLabel);
2504 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2505 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2506 const MCSection *PSec =
2507 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2508 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2510 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2511 E = getUnits().end();
2514 unsigned ID = TheU->getUniqueID();
2516 // Start the dwarf pubtypes section.
2517 Asm->OutStreamer.SwitchSection(PSec);
2519 // Emit a label so we can reference the beginning of this pubtype section.
2521 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
2524 Asm->OutStreamer.AddComment("Length of Public Types Info");
2525 MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
2526 MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
2527 Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
2529 Asm->OutStreamer.EmitLabel(BeginLabel);
2531 if (Asm->isVerbose())
2532 Asm->OutStreamer.AddComment("DWARF Version");
2533 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2535 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2536 Asm->EmitSectionOffset(
2537 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()),
2538 DwarfInfoSectionSym);
2540 Asm->OutStreamer.AddComment("Compilation Unit Length");
2541 Asm->EmitLabelDifference(
2542 Asm->GetTempSymbol(ISec->getLabelEndName(), TheU->getUniqueID()),
2543 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()), 4);
2545 // Emit the pubtypes.
2546 const StringMap<const DIE *> &Globals = TheU->getGlobalTypes();
2547 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2550 const char *Name = GI->getKeyData();
2551 const DIE *Entity = GI->second;
2553 if (Asm->isVerbose())
2554 Asm->OutStreamer.AddComment("DIE offset");
2555 Asm->EmitInt32(Entity->getOffset());
2558 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2559 Asm->OutStreamer.AddComment(
2560 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2561 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2562 Asm->EmitInt8(Desc.toBits());
2565 if (Asm->isVerbose())
2566 Asm->OutStreamer.AddComment("External Name");
2568 // Emit the name with a terminating null byte.
2569 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2572 Asm->OutStreamer.AddComment("End Mark");
2574 Asm->OutStreamer.EmitLabel(EndLabel);
2578 // Emit strings into a string section.
2579 void DwarfUnits::emitStrings(const MCSection *StrSection,
2580 const MCSection *OffsetSection = NULL,
2581 const MCSymbol *StrSecSym = NULL) {
2583 if (StringPool.empty())
2586 // Start the dwarf str section.
2587 Asm->OutStreamer.SwitchSection(StrSection);
2589 // Get all of the string pool entries and put them in an array by their ID so
2590 // we can sort them.
2592 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2595 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2596 I = StringPool.begin(),
2597 E = StringPool.end();
2599 Entries.push_back(std::make_pair(I->second.second, &*I));
2601 array_pod_sort(Entries.begin(), Entries.end());
2603 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2604 // Emit a label for reference from debug information entries.
2605 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2607 // Emit the string itself with a terminating null byte.
2608 Asm->OutStreamer.EmitBytes(
2609 StringRef(Entries[i].second->getKeyData(),
2610 Entries[i].second->getKeyLength() + 1));
2613 // If we've got an offset section go ahead and emit that now as well.
2614 if (OffsetSection) {
2615 Asm->OutStreamer.SwitchSection(OffsetSection);
2616 unsigned offset = 0;
2617 unsigned size = 4; // FIXME: DWARF64 is 8.
2618 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2619 Asm->OutStreamer.EmitIntValue(offset, size);
2620 offset += Entries[i].second->getKeyLength() + 1;
2626 // Emit addresses into the section given.
2627 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2629 if (AddressPool.empty())
2632 // Start the dwarf addr section.
2633 Asm->OutStreamer.SwitchSection(AddrSection);
2635 // Order the address pool entries by ID
2636 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2638 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2639 E = AddressPool.end();
2641 Entries[I->second] = I->first;
2643 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2644 // Emit an expression for reference from debug information entries.
2645 if (const MCExpr *Expr = Entries[i])
2646 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2648 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2652 // Emit visible names into a debug str section.
2653 void DwarfDebug::emitDebugStr() {
2654 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2655 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2658 // Emit locations into the debug loc section.
2659 void DwarfDebug::emitDebugLoc() {
2660 if (DotDebugLocEntries.empty())
2663 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2664 I = DotDebugLocEntries.begin(),
2665 E = DotDebugLocEntries.end();
2667 DotDebugLocEntry &Entry = *I;
2668 if (I + 1 != DotDebugLocEntries.end())
2672 // Start the dwarf loc section.
2673 Asm->OutStreamer.SwitchSection(
2674 Asm->getObjFileLowering().getDwarfLocSection());
2675 unsigned char Size = Asm->getDataLayout().getPointerSize();
2676 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2678 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2679 I = DotDebugLocEntries.begin(),
2680 E = DotDebugLocEntries.end();
2681 I != E; ++I, ++index) {
2682 DotDebugLocEntry &Entry = *I;
2683 if (Entry.isMerged())
2685 if (Entry.isEmpty()) {
2686 Asm->OutStreamer.EmitIntValue(0, Size);
2687 Asm->OutStreamer.EmitIntValue(0, Size);
2688 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2690 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2691 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2692 DIVariable DV(Entry.getVariable());
2693 Asm->OutStreamer.AddComment("Loc expr size");
2694 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2695 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2696 Asm->EmitLabelDifference(end, begin, 2);
2697 Asm->OutStreamer.EmitLabel(begin);
2698 if (Entry.isInt()) {
2699 DIBasicType BTy(DV.getType());
2700 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2701 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2702 Asm->OutStreamer.AddComment("DW_OP_consts");
2703 Asm->EmitInt8(dwarf::DW_OP_consts);
2704 Asm->EmitSLEB128(Entry.getInt());
2706 Asm->OutStreamer.AddComment("DW_OP_constu");
2707 Asm->EmitInt8(dwarf::DW_OP_constu);
2708 Asm->EmitULEB128(Entry.getInt());
2710 } else if (Entry.isLocation()) {
2711 MachineLocation Loc = Entry.getLoc();
2712 if (!DV.hasComplexAddress())
2714 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2716 // Complex address entry.
2717 unsigned N = DV.getNumAddrElements();
2719 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2720 if (Loc.getOffset()) {
2722 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2723 Asm->OutStreamer.AddComment("DW_OP_deref");
2724 Asm->EmitInt8(dwarf::DW_OP_deref);
2725 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2726 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2727 Asm->EmitSLEB128(DV.getAddrElement(1));
2729 // If first address element is OpPlus then emit
2730 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2731 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2732 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2736 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2739 // Emit remaining complex address elements.
2740 for (; i < N; ++i) {
2741 uint64_t Element = DV.getAddrElement(i);
2742 if (Element == DIBuilder::OpPlus) {
2743 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2744 Asm->EmitULEB128(DV.getAddrElement(++i));
2745 } else if (Element == DIBuilder::OpDeref) {
2747 Asm->EmitInt8(dwarf::DW_OP_deref);
2749 llvm_unreachable("unknown Opcode found in complex address");
2753 // else ... ignore constant fp. There is not any good way to
2754 // to represent them here in dwarf.
2755 Asm->OutStreamer.EmitLabel(end);
2760 struct SymbolCUSorter {
2761 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2762 const MCStreamer &Streamer;
2764 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2765 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2766 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2768 // Symbols with no order assigned should be placed at the end.
2769 // (e.g. section end labels)
2771 IA = (unsigned)(-1);
2773 IB = (unsigned)(-1);
2778 static bool CUSort(const Unit *A, const Unit *B) {
2779 return (A->getUniqueID() < B->getUniqueID());
2783 const MCSymbol *Start, *End;
2786 // Emit a debug aranges section, containing a CU lookup for any
2787 // address we can tie back to a CU.
2788 void DwarfDebug::emitDebugARanges() {
2789 // Start the dwarf aranges section.
2790 Asm->OutStreamer.SwitchSection(
2791 Asm->getObjFileLowering().getDwarfARangesSection());
2793 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2797 // Build a list of sections used.
2798 std::vector<const MCSection *> Sections;
2799 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2801 const MCSection *Section = it->first;
2802 Sections.push_back(Section);
2805 // Sort the sections into order.
2806 // This is only done to ensure consistent output order across different runs.
2807 std::sort(Sections.begin(), Sections.end(), SectionSort);
2809 // Build a set of address spans, sorted by CU.
2810 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2811 const MCSection *Section = Sections[SecIdx];
2812 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2813 if (List.size() < 2)
2816 // Sort the symbols by offset within the section.
2817 SymbolCUSorter sorter(Asm->OutStreamer);
2818 std::sort(List.begin(), List.end(), sorter);
2820 // If we have no section (e.g. common), just write out
2821 // individual spans for each symbol.
2822 if (Section == NULL) {
2823 for (size_t n = 0; n < List.size(); n++) {
2824 const SymbolCU &Cur = List[n];
2827 Span.Start = Cur.Sym;
2830 Spans[Cur.CU].push_back(Span);
2833 // Build spans between each label.
2834 const MCSymbol *StartSym = List[0].Sym;
2835 for (size_t n = 1; n < List.size(); n++) {
2836 const SymbolCU &Prev = List[n - 1];
2837 const SymbolCU &Cur = List[n];
2839 // Try and build the longest span we can within the same CU.
2840 if (Cur.CU != Prev.CU) {
2842 Span.Start = StartSym;
2844 Spans[Prev.CU].push_back(Span);
2851 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2852 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2854 // Build a list of CUs used.
2855 std::vector<CompileUnit *> CUs;
2856 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2857 CompileUnit *CU = it->first;
2861 // Sort the CU list (again, to ensure consistent output order).
2862 std::sort(CUs.begin(), CUs.end(), CUSort);
2864 // Emit an arange table for each CU we used.
2865 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2866 CompileUnit *CU = CUs[CUIdx];
2867 std::vector<ArangeSpan> &List = Spans[CU];
2869 // Emit size of content not including length itself.
2870 unsigned ContentSize =
2871 sizeof(int16_t) + // DWARF ARange version number
2872 sizeof(int32_t) + // Offset of CU in the .debug_info section
2873 sizeof(int8_t) + // Pointer Size (in bytes)
2874 sizeof(int8_t); // Segment Size (in bytes)
2876 unsigned TupleSize = PtrSize * 2;
2878 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2879 unsigned Padding = 0;
2880 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2883 ContentSize += Padding;
2884 ContentSize += (List.size() + 1) * TupleSize;
2886 // For each compile unit, write the list of spans it covers.
2887 Asm->OutStreamer.AddComment("Length of ARange Set");
2888 Asm->EmitInt32(ContentSize);
2889 Asm->OutStreamer.AddComment("DWARF Arange version number");
2890 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2891 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2892 Asm->EmitSectionOffset(
2893 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2894 DwarfInfoSectionSym);
2895 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2896 Asm->EmitInt8(PtrSize);
2897 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2900 for (unsigned n = 0; n < Padding; n++)
2901 Asm->EmitInt8(0xff);
2903 for (unsigned n = 0; n < List.size(); n++) {
2904 const ArangeSpan &Span = List[n];
2905 Asm->EmitLabelReference(Span.Start, PtrSize);
2907 // Calculate the size as being from the span start to it's end.
2909 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2911 // For symbols without an end marker (e.g. common), we
2912 // write a single arange entry containing just that one symbol.
2913 uint64_t Size = SymSize[Span.Start];
2917 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2921 Asm->OutStreamer.AddComment("ARange terminator");
2922 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2923 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2927 // Emit visible names into a debug ranges section.
2928 void DwarfDebug::emitDebugRanges() {
2929 // Start the dwarf ranges section.
2930 Asm->OutStreamer.SwitchSection(
2931 Asm->getObjFileLowering().getDwarfRangesSection());
2933 // Size for our labels.
2934 unsigned char Size = Asm->getDataLayout().getPointerSize();
2936 // Grab the specific ranges for the compile units in the module.
2937 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2940 CompileUnit *TheCU = I->second;
2941 unsigned ID = TheCU->getUniqueID();
2943 // Emit a symbol so we can find the beginning of our ranges.
2944 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_ranges", ID));
2946 // Iterate over the misc ranges for the compile units in the module.
2947 const SmallVectorImpl<RangeSpanList *> &RangeLists = TheCU->getRangeLists();
2948 for (SmallVectorImpl<RangeSpanList *>::const_iterator
2949 I = RangeLists.begin(),
2950 E = RangeLists.end();
2952 RangeSpanList *List = *I;
2954 // Emit a symbol so we can find the beginning of the range.
2955 Asm->OutStreamer.EmitLabel(
2956 Asm->GetTempSymbol("debug_ranges", List->getIndex()));
2958 for (SmallVectorImpl<RangeSpan>::const_iterator
2959 I = List->getRanges().begin(),
2960 E = List->getRanges().end();
2962 RangeSpan Range = *I;
2963 // We occasionally have ranges without begin/end labels.
2964 // FIXME: Verify and fix.
2965 const MCSymbol *Begin = Range.getStart();
2966 const MCSymbol *End = Range.getEnd();
2967 Begin ? Asm->OutStreamer.EmitSymbolValue(Begin, Size)
2968 : Asm->OutStreamer.EmitIntValue(0, Size);
2969 End ? Asm->OutStreamer.EmitSymbolValue(End, Size)
2970 : Asm->OutStreamer.EmitIntValue(0, Size);
2973 // And terminate the list with two 0 values.
2974 Asm->OutStreamer.EmitIntValue(0, Size);
2975 Asm->OutStreamer.EmitIntValue(0, Size);
2980 // Emit visible names into a debug macinfo section.
2981 void DwarfDebug::emitDebugMacInfo() {
2982 if (const MCSection *LineInfo =
2983 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2984 // Start the dwarf macinfo section.
2985 Asm->OutStreamer.SwitchSection(LineInfo);
2989 // DWARF5 Experimental Separate Dwarf emitters.
2991 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2992 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2993 // DW_AT_ranges_base, DW_AT_addr_base.
2994 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2996 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2997 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2998 Asm, this, &SkeletonHolder);
3000 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
3001 CU->getNode().getSplitDebugFilename());
3003 // Relocate to the beginning of the addr_base section, else 0 for the
3004 // beginning of the one for this compile unit.
3005 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3006 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
3007 DwarfAddrSectionSym);
3009 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3011 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
3012 // into an entity. We're using 0, or a NULL label for this.
3013 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
3015 // DW_AT_stmt_list is a offset of line number information for this
3016 // compile unit in debug_line section.
3017 // FIXME: Should handle multiple compile units.
3018 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3019 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
3020 DwarfLineSectionSym);
3022 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3024 if (!CompilationDir.empty())
3025 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3027 // Flags to let the linker know we have emitted new style pubnames.
3028 if (GenerateGnuPubSections) {
3029 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3030 NewCU->addSectionLabel(
3031 Die, dwarf::DW_AT_GNU_pubnames,
3032 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
3034 NewCU->addSectionDelta(
3035 Die, dwarf::DW_AT_GNU_pubnames,
3036 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
3037 DwarfGnuPubNamesSectionSym);
3039 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3040 NewCU->addSectionLabel(
3041 Die, dwarf::DW_AT_GNU_pubtypes,
3042 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
3044 NewCU->addSectionDelta(
3045 Die, dwarf::DW_AT_GNU_pubtypes,
3046 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
3047 DwarfGnuPubTypesSectionSym);
3050 // Attribute if we've emitted any ranges and their location for the compile unit.
3051 if (CU->getRangeLists().size()) {
3052 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3053 NewCU->addSectionLabel(
3054 Die, dwarf::DW_AT_GNU_ranges_base,
3055 Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()));
3057 NewCU->addSectionDelta(
3058 Die, dwarf::DW_AT_GNU_ranges_base,
3059 Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()),
3060 DwarfDebugRangeSectionSym);
3063 SkeletonHolder.addUnit(NewCU);
3068 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
3069 assert(useSplitDwarf() && "No split dwarf debug info?");
3070 emitAbbrevs(Section, &SkeletonAbbrevs);
3073 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3074 // compile units that would normally be in debug_info.
3075 void DwarfDebug::emitDebugInfoDWO() {
3076 assert(useSplitDwarf() && "No split dwarf debug info?");
3077 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3078 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3079 DwarfAbbrevDWOSectionSym);
3082 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3083 // abbreviations for the .debug_info.dwo section.
3084 void DwarfDebug::emitDebugAbbrevDWO() {
3085 assert(useSplitDwarf() && "No split dwarf?");
3086 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3090 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3091 // string section and is identical in format to traditional .debug_str
3093 void DwarfDebug::emitDebugStrDWO() {
3094 assert(useSplitDwarf() && "No split dwarf?");
3095 const MCSection *OffSec =
3096 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3097 const MCSymbol *StrSym = DwarfStrSectionSym;
3098 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3102 void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
3103 DICompositeType CTy) {
3104 DenseMap<const MDNode *,
3105 std::pair<uint64_t, SmallVectorImpl<DIE *> *> >::iterator I =
3106 TypeUnits.find(CTy);
3107 SmallVector<DIE *, 8> References;
3108 References.push_back(RefDie);
3109 if (I != TypeUnits.end()) {
3110 if (I->second.second) {
3111 I->second.second->push_back(RefDie);
3115 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3116 TypeUnit *NewTU = new TypeUnit(GlobalCUIndexCount++, UnitDie, Language, Asm,
3118 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3121 // Register the type in the TypeUnits map with a vector of references to be
3122 // populated whenever a reference is required.
3123 I = TypeUnits.insert(std::make_pair(CTy, std::make_pair(0, &References)))
3126 // Construct the type, this may, recursively, require more type units that
3127 // may in turn require this type again - in which case they will add DIEs to
3128 // the References vector.
3129 DIE *Die = NewTU->createTypeDIE(CTy);
3131 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3132 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3133 dwarf::DW_FORM_data8,
3134 DIEHash().computeDIEODRSignature(*Die));
3135 // FIXME: This won't handle circularly referential structures, as the DIE
3136 // may have references to other DIEs still under construction and missing
3137 // their signature. Hashing should walk through the signatures to their
3138 // referenced type, or possibly walk the precomputed hashes of related types
3140 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3142 // Remove the References vector and add the type hash.
3143 I->second.first = Signature;
3144 I->second.second = NULL;
3146 InfoHolder.addUnit(NewTU);
3149 // Populate all the signatures.
3150 for (unsigned i = 0, e = References.size(); i != e; ++i) {
3151 CUMap.begin()->second->addUInt(References[i], dwarf::DW_AT_signature,
3152 dwarf::DW_FORM_ref_sig8, I->second.first);