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"
17 #include "DwarfAccelTable.h"
18 #include "DwarfCompileUnit.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/CodeGen/MachineFunction.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/Constants.h"
26 #include "llvm/DIBuilder.h"
27 #include "llvm/DataLayout.h"
28 #include "llvm/DebugInfo.h"
29 #include "llvm/Instructions.h"
30 #include "llvm/MC/MCAsmInfo.h"
31 #include "llvm/MC/MCSection.h"
32 #include "llvm/MC/MCStreamer.h"
33 #include "llvm/MC/MCSymbol.h"
34 #include "llvm/Module.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/FormattedStream.h"
39 #include "llvm/Support/Path.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/Support/ValueHandle.h"
42 #include "llvm/Target/TargetFrameLowering.h"
43 #include "llvm/Target/TargetLoweringObjectFile.h"
44 #include "llvm/Target/TargetMachine.h"
45 #include "llvm/Target/TargetOptions.h"
46 #include "llvm/Target/TargetRegisterInfo.h"
49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
51 cl::desc("Disable debug info printing"));
53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
54 cl::desc("Make an absence of debug location information explicit."),
59 Default, Enable, Disable
63 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
64 cl::desc("Output prototype dwarf accelerator tables."),
66 clEnumVal(Default, "Default for platform"),
67 clEnumVal(Enable, "Enabled"),
68 clEnumVal(Disable, "Disabled"),
72 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
73 cl::desc("Compatibility with Darwin gdb."),
75 clEnumVal(Default, "Default for platform"),
76 clEnumVal(Enable, "Enabled"),
77 clEnumVal(Disable, "Disabled"),
81 static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
82 cl::desc("Output prototype dwarf split debug info."),
84 clEnumVal(Default, "Default for platform"),
85 clEnumVal(Enable, "Enabled"),
86 clEnumVal(Disable, "Disabled"),
91 const char *DWARFGroupName = "DWARF Emission";
92 const char *DbgTimerName = "DWARF Debug Writer";
93 } // end anonymous namespace
95 //===----------------------------------------------------------------------===//
97 // Configuration values for initial hash set sizes (log2).
99 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
103 DIType DbgVariable::getType() const {
104 DIType Ty = Var.getType();
105 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
106 // addresses instead.
107 if (Var.isBlockByrefVariable()) {
108 /* Byref variables, in Blocks, are declared by the programmer as
109 "SomeType VarName;", but the compiler creates a
110 __Block_byref_x_VarName struct, and gives the variable VarName
111 either the struct, or a pointer to the struct, as its type. This
112 is necessary for various behind-the-scenes things the compiler
113 needs to do with by-reference variables in blocks.
115 However, as far as the original *programmer* is concerned, the
116 variable should still have type 'SomeType', as originally declared.
118 The following function dives into the __Block_byref_x_VarName
119 struct to find the original type of the variable. This will be
120 passed back to the code generating the type for the Debug
121 Information Entry for the variable 'VarName'. 'VarName' will then
122 have the original type 'SomeType' in its debug information.
124 The original type 'SomeType' will be the type of the field named
125 'VarName' inside the __Block_byref_x_VarName struct.
127 NOTE: In order for this to not completely fail on the debugger
128 side, the Debug Information Entry for the variable VarName needs to
129 have a DW_AT_location that tells the debugger how to unwind through
130 the pointers and __Block_byref_x_VarName struct to find the actual
131 value of the variable. The function addBlockByrefType does this. */
133 unsigned tag = Ty.getTag();
135 if (tag == dwarf::DW_TAG_pointer_type) {
136 DIDerivedType DTy = DIDerivedType(Ty);
137 subType = DTy.getTypeDerivedFrom();
140 DICompositeType blockStruct = DICompositeType(subType);
141 DIArray Elements = blockStruct.getTypeArray();
143 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
144 DIDescriptor Element = Elements.getElement(i);
145 DIDerivedType DT = DIDerivedType(Element);
146 if (getName() == DT.getName())
147 return (DT.getTypeDerivedFrom());
153 } // end llvm namespace
155 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
156 : Asm(A), MMI(Asm->MMI), FirstCU(0),
157 AbbreviationsSet(InitAbbreviationsSetSize),
158 SourceIdMap(DIEValueAllocator), StringPool(DIEValueAllocator),
159 PrevLabel(NULL), GlobalCUIndexCount(0),
160 InfoHolder(A, &AbbreviationsSet, &Abbreviations),
161 SkeletonCU(0), SkeletonHolder(A, &AbbreviationsSet, &Abbreviations) {
162 NextStringPoolNumber = 0;
164 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
165 DwarfStrSectionSym = TextSectionSym = 0;
166 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
167 FunctionBeginSym = FunctionEndSym = 0;
169 // Turn on accelerator tables and older gdb compatibility
171 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
172 if (DarwinGDBCompat == Default) {
174 IsDarwinGDBCompat = true;
176 IsDarwinGDBCompat = false;
178 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
180 if (DwarfAccelTables == Default) {
182 HasDwarfAccelTables = true;
184 HasDwarfAccelTables = false;
186 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
188 if (SplitDwarf == Default)
189 HasSplitDwarf = false;
191 HasSplitDwarf = SplitDwarf == Enable ? true : false;
194 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
198 DwarfDebug::~DwarfDebug() {
201 // Switch to the specified MCSection and emit an assembler
202 // temporary label to it if SymbolStem is specified.
203 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
204 const char *SymbolStem = 0) {
205 Asm->OutStreamer.SwitchSection(Section);
206 if (!SymbolStem) return 0;
208 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
209 Asm->OutStreamer.EmitLabel(TmpSym);
213 MCSymbol *DwarfDebug::getStringPool() {
214 return Asm->GetTempSymbol("section_str");
217 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
218 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
219 if (Entry.first) return Entry.first;
221 Entry.second = NextStringPoolNumber++;
222 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
225 // Define a unique number for the abbreviation.
227 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
228 // Profile the node so that we can make it unique.
232 // Check the set for priors.
233 DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
235 // If it's newly added.
236 if (InSet == &Abbrev) {
237 // Add to abbreviation list.
238 Abbreviations->push_back(&Abbrev);
240 // Assign the vector position + 1 as its number.
241 Abbrev.setNumber(Abbreviations->size());
243 // Assign existing abbreviation number.
244 Abbrev.setNumber(InSet->getNumber());
248 // If special LLVM prefix that is used to inform the asm
249 // printer to not emit usual symbol prefix before the symbol name is used then
250 // return linkage name after skipping this special LLVM prefix.
251 static StringRef getRealLinkageName(StringRef LinkageName) {
253 if (LinkageName.startswith(StringRef(&One, 1)))
254 return LinkageName.substr(1);
258 static bool isObjCClass(StringRef Name) {
259 return Name.startswith("+") || Name.startswith("-");
262 static bool hasObjCCategory(StringRef Name) {
263 if (!isObjCClass(Name)) return false;
265 size_t pos = Name.find(')');
266 if (pos != std::string::npos) {
267 if (Name[pos+1] != ' ') return false;
273 static void getObjCClassCategory(StringRef In, StringRef &Class,
274 StringRef &Category) {
275 if (!hasObjCCategory(In)) {
276 Class = In.slice(In.find('[') + 1, In.find(' '));
281 Class = In.slice(In.find('[') + 1, In.find('('));
282 Category = In.slice(In.find('[') + 1, In.find(' '));
286 static StringRef getObjCMethodName(StringRef In) {
287 return In.slice(In.find(' ') + 1, In.find(']'));
290 // Add the various names to the Dwarf accelerator table names.
291 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
293 if (!SP.isDefinition()) return;
295 TheCU->addAccelName(SP.getName(), Die);
297 // If the linkage name is different than the name, go ahead and output
298 // that as well into the name table.
299 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
300 TheCU->addAccelName(SP.getLinkageName(), Die);
302 // If this is an Objective-C selector name add it to the ObjC accelerator
304 if (isObjCClass(SP.getName())) {
305 StringRef Class, Category;
306 getObjCClassCategory(SP.getName(), Class, Category);
307 TheCU->addAccelObjC(Class, Die);
309 TheCU->addAccelObjC(Category, Die);
310 // Also add the base method name to the name table.
311 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
315 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
316 // and DW_AT_high_pc attributes. If there are global variables in this
317 // scope then create and insert DIEs for these variables.
318 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
319 const MDNode *SPNode) {
320 DIE *SPDie = SPCU->getDIE(SPNode);
322 assert(SPDie && "Unable to find subprogram DIE!");
323 DISubprogram SP(SPNode);
325 // If we're updating an abstract DIE, then we will be adding the children and
326 // object pointer later on. But what we don't want to do is process the
327 // concrete DIE twice.
328 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
329 // Pick up abstract subprogram DIE.
330 SPDie = new DIE(dwarf::DW_TAG_subprogram);
331 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
332 dwarf::DW_FORM_ref4, AbsSPDIE);
335 DISubprogram SPDecl = SP.getFunctionDeclaration();
336 if (!SPDecl.isSubprogram()) {
337 // There is not any need to generate specification DIE for a function
338 // defined at compile unit level. If a function is defined inside another
339 // function then gdb prefers the definition at top level and but does not
340 // expect specification DIE in parent function. So avoid creating
341 // specification DIE for a function defined inside a function.
342 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
343 !SP.getContext().isFile() &&
344 !isSubprogramContext(SP.getContext())) {
345 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
348 DICompositeType SPTy = SP.getType();
349 DIArray Args = SPTy.getTypeArray();
350 unsigned SPTag = SPTy.getTag();
351 if (SPTag == dwarf::DW_TAG_subroutine_type)
352 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
353 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
354 DIType ATy = DIType(Args.getElement(i));
355 SPCU->addType(Arg, ATy);
356 if (ATy.isArtificial())
357 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
358 if (ATy.isObjectPointer())
359 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
360 dwarf::DW_FORM_ref4, Arg);
361 SPDie->addChild(Arg);
363 DIE *SPDeclDie = SPDie;
364 SPDie = new DIE(dwarf::DW_TAG_subprogram);
365 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
366 dwarf::DW_FORM_ref4, SPDeclDie);
372 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
373 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
374 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
375 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
376 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
377 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
378 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
380 // Add name to the name table, we do this here because we're guaranteed
381 // to have concrete versions of our DW_TAG_subprogram nodes.
382 addSubprogramNames(SPCU, SP, SPDie);
387 // Construct new DW_TAG_lexical_block for this scope and attach
388 // DW_AT_low_pc/DW_AT_high_pc labels.
389 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
390 LexicalScope *Scope) {
391 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
392 if (Scope->isAbstractScope())
395 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
399 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
400 if (Ranges.size() > 1) {
401 // .debug_range section has not been laid out yet. Emit offset in
402 // .debug_range as a uint, size 4, for now. emitDIE will handle
403 // DW_AT_ranges appropriately.
404 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
405 DebugRangeSymbols.size()
406 * Asm->getDataLayout().getPointerSize());
407 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
408 RE = Ranges.end(); RI != RE; ++RI) {
409 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
410 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
412 DebugRangeSymbols.push_back(NULL);
413 DebugRangeSymbols.push_back(NULL);
417 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
418 const MCSymbol *End = getLabelAfterInsn(RI->second);
420 if (End == 0) return 0;
422 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
423 assert(End->isDefined() && "Invalid end label for an inlined scope!");
425 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
426 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
431 // This scope represents inlined body of a function. Construct DIE to
432 // represent this concrete inlined copy of the function.
433 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
434 LexicalScope *Scope) {
435 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
436 assert(Ranges.empty() == false &&
437 "LexicalScope does not have instruction markers!");
439 if (!Scope->getScopeNode())
441 DIScope DS(Scope->getScopeNode());
442 DISubprogram InlinedSP = getDISubprogram(DS);
443 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
445 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
449 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
450 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
451 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
453 if (StartLabel == 0 || EndLabel == 0) {
454 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
456 assert(StartLabel->isDefined() &&
457 "Invalid starting label for an inlined scope!");
458 assert(EndLabel->isDefined() &&
459 "Invalid end label for an inlined scope!");
461 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
462 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
463 dwarf::DW_FORM_ref4, OriginDIE);
465 if (Ranges.size() > 1) {
466 // .debug_range section has not been laid out yet. Emit offset in
467 // .debug_range as a uint, size 4, for now. emitDIE will handle
468 // DW_AT_ranges appropriately.
469 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
470 DebugRangeSymbols.size()
471 * Asm->getDataLayout().getPointerSize());
472 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
473 RE = Ranges.end(); RI != RE; ++RI) {
474 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
475 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
477 DebugRangeSymbols.push_back(NULL);
478 DebugRangeSymbols.push_back(NULL);
480 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
482 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
486 InlinedSubprogramDIEs.insert(OriginDIE);
488 // Track the start label for this inlined function.
489 //.debug_inlined section specification does not clearly state how
490 // to emit inlined scope that is split into multiple instruction ranges.
491 // For now, use first instruction range and emit low_pc/high_pc pair and
492 // corresponding .debug_inlined section entry for this pair.
493 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
494 I = InlineInfo.find(InlinedSP);
496 if (I == InlineInfo.end()) {
497 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
498 InlinedSPNodes.push_back(InlinedSP);
500 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
502 DILocation DL(Scope->getInlinedAt());
503 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
504 getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
505 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
507 // Add name to the name table, we do this here because we're guaranteed
508 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
509 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
514 // Construct a DIE for this scope.
515 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
516 if (!Scope || !Scope->getScopeNode())
519 SmallVector<DIE *, 8> Children;
520 DIE *ObjectPointer = NULL;
522 // Collect arguments for current function.
523 if (LScopes.isCurrentFunctionScope(Scope))
524 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
525 if (DbgVariable *ArgDV = CurrentFnArguments[i])
527 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
528 Children.push_back(Arg);
529 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
532 // Collect lexical scope children first.
533 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
534 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
536 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
537 Children.push_back(Variable);
538 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
540 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
541 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
542 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
543 Children.push_back(Nested);
544 DIScope DS(Scope->getScopeNode());
545 DIE *ScopeDIE = NULL;
546 if (Scope->getInlinedAt())
547 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
548 else if (DS.isSubprogram()) {
549 ProcessedSPNodes.insert(DS);
550 if (Scope->isAbstractScope()) {
551 ScopeDIE = TheCU->getDIE(DS);
552 // Note down abstract DIE.
554 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
557 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
560 // There is no need to emit empty lexical block DIE.
561 if (Children.empty())
563 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
566 if (!ScopeDIE) return NULL;
569 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
570 E = Children.end(); I != E; ++I)
571 ScopeDIE->addChild(*I);
573 if (DS.isSubprogram() && ObjectPointer != NULL)
574 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
575 dwarf::DW_FORM_ref4, ObjectPointer);
577 if (DS.isSubprogram())
578 TheCU->addPubTypes(DISubprogram(DS));
583 // Look up the source id with the given directory and source file names.
584 // If none currently exists, create a new id and insert it in the
585 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
587 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
589 // If FE did not provide a file name, then assume stdin.
590 if (FileName.empty())
591 return getOrCreateSourceID("<stdin>", StringRef());
593 // TODO: this might not belong here. See if we can factor this better.
594 if (DirName == CompilationDir)
597 unsigned SrcId = SourceIdMap.size()+1;
599 // We look up the file/dir pair by concatenating them with a zero byte.
600 SmallString<128> NamePair;
602 NamePair += '\0'; // Zero bytes are not allowed in paths.
603 NamePair += FileName;
605 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
606 if (Ent.getValue() != SrcId)
607 return Ent.getValue();
609 // Print out a .file directive to specify files for .loc directives.
610 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
615 // Create new CompileUnit for the given metadata node with tag DW_TAG_compile_unit.
616 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
617 DICompileUnit DIUnit(N);
618 StringRef FN = DIUnit.getFilename();
619 CompilationDir = DIUnit.getDirectory();
620 // Call this to emit a .file directive if it wasn't emitted for the source
621 // file this CU comes from yet.
622 getOrCreateSourceID(FN, CompilationDir);
624 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
625 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
626 DIUnit.getLanguage(), Die, Asm, this);
627 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
628 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
629 DIUnit.getLanguage());
630 NewCU->addString(Die, dwarf::DW_AT_name, FN);
631 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
633 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
634 // DW_AT_stmt_list is a offset of line number information for this
635 // compile unit in debug_line section.
636 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
637 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
638 Asm->GetTempSymbol("section_line"));
640 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
642 if (!CompilationDir.empty())
643 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
644 if (DIUnit.isOptimized())
645 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
647 StringRef Flags = DIUnit.getFlags();
649 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
651 if (unsigned RVer = DIUnit.getRunTimeVersion())
652 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
653 dwarf::DW_FORM_data1, RVer);
657 if (useSplitDwarf() && !SkeletonCU)
658 SkeletonCU = constructSkeletonCU(N);
660 InfoHolder.addUnit(NewCU);
662 CUMap.insert(std::make_pair(N, NewCU));
666 // Construct subprogram DIE.
667 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
669 CompileUnit *&CURef = SPMap[N];
675 if (!SP.isDefinition())
676 // This is a method declaration which will be handled while constructing
680 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
683 TheCU->insertDIE(N, SubprogramDie);
685 // Add to context owner.
686 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
691 // Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
692 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
693 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
694 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
695 const MDNode *N = NMD->getOperand(i);
696 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
697 constructSubprogramDIE(CU, N);
700 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
701 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
702 const MDNode *N = NMD->getOperand(i);
703 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
704 CU->createGlobalVariableDIE(N);
707 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
708 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
709 DIType Ty(NMD->getOperand(i));
710 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
711 CU->getOrCreateTypeDIE(Ty);
714 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
715 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
716 DIType Ty(NMD->getOperand(i));
717 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
718 CU->getOrCreateTypeDIE(Ty);
722 // Collect debug info using DebugInfoFinder.
723 // FIXME - Remove this when dragonegg switches to DIBuilder.
724 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
725 DebugInfoFinder DbgFinder;
726 DbgFinder.processModule(*M);
728 bool HasDebugInfo = false;
729 // Scan all the compile-units to see if there are any marked as the main
730 // unit. If not, we do not generate debug info.
731 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
732 E = DbgFinder.compile_unit_end(); I != E; ++I) {
733 if (DICompileUnit(*I).isMain()) {
738 if (!HasDebugInfo) return false;
740 // Create all the compile unit DIEs.
741 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
742 E = DbgFinder.compile_unit_end(); I != E; ++I)
743 constructCompileUnit(*I);
745 // Create DIEs for each global variable.
746 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
747 E = DbgFinder.global_variable_end(); I != E; ++I) {
748 const MDNode *N = *I;
749 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
750 CU->createGlobalVariableDIE(N);
753 // Create DIEs for each subprogram.
754 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
755 E = DbgFinder.subprogram_end(); I != E; ++I) {
756 const MDNode *N = *I;
757 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
758 constructSubprogramDIE(CU, N);
764 // Emit all Dwarf sections that should come prior to the content. Create
765 // global DIEs and emit initial debug info sections. This is invoked by
766 // the target AsmPrinter.
767 void DwarfDebug::beginModule() {
768 if (DisableDebugInfoPrinting)
771 const Module *M = MMI->getModule();
773 // If module has named metadata anchors then use them, otherwise scan the
774 // module using debug info finder to collect debug info.
775 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
777 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
778 DICompileUnit CUNode(CU_Nodes->getOperand(i));
779 CompileUnit *CU = constructCompileUnit(CUNode);
780 DIArray GVs = CUNode.getGlobalVariables();
781 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
782 CU->createGlobalVariableDIE(GVs.getElement(i));
783 DIArray SPs = CUNode.getSubprograms();
784 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
785 constructSubprogramDIE(CU, SPs.getElement(i));
786 DIArray EnumTypes = CUNode.getEnumTypes();
787 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
788 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
789 DIArray RetainedTypes = CUNode.getRetainedTypes();
790 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
791 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
793 } else if (!collectLegacyDebugInfo(M))
796 collectInfoFromNamedMDNodes(M);
798 // Tell MMI that we have debug info.
799 MMI->setDebugInfoAvailability(true);
801 // Prime section data.
802 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
805 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
806 void DwarfDebug::computeInlinedDIEs() {
807 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
808 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
809 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
811 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
813 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
814 AE = AbstractSPDies.end(); AI != AE; ++AI) {
815 DIE *ISP = AI->second;
816 if (InlinedSubprogramDIEs.count(ISP))
818 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
822 // Collect info for variables that were optimized out.
823 void DwarfDebug::collectDeadVariables() {
824 const Module *M = MMI->getModule();
825 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
827 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
828 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
829 DICompileUnit TheCU(CU_Nodes->getOperand(i));
830 DIArray Subprograms = TheCU.getSubprograms();
831 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
832 DISubprogram SP(Subprograms.getElement(i));
833 if (ProcessedSPNodes.count(SP) != 0) continue;
834 if (!SP.Verify()) continue;
835 if (!SP.isDefinition()) continue;
836 DIArray Variables = SP.getVariables();
837 if (Variables.getNumElements() == 0) continue;
839 LexicalScope *Scope =
840 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
841 DeadFnScopeMap[SP] = Scope;
843 // Construct subprogram DIE and add variables DIEs.
844 CompileUnit *SPCU = CUMap.lookup(TheCU);
845 assert(SPCU && "Unable to find Compile Unit!");
846 constructSubprogramDIE(SPCU, SP);
847 DIE *ScopeDIE = SPCU->getDIE(SP);
848 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
849 DIVariable DV(Variables.getElement(vi));
850 if (!DV.Verify()) continue;
851 DbgVariable *NewVar = new DbgVariable(DV, NULL);
852 if (DIE *VariableDIE =
853 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
854 ScopeDIE->addChild(VariableDIE);
859 DeleteContainerSeconds(DeadFnScopeMap);
862 void DwarfDebug::finalizeModuleInfo() {
863 // Collect info for variables that were optimized out.
864 collectDeadVariables();
866 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
867 computeInlinedDIEs();
869 // Emit DW_AT_containing_type attribute to connect types with their
870 // vtable holding type.
871 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
872 CUE = CUMap.end(); CUI != CUE; ++CUI) {
873 CompileUnit *TheCU = CUI->second;
874 TheCU->constructContainingTypeDIEs();
877 // Compute DIE offsets and sizes.
878 InfoHolder.computeSizeAndOffsets();
880 SkeletonHolder.computeSizeAndOffsets();
883 void DwarfDebug::endSections() {
884 // Standard sections final addresses.
885 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
886 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
887 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
888 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
890 // End text sections.
891 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
892 Asm->OutStreamer.SwitchSection(SectionMap[I]);
893 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
897 // Emit all Dwarf sections that should come after the content.
898 void DwarfDebug::endModule() {
900 if (!FirstCU) return;
902 // End any existing sections.
903 // TODO: Does this need to happen?
906 // Finalize the debug info for the module.
907 finalizeModuleInfo();
909 // Emit initial sections.
912 if (!useSplitDwarf()) {
913 // Emit all the DIEs into a debug info section.
916 // Corresponding abbreviations into a abbrev section.
919 // Emit info into a debug loc section.
922 // Emit info into a debug aranges section.
925 // Emit info into a debug ranges section.
928 // Emit info into a debug macinfo section.
932 // TODO: When we don't need the option anymore we
933 // can remove all of the code that this section
935 if (useDarwinGDBCompat())
936 emitDebugInlineInfo();
938 // TODO: Fill this in for separated debug sections and separate
939 // out information into new sections.
941 // Emit the debug info section and compile units.
945 // Corresponding abbreviations into a abbrev section.
948 // Emit info into a debug loc section.
951 // Emit info into a debug aranges section.
954 // Emit info into a debug ranges section.
957 // Emit info into a debug macinfo section.
961 // TODO: When we don't need the option anymore we
962 // can remove all of the code that this section
964 if (useDarwinGDBCompat())
965 emitDebugInlineInfo();
968 // Emit info into the dwarf accelerator table sections.
969 if (useDwarfAccelTables()) {
972 emitAccelNamespaces();
976 // Emit info into a debug pubtypes section.
977 // TODO: When we don't need the option anymore we can
978 // remove all of the code that adds to the table.
979 if (useDarwinGDBCompat())
982 // Finally emit string information into a string table.
987 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
988 E = CUMap.end(); I != E; ++I)
993 // Reset these for the next Module if we have one.
998 // Find abstract variable, if any, associated with Var.
999 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1000 DebugLoc ScopeLoc) {
1001 LLVMContext &Ctx = DV->getContext();
1002 // More then one inlined variable corresponds to one abstract variable.
1003 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1004 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1006 return AbsDbgVariable;
1008 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1012 AbsDbgVariable = new DbgVariable(Var, NULL);
1013 addScopeVariable(Scope, AbsDbgVariable);
1014 AbstractVariables[Var] = AbsDbgVariable;
1015 return AbsDbgVariable;
1018 // If Var is a current function argument then add it to CurrentFnArguments list.
1019 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1020 DbgVariable *Var, LexicalScope *Scope) {
1021 if (!LScopes.isCurrentFunctionScope(Scope))
1023 DIVariable DV = Var->getVariable();
1024 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1026 unsigned ArgNo = DV.getArgNumber();
1030 size_t Size = CurrentFnArguments.size();
1032 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1033 // llvm::Function argument size is not good indicator of how many
1034 // arguments does the function have at source level.
1036 CurrentFnArguments.resize(ArgNo * 2);
1037 CurrentFnArguments[ArgNo - 1] = Var;
1041 // Collect variable information from side table maintained by MMI.
1043 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1044 SmallPtrSet<const MDNode *, 16> &Processed) {
1045 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1046 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1047 VE = VMap.end(); VI != VE; ++VI) {
1048 const MDNode *Var = VI->first;
1050 Processed.insert(Var);
1052 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1054 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1056 // If variable scope is not found then skip this variable.
1060 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1061 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1062 RegVar->setFrameIndex(VP.first);
1063 if (!addCurrentFnArgument(MF, RegVar, Scope))
1064 addScopeVariable(Scope, RegVar);
1066 AbsDbgVariable->setFrameIndex(VP.first);
1070 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1072 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1073 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1074 return MI->getNumOperands() == 3 &&
1075 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1076 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1079 // Get .debug_loc entry for the instruction range starting at MI.
1080 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1081 const MCSymbol *FLabel,
1082 const MCSymbol *SLabel,
1083 const MachineInstr *MI) {
1084 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1086 if (MI->getNumOperands() != 3) {
1087 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1088 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1090 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1091 MachineLocation MLoc;
1092 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1093 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1095 if (MI->getOperand(0).isImm())
1096 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1097 if (MI->getOperand(0).isFPImm())
1098 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1099 if (MI->getOperand(0).isCImm())
1100 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1102 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1105 // Find variables for each lexical scope.
1107 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1108 SmallPtrSet<const MDNode *, 16> &Processed) {
1110 // collection info from MMI table.
1111 collectVariableInfoFromMMITable(MF, Processed);
1113 for (SmallVectorImpl<const MDNode*>::const_iterator
1114 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1116 const MDNode *Var = *UVI;
1117 if (Processed.count(Var))
1120 // History contains relevant DBG_VALUE instructions for Var and instructions
1122 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1123 if (History.empty())
1125 const MachineInstr *MInsn = History.front();
1128 LexicalScope *Scope = NULL;
1129 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1130 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1131 Scope = LScopes.getCurrentFunctionScope();
1133 if (DV.getVersion() <= LLVMDebugVersion9)
1134 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1136 if (MDNode *IA = DV.getInlinedAt())
1137 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1139 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1142 // If variable scope is not found then skip this variable.
1146 Processed.insert(DV);
1147 assert(MInsn->isDebugValue() && "History must begin with debug value");
1148 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1149 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1150 if (!addCurrentFnArgument(MF, RegVar, Scope))
1151 addScopeVariable(Scope, RegVar);
1153 AbsVar->setMInsn(MInsn);
1155 // Simplify ranges that are fully coalesced.
1156 if (History.size() <= 1 || (History.size() == 2 &&
1157 MInsn->isIdenticalTo(History.back()))) {
1158 RegVar->setMInsn(MInsn);
1162 // handle multiple DBG_VALUE instructions describing one variable.
1163 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1165 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1166 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1167 const MachineInstr *Begin = *HI;
1168 assert(Begin->isDebugValue() && "Invalid History entry");
1170 // Check if DBG_VALUE is truncating a range.
1171 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1172 && !Begin->getOperand(0).getReg())
1175 // Compute the range for a register location.
1176 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1177 const MCSymbol *SLabel = 0;
1180 // If Begin is the last instruction in History then its value is valid
1181 // until the end of the function.
1182 SLabel = FunctionEndSym;
1184 const MachineInstr *End = HI[1];
1185 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1186 << "\t" << *Begin << "\t" << *End << "\n");
1187 if (End->isDebugValue())
1188 SLabel = getLabelBeforeInsn(End);
1190 // End is a normal instruction clobbering the range.
1191 SLabel = getLabelAfterInsn(End);
1192 assert(SLabel && "Forgot label after clobber instruction");
1197 // The value is valid until the next DBG_VALUE or clobber.
1198 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1201 DotDebugLocEntries.push_back(DotDebugLocEntry());
1204 // Collect info for variables that were optimized out.
1205 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1206 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1207 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1208 DIVariable DV(Variables.getElement(i));
1209 if (!DV || !DV.Verify() || !Processed.insert(DV))
1211 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1212 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1216 // Return Label preceding the instruction.
1217 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1218 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1219 assert(Label && "Didn't insert label before instruction");
1223 // Return Label immediately following the instruction.
1224 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1225 return LabelsAfterInsn.lookup(MI);
1228 // Process beginning of an instruction.
1229 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1230 // Check if source location changes, but ignore DBG_VALUE locations.
1231 if (!MI->isDebugValue()) {
1232 DebugLoc DL = MI->getDebugLoc();
1233 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1236 if (DL == PrologEndLoc) {
1237 Flags |= DWARF2_FLAG_PROLOGUE_END;
1238 PrologEndLoc = DebugLoc();
1240 if (PrologEndLoc.isUnknown())
1241 Flags |= DWARF2_FLAG_IS_STMT;
1243 if (!DL.isUnknown()) {
1244 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1245 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1247 recordSourceLine(0, 0, 0, 0);
1251 // Insert labels where requested.
1252 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1253 LabelsBeforeInsn.find(MI);
1256 if (I == LabelsBeforeInsn.end())
1259 // Label already assigned.
1264 PrevLabel = MMI->getContext().CreateTempSymbol();
1265 Asm->OutStreamer.EmitLabel(PrevLabel);
1267 I->second = PrevLabel;
1270 // Process end of an instruction.
1271 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1272 // Don't create a new label after DBG_VALUE instructions.
1273 // They don't generate code.
1274 if (!MI->isDebugValue())
1277 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1278 LabelsAfterInsn.find(MI);
1281 if (I == LabelsAfterInsn.end())
1284 // Label already assigned.
1288 // We need a label after this instruction.
1290 PrevLabel = MMI->getContext().CreateTempSymbol();
1291 Asm->OutStreamer.EmitLabel(PrevLabel);
1293 I->second = PrevLabel;
1296 // Each LexicalScope has first instruction and last instruction to mark
1297 // beginning and end of a scope respectively. Create an inverse map that list
1298 // scopes starts (and ends) with an instruction. One instruction may start (or
1299 // end) multiple scopes. Ignore scopes that are not reachable.
1300 void DwarfDebug::identifyScopeMarkers() {
1301 SmallVector<LexicalScope *, 4> WorkList;
1302 WorkList.push_back(LScopes.getCurrentFunctionScope());
1303 while (!WorkList.empty()) {
1304 LexicalScope *S = WorkList.pop_back_val();
1306 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1307 if (!Children.empty())
1308 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1309 SE = Children.end(); SI != SE; ++SI)
1310 WorkList.push_back(*SI);
1312 if (S->isAbstractScope())
1315 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1318 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1319 RE = Ranges.end(); RI != RE; ++RI) {
1320 assert(RI->first && "InsnRange does not have first instruction!");
1321 assert(RI->second && "InsnRange does not have second instruction!");
1322 requestLabelBeforeInsn(RI->first);
1323 requestLabelAfterInsn(RI->second);
1328 // Get MDNode for DebugLoc's scope.
1329 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1330 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1331 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1332 return DL.getScope(Ctx);
1335 // Walk up the scope chain of given debug loc and find line number info
1336 // for the function.
1337 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1338 const MDNode *Scope = getScopeNode(DL, Ctx);
1339 DISubprogram SP = getDISubprogram(Scope);
1341 // Check for number of operands since the compatibility is
1343 if (SP->getNumOperands() > 19)
1344 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1346 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1352 // Gather pre-function debug information. Assumes being called immediately
1353 // after the function entry point has been emitted.
1354 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1355 if (!MMI->hasDebugInfo()) return;
1356 LScopes.initialize(*MF);
1357 if (LScopes.empty()) return;
1358 identifyScopeMarkers();
1360 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1361 Asm->getFunctionNumber());
1362 // Assumes in correct section after the entry point.
1363 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1365 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1367 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1368 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1369 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1371 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1373 bool AtBlockEntry = true;
1374 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1376 const MachineInstr *MI = II;
1378 if (MI->isDebugValue()) {
1379 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1381 // Keep track of user variables.
1383 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1385 // Variable is in a register, we need to check for clobbers.
1386 if (isDbgValueInDefinedReg(MI))
1387 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1389 // Check the history of this variable.
1390 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1391 if (History.empty()) {
1392 UserVariables.push_back(Var);
1393 // The first mention of a function argument gets the FunctionBeginSym
1394 // label, so arguments are visible when breaking at function entry.
1396 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1397 DISubprogram(getDISubprogram(DV.getContext()))
1398 .describes(MF->getFunction()))
1399 LabelsBeforeInsn[MI] = FunctionBeginSym;
1401 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1402 const MachineInstr *Prev = History.back();
1403 if (Prev->isDebugValue()) {
1404 // Coalesce identical entries at the end of History.
1405 if (History.size() >= 2 &&
1406 Prev->isIdenticalTo(History[History.size() - 2])) {
1407 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1409 << "\t" << *History[History.size() - 2] << "\n");
1413 // Terminate old register assignments that don't reach MI;
1414 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1415 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1416 isDbgValueInDefinedReg(Prev)) {
1417 // Previous register assignment needs to terminate at the end of
1419 MachineBasicBlock::const_iterator LastMI =
1420 PrevMBB->getLastNonDebugInstr();
1421 if (LastMI == PrevMBB->end()) {
1422 // Drop DBG_VALUE for empty range.
1423 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1424 << "\t" << *Prev << "\n");
1428 // Terminate after LastMI.
1429 History.push_back(LastMI);
1434 History.push_back(MI);
1436 // Not a DBG_VALUE instruction.
1438 AtBlockEntry = false;
1440 // First known non-DBG_VALUE and non-frame setup location marks
1441 // the beginning of the function body.
1442 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1443 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1444 PrologEndLoc = MI->getDebugLoc();
1446 // Check if the instruction clobbers any registers with debug vars.
1447 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1448 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1449 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1451 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1452 AI.isValid(); ++AI) {
1454 const MDNode *Var = LiveUserVar[Reg];
1457 // Reg is now clobbered.
1458 LiveUserVar[Reg] = 0;
1460 // Was MD last defined by a DBG_VALUE referring to Reg?
1461 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1462 if (HistI == DbgValues.end())
1464 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1465 if (History.empty())
1467 const MachineInstr *Prev = History.back();
1468 // Sanity-check: Register assignments are terminated at the end of
1470 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1472 // Is the variable still in Reg?
1473 if (!isDbgValueInDefinedReg(Prev) ||
1474 Prev->getOperand(0).getReg() != Reg)
1476 // Var is clobbered. Make sure the next instruction gets a label.
1477 History.push_back(MI);
1484 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1486 SmallVectorImpl<const MachineInstr*> &History = I->second;
1487 if (History.empty())
1490 // Make sure the final register assignments are terminated.
1491 const MachineInstr *Prev = History.back();
1492 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1493 const MachineBasicBlock *PrevMBB = Prev->getParent();
1494 MachineBasicBlock::const_iterator LastMI =
1495 PrevMBB->getLastNonDebugInstr();
1496 if (LastMI == PrevMBB->end())
1497 // Drop DBG_VALUE for empty range.
1500 // Terminate after LastMI.
1501 History.push_back(LastMI);
1504 // Request labels for the full history.
1505 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1506 const MachineInstr *MI = History[i];
1507 if (MI->isDebugValue())
1508 requestLabelBeforeInsn(MI);
1510 requestLabelAfterInsn(MI);
1514 PrevInstLoc = DebugLoc();
1515 PrevLabel = FunctionBeginSym;
1517 // Record beginning of function.
1518 if (!PrologEndLoc.isUnknown()) {
1519 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1520 MF->getFunction()->getContext());
1521 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1522 FnStartDL.getScope(MF->getFunction()->getContext()),
1523 // We'd like to list the prologue as "not statements" but GDB behaves
1524 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1525 DWARF2_FLAG_IS_STMT);
1529 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1530 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1531 ScopeVariables[LS].push_back(Var);
1532 // Vars.push_back(Var);
1535 // Gather and emit post-function debug information.
1536 void DwarfDebug::endFunction(const MachineFunction *MF) {
1537 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1539 // Define end label for subprogram.
1540 FunctionEndSym = Asm->GetTempSymbol("func_end",
1541 Asm->getFunctionNumber());
1542 // Assumes in correct section after the entry point.
1543 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1545 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1546 collectVariableInfo(MF, ProcessedVars);
1548 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1549 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1550 assert(TheCU && "Unable to find compile unit!");
1552 // Construct abstract scopes.
1553 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1554 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1555 LexicalScope *AScope = AList[i];
1556 DISubprogram SP(AScope->getScopeNode());
1558 // Collect info for variables that were optimized out.
1559 DIArray Variables = SP.getVariables();
1560 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1561 DIVariable DV(Variables.getElement(i));
1562 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1564 // Check that DbgVariable for DV wasn't created earlier, when
1565 // findAbstractVariable() was called for inlined instance of DV.
1566 LLVMContext &Ctx = DV->getContext();
1567 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1568 if (AbstractVariables.lookup(CleanDV))
1570 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1571 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1574 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1575 constructScopeDIE(TheCU, AScope);
1578 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1580 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1581 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1583 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1584 MMI->getFrameMoves()));
1587 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1588 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1589 DeleteContainerPointers(I->second);
1590 ScopeVariables.clear();
1591 DeleteContainerPointers(CurrentFnArguments);
1592 UserVariables.clear();
1594 AbstractVariables.clear();
1595 LabelsBeforeInsn.clear();
1596 LabelsAfterInsn.clear();
1600 // Register a source line with debug info. Returns the unique label that was
1601 // emitted and which provides correspondence to the source line list.
1602 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1608 DIDescriptor Scope(S);
1610 if (Scope.isCompileUnit()) {
1611 DICompileUnit CU(S);
1612 Fn = CU.getFilename();
1613 Dir = CU.getDirectory();
1614 } else if (Scope.isFile()) {
1616 Fn = F.getFilename();
1617 Dir = F.getDirectory();
1618 } else if (Scope.isSubprogram()) {
1620 Fn = SP.getFilename();
1621 Dir = SP.getDirectory();
1622 } else if (Scope.isLexicalBlockFile()) {
1623 DILexicalBlockFile DBF(S);
1624 Fn = DBF.getFilename();
1625 Dir = DBF.getDirectory();
1626 } else if (Scope.isLexicalBlock()) {
1627 DILexicalBlock DB(S);
1628 Fn = DB.getFilename();
1629 Dir = DB.getDirectory();
1631 llvm_unreachable("Unexpected scope info");
1633 Src = getOrCreateSourceID(Fn, Dir);
1635 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1638 //===----------------------------------------------------------------------===//
1640 //===----------------------------------------------------------------------===//
1642 // Compute the size and offset of a DIE.
1644 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1645 // Get the children.
1646 const std::vector<DIE *> &Children = Die->getChildren();
1648 // Record the abbreviation.
1649 assignAbbrevNumber(Die->getAbbrev());
1651 // Get the abbreviation for this DIE.
1652 unsigned AbbrevNumber = Die->getAbbrevNumber();
1653 const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1656 Die->setOffset(Offset);
1658 // Start the size with the size of abbreviation code.
1659 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1661 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1662 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1664 // Size the DIE attribute values.
1665 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1666 // Size attribute value.
1667 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1669 // Size the DIE children if any.
1670 if (!Children.empty()) {
1671 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1672 "Children flag not set");
1674 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1675 Offset = computeSizeAndOffset(Children[j], Offset);
1677 // End of children marker.
1678 Offset += sizeof(int8_t);
1681 Die->setSize(Offset - Die->getOffset());
1685 // Compute the size and offset of all the DIEs.
1686 void DwarfUnits::computeSizeAndOffsets() {
1687 for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1688 E = CUs.end(); I != E; ++I) {
1690 sizeof(int32_t) + // Length of Compilation Unit Info
1691 sizeof(int16_t) + // DWARF version number
1692 sizeof(int32_t) + // Offset Into Abbrev. Section
1693 sizeof(int8_t); // Pointer Size (in bytes)
1695 computeSizeAndOffset((*I)->getCUDie(), Offset);
1699 // Emit initial Dwarf sections with a label at the start of each one.
1700 void DwarfDebug::emitSectionLabels() {
1701 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1703 // Dwarf sections base addresses.
1704 DwarfInfoSectionSym =
1705 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1706 DwarfAbbrevSectionSym =
1707 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1708 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1710 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1711 emitSectionSym(Asm, MacroInfo);
1713 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1714 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1715 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1716 DwarfStrSectionSym =
1717 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1718 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1721 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1722 "section_debug_loc");
1724 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1725 emitSectionSym(Asm, TLOF.getDataSection());
1728 // Recursively emits a debug information entry.
1729 void DwarfDebug::emitDIE(DIE *Die) {
1730 // Get the abbreviation for this DIE.
1731 unsigned AbbrevNumber = Die->getAbbrevNumber();
1732 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1734 // Emit the code (index) for the abbreviation.
1735 if (Asm->isVerbose())
1736 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1737 Twine::utohexstr(Die->getOffset()) + ":0x" +
1738 Twine::utohexstr(Die->getSize()) + " " +
1739 dwarf::TagString(Abbrev->getTag()));
1740 Asm->EmitULEB128(AbbrevNumber);
1742 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1743 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1745 // Emit the DIE attribute values.
1746 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1747 unsigned Attr = AbbrevData[i].getAttribute();
1748 unsigned Form = AbbrevData[i].getForm();
1749 assert(Form && "Too many attributes for DIE (check abbreviation)");
1751 if (Asm->isVerbose())
1752 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1755 case dwarf::DW_AT_abstract_origin: {
1756 DIEEntry *E = cast<DIEEntry>(Values[i]);
1757 DIE *Origin = E->getEntry();
1758 unsigned Addr = Origin->getOffset();
1759 Asm->EmitInt32(Addr);
1762 case dwarf::DW_AT_ranges: {
1763 // DW_AT_range Value encodes offset in debug_range section.
1764 DIEInteger *V = cast<DIEInteger>(Values[i]);
1766 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1767 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1771 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1773 DwarfDebugRangeSectionSym,
1778 case dwarf::DW_AT_location: {
1779 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1780 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1781 Asm->EmitLabelReference(L->getValue(), 4);
1783 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1785 Values[i]->EmitValue(Asm, Form);
1789 case dwarf::DW_AT_accessibility: {
1790 if (Asm->isVerbose()) {
1791 DIEInteger *V = cast<DIEInteger>(Values[i]);
1792 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1794 Values[i]->EmitValue(Asm, Form);
1798 // Emit an attribute using the defined form.
1799 Values[i]->EmitValue(Asm, Form);
1804 // Emit the DIE children if any.
1805 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1806 const std::vector<DIE *> &Children = Die->getChildren();
1808 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1809 emitDIE(Children[j]);
1811 if (Asm->isVerbose())
1812 Asm->OutStreamer.AddComment("End Of Children Mark");
1817 void DwarfDebug::emitCompileUnits(const MCSection *Section) {
1818 Asm->OutStreamer.SwitchSection(Section);
1819 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1820 E = CUMap.end(); I != E; ++I) {
1821 CompileUnit *TheCU = I->second;
1822 DIE *Die = TheCU->getCUDie();
1824 // Emit the compile units header.
1825 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1826 TheCU->getUniqueID()));
1828 // Emit size of content not including length itself
1829 unsigned ContentSize = Die->getSize() +
1830 sizeof(int16_t) + // DWARF version number
1831 sizeof(int32_t) + // Offset Into Abbrev. Section
1832 sizeof(int8_t); // Pointer Size (in bytes)
1834 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1835 Asm->EmitInt32(ContentSize);
1836 Asm->OutStreamer.AddComment("DWARF version number");
1837 Asm->EmitInt16(dwarf::DWARF_VERSION);
1838 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1839 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1840 DwarfAbbrevSectionSym);
1841 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1842 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1845 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end",
1846 TheCU->getUniqueID()));
1850 // Emit the debug info section.
1851 void DwarfDebug::emitDebugInfo() {
1852 if (!useSplitDwarf())
1853 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoSection());
1855 emitSkeletonCU(Asm->getObjFileLowering().getDwarfInfoSection());
1858 // Emit the abbreviation section.
1859 void DwarfDebug::emitAbbreviations() {
1860 // Check to see if it is worth the effort.
1861 if (!Abbreviations.empty()) {
1862 // Start the debug abbrev section.
1863 Asm->OutStreamer.SwitchSection(
1864 Asm->getObjFileLowering().getDwarfAbbrevSection());
1866 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1868 // For each abbrevation.
1869 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1870 // Get abbreviation data
1871 const DIEAbbrev *Abbrev = Abbreviations[i];
1873 // Emit the abbrevations code (base 1 index.)
1874 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1876 // Emit the abbreviations data.
1880 // Mark end of abbreviations.
1881 Asm->EmitULEB128(0, "EOM(3)");
1883 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1887 // Emit the last address of the section and the end of the line matrix.
1888 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1889 // Define last address of section.
1890 Asm->OutStreamer.AddComment("Extended Op");
1893 Asm->OutStreamer.AddComment("Op size");
1894 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1895 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1896 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1898 Asm->OutStreamer.AddComment("Section end label");
1900 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1901 Asm->getDataLayout().getPointerSize(),
1904 // Mark end of matrix.
1905 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1911 // Emit visible names into a hashed accelerator table section.
1912 void DwarfDebug::emitAccelNames() {
1913 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1914 dwarf::DW_FORM_data4));
1915 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1916 E = CUMap.end(); I != E; ++I) {
1917 CompileUnit *TheCU = I->second;
1918 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1919 for (StringMap<std::vector<DIE*> >::const_iterator
1920 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1921 const char *Name = GI->getKeyData();
1922 const std::vector<DIE *> &Entities = GI->second;
1923 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1924 DE = Entities.end(); DI != DE; ++DI)
1925 AT.AddName(Name, (*DI));
1929 AT.FinalizeTable(Asm, "Names");
1930 Asm->OutStreamer.SwitchSection(
1931 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1932 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1933 Asm->OutStreamer.EmitLabel(SectionBegin);
1935 // Emit the full data.
1936 AT.Emit(Asm, SectionBegin, this);
1939 // Emit objective C classes and categories into a hashed accelerator table section.
1940 void DwarfDebug::emitAccelObjC() {
1941 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1942 dwarf::DW_FORM_data4));
1943 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1944 E = CUMap.end(); I != E; ++I) {
1945 CompileUnit *TheCU = I->second;
1946 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1947 for (StringMap<std::vector<DIE*> >::const_iterator
1948 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1949 const char *Name = GI->getKeyData();
1950 const std::vector<DIE *> &Entities = GI->second;
1951 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1952 DE = Entities.end(); DI != DE; ++DI)
1953 AT.AddName(Name, (*DI));
1957 AT.FinalizeTable(Asm, "ObjC");
1958 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1959 .getDwarfAccelObjCSection());
1960 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1961 Asm->OutStreamer.EmitLabel(SectionBegin);
1963 // Emit the full data.
1964 AT.Emit(Asm, SectionBegin, this);
1967 // Emit namespace dies into a hashed accelerator table.
1968 void DwarfDebug::emitAccelNamespaces() {
1969 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1970 dwarf::DW_FORM_data4));
1971 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1972 E = CUMap.end(); I != E; ++I) {
1973 CompileUnit *TheCU = I->second;
1974 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1975 for (StringMap<std::vector<DIE*> >::const_iterator
1976 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1977 const char *Name = GI->getKeyData();
1978 const std::vector<DIE *> &Entities = GI->second;
1979 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1980 DE = Entities.end(); DI != DE; ++DI)
1981 AT.AddName(Name, (*DI));
1985 AT.FinalizeTable(Asm, "namespac");
1986 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1987 .getDwarfAccelNamespaceSection());
1988 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1989 Asm->OutStreamer.EmitLabel(SectionBegin);
1991 // Emit the full data.
1992 AT.Emit(Asm, SectionBegin, this);
1995 // Emit type dies into a hashed accelerator table.
1996 void DwarfDebug::emitAccelTypes() {
1997 std::vector<DwarfAccelTable::Atom> Atoms;
1998 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1999 dwarf::DW_FORM_data4));
2000 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2001 dwarf::DW_FORM_data2));
2002 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2003 dwarf::DW_FORM_data1));
2004 DwarfAccelTable AT(Atoms);
2005 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2006 E = CUMap.end(); I != E; ++I) {
2007 CompileUnit *TheCU = I->second;
2008 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2009 = TheCU->getAccelTypes();
2010 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2011 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2012 const char *Name = GI->getKeyData();
2013 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2014 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2015 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2016 AT.AddName(Name, (*DI).first, (*DI).second);
2020 AT.FinalizeTable(Asm, "types");
2021 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2022 .getDwarfAccelTypesSection());
2023 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2024 Asm->OutStreamer.EmitLabel(SectionBegin);
2026 // Emit the full data.
2027 AT.Emit(Asm, SectionBegin, this);
2030 void DwarfDebug::emitDebugPubTypes() {
2031 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2032 E = CUMap.end(); I != E; ++I) {
2033 CompileUnit *TheCU = I->second;
2034 // Start the dwarf pubtypes section.
2035 Asm->OutStreamer.SwitchSection(
2036 Asm->getObjFileLowering().getDwarfPubTypesSection());
2037 Asm->OutStreamer.AddComment("Length of Public Types Info");
2038 Asm->EmitLabelDifference(
2039 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2040 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2042 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2043 TheCU->getUniqueID()));
2045 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2046 Asm->EmitInt16(dwarf::DWARF_VERSION);
2048 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2049 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin",
2050 TheCU->getUniqueID()),
2051 DwarfInfoSectionSym);
2053 Asm->OutStreamer.AddComment("Compilation Unit Length");
2054 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end",
2055 TheCU->getUniqueID()),
2056 Asm->GetTempSymbol("info_begin",
2057 TheCU->getUniqueID()),
2060 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2061 for (StringMap<DIE*>::const_iterator
2062 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2063 const char *Name = GI->getKeyData();
2064 DIE *Entity = GI->second;
2066 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2067 Asm->EmitInt32(Entity->getOffset());
2069 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2070 // Emit the name with a terminating null byte.
2071 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2074 Asm->OutStreamer.AddComment("End Mark");
2076 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2077 TheCU->getUniqueID()));
2081 // Emit visible names into a debug str section.
2082 void DwarfDebug::emitDebugStr() {
2083 // Check to see if it is worth the effort.
2084 if (StringPool.empty()) return;
2086 // Start the dwarf str section.
2087 Asm->OutStreamer.SwitchSection(
2088 Asm->getObjFileLowering().getDwarfStrSection());
2090 // Get all of the string pool entries and put them in an array by their ID so
2091 // we can sort them.
2092 SmallVector<std::pair<unsigned,
2093 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2095 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2096 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2097 Entries.push_back(std::make_pair(I->second.second, &*I));
2099 array_pod_sort(Entries.begin(), Entries.end());
2101 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2102 // Emit a label for reference from debug information entries.
2103 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2105 // Emit the string itself with a terminating null byte.
2106 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2107 Entries[i].second->getKeyLength()+1),
2112 // Emit visible names into a debug loc section.
2113 void DwarfDebug::emitDebugLoc() {
2114 if (DotDebugLocEntries.empty())
2117 for (SmallVector<DotDebugLocEntry, 4>::iterator
2118 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2120 DotDebugLocEntry &Entry = *I;
2121 if (I + 1 != DotDebugLocEntries.end())
2125 // Start the dwarf loc section.
2126 Asm->OutStreamer.SwitchSection(
2127 Asm->getObjFileLowering().getDwarfLocSection());
2128 unsigned char Size = Asm->getDataLayout().getPointerSize();
2129 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2131 for (SmallVector<DotDebugLocEntry, 4>::iterator
2132 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2133 I != E; ++I, ++index) {
2134 DotDebugLocEntry &Entry = *I;
2135 if (Entry.isMerged()) continue;
2136 if (Entry.isEmpty()) {
2137 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2138 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2139 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2141 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2142 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2143 DIVariable DV(Entry.Variable);
2144 Asm->OutStreamer.AddComment("Loc expr size");
2145 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2146 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2147 Asm->EmitLabelDifference(end, begin, 2);
2148 Asm->OutStreamer.EmitLabel(begin);
2149 if (Entry.isInt()) {
2150 DIBasicType BTy(DV.getType());
2152 (BTy.getEncoding() == dwarf::DW_ATE_signed
2153 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2154 Asm->OutStreamer.AddComment("DW_OP_consts");
2155 Asm->EmitInt8(dwarf::DW_OP_consts);
2156 Asm->EmitSLEB128(Entry.getInt());
2158 Asm->OutStreamer.AddComment("DW_OP_constu");
2159 Asm->EmitInt8(dwarf::DW_OP_constu);
2160 Asm->EmitULEB128(Entry.getInt());
2162 } else if (Entry.isLocation()) {
2163 if (!DV.hasComplexAddress())
2165 Asm->EmitDwarfRegOp(Entry.Loc);
2167 // Complex address entry.
2168 unsigned N = DV.getNumAddrElements();
2170 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2171 if (Entry.Loc.getOffset()) {
2173 Asm->EmitDwarfRegOp(Entry.Loc);
2174 Asm->OutStreamer.AddComment("DW_OP_deref");
2175 Asm->EmitInt8(dwarf::DW_OP_deref);
2176 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2177 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2178 Asm->EmitSLEB128(DV.getAddrElement(1));
2180 // If first address element is OpPlus then emit
2181 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2182 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2183 Asm->EmitDwarfRegOp(Loc);
2187 Asm->EmitDwarfRegOp(Entry.Loc);
2190 // Emit remaining complex address elements.
2191 for (; i < N; ++i) {
2192 uint64_t Element = DV.getAddrElement(i);
2193 if (Element == DIBuilder::OpPlus) {
2194 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2195 Asm->EmitULEB128(DV.getAddrElement(++i));
2196 } else if (Element == DIBuilder::OpDeref) {
2197 if (!Entry.Loc.isReg())
2198 Asm->EmitInt8(dwarf::DW_OP_deref);
2200 llvm_unreachable("unknown Opcode found in complex address");
2204 // else ... ignore constant fp. There is not any good way to
2205 // to represent them here in dwarf.
2206 Asm->OutStreamer.EmitLabel(end);
2211 // Emit visible names into a debug aranges section.
2212 void DwarfDebug::emitDebugARanges() {
2213 // Start the dwarf aranges section.
2214 Asm->OutStreamer.SwitchSection(
2215 Asm->getObjFileLowering().getDwarfARangesSection());
2218 // Emit visible names into a debug ranges section.
2219 void DwarfDebug::emitDebugRanges() {
2220 // Start the dwarf ranges section.
2221 Asm->OutStreamer.SwitchSection(
2222 Asm->getObjFileLowering().getDwarfRangesSection());
2223 unsigned char Size = Asm->getDataLayout().getPointerSize();
2224 for (SmallVector<const MCSymbol *, 8>::iterator
2225 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2228 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2230 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2234 // Emit visible names into a debug macinfo section.
2235 void DwarfDebug::emitDebugMacInfo() {
2236 if (const MCSection *LineInfo =
2237 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2238 // Start the dwarf macinfo section.
2239 Asm->OutStreamer.SwitchSection(LineInfo);
2243 // Emit inline info using following format.
2245 // 1. length of section
2246 // 2. Dwarf version number
2249 // Entries (one "entry" for each function that was inlined):
2251 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2252 // otherwise offset into __debug_str for regular function name.
2253 // 2. offset into __debug_str section for regular function name.
2254 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2255 // instances for the function.
2257 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2258 // inlined instance; the die_offset points to the inlined_subroutine die in the
2259 // __debug_info section, and the low_pc is the starting address for the
2260 // inlining instance.
2261 void DwarfDebug::emitDebugInlineInfo() {
2262 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2268 Asm->OutStreamer.SwitchSection(
2269 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2271 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2272 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2273 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2275 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2277 Asm->OutStreamer.AddComment("Dwarf Version");
2278 Asm->EmitInt16(dwarf::DWARF_VERSION);
2279 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2280 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2282 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2283 E = InlinedSPNodes.end(); I != E; ++I) {
2285 const MDNode *Node = *I;
2286 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2287 = InlineInfo.find(Node);
2288 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2289 DISubprogram SP(Node);
2290 StringRef LName = SP.getLinkageName();
2291 StringRef Name = SP.getName();
2293 Asm->OutStreamer.AddComment("MIPS linkage name");
2295 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2297 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2298 DwarfStrSectionSym);
2300 Asm->OutStreamer.AddComment("Function name");
2301 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2302 Asm->EmitULEB128(Labels.size(), "Inline count");
2304 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2305 LE = Labels.end(); LI != LE; ++LI) {
2306 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2307 Asm->EmitInt32(LI->second->getOffset());
2309 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2310 Asm->OutStreamer.EmitSymbolValue(LI->first,
2311 Asm->getDataLayout().getPointerSize(),0);
2315 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2318 // DWARF5 Experimental Separate Dwarf emitters.
2320 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2321 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2322 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2323 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2324 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2325 DICompileUnit DIUnit(N);
2326 StringRef FN = DIUnit.getFilename();
2327 CompilationDir = DIUnit.getDirectory();
2329 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2330 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2331 DIUnit.getLanguage(), Die, Asm, this);
2332 // FIXME: This should be the .dwo file.
2333 NewCU->addString(Die, dwarf::DW_AT_GNU_dwo_name, FN);
2335 // FIXME: We also need DW_AT_addr_base and DW_AT_dwo_id.
2337 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2339 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2340 // DW_AT_stmt_list is a offset of line number information for this
2341 // compile unit in debug_line section.
2342 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2343 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
2344 Asm->GetTempSymbol("section_line"));
2346 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
2348 if (!CompilationDir.empty())
2349 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2351 SkeletonHolder.addUnit(NewCU);
2356 void DwarfDebug::emitSkeletonCU(const MCSection *Section) {
2357 Asm->OutStreamer.SwitchSection(Section);
2358 DIE *Die = SkeletonCU->getCUDie();
2360 // Emit the compile units header.
2361 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_begin",
2362 SkeletonCU->getUniqueID()));
2364 // Emit size of content not including length itself
2365 unsigned ContentSize = Die->getSize() +
2366 sizeof(int16_t) + // DWARF version number
2367 sizeof(int32_t) + // Offset Into Abbrev. Section
2368 sizeof(int8_t); // Pointer Size (in bytes)
2370 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2371 Asm->EmitInt32(ContentSize);
2372 Asm->OutStreamer.AddComment("DWARF version number");
2373 Asm->EmitInt16(dwarf::DWARF_VERSION);
2374 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2375 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2376 DwarfAbbrevSectionSym);
2377 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2378 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2381 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_end",
2382 SkeletonCU->getUniqueID()));
2387 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2388 // compile units that would normally be in debug_info.
2389 void DwarfDebug::emitDebugInfoDWO() {
2390 assert(useSplitDwarf() && "No split dwarf debug info?");
2391 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoDWOSection());