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 MCSymbol *FuncBegin =
434 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
435 MCSymbol *FuncEnd = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
436 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FuncBegin);
437 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FuncEnd);
439 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
440 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
441 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
443 // Add name to the name table, we do this here because we're guaranteed
444 // to have concrete versions of our DW_TAG_subprogram nodes.
445 addSubprogramNames(SPCU, SP, SPDie);
450 /// Check whether we should create a DIE for the given Scope, return true
451 /// if we don't create a DIE (the corresponding DIE is null).
452 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
453 if (Scope->isAbstractScope())
456 // We don't create a DIE if there is no Range.
457 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
461 if (Ranges.size() > 1)
464 // We don't create a DIE if we have a single Range and the end label
466 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
467 MCSymbol *End = getLabelAfterInsn(RI->second);
471 void DwarfDebug::addScopeRangeList(CompileUnit *TheCU, DIE *ScopeDIE,
472 const SmallVectorImpl<InsnRange> &Range) {
473 // Emit offset in .debug_range as a relocatable label. emitDIE will handle
474 // emitting it appropriately.
475 TheCU->addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges,
476 Asm->GetTempSymbol("debug_ranges", GlobalRangeCount));
477 RangeSpanList *List = new RangeSpanList(GlobalRangeCount++);
478 for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
481 RangeSpan Span(getLabelBeforeInsn(RI->first),
482 getLabelAfterInsn(RI->second));
483 List->addRange(Span);
486 // Add the range list to the set of ranges to be emitted.
487 TheCU->addRangeList(List);
490 // Construct new DW_TAG_lexical_block for this scope and attach
491 // DW_AT_low_pc/DW_AT_high_pc labels.
492 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
493 LexicalScope *Scope) {
494 if (isLexicalScopeDIENull(Scope))
497 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
498 if (Scope->isAbstractScope())
501 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
503 // If we have multiple ranges, emit them into the range section.
504 if (ScopeRanges.size() > 1) {
505 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
509 // Construct the address range for this DIE.
510 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
511 MCSymbol *Start = getLabelBeforeInsn(RI->first);
512 MCSymbol *End = getLabelAfterInsn(RI->second);
513 assert(End && "End label should not be null!");
515 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
516 assert(End->isDefined() && "Invalid end label for an inlined scope!");
518 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
519 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
524 // This scope represents inlined body of a function. Construct DIE to
525 // represent this concrete inlined copy of the function.
526 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
527 LexicalScope *Scope) {
528 const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
529 assert(ScopeRanges.empty() == false &&
530 "LexicalScope does not have instruction markers!");
532 if (!Scope->getScopeNode())
534 DIScope DS(Scope->getScopeNode());
535 DISubprogram InlinedSP = getDISubprogram(DS);
536 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
538 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
542 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
543 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
545 // If we have multiple ranges, emit them into the range section.
546 if (ScopeRanges.size() > 1)
547 addScopeRangeList(TheCU, ScopeDIE, ScopeRanges);
549 SmallVectorImpl<InsnRange>::const_iterator RI = ScopeRanges.begin();
550 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
551 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
553 if (StartLabel == 0 || EndLabel == 0)
554 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
556 assert(StartLabel->isDefined() &&
557 "Invalid starting label for an inlined scope!");
558 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
560 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
561 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
564 InlinedSubprogramDIEs.insert(OriginDIE);
566 // Add the call site information to the DIE.
567 DILocation DL(Scope->getInlinedAt());
568 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
569 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
570 TheCU->getUniqueID()));
571 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
573 // Add name to the name table, we do this here because we're guaranteed
574 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
575 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
580 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
581 SmallVectorImpl<DIE *> &Children) {
582 DIE *ObjectPointer = NULL;
584 // Collect arguments for current function.
585 if (LScopes.isCurrentFunctionScope(Scope))
586 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
587 if (DbgVariable *ArgDV = CurrentFnArguments[i])
589 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
590 Children.push_back(Arg);
591 if (ArgDV->isObjectPointer())
595 // Collect lexical scope children first.
596 const SmallVectorImpl<DbgVariable *> &Variables =
597 ScopeVariables.lookup(Scope);
598 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
599 if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
600 Scope->isAbstractScope())) {
601 Children.push_back(Variable);
602 if (Variables[i]->isObjectPointer())
603 ObjectPointer = Variable;
605 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
606 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
607 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
608 Children.push_back(Nested);
609 return ObjectPointer;
612 // Construct a DIE for this scope.
613 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
614 if (!Scope || !Scope->getScopeNode())
617 DIScope DS(Scope->getScopeNode());
619 SmallVector<DIE *, 8> Children;
620 DIE *ObjectPointer = NULL;
621 bool ChildrenCreated = false;
623 // We try to create the scope DIE first, then the children DIEs. This will
624 // avoid creating un-used children then removing them later when we find out
625 // the scope DIE is null.
626 DIE *ScopeDIE = NULL;
627 if (Scope->getInlinedAt())
628 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
629 else if (DS.isSubprogram()) {
630 ProcessedSPNodes.insert(DS);
631 if (Scope->isAbstractScope()) {
632 ScopeDIE = TheCU->getDIE(DS);
633 // Note down abstract DIE.
635 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
637 ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
639 // Early exit when we know the scope DIE is going to be null.
640 if (isLexicalScopeDIENull(Scope))
643 // We create children here when we know the scope DIE is not going to be
644 // null and the children will be added to the scope DIE.
645 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
646 ChildrenCreated = true;
648 // There is no need to emit empty lexical block DIE.
649 std::pair<ImportedEntityMap::const_iterator,
650 ImportedEntityMap::const_iterator> Range =
652 ScopesWithImportedEntities.begin(),
653 ScopesWithImportedEntities.end(),
654 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
656 if (Children.empty() && Range.first == Range.second)
658 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
659 assert(ScopeDIE && "Scope DIE should not be null.");
660 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
662 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
666 assert(Children.empty() &&
667 "We create children only when the scope DIE is not null.");
670 if (!ChildrenCreated)
671 // We create children when the scope DIE is not null.
672 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
675 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
678 ScopeDIE->addChild(*I);
680 if (DS.isSubprogram() && ObjectPointer != NULL)
681 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
686 // Look up the source id with the given directory and source file names.
687 // If none currently exists, create a new id and insert it in the
688 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
690 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
692 // If we use .loc in assembly, we can't separate .file entries according to
693 // compile units. Thus all files will belong to the default compile unit.
695 // FIXME: add a better feature test than hasRawTextSupport. Even better,
696 // extend .file to support this.
697 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
700 // If FE did not provide a file name, then assume stdin.
701 if (FileName.empty())
702 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
704 // TODO: this might not belong here. See if we can factor this better.
705 if (DirName == CompilationDir)
708 // FileIDCUMap stores the current ID for the given compile unit.
709 unsigned SrcId = FileIDCUMap[CUID] + 1;
711 // We look up the CUID/file/dir by concatenating them with a zero byte.
712 SmallString<128> NamePair;
713 NamePair += utostr(CUID);
716 NamePair += '\0'; // Zero bytes are not allowed in paths.
717 NamePair += FileName;
719 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
720 if (Ent.getValue() != SrcId)
721 return Ent.getValue();
723 FileIDCUMap[CUID] = SrcId;
724 // Print out a .file directive to specify files for .loc directives.
725 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
730 // Create new CompileUnit for the given metadata node with tag
731 // DW_TAG_compile_unit.
732 CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
733 StringRef FN = DIUnit.getFilename();
734 CompilationDir = DIUnit.getDirectory();
736 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
737 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++, Die, DIUnit, Asm,
740 FileIDCUMap[NewCU->getUniqueID()] = 0;
741 // Call this to emit a .file directive if it wasn't emitted for the source
742 // file this CU comes from yet.
743 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
745 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
746 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
747 DIUnit.getLanguage());
748 NewCU->addString(Die, dwarf::DW_AT_name, FN);
750 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
751 // into an entity. We're using 0 (or a NULL label) for this. For
752 // split dwarf it's in the skeleton CU so omit it here.
753 if (!useSplitDwarf())
754 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
756 // Define start line table label for each Compile Unit.
757 MCSymbol *LineTableStartSym =
758 Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
759 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
760 NewCU->getUniqueID());
762 // Use a single line table if we are using .loc and generating assembly.
764 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
765 (NewCU->getUniqueID() == 0);
767 if (!useSplitDwarf()) {
768 // DW_AT_stmt_list is a offset of line number information for this
769 // compile unit in debug_line section. For split dwarf this is
770 // left in the skeleton CU and so not included.
771 // The line table entries are not always emitted in assembly, so it
772 // is not okay to use line_table_start here.
773 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
774 NewCU->addSectionLabel(
775 Die, dwarf::DW_AT_stmt_list,
776 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
777 : LineTableStartSym);
778 else if (UseTheFirstCU)
779 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
781 NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list,
782 LineTableStartSym, DwarfLineSectionSym);
784 // If we're using split dwarf the compilation dir is going to be in the
785 // skeleton CU and so we don't need to duplicate it here.
786 if (!CompilationDir.empty())
787 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
789 // Flags to let the linker know we have emitted new style pubnames. Only
790 // emit it here if we don't have a skeleton CU for split dwarf.
791 if (GenerateGnuPubSections) {
792 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
793 NewCU->addSectionLabel(
794 Die, dwarf::DW_AT_GNU_pubnames,
795 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
797 NewCU->addSectionDelta(
798 Die, dwarf::DW_AT_GNU_pubnames,
799 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
800 DwarfGnuPubNamesSectionSym);
802 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
803 NewCU->addSectionLabel(
804 Die, dwarf::DW_AT_GNU_pubtypes,
805 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
807 NewCU->addSectionDelta(
808 Die, dwarf::DW_AT_GNU_pubtypes,
809 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
810 DwarfGnuPubTypesSectionSym);
814 if (DIUnit.isOptimized())
815 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
817 StringRef Flags = DIUnit.getFlags();
819 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
821 if (unsigned RVer = DIUnit.getRunTimeVersion())
822 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
823 dwarf::DW_FORM_data1, RVer);
828 InfoHolder.addUnit(NewCU);
830 CUMap.insert(std::make_pair(DIUnit, NewCU));
831 CUDieMap.insert(std::make_pair(Die, NewCU));
835 // Construct subprogram DIE.
836 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
837 // FIXME: We should only call this routine once, however, during LTO if a
838 // program is defined in multiple CUs we could end up calling it out of
839 // beginModule as we walk the CUs.
841 CompileUnit *&CURef = SPMap[N];
847 if (!SP.isDefinition())
848 // This is a method declaration which will be handled while constructing
852 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
854 // Expose as a global name.
855 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
858 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
860 DIImportedEntity Module(N);
861 if (!Module.Verify())
863 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
864 constructImportedEntityDIE(TheCU, Module, D);
867 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
869 DIImportedEntity Module(N);
870 if (!Module.Verify())
872 return constructImportedEntityDIE(TheCU, Module, Context);
875 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
876 const DIImportedEntity &Module,
878 assert(Module.Verify() &&
879 "Use one of the MDNode * overloads to handle invalid metadata");
880 assert(Context && "Should always have a context for an imported_module");
881 DIE *IMDie = new DIE(Module.getTag());
882 TheCU->insertDIE(Module, IMDie);
884 DIDescriptor Entity = Module.getEntity();
885 if (Entity.isNameSpace())
886 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
887 else if (Entity.isSubprogram())
888 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
889 else if (Entity.isType())
890 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
892 EntityDie = TheCU->getDIE(Entity);
893 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
894 Module.getContext().getDirectory(),
895 TheCU->getUniqueID());
896 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
897 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
898 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
899 StringRef Name = Module.getName();
901 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
902 Context->addChild(IMDie);
905 // Emit all Dwarf sections that should come prior to the content. Create
906 // global DIEs and emit initial debug info sections. This is invoked by
907 // the target AsmPrinter.
908 void DwarfDebug::beginModule() {
909 if (DisableDebugInfoPrinting)
912 const Module *M = MMI->getModule();
914 // If module has named metadata anchors then use them, otherwise scan the
915 // module using debug info finder to collect debug info.
916 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
919 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
921 // Emit initial sections so we can reference labels later.
924 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
925 DICompileUnit CUNode(CU_Nodes->getOperand(i));
926 CompileUnit *CU = constructCompileUnit(CUNode);
927 DIArray ImportedEntities = CUNode.getImportedEntities();
928 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
929 ScopesWithImportedEntities.push_back(std::make_pair(
930 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
931 ImportedEntities.getElement(i)));
932 std::sort(ScopesWithImportedEntities.begin(),
933 ScopesWithImportedEntities.end(), less_first());
934 DIArray GVs = CUNode.getGlobalVariables();
935 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
936 CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
937 DIArray SPs = CUNode.getSubprograms();
938 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
939 constructSubprogramDIE(CU, SPs.getElement(i));
940 DIArray EnumTypes = CUNode.getEnumTypes();
941 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
942 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
943 DIArray RetainedTypes = CUNode.getRetainedTypes();
944 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
945 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
946 // Emit imported_modules last so that the relevant context is already
948 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
949 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
952 // Tell MMI that we have debug info.
953 MMI->setDebugInfoAvailability(true);
955 // Prime section data.
956 SectionMap[Asm->getObjFileLowering().getTextSection()];
959 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
960 void DwarfDebug::computeInlinedDIEs() {
961 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
962 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
963 AE = InlinedSubprogramDIEs.end();
966 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
968 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
969 AE = AbstractSPDies.end();
971 DIE *ISP = AI->second;
972 if (InlinedSubprogramDIEs.count(ISP))
974 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
978 // Collect info for variables that were optimized out.
979 void DwarfDebug::collectDeadVariables() {
980 const Module *M = MMI->getModule();
982 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
983 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
984 DICompileUnit TheCU(CU_Nodes->getOperand(i));
985 DIArray Subprograms = TheCU.getSubprograms();
986 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
987 DISubprogram SP(Subprograms.getElement(i));
988 if (ProcessedSPNodes.count(SP) != 0)
990 if (!SP.isSubprogram())
992 if (!SP.isDefinition())
994 DIArray Variables = SP.getVariables();
995 if (Variables.getNumElements() == 0)
998 // Construct subprogram DIE and add variables DIEs.
999 CompileUnit *SPCU = static_cast<CompileUnit *>(CUMap.lookup(TheCU));
1000 assert(SPCU && "Unable to find Compile Unit!");
1001 // FIXME: See the comment in constructSubprogramDIE about duplicate
1003 constructSubprogramDIE(SPCU, SP);
1004 DIE *SPDIE = SPCU->getDIE(SP);
1005 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1006 DIVariable DV(Variables.getElement(vi));
1007 if (!DV.isVariable())
1009 DbgVariable NewVar(DV, NULL, this);
1010 if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1011 SPDIE->addChild(VariableDIE);
1018 // Type Signature [7.27] and ODR Hash code.
1020 /// \brief Grabs the string in whichever attribute is passed in and returns
1021 /// a reference to it. Returns "" if the attribute doesn't exist.
1022 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1023 DIEValue *V = Die->findAttribute(Attr);
1025 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1026 return S->getString();
1028 return StringRef("");
1031 /// Return true if the current DIE is contained within an anonymous namespace.
1032 static bool isContainedInAnonNamespace(DIE *Die) {
1033 DIE *Parent = Die->getParent();
1036 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1037 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1039 Parent = Parent->getParent();
1045 /// Test if the current CU language is C++ and that we have
1046 /// a named type that is not contained in an anonymous namespace.
1047 static bool shouldAddODRHash(TypeUnit *CU, DIE *Die) {
1048 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1049 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1050 !isContainedInAnonNamespace(Die);
1053 void DwarfDebug::finalizeModuleInfo() {
1054 // Collect info for variables that were optimized out.
1055 collectDeadVariables();
1057 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1058 computeInlinedDIEs();
1060 // Handle anything that needs to be done on a per-cu basis.
1061 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
1062 E = getUnits().end();
1065 // Emit DW_AT_containing_type attribute to connect types with their
1066 // vtable holding type.
1067 TheU->constructContainingTypeDIEs();
1069 // If we're splitting the dwarf out now that we've got the entire
1070 // CU then construct a skeleton CU based upon it.
1071 if (useSplitDwarf() &&
1072 TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1074 if (GenerateCUHash) {
1076 ID = CUHash.computeCUSignature(*TheU->getUnitDie());
1078 // This should be a unique identifier when we want to build .dwp files.
1079 TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1080 dwarf::DW_FORM_data8, ID);
1081 // Now construct the skeleton CU associated.
1082 CompileUnit *SkCU = constructSkeletonCU(static_cast<CompileUnit *>(TheU));
1083 // This should be a unique identifier when we want to build .dwp files.
1084 SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
1085 dwarf::DW_FORM_data8, ID);
1089 // Compute DIE offsets and sizes.
1090 InfoHolder.computeSizeAndOffsets();
1091 if (useSplitDwarf())
1092 SkeletonHolder.computeSizeAndOffsets();
1095 void DwarfDebug::endSections() {
1096 // Filter labels by section.
1097 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1098 const SymbolCU &SCU = ArangeLabels[n];
1099 if (SCU.Sym->isInSection()) {
1100 // Make a note of this symbol and it's section.
1101 const MCSection *Section = &SCU.Sym->getSection();
1102 if (!Section->getKind().isMetadata())
1103 SectionMap[Section].push_back(SCU);
1105 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1106 // appear in the output. This sucks as we rely on sections to build
1107 // arange spans. We can do it without, but it's icky.
1108 SectionMap[NULL].push_back(SCU);
1112 // Build a list of sections used.
1113 std::vector<const MCSection *> Sections;
1114 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1116 const MCSection *Section = it->first;
1117 Sections.push_back(Section);
1120 // Sort the sections into order.
1121 // This is only done to ensure consistent output order across different runs.
1122 std::sort(Sections.begin(), Sections.end(), SectionSort);
1124 // Add terminating symbols for each section.
1125 for (unsigned ID = 0; ID < Sections.size(); ID++) {
1126 const MCSection *Section = Sections[ID];
1127 MCSymbol *Sym = NULL;
1130 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1131 // if we know the section name up-front. For user-created sections, the
1133 // label may not be valid to use as a label. (section names can use a
1135 // set of characters on some systems)
1136 Sym = Asm->GetTempSymbol("debug_end", ID);
1137 Asm->OutStreamer.SwitchSection(Section);
1138 Asm->OutStreamer.EmitLabel(Sym);
1141 // Insert a final terminator.
1142 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1146 // Emit all Dwarf sections that should come after the content.
1147 void DwarfDebug::endModule() {
1154 // End any existing sections.
1155 // TODO: Does this need to happen?
1158 // Finalize the debug info for the module.
1159 finalizeModuleInfo();
1163 // Emit all the DIEs into a debug info section.
1166 // Corresponding abbreviations into a abbrev section.
1167 emitAbbreviations();
1169 // Emit info into a debug loc section.
1172 // Emit info into a debug aranges section.
1175 // Emit info into a debug ranges section.
1178 // Emit info into a debug macinfo section.
1181 if (useSplitDwarf()) {
1184 emitDebugAbbrevDWO();
1185 // Emit DWO addresses.
1186 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1189 // Emit info into the dwarf accelerator table sections.
1190 if (useDwarfAccelTables()) {
1193 emitAccelNamespaces();
1197 // Emit the pubnames and pubtypes sections if requested.
1198 if (HasDwarfPubSections) {
1199 emitDebugPubNames(GenerateGnuPubSections);
1200 emitDebugPubTypes(GenerateGnuPubSections);
1206 // Reset these for the next Module if we have one.
1210 // Find abstract variable, if any, associated with Var.
1211 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1212 DebugLoc ScopeLoc) {
1213 LLVMContext &Ctx = DV->getContext();
1214 // More then one inlined variable corresponds to one abstract variable.
1215 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1216 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1218 return AbsDbgVariable;
1220 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1224 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1225 addScopeVariable(Scope, AbsDbgVariable);
1226 AbstractVariables[Var] = AbsDbgVariable;
1227 return AbsDbgVariable;
1230 // If Var is a current function argument then add it to CurrentFnArguments list.
1231 bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
1232 if (!LScopes.isCurrentFunctionScope(Scope))
1234 DIVariable DV = Var->getVariable();
1235 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1237 unsigned ArgNo = DV.getArgNumber();
1241 size_t Size = CurrentFnArguments.size();
1243 CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
1244 // llvm::Function argument size is not good indicator of how many
1245 // arguments does the function have at source level.
1247 CurrentFnArguments.resize(ArgNo * 2);
1248 CurrentFnArguments[ArgNo - 1] = Var;
1252 // Collect variable information from side table maintained by MMI.
1253 void DwarfDebug::collectVariableInfoFromMMITable(
1254 SmallPtrSet<const MDNode *, 16> &Processed) {
1255 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1256 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1259 const MDNode *Var = VI->first;
1262 Processed.insert(Var);
1264 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1266 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1268 // If variable scope is not found then skip this variable.
1272 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1273 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1274 RegVar->setFrameIndex(VP.first);
1275 if (!addCurrentFnArgument(RegVar, Scope))
1276 addScopeVariable(Scope, RegVar);
1278 AbsDbgVariable->setFrameIndex(VP.first);
1282 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1284 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1285 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1286 return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1287 MI->getOperand(0).getReg() &&
1288 (MI->getOperand(1).isImm() ||
1289 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1292 // Get .debug_loc entry for the instruction range starting at MI.
1293 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1294 const MCSymbol *FLabel,
1295 const MCSymbol *SLabel,
1296 const MachineInstr *MI) {
1297 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1299 assert(MI->getNumOperands() == 3);
1300 if (MI->getOperand(0).isReg()) {
1301 MachineLocation MLoc;
1302 // If the second operand is an immediate, this is a
1303 // register-indirect address.
1304 if (!MI->getOperand(1).isImm())
1305 MLoc.set(MI->getOperand(0).getReg());
1307 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1308 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1310 if (MI->getOperand(0).isImm())
1311 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1312 if (MI->getOperand(0).isFPImm())
1313 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1314 if (MI->getOperand(0).isCImm())
1315 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1317 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1320 // Find variables for each lexical scope.
1322 DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
1324 // Grab the variable info that was squirreled away in the MMI side-table.
1325 collectVariableInfoFromMMITable(Processed);
1327 for (SmallVectorImpl<const MDNode *>::const_iterator
1328 UVI = UserVariables.begin(),
1329 UVE = UserVariables.end();
1330 UVI != UVE; ++UVI) {
1331 const MDNode *Var = *UVI;
1332 if (Processed.count(Var))
1335 // History contains relevant DBG_VALUE instructions for Var and instructions
1337 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1338 if (History.empty())
1340 const MachineInstr *MInsn = History.front();
1343 LexicalScope *Scope = NULL;
1344 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1345 DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
1346 Scope = LScopes.getCurrentFunctionScope();
1347 else if (MDNode *IA = DV.getInlinedAt())
1348 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1350 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1351 // If variable scope is not found then skip this variable.
1355 Processed.insert(DV);
1356 assert(MInsn->isDebugValue() && "History must begin with debug value");
1357 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1358 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1359 if (!addCurrentFnArgument(RegVar, Scope))
1360 addScopeVariable(Scope, RegVar);
1362 AbsVar->setMInsn(MInsn);
1364 // Simplify ranges that are fully coalesced.
1365 if (History.size() <= 1 ||
1366 (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1367 RegVar->setMInsn(MInsn);
1371 // Handle multiple DBG_VALUE instructions describing one variable.
1372 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1374 for (SmallVectorImpl<const MachineInstr *>::const_iterator
1375 HI = History.begin(),
1378 const MachineInstr *Begin = *HI;
1379 assert(Begin->isDebugValue() && "Invalid History entry");
1381 // Check if DBG_VALUE is truncating a range.
1382 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1383 !Begin->getOperand(0).getReg())
1386 // Compute the range for a register location.
1387 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1388 const MCSymbol *SLabel = 0;
1391 // If Begin is the last instruction in History then its value is valid
1392 // until the end of the function.
1393 SLabel = FunctionEndSym;
1395 const MachineInstr *End = HI[1];
1396 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1397 << "\t" << *Begin << "\t" << *End << "\n");
1398 if (End->isDebugValue())
1399 SLabel = getLabelBeforeInsn(End);
1401 // End is a normal instruction clobbering the range.
1402 SLabel = getLabelAfterInsn(End);
1403 assert(SLabel && "Forgot label after clobber instruction");
1408 // The value is valid until the next DBG_VALUE or clobber.
1409 DotDebugLocEntries.push_back(
1410 getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1412 DotDebugLocEntries.push_back(DotDebugLocEntry());
1415 // Collect info for variables that were optimized out.
1416 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1417 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1418 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1419 DIVariable DV(Variables.getElement(i));
1420 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1422 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1423 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1427 // Return Label preceding the instruction.
1428 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1429 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1430 assert(Label && "Didn't insert label before instruction");
1434 // Return Label immediately following the instruction.
1435 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1436 return LabelsAfterInsn.lookup(MI);
1439 // Process beginning of an instruction.
1440 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1443 // Check if source location changes, but ignore DBG_VALUE locations.
1444 if (!MI->isDebugValue()) {
1445 DebugLoc DL = MI->getDebugLoc();
1446 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1449 if (DL == PrologEndLoc) {
1450 Flags |= DWARF2_FLAG_PROLOGUE_END;
1451 PrologEndLoc = DebugLoc();
1453 if (PrologEndLoc.isUnknown())
1454 Flags |= DWARF2_FLAG_IS_STMT;
1456 if (!DL.isUnknown()) {
1457 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1458 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1460 recordSourceLine(0, 0, 0, 0);
1464 // Insert labels where requested.
1465 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1466 LabelsBeforeInsn.find(MI);
1469 if (I == LabelsBeforeInsn.end())
1472 // Label already assigned.
1477 PrevLabel = MMI->getContext().CreateTempSymbol();
1478 Asm->OutStreamer.EmitLabel(PrevLabel);
1480 I->second = PrevLabel;
1483 // Process end of an instruction.
1484 void DwarfDebug::endInstruction() {
1486 // Don't create a new label after DBG_VALUE instructions.
1487 // They don't generate code.
1488 if (!CurMI->isDebugValue())
1491 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1492 LabelsAfterInsn.find(CurMI);
1496 if (I == LabelsAfterInsn.end())
1499 // Label already assigned.
1503 // We need a label after this instruction.
1505 PrevLabel = MMI->getContext().CreateTempSymbol();
1506 Asm->OutStreamer.EmitLabel(PrevLabel);
1508 I->second = PrevLabel;
1511 // Each LexicalScope has first instruction and last instruction to mark
1512 // beginning and end of a scope respectively. Create an inverse map that list
1513 // scopes starts (and ends) with an instruction. One instruction may start (or
1514 // end) multiple scopes. Ignore scopes that are not reachable.
1515 void DwarfDebug::identifyScopeMarkers() {
1516 SmallVector<LexicalScope *, 4> WorkList;
1517 WorkList.push_back(LScopes.getCurrentFunctionScope());
1518 while (!WorkList.empty()) {
1519 LexicalScope *S = WorkList.pop_back_val();
1521 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1522 if (!Children.empty())
1523 for (SmallVectorImpl<LexicalScope *>::const_iterator
1524 SI = Children.begin(),
1525 SE = Children.end();
1527 WorkList.push_back(*SI);
1529 if (S->isAbstractScope())
1532 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1535 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1538 assert(RI->first && "InsnRange does not have first instruction!");
1539 assert(RI->second && "InsnRange does not have second instruction!");
1540 requestLabelBeforeInsn(RI->first);
1541 requestLabelAfterInsn(RI->second);
1546 // Get MDNode for DebugLoc's scope.
1547 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1548 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1549 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1550 return DL.getScope(Ctx);
1553 // Walk up the scope chain of given debug loc and find line number info
1554 // for the function.
1555 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1556 const MDNode *Scope = getScopeNode(DL, Ctx);
1557 DISubprogram SP = getDISubprogram(Scope);
1558 if (SP.isSubprogram()) {
1559 // Check for number of operands since the compatibility is
1561 if (SP->getNumOperands() > 19)
1562 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1564 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1570 // Gather pre-function debug information. Assumes being called immediately
1571 // after the function entry point has been emitted.
1572 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1575 // If there's no debug info for the function we're not going to do anything.
1576 if (!MMI->hasDebugInfo())
1579 // Grab the lexical scopes for the function, if we don't have any of those
1580 // then we're not going to be able to do anything.
1581 LScopes.initialize(*MF);
1582 if (LScopes.empty())
1585 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1587 // Make sure that each lexical scope will have a begin/end label.
1588 identifyScopeMarkers();
1590 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1591 // belongs to so that we add to the correct per-cu line table in the
1593 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1594 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1595 assert(TheCU && "Unable to find compile unit!");
1596 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1597 // Use a single line table if we are using .loc and generating assembly.
1598 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1600 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1602 // Emit a label for the function so that we have a beginning address.
1603 FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1604 // Assumes in correct section after the entry point.
1605 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1607 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1608 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1609 std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1611 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1613 bool AtBlockEntry = true;
1614 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1616 const MachineInstr *MI = II;
1618 if (MI->isDebugValue()) {
1619 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1621 // Keep track of user variables.
1623 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1625 // Variable is in a register, we need to check for clobbers.
1626 if (isDbgValueInDefinedReg(MI))
1627 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1629 // Check the history of this variable.
1630 SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1631 if (History.empty()) {
1632 UserVariables.push_back(Var);
1633 // The first mention of a function argument gets the FunctionBeginSym
1634 // label, so arguments are visible when breaking at function entry.
1636 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1637 getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1638 LabelsBeforeInsn[MI] = FunctionBeginSym;
1640 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1641 const MachineInstr *Prev = History.back();
1642 if (Prev->isDebugValue()) {
1643 // Coalesce identical entries at the end of History.
1644 if (History.size() >= 2 &&
1645 Prev->isIdenticalTo(History[History.size() - 2])) {
1646 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1647 << "\t" << *Prev << "\t"
1648 << *History[History.size() - 2] << "\n");
1652 // Terminate old register assignments that don't reach MI;
1653 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1654 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1655 isDbgValueInDefinedReg(Prev)) {
1656 // Previous register assignment needs to terminate at the end of
1658 MachineBasicBlock::const_iterator LastMI =
1659 PrevMBB->getLastNonDebugInstr();
1660 if (LastMI == PrevMBB->end()) {
1661 // Drop DBG_VALUE for empty range.
1662 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1663 << "\t" << *Prev << "\n");
1665 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1666 // Terminate after LastMI.
1667 History.push_back(LastMI);
1671 History.push_back(MI);
1673 // Not a DBG_VALUE instruction.
1675 AtBlockEntry = false;
1677 // First known non-DBG_VALUE and non-frame setup location marks
1678 // the beginning of the function body.
1679 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1680 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1681 PrologEndLoc = MI->getDebugLoc();
1683 // Check if the instruction clobbers any registers with debug vars.
1684 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1685 MOE = MI->operands_end();
1686 MOI != MOE; ++MOI) {
1687 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1689 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1692 const MDNode *Var = LiveUserVar[Reg];
1695 // Reg is now clobbered.
1696 LiveUserVar[Reg] = 0;
1698 // Was MD last defined by a DBG_VALUE referring to Reg?
1699 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1700 if (HistI == DbgValues.end())
1702 SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1703 if (History.empty())
1705 const MachineInstr *Prev = History.back();
1706 // Sanity-check: Register assignments are terminated at the end of
1708 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1710 // Is the variable still in Reg?
1711 if (!isDbgValueInDefinedReg(Prev) ||
1712 Prev->getOperand(0).getReg() != Reg)
1714 // Var is clobbered. Make sure the next instruction gets a label.
1715 History.push_back(MI);
1722 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1724 SmallVectorImpl<const MachineInstr *> &History = I->second;
1725 if (History.empty())
1728 // Make sure the final register assignments are terminated.
1729 const MachineInstr *Prev = History.back();
1730 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1731 const MachineBasicBlock *PrevMBB = Prev->getParent();
1732 MachineBasicBlock::const_iterator LastMI =
1733 PrevMBB->getLastNonDebugInstr();
1734 if (LastMI == PrevMBB->end())
1735 // Drop DBG_VALUE for empty range.
1737 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1738 // Terminate after LastMI.
1739 History.push_back(LastMI);
1742 // Request labels for the full history.
1743 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1744 const MachineInstr *MI = History[i];
1745 if (MI->isDebugValue())
1746 requestLabelBeforeInsn(MI);
1748 requestLabelAfterInsn(MI);
1752 PrevInstLoc = DebugLoc();
1753 PrevLabel = FunctionBeginSym;
1755 // Record beginning of function.
1756 if (!PrologEndLoc.isUnknown()) {
1757 DebugLoc FnStartDL =
1758 getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1760 FnStartDL.getLine(), FnStartDL.getCol(),
1761 FnStartDL.getScope(MF->getFunction()->getContext()),
1762 // We'd like to list the prologue as "not statements" but GDB behaves
1763 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1764 DWARF2_FLAG_IS_STMT);
1768 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1769 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1770 DIVariable DV = Var->getVariable();
1771 // Variables with positive arg numbers are parameters.
1772 if (unsigned ArgNum = DV.getArgNumber()) {
1773 // Keep all parameters in order at the start of the variable list to ensure
1774 // function types are correct (no out-of-order parameters)
1776 // This could be improved by only doing it for optimized builds (unoptimized
1777 // builds have the right order to begin with), searching from the back (this
1778 // would catch the unoptimized case quickly), or doing a binary search
1779 // rather than linear search.
1780 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1781 while (I != Vars.end()) {
1782 unsigned CurNum = (*I)->getVariable().getArgNumber();
1783 // A local (non-parameter) variable has been found, insert immediately
1787 // A later indexed parameter has been found, insert immediately before it.
1788 if (CurNum > ArgNum)
1792 Vars.insert(I, Var);
1796 Vars.push_back(Var);
1799 // Gather and emit post-function debug information.
1800 void DwarfDebug::endFunction(const MachineFunction *MF) {
1801 // Every beginFunction(MF) call should be followed by an endFunction(MF) call,
1802 // though the beginFunction may not be called at all.
1803 // We should handle both cases.
1807 assert(CurFn == MF);
1810 if (!MMI->hasDebugInfo() || LScopes.empty()) {
1815 // Define end label for subprogram.
1816 FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1817 // Assumes in correct section after the entry point.
1818 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1819 // Set DwarfCompileUnitID in MCContext to default value.
1820 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1822 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1823 collectVariableInfo(ProcessedVars);
1825 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1826 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1827 assert(TheCU && "Unable to find compile unit!");
1829 // Construct abstract scopes.
1830 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1831 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1832 LexicalScope *AScope = AList[i];
1833 DISubprogram SP(AScope->getScopeNode());
1834 if (SP.isSubprogram()) {
1835 // Collect info for variables that were optimized out.
1836 DIArray Variables = SP.getVariables();
1837 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1838 DIVariable DV(Variables.getElement(i));
1839 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1841 // Check that DbgVariable for DV wasn't created earlier, when
1842 // findAbstractVariable() was called for inlined instance of DV.
1843 LLVMContext &Ctx = DV->getContext();
1844 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1845 if (AbstractVariables.lookup(CleanDV))
1847 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1848 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1851 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1852 constructScopeDIE(TheCU, AScope);
1855 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1857 if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
1858 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1861 for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1862 E = ScopeVariables.end();
1864 DeleteContainerPointers(I->second);
1865 ScopeVariables.clear();
1866 DeleteContainerPointers(CurrentFnArguments);
1867 UserVariables.clear();
1869 AbstractVariables.clear();
1870 LabelsBeforeInsn.clear();
1871 LabelsAfterInsn.clear();
1876 // Register a source line with debug info. Returns the unique label that was
1877 // emitted and which provides correspondence to the source line list.
1878 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1884 DIDescriptor Scope(S);
1886 if (Scope.isCompileUnit()) {
1887 DICompileUnit CU(S);
1888 Fn = CU.getFilename();
1889 Dir = CU.getDirectory();
1890 } else if (Scope.isFile()) {
1892 Fn = F.getFilename();
1893 Dir = F.getDirectory();
1894 } else if (Scope.isSubprogram()) {
1896 Fn = SP.getFilename();
1897 Dir = SP.getDirectory();
1898 } else if (Scope.isLexicalBlockFile()) {
1899 DILexicalBlockFile DBF(S);
1900 Fn = DBF.getFilename();
1901 Dir = DBF.getDirectory();
1902 } else if (Scope.isLexicalBlock()) {
1903 DILexicalBlock DB(S);
1904 Fn = DB.getFilename();
1905 Dir = DB.getDirectory();
1907 llvm_unreachable("Unexpected scope info");
1909 Src = getOrCreateSourceID(
1910 Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1912 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1915 //===----------------------------------------------------------------------===//
1917 //===----------------------------------------------------------------------===//
1919 // Compute the size and offset of a DIE. The offset is relative to start of the
1920 // CU. It returns the offset after laying out the DIE.
1921 unsigned DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1922 // Get the children.
1923 const std::vector<DIE *> &Children = Die->getChildren();
1925 // Record the abbreviation.
1926 assignAbbrevNumber(Die->getAbbrev());
1928 // Get the abbreviation for this DIE.
1929 unsigned AbbrevNumber = Die->getAbbrevNumber();
1930 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1933 Die->setOffset(Offset);
1935 // Start the size with the size of abbreviation code.
1936 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1938 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1939 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1941 // Size the DIE attribute values.
1942 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1943 // Size attribute value.
1944 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1946 // Size the DIE children if any.
1947 if (!Children.empty()) {
1948 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1949 "Children flag not set");
1951 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1952 Offset = computeSizeAndOffset(Children[j], Offset);
1954 // End of children marker.
1955 Offset += sizeof(int8_t);
1958 Die->setSize(Offset - Die->getOffset());
1962 // Compute the size and offset for each DIE.
1963 void DwarfUnits::computeSizeAndOffsets() {
1964 // Offset from the first CU in the debug info section is 0 initially.
1965 unsigned SecOffset = 0;
1967 // Iterate over each compile unit and set the size and offsets for each
1968 // DIE within each compile unit. All offsets are CU relative.
1969 for (SmallVectorImpl<Unit *>::const_iterator I = CUs.begin(), E = CUs.end();
1971 (*I)->setDebugInfoOffset(SecOffset);
1973 // CU-relative offset is reset to 0 here.
1974 unsigned Offset = sizeof(int32_t) + // Length of Unit Info
1975 (*I)->getHeaderSize(); // Unit-specific headers
1977 // EndOffset here is CU-relative, after laying out
1978 // all of the CU DIE.
1979 unsigned EndOffset = computeSizeAndOffset((*I)->getUnitDie(), Offset);
1980 SecOffset += EndOffset;
1984 // Emit initial Dwarf sections with a label at the start of each one.
1985 void DwarfDebug::emitSectionLabels() {
1986 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1988 // Dwarf sections base addresses.
1989 DwarfInfoSectionSym =
1990 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1991 DwarfAbbrevSectionSym =
1992 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1993 if (useSplitDwarf())
1994 DwarfAbbrevDWOSectionSym = emitSectionSym(
1995 Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1996 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1998 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1999 emitSectionSym(Asm, MacroInfo);
2001 DwarfLineSectionSym =
2002 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2003 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2004 if (GenerateGnuPubSections) {
2005 DwarfGnuPubNamesSectionSym =
2006 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2007 DwarfGnuPubTypesSectionSym =
2008 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2009 } else if (HasDwarfPubSections) {
2010 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2011 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2014 DwarfStrSectionSym =
2015 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2016 if (useSplitDwarf()) {
2017 DwarfStrDWOSectionSym =
2018 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2019 DwarfAddrSectionSym =
2020 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2022 DwarfDebugRangeSectionSym =
2023 emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2025 DwarfDebugLocSectionSym =
2026 emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2028 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2029 emitSectionSym(Asm, TLOF.getDataSection());
2032 // Recursively emits a debug information entry.
2033 void DwarfDebug::emitDIE(DIE *Die, ArrayRef<DIEAbbrev *> Abbrevs) {
2034 // Get the abbreviation for this DIE.
2035 unsigned AbbrevNumber = Die->getAbbrevNumber();
2036 const DIEAbbrev *Abbrev = Abbrevs[AbbrevNumber - 1];
2038 // Emit the code (index) for the abbreviation.
2039 if (Asm->isVerbose())
2040 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2041 Twine::utohexstr(Die->getOffset()) + ":0x" +
2042 Twine::utohexstr(Die->getSize()) + " " +
2043 dwarf::TagString(Abbrev->getTag()));
2044 Asm->EmitULEB128(AbbrevNumber);
2046 const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2047 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2049 // Emit the DIE attribute values.
2050 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2051 dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2052 dwarf::Form Form = AbbrevData[i].getForm();
2053 assert(Form && "Too many attributes for DIE (check abbreviation)");
2055 if (Asm->isVerbose())
2056 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2059 case dwarf::DW_AT_abstract_origin:
2060 case dwarf::DW_AT_type:
2061 case dwarf::DW_AT_friend:
2062 case dwarf::DW_AT_specification:
2063 case dwarf::DW_AT_import:
2064 case dwarf::DW_AT_containing_type: {
2065 DIEEntry *E = cast<DIEEntry>(Values[i]);
2066 DIE *Origin = E->getEntry();
2067 unsigned Addr = Origin->getOffset();
2068 if (Form == dwarf::DW_FORM_ref_addr) {
2069 assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2070 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2071 // section. Origin->getOffset() returns the offset from start of the
2073 CompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2074 assert(CU && "CUDie should belong to a CU.");
2075 Addr += CU->getDebugInfoOffset();
2076 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2077 Asm->EmitLabelPlusOffset(DwarfInfoSectionSym, Addr,
2078 DIEEntry::getRefAddrSize(Asm));
2080 Asm->EmitLabelOffsetDifference(DwarfInfoSectionSym, Addr,
2081 DwarfInfoSectionSym,
2082 DIEEntry::getRefAddrSize(Asm));
2084 // Make sure Origin belong to the same CU.
2085 assert(Die->getUnit() == Origin->getUnit() &&
2086 "The referenced DIE should belong to the same CU in ref4");
2087 Asm->EmitInt32(Addr);
2091 case dwarf::DW_AT_ranges: {
2092 // DW_AT_range Value encodes offset in debug_range section.
2093 DIELabel *V = cast<DIELabel>(Values[i]);
2095 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2096 Asm->EmitSectionOffset(V->getValue(), DwarfDebugRangeSectionSym);
2098 Asm->EmitLabelDifference(V->getValue(), DwarfDebugRangeSectionSym, 4);
2101 case dwarf::DW_AT_location: {
2102 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2103 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2104 Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2106 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2108 Values[i]->EmitValue(Asm, Form);
2112 case dwarf::DW_AT_accessibility: {
2113 if (Asm->isVerbose()) {
2114 DIEInteger *V = cast<DIEInteger>(Values[i]);
2115 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2117 Values[i]->EmitValue(Asm, Form);
2121 // Emit an attribute using the defined form.
2122 Values[i]->EmitValue(Asm, Form);
2127 // Emit the DIE children if any.
2128 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2129 const std::vector<DIE *> &Children = Die->getChildren();
2131 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2132 emitDIE(Children[j], Abbrevs);
2134 if (Asm->isVerbose())
2135 Asm->OutStreamer.AddComment("End Of Children Mark");
2140 // Emit the various dwarf units to the unit section USection with
2141 // the abbreviations going into ASection.
2142 void DwarfUnits::emitUnits(DwarfDebug *DD, const MCSection *USection,
2143 const MCSection *ASection,
2144 const MCSymbol *ASectionSym) {
2145 Asm->OutStreamer.SwitchSection(USection);
2146 for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
2149 DIE *Die = TheU->getUnitDie();
2151 // Emit the compile units header.
2152 Asm->OutStreamer.EmitLabel(
2153 Asm->GetTempSymbol(USection->getLabelBeginName(), TheU->getUniqueID()));
2155 // Emit size of content not including length itself
2156 Asm->OutStreamer.AddComment("Length of Unit");
2157 Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
2159 TheU->emitHeader(ASection, ASectionSym);
2161 DD->emitDIE(Die, Abbreviations);
2162 Asm->OutStreamer.EmitLabel(
2163 Asm->GetTempSymbol(USection->getLabelEndName(), TheU->getUniqueID()));
2167 // Emit the debug info section.
2168 void DwarfDebug::emitDebugInfo() {
2169 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2171 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2172 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2173 DwarfAbbrevSectionSym);
2176 // Emit the abbreviation section.
2177 void DwarfDebug::emitAbbreviations() {
2178 if (!useSplitDwarf())
2179 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2182 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2185 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2186 std::vector<DIEAbbrev *> *Abbrevs) {
2187 // Check to see if it is worth the effort.
2188 if (!Abbrevs->empty()) {
2189 // Start the debug abbrev section.
2190 Asm->OutStreamer.SwitchSection(Section);
2192 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2193 Asm->OutStreamer.EmitLabel(Begin);
2195 // For each abbrevation.
2196 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2197 // Get abbreviation data
2198 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2200 // Emit the abbrevations code (base 1 index.)
2201 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2203 // Emit the abbreviations data.
2207 // Mark end of abbreviations.
2208 Asm->EmitULEB128(0, "EOM(3)");
2210 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2211 Asm->OutStreamer.EmitLabel(End);
2215 // Emit the last address of the section and the end of the line matrix.
2216 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2217 // Define last address of section.
2218 Asm->OutStreamer.AddComment("Extended Op");
2221 Asm->OutStreamer.AddComment("Op size");
2222 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2223 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2224 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2226 Asm->OutStreamer.AddComment("Section end label");
2228 Asm->OutStreamer.EmitSymbolValue(
2229 Asm->GetTempSymbol("section_end", SectionEnd),
2230 Asm->getDataLayout().getPointerSize());
2232 // Mark end of matrix.
2233 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2239 // Emit visible names into a hashed accelerator table section.
2240 void DwarfDebug::emitAccelNames() {
2242 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2243 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2244 E = getUnits().end();
2247 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
2248 for (StringMap<std::vector<const DIE *> >::const_iterator
2252 StringRef Name = GI->getKey();
2253 const std::vector<const DIE *> &Entities = GI->second;
2254 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2255 DE = Entities.end();
2257 AT.AddName(Name, *DI);
2261 AT.FinalizeTable(Asm, "Names");
2262 Asm->OutStreamer.SwitchSection(
2263 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2264 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2265 Asm->OutStreamer.EmitLabel(SectionBegin);
2267 // Emit the full data.
2268 AT.Emit(Asm, SectionBegin, &InfoHolder);
2271 // Emit objective C classes and categories into a hashed accelerator table
2273 void DwarfDebug::emitAccelObjC() {
2275 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2276 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2277 E = getUnits().end();
2280 const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
2281 for (StringMap<std::vector<const DIE *> >::const_iterator
2285 StringRef Name = GI->getKey();
2286 const std::vector<const DIE *> &Entities = GI->second;
2287 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2288 DE = Entities.end();
2290 AT.AddName(Name, *DI);
2294 AT.FinalizeTable(Asm, "ObjC");
2295 Asm->OutStreamer.SwitchSection(
2296 Asm->getObjFileLowering().getDwarfAccelObjCSection());
2297 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2298 Asm->OutStreamer.EmitLabel(SectionBegin);
2300 // Emit the full data.
2301 AT.Emit(Asm, SectionBegin, &InfoHolder);
2304 // Emit namespace dies into a hashed accelerator table.
2305 void DwarfDebug::emitAccelNamespaces() {
2307 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2308 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2309 E = getUnits().end();
2312 const StringMap<std::vector<const DIE *> > &Names =
2313 TheU->getAccelNamespace();
2314 for (StringMap<std::vector<const DIE *> >::const_iterator
2318 StringRef Name = GI->getKey();
2319 const std::vector<const DIE *> &Entities = GI->second;
2320 for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2321 DE = Entities.end();
2323 AT.AddName(Name, *DI);
2327 AT.FinalizeTable(Asm, "namespac");
2328 Asm->OutStreamer.SwitchSection(
2329 Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2330 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2331 Asm->OutStreamer.EmitLabel(SectionBegin);
2333 // Emit the full data.
2334 AT.Emit(Asm, SectionBegin, &InfoHolder);
2337 // Emit type dies into a hashed accelerator table.
2338 void DwarfDebug::emitAccelTypes() {
2339 std::vector<DwarfAccelTable::Atom> Atoms;
2341 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2343 DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2345 DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2346 DwarfAccelTable AT(Atoms);
2347 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2348 E = getUnits().end();
2351 const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2352 TheU->getAccelTypes();
2354 std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2358 StringRef Name = GI->getKey();
2359 const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2361 for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2362 DI = Entities.begin(),
2363 DE = Entities.end();
2365 AT.AddName(Name, DI->first, DI->second);
2369 AT.FinalizeTable(Asm, "types");
2370 Asm->OutStreamer.SwitchSection(
2371 Asm->getObjFileLowering().getDwarfAccelTypesSection());
2372 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2373 Asm->OutStreamer.EmitLabel(SectionBegin);
2375 // Emit the full data.
2376 AT.Emit(Asm, SectionBegin, &InfoHolder);
2379 // Public name handling.
2380 // The format for the various pubnames:
2382 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2383 // for the DIE that is named.
2385 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2386 // into the CU and the index value is computed according to the type of value
2387 // for the DIE that is named.
2389 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2390 // it's the offset within the debug_info/debug_types dwo section, however, the
2391 // reference in the pubname header doesn't change.
2393 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2394 static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
2396 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2398 // We could have a specification DIE that has our most of our knowledge,
2399 // look for that now.
2400 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2402 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2403 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2404 Linkage = dwarf::GIEL_EXTERNAL;
2405 } else if (Die->findAttribute(dwarf::DW_AT_external))
2406 Linkage = dwarf::GIEL_EXTERNAL;
2408 switch (Die->getTag()) {
2409 case dwarf::DW_TAG_class_type:
2410 case dwarf::DW_TAG_structure_type:
2411 case dwarf::DW_TAG_union_type:
2412 case dwarf::DW_TAG_enumeration_type:
2413 return dwarf::PubIndexEntryDescriptor(
2414 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2415 ? dwarf::GIEL_STATIC
2416 : dwarf::GIEL_EXTERNAL);
2417 case dwarf::DW_TAG_typedef:
2418 case dwarf::DW_TAG_base_type:
2419 case dwarf::DW_TAG_subrange_type:
2420 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2421 case dwarf::DW_TAG_namespace:
2422 return dwarf::GIEK_TYPE;
2423 case dwarf::DW_TAG_subprogram:
2424 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2425 case dwarf::DW_TAG_constant:
2426 case dwarf::DW_TAG_variable:
2427 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2428 case dwarf::DW_TAG_enumerator:
2429 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2430 dwarf::GIEL_STATIC);
2432 return dwarf::GIEK_NONE;
2436 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2438 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2439 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2440 const MCSection *PSec =
2441 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2442 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2444 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2445 E = getUnits().end();
2448 unsigned ID = TheU->getUniqueID();
2450 // Start the dwarf pubnames section.
2451 Asm->OutStreamer.SwitchSection(PSec);
2453 // Emit a label so we can reference the beginning of this pubname section.
2455 Asm->OutStreamer.EmitLabel(
2456 Asm->GetTempSymbol("gnu_pubnames", TheU->getUniqueID()));
2459 Asm->OutStreamer.AddComment("Length of Public Names Info");
2460 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2461 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2463 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2465 Asm->OutStreamer.AddComment("DWARF Version");
2466 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2468 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2469 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2470 DwarfInfoSectionSym);
2472 Asm->OutStreamer.AddComment("Compilation Unit Length");
2473 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2474 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2477 // Emit the pubnames for this compilation unit.
2478 const StringMap<const DIE *> &Globals = TheU->getGlobalNames();
2479 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2482 const char *Name = GI->getKeyData();
2483 const DIE *Entity = GI->second;
2485 Asm->OutStreamer.AddComment("DIE offset");
2486 Asm->EmitInt32(Entity->getOffset());
2489 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2490 Asm->OutStreamer.AddComment(
2491 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2492 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2493 Asm->EmitInt8(Desc.toBits());
2496 if (Asm->isVerbose())
2497 Asm->OutStreamer.AddComment("External Name");
2498 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2501 Asm->OutStreamer.AddComment("End Mark");
2503 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2507 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2508 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2509 const MCSection *PSec =
2510 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2511 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2513 for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2514 E = getUnits().end();
2517 // Start the dwarf pubtypes section.
2518 Asm->OutStreamer.SwitchSection(PSec);
2520 // Emit a label so we can reference the beginning of this pubtype section.
2522 Asm->OutStreamer.EmitLabel(
2523 Asm->GetTempSymbol("gnu_pubtypes", TheU->getUniqueID()));
2526 Asm->OutStreamer.AddComment("Length of Public Types Info");
2527 Asm->EmitLabelDifference(
2528 Asm->GetTempSymbol("pubtypes_end", TheU->getUniqueID()),
2529 Asm->GetTempSymbol("pubtypes_begin", TheU->getUniqueID()), 4);
2531 Asm->OutStreamer.EmitLabel(
2532 Asm->GetTempSymbol("pubtypes_begin", TheU->getUniqueID()));
2534 if (Asm->isVerbose())
2535 Asm->OutStreamer.AddComment("DWARF Version");
2536 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2538 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2539 Asm->EmitSectionOffset(
2540 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()),
2541 DwarfInfoSectionSym);
2543 Asm->OutStreamer.AddComment("Compilation Unit Length");
2544 Asm->EmitLabelDifference(
2545 Asm->GetTempSymbol(ISec->getLabelEndName(), TheU->getUniqueID()),
2546 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()), 4);
2548 // Emit the pubtypes.
2549 const StringMap<const DIE *> &Globals = TheU->getGlobalTypes();
2550 for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2553 const char *Name = GI->getKeyData();
2554 const DIE *Entity = GI->second;
2556 if (Asm->isVerbose())
2557 Asm->OutStreamer.AddComment("DIE offset");
2558 Asm->EmitInt32(Entity->getOffset());
2561 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheU, Entity);
2562 Asm->OutStreamer.AddComment(
2563 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2564 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2565 Asm->EmitInt8(Desc.toBits());
2568 if (Asm->isVerbose())
2569 Asm->OutStreamer.AddComment("External Name");
2571 // Emit the name with a terminating null byte.
2572 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2575 Asm->OutStreamer.AddComment("End Mark");
2577 Asm->OutStreamer.EmitLabel(
2578 Asm->GetTempSymbol("pubtypes_end", TheU->getUniqueID()));
2582 // Emit strings into a string section.
2583 void DwarfUnits::emitStrings(const MCSection *StrSection,
2584 const MCSection *OffsetSection = NULL,
2585 const MCSymbol *StrSecSym = NULL) {
2587 if (StringPool.empty())
2590 // Start the dwarf str section.
2591 Asm->OutStreamer.SwitchSection(StrSection);
2593 // Get all of the string pool entries and put them in an array by their ID so
2594 // we can sort them.
2596 std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2599 for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2600 I = StringPool.begin(),
2601 E = StringPool.end();
2603 Entries.push_back(std::make_pair(I->second.second, &*I));
2605 array_pod_sort(Entries.begin(), Entries.end());
2607 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2608 // Emit a label for reference from debug information entries.
2609 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2611 // Emit the string itself with a terminating null byte.
2612 Asm->OutStreamer.EmitBytes(
2613 StringRef(Entries[i].second->getKeyData(),
2614 Entries[i].second->getKeyLength() + 1));
2617 // If we've got an offset section go ahead and emit that now as well.
2618 if (OffsetSection) {
2619 Asm->OutStreamer.SwitchSection(OffsetSection);
2620 unsigned offset = 0;
2621 unsigned size = 4; // FIXME: DWARF64 is 8.
2622 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2623 Asm->OutStreamer.EmitIntValue(offset, size);
2624 offset += Entries[i].second->getKeyLength() + 1;
2630 // Emit addresses into the section given.
2631 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2633 if (AddressPool.empty())
2636 // Start the dwarf addr section.
2637 Asm->OutStreamer.SwitchSection(AddrSection);
2639 // Order the address pool entries by ID
2640 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2642 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2643 E = AddressPool.end();
2645 Entries[I->second] = I->first;
2647 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2648 // Emit an expression for reference from debug information entries.
2649 if (const MCExpr *Expr = Entries[i])
2650 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2652 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2656 // Emit visible names into a debug str section.
2657 void DwarfDebug::emitDebugStr() {
2658 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2659 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2662 // Emit locations into the debug loc section.
2663 void DwarfDebug::emitDebugLoc() {
2664 if (DotDebugLocEntries.empty())
2667 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2668 I = DotDebugLocEntries.begin(),
2669 E = DotDebugLocEntries.end();
2671 DotDebugLocEntry &Entry = *I;
2672 if (I + 1 != DotDebugLocEntries.end())
2676 // Start the dwarf loc section.
2677 Asm->OutStreamer.SwitchSection(
2678 Asm->getObjFileLowering().getDwarfLocSection());
2679 unsigned char Size = Asm->getDataLayout().getPointerSize();
2680 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2682 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2683 I = DotDebugLocEntries.begin(),
2684 E = DotDebugLocEntries.end();
2685 I != E; ++I, ++index) {
2686 DotDebugLocEntry &Entry = *I;
2687 if (Entry.isMerged())
2689 if (Entry.isEmpty()) {
2690 Asm->OutStreamer.EmitIntValue(0, Size);
2691 Asm->OutStreamer.EmitIntValue(0, Size);
2692 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2694 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2695 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2696 DIVariable DV(Entry.getVariable());
2697 Asm->OutStreamer.AddComment("Loc expr size");
2698 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2699 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2700 Asm->EmitLabelDifference(end, begin, 2);
2701 Asm->OutStreamer.EmitLabel(begin);
2702 if (Entry.isInt()) {
2703 DIBasicType BTy(DV.getType());
2704 if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2705 BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2706 Asm->OutStreamer.AddComment("DW_OP_consts");
2707 Asm->EmitInt8(dwarf::DW_OP_consts);
2708 Asm->EmitSLEB128(Entry.getInt());
2710 Asm->OutStreamer.AddComment("DW_OP_constu");
2711 Asm->EmitInt8(dwarf::DW_OP_constu);
2712 Asm->EmitULEB128(Entry.getInt());
2714 } else if (Entry.isLocation()) {
2715 MachineLocation Loc = Entry.getLoc();
2716 if (!DV.hasComplexAddress())
2718 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2720 // Complex address entry.
2721 unsigned N = DV.getNumAddrElements();
2723 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2724 if (Loc.getOffset()) {
2726 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2727 Asm->OutStreamer.AddComment("DW_OP_deref");
2728 Asm->EmitInt8(dwarf::DW_OP_deref);
2729 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2730 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2731 Asm->EmitSLEB128(DV.getAddrElement(1));
2733 // If first address element is OpPlus then emit
2734 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2735 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2736 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2740 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2743 // Emit remaining complex address elements.
2744 for (; i < N; ++i) {
2745 uint64_t Element = DV.getAddrElement(i);
2746 if (Element == DIBuilder::OpPlus) {
2747 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2748 Asm->EmitULEB128(DV.getAddrElement(++i));
2749 } else if (Element == DIBuilder::OpDeref) {
2751 Asm->EmitInt8(dwarf::DW_OP_deref);
2753 llvm_unreachable("unknown Opcode found in complex address");
2757 // else ... ignore constant fp. There is not any good way to
2758 // to represent them here in dwarf.
2759 Asm->OutStreamer.EmitLabel(end);
2764 struct SymbolCUSorter {
2765 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2766 const MCStreamer &Streamer;
2768 bool operator()(const SymbolCU &A, const SymbolCU &B) {
2769 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2770 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2772 // Symbols with no order assigned should be placed at the end.
2773 // (e.g. section end labels)
2775 IA = (unsigned)(-1);
2777 IB = (unsigned)(-1);
2782 static bool CUSort(const Unit *A, const Unit *B) {
2783 return (A->getUniqueID() < B->getUniqueID());
2787 const MCSymbol *Start, *End;
2790 // Emit a debug aranges section, containing a CU lookup for any
2791 // address we can tie back to a CU.
2792 void DwarfDebug::emitDebugARanges() {
2793 // Start the dwarf aranges section.
2794 Asm->OutStreamer.SwitchSection(
2795 Asm->getObjFileLowering().getDwarfARangesSection());
2797 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2801 // Build a list of sections used.
2802 std::vector<const MCSection *> Sections;
2803 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2805 const MCSection *Section = it->first;
2806 Sections.push_back(Section);
2809 // Sort the sections into order.
2810 // This is only done to ensure consistent output order across different runs.
2811 std::sort(Sections.begin(), Sections.end(), SectionSort);
2813 // Build a set of address spans, sorted by CU.
2814 for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2815 const MCSection *Section = Sections[SecIdx];
2816 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2817 if (List.size() < 2)
2820 // Sort the symbols by offset within the section.
2821 SymbolCUSorter sorter(Asm->OutStreamer);
2822 std::sort(List.begin(), List.end(), sorter);
2824 // If we have no section (e.g. common), just write out
2825 // individual spans for each symbol.
2826 if (Section == NULL) {
2827 for (size_t n = 0; n < List.size(); n++) {
2828 const SymbolCU &Cur = List[n];
2831 Span.Start = Cur.Sym;
2834 Spans[Cur.CU].push_back(Span);
2837 // Build spans between each label.
2838 const MCSymbol *StartSym = List[0].Sym;
2839 for (size_t n = 1; n < List.size(); n++) {
2840 const SymbolCU &Prev = List[n - 1];
2841 const SymbolCU &Cur = List[n];
2843 // Try and build the longest span we can within the same CU.
2844 if (Cur.CU != Prev.CU) {
2846 Span.Start = StartSym;
2848 Spans[Prev.CU].push_back(Span);
2855 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2856 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2858 // Build a list of CUs used.
2859 std::vector<CompileUnit *> CUs;
2860 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2861 CompileUnit *CU = it->first;
2865 // Sort the CU list (again, to ensure consistent output order).
2866 std::sort(CUs.begin(), CUs.end(), CUSort);
2868 // Emit an arange table for each CU we used.
2869 for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2870 CompileUnit *CU = CUs[CUIdx];
2871 std::vector<ArangeSpan> &List = Spans[CU];
2873 // Emit size of content not including length itself.
2874 unsigned ContentSize =
2875 sizeof(int16_t) + // DWARF ARange version number
2876 sizeof(int32_t) + // Offset of CU in the .debug_info section
2877 sizeof(int8_t) + // Pointer Size (in bytes)
2878 sizeof(int8_t); // Segment Size (in bytes)
2880 unsigned TupleSize = PtrSize * 2;
2882 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2883 unsigned Padding = 0;
2884 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2887 ContentSize += Padding;
2888 ContentSize += (List.size() + 1) * TupleSize;
2890 // For each compile unit, write the list of spans it covers.
2891 Asm->OutStreamer.AddComment("Length of ARange Set");
2892 Asm->EmitInt32(ContentSize);
2893 Asm->OutStreamer.AddComment("DWARF Arange version number");
2894 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2895 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2896 Asm->EmitSectionOffset(
2897 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2898 DwarfInfoSectionSym);
2899 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2900 Asm->EmitInt8(PtrSize);
2901 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2904 for (unsigned n = 0; n < Padding; n++)
2905 Asm->EmitInt8(0xff);
2907 for (unsigned n = 0; n < List.size(); n++) {
2908 const ArangeSpan &Span = List[n];
2909 Asm->EmitLabelReference(Span.Start, PtrSize);
2911 // Calculate the size as being from the span start to it's end.
2913 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2915 // For symbols without an end marker (e.g. common), we
2916 // write a single arange entry containing just that one symbol.
2917 uint64_t Size = SymSize[Span.Start];
2921 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2925 Asm->OutStreamer.AddComment("ARange terminator");
2926 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2927 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2931 // Emit visible names into a debug ranges section.
2932 void DwarfDebug::emitDebugRanges() {
2933 // Start the dwarf ranges section.
2934 Asm->OutStreamer.SwitchSection(
2935 Asm->getObjFileLowering().getDwarfRangesSection());
2937 // Size for our labels.
2938 unsigned char Size = Asm->getDataLayout().getPointerSize();
2940 // Grab the specific ranges for the compile units in the module.
2941 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2944 CompileUnit *TheCU = I->second;
2945 unsigned ID = TheCU->getUniqueID();
2947 // Emit a symbol so we can find the beginning of our ranges.
2948 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_ranges", ID));
2950 // Iterate over the misc ranges for the compile units in the module.
2951 const SmallVectorImpl<RangeSpanList *> &RangeLists = TheCU->getRangeLists();
2952 for (SmallVectorImpl<RangeSpanList *>::const_iterator
2953 I = RangeLists.begin(),
2954 E = RangeLists.end();
2956 RangeSpanList *List = *I;
2958 // Emit a symbol so we can find the beginning of the range.
2959 Asm->OutStreamer.EmitLabel(
2960 Asm->GetTempSymbol("debug_ranges", List->getIndex()));
2962 for (SmallVectorImpl<RangeSpan>::const_iterator
2963 I = List->getRanges().begin(),
2964 E = List->getRanges().end();
2966 RangeSpan Range = *I;
2967 // We occasionally have ranges without begin/end labels.
2968 // FIXME: Verify and fix.
2969 const MCSymbol *Begin = Range.getStart();
2970 const MCSymbol *End = Range.getEnd();
2971 Begin ? Asm->OutStreamer.EmitSymbolValue(Begin, Size)
2972 : Asm->OutStreamer.EmitIntValue(0, Size);
2973 End ? Asm->OutStreamer.EmitSymbolValue(End, Size)
2974 : Asm->OutStreamer.EmitIntValue(0, Size);
2977 // And terminate the list with two 0 values.
2978 Asm->OutStreamer.EmitIntValue(0, Size);
2979 Asm->OutStreamer.EmitIntValue(0, Size);
2984 // Emit visible names into a debug macinfo section.
2985 void DwarfDebug::emitDebugMacInfo() {
2986 if (const MCSection *LineInfo =
2987 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2988 // Start the dwarf macinfo section.
2989 Asm->OutStreamer.SwitchSection(LineInfo);
2993 // DWARF5 Experimental Separate Dwarf emitters.
2995 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2996 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2997 // DW_AT_ranges_base, DW_AT_addr_base.
2998 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
3000 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
3001 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
3002 Asm, this, &SkeletonHolder);
3004 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
3005 CU->getNode().getSplitDebugFilename());
3007 // Relocate to the beginning of the addr_base section, else 0 for the
3008 // beginning of the one for this compile unit.
3009 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3010 NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
3011 DwarfAddrSectionSym);
3013 NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
3015 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
3016 // into an entity. We're using 0, or a NULL label for this.
3017 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
3019 // DW_AT_stmt_list is a offset of line number information for this
3020 // compile unit in debug_line section.
3021 // FIXME: Should handle multiple compile units.
3022 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3023 NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
3024 DwarfLineSectionSym);
3026 NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
3028 if (!CompilationDir.empty())
3029 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
3031 // Flags to let the linker know we have emitted new style pubnames.
3032 if (GenerateGnuPubSections) {
3033 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3034 NewCU->addSectionLabel(
3035 Die, dwarf::DW_AT_GNU_pubnames,
3036 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
3038 NewCU->addSectionDelta(
3039 Die, dwarf::DW_AT_GNU_pubnames,
3040 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
3041 DwarfGnuPubNamesSectionSym);
3043 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3044 NewCU->addSectionLabel(
3045 Die, dwarf::DW_AT_GNU_pubtypes,
3046 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
3048 NewCU->addSectionDelta(
3049 Die, dwarf::DW_AT_GNU_pubtypes,
3050 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
3051 DwarfGnuPubTypesSectionSym);
3054 // Attribute if we've emitted any ranges and their location for the compile unit.
3055 if (CU->getRangeLists().size()) {
3056 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3057 NewCU->addSectionLabel(
3058 Die, dwarf::DW_AT_GNU_ranges_base,
3059 Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()));
3061 NewCU->addSectionDelta(
3062 Die, dwarf::DW_AT_GNU_ranges_base,
3063 Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()),
3064 DwarfDebugRangeSectionSym);
3067 SkeletonHolder.addUnit(NewCU);
3072 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
3073 assert(useSplitDwarf() && "No split dwarf debug info?");
3074 emitAbbrevs(Section, &SkeletonAbbrevs);
3077 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3078 // compile units that would normally be in debug_info.
3079 void DwarfDebug::emitDebugInfoDWO() {
3080 assert(useSplitDwarf() && "No split dwarf debug info?");
3081 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3082 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3083 DwarfAbbrevDWOSectionSym);
3086 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3087 // abbreviations for the .debug_info.dwo section.
3088 void DwarfDebug::emitDebugAbbrevDWO() {
3089 assert(useSplitDwarf() && "No split dwarf?");
3090 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3094 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3095 // string section and is identical in format to traditional .debug_str
3097 void DwarfDebug::emitDebugStrDWO() {
3098 assert(useSplitDwarf() && "No split dwarf?");
3099 const MCSection *OffSec =
3100 Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3101 const MCSymbol *StrSym = DwarfStrSectionSym;
3102 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3106 void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
3107 DICompositeType CTy) {
3108 DenseMap<const MDNode *,
3109 std::pair<uint64_t, SmallVectorImpl<DIE *> *> >::iterator I =
3110 TypeUnits.find(CTy);
3111 SmallVector<DIE *, 8> References;
3112 References.push_back(RefDie);
3113 if (I != TypeUnits.end()) {
3114 if (I->second.second) {
3115 I->second.second->push_back(RefDie);
3119 DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3120 TypeUnit *NewTU = new TypeUnit(GlobalCUIndexCount++, UnitDie, Language, Asm,
3122 NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3125 // Register the type in the TypeUnits map with a vector of references to be
3126 // populated whenever a reference is required.
3127 I = TypeUnits.insert(std::make_pair(CTy, std::make_pair(0, &References)))
3130 // Construct the type, this may, recursively, require more type units that
3131 // may in turn require this type again - in which case they will add DIEs to
3132 // the References vector.
3133 DIE *Die = NewTU->createTypeDIE(CTy);
3135 if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3136 NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3137 dwarf::DW_FORM_data8,
3138 DIEHash().computeDIEODRSignature(*Die));
3139 // FIXME: This won't handle circularly referential structures, as the DIE
3140 // may have references to other DIEs still under construction and missing
3141 // their signature. Hashing should walk through the signatures to their
3142 // referenced type, or possibly walk the precomputed hashes of related types
3144 uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3146 // Remove the References vector and add the type hash.
3147 I->second.first = Signature;
3148 I->second.second = NULL;
3150 InfoHolder.addUnit(NewTU);
3153 // Populate all the signatures.
3154 for (unsigned i = 0, e = References.size(); i != e; ++i) {
3155 CUMap.begin()->second->addUInt(References[i], dwarf::DW_AT_signature,
3156 dwarf::DW_FORM_ref_sig8, I->second.first);