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), SkeletonCU(0) {
160 NextStringPoolNumber = 0;
162 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
163 DwarfStrSectionSym = TextSectionSym = 0;
164 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
165 FunctionBeginSym = FunctionEndSym = 0;
167 // Turn on accelerator tables and older gdb compatibility
169 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
170 if (DarwinGDBCompat == Default) {
172 IsDarwinGDBCompat = true;
174 IsDarwinGDBCompat = false;
176 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
178 if (DwarfAccelTables == Default) {
180 HasDwarfAccelTables = true;
182 HasDwarfAccelTables = false;
184 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
186 if (SplitDwarf == Default)
187 HasSplitDwarf = false;
189 HasSplitDwarf = SplitDwarf == Enable ? true : false;
192 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
196 DwarfDebug::~DwarfDebug() {
199 // Switch to the specified MCSection and emit an assembler
200 // temporary label to it if SymbolStem is specified.
201 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
202 const char *SymbolStem = 0) {
203 Asm->OutStreamer.SwitchSection(Section);
204 if (!SymbolStem) return 0;
206 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
207 Asm->OutStreamer.EmitLabel(TmpSym);
211 MCSymbol *DwarfDebug::getStringPool() {
212 return Asm->GetTempSymbol("section_str");
215 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
216 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
217 if (Entry.first) return Entry.first;
219 Entry.second = NextStringPoolNumber++;
220 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
223 // Define a unique number for the abbreviation.
225 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
226 // Profile the node so that we can make it unique.
230 // Check the set for priors.
231 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
233 // If it's newly added.
234 if (InSet == &Abbrev) {
235 // Add to abbreviation list.
236 Abbreviations.push_back(&Abbrev);
238 // Assign the vector position + 1 as its number.
239 Abbrev.setNumber(Abbreviations.size());
241 // Assign existing abbreviation number.
242 Abbrev.setNumber(InSet->getNumber());
246 // If special LLVM prefix that is used to inform the asm
247 // printer to not emit usual symbol prefix before the symbol name is used then
248 // return linkage name after skipping this special LLVM prefix.
249 static StringRef getRealLinkageName(StringRef LinkageName) {
251 if (LinkageName.startswith(StringRef(&One, 1)))
252 return LinkageName.substr(1);
256 static bool isObjCClass(StringRef Name) {
257 return Name.startswith("+") || Name.startswith("-");
260 static bool hasObjCCategory(StringRef Name) {
261 if (!isObjCClass(Name)) return false;
263 size_t pos = Name.find(')');
264 if (pos != std::string::npos) {
265 if (Name[pos+1] != ' ') return false;
271 static void getObjCClassCategory(StringRef In, StringRef &Class,
272 StringRef &Category) {
273 if (!hasObjCCategory(In)) {
274 Class = In.slice(In.find('[') + 1, In.find(' '));
279 Class = In.slice(In.find('[') + 1, In.find('('));
280 Category = In.slice(In.find('[') + 1, In.find(' '));
284 static StringRef getObjCMethodName(StringRef In) {
285 return In.slice(In.find(' ') + 1, In.find(']'));
288 // Add the various names to the Dwarf accelerator table names.
289 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
291 if (!SP.isDefinition()) return;
293 TheCU->addAccelName(SP.getName(), Die);
295 // If the linkage name is different than the name, go ahead and output
296 // that as well into the name table.
297 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
298 TheCU->addAccelName(SP.getLinkageName(), Die);
300 // If this is an Objective-C selector name add it to the ObjC accelerator
302 if (isObjCClass(SP.getName())) {
303 StringRef Class, Category;
304 getObjCClassCategory(SP.getName(), Class, Category);
305 TheCU->addAccelObjC(Class, Die);
307 TheCU->addAccelObjC(Category, Die);
308 // Also add the base method name to the name table.
309 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
313 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
314 // and DW_AT_high_pc attributes. If there are global variables in this
315 // scope then create and insert DIEs for these variables.
316 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
317 const MDNode *SPNode) {
318 DIE *SPDie = SPCU->getDIE(SPNode);
320 assert(SPDie && "Unable to find subprogram DIE!");
321 DISubprogram SP(SPNode);
323 // If we're updating an abstract DIE, then we will be adding the children and
324 // object pointer later on. But what we don't want to do is process the
325 // concrete DIE twice.
326 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
327 // Pick up abstract subprogram DIE.
328 SPDie = new DIE(dwarf::DW_TAG_subprogram);
329 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
330 dwarf::DW_FORM_ref4, AbsSPDIE);
333 DISubprogram SPDecl = SP.getFunctionDeclaration();
334 if (!SPDecl.isSubprogram()) {
335 // There is not any need to generate specification DIE for a function
336 // defined at compile unit level. If a function is defined inside another
337 // function then gdb prefers the definition at top level and but does not
338 // expect specification DIE in parent function. So avoid creating
339 // specification DIE for a function defined inside a function.
340 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
341 !SP.getContext().isFile() &&
342 !isSubprogramContext(SP.getContext())) {
343 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
346 DICompositeType SPTy = SP.getType();
347 DIArray Args = SPTy.getTypeArray();
348 unsigned SPTag = SPTy.getTag();
349 if (SPTag == dwarf::DW_TAG_subroutine_type)
350 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
351 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
352 DIType ATy = DIType(Args.getElement(i));
353 SPCU->addType(Arg, ATy);
354 if (ATy.isArtificial())
355 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
356 if (ATy.isObjectPointer())
357 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
358 dwarf::DW_FORM_ref4, Arg);
359 SPDie->addChild(Arg);
361 DIE *SPDeclDie = SPDie;
362 SPDie = new DIE(dwarf::DW_TAG_subprogram);
363 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
364 dwarf::DW_FORM_ref4, SPDeclDie);
370 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
371 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
372 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
373 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
374 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
375 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
376 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
378 // Add name to the name table, we do this here because we're guaranteed
379 // to have concrete versions of our DW_TAG_subprogram nodes.
380 addSubprogramNames(SPCU, SP, SPDie);
385 // Construct new DW_TAG_lexical_block for this scope and attach
386 // DW_AT_low_pc/DW_AT_high_pc labels.
387 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
388 LexicalScope *Scope) {
389 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
390 if (Scope->isAbstractScope())
393 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
397 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
398 if (Ranges.size() > 1) {
399 // .debug_range section has not been laid out yet. Emit offset in
400 // .debug_range as a uint, size 4, for now. emitDIE will handle
401 // DW_AT_ranges appropriately.
402 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
403 DebugRangeSymbols.size()
404 * Asm->getDataLayout().getPointerSize());
405 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
406 RE = Ranges.end(); RI != RE; ++RI) {
407 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
408 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
410 DebugRangeSymbols.push_back(NULL);
411 DebugRangeSymbols.push_back(NULL);
415 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
416 const MCSymbol *End = getLabelAfterInsn(RI->second);
418 if (End == 0) return 0;
420 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
421 assert(End->isDefined() && "Invalid end label for an inlined scope!");
423 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
424 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
429 // This scope represents inlined body of a function. Construct DIE to
430 // represent this concrete inlined copy of the function.
431 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
432 LexicalScope *Scope) {
433 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
434 assert(Ranges.empty() == false &&
435 "LexicalScope does not have instruction markers!");
437 if (!Scope->getScopeNode())
439 DIScope DS(Scope->getScopeNode());
440 DISubprogram InlinedSP = getDISubprogram(DS);
441 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
443 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
447 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
448 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
449 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
451 if (StartLabel == 0 || EndLabel == 0) {
452 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
454 assert(StartLabel->isDefined() &&
455 "Invalid starting label for an inlined scope!");
456 assert(EndLabel->isDefined() &&
457 "Invalid end label for an inlined scope!");
459 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
460 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
461 dwarf::DW_FORM_ref4, OriginDIE);
463 if (Ranges.size() > 1) {
464 // .debug_range section has not been laid out yet. Emit offset in
465 // .debug_range as a uint, size 4, for now. emitDIE will handle
466 // DW_AT_ranges appropriately.
467 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
468 DebugRangeSymbols.size()
469 * Asm->getDataLayout().getPointerSize());
470 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
471 RE = Ranges.end(); RI != RE; ++RI) {
472 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
473 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
475 DebugRangeSymbols.push_back(NULL);
476 DebugRangeSymbols.push_back(NULL);
478 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
480 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
484 InlinedSubprogramDIEs.insert(OriginDIE);
486 // Track the start label for this inlined function.
487 //.debug_inlined section specification does not clearly state how
488 // to emit inlined scope that is split into multiple instruction ranges.
489 // For now, use first instruction range and emit low_pc/high_pc pair and
490 // corresponding .debug_inlined section entry for this pair.
491 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
492 I = InlineInfo.find(InlinedSP);
494 if (I == InlineInfo.end()) {
495 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
496 InlinedSPNodes.push_back(InlinedSP);
498 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
500 DILocation DL(Scope->getInlinedAt());
501 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
502 getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
503 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
505 // Add name to the name table, we do this here because we're guaranteed
506 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
507 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
512 // Construct a DIE for this scope.
513 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
514 if (!Scope || !Scope->getScopeNode())
517 SmallVector<DIE *, 8> Children;
518 DIE *ObjectPointer = NULL;
520 // Collect arguments for current function.
521 if (LScopes.isCurrentFunctionScope(Scope))
522 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
523 if (DbgVariable *ArgDV = CurrentFnArguments[i])
525 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
526 Children.push_back(Arg);
527 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
530 // Collect lexical scope children first.
531 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
532 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
534 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
535 Children.push_back(Variable);
536 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
538 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
539 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
540 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
541 Children.push_back(Nested);
542 DIScope DS(Scope->getScopeNode());
543 DIE *ScopeDIE = NULL;
544 if (Scope->getInlinedAt())
545 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
546 else if (DS.isSubprogram()) {
547 ProcessedSPNodes.insert(DS);
548 if (Scope->isAbstractScope()) {
549 ScopeDIE = TheCU->getDIE(DS);
550 // Note down abstract DIE.
552 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
555 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
558 // There is no need to emit empty lexical block DIE.
559 if (Children.empty())
561 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
564 if (!ScopeDIE) return NULL;
567 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
568 E = Children.end(); I != E; ++I)
569 ScopeDIE->addChild(*I);
571 if (DS.isSubprogram() && ObjectPointer != NULL)
572 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
573 dwarf::DW_FORM_ref4, ObjectPointer);
575 if (DS.isSubprogram())
576 TheCU->addPubTypes(DISubprogram(DS));
581 // Look up the source id with the given directory and source file names.
582 // If none currently exists, create a new id and insert it in the
583 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
585 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
587 // If FE did not provide a file name, then assume stdin.
588 if (FileName.empty())
589 return getOrCreateSourceID("<stdin>", StringRef());
591 // TODO: this might not belong here. See if we can factor this better.
592 if (DirName == CompilationDir)
595 unsigned SrcId = SourceIdMap.size()+1;
597 // We look up the file/dir pair by concatenating them with a zero byte.
598 SmallString<128> NamePair;
600 NamePair += '\0'; // Zero bytes are not allowed in paths.
601 NamePair += FileName;
603 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
604 if (Ent.getValue() != SrcId)
605 return Ent.getValue();
607 // Print out a .file directive to specify files for .loc directives.
608 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
613 // Create new CompileUnit for the given metadata node with tag DW_TAG_compile_unit.
614 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
615 DICompileUnit DIUnit(N);
616 StringRef FN = DIUnit.getFilename();
617 CompilationDir = DIUnit.getDirectory();
618 // Call this to emit a .file directive if it wasn't emitted for the source
619 // file this CU comes from yet.
620 getOrCreateSourceID(FN, CompilationDir);
622 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
623 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
624 DIUnit.getLanguage(), Die, Asm, this);
625 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
626 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
627 DIUnit.getLanguage());
628 NewCU->addString(Die, dwarf::DW_AT_name, FN);
629 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
631 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
632 // DW_AT_stmt_list is a offset of line number information for this
633 // compile unit in debug_line section.
634 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
635 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
636 Asm->GetTempSymbol("section_line"));
638 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
640 if (!CompilationDir.empty())
641 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
642 if (DIUnit.isOptimized())
643 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
645 StringRef Flags = DIUnit.getFlags();
647 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
649 if (unsigned RVer = DIUnit.getRunTimeVersion())
650 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
651 dwarf::DW_FORM_data1, RVer);
655 if (useSplitDwarf() && !SkeletonCU)
656 SkeletonCU = constructSkeletonCU(N);
658 CUMap.insert(std::make_pair(N, NewCU));
662 // Construct subprogram DIE.
663 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
665 CompileUnit *&CURef = SPMap[N];
671 if (!SP.isDefinition())
672 // This is a method declaration which will be handled while constructing
676 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
679 TheCU->insertDIE(N, SubprogramDie);
681 // Add to context owner.
682 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
687 // Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
688 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
689 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
690 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
691 const MDNode *N = NMD->getOperand(i);
692 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
693 constructSubprogramDIE(CU, N);
696 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
697 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
698 const MDNode *N = NMD->getOperand(i);
699 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
700 CU->createGlobalVariableDIE(N);
703 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
704 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
705 DIType Ty(NMD->getOperand(i));
706 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
707 CU->getOrCreateTypeDIE(Ty);
710 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
711 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
712 DIType Ty(NMD->getOperand(i));
713 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
714 CU->getOrCreateTypeDIE(Ty);
718 // Collect debug info using DebugInfoFinder.
719 // FIXME - Remove this when dragonegg switches to DIBuilder.
720 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
721 DebugInfoFinder DbgFinder;
722 DbgFinder.processModule(*M);
724 bool HasDebugInfo = false;
725 // Scan all the compile-units to see if there are any marked as the main
726 // unit. If not, we do not generate debug info.
727 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
728 E = DbgFinder.compile_unit_end(); I != E; ++I) {
729 if (DICompileUnit(*I).isMain()) {
734 if (!HasDebugInfo) return false;
736 // Create all the compile unit DIEs.
737 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
738 E = DbgFinder.compile_unit_end(); I != E; ++I)
739 constructCompileUnit(*I);
741 // Create DIEs for each global variable.
742 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
743 E = DbgFinder.global_variable_end(); I != E; ++I) {
744 const MDNode *N = *I;
745 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
746 CU->createGlobalVariableDIE(N);
749 // Create DIEs for each subprogram.
750 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
751 E = DbgFinder.subprogram_end(); I != E; ++I) {
752 const MDNode *N = *I;
753 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
754 constructSubprogramDIE(CU, N);
760 // Emit all Dwarf sections that should come prior to the content. Create
761 // global DIEs and emit initial debug info sections. This is invoked by
762 // the target AsmPrinter.
763 void DwarfDebug::beginModule() {
764 if (DisableDebugInfoPrinting)
767 const Module *M = MMI->getModule();
769 // If module has named metadata anchors then use them, otherwise scan the
770 // module using debug info finder to collect debug info.
771 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
773 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
774 DICompileUnit CUNode(CU_Nodes->getOperand(i));
775 CompileUnit *CU = constructCompileUnit(CUNode);
776 DIArray GVs = CUNode.getGlobalVariables();
777 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
778 CU->createGlobalVariableDIE(GVs.getElement(i));
779 DIArray SPs = CUNode.getSubprograms();
780 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
781 constructSubprogramDIE(CU, SPs.getElement(i));
782 DIArray EnumTypes = CUNode.getEnumTypes();
783 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
784 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
785 DIArray RetainedTypes = CUNode.getRetainedTypes();
786 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
787 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
789 } else if (!collectLegacyDebugInfo(M))
792 collectInfoFromNamedMDNodes(M);
794 // Tell MMI that we have debug info.
795 MMI->setDebugInfoAvailability(true);
797 // Prime section data.
798 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
801 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
802 void DwarfDebug::computeInlinedDIEs() {
803 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
804 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
805 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
807 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
809 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
810 AE = AbstractSPDies.end(); AI != AE; ++AI) {
811 DIE *ISP = AI->second;
812 if (InlinedSubprogramDIEs.count(ISP))
814 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
818 // Collect info for variables that were optimized out.
819 void DwarfDebug::collectDeadVariables() {
820 const Module *M = MMI->getModule();
821 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
823 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
824 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
825 DICompileUnit TheCU(CU_Nodes->getOperand(i));
826 DIArray Subprograms = TheCU.getSubprograms();
827 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
828 DISubprogram SP(Subprograms.getElement(i));
829 if (ProcessedSPNodes.count(SP) != 0) continue;
830 if (!SP.Verify()) continue;
831 if (!SP.isDefinition()) continue;
832 DIArray Variables = SP.getVariables();
833 if (Variables.getNumElements() == 0) continue;
835 LexicalScope *Scope =
836 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
837 DeadFnScopeMap[SP] = Scope;
839 // Construct subprogram DIE and add variables DIEs.
840 CompileUnit *SPCU = CUMap.lookup(TheCU);
841 assert(SPCU && "Unable to find Compile Unit!");
842 constructSubprogramDIE(SPCU, SP);
843 DIE *ScopeDIE = SPCU->getDIE(SP);
844 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
845 DIVariable DV(Variables.getElement(vi));
846 if (!DV.Verify()) continue;
847 DbgVariable *NewVar = new DbgVariable(DV, NULL);
848 if (DIE *VariableDIE =
849 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
850 ScopeDIE->addChild(VariableDIE);
855 DeleteContainerSeconds(DeadFnScopeMap);
858 void DwarfDebug::finalizeModuleInfo() {
859 // Collect info for variables that were optimized out.
860 collectDeadVariables();
862 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
863 computeInlinedDIEs();
865 // Emit DW_AT_containing_type attribute to connect types with their
866 // vtable holding type.
867 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
868 CUE = CUMap.end(); CUI != CUE; ++CUI) {
869 CompileUnit *TheCU = CUI->second;
870 TheCU->constructContainingTypeDIEs();
873 // Compute DIE offsets and sizes.
874 computeSizeAndOffsets();
877 void DwarfDebug::endSections() {
878 // Standard sections final addresses.
879 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
880 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
881 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
882 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
884 // End text sections.
885 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
886 Asm->OutStreamer.SwitchSection(SectionMap[I]);
887 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
891 // Emit all Dwarf sections that should come after the content.
892 void DwarfDebug::endModule() {
894 if (!FirstCU) return;
896 // End any existing sections.
897 // TODO: Does this need to happen?
900 // Finalize the debug info for the module.
901 finalizeModuleInfo();
903 // Emit initial sections.
906 if (!useSplitDwarf()) {
907 // Emit all the DIEs into a debug info section.
910 // Corresponding abbreviations into a abbrev section.
913 // Emit info into a debug loc section.
916 // Emit info into a debug aranges section.
919 // Emit info into a debug ranges section.
922 // Emit info into a debug macinfo section.
926 // TODO: When we don't need the option anymore we
927 // can remove all of the code that this section
929 if (useDarwinGDBCompat())
930 emitDebugInlineInfo();
932 // TODO: Fill this in for Fission sections and separate
933 // out information into new sections.
935 // Emit the debug info section and compile units.
939 // Corresponding abbreviations into a abbrev section.
942 // Emit info into a debug loc section.
945 // Emit info into a debug aranges section.
948 // Emit info into a debug ranges section.
951 // Emit info into a debug macinfo section.
955 // TODO: When we don't need the option anymore we
956 // can remove all of the code that this section
958 if (useDarwinGDBCompat())
959 emitDebugInlineInfo();
962 // Emit info into the dwarf accelerator table sections.
963 if (useDwarfAccelTables()) {
966 emitAccelNamespaces();
970 // Emit info into a debug pubtypes section.
971 // TODO: When we don't need the option anymore we can
972 // remove all of the code that adds to the table.
973 if (useDarwinGDBCompat())
976 // Finally emit string information into a string table.
981 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
982 E = CUMap.end(); I != E; ++I)
987 // Reset these for the next Module if we have one.
992 // Find abstract variable, if any, associated with Var.
993 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
995 LLVMContext &Ctx = DV->getContext();
996 // More then one inlined variable corresponds to one abstract variable.
997 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
998 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1000 return AbsDbgVariable;
1002 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1006 AbsDbgVariable = new DbgVariable(Var, NULL);
1007 addScopeVariable(Scope, AbsDbgVariable);
1008 AbstractVariables[Var] = AbsDbgVariable;
1009 return AbsDbgVariable;
1012 // If Var is a current function argument then add it to CurrentFnArguments list.
1013 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1014 DbgVariable *Var, LexicalScope *Scope) {
1015 if (!LScopes.isCurrentFunctionScope(Scope))
1017 DIVariable DV = Var->getVariable();
1018 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1020 unsigned ArgNo = DV.getArgNumber();
1024 size_t Size = CurrentFnArguments.size();
1026 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1027 // llvm::Function argument size is not good indicator of how many
1028 // arguments does the function have at source level.
1030 CurrentFnArguments.resize(ArgNo * 2);
1031 CurrentFnArguments[ArgNo - 1] = Var;
1035 // Collect variable information from side table maintained by MMI.
1037 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1038 SmallPtrSet<const MDNode *, 16> &Processed) {
1039 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1040 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1041 VE = VMap.end(); VI != VE; ++VI) {
1042 const MDNode *Var = VI->first;
1044 Processed.insert(Var);
1046 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1048 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1050 // If variable scope is not found then skip this variable.
1054 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1055 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1056 RegVar->setFrameIndex(VP.first);
1057 if (!addCurrentFnArgument(MF, RegVar, Scope))
1058 addScopeVariable(Scope, RegVar);
1060 AbsDbgVariable->setFrameIndex(VP.first);
1064 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1066 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1067 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1068 return MI->getNumOperands() == 3 &&
1069 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1070 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1073 // Get .debug_loc entry for the instruction range starting at MI.
1074 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1075 const MCSymbol *FLabel,
1076 const MCSymbol *SLabel,
1077 const MachineInstr *MI) {
1078 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1080 if (MI->getNumOperands() != 3) {
1081 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1082 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1084 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1085 MachineLocation MLoc;
1086 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1087 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1089 if (MI->getOperand(0).isImm())
1090 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1091 if (MI->getOperand(0).isFPImm())
1092 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1093 if (MI->getOperand(0).isCImm())
1094 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1096 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1099 // Find variables for each lexical scope.
1101 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1102 SmallPtrSet<const MDNode *, 16> &Processed) {
1104 // collection info from MMI table.
1105 collectVariableInfoFromMMITable(MF, Processed);
1107 for (SmallVectorImpl<const MDNode*>::const_iterator
1108 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1110 const MDNode *Var = *UVI;
1111 if (Processed.count(Var))
1114 // History contains relevant DBG_VALUE instructions for Var and instructions
1116 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1117 if (History.empty())
1119 const MachineInstr *MInsn = History.front();
1122 LexicalScope *Scope = NULL;
1123 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1124 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1125 Scope = LScopes.getCurrentFunctionScope();
1127 if (DV.getVersion() <= LLVMDebugVersion9)
1128 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1130 if (MDNode *IA = DV.getInlinedAt())
1131 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1133 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1136 // If variable scope is not found then skip this variable.
1140 Processed.insert(DV);
1141 assert(MInsn->isDebugValue() && "History must begin with debug value");
1142 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1143 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1144 if (!addCurrentFnArgument(MF, RegVar, Scope))
1145 addScopeVariable(Scope, RegVar);
1147 AbsVar->setMInsn(MInsn);
1149 // Simplify ranges that are fully coalesced.
1150 if (History.size() <= 1 || (History.size() == 2 &&
1151 MInsn->isIdenticalTo(History.back()))) {
1152 RegVar->setMInsn(MInsn);
1156 // handle multiple DBG_VALUE instructions describing one variable.
1157 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1159 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1160 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1161 const MachineInstr *Begin = *HI;
1162 assert(Begin->isDebugValue() && "Invalid History entry");
1164 // Check if DBG_VALUE is truncating a range.
1165 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1166 && !Begin->getOperand(0).getReg())
1169 // Compute the range for a register location.
1170 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1171 const MCSymbol *SLabel = 0;
1174 // If Begin is the last instruction in History then its value is valid
1175 // until the end of the function.
1176 SLabel = FunctionEndSym;
1178 const MachineInstr *End = HI[1];
1179 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1180 << "\t" << *Begin << "\t" << *End << "\n");
1181 if (End->isDebugValue())
1182 SLabel = getLabelBeforeInsn(End);
1184 // End is a normal instruction clobbering the range.
1185 SLabel = getLabelAfterInsn(End);
1186 assert(SLabel && "Forgot label after clobber instruction");
1191 // The value is valid until the next DBG_VALUE or clobber.
1192 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1195 DotDebugLocEntries.push_back(DotDebugLocEntry());
1198 // Collect info for variables that were optimized out.
1199 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1200 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1201 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1202 DIVariable DV(Variables.getElement(i));
1203 if (!DV || !DV.Verify() || !Processed.insert(DV))
1205 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1206 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1210 // Return Label preceding the instruction.
1211 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1212 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1213 assert(Label && "Didn't insert label before instruction");
1217 // Return Label immediately following the instruction.
1218 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1219 return LabelsAfterInsn.lookup(MI);
1222 // Process beginning of an instruction.
1223 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1224 // Check if source location changes, but ignore DBG_VALUE locations.
1225 if (!MI->isDebugValue()) {
1226 DebugLoc DL = MI->getDebugLoc();
1227 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1230 if (DL == PrologEndLoc) {
1231 Flags |= DWARF2_FLAG_PROLOGUE_END;
1232 PrologEndLoc = DebugLoc();
1234 if (PrologEndLoc.isUnknown())
1235 Flags |= DWARF2_FLAG_IS_STMT;
1237 if (!DL.isUnknown()) {
1238 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1239 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1241 recordSourceLine(0, 0, 0, 0);
1245 // Insert labels where requested.
1246 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1247 LabelsBeforeInsn.find(MI);
1250 if (I == LabelsBeforeInsn.end())
1253 // Label already assigned.
1258 PrevLabel = MMI->getContext().CreateTempSymbol();
1259 Asm->OutStreamer.EmitLabel(PrevLabel);
1261 I->second = PrevLabel;
1264 // Process end of an instruction.
1265 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1266 // Don't create a new label after DBG_VALUE instructions.
1267 // They don't generate code.
1268 if (!MI->isDebugValue())
1271 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1272 LabelsAfterInsn.find(MI);
1275 if (I == LabelsAfterInsn.end())
1278 // Label already assigned.
1282 // We need a label after this instruction.
1284 PrevLabel = MMI->getContext().CreateTempSymbol();
1285 Asm->OutStreamer.EmitLabel(PrevLabel);
1287 I->second = PrevLabel;
1290 // Each LexicalScope has first instruction and last instruction to mark
1291 // beginning and end of a scope respectively. Create an inverse map that list
1292 // scopes starts (and ends) with an instruction. One instruction may start (or
1293 // end) multiple scopes. Ignore scopes that are not reachable.
1294 void DwarfDebug::identifyScopeMarkers() {
1295 SmallVector<LexicalScope *, 4> WorkList;
1296 WorkList.push_back(LScopes.getCurrentFunctionScope());
1297 while (!WorkList.empty()) {
1298 LexicalScope *S = WorkList.pop_back_val();
1300 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1301 if (!Children.empty())
1302 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1303 SE = Children.end(); SI != SE; ++SI)
1304 WorkList.push_back(*SI);
1306 if (S->isAbstractScope())
1309 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1312 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1313 RE = Ranges.end(); RI != RE; ++RI) {
1314 assert(RI->first && "InsnRange does not have first instruction!");
1315 assert(RI->second && "InsnRange does not have second instruction!");
1316 requestLabelBeforeInsn(RI->first);
1317 requestLabelAfterInsn(RI->second);
1322 // Get MDNode for DebugLoc's scope.
1323 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1324 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1325 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1326 return DL.getScope(Ctx);
1329 // Walk up the scope chain of given debug loc and find line number info
1330 // for the function.
1331 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1332 const MDNode *Scope = getScopeNode(DL, Ctx);
1333 DISubprogram SP = getDISubprogram(Scope);
1335 // Check for number of operands since the compatibility is
1337 if (SP->getNumOperands() > 19)
1338 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1340 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1346 // Gather pre-function debug information. Assumes being called immediately
1347 // after the function entry point has been emitted.
1348 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1349 if (!MMI->hasDebugInfo()) return;
1350 LScopes.initialize(*MF);
1351 if (LScopes.empty()) return;
1352 identifyScopeMarkers();
1354 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1355 Asm->getFunctionNumber());
1356 // Assumes in correct section after the entry point.
1357 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1359 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1361 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1362 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1363 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1365 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1367 bool AtBlockEntry = true;
1368 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1370 const MachineInstr *MI = II;
1372 if (MI->isDebugValue()) {
1373 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1375 // Keep track of user variables.
1377 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1379 // Variable is in a register, we need to check for clobbers.
1380 if (isDbgValueInDefinedReg(MI))
1381 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1383 // Check the history of this variable.
1384 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1385 if (History.empty()) {
1386 UserVariables.push_back(Var);
1387 // The first mention of a function argument gets the FunctionBeginSym
1388 // label, so arguments are visible when breaking at function entry.
1390 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1391 DISubprogram(getDISubprogram(DV.getContext()))
1392 .describes(MF->getFunction()))
1393 LabelsBeforeInsn[MI] = FunctionBeginSym;
1395 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1396 const MachineInstr *Prev = History.back();
1397 if (Prev->isDebugValue()) {
1398 // Coalesce identical entries at the end of History.
1399 if (History.size() >= 2 &&
1400 Prev->isIdenticalTo(History[History.size() - 2])) {
1401 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1403 << "\t" << *History[History.size() - 2] << "\n");
1407 // Terminate old register assignments that don't reach MI;
1408 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1409 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1410 isDbgValueInDefinedReg(Prev)) {
1411 // Previous register assignment needs to terminate at the end of
1413 MachineBasicBlock::const_iterator LastMI =
1414 PrevMBB->getLastNonDebugInstr();
1415 if (LastMI == PrevMBB->end()) {
1416 // Drop DBG_VALUE for empty range.
1417 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1418 << "\t" << *Prev << "\n");
1422 // Terminate after LastMI.
1423 History.push_back(LastMI);
1428 History.push_back(MI);
1430 // Not a DBG_VALUE instruction.
1432 AtBlockEntry = false;
1434 // First known non-DBG_VALUE and non-frame setup location marks
1435 // the beginning of the function body.
1436 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1437 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1438 PrologEndLoc = MI->getDebugLoc();
1440 // Check if the instruction clobbers any registers with debug vars.
1441 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1442 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1443 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1445 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1446 AI.isValid(); ++AI) {
1448 const MDNode *Var = LiveUserVar[Reg];
1451 // Reg is now clobbered.
1452 LiveUserVar[Reg] = 0;
1454 // Was MD last defined by a DBG_VALUE referring to Reg?
1455 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1456 if (HistI == DbgValues.end())
1458 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1459 if (History.empty())
1461 const MachineInstr *Prev = History.back();
1462 // Sanity-check: Register assignments are terminated at the end of
1464 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1466 // Is the variable still in Reg?
1467 if (!isDbgValueInDefinedReg(Prev) ||
1468 Prev->getOperand(0).getReg() != Reg)
1470 // Var is clobbered. Make sure the next instruction gets a label.
1471 History.push_back(MI);
1478 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1480 SmallVectorImpl<const MachineInstr*> &History = I->second;
1481 if (History.empty())
1484 // Make sure the final register assignments are terminated.
1485 const MachineInstr *Prev = History.back();
1486 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1487 const MachineBasicBlock *PrevMBB = Prev->getParent();
1488 MachineBasicBlock::const_iterator LastMI =
1489 PrevMBB->getLastNonDebugInstr();
1490 if (LastMI == PrevMBB->end())
1491 // Drop DBG_VALUE for empty range.
1494 // Terminate after LastMI.
1495 History.push_back(LastMI);
1498 // Request labels for the full history.
1499 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1500 const MachineInstr *MI = History[i];
1501 if (MI->isDebugValue())
1502 requestLabelBeforeInsn(MI);
1504 requestLabelAfterInsn(MI);
1508 PrevInstLoc = DebugLoc();
1509 PrevLabel = FunctionBeginSym;
1511 // Record beginning of function.
1512 if (!PrologEndLoc.isUnknown()) {
1513 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1514 MF->getFunction()->getContext());
1515 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1516 FnStartDL.getScope(MF->getFunction()->getContext()),
1517 // We'd like to list the prologue as "not statements" but GDB behaves
1518 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1519 DWARF2_FLAG_IS_STMT);
1523 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1524 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1525 ScopeVariables[LS].push_back(Var);
1526 // Vars.push_back(Var);
1529 // Gather and emit post-function debug information.
1530 void DwarfDebug::endFunction(const MachineFunction *MF) {
1531 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1533 // Define end label for subprogram.
1534 FunctionEndSym = Asm->GetTempSymbol("func_end",
1535 Asm->getFunctionNumber());
1536 // Assumes in correct section after the entry point.
1537 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1539 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1540 collectVariableInfo(MF, ProcessedVars);
1542 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1543 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1544 assert(TheCU && "Unable to find compile unit!");
1546 // Construct abstract scopes.
1547 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1548 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1549 LexicalScope *AScope = AList[i];
1550 DISubprogram SP(AScope->getScopeNode());
1552 // Collect info for variables that were optimized out.
1553 DIArray Variables = SP.getVariables();
1554 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1555 DIVariable DV(Variables.getElement(i));
1556 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1558 // Check that DbgVariable for DV wasn't created earlier, when
1559 // findAbstractVariable() was called for inlined instance of DV.
1560 LLVMContext &Ctx = DV->getContext();
1561 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1562 if (AbstractVariables.lookup(CleanDV))
1564 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1565 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1568 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1569 constructScopeDIE(TheCU, AScope);
1572 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1574 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1575 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1577 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1578 MMI->getFrameMoves()));
1581 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1582 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1583 DeleteContainerPointers(I->second);
1584 ScopeVariables.clear();
1585 DeleteContainerPointers(CurrentFnArguments);
1586 UserVariables.clear();
1588 AbstractVariables.clear();
1589 LabelsBeforeInsn.clear();
1590 LabelsAfterInsn.clear();
1594 // Register a source line with debug info. Returns the unique label that was
1595 // emitted and which provides correspondence to the source line list.
1596 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1602 DIDescriptor Scope(S);
1604 if (Scope.isCompileUnit()) {
1605 DICompileUnit CU(S);
1606 Fn = CU.getFilename();
1607 Dir = CU.getDirectory();
1608 } else if (Scope.isFile()) {
1610 Fn = F.getFilename();
1611 Dir = F.getDirectory();
1612 } else if (Scope.isSubprogram()) {
1614 Fn = SP.getFilename();
1615 Dir = SP.getDirectory();
1616 } else if (Scope.isLexicalBlockFile()) {
1617 DILexicalBlockFile DBF(S);
1618 Fn = DBF.getFilename();
1619 Dir = DBF.getDirectory();
1620 } else if (Scope.isLexicalBlock()) {
1621 DILexicalBlock DB(S);
1622 Fn = DB.getFilename();
1623 Dir = DB.getDirectory();
1625 llvm_unreachable("Unexpected scope info");
1627 Src = getOrCreateSourceID(Fn, Dir);
1629 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1632 //===----------------------------------------------------------------------===//
1634 //===----------------------------------------------------------------------===//
1636 // Compute the size and offset of a DIE.
1638 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1639 // Get the children.
1640 const std::vector<DIE *> &Children = Die->getChildren();
1642 // Record the abbreviation.
1643 assignAbbrevNumber(Die->getAbbrev());
1645 // Get the abbreviation for this DIE.
1646 unsigned AbbrevNumber = Die->getAbbrevNumber();
1647 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1650 Die->setOffset(Offset);
1652 // Start the size with the size of abbreviation code.
1653 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1655 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1656 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1658 // Size the DIE attribute values.
1659 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1660 // Size attribute value.
1661 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1663 // Size the DIE children if any.
1664 if (!Children.empty()) {
1665 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1666 "Children flag not set");
1668 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1669 Offset = computeSizeAndOffset(Children[j], Offset);
1671 // End of children marker.
1672 Offset += sizeof(int8_t);
1675 Die->setSize(Offset - Die->getOffset());
1679 // Compute the size and offset of all the DIEs.
1680 void DwarfDebug::computeSizeAndOffsets() {
1683 sizeof(int32_t) + // Length of Compilation Unit Info
1684 sizeof(int16_t) + // DWARF version number
1685 sizeof(int32_t) + // Offset Into Abbrev. Section
1686 sizeof(int8_t); // Pointer Size (in bytes)
1688 computeSizeAndOffset(SkeletonCU->getCUDie(), Offset);
1690 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1691 E = CUMap.end(); I != E; ++I) {
1692 // Compute size of compile unit header.
1694 sizeof(int32_t) + // Length of Compilation Unit Info
1695 sizeof(int16_t) + // DWARF version number
1696 sizeof(int32_t) + // Offset Into Abbrev. Section
1697 sizeof(int8_t); // Pointer Size (in bytes)
1698 computeSizeAndOffset(I->second->getCUDie(), Offset);
1702 // Emit initial Dwarf sections with a label at the start of each one.
1703 void DwarfDebug::emitSectionLabels() {
1704 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1706 // Dwarf sections base addresses.
1707 DwarfInfoSectionSym =
1708 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1709 DwarfAbbrevSectionSym =
1710 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1711 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1713 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1714 emitSectionSym(Asm, MacroInfo);
1716 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1717 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1718 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1719 DwarfStrSectionSym =
1720 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1721 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1724 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1725 "section_debug_loc");
1727 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1728 emitSectionSym(Asm, TLOF.getDataSection());
1731 // Recursively emits a debug information entry.
1732 void DwarfDebug::emitDIE(DIE *Die) {
1733 // Get the abbreviation for this DIE.
1734 unsigned AbbrevNumber = Die->getAbbrevNumber();
1735 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1737 // Emit the code (index) for the abbreviation.
1738 if (Asm->isVerbose())
1739 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1740 Twine::utohexstr(Die->getOffset()) + ":0x" +
1741 Twine::utohexstr(Die->getSize()) + " " +
1742 dwarf::TagString(Abbrev->getTag()));
1743 Asm->EmitULEB128(AbbrevNumber);
1745 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1746 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1748 // Emit the DIE attribute values.
1749 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1750 unsigned Attr = AbbrevData[i].getAttribute();
1751 unsigned Form = AbbrevData[i].getForm();
1752 assert(Form && "Too many attributes for DIE (check abbreviation)");
1754 if (Asm->isVerbose())
1755 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1758 case dwarf::DW_AT_abstract_origin: {
1759 DIEEntry *E = cast<DIEEntry>(Values[i]);
1760 DIE *Origin = E->getEntry();
1761 unsigned Addr = Origin->getOffset();
1762 Asm->EmitInt32(Addr);
1765 case dwarf::DW_AT_ranges: {
1766 // DW_AT_range Value encodes offset in debug_range section.
1767 DIEInteger *V = cast<DIEInteger>(Values[i]);
1769 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1770 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1774 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1776 DwarfDebugRangeSectionSym,
1781 case dwarf::DW_AT_location: {
1782 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1783 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1784 Asm->EmitLabelReference(L->getValue(), 4);
1786 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1788 Values[i]->EmitValue(Asm, Form);
1792 case dwarf::DW_AT_accessibility: {
1793 if (Asm->isVerbose()) {
1794 DIEInteger *V = cast<DIEInteger>(Values[i]);
1795 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1797 Values[i]->EmitValue(Asm, Form);
1801 // Emit an attribute using the defined form.
1802 Values[i]->EmitValue(Asm, Form);
1807 // Emit the DIE children if any.
1808 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1809 const std::vector<DIE *> &Children = Die->getChildren();
1811 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1812 emitDIE(Children[j]);
1814 if (Asm->isVerbose())
1815 Asm->OutStreamer.AddComment("End Of Children Mark");
1820 void DwarfDebug::emitCompileUnits(const MCSection *Section) {
1821 Asm->OutStreamer.SwitchSection(Section);
1822 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1823 E = CUMap.end(); I != E; ++I) {
1824 CompileUnit *TheCU = I->second;
1825 DIE *Die = TheCU->getCUDie();
1827 // Emit the compile units header.
1828 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1829 TheCU->getUniqueID()));
1831 // Emit size of content not including length itself
1832 unsigned ContentSize = Die->getSize() +
1833 sizeof(int16_t) + // DWARF version number
1834 sizeof(int32_t) + // Offset Into Abbrev. Section
1835 sizeof(int8_t); // Pointer Size (in bytes)
1837 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1838 Asm->EmitInt32(ContentSize);
1839 Asm->OutStreamer.AddComment("DWARF version number");
1840 Asm->EmitInt16(dwarf::DWARF_VERSION);
1841 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1842 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1843 DwarfAbbrevSectionSym);
1844 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1845 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1848 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end",
1849 TheCU->getUniqueID()));
1853 // Emit the debug info section.
1854 void DwarfDebug::emitDebugInfo() {
1855 if (!useSplitDwarf())
1856 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoSection());
1858 emitSkeletonCU(Asm->getObjFileLowering().getDwarfInfoSection());
1861 // Emit the abbreviation section.
1862 void DwarfDebug::emitAbbreviations() {
1863 // Check to see if it is worth the effort.
1864 if (!Abbreviations.empty()) {
1865 // Start the debug abbrev section.
1866 Asm->OutStreamer.SwitchSection(
1867 Asm->getObjFileLowering().getDwarfAbbrevSection());
1869 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1871 // For each abbrevation.
1872 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1873 // Get abbreviation data
1874 const DIEAbbrev *Abbrev = Abbreviations[i];
1876 // Emit the abbrevations code (base 1 index.)
1877 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1879 // Emit the abbreviations data.
1883 // Mark end of abbreviations.
1884 Asm->EmitULEB128(0, "EOM(3)");
1886 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1890 // Emit the last address of the section and the end of the line matrix.
1891 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1892 // Define last address of section.
1893 Asm->OutStreamer.AddComment("Extended Op");
1896 Asm->OutStreamer.AddComment("Op size");
1897 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1898 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1899 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1901 Asm->OutStreamer.AddComment("Section end label");
1903 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1904 Asm->getDataLayout().getPointerSize(),
1907 // Mark end of matrix.
1908 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1914 // Emit visible names into a hashed accelerator table section.
1915 void DwarfDebug::emitAccelNames() {
1916 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1917 dwarf::DW_FORM_data4));
1918 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1919 E = CUMap.end(); I != E; ++I) {
1920 CompileUnit *TheCU = I->second;
1921 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1922 for (StringMap<std::vector<DIE*> >::const_iterator
1923 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1924 const char *Name = GI->getKeyData();
1925 const std::vector<DIE *> &Entities = GI->second;
1926 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1927 DE = Entities.end(); DI != DE; ++DI)
1928 AT.AddName(Name, (*DI));
1932 AT.FinalizeTable(Asm, "Names");
1933 Asm->OutStreamer.SwitchSection(
1934 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1935 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1936 Asm->OutStreamer.EmitLabel(SectionBegin);
1938 // Emit the full data.
1939 AT.Emit(Asm, SectionBegin, this);
1942 // Emit objective C classes and categories into a hashed accelerator table section.
1943 void DwarfDebug::emitAccelObjC() {
1944 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1945 dwarf::DW_FORM_data4));
1946 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1947 E = CUMap.end(); I != E; ++I) {
1948 CompileUnit *TheCU = I->second;
1949 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1950 for (StringMap<std::vector<DIE*> >::const_iterator
1951 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1952 const char *Name = GI->getKeyData();
1953 const std::vector<DIE *> &Entities = GI->second;
1954 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1955 DE = Entities.end(); DI != DE; ++DI)
1956 AT.AddName(Name, (*DI));
1960 AT.FinalizeTable(Asm, "ObjC");
1961 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1962 .getDwarfAccelObjCSection());
1963 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1964 Asm->OutStreamer.EmitLabel(SectionBegin);
1966 // Emit the full data.
1967 AT.Emit(Asm, SectionBegin, this);
1970 // Emit namespace dies into a hashed accelerator table.
1971 void DwarfDebug::emitAccelNamespaces() {
1972 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1973 dwarf::DW_FORM_data4));
1974 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1975 E = CUMap.end(); I != E; ++I) {
1976 CompileUnit *TheCU = I->second;
1977 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1978 for (StringMap<std::vector<DIE*> >::const_iterator
1979 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1980 const char *Name = GI->getKeyData();
1981 const std::vector<DIE *> &Entities = GI->second;
1982 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1983 DE = Entities.end(); DI != DE; ++DI)
1984 AT.AddName(Name, (*DI));
1988 AT.FinalizeTable(Asm, "namespac");
1989 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1990 .getDwarfAccelNamespaceSection());
1991 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1992 Asm->OutStreamer.EmitLabel(SectionBegin);
1994 // Emit the full data.
1995 AT.Emit(Asm, SectionBegin, this);
1998 // Emit type dies into a hashed accelerator table.
1999 void DwarfDebug::emitAccelTypes() {
2000 std::vector<DwarfAccelTable::Atom> Atoms;
2001 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2002 dwarf::DW_FORM_data4));
2003 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2004 dwarf::DW_FORM_data2));
2005 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2006 dwarf::DW_FORM_data1));
2007 DwarfAccelTable AT(Atoms);
2008 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2009 E = CUMap.end(); I != E; ++I) {
2010 CompileUnit *TheCU = I->second;
2011 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2012 = TheCU->getAccelTypes();
2013 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2014 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2015 const char *Name = GI->getKeyData();
2016 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2017 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2018 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2019 AT.AddName(Name, (*DI).first, (*DI).second);
2023 AT.FinalizeTable(Asm, "types");
2024 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2025 .getDwarfAccelTypesSection());
2026 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2027 Asm->OutStreamer.EmitLabel(SectionBegin);
2029 // Emit the full data.
2030 AT.Emit(Asm, SectionBegin, this);
2033 void DwarfDebug::emitDebugPubTypes() {
2034 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2035 E = CUMap.end(); I != E; ++I) {
2036 CompileUnit *TheCU = I->second;
2037 // Start the dwarf pubtypes section.
2038 Asm->OutStreamer.SwitchSection(
2039 Asm->getObjFileLowering().getDwarfPubTypesSection());
2040 Asm->OutStreamer.AddComment("Length of Public Types Info");
2041 Asm->EmitLabelDifference(
2042 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2043 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2045 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2046 TheCU->getUniqueID()));
2048 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2049 Asm->EmitInt16(dwarf::DWARF_VERSION);
2051 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2052 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin",
2053 TheCU->getUniqueID()),
2054 DwarfInfoSectionSym);
2056 Asm->OutStreamer.AddComment("Compilation Unit Length");
2057 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end",
2058 TheCU->getUniqueID()),
2059 Asm->GetTempSymbol("info_begin",
2060 TheCU->getUniqueID()),
2063 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2064 for (StringMap<DIE*>::const_iterator
2065 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2066 const char *Name = GI->getKeyData();
2067 DIE *Entity = GI->second;
2069 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2070 Asm->EmitInt32(Entity->getOffset());
2072 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2073 // Emit the name with a terminating null byte.
2074 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2077 Asm->OutStreamer.AddComment("End Mark");
2079 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2080 TheCU->getUniqueID()));
2084 // Emit visible names into a debug str section.
2085 void DwarfDebug::emitDebugStr() {
2086 // Check to see if it is worth the effort.
2087 if (StringPool.empty()) return;
2089 // Start the dwarf str section.
2090 Asm->OutStreamer.SwitchSection(
2091 Asm->getObjFileLowering().getDwarfStrSection());
2093 // Get all of the string pool entries and put them in an array by their ID so
2094 // we can sort them.
2095 SmallVector<std::pair<unsigned,
2096 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2098 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2099 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2100 Entries.push_back(std::make_pair(I->second.second, &*I));
2102 array_pod_sort(Entries.begin(), Entries.end());
2104 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2105 // Emit a label for reference from debug information entries.
2106 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2108 // Emit the string itself with a terminating null byte.
2109 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2110 Entries[i].second->getKeyLength()+1),
2115 // Emit visible names into a debug loc section.
2116 void DwarfDebug::emitDebugLoc() {
2117 if (DotDebugLocEntries.empty())
2120 for (SmallVector<DotDebugLocEntry, 4>::iterator
2121 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2123 DotDebugLocEntry &Entry = *I;
2124 if (I + 1 != DotDebugLocEntries.end())
2128 // Start the dwarf loc section.
2129 Asm->OutStreamer.SwitchSection(
2130 Asm->getObjFileLowering().getDwarfLocSection());
2131 unsigned char Size = Asm->getDataLayout().getPointerSize();
2132 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2134 for (SmallVector<DotDebugLocEntry, 4>::iterator
2135 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2136 I != E; ++I, ++index) {
2137 DotDebugLocEntry &Entry = *I;
2138 if (Entry.isMerged()) continue;
2139 if (Entry.isEmpty()) {
2140 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2141 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2142 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2144 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2145 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2146 DIVariable DV(Entry.Variable);
2147 Asm->OutStreamer.AddComment("Loc expr size");
2148 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2149 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2150 Asm->EmitLabelDifference(end, begin, 2);
2151 Asm->OutStreamer.EmitLabel(begin);
2152 if (Entry.isInt()) {
2153 DIBasicType BTy(DV.getType());
2155 (BTy.getEncoding() == dwarf::DW_ATE_signed
2156 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2157 Asm->OutStreamer.AddComment("DW_OP_consts");
2158 Asm->EmitInt8(dwarf::DW_OP_consts);
2159 Asm->EmitSLEB128(Entry.getInt());
2161 Asm->OutStreamer.AddComment("DW_OP_constu");
2162 Asm->EmitInt8(dwarf::DW_OP_constu);
2163 Asm->EmitULEB128(Entry.getInt());
2165 } else if (Entry.isLocation()) {
2166 if (!DV.hasComplexAddress())
2168 Asm->EmitDwarfRegOp(Entry.Loc);
2170 // Complex address entry.
2171 unsigned N = DV.getNumAddrElements();
2173 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2174 if (Entry.Loc.getOffset()) {
2176 Asm->EmitDwarfRegOp(Entry.Loc);
2177 Asm->OutStreamer.AddComment("DW_OP_deref");
2178 Asm->EmitInt8(dwarf::DW_OP_deref);
2179 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2180 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2181 Asm->EmitSLEB128(DV.getAddrElement(1));
2183 // If first address element is OpPlus then emit
2184 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2185 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2186 Asm->EmitDwarfRegOp(Loc);
2190 Asm->EmitDwarfRegOp(Entry.Loc);
2193 // Emit remaining complex address elements.
2194 for (; i < N; ++i) {
2195 uint64_t Element = DV.getAddrElement(i);
2196 if (Element == DIBuilder::OpPlus) {
2197 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2198 Asm->EmitULEB128(DV.getAddrElement(++i));
2199 } else if (Element == DIBuilder::OpDeref) {
2200 if (!Entry.Loc.isReg())
2201 Asm->EmitInt8(dwarf::DW_OP_deref);
2203 llvm_unreachable("unknown Opcode found in complex address");
2207 // else ... ignore constant fp. There is not any good way to
2208 // to represent them here in dwarf.
2209 Asm->OutStreamer.EmitLabel(end);
2214 // Emit visible names into a debug aranges section.
2215 void DwarfDebug::emitDebugARanges() {
2216 // Start the dwarf aranges section.
2217 Asm->OutStreamer.SwitchSection(
2218 Asm->getObjFileLowering().getDwarfARangesSection());
2221 // Emit visible names into a debug ranges section.
2222 void DwarfDebug::emitDebugRanges() {
2223 // Start the dwarf ranges section.
2224 Asm->OutStreamer.SwitchSection(
2225 Asm->getObjFileLowering().getDwarfRangesSection());
2226 unsigned char Size = Asm->getDataLayout().getPointerSize();
2227 for (SmallVector<const MCSymbol *, 8>::iterator
2228 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2231 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2233 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2237 // Emit visible names into a debug macinfo section.
2238 void DwarfDebug::emitDebugMacInfo() {
2239 if (const MCSection *LineInfo =
2240 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2241 // Start the dwarf macinfo section.
2242 Asm->OutStreamer.SwitchSection(LineInfo);
2246 // Emit inline info using following format.
2248 // 1. length of section
2249 // 2. Dwarf version number
2252 // Entries (one "entry" for each function that was inlined):
2254 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2255 // otherwise offset into __debug_str for regular function name.
2256 // 2. offset into __debug_str section for regular function name.
2257 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2258 // instances for the function.
2260 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2261 // inlined instance; the die_offset points to the inlined_subroutine die in the
2262 // __debug_info section, and the low_pc is the starting address for the
2263 // inlining instance.
2264 void DwarfDebug::emitDebugInlineInfo() {
2265 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2271 Asm->OutStreamer.SwitchSection(
2272 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2274 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2275 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2276 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2278 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2280 Asm->OutStreamer.AddComment("Dwarf Version");
2281 Asm->EmitInt16(dwarf::DWARF_VERSION);
2282 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2283 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2285 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2286 E = InlinedSPNodes.end(); I != E; ++I) {
2288 const MDNode *Node = *I;
2289 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2290 = InlineInfo.find(Node);
2291 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2292 DISubprogram SP(Node);
2293 StringRef LName = SP.getLinkageName();
2294 StringRef Name = SP.getName();
2296 Asm->OutStreamer.AddComment("MIPS linkage name");
2298 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2300 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2301 DwarfStrSectionSym);
2303 Asm->OutStreamer.AddComment("Function name");
2304 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2305 Asm->EmitULEB128(Labels.size(), "Inline count");
2307 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2308 LE = Labels.end(); LI != LE; ++LI) {
2309 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2310 Asm->EmitInt32(LI->second->getOffset());
2312 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2313 Asm->OutStreamer.EmitSymbolValue(LI->first,
2314 Asm->getDataLayout().getPointerSize(),0);
2318 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2321 // DWARF5 Experimental Fission emitters.
2323 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2324 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2325 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2326 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2327 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2328 DICompileUnit DIUnit(N);
2329 StringRef FN = DIUnit.getFilename();
2330 CompilationDir = DIUnit.getDirectory();
2332 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2333 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2334 DIUnit.getLanguage(), Die, Asm, this);
2335 // FIXME: This should be the .dwo file.
2336 NewCU->addString(Die, dwarf::DW_AT_GNU_dwo_name, FN);
2338 // FIXME: We also need DW_AT_addr_base and DW_AT_dwo_id.
2340 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2342 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2343 // DW_AT_stmt_list is a offset of line number information for this
2344 // compile unit in debug_line section.
2345 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2346 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
2347 Asm->GetTempSymbol("section_line"));
2349 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
2351 if (!CompilationDir.empty())
2352 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2357 void DwarfDebug::emitSkeletonCU(const MCSection *Section) {
2358 Asm->OutStreamer.SwitchSection(Section);
2359 DIE *Die = SkeletonCU->getCUDie();
2361 // Emit the compile units header.
2362 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_begin",
2363 SkeletonCU->getUniqueID()));
2365 // Emit size of content not including length itself
2366 unsigned ContentSize = Die->getSize() +
2367 sizeof(int16_t) + // DWARF version number
2368 sizeof(int32_t) + // Offset Into Abbrev. Section
2369 sizeof(int8_t); // Pointer Size (in bytes)
2371 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2372 Asm->EmitInt32(ContentSize);
2373 Asm->OutStreamer.AddComment("DWARF version number");
2374 Asm->EmitInt16(dwarf::DWARF_VERSION);
2375 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2376 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2377 DwarfAbbrevSectionSym);
2378 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2379 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2382 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_end",
2383 SkeletonCU->getUniqueID()));
2388 // Emit the .debug_info.dwo section for fission. This contains the compile
2389 // units that would normally be in debug_info.
2390 void DwarfDebug::emitDebugInfoDWO() {
2391 assert(useSplitDwarf() && "No split dwarf debug info?");
2392 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoDWOSection());