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 "DwarfCompileUnit.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."),
67 GenerateCUHash("generate-cu-hash", cl::Hidden,
68 cl::desc("Add the CU hash as the dwo_id."),
72 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
73 cl::desc("Generate GNU-style pubnames and pubtypes"),
84 static cl::opt<DefaultOnOff>
85 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
86 cl::desc("Output prototype dwarf accelerator tables."),
87 cl::values(clEnumVal(Default, "Default for platform"),
88 clEnumVal(Enable, "Enabled"),
89 clEnumVal(Disable, "Disabled"), clEnumValEnd),
92 static cl::opt<DefaultOnOff>
93 SplitDwarf("split-dwarf", cl::Hidden,
94 cl::desc("Output prototype dwarf split debug info."),
95 cl::values(clEnumVal(Default, "Default for platform"),
96 clEnumVal(Enable, "Enabled"),
97 clEnumVal(Disable, "Disabled"), clEnumValEnd),
100 static cl::opt<DefaultOnOff>
101 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
102 cl::desc("Generate DWARF pubnames and pubtypes sections"),
103 cl::values(clEnumVal(Default, "Default for platform"),
104 clEnumVal(Enable, "Enabled"),
105 clEnumVal(Disable, "Disabled"), clEnumValEnd),
108 static const char *const DWARFGroupName = "DWARF Emission";
109 static const char *const DbgTimerName = "DWARF Debug Writer";
111 //===----------------------------------------------------------------------===//
113 // Configuration values for initial hash set sizes (log2).
115 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
119 /// resolve - Look in the DwarfDebug map for the MDNode that
120 /// corresponds to the reference.
121 template <typename T>
122 T DbgVariable::resolve(DIRef<T> Ref) const {
123 return DD->resolve(Ref);
126 DIType DbgVariable::getType() const {
127 DIType Ty = Var.getType();
128 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
129 // addresses instead.
130 if (Var.isBlockByrefVariable()) {
131 /* Byref variables, in Blocks, are declared by the programmer as
132 "SomeType VarName;", but the compiler creates a
133 __Block_byref_x_VarName struct, and gives the variable VarName
134 either the struct, or a pointer to the struct, as its type. This
135 is necessary for various behind-the-scenes things the compiler
136 needs to do with by-reference variables in blocks.
138 However, as far as the original *programmer* is concerned, the
139 variable should still have type 'SomeType', as originally declared.
141 The following function dives into the __Block_byref_x_VarName
142 struct to find the original type of the variable. This will be
143 passed back to the code generating the type for the Debug
144 Information Entry for the variable 'VarName'. 'VarName' will then
145 have the original type 'SomeType' in its debug information.
147 The original type 'SomeType' will be the type of the field named
148 'VarName' inside the __Block_byref_x_VarName struct.
150 NOTE: In order for this to not completely fail on the debugger
151 side, the Debug Information Entry for the variable VarName needs to
152 have a DW_AT_location that tells the debugger how to unwind through
153 the pointers and __Block_byref_x_VarName struct to find the actual
154 value of the variable. The function addBlockByrefType does this. */
156 uint16_t tag = Ty.getTag();
158 if (tag == dwarf::DW_TAG_pointer_type)
159 subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
161 DIArray Elements = DICompositeType(subType).getTypeArray();
162 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
163 DIDerivedType DT = DIDerivedType(Elements.getElement(i));
164 if (getName() == DT.getName())
165 return (resolve(DT.getTypeDerivedFrom()));
171 } // end llvm namespace
173 /// Return Dwarf Version by checking module flags.
174 static unsigned getDwarfVersionFromModule(const Module *M) {
175 Value *Val = M->getModuleFlag("Dwarf Version");
177 return dwarf::DWARF_VERSION;
178 return cast<ConstantInt>(Val)->getZExtValue();
181 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
182 : Asm(A), MMI(Asm->MMI), FirstCU(0),
183 AbbreviationsSet(InitAbbreviationsSetSize),
184 SourceIdMap(DIEValueAllocator),
185 PrevLabel(NULL), GlobalCUIndexCount(0),
186 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
188 SkeletonAbbrevSet(InitAbbreviationsSetSize),
189 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
192 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
193 DwarfStrSectionSym = TextSectionSym = 0;
194 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
195 DwarfAddrSectionSym = 0;
196 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
197 FunctionBeginSym = FunctionEndSym = 0;
199 // Turn on accelerator tables for Darwin by default, pubnames by
200 // default for non-Darwin, and handle split dwarf.
201 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
203 if (DwarfAccelTables == Default)
204 HasDwarfAccelTables = IsDarwin;
206 HasDwarfAccelTables = DwarfAccelTables == Enable;
208 if (SplitDwarf == Default)
209 HasSplitDwarf = false;
211 HasSplitDwarf = SplitDwarf == Enable;
213 if (DwarfPubSections == Default)
214 HasDwarfPubSections = !IsDarwin;
216 HasDwarfPubSections = DwarfPubSections == Enable;
218 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
221 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
226 // Switch to the specified MCSection and emit an assembler
227 // temporary label to it if SymbolStem is specified.
228 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
229 const char *SymbolStem = 0) {
230 Asm->OutStreamer.SwitchSection(Section);
231 if (!SymbolStem) return 0;
233 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
234 Asm->OutStreamer.EmitLabel(TmpSym);
238 MCSymbol *DwarfUnits::getStringPoolSym() {
239 return Asm->GetTempSymbol(StringPref);
242 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
243 std::pair<MCSymbol*, unsigned> &Entry =
244 StringPool.GetOrCreateValue(Str).getValue();
245 if (Entry.first) return Entry.first;
247 Entry.second = NextStringPoolNumber++;
248 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
251 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
252 std::pair<MCSymbol*, unsigned> &Entry =
253 StringPool.GetOrCreateValue(Str).getValue();
254 if (Entry.first) return Entry.second;
256 Entry.second = NextStringPoolNumber++;
257 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
261 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
262 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
265 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
266 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
267 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
269 ++NextAddrPoolNumber;
270 return P.first->second;
273 // Define a unique number for the abbreviation.
275 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
276 // Check the set for priors.
277 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
279 // If it's newly added.
280 if (InSet == &Abbrev) {
281 // Add to abbreviation list.
282 Abbreviations->push_back(&Abbrev);
284 // Assign the vector position + 1 as its number.
285 Abbrev.setNumber(Abbreviations->size());
287 // Assign existing abbreviation number.
288 Abbrev.setNumber(InSet->getNumber());
292 static bool isObjCClass(StringRef Name) {
293 return Name.startswith("+") || Name.startswith("-");
296 static bool hasObjCCategory(StringRef Name) {
297 if (!isObjCClass(Name)) return false;
299 return Name.find(") ") != StringRef::npos;
302 static void getObjCClassCategory(StringRef In, StringRef &Class,
303 StringRef &Category) {
304 if (!hasObjCCategory(In)) {
305 Class = In.slice(In.find('[') + 1, In.find(' '));
310 Class = In.slice(In.find('[') + 1, In.find('('));
311 Category = In.slice(In.find('[') + 1, In.find(' '));
315 static StringRef getObjCMethodName(StringRef In) {
316 return In.slice(In.find(' ') + 1, In.find(']'));
319 // Helper for sorting sections into a stable output order.
320 static bool SectionSort(const MCSection *A, const MCSection *B) {
321 std::string LA = (A ? A->getLabelBeginName() : "");
322 std::string LB = (B ? B->getLabelBeginName() : "");
326 // Add the various names to the Dwarf accelerator table names.
327 // TODO: Determine whether or not we should add names for programs
328 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
329 // is only slightly different than the lookup of non-standard ObjC names.
330 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
332 if (!SP.isDefinition()) return;
333 TheCU->addAccelName(SP.getName(), Die);
335 // If the linkage name is different than the name, go ahead and output
336 // that as well into the name table.
337 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
338 TheCU->addAccelName(SP.getLinkageName(), Die);
340 // If this is an Objective-C selector name add it to the ObjC accelerator
342 if (isObjCClass(SP.getName())) {
343 StringRef Class, Category;
344 getObjCClassCategory(SP.getName(), Class, Category);
345 TheCU->addAccelObjC(Class, Die);
347 TheCU->addAccelObjC(Category, Die);
348 // Also add the base method name to the name table.
349 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
353 /// isSubprogramContext - Return true if Context is either a subprogram
354 /// or another context nested inside a subprogram.
355 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
358 DIDescriptor D(Context);
359 if (D.isSubprogram())
362 return isSubprogramContext(resolve(DIType(Context).getContext()));
366 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
367 // and DW_AT_high_pc attributes. If there are global variables in this
368 // scope then create and insert DIEs for these variables.
369 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
370 const MDNode *SPNode) {
371 DIE *SPDie = SPCU->getDIE(SPNode);
373 assert(SPDie && "Unable to find subprogram DIE!");
374 DISubprogram SP(SPNode);
376 // If we're updating an abstract DIE, then we will be adding the children and
377 // object pointer later on. But what we don't want to do is process the
378 // concrete DIE twice.
379 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
380 // Pick up abstract subprogram DIE.
381 SPDie = new DIE(dwarf::DW_TAG_subprogram);
382 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
385 DISubprogram SPDecl = SP.getFunctionDeclaration();
386 if (!SPDecl.isSubprogram()) {
387 // There is not any need to generate specification DIE for a function
388 // defined at compile unit level. If a function is defined inside another
389 // function then gdb prefers the definition at top level and but does not
390 // expect specification DIE in parent function. So avoid creating
391 // specification DIE for a function defined inside a function.
392 DIScope SPContext = resolve(SP.getContext());
393 if (SP.isDefinition() && !SPContext.isCompileUnit() &&
394 !SPContext.isFile() &&
395 !isSubprogramContext(SPContext)) {
396 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
399 DICompositeType SPTy = SP.getType();
400 DIArray Args = SPTy.getTypeArray();
401 uint16_t SPTag = SPTy.getTag();
402 if (SPTag == dwarf::DW_TAG_subroutine_type)
403 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
404 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
405 DIType ATy = DIType(Args.getElement(i));
406 SPCU->addType(Arg, ATy);
407 if (ATy.isArtificial())
408 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
409 if (ATy.isObjectPointer())
410 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
411 SPDie->addChild(Arg);
413 DIE *SPDeclDie = SPDie;
414 SPDie = new DIE(dwarf::DW_TAG_subprogram);
415 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
421 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
422 Asm->GetTempSymbol("func_begin",
423 Asm->getFunctionNumber()));
424 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
425 Asm->GetTempSymbol("func_end",
426 Asm->getFunctionNumber()));
427 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
428 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
429 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
431 // Add name to the name table, we do this here because we're guaranteed
432 // to have concrete versions of our DW_TAG_subprogram nodes.
433 addSubprogramNames(SPCU, SP, SPDie);
438 /// Check whether we should create a DIE for the given Scope, return true
439 /// if we don't create a DIE (the corresponding DIE is null).
440 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
441 if (Scope->isAbstractScope())
444 // We don't create a DIE if there is no Range.
445 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
449 if (Ranges.size() > 1)
452 // We don't create a DIE if we have a single Range and the end label
454 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
455 MCSymbol *End = getLabelAfterInsn(RI->second);
459 // Construct new DW_TAG_lexical_block for this scope and attach
460 // DW_AT_low_pc/DW_AT_high_pc labels.
461 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
462 LexicalScope *Scope) {
463 if (isLexicalScopeDIENull(Scope))
466 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
467 if (Scope->isAbstractScope())
470 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
471 // If we have multiple ranges, emit them into the range section.
472 if (Ranges.size() > 1) {
473 // .debug_range section has not been laid out yet. Emit offset in
474 // .debug_range as a uint, size 4, for now. emitDIE will handle
475 // DW_AT_ranges appropriately.
476 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
477 DebugRangeSymbols.size()
478 * Asm->getDataLayout().getPointerSize());
479 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
480 RE = Ranges.end(); RI != RE; ++RI) {
481 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
482 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
485 // Terminate the range list.
486 DebugRangeSymbols.push_back(NULL);
487 DebugRangeSymbols.push_back(NULL);
491 // Construct the address range for this DIE.
492 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
493 MCSymbol *Start = getLabelBeforeInsn(RI->first);
494 MCSymbol *End = getLabelAfterInsn(RI->second);
495 assert(End && "End label should not be null!");
497 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
498 assert(End->isDefined() && "Invalid end label for an inlined scope!");
500 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
501 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
506 // This scope represents inlined body of a function. Construct DIE to
507 // represent this concrete inlined copy of the function.
508 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
509 LexicalScope *Scope) {
510 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
511 assert(Ranges.empty() == false &&
512 "LexicalScope does not have instruction markers!");
514 if (!Scope->getScopeNode())
516 DIScope DS(Scope->getScopeNode());
517 DISubprogram InlinedSP = getDISubprogram(DS);
518 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
520 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
524 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
525 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
527 if (Ranges.size() > 1) {
528 // .debug_range section has not been laid out yet. Emit offset in
529 // .debug_range as a uint, size 4, for now. emitDIE will handle
530 // DW_AT_ranges appropriately.
531 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
532 DebugRangeSymbols.size()
533 * Asm->getDataLayout().getPointerSize());
534 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
535 RE = Ranges.end(); RI != RE; ++RI) {
536 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
537 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
539 DebugRangeSymbols.push_back(NULL);
540 DebugRangeSymbols.push_back(NULL);
542 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
543 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
544 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
546 if (StartLabel == 0 || EndLabel == 0)
547 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
549 assert(StartLabel->isDefined() &&
550 "Invalid starting label for an inlined scope!");
551 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
553 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
554 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
557 InlinedSubprogramDIEs.insert(OriginDIE);
559 // Add the call site information to the DIE.
560 DILocation DL(Scope->getInlinedAt());
561 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
562 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
563 TheCU->getUniqueID()));
564 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
566 // Add name to the name table, we do this here because we're guaranteed
567 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
568 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
573 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
574 SmallVectorImpl<DIE*> &Children) {
575 DIE *ObjectPointer = NULL;
577 // Collect arguments for current function.
578 if (LScopes.isCurrentFunctionScope(Scope))
579 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
580 if (DbgVariable *ArgDV = CurrentFnArguments[i])
582 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
583 Children.push_back(Arg);
584 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
587 // Collect lexical scope children first.
588 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
589 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
591 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
592 Children.push_back(Variable);
593 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
595 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
596 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
597 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
598 Children.push_back(Nested);
599 return ObjectPointer;
602 // Construct a DIE for this scope.
603 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
604 if (!Scope || !Scope->getScopeNode())
607 DIScope DS(Scope->getScopeNode());
609 SmallVector<DIE *, 8> Children;
610 DIE *ObjectPointer = NULL;
611 bool ChildrenCreated = false;
613 // We try to create the scope DIE first, then the children DIEs. This will
614 // avoid creating un-used children then removing them later when we find out
615 // the scope DIE is null.
616 DIE *ScopeDIE = NULL;
617 if (Scope->getInlinedAt())
618 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
619 else if (DS.isSubprogram()) {
620 ProcessedSPNodes.insert(DS);
621 if (Scope->isAbstractScope()) {
622 ScopeDIE = TheCU->getDIE(DS);
623 // Note down abstract DIE.
625 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
628 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
631 // Early exit when we know the scope DIE is going to be null.
632 if (isLexicalScopeDIENull(Scope))
635 // We create children here when we know the scope DIE is not going to be
636 // null and the children will be added to the scope DIE.
637 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
638 ChildrenCreated = true;
640 // There is no need to emit empty lexical block DIE.
641 std::pair<ImportedEntityMap::const_iterator,
642 ImportedEntityMap::const_iterator> Range = std::equal_range(
643 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
644 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
646 if (Children.empty() && Range.first == Range.second)
648 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
649 assert(ScopeDIE && "Scope DIE should not be null.");
650 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
652 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
656 assert(Children.empty() &&
657 "We create children only when the scope DIE is not null.");
660 if (!ChildrenCreated)
661 // We create children when the scope DIE is not null.
662 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
665 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
666 E = Children.end(); I != E; ++I)
667 ScopeDIE->addChild(*I);
669 if (DS.isSubprogram() && ObjectPointer != NULL)
670 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
672 if (DS.isSubprogram())
673 TheCU->addPubTypes(DISubprogram(DS));
678 // Look up the source id with the given directory and source file names.
679 // If none currently exists, create a new id and insert it in the
680 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
682 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
683 StringRef DirName, unsigned CUID) {
684 // If we use .loc in assembly, we can't separate .file entries according to
685 // compile units. Thus all files will belong to the default compile unit.
687 // FIXME: add a better feature test than hasRawTextSupport. Even better,
688 // extend .file to support this.
689 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
692 // If FE did not provide a file name, then assume stdin.
693 if (FileName.empty())
694 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
696 // TODO: this might not belong here. See if we can factor this better.
697 if (DirName == CompilationDir)
700 // FileIDCUMap stores the current ID for the given compile unit.
701 unsigned SrcId = FileIDCUMap[CUID] + 1;
703 // We look up the CUID/file/dir by concatenating them with a zero byte.
704 SmallString<128> NamePair;
705 NamePair += utostr(CUID);
708 NamePair += '\0'; // Zero bytes are not allowed in paths.
709 NamePair += FileName;
711 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
712 if (Ent.getValue() != SrcId)
713 return Ent.getValue();
715 FileIDCUMap[CUID] = SrcId;
716 // Print out a .file directive to specify files for .loc directives.
717 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
722 // Create new CompileUnit for the given metadata node with tag
723 // DW_TAG_compile_unit.
724 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
725 DICompileUnit DIUnit(N);
726 StringRef FN = DIUnit.getFilename();
727 CompilationDir = DIUnit.getDirectory();
729 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
731 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
733 FileIDCUMap[NewCU->getUniqueID()] = 0;
734 // Call this to emit a .file directive if it wasn't emitted for the source
735 // file this CU comes from yet.
736 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
738 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
739 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
740 DIUnit.getLanguage());
741 NewCU->addString(Die, dwarf::DW_AT_name, FN);
743 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
744 // into an entity. We're using 0 (or a NULL label) for this. For
745 // split dwarf it's in the skeleton CU so omit it here.
746 if (!useSplitDwarf())
747 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
749 // Define start line table label for each Compile Unit.
750 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
751 NewCU->getUniqueID());
752 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
753 NewCU->getUniqueID());
755 // Use a single line table if we are using .loc and generating assembly.
757 (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
758 (NewCU->getUniqueID() == 0);
760 if (!useSplitDwarf()) {
761 // DW_AT_stmt_list is a offset of line number information for this
762 // compile unit in debug_line section. For split dwarf this is
763 // left in the skeleton CU and so not included.
764 // The line table entries are not always emitted in assembly, so it
765 // is not okay to use line_table_start here.
766 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
767 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
768 UseTheFirstCU ? Asm->GetTempSymbol("section_line")
769 : LineTableStartSym);
770 else if (UseTheFirstCU)
771 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
773 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
774 LineTableStartSym, DwarfLineSectionSym);
776 // If we're using split dwarf the compilation dir is going to be in the
777 // skeleton CU and so we don't need to duplicate it here.
778 if (!CompilationDir.empty())
779 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
781 // Flags to let the linker know we have emitted new style pubnames. Only
782 // emit it here if we don't have a skeleton CU for split dwarf.
783 if (GenerateGnuPubSections) {
784 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
785 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames,
786 dwarf::DW_FORM_sec_offset,
787 Asm->GetTempSymbol("gnu_pubnames",
788 NewCU->getUniqueID()));
790 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
791 Asm->GetTempSymbol("gnu_pubnames",
792 NewCU->getUniqueID()),
793 DwarfGnuPubNamesSectionSym);
795 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
796 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes,
797 dwarf::DW_FORM_sec_offset,
798 Asm->GetTempSymbol("gnu_pubtypes",
799 NewCU->getUniqueID()));
801 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
802 Asm->GetTempSymbol("gnu_pubtypes",
803 NewCU->getUniqueID()),
804 DwarfGnuPubTypesSectionSym);
808 if (DIUnit.isOptimized())
809 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
811 StringRef Flags = DIUnit.getFlags();
813 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
815 if (unsigned RVer = DIUnit.getRunTimeVersion())
816 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
817 dwarf::DW_FORM_data1, RVer);
822 InfoHolder.addUnit(NewCU);
824 CUMap.insert(std::make_pair(N, NewCU));
828 // Construct subprogram DIE.
829 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
830 // FIXME: We should only call this routine once, however, during LTO if a
831 // program is defined in multiple CUs we could end up calling it out of
832 // beginModule as we walk the CUs.
834 CompileUnit *&CURef = SPMap[N];
840 if (!SP.isDefinition())
841 // This is a method declaration which will be handled while constructing
845 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
847 // Expose as a global name.
848 TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
851 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
853 DIImportedEntity Module(N);
854 if (!Module.Verify())
856 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
857 constructImportedEntityDIE(TheCU, Module, D);
860 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
862 DIImportedEntity Module(N);
863 if (!Module.Verify())
865 return constructImportedEntityDIE(TheCU, Module, Context);
868 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
869 const DIImportedEntity &Module,
871 assert(Module.Verify() &&
872 "Use one of the MDNode * overloads to handle invalid metadata");
873 assert(Context && "Should always have a context for an imported_module");
874 DIE *IMDie = new DIE(Module.getTag());
875 TheCU->insertDIE(Module, IMDie);
877 DIDescriptor Entity = Module.getEntity();
878 if (Entity.isNameSpace())
879 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
880 else if (Entity.isSubprogram())
881 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
882 else if (Entity.isType())
883 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
885 EntityDie = TheCU->getDIE(Entity);
886 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
887 Module.getContext().getDirectory(),
888 TheCU->getUniqueID());
889 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
890 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
891 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
892 StringRef Name = Module.getName();
894 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
895 Context->addChild(IMDie);
898 // Emit all Dwarf sections that should come prior to the content. Create
899 // global DIEs and emit initial debug info sections. This is invoked by
900 // the target AsmPrinter.
901 void DwarfDebug::beginModule() {
902 if (DisableDebugInfoPrinting)
905 const Module *M = MMI->getModule();
907 // If module has named metadata anchors then use them, otherwise scan the
908 // module using debug info finder to collect debug info.
909 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
912 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
914 // Emit initial sections so we can reference labels later.
917 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
918 DICompileUnit CUNode(CU_Nodes->getOperand(i));
919 CompileUnit *CU = constructCompileUnit(CUNode);
920 DIArray ImportedEntities = CUNode.getImportedEntities();
921 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
922 ScopesWithImportedEntities.push_back(std::make_pair(
923 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
924 ImportedEntities.getElement(i)));
925 std::sort(ScopesWithImportedEntities.begin(),
926 ScopesWithImportedEntities.end(), less_first());
927 DIArray GVs = CUNode.getGlobalVariables();
928 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
929 CU->createGlobalVariableDIE(GVs.getElement(i));
930 DIArray SPs = CUNode.getSubprograms();
931 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
932 constructSubprogramDIE(CU, SPs.getElement(i));
933 DIArray EnumTypes = CUNode.getEnumTypes();
934 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
935 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
936 DIArray RetainedTypes = CUNode.getRetainedTypes();
937 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
938 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
939 // Emit imported_modules last so that the relevant context is already
941 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
942 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
945 // Tell MMI that we have debug info.
946 MMI->setDebugInfoAvailability(true);
948 // Prime section data.
949 SectionMap[Asm->getObjFileLowering().getTextSection()];
952 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
953 void DwarfDebug::computeInlinedDIEs() {
954 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
955 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
956 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
958 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
960 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
961 AE = AbstractSPDies.end(); AI != AE; ++AI) {
962 DIE *ISP = AI->second;
963 if (InlinedSubprogramDIEs.count(ISP))
965 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
969 // Collect info for variables that were optimized out.
970 void DwarfDebug::collectDeadVariables() {
971 const Module *M = MMI->getModule();
972 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
974 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
975 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
976 DICompileUnit TheCU(CU_Nodes->getOperand(i));
977 DIArray Subprograms = TheCU.getSubprograms();
978 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
979 DISubprogram SP(Subprograms.getElement(i));
980 if (ProcessedSPNodes.count(SP) != 0)
982 if (!SP.isSubprogram())
984 if (!SP.isDefinition())
986 DIArray Variables = SP.getVariables();
987 if (Variables.getNumElements() == 0)
990 LexicalScope *Scope =
991 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
992 DeadFnScopeMap[SP] = Scope;
994 // Construct subprogram DIE and add variables DIEs.
995 CompileUnit *SPCU = CUMap.lookup(TheCU);
996 assert(SPCU && "Unable to find Compile Unit!");
997 DIE *SPDIE = SPCU->getDIE(SP);
998 assert(SPDIE && "Subprogram wasn't created?");
999 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1000 DIVariable DV(Variables.getElement(vi));
1001 if (!DV.isVariable())
1003 DbgVariable NewVar(DV, NULL, this);
1004 if (DIE *VariableDIE =
1005 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
1006 SPDIE->addChild(VariableDIE);
1011 DeleteContainerSeconds(DeadFnScopeMap);
1014 // Type Signature [7.27] and ODR Hash code.
1016 /// \brief Grabs the string in whichever attribute is passed in and returns
1017 /// a reference to it. Returns "" if the attribute doesn't exist.
1018 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1019 DIEValue *V = Die->findAttribute(Attr);
1021 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1022 return S->getString();
1024 return StringRef("");
1027 /// Return true if the current DIE is contained within an anonymous namespace.
1028 static bool isContainedInAnonNamespace(DIE *Die) {
1029 DIE *Parent = Die->getParent();
1032 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1033 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1035 Parent = Parent->getParent();
1041 /// Test if the current CU language is C++ and that we have
1042 /// a named type that is not contained in an anonymous namespace.
1043 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1044 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1045 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1046 !isContainedInAnonNamespace(Die);
1049 void DwarfDebug::finalizeModuleInfo() {
1050 // Collect info for variables that were optimized out.
1051 collectDeadVariables();
1053 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1054 computeInlinedDIEs();
1056 // Split out type units and conditionally add an ODR tag to the split
1058 // FIXME: Do type splitting.
1059 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1060 DIE *Die = TypeUnits[i];
1062 // If we've requested ODR hashes and it's applicable for an ODR hash then
1063 // add the ODR signature now.
1064 // FIXME: This should be added onto the type unit, not the type, but this
1065 // works as an intermediate stage.
1066 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1067 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1068 dwarf::DW_FORM_data8,
1069 Hash.computeDIEODRSignature(Die));
1072 // Handle anything that needs to be done on a per-cu basis.
1073 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1075 CUI != CUE; ++CUI) {
1076 CompileUnit *TheCU = CUI->second;
1077 // Emit DW_AT_containing_type attribute to connect types with their
1078 // vtable holding type.
1079 TheCU->constructContainingTypeDIEs();
1081 // If we're splitting the dwarf out now that we've got the entire
1082 // CU then construct a skeleton CU based upon it.
1083 if (useSplitDwarf()) {
1085 if (GenerateCUHash) {
1087 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1089 // This should be a unique identifier when we want to build .dwp files.
1090 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1091 dwarf::DW_FORM_data8, ID);
1092 // Now construct the skeleton CU associated.
1093 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1094 // This should be a unique identifier when we want to build .dwp files.
1095 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1096 dwarf::DW_FORM_data8, ID);
1100 // Compute DIE offsets and sizes.
1101 InfoHolder.computeSizeAndOffsets();
1102 if (useSplitDwarf())
1103 SkeletonHolder.computeSizeAndOffsets();
1106 void DwarfDebug::endSections() {
1107 // Filter labels by section.
1108 for (size_t n = 0; n < ArangeLabels.size(); n++) {
1109 const SymbolCU &SCU = ArangeLabels[n];
1110 if (SCU.Sym->isInSection()) {
1111 // Make a note of this symbol and it's section.
1112 const MCSection *Section = &SCU.Sym->getSection();
1113 if (!Section->getKind().isMetadata())
1114 SectionMap[Section].push_back(SCU);
1116 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1117 // appear in the output. This sucks as we rely on sections to build
1118 // arange spans. We can do it without, but it's icky.
1119 SectionMap[NULL].push_back(SCU);
1123 // Build a list of sections used.
1124 std::vector<const MCSection *> Sections;
1125 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1127 const MCSection *Section = it->first;
1128 Sections.push_back(Section);
1131 // Sort the sections into order.
1132 // This is only done to ensure consistent output order across different runs.
1133 std::sort(Sections.begin(), Sections.end(), SectionSort);
1135 // Add terminating symbols for each section.
1136 for (unsigned ID=0;ID<Sections.size();ID++) {
1137 const MCSection *Section = Sections[ID];
1138 MCSymbol *Sym = NULL;
1141 // We can't call MCSection::getLabelEndName, as it's only safe to do so
1142 // if we know the section name up-front. For user-created sections, the resulting
1143 // label may not be valid to use as a label. (section names can use a greater
1144 // set of characters on some systems)
1145 Sym = Asm->GetTempSymbol("debug_end", ID);
1146 Asm->OutStreamer.SwitchSection(Section);
1147 Asm->OutStreamer.EmitLabel(Sym);
1150 // Insert a final terminator.
1151 SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1155 // Emit all Dwarf sections that should come after the content.
1156 void DwarfDebug::endModule() {
1158 if (!FirstCU) return;
1160 // End any existing sections.
1161 // TODO: Does this need to happen?
1164 // Finalize the debug info for the module.
1165 finalizeModuleInfo();
1167 if (!useSplitDwarf()) {
1170 // Emit all the DIEs into a debug info section.
1173 // Corresponding abbreviations into a abbrev section.
1174 emitAbbreviations();
1176 // Emit info into a debug loc section.
1179 // Emit info into a debug aranges section.
1182 // Emit info into a debug ranges section.
1185 // Emit info into a debug macinfo section.
1189 // TODO: Fill this in for separated debug sections and separate
1190 // out information into new sections.
1192 if (useSplitDwarf())
1195 // Emit the debug info section and compile units.
1199 // Corresponding abbreviations into a abbrev section.
1200 emitAbbreviations();
1201 emitDebugAbbrevDWO();
1203 // Emit info into a debug loc section.
1206 // Emit info into a debug aranges section.
1209 // Emit info into a debug ranges section.
1212 // Emit info into a debug macinfo section.
1215 // Emit DWO addresses.
1216 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1220 // Emit info into the dwarf accelerator table sections.
1221 if (useDwarfAccelTables()) {
1224 emitAccelNamespaces();
1228 // Emit the pubnames and pubtypes sections if requested.
1229 if (HasDwarfPubSections) {
1230 emitDebugPubNames(GenerateGnuPubSections);
1231 emitDebugPubTypes(GenerateGnuPubSections);
1236 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1237 E = CUMap.end(); I != E; ++I)
1240 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1241 E = SkeletonCUs.end(); I != E; ++I)
1244 // Reset these for the next Module if we have one.
1248 // Find abstract variable, if any, associated with Var.
1249 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1250 DebugLoc ScopeLoc) {
1251 LLVMContext &Ctx = DV->getContext();
1252 // More then one inlined variable corresponds to one abstract variable.
1253 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1254 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1256 return AbsDbgVariable;
1258 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1262 AbsDbgVariable = new DbgVariable(Var, NULL, this);
1263 addScopeVariable(Scope, AbsDbgVariable);
1264 AbstractVariables[Var] = AbsDbgVariable;
1265 return AbsDbgVariable;
1268 // If Var is a current function argument then add it to CurrentFnArguments list.
1269 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1270 DbgVariable *Var, LexicalScope *Scope) {
1271 if (!LScopes.isCurrentFunctionScope(Scope))
1273 DIVariable DV = Var->getVariable();
1274 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1276 unsigned ArgNo = DV.getArgNumber();
1280 size_t Size = CurrentFnArguments.size();
1282 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1283 // llvm::Function argument size is not good indicator of how many
1284 // arguments does the function have at source level.
1286 CurrentFnArguments.resize(ArgNo * 2);
1287 CurrentFnArguments[ArgNo - 1] = Var;
1291 // Collect variable information from side table maintained by MMI.
1293 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1294 SmallPtrSet<const MDNode *, 16> &Processed) {
1295 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1296 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1297 VE = VMap.end(); VI != VE; ++VI) {
1298 const MDNode *Var = VI->first;
1300 Processed.insert(Var);
1302 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1304 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1306 // If variable scope is not found then skip this variable.
1310 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1311 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1312 RegVar->setFrameIndex(VP.first);
1313 if (!addCurrentFnArgument(MF, RegVar, Scope))
1314 addScopeVariable(Scope, RegVar);
1316 AbsDbgVariable->setFrameIndex(VP.first);
1320 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1322 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1323 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1324 return MI->getNumOperands() == 3 &&
1325 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1326 (MI->getOperand(1).isImm() ||
1327 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1330 // Get .debug_loc entry for the instruction range starting at MI.
1331 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1332 const MCSymbol *FLabel,
1333 const MCSymbol *SLabel,
1334 const MachineInstr *MI) {
1335 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1337 assert(MI->getNumOperands() == 3);
1338 if (MI->getOperand(0).isReg()) {
1339 MachineLocation MLoc;
1340 // If the second operand is an immediate, this is a
1341 // register-indirect address.
1342 if (!MI->getOperand(1).isImm())
1343 MLoc.set(MI->getOperand(0).getReg());
1345 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1346 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1348 if (MI->getOperand(0).isImm())
1349 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1350 if (MI->getOperand(0).isFPImm())
1351 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1352 if (MI->getOperand(0).isCImm())
1353 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1355 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1358 // Find variables for each lexical scope.
1360 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1361 SmallPtrSet<const MDNode *, 16> &Processed) {
1363 // Grab the variable info that was squirreled away in the MMI side-table.
1364 collectVariableInfoFromMMITable(MF, Processed);
1366 for (SmallVectorImpl<const MDNode*>::const_iterator
1367 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1369 const MDNode *Var = *UVI;
1370 if (Processed.count(Var))
1373 // History contains relevant DBG_VALUE instructions for Var and instructions
1375 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1376 if (History.empty())
1378 const MachineInstr *MInsn = History.front();
1381 LexicalScope *Scope = NULL;
1382 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1383 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1384 Scope = LScopes.getCurrentFunctionScope();
1385 else if (MDNode *IA = DV.getInlinedAt())
1386 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1388 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1389 // If variable scope is not found then skip this variable.
1393 Processed.insert(DV);
1394 assert(MInsn->isDebugValue() && "History must begin with debug value");
1395 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1396 DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1397 if (!addCurrentFnArgument(MF, RegVar, Scope))
1398 addScopeVariable(Scope, RegVar);
1400 AbsVar->setMInsn(MInsn);
1402 // Simplify ranges that are fully coalesced.
1403 if (History.size() <= 1 || (History.size() == 2 &&
1404 MInsn->isIdenticalTo(History.back()))) {
1405 RegVar->setMInsn(MInsn);
1409 // Handle multiple DBG_VALUE instructions describing one variable.
1410 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1412 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1413 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1414 const MachineInstr *Begin = *HI;
1415 assert(Begin->isDebugValue() && "Invalid History entry");
1417 // Check if DBG_VALUE is truncating a range.
1418 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1419 && !Begin->getOperand(0).getReg())
1422 // Compute the range for a register location.
1423 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1424 const MCSymbol *SLabel = 0;
1427 // If Begin is the last instruction in History then its value is valid
1428 // until the end of the function.
1429 SLabel = FunctionEndSym;
1431 const MachineInstr *End = HI[1];
1432 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1433 << "\t" << *Begin << "\t" << *End << "\n");
1434 if (End->isDebugValue())
1435 SLabel = getLabelBeforeInsn(End);
1437 // End is a normal instruction clobbering the range.
1438 SLabel = getLabelAfterInsn(End);
1439 assert(SLabel && "Forgot label after clobber instruction");
1444 // The value is valid until the next DBG_VALUE or clobber.
1445 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1448 DotDebugLocEntries.push_back(DotDebugLocEntry());
1451 // Collect info for variables that were optimized out.
1452 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1453 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1454 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1455 DIVariable DV(Variables.getElement(i));
1456 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1458 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1459 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1463 // Return Label preceding the instruction.
1464 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1465 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1466 assert(Label && "Didn't insert label before instruction");
1470 // Return Label immediately following the instruction.
1471 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1472 return LabelsAfterInsn.lookup(MI);
1475 // Process beginning of an instruction.
1476 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1477 // Check if source location changes, but ignore DBG_VALUE locations.
1478 if (!MI->isDebugValue()) {
1479 DebugLoc DL = MI->getDebugLoc();
1480 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1483 if (DL == PrologEndLoc) {
1484 Flags |= DWARF2_FLAG_PROLOGUE_END;
1485 PrologEndLoc = DebugLoc();
1487 if (PrologEndLoc.isUnknown())
1488 Flags |= DWARF2_FLAG_IS_STMT;
1490 if (!DL.isUnknown()) {
1491 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1492 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1494 recordSourceLine(0, 0, 0, 0);
1498 // Insert labels where requested.
1499 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1500 LabelsBeforeInsn.find(MI);
1503 if (I == LabelsBeforeInsn.end())
1506 // Label already assigned.
1511 PrevLabel = MMI->getContext().CreateTempSymbol();
1512 Asm->OutStreamer.EmitLabel(PrevLabel);
1514 I->second = PrevLabel;
1517 // Process end of an instruction.
1518 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1519 // Don't create a new label after DBG_VALUE instructions.
1520 // They don't generate code.
1521 if (!MI->isDebugValue())
1524 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1525 LabelsAfterInsn.find(MI);
1528 if (I == LabelsAfterInsn.end())
1531 // Label already assigned.
1535 // We need a label after this instruction.
1537 PrevLabel = MMI->getContext().CreateTempSymbol();
1538 Asm->OutStreamer.EmitLabel(PrevLabel);
1540 I->second = PrevLabel;
1543 // Each LexicalScope has first instruction and last instruction to mark
1544 // beginning and end of a scope respectively. Create an inverse map that list
1545 // scopes starts (and ends) with an instruction. One instruction may start (or
1546 // end) multiple scopes. Ignore scopes that are not reachable.
1547 void DwarfDebug::identifyScopeMarkers() {
1548 SmallVector<LexicalScope *, 4> WorkList;
1549 WorkList.push_back(LScopes.getCurrentFunctionScope());
1550 while (!WorkList.empty()) {
1551 LexicalScope *S = WorkList.pop_back_val();
1553 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1554 if (!Children.empty())
1555 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1556 SE = Children.end(); SI != SE; ++SI)
1557 WorkList.push_back(*SI);
1559 if (S->isAbstractScope())
1562 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1565 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1566 RE = Ranges.end(); RI != RE; ++RI) {
1567 assert(RI->first && "InsnRange does not have first instruction!");
1568 assert(RI->second && "InsnRange does not have second instruction!");
1569 requestLabelBeforeInsn(RI->first);
1570 requestLabelAfterInsn(RI->second);
1575 // Get MDNode for DebugLoc's scope.
1576 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1577 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1578 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1579 return DL.getScope(Ctx);
1582 // Walk up the scope chain of given debug loc and find line number info
1583 // for the function.
1584 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1585 const MDNode *Scope = getScopeNode(DL, Ctx);
1586 DISubprogram SP = getDISubprogram(Scope);
1587 if (SP.isSubprogram()) {
1588 // Check for number of operands since the compatibility is
1590 if (SP->getNumOperands() > 19)
1591 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1593 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1599 // Gather pre-function debug information. Assumes being called immediately
1600 // after the function entry point has been emitted.
1601 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1602 if (!MMI->hasDebugInfo()) return;
1603 LScopes.initialize(*MF);
1604 if (LScopes.empty()) return;
1605 identifyScopeMarkers();
1607 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1609 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1610 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1611 assert(TheCU && "Unable to find compile unit!");
1612 if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1613 // Use a single line table if we are using .loc and generating assembly.
1614 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1616 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1618 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1619 Asm->getFunctionNumber());
1620 // Assumes in correct section after the entry point.
1621 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1623 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1625 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1626 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1627 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1629 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1631 bool AtBlockEntry = true;
1632 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1634 const MachineInstr *MI = II;
1636 if (MI->isDebugValue()) {
1637 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1639 // Keep track of user variables.
1641 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1643 // Variable is in a register, we need to check for clobbers.
1644 if (isDbgValueInDefinedReg(MI))
1645 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1647 // Check the history of this variable.
1648 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1649 if (History.empty()) {
1650 UserVariables.push_back(Var);
1651 // The first mention of a function argument gets the FunctionBeginSym
1652 // label, so arguments are visible when breaking at function entry.
1654 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1655 DISubprogram(getDISubprogram(DV.getContext()))
1656 .describes(MF->getFunction()))
1657 LabelsBeforeInsn[MI] = FunctionBeginSym;
1659 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1660 const MachineInstr *Prev = History.back();
1661 if (Prev->isDebugValue()) {
1662 // Coalesce identical entries at the end of History.
1663 if (History.size() >= 2 &&
1664 Prev->isIdenticalTo(History[History.size() - 2])) {
1665 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1667 << "\t" << *History[History.size() - 2] << "\n");
1671 // Terminate old register assignments that don't reach MI;
1672 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1673 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1674 isDbgValueInDefinedReg(Prev)) {
1675 // Previous register assignment needs to terminate at the end of
1677 MachineBasicBlock::const_iterator LastMI =
1678 PrevMBB->getLastNonDebugInstr();
1679 if (LastMI == PrevMBB->end()) {
1680 // Drop DBG_VALUE for empty range.
1681 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1682 << "\t" << *Prev << "\n");
1684 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1685 // Terminate after LastMI.
1686 History.push_back(LastMI);
1690 History.push_back(MI);
1692 // Not a DBG_VALUE instruction.
1694 AtBlockEntry = false;
1696 // First known non-DBG_VALUE and non-frame setup location marks
1697 // the beginning of the function body.
1698 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1699 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1700 PrologEndLoc = MI->getDebugLoc();
1702 // Check if the instruction clobbers any registers with debug vars.
1703 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1704 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1705 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1707 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1708 AI.isValid(); ++AI) {
1710 const MDNode *Var = LiveUserVar[Reg];
1713 // Reg is now clobbered.
1714 LiveUserVar[Reg] = 0;
1716 // Was MD last defined by a DBG_VALUE referring to Reg?
1717 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1718 if (HistI == DbgValues.end())
1720 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1721 if (History.empty())
1723 const MachineInstr *Prev = History.back();
1724 // Sanity-check: Register assignments are terminated at the end of
1726 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1728 // Is the variable still in Reg?
1729 if (!isDbgValueInDefinedReg(Prev) ||
1730 Prev->getOperand(0).getReg() != Reg)
1732 // Var is clobbered. Make sure the next instruction gets a label.
1733 History.push_back(MI);
1740 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1742 SmallVectorImpl<const MachineInstr*> &History = I->second;
1743 if (History.empty())
1746 // Make sure the final register assignments are terminated.
1747 const MachineInstr *Prev = History.back();
1748 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1749 const MachineBasicBlock *PrevMBB = Prev->getParent();
1750 MachineBasicBlock::const_iterator LastMI =
1751 PrevMBB->getLastNonDebugInstr();
1752 if (LastMI == PrevMBB->end())
1753 // Drop DBG_VALUE for empty range.
1755 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1756 // Terminate after LastMI.
1757 History.push_back(LastMI);
1760 // Request labels for the full history.
1761 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1762 const MachineInstr *MI = History[i];
1763 if (MI->isDebugValue())
1764 requestLabelBeforeInsn(MI);
1766 requestLabelAfterInsn(MI);
1770 PrevInstLoc = DebugLoc();
1771 PrevLabel = FunctionBeginSym;
1773 // Record beginning of function.
1774 if (!PrologEndLoc.isUnknown()) {
1775 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1776 MF->getFunction()->getContext());
1777 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1778 FnStartDL.getScope(MF->getFunction()->getContext()),
1779 // We'd like to list the prologue as "not statements" but GDB behaves
1780 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1781 DWARF2_FLAG_IS_STMT);
1785 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1786 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1787 DIVariable DV = Var->getVariable();
1788 // Variables with positive arg numbers are parameters.
1789 if (unsigned ArgNum = DV.getArgNumber()) {
1790 // Keep all parameters in order at the start of the variable list to ensure
1791 // function types are correct (no out-of-order parameters)
1793 // This could be improved by only doing it for optimized builds (unoptimized
1794 // builds have the right order to begin with), searching from the back (this
1795 // would catch the unoptimized case quickly), or doing a binary search
1796 // rather than linear search.
1797 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1798 while (I != Vars.end()) {
1799 unsigned CurNum = (*I)->getVariable().getArgNumber();
1800 // A local (non-parameter) variable has been found, insert immediately
1804 // A later indexed parameter has been found, insert immediately before it.
1805 if (CurNum > ArgNum)
1809 Vars.insert(I, Var);
1813 Vars.push_back(Var);
1816 // Gather and emit post-function debug information.
1817 void DwarfDebug::endFunction(const MachineFunction *MF) {
1818 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1820 // Define end label for subprogram.
1821 FunctionEndSym = Asm->GetTempSymbol("func_end",
1822 Asm->getFunctionNumber());
1823 // Assumes in correct section after the entry point.
1824 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1825 // Set DwarfCompileUnitID in MCContext to default value.
1826 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1828 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1829 collectVariableInfo(MF, ProcessedVars);
1831 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1832 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1833 assert(TheCU && "Unable to find compile unit!");
1835 // Construct abstract scopes.
1836 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1837 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1838 LexicalScope *AScope = AList[i];
1839 DISubprogram SP(AScope->getScopeNode());
1840 if (SP.isSubprogram()) {
1841 // Collect info for variables that were optimized out.
1842 DIArray Variables = SP.getVariables();
1843 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1844 DIVariable DV(Variables.getElement(i));
1845 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1847 // Check that DbgVariable for DV wasn't created earlier, when
1848 // findAbstractVariable() was called for inlined instance of DV.
1849 LLVMContext &Ctx = DV->getContext();
1850 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1851 if (AbstractVariables.lookup(CleanDV))
1853 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1854 addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1857 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1858 constructScopeDIE(TheCU, AScope);
1861 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1863 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1864 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1867 for (ScopeVariablesMap::iterator
1868 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1869 DeleteContainerPointers(I->second);
1870 ScopeVariables.clear();
1871 DeleteContainerPointers(CurrentFnArguments);
1872 UserVariables.clear();
1874 AbstractVariables.clear();
1875 LabelsBeforeInsn.clear();
1876 LabelsAfterInsn.clear();
1880 // Register a source line with debug info. Returns the unique label that was
1881 // emitted and which provides correspondence to the source line list.
1882 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1888 DIDescriptor Scope(S);
1890 if (Scope.isCompileUnit()) {
1891 DICompileUnit CU(S);
1892 Fn = CU.getFilename();
1893 Dir = CU.getDirectory();
1894 } else if (Scope.isFile()) {
1896 Fn = F.getFilename();
1897 Dir = F.getDirectory();
1898 } else if (Scope.isSubprogram()) {
1900 Fn = SP.getFilename();
1901 Dir = SP.getDirectory();
1902 } else if (Scope.isLexicalBlockFile()) {
1903 DILexicalBlockFile DBF(S);
1904 Fn = DBF.getFilename();
1905 Dir = DBF.getDirectory();
1906 } else if (Scope.isLexicalBlock()) {
1907 DILexicalBlock DB(S);
1908 Fn = DB.getFilename();
1909 Dir = DB.getDirectory();
1911 llvm_unreachable("Unexpected scope info");
1913 Src = getOrCreateSourceID(Fn, Dir,
1914 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1916 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1919 //===----------------------------------------------------------------------===//
1921 //===----------------------------------------------------------------------===//
1923 // Compute the size and offset of a DIE.
1925 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1926 // Get the children.
1927 const std::vector<DIE *> &Children = Die->getChildren();
1929 // Record the abbreviation.
1930 assignAbbrevNumber(Die->getAbbrev());
1932 // Get the abbreviation for this DIE.
1933 unsigned AbbrevNumber = Die->getAbbrevNumber();
1934 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1937 Die->setOffset(Offset);
1939 // Start the size with the size of abbreviation code.
1940 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1942 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1943 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1945 // Size the DIE attribute values.
1946 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1947 // Size attribute value.
1948 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1950 // Size the DIE children if any.
1951 if (!Children.empty()) {
1952 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1953 "Children flag not set");
1955 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1956 Offset = computeSizeAndOffset(Children[j], Offset);
1958 // End of children marker.
1959 Offset += sizeof(int8_t);
1962 Die->setSize(Offset - Die->getOffset());
1966 // Compute the size and offset of all the DIEs.
1967 void DwarfUnits::computeSizeAndOffsets() {
1968 // Offset from the beginning of debug info section.
1969 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1970 E = CUs.end(); I != E; ++I) {
1972 sizeof(int32_t) + // Length of Compilation Unit Info
1973 sizeof(int16_t) + // DWARF version number
1974 sizeof(int32_t) + // Offset Into Abbrev. Section
1975 sizeof(int8_t); // Pointer Size (in bytes)
1976 computeSizeAndOffset((*I)->getCUDie(), Offset);
1980 // Emit initial Dwarf sections with a label at the start of each one.
1981 void DwarfDebug::emitSectionLabels() {
1982 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1984 // Dwarf sections base addresses.
1985 DwarfInfoSectionSym =
1986 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1987 DwarfAbbrevSectionSym =
1988 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1989 if (useSplitDwarf())
1990 DwarfAbbrevDWOSectionSym =
1991 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1992 "section_abbrev_dwo");
1993 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1995 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1996 emitSectionSym(Asm, MacroInfo);
1998 DwarfLineSectionSym =
1999 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2000 emitSectionSym(Asm, TLOF.getDwarfLocSection());
2001 if (GenerateGnuPubSections) {
2002 DwarfGnuPubNamesSectionSym =
2003 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
2004 DwarfGnuPubTypesSectionSym =
2005 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
2006 } else if (HasDwarfPubSections) {
2007 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2008 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2011 DwarfStrSectionSym =
2012 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2013 if (useSplitDwarf()) {
2014 DwarfStrDWOSectionSym =
2015 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2016 DwarfAddrSectionSym =
2017 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2019 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2022 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2023 "section_debug_loc");
2025 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2026 emitSectionSym(Asm, TLOF.getDataSection());
2029 // Recursively emits a debug information entry.
2030 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2031 // Get the abbreviation for this DIE.
2032 unsigned AbbrevNumber = Die->getAbbrevNumber();
2033 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2035 // Emit the code (index) for the abbreviation.
2036 if (Asm->isVerbose())
2037 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2038 Twine::utohexstr(Die->getOffset()) + ":0x" +
2039 Twine::utohexstr(Die->getSize()) + " " +
2040 dwarf::TagString(Abbrev->getTag()));
2041 Asm->EmitULEB128(AbbrevNumber);
2043 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2044 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2046 // Emit the DIE attribute values.
2047 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2048 unsigned Attr = AbbrevData[i].getAttribute();
2049 unsigned Form = AbbrevData[i].getForm();
2050 assert(Form && "Too many attributes for DIE (check abbreviation)");
2052 if (Asm->isVerbose())
2053 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2056 case dwarf::DW_AT_abstract_origin: {
2057 DIEEntry *E = cast<DIEEntry>(Values[i]);
2058 DIE *Origin = E->getEntry();
2059 unsigned Addr = Origin->getOffset();
2060 Asm->EmitInt32(Addr);
2063 case dwarf::DW_AT_ranges: {
2064 // DW_AT_range Value encodes offset in debug_range section.
2065 DIEInteger *V = cast<DIEInteger>(Values[i]);
2067 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2068 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2072 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2074 DwarfDebugRangeSectionSym,
2079 case dwarf::DW_AT_location: {
2080 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2081 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2082 Asm->EmitLabelReference(L->getValue(), 4);
2084 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2086 Values[i]->EmitValue(Asm, Form);
2090 case dwarf::DW_AT_accessibility: {
2091 if (Asm->isVerbose()) {
2092 DIEInteger *V = cast<DIEInteger>(Values[i]);
2093 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2095 Values[i]->EmitValue(Asm, Form);
2099 // Emit an attribute using the defined form.
2100 Values[i]->EmitValue(Asm, Form);
2105 // Emit the DIE children if any.
2106 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2107 const std::vector<DIE *> &Children = Die->getChildren();
2109 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2110 emitDIE(Children[j], Abbrevs);
2112 if (Asm->isVerbose())
2113 Asm->OutStreamer.AddComment("End Of Children Mark");
2118 // Emit the various dwarf units to the unit section USection with
2119 // the abbreviations going into ASection.
2120 void DwarfUnits::emitUnits(DwarfDebug *DD,
2121 const MCSection *USection,
2122 const MCSection *ASection,
2123 const MCSymbol *ASectionSym) {
2124 Asm->OutStreamer.SwitchSection(USection);
2125 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2126 E = CUs.end(); I != E; ++I) {
2127 CompileUnit *TheCU = *I;
2128 DIE *Die = TheCU->getCUDie();
2130 // Emit the compile units header.
2132 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2133 TheCU->getUniqueID()));
2135 // Emit size of content not including length itself
2136 unsigned ContentSize = Die->getSize() +
2137 sizeof(int16_t) + // DWARF version number
2138 sizeof(int32_t) + // Offset Into Abbrev. Section
2139 sizeof(int8_t); // Pointer Size (in bytes)
2141 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2142 Asm->EmitInt32(ContentSize);
2143 Asm->OutStreamer.AddComment("DWARF version number");
2144 Asm->EmitInt16(DD->getDwarfVersion());
2145 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2146 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2148 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2149 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2151 DD->emitDIE(Die, Abbreviations);
2152 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2153 TheCU->getUniqueID()));
2157 // Emit the debug info section.
2158 void DwarfDebug::emitDebugInfo() {
2159 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2161 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2162 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2163 DwarfAbbrevSectionSym);
2166 // Emit the abbreviation section.
2167 void DwarfDebug::emitAbbreviations() {
2168 if (!useSplitDwarf())
2169 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2172 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2175 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2176 std::vector<DIEAbbrev *> *Abbrevs) {
2177 // Check to see if it is worth the effort.
2178 if (!Abbrevs->empty()) {
2179 // Start the debug abbrev section.
2180 Asm->OutStreamer.SwitchSection(Section);
2182 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2183 Asm->OutStreamer.EmitLabel(Begin);
2185 // For each abbrevation.
2186 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2187 // Get abbreviation data
2188 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2190 // Emit the abbrevations code (base 1 index.)
2191 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2193 // Emit the abbreviations data.
2197 // Mark end of abbreviations.
2198 Asm->EmitULEB128(0, "EOM(3)");
2200 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2201 Asm->OutStreamer.EmitLabel(End);
2205 // Emit the last address of the section and the end of the line matrix.
2206 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2207 // Define last address of section.
2208 Asm->OutStreamer.AddComment("Extended Op");
2211 Asm->OutStreamer.AddComment("Op size");
2212 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2213 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2214 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2216 Asm->OutStreamer.AddComment("Section end label");
2218 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2219 Asm->getDataLayout().getPointerSize());
2221 // Mark end of matrix.
2222 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2228 // Emit visible names into a hashed accelerator table section.
2229 void DwarfDebug::emitAccelNames() {
2230 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2231 dwarf::DW_FORM_data4));
2232 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2233 E = CUMap.end(); I != E; ++I) {
2234 CompileUnit *TheCU = I->second;
2235 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2236 for (StringMap<std::vector<DIE*> >::const_iterator
2237 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2238 StringRef Name = GI->getKey();
2239 const std::vector<DIE *> &Entities = GI->second;
2240 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2241 DE = Entities.end(); DI != DE; ++DI)
2242 AT.AddName(Name, (*DI));
2246 AT.FinalizeTable(Asm, "Names");
2247 Asm->OutStreamer.SwitchSection(
2248 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2249 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2250 Asm->OutStreamer.EmitLabel(SectionBegin);
2252 // Emit the full data.
2253 AT.Emit(Asm, SectionBegin, &InfoHolder);
2256 // Emit objective C classes and categories into a hashed accelerator table
2258 void DwarfDebug::emitAccelObjC() {
2259 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2260 dwarf::DW_FORM_data4));
2261 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2262 E = CUMap.end(); I != E; ++I) {
2263 CompileUnit *TheCU = I->second;
2264 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2265 for (StringMap<std::vector<DIE*> >::const_iterator
2266 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2267 StringRef Name = GI->getKey();
2268 const std::vector<DIE *> &Entities = GI->second;
2269 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2270 DE = Entities.end(); DI != DE; ++DI)
2271 AT.AddName(Name, (*DI));
2275 AT.FinalizeTable(Asm, "ObjC");
2276 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2277 .getDwarfAccelObjCSection());
2278 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2279 Asm->OutStreamer.EmitLabel(SectionBegin);
2281 // Emit the full data.
2282 AT.Emit(Asm, SectionBegin, &InfoHolder);
2285 // Emit namespace dies into a hashed accelerator table.
2286 void DwarfDebug::emitAccelNamespaces() {
2287 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2288 dwarf::DW_FORM_data4));
2289 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2290 E = CUMap.end(); I != E; ++I) {
2291 CompileUnit *TheCU = I->second;
2292 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2293 for (StringMap<std::vector<DIE*> >::const_iterator
2294 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2295 StringRef Name = GI->getKey();
2296 const std::vector<DIE *> &Entities = GI->second;
2297 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2298 DE = Entities.end(); DI != DE; ++DI)
2299 AT.AddName(Name, (*DI));
2303 AT.FinalizeTable(Asm, "namespac");
2304 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2305 .getDwarfAccelNamespaceSection());
2306 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2307 Asm->OutStreamer.EmitLabel(SectionBegin);
2309 // Emit the full data.
2310 AT.Emit(Asm, SectionBegin, &InfoHolder);
2313 // Emit type dies into a hashed accelerator table.
2314 void DwarfDebug::emitAccelTypes() {
2315 std::vector<DwarfAccelTable::Atom> Atoms;
2316 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2317 dwarf::DW_FORM_data4));
2318 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2319 dwarf::DW_FORM_data2));
2320 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2321 dwarf::DW_FORM_data1));
2322 DwarfAccelTable AT(Atoms);
2323 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2324 E = CUMap.end(); I != E; ++I) {
2325 CompileUnit *TheCU = I->second;
2326 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2327 = TheCU->getAccelTypes();
2328 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2329 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2330 StringRef Name = GI->getKey();
2331 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2332 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2333 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2334 AT.AddName(Name, (*DI).first, (*DI).second);
2338 AT.FinalizeTable(Asm, "types");
2339 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2340 .getDwarfAccelTypesSection());
2341 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2342 Asm->OutStreamer.EmitLabel(SectionBegin);
2344 // Emit the full data.
2345 AT.Emit(Asm, SectionBegin, &InfoHolder);
2348 // Public name handling.
2349 // The format for the various pubnames:
2351 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2352 // for the DIE that is named.
2354 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2355 // into the CU and the index value is computed according to the type of value
2356 // for the DIE that is named.
2358 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2359 // it's the offset within the debug_info/debug_types dwo section, however, the
2360 // reference in the pubname header doesn't change.
2362 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2363 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2365 dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2367 // We could have a specification DIE that has our most of our knowledge,
2368 // look for that now.
2369 DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2371 DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2372 if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2373 Linkage = dwarf::GIEL_EXTERNAL;
2374 } else if (Die->findAttribute(dwarf::DW_AT_external))
2375 Linkage = dwarf::GIEL_EXTERNAL;
2377 switch (Die->getTag()) {
2378 case dwarf::DW_TAG_class_type:
2379 case dwarf::DW_TAG_structure_type:
2380 case dwarf::DW_TAG_union_type:
2381 case dwarf::DW_TAG_enumeration_type:
2382 return dwarf::PubIndexEntryDescriptor(
2383 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2384 ? dwarf::GIEL_STATIC
2385 : dwarf::GIEL_EXTERNAL);
2386 case dwarf::DW_TAG_typedef:
2387 case dwarf::DW_TAG_base_type:
2388 case dwarf::DW_TAG_subrange_type:
2389 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2390 case dwarf::DW_TAG_namespace:
2391 return dwarf::GIEK_TYPE;
2392 case dwarf::DW_TAG_subprogram:
2393 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2394 case dwarf::DW_TAG_constant:
2395 case dwarf::DW_TAG_variable:
2396 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2397 case dwarf::DW_TAG_enumerator:
2398 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2399 dwarf::GIEL_STATIC);
2401 return dwarf::GIEK_NONE;
2405 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2407 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2408 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2409 const MCSection *PSec =
2410 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2411 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2413 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2414 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2415 CompileUnit *TheCU = I->second;
2416 unsigned ID = TheCU->getUniqueID();
2418 // Start the dwarf pubnames section.
2419 Asm->OutStreamer.SwitchSection(PSec);
2421 // Emit a label so we can reference the beginning of this pubname section.
2423 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames",
2424 TheCU->getUniqueID()));
2427 Asm->OutStreamer.AddComment("Length of Public Names Info");
2428 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2429 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2431 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2433 Asm->OutStreamer.AddComment("DWARF Version");
2434 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2436 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2437 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2438 DwarfInfoSectionSym);
2440 Asm->OutStreamer.AddComment("Compilation Unit Length");
2441 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2442 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2445 // Emit the pubnames for this compilation unit.
2446 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2447 for (StringMap<DIE*>::const_iterator
2448 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2449 const char *Name = GI->getKeyData();
2450 DIE *Entity = GI->second;
2452 Asm->OutStreamer.AddComment("DIE offset");
2453 Asm->EmitInt32(Entity->getOffset());
2456 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2457 Asm->OutStreamer.AddComment(
2458 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2459 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2460 Asm->EmitInt8(Desc.toBits());
2463 if (Asm->isVerbose())
2464 Asm->OutStreamer.AddComment("External Name");
2465 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2468 Asm->OutStreamer.AddComment("End Mark");
2470 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2474 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2475 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2476 const MCSection *PSec =
2477 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2478 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2480 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2483 CompileUnit *TheCU = I->second;
2484 // Start the dwarf pubtypes section.
2485 Asm->OutStreamer.SwitchSection(PSec);
2487 // Emit a label so we can reference the beginning of this pubtype section.
2489 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes",
2490 TheCU->getUniqueID()));
2493 Asm->OutStreamer.AddComment("Length of Public Types Info");
2494 Asm->EmitLabelDifference(
2495 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2496 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2498 Asm->OutStreamer.EmitLabel(
2499 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2501 if (Asm->isVerbose())
2502 Asm->OutStreamer.AddComment("DWARF Version");
2503 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2505 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2506 Asm->EmitSectionOffset(
2507 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2508 DwarfInfoSectionSym);
2510 Asm->OutStreamer.AddComment("Compilation Unit Length");
2511 Asm->EmitLabelDifference(
2512 Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2513 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2515 // Emit the pubtypes.
2516 const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2517 for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2520 const char *Name = GI->getKeyData();
2521 DIE *Entity = GI->second;
2523 if (Asm->isVerbose())
2524 Asm->OutStreamer.AddComment("DIE offset");
2525 Asm->EmitInt32(Entity->getOffset());
2528 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2529 Asm->OutStreamer.AddComment(
2530 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2531 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2532 Asm->EmitInt8(Desc.toBits());
2535 if (Asm->isVerbose())
2536 Asm->OutStreamer.AddComment("External Name");
2538 // Emit the name with a terminating null byte.
2539 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2542 Asm->OutStreamer.AddComment("End Mark");
2544 Asm->OutStreamer.EmitLabel(
2545 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2549 // Emit strings into a string section.
2550 void DwarfUnits::emitStrings(const MCSection *StrSection,
2551 const MCSection *OffsetSection = NULL,
2552 const MCSymbol *StrSecSym = NULL) {
2554 if (StringPool.empty()) return;
2556 // Start the dwarf str section.
2557 Asm->OutStreamer.SwitchSection(StrSection);
2559 // Get all of the string pool entries and put them in an array by their ID so
2560 // we can sort them.
2561 SmallVector<std::pair<unsigned,
2562 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2564 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2565 I = StringPool.begin(), E = StringPool.end();
2567 Entries.push_back(std::make_pair(I->second.second, &*I));
2569 array_pod_sort(Entries.begin(), Entries.end());
2571 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2572 // Emit a label for reference from debug information entries.
2573 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2575 // Emit the string itself with a terminating null byte.
2576 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2577 Entries[i].second->getKeyLength()+1));
2580 // If we've got an offset section go ahead and emit that now as well.
2581 if (OffsetSection) {
2582 Asm->OutStreamer.SwitchSection(OffsetSection);
2583 unsigned offset = 0;
2584 unsigned size = 4; // FIXME: DWARF64 is 8.
2585 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2586 Asm->OutStreamer.EmitIntValue(offset, size);
2587 offset += Entries[i].second->getKeyLength() + 1;
2592 // Emit strings into a string section.
2593 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2595 if (AddressPool.empty()) return;
2597 // Start the dwarf addr section.
2598 Asm->OutStreamer.SwitchSection(AddrSection);
2600 // Order the address pool entries by ID
2601 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2603 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2604 E = AddressPool.end();
2606 Entries[I->second] = I->first;
2608 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2609 // Emit an expression for reference from debug information entries.
2610 if (const MCExpr *Expr = Entries[i])
2611 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2613 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2618 // Emit visible names into a debug str section.
2619 void DwarfDebug::emitDebugStr() {
2620 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2621 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2624 // Emit locations into the debug loc section.
2625 void DwarfDebug::emitDebugLoc() {
2626 if (DotDebugLocEntries.empty())
2629 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2630 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2632 DotDebugLocEntry &Entry = *I;
2633 if (I + 1 != DotDebugLocEntries.end())
2637 // Start the dwarf loc section.
2638 Asm->OutStreamer.SwitchSection(
2639 Asm->getObjFileLowering().getDwarfLocSection());
2640 unsigned char Size = Asm->getDataLayout().getPointerSize();
2641 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2643 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2644 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2645 I != E; ++I, ++index) {
2646 DotDebugLocEntry &Entry = *I;
2647 if (Entry.isMerged()) continue;
2648 if (Entry.isEmpty()) {
2649 Asm->OutStreamer.EmitIntValue(0, Size);
2650 Asm->OutStreamer.EmitIntValue(0, Size);
2651 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2653 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2654 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2655 DIVariable DV(Entry.getVariable());
2656 Asm->OutStreamer.AddComment("Loc expr size");
2657 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2658 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2659 Asm->EmitLabelDifference(end, begin, 2);
2660 Asm->OutStreamer.EmitLabel(begin);
2661 if (Entry.isInt()) {
2662 DIBasicType BTy(DV.getType());
2664 (BTy.getEncoding() == dwarf::DW_ATE_signed
2665 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2666 Asm->OutStreamer.AddComment("DW_OP_consts");
2667 Asm->EmitInt8(dwarf::DW_OP_consts);
2668 Asm->EmitSLEB128(Entry.getInt());
2670 Asm->OutStreamer.AddComment("DW_OP_constu");
2671 Asm->EmitInt8(dwarf::DW_OP_constu);
2672 Asm->EmitULEB128(Entry.getInt());
2674 } else if (Entry.isLocation()) {
2675 MachineLocation Loc = Entry.getLoc();
2676 if (!DV.hasComplexAddress())
2678 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2680 // Complex address entry.
2681 unsigned N = DV.getNumAddrElements();
2683 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2684 if (Loc.getOffset()) {
2686 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2687 Asm->OutStreamer.AddComment("DW_OP_deref");
2688 Asm->EmitInt8(dwarf::DW_OP_deref);
2689 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2690 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2691 Asm->EmitSLEB128(DV.getAddrElement(1));
2693 // If first address element is OpPlus then emit
2694 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2695 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2696 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2700 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2703 // Emit remaining complex address elements.
2704 for (; i < N; ++i) {
2705 uint64_t Element = DV.getAddrElement(i);
2706 if (Element == DIBuilder::OpPlus) {
2707 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2708 Asm->EmitULEB128(DV.getAddrElement(++i));
2709 } else if (Element == DIBuilder::OpDeref) {
2711 Asm->EmitInt8(dwarf::DW_OP_deref);
2713 llvm_unreachable("unknown Opcode found in complex address");
2717 // else ... ignore constant fp. There is not any good way to
2718 // to represent them here in dwarf.
2719 Asm->OutStreamer.EmitLabel(end);
2724 struct SymbolCUSorter {
2725 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2726 const MCStreamer &Streamer;
2728 bool operator() (const SymbolCU &A, const SymbolCU &B) {
2729 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2730 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2732 // Symbols with no order assigned should be placed at the end.
2733 // (e.g. section end labels)
2735 IA = (unsigned)(-1);
2737 IB = (unsigned)(-1);
2742 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2743 return (A->getUniqueID() < B->getUniqueID());
2747 const MCSymbol *Start, *End;
2750 // Emit a debug aranges section, containing a CU lookup for any
2751 // address we can tie back to a CU.
2752 void DwarfDebug::emitDebugARanges() {
2753 // Start the dwarf aranges section.
2755 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2757 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2761 // Build a list of sections used.
2762 std::vector<const MCSection *> Sections;
2763 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2765 const MCSection *Section = it->first;
2766 Sections.push_back(Section);
2769 // Sort the sections into order.
2770 // This is only done to ensure consistent output order across different runs.
2771 std::sort(Sections.begin(), Sections.end(), SectionSort);
2773 // Build a set of address spans, sorted by CU.
2774 for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2775 const MCSection *Section = Sections[SecIdx];
2776 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2777 if (List.size() < 2)
2780 // Sort the symbols by offset within the section.
2781 SymbolCUSorter sorter(Asm->OutStreamer);
2782 std::sort(List.begin(), List.end(), sorter);
2784 // If we have no section (e.g. common), just write out
2785 // individual spans for each symbol.
2786 if (Section == NULL) {
2787 for (size_t n = 0; n < List.size(); n++) {
2788 const SymbolCU &Cur = List[n];
2791 Span.Start = Cur.Sym;
2794 Spans[Cur.CU].push_back(Span);
2797 // Build spans between each label.
2798 const MCSymbol *StartSym = List[0].Sym;
2799 for (size_t n = 1; n < List.size(); n++) {
2800 const SymbolCU &Prev = List[n - 1];
2801 const SymbolCU &Cur = List[n];
2803 // Try and build the longest span we can within the same CU.
2804 if (Cur.CU != Prev.CU) {
2806 Span.Start = StartSym;
2808 Spans[Prev.CU].push_back(Span);
2815 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2816 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2818 // Build a list of CUs used.
2819 std::vector<CompileUnit *> CUs;
2820 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2821 CompileUnit *CU = it->first;
2825 // Sort the CU list (again, to ensure consistent output order).
2826 std::sort(CUs.begin(), CUs.end(), CUSort);
2828 // Emit an arange table for each CU we used.
2829 for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2830 CompileUnit *CU = CUs[CUIdx];
2831 std::vector<ArangeSpan> &List = Spans[CU];
2833 // Emit size of content not including length itself.
2834 unsigned ContentSize
2835 = sizeof(int16_t) // DWARF ARange version number
2836 + sizeof(int32_t) // Offset of CU in the .debug_info section
2837 + sizeof(int8_t) // Pointer Size (in bytes)
2838 + sizeof(int8_t); // Segment Size (in bytes)
2840 unsigned TupleSize = PtrSize * 2;
2842 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2843 unsigned Padding = 0;
2844 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2847 ContentSize += Padding;
2848 ContentSize += (List.size() + 1) * TupleSize;
2850 // For each compile unit, write the list of spans it covers.
2851 Asm->OutStreamer.AddComment("Length of ARange Set");
2852 Asm->EmitInt32(ContentSize);
2853 Asm->OutStreamer.AddComment("DWARF Arange version number");
2854 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2855 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2856 Asm->EmitSectionOffset(
2857 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2858 DwarfInfoSectionSym);
2859 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2860 Asm->EmitInt8(PtrSize);
2861 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2864 for (unsigned n = 0; n < Padding; n++)
2865 Asm->EmitInt8(0xff);
2867 for (unsigned n = 0; n < List.size(); n++) {
2868 const ArangeSpan &Span = List[n];
2869 Asm->EmitLabelReference(Span.Start, PtrSize);
2871 // Calculate the size as being from the span start to it's end.
2873 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2875 // For symbols without an end marker (e.g. common), we
2876 // write a single arange entry containing just that one symbol.
2877 uint64_t Size = SymSize[Span.Start];
2881 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2885 Asm->OutStreamer.AddComment("ARange terminator");
2886 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2887 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2891 // Emit visible names into a debug ranges section.
2892 void DwarfDebug::emitDebugRanges() {
2893 // Start the dwarf ranges section.
2895 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2896 unsigned char Size = Asm->getDataLayout().getPointerSize();
2897 for (SmallVectorImpl<const MCSymbol *>::iterator
2898 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2901 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2903 Asm->OutStreamer.EmitIntValue(0, Size);
2907 // Emit visible names into a debug macinfo section.
2908 void DwarfDebug::emitDebugMacInfo() {
2909 if (const MCSection *LineInfo =
2910 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2911 // Start the dwarf macinfo section.
2912 Asm->OutStreamer.SwitchSection(LineInfo);
2916 // DWARF5 Experimental Separate Dwarf emitters.
2918 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2919 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2920 // DW_AT_ranges_base, DW_AT_addr_base.
2921 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2923 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2924 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2925 Asm, this, &SkeletonHolder);
2927 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2928 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2930 // Relocate to the beginning of the addr_base section, else 0 for the
2931 // beginning of the one for this compile unit.
2932 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2933 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2934 DwarfAddrSectionSym);
2936 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2937 dwarf::DW_FORM_sec_offset, 0);
2939 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2940 // into an entity. We're using 0, or a NULL label for this.
2941 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2943 // DW_AT_stmt_list is a offset of line number information for this
2944 // compile unit in debug_line section.
2945 // FIXME: Should handle multiple compile units.
2946 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2947 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2948 DwarfLineSectionSym);
2950 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2952 if (!CompilationDir.empty())
2953 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2955 // Flags to let the linker know we have emitted new style pubnames.
2956 if (GenerateGnuPubSections) {
2957 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2958 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_sec_offset,
2959 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
2961 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
2962 Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2963 DwarfGnuPubNamesSectionSym);
2965 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2966 NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_sec_offset,
2967 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
2969 NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
2970 Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
2971 DwarfGnuPubTypesSectionSym);
2974 // Flag if we've emitted any ranges and their location for the compile unit.
2975 if (DebugRangeSymbols.size()) {
2976 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2977 NewCU->addLabel(Die, dwarf::DW_AT_GNU_ranges_base,
2978 dwarf::DW_FORM_sec_offset, DwarfDebugRangeSectionSym);
2980 NewCU->addUInt(Die, dwarf::DW_AT_GNU_ranges_base, dwarf::DW_FORM_data4,
2984 SkeletonHolder.addUnit(NewCU);
2985 SkeletonCUs.push_back(NewCU);
2990 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2991 assert(useSplitDwarf() && "No split dwarf debug info?");
2992 emitAbbrevs(Section, &SkeletonAbbrevs);
2995 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2996 // compile units that would normally be in debug_info.
2997 void DwarfDebug::emitDebugInfoDWO() {
2998 assert(useSplitDwarf() && "No split dwarf debug info?");
2999 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3000 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3001 DwarfAbbrevDWOSectionSym);
3004 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3005 // abbreviations for the .debug_info.dwo section.
3006 void DwarfDebug::emitDebugAbbrevDWO() {
3007 assert(useSplitDwarf() && "No split dwarf?");
3008 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3012 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3013 // string section and is identical in format to traditional .debug_str
3015 void DwarfDebug::emitDebugStrDWO() {
3016 assert(useSplitDwarf() && "No split dwarf?");
3017 const MCSection *OffSec = Asm->getObjFileLowering()
3018 .getDwarfStrOffDWOSection();
3019 const MCSymbol *StrSym = DwarfStrSectionSym;
3020 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),