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 DIType DbgVariable::getType() const {
120 DIType Ty = Var.getType();
121 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
122 // addresses instead.
123 if (Var.isBlockByrefVariable()) {
124 /* Byref variables, in Blocks, are declared by the programmer as
125 "SomeType VarName;", but the compiler creates a
126 __Block_byref_x_VarName struct, and gives the variable VarName
127 either the struct, or a pointer to the struct, as its type. This
128 is necessary for various behind-the-scenes things the compiler
129 needs to do with by-reference variables in blocks.
131 However, as far as the original *programmer* is concerned, the
132 variable should still have type 'SomeType', as originally declared.
134 The following function dives into the __Block_byref_x_VarName
135 struct to find the original type of the variable. This will be
136 passed back to the code generating the type for the Debug
137 Information Entry for the variable 'VarName'. 'VarName' will then
138 have the original type 'SomeType' in its debug information.
140 The original type 'SomeType' will be the type of the field named
141 'VarName' inside the __Block_byref_x_VarName struct.
143 NOTE: In order for this to not completely fail on the debugger
144 side, the Debug Information Entry for the variable VarName needs to
145 have a DW_AT_location that tells the debugger how to unwind through
146 the pointers and __Block_byref_x_VarName struct to find the actual
147 value of the variable. The function addBlockByrefType does this. */
149 uint16_t tag = Ty.getTag();
151 if (tag == dwarf::DW_TAG_pointer_type)
152 subType = DIDerivedType(Ty).getTypeDerivedFrom();
154 DIArray Elements = DICompositeType(subType).getTypeArray();
155 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
156 DIDerivedType DT = DIDerivedType(Elements.getElement(i));
157 if (getName() == DT.getName())
158 return (DT.getTypeDerivedFrom());
164 } // end llvm namespace
166 /// Return Dwarf Version by checking module flags.
167 static unsigned getDwarfVersionFromModule(const Module *M) {
168 Value *Val = M->getModuleFlag("Dwarf Version");
170 return dwarf::DWARF_VERSION;
171 return cast<ConstantInt>(Val)->getZExtValue();
174 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
175 : Asm(A), MMI(Asm->MMI), FirstCU(0),
176 AbbreviationsSet(InitAbbreviationsSetSize),
177 SourceIdMap(DIEValueAllocator),
178 PrevLabel(NULL), GlobalCUIndexCount(0),
179 InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
181 SkeletonAbbrevSet(InitAbbreviationsSetSize),
182 SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
185 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
186 DwarfStrSectionSym = TextSectionSym = 0;
187 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
188 DwarfAddrSectionSym = 0;
189 DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
190 FunctionBeginSym = FunctionEndSym = 0;
192 // Turn on accelerator tables and older gdb compatibility
193 // for Darwin by default, pubnames by default for non-Darwin,
194 // and handle split dwarf.
195 bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
197 if (DwarfAccelTables == Default)
198 HasDwarfAccelTables = IsDarwin;
200 HasDwarfAccelTables = DwarfAccelTables == Enable;
202 if (SplitDwarf == Default)
203 HasSplitDwarf = false;
205 HasSplitDwarf = SplitDwarf == Enable;
207 if (DwarfPubSections == Default)
208 HasDwarfPubSections = !IsDarwin;
210 HasDwarfPubSections = DwarfPubSections == Enable;
212 DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
215 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
219 DwarfDebug::~DwarfDebug() {
222 // Switch to the specified MCSection and emit an assembler
223 // temporary label to it if SymbolStem is specified.
224 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
225 const char *SymbolStem = 0) {
226 Asm->OutStreamer.SwitchSection(Section);
227 if (!SymbolStem) return 0;
229 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
230 Asm->OutStreamer.EmitLabel(TmpSym);
234 MCSymbol *DwarfUnits::getStringPoolSym() {
235 return Asm->GetTempSymbol(StringPref);
238 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
239 std::pair<MCSymbol*, unsigned> &Entry =
240 StringPool.GetOrCreateValue(Str).getValue();
241 if (Entry.first) return Entry.first;
243 Entry.second = NextStringPoolNumber++;
244 return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
247 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
248 std::pair<MCSymbol*, unsigned> &Entry =
249 StringPool.GetOrCreateValue(Str).getValue();
250 if (Entry.first) return Entry.second;
252 Entry.second = NextStringPoolNumber++;
253 Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
257 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
258 return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
261 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
262 std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
263 AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
265 ++NextAddrPoolNumber;
266 return P.first->second;
269 // Define a unique number for the abbreviation.
271 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
272 // Check the set for priors.
273 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
275 // If it's newly added.
276 if (InSet == &Abbrev) {
277 // Add to abbreviation list.
278 Abbreviations->push_back(&Abbrev);
280 // Assign the vector position + 1 as its number.
281 Abbrev.setNumber(Abbreviations->size());
283 // Assign existing abbreviation number.
284 Abbrev.setNumber(InSet->getNumber());
288 static bool isObjCClass(StringRef Name) {
289 return Name.startswith("+") || Name.startswith("-");
292 static bool hasObjCCategory(StringRef Name) {
293 if (!isObjCClass(Name)) return false;
295 return Name.find(") ") != StringRef::npos;
298 static void getObjCClassCategory(StringRef In, StringRef &Class,
299 StringRef &Category) {
300 if (!hasObjCCategory(In)) {
301 Class = In.slice(In.find('[') + 1, In.find(' '));
306 Class = In.slice(In.find('[') + 1, In.find('('));
307 Category = In.slice(In.find('[') + 1, In.find(' '));
311 static StringRef getObjCMethodName(StringRef In) {
312 return In.slice(In.find(' ') + 1, In.find(']'));
315 // Add the various names to the Dwarf accelerator table names.
316 // TODO: Determine whether or not we should add names for programs
317 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
318 // is only slightly different than the lookup of non-standard ObjC names.
319 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
321 if (!SP.isDefinition()) return;
322 TheCU->addAccelName(SP.getName(), Die);
324 // If the linkage name is different than the name, go ahead and output
325 // that as well into the name table.
326 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
327 TheCU->addAccelName(SP.getLinkageName(), Die);
329 // If this is an Objective-C selector name add it to the ObjC accelerator
331 if (isObjCClass(SP.getName())) {
332 StringRef Class, Category;
333 getObjCClassCategory(SP.getName(), Class, Category);
334 TheCU->addAccelObjC(Class, Die);
336 TheCU->addAccelObjC(Category, Die);
337 // Also add the base method name to the name table.
338 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
342 /// isSubprogramContext - Return true if Context is either a subprogram
343 /// or another context nested inside a subprogram.
344 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
347 DIDescriptor D(Context);
348 if (D.isSubprogram())
351 return isSubprogramContext(resolve(DIType(Context).getContext()));
355 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
356 // and DW_AT_high_pc attributes. If there are global variables in this
357 // scope then create and insert DIEs for these variables.
358 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
359 const MDNode *SPNode) {
360 DIE *SPDie = SPCU->getDIE(SPNode);
362 assert(SPDie && "Unable to find subprogram DIE!");
363 DISubprogram SP(SPNode);
365 // If we're updating an abstract DIE, then we will be adding the children and
366 // object pointer later on. But what we don't want to do is process the
367 // concrete DIE twice.
368 DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
370 bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
371 // Pick up abstract subprogram DIE.
372 SPDie = new DIE(dwarf::DW_TAG_subprogram);
373 // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
375 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
376 InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
380 DISubprogram SPDecl = SP.getFunctionDeclaration();
381 if (!SPDecl.isSubprogram()) {
382 // There is not any need to generate specification DIE for a function
383 // defined at compile unit level. If a function is defined inside another
384 // function then gdb prefers the definition at top level and but does not
385 // expect specification DIE in parent function. So avoid creating
386 // specification DIE for a function defined inside a function.
387 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
388 !SP.getContext().isFile() &&
389 !isSubprogramContext(SP.getContext())) {
390 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
393 DICompositeType SPTy = SP.getType();
394 DIArray Args = SPTy.getTypeArray();
395 uint16_t SPTag = SPTy.getTag();
396 if (SPTag == dwarf::DW_TAG_subroutine_type)
397 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
398 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
399 DIType ATy = DIType(Args.getElement(i));
400 SPCU->addType(Arg, ATy);
401 if (ATy.isArtificial())
402 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
403 if (ATy.isObjectPointer())
404 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
405 dwarf::DW_FORM_ref4, Arg);
406 SPDie->addChild(Arg);
408 DIE *SPDeclDie = SPDie;
409 SPDie = new DIE(dwarf::DW_TAG_subprogram);
410 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
411 dwarf::DW_FORM_ref4, SPDeclDie);
417 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
418 Asm->GetTempSymbol("func_begin",
419 Asm->getFunctionNumber()));
420 SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
421 Asm->GetTempSymbol("func_end",
422 Asm->getFunctionNumber()));
423 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
424 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
425 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
427 // Add name to the name table, we do this here because we're guaranteed
428 // to have concrete versions of our DW_TAG_subprogram nodes.
429 addSubprogramNames(SPCU, SP, SPDie);
434 /// Check whether we should create a DIE for the given Scope, return true
435 /// if we don't create a DIE (the corresponding DIE is null).
436 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
437 if (Scope->isAbstractScope())
440 // We don't create a DIE if there is no Range.
441 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
445 if (Ranges.size() > 1)
448 // We don't create a DIE if we have a single Range and the end label
450 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
451 MCSymbol *End = getLabelAfterInsn(RI->second);
455 // Construct new DW_TAG_lexical_block for this scope and attach
456 // DW_AT_low_pc/DW_AT_high_pc labels.
457 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
458 LexicalScope *Scope) {
459 if (isLexicalScopeDIENull(Scope))
462 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
463 if (Scope->isAbstractScope())
466 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
467 // If we have multiple ranges, emit them into the range section.
468 if (Ranges.size() > 1) {
469 // .debug_range section has not been laid out yet. Emit offset in
470 // .debug_range as a uint, size 4, for now. emitDIE will handle
471 // DW_AT_ranges appropriately.
472 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
473 DebugRangeSymbols.size()
474 * Asm->getDataLayout().getPointerSize());
475 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
476 RE = Ranges.end(); RI != RE; ++RI) {
477 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
478 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
481 // Terminate the range list.
482 DebugRangeSymbols.push_back(NULL);
483 DebugRangeSymbols.push_back(NULL);
487 // Construct the address range for this DIE.
488 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
489 MCSymbol *Start = getLabelBeforeInsn(RI->first);
490 MCSymbol *End = getLabelAfterInsn(RI->second);
491 assert(End && "End label should not be null!");
493 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
494 assert(End->isDefined() && "Invalid end label for an inlined scope!");
496 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
497 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
502 // This scope represents inlined body of a function. Construct DIE to
503 // represent this concrete inlined copy of the function.
504 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
505 LexicalScope *Scope) {
506 const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
507 assert(Ranges.empty() == false &&
508 "LexicalScope does not have instruction markers!");
510 if (!Scope->getScopeNode())
512 DIScope DS(Scope->getScopeNode());
513 DISubprogram InlinedSP = getDISubprogram(DS);
514 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
516 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
520 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
521 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
522 dwarf::DW_FORM_ref4, OriginDIE);
524 if (Ranges.size() > 1) {
525 // .debug_range section has not been laid out yet. Emit offset in
526 // .debug_range as a uint, size 4, for now. emitDIE will handle
527 // DW_AT_ranges appropriately.
528 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
529 DebugRangeSymbols.size()
530 * Asm->getDataLayout().getPointerSize());
531 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
532 RE = Ranges.end(); RI != RE; ++RI) {
533 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
534 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
536 DebugRangeSymbols.push_back(NULL);
537 DebugRangeSymbols.push_back(NULL);
539 SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
540 MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
541 MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
543 if (StartLabel == 0 || EndLabel == 0)
544 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
546 assert(StartLabel->isDefined() &&
547 "Invalid starting label for an inlined scope!");
548 assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
550 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
551 TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
554 InlinedSubprogramDIEs.insert(OriginDIE);
556 // Add the call site information to the DIE.
557 DILocation DL(Scope->getInlinedAt());
558 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
559 getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
560 TheCU->getUniqueID()));
561 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
563 // Add name to the name table, we do this here because we're guaranteed
564 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
565 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
570 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
571 SmallVectorImpl<DIE*> &Children) {
572 DIE *ObjectPointer = NULL;
574 // Collect arguments for current function.
575 if (LScopes.isCurrentFunctionScope(Scope))
576 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
577 if (DbgVariable *ArgDV = CurrentFnArguments[i])
579 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
580 Children.push_back(Arg);
581 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
584 // Collect lexical scope children first.
585 const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
586 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
588 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
589 Children.push_back(Variable);
590 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
592 const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
593 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
594 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
595 Children.push_back(Nested);
596 return ObjectPointer;
599 // Construct a DIE for this scope.
600 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
601 if (!Scope || !Scope->getScopeNode())
604 DIScope DS(Scope->getScopeNode());
606 SmallVector<DIE *, 8> Children;
607 DIE *ObjectPointer = NULL;
608 bool ChildrenCreated = false;
610 // We try to create the scope DIE first, then the children DIEs. This will
611 // avoid creating un-used children then removing them later when we find out
612 // the scope DIE is null.
613 DIE *ScopeDIE = NULL;
614 if (Scope->getInlinedAt())
615 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
616 else if (DS.isSubprogram()) {
617 ProcessedSPNodes.insert(DS);
618 if (Scope->isAbstractScope()) {
619 ScopeDIE = TheCU->getDIE(DS);
620 // Note down abstract DIE.
622 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
625 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
628 // Early exit when we know the scope DIE is going to be null.
629 if (isLexicalScopeDIENull(Scope))
632 // We create children here when we know the scope DIE is not going to be
633 // null and the children will be added to the scope DIE.
634 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
635 ChildrenCreated = true;
637 // There is no need to emit empty lexical block DIE.
638 std::pair<ImportedEntityMap::const_iterator,
639 ImportedEntityMap::const_iterator> Range = std::equal_range(
640 ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
641 std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
643 if (Children.empty() && Range.first == Range.second)
645 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
646 assert(ScopeDIE && "Scope DIE should not be null.");
647 for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
649 constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
653 assert(Children.empty() &&
654 "We create children only when the scope DIE is not null.");
657 if (!ChildrenCreated)
658 // We create children when the scope DIE is not null.
659 ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
662 for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
663 E = Children.end(); I != E; ++I)
664 ScopeDIE->addChild(*I);
666 if (DS.isSubprogram() && ObjectPointer != NULL)
667 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
668 dwarf::DW_FORM_ref4, ObjectPointer);
670 if (DS.isSubprogram())
671 TheCU->addPubTypes(DISubprogram(DS));
676 // Look up the source id with the given directory and source file names.
677 // If none currently exists, create a new id and insert it in the
678 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
680 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
681 StringRef DirName, unsigned CUID) {
682 // If we use .loc in assembly, we can't separate .file entries according to
683 // compile units. Thus all files will belong to the default compile unit.
684 if (Asm->TM.hasMCUseLoc() &&
685 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
688 // If FE did not provide a file name, then assume stdin.
689 if (FileName.empty())
690 return getOrCreateSourceID("<stdin>", StringRef(), CUID);
692 // TODO: this might not belong here. See if we can factor this better.
693 if (DirName == CompilationDir)
696 // FileIDCUMap stores the current ID for the given compile unit.
697 unsigned SrcId = FileIDCUMap[CUID] + 1;
699 // We look up the CUID/file/dir by concatenating them with a zero byte.
700 SmallString<128> NamePair;
701 NamePair += utostr(CUID);
704 NamePair += '\0'; // Zero bytes are not allowed in paths.
705 NamePair += FileName;
707 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
708 if (Ent.getValue() != SrcId)
709 return Ent.getValue();
711 FileIDCUMap[CUID] = SrcId;
712 // Print out a .file directive to specify files for .loc directives.
713 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
718 // Create new CompileUnit for the given metadata node with tag
719 // DW_TAG_compile_unit.
720 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
721 DICompileUnit DIUnit(N);
722 StringRef FN = DIUnit.getFilename();
723 CompilationDir = DIUnit.getDirectory();
725 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
727 new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
729 FileIDCUMap[NewCU->getUniqueID()] = 0;
730 // Call this to emit a .file directive if it wasn't emitted for the source
731 // file this CU comes from yet.
732 getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
734 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
735 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
736 DIUnit.getLanguage());
737 NewCU->addString(Die, dwarf::DW_AT_name, FN);
739 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
740 // into an entity. We're using 0 (or a NULL label) for this. For
741 // split dwarf it's in the skeleton CU so omit it here.
742 if (!useSplitDwarf())
743 NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
745 // Define start line table label for each Compile Unit.
746 MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
747 NewCU->getUniqueID());
748 Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
749 NewCU->getUniqueID());
751 // Use a single line table if we are using .loc and generating assembly.
753 (Asm->TM.hasMCUseLoc() &&
754 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
755 (NewCU->getUniqueID() == 0);
757 // DW_AT_stmt_list is a offset of line number information for this
758 // compile unit in debug_line section. For split dwarf this is
759 // left in the skeleton CU and so not included.
760 // The line table entries are not always emitted in assembly, so it
761 // is not okay to use line_table_start here.
762 if (!useSplitDwarf()) {
763 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
764 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
766 Asm->GetTempSymbol("section_line") : LineTableStartSym);
767 else if (UseTheFirstCU)
768 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
770 NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
771 LineTableStartSym, DwarfLineSectionSym);
774 // If we're using split dwarf the compilation dir is going to be in the
775 // skeleton CU and so we don't need to duplicate it here.
776 if (!useSplitDwarf() && !CompilationDir.empty())
777 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
779 // Flag to let the linker know we have emitted new style pubnames. Only
780 // emit it here if we don't have a skeleton CU for split dwarf.
781 if (!useSplitDwarf() && GenerateGnuPubSections)
782 NewCU->addFlag(Die, dwarf::DW_AT_GNU_pubnames);
784 if (DIUnit.isOptimized())
785 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
787 StringRef Flags = DIUnit.getFlags();
789 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
791 if (unsigned RVer = DIUnit.getRunTimeVersion())
792 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
793 dwarf::DW_FORM_data1, RVer);
798 InfoHolder.addUnit(NewCU);
800 CUMap.insert(std::make_pair(N, NewCU));
804 // Construct subprogram DIE.
805 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
807 CompileUnit *&CURef = SPMap[N];
813 if (!SP.isDefinition())
814 // This is a method declaration which will be handled while constructing
818 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
821 TheCU->insertDIE(N, SubprogramDie);
823 // Add to context owner.
824 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
826 // Expose as a global name.
827 TheCU->addGlobalName(SP.getName(), SubprogramDie);
830 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
832 DIImportedEntity Module(N);
833 if (!Module.Verify())
835 if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
836 constructImportedEntityDIE(TheCU, Module, D);
839 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
841 DIImportedEntity Module(N);
842 if (!Module.Verify())
844 return constructImportedEntityDIE(TheCU, Module, Context);
847 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
848 const DIImportedEntity &Module,
850 assert(Module.Verify() &&
851 "Use one of the MDNode * overloads to handle invalid metadata");
852 assert(Context && "Should always have a context for an imported_module");
853 DIE *IMDie = new DIE(Module.getTag());
854 TheCU->insertDIE(Module, IMDie);
856 DIDescriptor Entity = Module.getEntity();
857 if (Entity.isNameSpace())
858 EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
859 else if (Entity.isSubprogram())
860 EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
861 else if (Entity.isType())
862 EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
864 EntityDie = TheCU->getDIE(Entity);
865 unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
866 Module.getContext().getDirectory(),
867 TheCU->getUniqueID());
868 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
869 TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
870 TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
872 StringRef Name = Module.getName();
874 TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
875 Context->addChild(IMDie);
878 // Emit all Dwarf sections that should come prior to the content. Create
879 // global DIEs and emit initial debug info sections. This is invoked by
880 // the target AsmPrinter.
881 void DwarfDebug::beginModule() {
882 if (DisableDebugInfoPrinting)
885 const Module *M = MMI->getModule();
887 // If module has named metadata anchors then use them, otherwise scan the
888 // module using debug info finder to collect debug info.
889 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
892 TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
894 // Emit initial sections so we can reference labels later.
897 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
898 DICompileUnit CUNode(CU_Nodes->getOperand(i));
899 CompileUnit *CU = constructCompileUnit(CUNode);
900 DIArray ImportedEntities = CUNode.getImportedEntities();
901 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
902 ScopesWithImportedEntities.push_back(std::make_pair(
903 DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
904 ImportedEntities.getElement(i)));
905 std::sort(ScopesWithImportedEntities.begin(),
906 ScopesWithImportedEntities.end(), less_first());
907 DIArray GVs = CUNode.getGlobalVariables();
908 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
909 CU->createGlobalVariableDIE(GVs.getElement(i));
910 DIArray SPs = CUNode.getSubprograms();
911 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
912 constructSubprogramDIE(CU, SPs.getElement(i));
913 DIArray EnumTypes = CUNode.getEnumTypes();
914 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
915 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
916 DIArray RetainedTypes = CUNode.getRetainedTypes();
917 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
918 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
919 // Emit imported_modules last so that the relevant context is already
921 for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
922 constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
925 // Tell MMI that we have debug info.
926 MMI->setDebugInfoAvailability(true);
928 // Prime section data.
929 SectionMap[Asm->getObjFileLowering().getTextSection()];
932 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
933 void DwarfDebug::computeInlinedDIEs() {
934 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
935 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
936 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
938 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
940 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
941 AE = AbstractSPDies.end(); AI != AE; ++AI) {
942 DIE *ISP = AI->second;
943 if (InlinedSubprogramDIEs.count(ISP))
945 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
949 // Collect info for variables that were optimized out.
950 void DwarfDebug::collectDeadVariables() {
951 const Module *M = MMI->getModule();
952 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
954 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
955 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
956 DICompileUnit TheCU(CU_Nodes->getOperand(i));
957 DIArray Subprograms = TheCU.getSubprograms();
958 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
959 DISubprogram SP(Subprograms.getElement(i));
960 if (ProcessedSPNodes.count(SP) != 0) continue;
961 if (!SP.isSubprogram()) continue;
962 if (!SP.isDefinition()) continue;
963 DIArray Variables = SP.getVariables();
964 if (Variables.getNumElements() == 0) continue;
966 LexicalScope *Scope =
967 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
968 DeadFnScopeMap[SP] = Scope;
970 // Construct subprogram DIE and add variables DIEs.
971 CompileUnit *SPCU = CUMap.lookup(TheCU);
972 assert(SPCU && "Unable to find Compile Unit!");
973 constructSubprogramDIE(SPCU, SP);
974 DIE *ScopeDIE = SPCU->getDIE(SP);
975 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
976 DIVariable DV(Variables.getElement(vi));
977 if (!DV.isVariable()) continue;
978 DbgVariable NewVar(DV, NULL);
979 if (DIE *VariableDIE =
980 SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
981 ScopeDIE->addChild(VariableDIE);
986 DeleteContainerSeconds(DeadFnScopeMap);
989 // Type Signature [7.27] and ODR Hash code.
991 /// \brief Grabs the string in whichever attribute is passed in and returns
992 /// a reference to it. Returns "" if the attribute doesn't exist.
993 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
994 DIEValue *V = Die->findAttribute(Attr);
996 if (DIEString *S = dyn_cast_or_null<DIEString>(V))
997 return S->getString();
999 return StringRef("");
1002 /// Return true if the current DIE is contained within an anonymous namespace.
1003 static bool isContainedInAnonNamespace(DIE *Die) {
1004 DIE *Parent = Die->getParent();
1007 if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1008 getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1010 Parent = Parent->getParent();
1016 /// Test if the current CU language is C++ and that we have
1017 /// a named type that is not contained in an anonymous namespace.
1018 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1019 return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1020 getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1021 !isContainedInAnonNamespace(Die);
1024 void DwarfDebug::finalizeModuleInfo() {
1025 // Collect info for variables that were optimized out.
1026 collectDeadVariables();
1028 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1029 computeInlinedDIEs();
1031 // Split out type units and conditionally add an ODR tag to the split
1033 // FIXME: Do type splitting.
1034 for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1035 DIE *Die = TypeUnits[i];
1037 // If we've requested ODR hashes and it's applicable for an ODR hash then
1038 // add the ODR signature now.
1039 // FIXME: This should be added onto the type unit, not the type, but this
1040 // works as an intermediate stage.
1041 if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1042 CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1043 dwarf::DW_FORM_data8,
1044 Hash.computeDIEODRSignature(Die));
1047 // Handle anything that needs to be done on a per-cu basis.
1048 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1050 CUI != CUE; ++CUI) {
1051 CompileUnit *TheCU = CUI->second;
1052 // Emit DW_AT_containing_type attribute to connect types with their
1053 // vtable holding type.
1054 TheCU->constructContainingTypeDIEs();
1056 // If we're splitting the dwarf out now that we've got the entire
1057 // CU then construct a skeleton CU based upon it.
1058 if (useSplitDwarf()) {
1060 if (GenerateCUHash) {
1062 ID = CUHash.computeCUSignature(TheCU->getCUDie());
1064 // This should be a unique identifier when we want to build .dwp files.
1065 TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1066 dwarf::DW_FORM_data8, ID);
1067 // Now construct the skeleton CU associated.
1068 CompileUnit *SkCU = constructSkeletonCU(TheCU);
1069 // This should be a unique identifier when we want to build .dwp files.
1070 SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1071 dwarf::DW_FORM_data8, ID);
1075 // Compute DIE offsets and sizes.
1076 InfoHolder.computeSizeAndOffsets();
1077 if (useSplitDwarf())
1078 SkeletonHolder.computeSizeAndOffsets();
1081 void DwarfDebug::endSections() {
1082 // Filter labels by section.
1083 for (size_t n = 0; n < Labels.size(); n++) {
1084 const SymbolCU &SCU = Labels[n];
1085 if (SCU.Sym->isInSection()) {
1086 // Make a note of this symbol and it's section.
1087 const MCSection *Section = &SCU.Sym->getSection();
1088 if (!Section->getKind().isMetadata())
1089 SectionMap[Section].push_back(SCU);
1091 // Some symbols (e.g. common/bss on mach-o) can have no section but still
1092 // appear in the output. This sucks as we rely on sections to build
1093 // arange spans. We can do it without, but it's icky.
1094 SectionMap[NULL].push_back(SCU);
1098 // Add terminating symbols for each section.
1099 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1101 const MCSection *Section = it->first;
1102 MCSymbol *Sym = NULL;
1105 Sym = Asm->GetTempSymbol(Section->getLabelEndName());
1106 Asm->OutStreamer.SwitchSection(Section);
1107 Asm->OutStreamer.EmitLabel(Sym);
1110 // Insert a final terminator.
1114 SectionMap[Section].push_back(Entry);
1118 // Emit all Dwarf sections that should come after the content.
1119 void DwarfDebug::endModule() {
1121 if (!FirstCU) return;
1123 // End any existing sections.
1124 // TODO: Does this need to happen?
1127 // Finalize the debug info for the module.
1128 finalizeModuleInfo();
1130 if (!useSplitDwarf()) {
1133 // Emit all the DIEs into a debug info section.
1136 // Corresponding abbreviations into a abbrev section.
1137 emitAbbreviations();
1139 // Emit info into a debug loc section.
1142 // Emit info into a debug aranges section.
1145 // Emit info into a debug ranges section.
1148 // Emit info into a debug macinfo section.
1152 // TODO: Fill this in for separated debug sections and separate
1153 // out information into new sections.
1155 if (useSplitDwarf())
1158 // Emit the debug info section and compile units.
1162 // Corresponding abbreviations into a abbrev section.
1163 emitAbbreviations();
1164 emitDebugAbbrevDWO();
1166 // Emit info into a debug loc section.
1169 // Emit info into a debug aranges section.
1172 // Emit info into a debug ranges section.
1175 // Emit info into a debug macinfo section.
1178 // Emit DWO addresses.
1179 InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1183 // Emit info into the dwarf accelerator table sections.
1184 if (useDwarfAccelTables()) {
1187 emitAccelNamespaces();
1191 // Emit the pubnames and pubtypes sections if requested.
1192 if (HasDwarfPubSections) {
1193 emitDebugPubNames(GenerateGnuPubSections);
1194 emitDebugPubTypes(GenerateGnuPubSections);
1199 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1200 E = CUMap.end(); I != E; ++I)
1203 for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1204 E = SkeletonCUs.end(); I != E; ++I)
1207 // Reset these for the next Module if we have one.
1211 // Find abstract variable, if any, associated with Var.
1212 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1213 DebugLoc ScopeLoc) {
1214 LLVMContext &Ctx = DV->getContext();
1215 // More then one inlined variable corresponds to one abstract variable.
1216 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1217 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1219 return AbsDbgVariable;
1221 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1225 AbsDbgVariable = new DbgVariable(Var, NULL);
1226 addScopeVariable(Scope, AbsDbgVariable);
1227 AbstractVariables[Var] = AbsDbgVariable;
1228 return AbsDbgVariable;
1231 // If Var is a current function argument then add it to CurrentFnArguments list.
1232 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1233 DbgVariable *Var, LexicalScope *Scope) {
1234 if (!LScopes.isCurrentFunctionScope(Scope))
1236 DIVariable DV = Var->getVariable();
1237 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1239 unsigned ArgNo = DV.getArgNumber();
1243 size_t Size = CurrentFnArguments.size();
1245 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1246 // llvm::Function argument size is not good indicator of how many
1247 // arguments does the function have at source level.
1249 CurrentFnArguments.resize(ArgNo * 2);
1250 CurrentFnArguments[ArgNo - 1] = Var;
1254 // Collect variable information from side table maintained by MMI.
1256 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1257 SmallPtrSet<const MDNode *, 16> &Processed) {
1258 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1259 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1260 VE = VMap.end(); VI != VE; ++VI) {
1261 const MDNode *Var = VI->first;
1263 Processed.insert(Var);
1265 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1267 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1269 // If variable scope is not found then skip this variable.
1273 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1274 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1275 RegVar->setFrameIndex(VP.first);
1276 if (!addCurrentFnArgument(MF, RegVar, Scope))
1277 addScopeVariable(Scope, RegVar);
1279 AbsDbgVariable->setFrameIndex(VP.first);
1283 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1285 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1286 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1287 return MI->getNumOperands() == 3 &&
1288 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1289 (MI->getOperand(1).isImm() ||
1290 (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1293 // Get .debug_loc entry for the instruction range starting at MI.
1294 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1295 const MCSymbol *FLabel,
1296 const MCSymbol *SLabel,
1297 const MachineInstr *MI) {
1298 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1300 assert(MI->getNumOperands() == 3);
1301 if (MI->getOperand(0).isReg()) {
1302 MachineLocation MLoc;
1303 // If the second operand is an immediate, this is a
1304 // register-indirect address.
1305 if (!MI->getOperand(1).isImm())
1306 MLoc.set(MI->getOperand(0).getReg());
1308 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1309 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1311 if (MI->getOperand(0).isImm())
1312 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1313 if (MI->getOperand(0).isFPImm())
1314 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1315 if (MI->getOperand(0).isCImm())
1316 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1318 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1321 // Find variables for each lexical scope.
1323 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1324 SmallPtrSet<const MDNode *, 16> &Processed) {
1326 // Grab the variable info that was squirreled away in the MMI side-table.
1327 collectVariableInfoFromMMITable(MF, Processed);
1329 for (SmallVectorImpl<const MDNode*>::const_iterator
1330 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1332 const MDNode *Var = *UVI;
1333 if (Processed.count(Var))
1336 // History contains relevant DBG_VALUE instructions for Var and instructions
1338 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1339 if (History.empty())
1341 const MachineInstr *MInsn = History.front();
1344 LexicalScope *Scope = NULL;
1345 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1346 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1347 Scope = LScopes.getCurrentFunctionScope();
1348 else if (MDNode *IA = DV.getInlinedAt())
1349 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1351 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1352 // If variable scope is not found then skip this variable.
1356 Processed.insert(DV);
1357 assert(MInsn->isDebugValue() && "History must begin with debug value");
1358 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1359 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1360 if (!addCurrentFnArgument(MF, RegVar, Scope))
1361 addScopeVariable(Scope, RegVar);
1363 AbsVar->setMInsn(MInsn);
1365 // Simplify ranges that are fully coalesced.
1366 if (History.size() <= 1 || (History.size() == 2 &&
1367 MInsn->isIdenticalTo(History.back()))) {
1368 RegVar->setMInsn(MInsn);
1372 // Handle multiple DBG_VALUE instructions describing one variable.
1373 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1375 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1376 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1377 const MachineInstr *Begin = *HI;
1378 assert(Begin->isDebugValue() && "Invalid History entry");
1380 // Check if DBG_VALUE is truncating a range.
1381 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1382 && !Begin->getOperand(0).getReg())
1385 // Compute the range for a register location.
1386 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1387 const MCSymbol *SLabel = 0;
1390 // If Begin is the last instruction in History then its value is valid
1391 // until the end of the function.
1392 SLabel = FunctionEndSym;
1394 const MachineInstr *End = HI[1];
1395 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1396 << "\t" << *Begin << "\t" << *End << "\n");
1397 if (End->isDebugValue())
1398 SLabel = getLabelBeforeInsn(End);
1400 // End is a normal instruction clobbering the range.
1401 SLabel = getLabelAfterInsn(End);
1402 assert(SLabel && "Forgot label after clobber instruction");
1407 // The value is valid until the next DBG_VALUE or clobber.
1408 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1411 DotDebugLocEntries.push_back(DotDebugLocEntry());
1414 // Collect info for variables that were optimized out.
1415 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1416 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1417 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1418 DIVariable DV(Variables.getElement(i));
1419 if (!DV || !DV.isVariable() || !Processed.insert(DV))
1421 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1422 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1426 // Return Label preceding the instruction.
1427 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1428 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1429 assert(Label && "Didn't insert label before instruction");
1433 // Return Label immediately following the instruction.
1434 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1435 return LabelsAfterInsn.lookup(MI);
1438 // Process beginning of an instruction.
1439 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1440 // Check if source location changes, but ignore DBG_VALUE locations.
1441 if (!MI->isDebugValue()) {
1442 DebugLoc DL = MI->getDebugLoc();
1443 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1446 if (DL == PrologEndLoc) {
1447 Flags |= DWARF2_FLAG_PROLOGUE_END;
1448 PrologEndLoc = DebugLoc();
1450 if (PrologEndLoc.isUnknown())
1451 Flags |= DWARF2_FLAG_IS_STMT;
1453 if (!DL.isUnknown()) {
1454 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1455 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1457 recordSourceLine(0, 0, 0, 0);
1461 // Insert labels where requested.
1462 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1463 LabelsBeforeInsn.find(MI);
1466 if (I == LabelsBeforeInsn.end())
1469 // Label already assigned.
1474 PrevLabel = MMI->getContext().CreateTempSymbol();
1475 Asm->OutStreamer.EmitLabel(PrevLabel);
1477 I->second = PrevLabel;
1480 // Process end of an instruction.
1481 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1482 // Don't create a new label after DBG_VALUE instructions.
1483 // They don't generate code.
1484 if (!MI->isDebugValue())
1487 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1488 LabelsAfterInsn.find(MI);
1491 if (I == LabelsAfterInsn.end())
1494 // Label already assigned.
1498 // We need a label after this instruction.
1500 PrevLabel = MMI->getContext().CreateTempSymbol();
1501 Asm->OutStreamer.EmitLabel(PrevLabel);
1503 I->second = PrevLabel;
1506 // Each LexicalScope has first instruction and last instruction to mark
1507 // beginning and end of a scope respectively. Create an inverse map that list
1508 // scopes starts (and ends) with an instruction. One instruction may start (or
1509 // end) multiple scopes. Ignore scopes that are not reachable.
1510 void DwarfDebug::identifyScopeMarkers() {
1511 SmallVector<LexicalScope *, 4> WorkList;
1512 WorkList.push_back(LScopes.getCurrentFunctionScope());
1513 while (!WorkList.empty()) {
1514 LexicalScope *S = WorkList.pop_back_val();
1516 const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1517 if (!Children.empty())
1518 for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1519 SE = Children.end(); SI != SE; ++SI)
1520 WorkList.push_back(*SI);
1522 if (S->isAbstractScope())
1525 const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1528 for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1529 RE = Ranges.end(); RI != RE; ++RI) {
1530 assert(RI->first && "InsnRange does not have first instruction!");
1531 assert(RI->second && "InsnRange does not have second instruction!");
1532 requestLabelBeforeInsn(RI->first);
1533 requestLabelAfterInsn(RI->second);
1538 // Get MDNode for DebugLoc's scope.
1539 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1540 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1541 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1542 return DL.getScope(Ctx);
1545 // Walk up the scope chain of given debug loc and find line number info
1546 // for the function.
1547 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1548 const MDNode *Scope = getScopeNode(DL, Ctx);
1549 DISubprogram SP = getDISubprogram(Scope);
1550 if (SP.isSubprogram()) {
1551 // Check for number of operands since the compatibility is
1553 if (SP->getNumOperands() > 19)
1554 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1556 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1562 // Gather pre-function debug information. Assumes being called immediately
1563 // after the function entry point has been emitted.
1564 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1565 if (!MMI->hasDebugInfo()) return;
1566 LScopes.initialize(*MF);
1567 if (LScopes.empty()) return;
1568 identifyScopeMarkers();
1570 // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1572 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1573 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1574 assert(TheCU && "Unable to find compile unit!");
1575 if (Asm->TM.hasMCUseLoc() &&
1576 Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1577 // Use a single line table if we are using .loc and generating assembly.
1578 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1580 Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1582 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1583 Asm->getFunctionNumber());
1584 // Assumes in correct section after the entry point.
1585 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1587 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1589 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1590 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1591 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1593 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1595 bool AtBlockEntry = true;
1596 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1598 const MachineInstr *MI = II;
1600 if (MI->isDebugValue()) {
1601 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1603 // Keep track of user variables.
1605 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1607 // Variable is in a register, we need to check for clobbers.
1608 if (isDbgValueInDefinedReg(MI))
1609 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1611 // Check the history of this variable.
1612 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1613 if (History.empty()) {
1614 UserVariables.push_back(Var);
1615 // The first mention of a function argument gets the FunctionBeginSym
1616 // label, so arguments are visible when breaking at function entry.
1618 if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1619 DISubprogram(getDISubprogram(DV.getContext()))
1620 .describes(MF->getFunction()))
1621 LabelsBeforeInsn[MI] = FunctionBeginSym;
1623 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1624 const MachineInstr *Prev = History.back();
1625 if (Prev->isDebugValue()) {
1626 // Coalesce identical entries at the end of History.
1627 if (History.size() >= 2 &&
1628 Prev->isIdenticalTo(History[History.size() - 2])) {
1629 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1631 << "\t" << *History[History.size() - 2] << "\n");
1635 // Terminate old register assignments that don't reach MI;
1636 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1637 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1638 isDbgValueInDefinedReg(Prev)) {
1639 // Previous register assignment needs to terminate at the end of
1641 MachineBasicBlock::const_iterator LastMI =
1642 PrevMBB->getLastNonDebugInstr();
1643 if (LastMI == PrevMBB->end()) {
1644 // Drop DBG_VALUE for empty range.
1645 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1646 << "\t" << *Prev << "\n");
1648 } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1649 // Terminate after LastMI.
1650 History.push_back(LastMI);
1654 History.push_back(MI);
1656 // Not a DBG_VALUE instruction.
1658 AtBlockEntry = false;
1660 // First known non-DBG_VALUE and non-frame setup location marks
1661 // the beginning of the function body.
1662 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1663 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1664 PrologEndLoc = MI->getDebugLoc();
1666 // Check if the instruction clobbers any registers with debug vars.
1667 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1668 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1669 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1671 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1672 AI.isValid(); ++AI) {
1674 const MDNode *Var = LiveUserVar[Reg];
1677 // Reg is now clobbered.
1678 LiveUserVar[Reg] = 0;
1680 // Was MD last defined by a DBG_VALUE referring to Reg?
1681 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1682 if (HistI == DbgValues.end())
1684 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1685 if (History.empty())
1687 const MachineInstr *Prev = History.back();
1688 // Sanity-check: Register assignments are terminated at the end of
1690 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1692 // Is the variable still in Reg?
1693 if (!isDbgValueInDefinedReg(Prev) ||
1694 Prev->getOperand(0).getReg() != Reg)
1696 // Var is clobbered. Make sure the next instruction gets a label.
1697 History.push_back(MI);
1704 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1706 SmallVectorImpl<const MachineInstr*> &History = I->second;
1707 if (History.empty())
1710 // Make sure the final register assignments are terminated.
1711 const MachineInstr *Prev = History.back();
1712 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1713 const MachineBasicBlock *PrevMBB = Prev->getParent();
1714 MachineBasicBlock::const_iterator LastMI =
1715 PrevMBB->getLastNonDebugInstr();
1716 if (LastMI == PrevMBB->end())
1717 // Drop DBG_VALUE for empty range.
1719 else if (PrevMBB != &PrevMBB->getParent()->back()) {
1720 // Terminate after LastMI.
1721 History.push_back(LastMI);
1724 // Request labels for the full history.
1725 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1726 const MachineInstr *MI = History[i];
1727 if (MI->isDebugValue())
1728 requestLabelBeforeInsn(MI);
1730 requestLabelAfterInsn(MI);
1734 PrevInstLoc = DebugLoc();
1735 PrevLabel = FunctionBeginSym;
1737 // Record beginning of function.
1738 if (!PrologEndLoc.isUnknown()) {
1739 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1740 MF->getFunction()->getContext());
1741 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1742 FnStartDL.getScope(MF->getFunction()->getContext()),
1743 // We'd like to list the prologue as "not statements" but GDB behaves
1744 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1745 DWARF2_FLAG_IS_STMT);
1749 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1750 SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1751 DIVariable DV = Var->getVariable();
1752 // Variables with positive arg numbers are parameters.
1753 if (unsigned ArgNum = DV.getArgNumber()) {
1754 // Keep all parameters in order at the start of the variable list to ensure
1755 // function types are correct (no out-of-order parameters)
1757 // This could be improved by only doing it for optimized builds (unoptimized
1758 // builds have the right order to begin with), searching from the back (this
1759 // would catch the unoptimized case quickly), or doing a binary search
1760 // rather than linear search.
1761 SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1762 while (I != Vars.end()) {
1763 unsigned CurNum = (*I)->getVariable().getArgNumber();
1764 // A local (non-parameter) variable has been found, insert immediately
1768 // A later indexed parameter has been found, insert immediately before it.
1769 if (CurNum > ArgNum)
1773 Vars.insert(I, Var);
1777 Vars.push_back(Var);
1780 // Gather and emit post-function debug information.
1781 void DwarfDebug::endFunction(const MachineFunction *MF) {
1782 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1784 // Define end label for subprogram.
1785 FunctionEndSym = Asm->GetTempSymbol("func_end",
1786 Asm->getFunctionNumber());
1787 // Assumes in correct section after the entry point.
1788 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1789 // Set DwarfCompileUnitID in MCContext to default value.
1790 Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1792 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1793 collectVariableInfo(MF, ProcessedVars);
1795 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1796 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1797 assert(TheCU && "Unable to find compile unit!");
1799 // Construct abstract scopes.
1800 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1801 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1802 LexicalScope *AScope = AList[i];
1803 DISubprogram SP(AScope->getScopeNode());
1804 if (SP.isSubprogram()) {
1805 // Collect info for variables that were optimized out.
1806 DIArray Variables = SP.getVariables();
1807 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1808 DIVariable DV(Variables.getElement(i));
1809 if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1811 // Check that DbgVariable for DV wasn't created earlier, when
1812 // findAbstractVariable() was called for inlined instance of DV.
1813 LLVMContext &Ctx = DV->getContext();
1814 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1815 if (AbstractVariables.lookup(CleanDV))
1817 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1818 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1821 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1822 constructScopeDIE(TheCU, AScope);
1825 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1827 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1828 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1831 for (ScopeVariablesMap::iterator
1832 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1833 DeleteContainerPointers(I->second);
1834 ScopeVariables.clear();
1835 DeleteContainerPointers(CurrentFnArguments);
1836 UserVariables.clear();
1838 AbstractVariables.clear();
1839 LabelsBeforeInsn.clear();
1840 LabelsAfterInsn.clear();
1844 // Register a source line with debug info. Returns the unique label that was
1845 // emitted and which provides correspondence to the source line list.
1846 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1852 DIDescriptor Scope(S);
1854 if (Scope.isCompileUnit()) {
1855 DICompileUnit CU(S);
1856 Fn = CU.getFilename();
1857 Dir = CU.getDirectory();
1858 } else if (Scope.isFile()) {
1860 Fn = F.getFilename();
1861 Dir = F.getDirectory();
1862 } else if (Scope.isSubprogram()) {
1864 Fn = SP.getFilename();
1865 Dir = SP.getDirectory();
1866 } else if (Scope.isLexicalBlockFile()) {
1867 DILexicalBlockFile DBF(S);
1868 Fn = DBF.getFilename();
1869 Dir = DBF.getDirectory();
1870 } else if (Scope.isLexicalBlock()) {
1871 DILexicalBlock DB(S);
1872 Fn = DB.getFilename();
1873 Dir = DB.getDirectory();
1875 llvm_unreachable("Unexpected scope info");
1877 Src = getOrCreateSourceID(Fn, Dir,
1878 Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1880 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1883 //===----------------------------------------------------------------------===//
1885 //===----------------------------------------------------------------------===//
1887 // Compute the size and offset of a DIE.
1889 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1890 // Get the children.
1891 const std::vector<DIE *> &Children = Die->getChildren();
1893 // Record the abbreviation.
1894 assignAbbrevNumber(Die->getAbbrev());
1896 // Get the abbreviation for this DIE.
1897 unsigned AbbrevNumber = Die->getAbbrevNumber();
1898 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1901 Die->setOffset(Offset);
1903 // Start the size with the size of abbreviation code.
1904 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1906 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1907 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1909 // Size the DIE attribute values.
1910 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1911 // Size attribute value.
1912 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1914 // Size the DIE children if any.
1915 if (!Children.empty()) {
1916 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1917 "Children flag not set");
1919 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1920 Offset = computeSizeAndOffset(Children[j], Offset);
1922 // End of children marker.
1923 Offset += sizeof(int8_t);
1926 Die->setSize(Offset - Die->getOffset());
1930 // Compute the size and offset of all the DIEs.
1931 void DwarfUnits::computeSizeAndOffsets() {
1932 // Offset from the beginning of debug info section.
1933 unsigned SecOffset = 0;
1934 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1935 E = CUs.end(); I != E; ++I) {
1936 (*I)->setDebugInfoOffset(SecOffset);
1938 sizeof(int32_t) + // Length of Compilation Unit Info
1939 sizeof(int16_t) + // DWARF version number
1940 sizeof(int32_t) + // Offset Into Abbrev. Section
1941 sizeof(int8_t); // Pointer Size (in bytes)
1943 unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1944 SecOffset += EndOffset;
1948 // Emit initial Dwarf sections with a label at the start of each one.
1949 void DwarfDebug::emitSectionLabels() {
1950 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1952 // Dwarf sections base addresses.
1953 DwarfInfoSectionSym =
1954 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1955 DwarfAbbrevSectionSym =
1956 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1957 if (useSplitDwarf())
1958 DwarfAbbrevDWOSectionSym =
1959 emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1960 "section_abbrev_dwo");
1961 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1963 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1964 emitSectionSym(Asm, MacroInfo);
1966 DwarfLineSectionSym =
1967 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1968 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1969 if (GenerateGnuPubSections) {
1970 emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1971 emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1972 } else if (HasDwarfPubSections) {
1973 emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1974 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1977 DwarfStrSectionSym =
1978 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1979 if (useSplitDwarf()) {
1980 DwarfStrDWOSectionSym =
1981 emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1982 DwarfAddrSectionSym =
1983 emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1985 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1988 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1989 "section_debug_loc");
1991 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1992 emitSectionSym(Asm, TLOF.getDataSection());
1995 // Recursively emits a debug information entry.
1996 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1997 // Get the abbreviation for this DIE.
1998 unsigned AbbrevNumber = Die->getAbbrevNumber();
1999 const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2001 // Emit the code (index) for the abbreviation.
2002 if (Asm->isVerbose())
2003 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2004 Twine::utohexstr(Die->getOffset()) + ":0x" +
2005 Twine::utohexstr(Die->getSize()) + " " +
2006 dwarf::TagString(Abbrev->getTag()));
2007 Asm->EmitULEB128(AbbrevNumber);
2009 const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2010 const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2012 // Emit the DIE attribute values.
2013 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2014 unsigned Attr = AbbrevData[i].getAttribute();
2015 unsigned Form = AbbrevData[i].getForm();
2016 assert(Form && "Too many attributes for DIE (check abbreviation)");
2018 if (Asm->isVerbose())
2019 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2022 case dwarf::DW_AT_abstract_origin: {
2023 DIEEntry *E = cast<DIEEntry>(Values[i]);
2024 DIE *Origin = E->getEntry();
2025 unsigned Addr = Origin->getOffset();
2026 if (Form == dwarf::DW_FORM_ref_addr) {
2027 // For DW_FORM_ref_addr, output the offset from beginning of debug info
2028 // section. Origin->getOffset() returns the offset from start of the
2030 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2031 Addr += Holder.getCUOffset(Origin->getCompileUnit());
2033 Asm->OutStreamer.EmitIntValue(Addr,
2034 Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2037 case dwarf::DW_AT_ranges: {
2038 // DW_AT_range Value encodes offset in debug_range section.
2039 DIEInteger *V = cast<DIEInteger>(Values[i]);
2041 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2042 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2046 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2048 DwarfDebugRangeSectionSym,
2053 case dwarf::DW_AT_location: {
2054 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2055 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2056 Asm->EmitLabelReference(L->getValue(), 4);
2058 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2060 Values[i]->EmitValue(Asm, Form);
2064 case dwarf::DW_AT_accessibility: {
2065 if (Asm->isVerbose()) {
2066 DIEInteger *V = cast<DIEInteger>(Values[i]);
2067 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2069 Values[i]->EmitValue(Asm, Form);
2073 // Emit an attribute using the defined form.
2074 Values[i]->EmitValue(Asm, Form);
2079 // Emit the DIE children if any.
2080 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2081 const std::vector<DIE *> &Children = Die->getChildren();
2083 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2084 emitDIE(Children[j], Abbrevs);
2086 if (Asm->isVerbose())
2087 Asm->OutStreamer.AddComment("End Of Children Mark");
2092 // Emit the various dwarf units to the unit section USection with
2093 // the abbreviations going into ASection.
2094 void DwarfUnits::emitUnits(DwarfDebug *DD,
2095 const MCSection *USection,
2096 const MCSection *ASection,
2097 const MCSymbol *ASectionSym) {
2098 Asm->OutStreamer.SwitchSection(USection);
2099 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2100 E = CUs.end(); I != E; ++I) {
2101 CompileUnit *TheCU = *I;
2102 DIE *Die = TheCU->getCUDie();
2104 // Emit the compile units header.
2106 .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2107 TheCU->getUniqueID()));
2109 // Emit size of content not including length itself
2110 unsigned ContentSize = Die->getSize() +
2111 sizeof(int16_t) + // DWARF version number
2112 sizeof(int32_t) + // Offset Into Abbrev. Section
2113 sizeof(int8_t); // Pointer Size (in bytes)
2115 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2116 Asm->EmitInt32(ContentSize);
2117 Asm->OutStreamer.AddComment("DWARF version number");
2118 Asm->EmitInt16(DD->getDwarfVersion());
2119 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2120 Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2122 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2123 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2125 DD->emitDIE(Die, Abbreviations);
2126 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2127 TheCU->getUniqueID()));
2131 /// For a given compile unit DIE, returns offset from beginning of debug info.
2132 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2133 assert(Die->getTag() == dwarf::DW_TAG_compile_unit &&
2134 "Input DIE should be compile unit in getCUOffset.");
2135 for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2137 CompileUnit *TheCU = *I;
2138 if (TheCU->getCUDie() == Die)
2139 return TheCU->getDebugInfoOffset();
2141 llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2144 // Emit the debug info section.
2145 void DwarfDebug::emitDebugInfo() {
2146 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2148 Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2149 Asm->getObjFileLowering().getDwarfAbbrevSection(),
2150 DwarfAbbrevSectionSym);
2153 // Emit the abbreviation section.
2154 void DwarfDebug::emitAbbreviations() {
2155 if (!useSplitDwarf())
2156 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2159 emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2162 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2163 std::vector<DIEAbbrev *> *Abbrevs) {
2164 // Check to see if it is worth the effort.
2165 if (!Abbrevs->empty()) {
2166 // Start the debug abbrev section.
2167 Asm->OutStreamer.SwitchSection(Section);
2169 MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2170 Asm->OutStreamer.EmitLabel(Begin);
2172 // For each abbrevation.
2173 for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2174 // Get abbreviation data
2175 const DIEAbbrev *Abbrev = Abbrevs->at(i);
2177 // Emit the abbrevations code (base 1 index.)
2178 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2180 // Emit the abbreviations data.
2184 // Mark end of abbreviations.
2185 Asm->EmitULEB128(0, "EOM(3)");
2187 MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2188 Asm->OutStreamer.EmitLabel(End);
2192 // Emit the last address of the section and the end of the line matrix.
2193 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2194 // Define last address of section.
2195 Asm->OutStreamer.AddComment("Extended Op");
2198 Asm->OutStreamer.AddComment("Op size");
2199 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2200 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2201 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2203 Asm->OutStreamer.AddComment("Section end label");
2205 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2206 Asm->getDataLayout().getPointerSize());
2208 // Mark end of matrix.
2209 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2215 // Emit visible names into a hashed accelerator table section.
2216 void DwarfDebug::emitAccelNames() {
2217 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2218 dwarf::DW_FORM_data4));
2219 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2220 E = CUMap.end(); I != E; ++I) {
2221 CompileUnit *TheCU = I->second;
2222 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2223 for (StringMap<std::vector<DIE*> >::const_iterator
2224 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2225 StringRef Name = GI->getKey();
2226 const std::vector<DIE *> &Entities = GI->second;
2227 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2228 DE = Entities.end(); DI != DE; ++DI)
2229 AT.AddName(Name, (*DI));
2233 AT.FinalizeTable(Asm, "Names");
2234 Asm->OutStreamer.SwitchSection(
2235 Asm->getObjFileLowering().getDwarfAccelNamesSection());
2236 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2237 Asm->OutStreamer.EmitLabel(SectionBegin);
2239 // Emit the full data.
2240 AT.Emit(Asm, SectionBegin, &InfoHolder);
2243 // Emit objective C classes and categories into a hashed accelerator table
2245 void DwarfDebug::emitAccelObjC() {
2246 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2247 dwarf::DW_FORM_data4));
2248 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2249 E = CUMap.end(); I != E; ++I) {
2250 CompileUnit *TheCU = I->second;
2251 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2252 for (StringMap<std::vector<DIE*> >::const_iterator
2253 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2254 StringRef Name = GI->getKey();
2255 const std::vector<DIE *> &Entities = GI->second;
2256 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2257 DE = Entities.end(); DI != DE; ++DI)
2258 AT.AddName(Name, (*DI));
2262 AT.FinalizeTable(Asm, "ObjC");
2263 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2264 .getDwarfAccelObjCSection());
2265 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2266 Asm->OutStreamer.EmitLabel(SectionBegin);
2268 // Emit the full data.
2269 AT.Emit(Asm, SectionBegin, &InfoHolder);
2272 // Emit namespace dies into a hashed accelerator table.
2273 void DwarfDebug::emitAccelNamespaces() {
2274 DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2275 dwarf::DW_FORM_data4));
2276 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2277 E = CUMap.end(); I != E; ++I) {
2278 CompileUnit *TheCU = I->second;
2279 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2280 for (StringMap<std::vector<DIE*> >::const_iterator
2281 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2282 StringRef Name = GI->getKey();
2283 const std::vector<DIE *> &Entities = GI->second;
2284 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2285 DE = Entities.end(); DI != DE; ++DI)
2286 AT.AddName(Name, (*DI));
2290 AT.FinalizeTable(Asm, "namespac");
2291 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2292 .getDwarfAccelNamespaceSection());
2293 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2294 Asm->OutStreamer.EmitLabel(SectionBegin);
2296 // Emit the full data.
2297 AT.Emit(Asm, SectionBegin, &InfoHolder);
2300 // Emit type dies into a hashed accelerator table.
2301 void DwarfDebug::emitAccelTypes() {
2302 std::vector<DwarfAccelTable::Atom> Atoms;
2303 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2304 dwarf::DW_FORM_data4));
2305 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2306 dwarf::DW_FORM_data2));
2307 Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2308 dwarf::DW_FORM_data1));
2309 DwarfAccelTable AT(Atoms);
2310 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2311 E = CUMap.end(); I != E; ++I) {
2312 CompileUnit *TheCU = I->second;
2313 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2314 = TheCU->getAccelTypes();
2315 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2316 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2317 StringRef Name = GI->getKey();
2318 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2319 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2320 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2321 AT.AddName(Name, (*DI).first, (*DI).second);
2325 AT.FinalizeTable(Asm, "types");
2326 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2327 .getDwarfAccelTypesSection());
2328 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2329 Asm->OutStreamer.EmitLabel(SectionBegin);
2331 // Emit the full data.
2332 AT.Emit(Asm, SectionBegin, &InfoHolder);
2335 // Public name handling.
2336 // The format for the various pubnames:
2338 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2339 // for the DIE that is named.
2341 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2342 // into the CU and the index value is computed according to the type of value
2343 // for the DIE that is named.
2345 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2346 // it's the offset within the debug_info/debug_types dwo section, however, the
2347 // reference in the pubname header doesn't change.
2349 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2350 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2352 dwarf::GDBIndexEntryLinkage Linkage =
2353 Die->findAttribute(dwarf::DW_AT_external) ? dwarf::GIEL_EXTERNAL
2354 : dwarf::GIEL_STATIC;
2356 switch (Die->getTag()) {
2357 case dwarf::DW_TAG_class_type:
2358 case dwarf::DW_TAG_structure_type:
2359 case dwarf::DW_TAG_union_type:
2360 case dwarf::DW_TAG_enumeration_type:
2361 return dwarf::PubIndexEntryDescriptor(
2362 dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2363 ? dwarf::GIEL_STATIC
2364 : dwarf::GIEL_EXTERNAL);
2365 case dwarf::DW_TAG_typedef:
2366 case dwarf::DW_TAG_base_type:
2367 case dwarf::DW_TAG_subrange_type:
2368 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2369 case dwarf::DW_TAG_namespace:
2370 return dwarf::GIEK_TYPE;
2371 case dwarf::DW_TAG_subprogram:
2372 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2373 case dwarf::DW_TAG_constant:
2374 case dwarf::DW_TAG_variable:
2375 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2376 case dwarf::DW_TAG_enumerator:
2377 return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2378 dwarf::GIEL_STATIC);
2380 return dwarf::GIEK_NONE;
2384 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2386 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2387 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2388 const MCSection *PSec =
2389 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2390 : Asm->getObjFileLowering().getDwarfPubNamesSection();
2392 typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2393 for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2394 CompileUnit *TheCU = I->second;
2395 unsigned ID = TheCU->getUniqueID();
2397 if (TheCU->getGlobalNames().empty())
2400 // Start the dwarf pubnames section.
2401 Asm->OutStreamer.SwitchSection(PSec);
2404 Asm->OutStreamer.AddComment("Length of Public Names Info");
2405 Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2406 Asm->GetTempSymbol("pubnames_begin", ID), 4);
2408 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2410 Asm->OutStreamer.AddComment("DWARF Version");
2411 Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2413 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2414 Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2415 DwarfInfoSectionSym);
2417 Asm->OutStreamer.AddComment("Compilation Unit Length");
2418 Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2419 Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2422 // Emit the pubnames for this compilation unit.
2423 const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2424 for (StringMap<DIE*>::const_iterator
2425 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2426 const char *Name = GI->getKeyData();
2427 DIE *Entity = GI->second;
2429 Asm->OutStreamer.AddComment("DIE offset");
2430 Asm->EmitInt32(Entity->getOffset());
2433 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2434 Asm->OutStreamer.AddComment(
2435 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2436 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2437 Asm->EmitInt8(Desc.toBits());
2440 if (Asm->isVerbose())
2441 Asm->OutStreamer.AddComment("External Name");
2442 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2445 Asm->OutStreamer.AddComment("End Mark");
2447 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2451 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2452 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2453 const MCSection *PSec =
2454 GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2455 : Asm->getObjFileLowering().getDwarfPubTypesSection();
2457 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2460 CompileUnit *TheCU = I->second;
2461 // Start the dwarf pubtypes section.
2462 Asm->OutStreamer.SwitchSection(PSec);
2463 Asm->OutStreamer.AddComment("Length of Public Types Info");
2464 Asm->EmitLabelDifference(
2465 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2466 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2468 Asm->OutStreamer.EmitLabel(
2469 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2471 if (Asm->isVerbose())
2472 Asm->OutStreamer.AddComment("DWARF Version");
2473 Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2475 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2476 Asm->EmitSectionOffset(
2477 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2478 DwarfInfoSectionSym);
2480 Asm->OutStreamer.AddComment("Compilation Unit Length");
2481 Asm->EmitLabelDifference(
2482 Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2483 Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2485 const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2486 for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2489 const char *Name = GI->getKeyData();
2490 DIE *Entity = GI->second;
2492 if (Asm->isVerbose())
2493 Asm->OutStreamer.AddComment("DIE offset");
2494 Asm->EmitInt32(Entity->getOffset());
2497 dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2498 Asm->OutStreamer.AddComment(
2499 Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2500 dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2501 Asm->EmitInt8(Desc.toBits());
2504 if (Asm->isVerbose())
2505 Asm->OutStreamer.AddComment("External Name");
2507 // Emit the name with a terminating null byte.
2508 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2511 Asm->OutStreamer.AddComment("End Mark");
2513 Asm->OutStreamer.EmitLabel(
2514 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2518 // Emit strings into a string section.
2519 void DwarfUnits::emitStrings(const MCSection *StrSection,
2520 const MCSection *OffsetSection = NULL,
2521 const MCSymbol *StrSecSym = NULL) {
2523 if (StringPool.empty()) return;
2525 // Start the dwarf str section.
2526 Asm->OutStreamer.SwitchSection(StrSection);
2528 // Get all of the string pool entries and put them in an array by their ID so
2529 // we can sort them.
2530 SmallVector<std::pair<unsigned,
2531 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2533 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2534 I = StringPool.begin(), E = StringPool.end();
2536 Entries.push_back(std::make_pair(I->second.second, &*I));
2538 array_pod_sort(Entries.begin(), Entries.end());
2540 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2541 // Emit a label for reference from debug information entries.
2542 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2544 // Emit the string itself with a terminating null byte.
2545 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2546 Entries[i].second->getKeyLength()+1));
2549 // If we've got an offset section go ahead and emit that now as well.
2550 if (OffsetSection) {
2551 Asm->OutStreamer.SwitchSection(OffsetSection);
2552 unsigned offset = 0;
2553 unsigned size = 4; // FIXME: DWARF64 is 8.
2554 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2555 Asm->OutStreamer.EmitIntValue(offset, size);
2556 offset += Entries[i].second->getKeyLength() + 1;
2561 // Emit strings into a string section.
2562 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2564 if (AddressPool.empty()) return;
2566 // Start the dwarf addr section.
2567 Asm->OutStreamer.SwitchSection(AddrSection);
2569 // Order the address pool entries by ID
2570 SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2572 for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2573 E = AddressPool.end();
2575 Entries[I->second] = I->first;
2577 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2578 // Emit an expression for reference from debug information entries.
2579 if (const MCExpr *Expr = Entries[i])
2580 Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2582 Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2587 // Emit visible names into a debug str section.
2588 void DwarfDebug::emitDebugStr() {
2589 DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2590 Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2593 // Emit locations into the debug loc section.
2594 void DwarfDebug::emitDebugLoc() {
2595 if (DotDebugLocEntries.empty())
2598 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2599 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2601 DotDebugLocEntry &Entry = *I;
2602 if (I + 1 != DotDebugLocEntries.end())
2606 // Start the dwarf loc section.
2607 Asm->OutStreamer.SwitchSection(
2608 Asm->getObjFileLowering().getDwarfLocSection());
2609 unsigned char Size = Asm->getDataLayout().getPointerSize();
2610 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2612 for (SmallVectorImpl<DotDebugLocEntry>::iterator
2613 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2614 I != E; ++I, ++index) {
2615 DotDebugLocEntry &Entry = *I;
2616 if (Entry.isMerged()) continue;
2617 if (Entry.isEmpty()) {
2618 Asm->OutStreamer.EmitIntValue(0, Size);
2619 Asm->OutStreamer.EmitIntValue(0, Size);
2620 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2622 Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2623 Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2624 DIVariable DV(Entry.getVariable());
2625 Asm->OutStreamer.AddComment("Loc expr size");
2626 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2627 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2628 Asm->EmitLabelDifference(end, begin, 2);
2629 Asm->OutStreamer.EmitLabel(begin);
2630 if (Entry.isInt()) {
2631 DIBasicType BTy(DV.getType());
2633 (BTy.getEncoding() == dwarf::DW_ATE_signed
2634 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2635 Asm->OutStreamer.AddComment("DW_OP_consts");
2636 Asm->EmitInt8(dwarf::DW_OP_consts);
2637 Asm->EmitSLEB128(Entry.getInt());
2639 Asm->OutStreamer.AddComment("DW_OP_constu");
2640 Asm->EmitInt8(dwarf::DW_OP_constu);
2641 Asm->EmitULEB128(Entry.getInt());
2643 } else if (Entry.isLocation()) {
2644 MachineLocation Loc = Entry.getLoc();
2645 if (!DV.hasComplexAddress())
2647 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2649 // Complex address entry.
2650 unsigned N = DV.getNumAddrElements();
2652 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2653 if (Loc.getOffset()) {
2655 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2656 Asm->OutStreamer.AddComment("DW_OP_deref");
2657 Asm->EmitInt8(dwarf::DW_OP_deref);
2658 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2659 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2660 Asm->EmitSLEB128(DV.getAddrElement(1));
2662 // If first address element is OpPlus then emit
2663 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2664 MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2665 Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2669 Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2672 // Emit remaining complex address elements.
2673 for (; i < N; ++i) {
2674 uint64_t Element = DV.getAddrElement(i);
2675 if (Element == DIBuilder::OpPlus) {
2676 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2677 Asm->EmitULEB128(DV.getAddrElement(++i));
2678 } else if (Element == DIBuilder::OpDeref) {
2680 Asm->EmitInt8(dwarf::DW_OP_deref);
2682 llvm_unreachable("unknown Opcode found in complex address");
2686 // else ... ignore constant fp. There is not any good way to
2687 // to represent them here in dwarf.
2688 Asm->OutStreamer.EmitLabel(end);
2693 struct SymbolCUSorter {
2694 SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2695 const MCStreamer &Streamer;
2697 bool operator() (const SymbolCU &A, const SymbolCU &B) {
2698 unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2699 unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2701 // Symbols with no order assigned should be placed at the end.
2702 // (e.g. section end labels)
2704 IA = (unsigned)(-1);
2706 IB = (unsigned)(-1);
2711 static bool SectionSort(const MCSection *A, const MCSection *B) {
2712 std::string LA = (A ? A->getLabelBeginName() : "");
2713 std::string LB = (B ? B->getLabelBeginName() : "");
2717 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2718 return (A->getUniqueID() < B->getUniqueID());
2722 const MCSymbol *Start, *End;
2725 // Emit a debug aranges section, containing a CU lookup for any
2726 // address we can tie back to a CU.
2727 void DwarfDebug::emitDebugARanges() {
2728 // Start the dwarf aranges section.
2730 .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2732 typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2736 // Build a list of sections used.
2737 std::vector<const MCSection *> Sections;
2738 for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2740 const MCSection *Section = it->first;
2741 Sections.push_back(Section);
2744 // Sort the sections into order.
2745 // This is only done to ensure consistent output order across different runs.
2746 std::sort(Sections.begin(), Sections.end(), SectionSort);
2748 // Build a set of address spans, sorted by CU.
2749 for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2750 const MCSection *Section = Sections[SecIdx];
2751 SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2752 if (List.size() < 2)
2755 // Sort the symbols by offset within the section.
2756 SymbolCUSorter sorter(Asm->OutStreamer);
2757 std::sort(List.begin(), List.end(), sorter);
2759 // If we have no section (e.g. common), just write out
2760 // individual spans for each symbol.
2761 if (Section == NULL) {
2762 for (size_t n = 0; n < List.size(); n++) {
2763 const SymbolCU &Cur = List[n];
2766 Span.Start = Cur.Sym;
2769 Spans[Cur.CU].push_back(Span);
2772 // Build spans between each label.
2773 const MCSymbol *StartSym = List[0].Sym;
2774 for (size_t n = 1; n < List.size(); n++) {
2775 const SymbolCU &Prev = List[n - 1];
2776 const SymbolCU &Cur = List[n];
2778 // Try and build the longest span we can within the same CU.
2779 if (Cur.CU != Prev.CU) {
2781 Span.Start = StartSym;
2783 Spans[Prev.CU].push_back(Span);
2790 const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2791 unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2793 // Build a list of CUs used.
2794 std::vector<CompileUnit *> CUs;
2795 for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2796 CompileUnit *CU = it->first;
2800 // Sort the CU list (again, to ensure consistent output order).
2801 std::sort(CUs.begin(), CUs.end(), CUSort);
2803 // Emit an arange table for each CU we used.
2804 for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2805 CompileUnit *CU = CUs[CUIdx];
2806 std::vector<ArangeSpan> &List = Spans[CU];
2808 // Emit size of content not including length itself.
2809 unsigned ContentSize
2810 = sizeof(int16_t) // DWARF ARange version number
2811 + sizeof(int32_t) // Offset of CU in the .debug_info section
2812 + sizeof(int8_t) // Pointer Size (in bytes)
2813 + sizeof(int8_t); // Segment Size (in bytes)
2815 unsigned TupleSize = PtrSize * 2;
2817 // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2818 unsigned Padding = 0;
2819 while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2822 ContentSize += Padding;
2823 ContentSize += (List.size() + 1) * TupleSize;
2825 // For each compile unit, write the list of spans it covers.
2826 Asm->OutStreamer.AddComment("Length of ARange Set");
2827 Asm->EmitInt32(ContentSize);
2828 Asm->OutStreamer.AddComment("DWARF Arange version number");
2829 Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2830 Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2831 Asm->EmitSectionOffset(
2832 Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2833 DwarfInfoSectionSym);
2834 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2835 Asm->EmitInt8(PtrSize);
2836 Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2839 for (unsigned n = 0; n < Padding; n++)
2840 Asm->EmitInt8(0xff);
2842 for (unsigned n = 0; n < List.size(); n++) {
2843 const ArangeSpan &Span = List[n];
2844 Asm->EmitLabelReference(Span.Start, PtrSize);
2846 // Calculate the size as being from the span start to it's end.
2848 Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2850 // For symbols without an end marker (e.g. common), we
2851 // write a single arange entry containing just that one symbol.
2852 uint64_t Size = SymSize[Span.Start];
2856 Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2860 Asm->OutStreamer.AddComment("ARange terminator");
2861 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2862 Asm->OutStreamer.EmitIntValue(0, PtrSize);
2866 // Emit visible names into a debug ranges section.
2867 void DwarfDebug::emitDebugRanges() {
2868 // Start the dwarf ranges section.
2870 .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2871 unsigned char Size = Asm->getDataLayout().getPointerSize();
2872 for (SmallVectorImpl<const MCSymbol *>::iterator
2873 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2876 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2878 Asm->OutStreamer.EmitIntValue(0, Size);
2882 // Emit visible names into a debug macinfo section.
2883 void DwarfDebug::emitDebugMacInfo() {
2884 if (const MCSection *LineInfo =
2885 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2886 // Start the dwarf macinfo section.
2887 Asm->OutStreamer.SwitchSection(LineInfo);
2891 // DWARF5 Experimental Separate Dwarf emitters.
2893 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2894 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2895 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2896 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2897 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2899 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2900 CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2901 Asm, this, &SkeletonHolder);
2903 NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2904 DICompileUnit(CU->getNode()).getSplitDebugFilename());
2906 // Relocate to the beginning of the addr_base section, else 0 for the
2907 // beginning of the one for this compile unit.
2908 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2909 NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2910 DwarfAddrSectionSym);
2912 NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2913 dwarf::DW_FORM_sec_offset, 0);
2915 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2916 // into an entity. We're using 0, or a NULL label for this.
2917 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2919 // DW_AT_stmt_list is a offset of line number information for this
2920 // compile unit in debug_line section.
2921 // FIXME: Should handle multiple compile units.
2922 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2923 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2924 DwarfLineSectionSym);
2926 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2928 if (!CompilationDir.empty())
2929 NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2931 // Flag to let the linker know we have emitted new style pubnames.
2932 if (GenerateGnuPubSections)
2933 NewCU->addFlag(Die, dwarf::DW_AT_GNU_pubnames);
2935 SkeletonHolder.addUnit(NewCU);
2936 SkeletonCUs.push_back(NewCU);
2941 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2942 assert(useSplitDwarf() && "No split dwarf debug info?");
2943 emitAbbrevs(Section, &SkeletonAbbrevs);
2946 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2947 // compile units that would normally be in debug_info.
2948 void DwarfDebug::emitDebugInfoDWO() {
2949 assert(useSplitDwarf() && "No split dwarf debug info?");
2950 InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2951 Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2952 DwarfAbbrevDWOSectionSym);
2955 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2956 // abbreviations for the .debug_info.dwo section.
2957 void DwarfDebug::emitDebugAbbrevDWO() {
2958 assert(useSplitDwarf() && "No split dwarf?");
2959 emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2963 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2964 // string section and is identical in format to traditional .debug_str
2966 void DwarfDebug::emitDebugStrDWO() {
2967 assert(useSplitDwarf() && "No split dwarf?");
2968 const MCSection *OffSec = Asm->getObjFileLowering()
2969 .getDwarfStrOffDWOSection();
2970 const MCSymbol *StrSym = DwarfStrSectionSym;
2971 InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),