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> DwarfFission("dwarf-fission", cl::Hidden,
82 cl::desc("Output prototype dwarf fission."),
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), FissionCU(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 (DwarfFission == Default)
187 HasDwarfFission = false;
189 HasDwarfFission = DwarfFission == 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 (useDwarfFission() && !FissionCU)
656 FissionCU = constructFissionCU(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 (!useDwarfFission()) {
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)
984 // Reset these for the next Module if we have one.
989 // Find abstract variable, if any, associated with Var.
990 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
992 LLVMContext &Ctx = DV->getContext();
993 // More then one inlined variable corresponds to one abstract variable.
994 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
995 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
997 return AbsDbgVariable;
999 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1003 AbsDbgVariable = new DbgVariable(Var, NULL);
1004 addScopeVariable(Scope, AbsDbgVariable);
1005 AbstractVariables[Var] = AbsDbgVariable;
1006 return AbsDbgVariable;
1009 // If Var is a current function argument then add it to CurrentFnArguments list.
1010 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1011 DbgVariable *Var, LexicalScope *Scope) {
1012 if (!LScopes.isCurrentFunctionScope(Scope))
1014 DIVariable DV = Var->getVariable();
1015 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1017 unsigned ArgNo = DV.getArgNumber();
1021 size_t Size = CurrentFnArguments.size();
1023 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1024 // llvm::Function argument size is not good indicator of how many
1025 // arguments does the function have at source level.
1027 CurrentFnArguments.resize(ArgNo * 2);
1028 CurrentFnArguments[ArgNo - 1] = Var;
1032 // Collect variable information from side table maintained by MMI.
1034 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1035 SmallPtrSet<const MDNode *, 16> &Processed) {
1036 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1037 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1038 VE = VMap.end(); VI != VE; ++VI) {
1039 const MDNode *Var = VI->first;
1041 Processed.insert(Var);
1043 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1045 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1047 // If variable scope is not found then skip this variable.
1051 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1052 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1053 RegVar->setFrameIndex(VP.first);
1054 if (!addCurrentFnArgument(MF, RegVar, Scope))
1055 addScopeVariable(Scope, RegVar);
1057 AbsDbgVariable->setFrameIndex(VP.first);
1061 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1063 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1064 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1065 return MI->getNumOperands() == 3 &&
1066 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1067 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1070 // Get .debug_loc entry for the instruction range starting at MI.
1071 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1072 const MCSymbol *FLabel,
1073 const MCSymbol *SLabel,
1074 const MachineInstr *MI) {
1075 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1077 if (MI->getNumOperands() != 3) {
1078 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1079 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1081 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1082 MachineLocation MLoc;
1083 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1084 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1086 if (MI->getOperand(0).isImm())
1087 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1088 if (MI->getOperand(0).isFPImm())
1089 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1090 if (MI->getOperand(0).isCImm())
1091 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1093 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1096 // Find variables for each lexical scope.
1098 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1099 SmallPtrSet<const MDNode *, 16> &Processed) {
1101 // collection info from MMI table.
1102 collectVariableInfoFromMMITable(MF, Processed);
1104 for (SmallVectorImpl<const MDNode*>::const_iterator
1105 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1107 const MDNode *Var = *UVI;
1108 if (Processed.count(Var))
1111 // History contains relevant DBG_VALUE instructions for Var and instructions
1113 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1114 if (History.empty())
1116 const MachineInstr *MInsn = History.front();
1119 LexicalScope *Scope = NULL;
1120 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1121 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1122 Scope = LScopes.getCurrentFunctionScope();
1124 if (DV.getVersion() <= LLVMDebugVersion9)
1125 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1127 if (MDNode *IA = DV.getInlinedAt())
1128 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1130 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1133 // If variable scope is not found then skip this variable.
1137 Processed.insert(DV);
1138 assert(MInsn->isDebugValue() && "History must begin with debug value");
1139 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1140 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1141 if (!addCurrentFnArgument(MF, RegVar, Scope))
1142 addScopeVariable(Scope, RegVar);
1144 AbsVar->setMInsn(MInsn);
1146 // Simplify ranges that are fully coalesced.
1147 if (History.size() <= 1 || (History.size() == 2 &&
1148 MInsn->isIdenticalTo(History.back()))) {
1149 RegVar->setMInsn(MInsn);
1153 // handle multiple DBG_VALUE instructions describing one variable.
1154 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1156 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1157 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1158 const MachineInstr *Begin = *HI;
1159 assert(Begin->isDebugValue() && "Invalid History entry");
1161 // Check if DBG_VALUE is truncating a range.
1162 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1163 && !Begin->getOperand(0).getReg())
1166 // Compute the range for a register location.
1167 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1168 const MCSymbol *SLabel = 0;
1171 // If Begin is the last instruction in History then its value is valid
1172 // until the end of the function.
1173 SLabel = FunctionEndSym;
1175 const MachineInstr *End = HI[1];
1176 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1177 << "\t" << *Begin << "\t" << *End << "\n");
1178 if (End->isDebugValue())
1179 SLabel = getLabelBeforeInsn(End);
1181 // End is a normal instruction clobbering the range.
1182 SLabel = getLabelAfterInsn(End);
1183 assert(SLabel && "Forgot label after clobber instruction");
1188 // The value is valid until the next DBG_VALUE or clobber.
1189 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1192 DotDebugLocEntries.push_back(DotDebugLocEntry());
1195 // Collect info for variables that were optimized out.
1196 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1197 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1198 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1199 DIVariable DV(Variables.getElement(i));
1200 if (!DV || !DV.Verify() || !Processed.insert(DV))
1202 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1203 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1207 // Return Label preceding the instruction.
1208 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1209 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1210 assert(Label && "Didn't insert label before instruction");
1214 // Return Label immediately following the instruction.
1215 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1216 return LabelsAfterInsn.lookup(MI);
1219 // Process beginning of an instruction.
1220 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1221 // Check if source location changes, but ignore DBG_VALUE locations.
1222 if (!MI->isDebugValue()) {
1223 DebugLoc DL = MI->getDebugLoc();
1224 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1227 if (DL == PrologEndLoc) {
1228 Flags |= DWARF2_FLAG_PROLOGUE_END;
1229 PrologEndLoc = DebugLoc();
1231 if (PrologEndLoc.isUnknown())
1232 Flags |= DWARF2_FLAG_IS_STMT;
1234 if (!DL.isUnknown()) {
1235 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1236 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1238 recordSourceLine(0, 0, 0, 0);
1242 // Insert labels where requested.
1243 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1244 LabelsBeforeInsn.find(MI);
1247 if (I == LabelsBeforeInsn.end())
1250 // Label already assigned.
1255 PrevLabel = MMI->getContext().CreateTempSymbol();
1256 Asm->OutStreamer.EmitLabel(PrevLabel);
1258 I->second = PrevLabel;
1261 // Process end of an instruction.
1262 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1263 // Don't create a new label after DBG_VALUE instructions.
1264 // They don't generate code.
1265 if (!MI->isDebugValue())
1268 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1269 LabelsAfterInsn.find(MI);
1272 if (I == LabelsAfterInsn.end())
1275 // Label already assigned.
1279 // We need a label after this instruction.
1281 PrevLabel = MMI->getContext().CreateTempSymbol();
1282 Asm->OutStreamer.EmitLabel(PrevLabel);
1284 I->second = PrevLabel;
1287 // Each LexicalScope has first instruction and last instruction to mark
1288 // beginning and end of a scope respectively. Create an inverse map that list
1289 // scopes starts (and ends) with an instruction. One instruction may start (or
1290 // end) multiple scopes. Ignore scopes that are not reachable.
1291 void DwarfDebug::identifyScopeMarkers() {
1292 SmallVector<LexicalScope *, 4> WorkList;
1293 WorkList.push_back(LScopes.getCurrentFunctionScope());
1294 while (!WorkList.empty()) {
1295 LexicalScope *S = WorkList.pop_back_val();
1297 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1298 if (!Children.empty())
1299 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1300 SE = Children.end(); SI != SE; ++SI)
1301 WorkList.push_back(*SI);
1303 if (S->isAbstractScope())
1306 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1309 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1310 RE = Ranges.end(); RI != RE; ++RI) {
1311 assert(RI->first && "InsnRange does not have first instruction!");
1312 assert(RI->second && "InsnRange does not have second instruction!");
1313 requestLabelBeforeInsn(RI->first);
1314 requestLabelAfterInsn(RI->second);
1319 // Get MDNode for DebugLoc's scope.
1320 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1321 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1322 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1323 return DL.getScope(Ctx);
1326 // Walk up the scope chain of given debug loc and find line number info
1327 // for the function.
1328 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1329 const MDNode *Scope = getScopeNode(DL, Ctx);
1330 DISubprogram SP = getDISubprogram(Scope);
1332 // Check for number of operands since the compatibility is
1334 if (SP->getNumOperands() > 19)
1335 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1337 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1343 // Gather pre-function debug information. Assumes being called immediately
1344 // after the function entry point has been emitted.
1345 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1346 if (!MMI->hasDebugInfo()) return;
1347 LScopes.initialize(*MF);
1348 if (LScopes.empty()) return;
1349 identifyScopeMarkers();
1351 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1352 Asm->getFunctionNumber());
1353 // Assumes in correct section after the entry point.
1354 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1356 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1358 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1359 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1360 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1362 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1364 bool AtBlockEntry = true;
1365 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1367 const MachineInstr *MI = II;
1369 if (MI->isDebugValue()) {
1370 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1372 // Keep track of user variables.
1374 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1376 // Variable is in a register, we need to check for clobbers.
1377 if (isDbgValueInDefinedReg(MI))
1378 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1380 // Check the history of this variable.
1381 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1382 if (History.empty()) {
1383 UserVariables.push_back(Var);
1384 // The first mention of a function argument gets the FunctionBeginSym
1385 // label, so arguments are visible when breaking at function entry.
1387 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1388 DISubprogram(getDISubprogram(DV.getContext()))
1389 .describes(MF->getFunction()))
1390 LabelsBeforeInsn[MI] = FunctionBeginSym;
1392 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1393 const MachineInstr *Prev = History.back();
1394 if (Prev->isDebugValue()) {
1395 // Coalesce identical entries at the end of History.
1396 if (History.size() >= 2 &&
1397 Prev->isIdenticalTo(History[History.size() - 2])) {
1398 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1400 << "\t" << *History[History.size() - 2] << "\n");
1404 // Terminate old register assignments that don't reach MI;
1405 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1406 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1407 isDbgValueInDefinedReg(Prev)) {
1408 // Previous register assignment needs to terminate at the end of
1410 MachineBasicBlock::const_iterator LastMI =
1411 PrevMBB->getLastNonDebugInstr();
1412 if (LastMI == PrevMBB->end()) {
1413 // Drop DBG_VALUE for empty range.
1414 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1415 << "\t" << *Prev << "\n");
1419 // Terminate after LastMI.
1420 History.push_back(LastMI);
1425 History.push_back(MI);
1427 // Not a DBG_VALUE instruction.
1429 AtBlockEntry = false;
1431 // First known non-DBG_VALUE and non-frame setup location marks
1432 // the beginning of the function body.
1433 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1434 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1435 PrologEndLoc = MI->getDebugLoc();
1437 // Check if the instruction clobbers any registers with debug vars.
1438 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1439 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1440 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1442 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1443 AI.isValid(); ++AI) {
1445 const MDNode *Var = LiveUserVar[Reg];
1448 // Reg is now clobbered.
1449 LiveUserVar[Reg] = 0;
1451 // Was MD last defined by a DBG_VALUE referring to Reg?
1452 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1453 if (HistI == DbgValues.end())
1455 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1456 if (History.empty())
1458 const MachineInstr *Prev = History.back();
1459 // Sanity-check: Register assignments are terminated at the end of
1461 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1463 // Is the variable still in Reg?
1464 if (!isDbgValueInDefinedReg(Prev) ||
1465 Prev->getOperand(0).getReg() != Reg)
1467 // Var is clobbered. Make sure the next instruction gets a label.
1468 History.push_back(MI);
1475 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1477 SmallVectorImpl<const MachineInstr*> &History = I->second;
1478 if (History.empty())
1481 // Make sure the final register assignments are terminated.
1482 const MachineInstr *Prev = History.back();
1483 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1484 const MachineBasicBlock *PrevMBB = Prev->getParent();
1485 MachineBasicBlock::const_iterator LastMI =
1486 PrevMBB->getLastNonDebugInstr();
1487 if (LastMI == PrevMBB->end())
1488 // Drop DBG_VALUE for empty range.
1491 // Terminate after LastMI.
1492 History.push_back(LastMI);
1495 // Request labels for the full history.
1496 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1497 const MachineInstr *MI = History[i];
1498 if (MI->isDebugValue())
1499 requestLabelBeforeInsn(MI);
1501 requestLabelAfterInsn(MI);
1505 PrevInstLoc = DebugLoc();
1506 PrevLabel = FunctionBeginSym;
1508 // Record beginning of function.
1509 if (!PrologEndLoc.isUnknown()) {
1510 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1511 MF->getFunction()->getContext());
1512 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1513 FnStartDL.getScope(MF->getFunction()->getContext()),
1514 // We'd like to list the prologue as "not statements" but GDB behaves
1515 // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1516 DWARF2_FLAG_IS_STMT);
1520 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1521 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1522 ScopeVariables[LS].push_back(Var);
1523 // Vars.push_back(Var);
1526 // Gather and emit post-function debug information.
1527 void DwarfDebug::endFunction(const MachineFunction *MF) {
1528 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1530 // Define end label for subprogram.
1531 FunctionEndSym = Asm->GetTempSymbol("func_end",
1532 Asm->getFunctionNumber());
1533 // Assumes in correct section after the entry point.
1534 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1536 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1537 collectVariableInfo(MF, ProcessedVars);
1539 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1540 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1541 assert(TheCU && "Unable to find compile unit!");
1543 // Construct abstract scopes.
1544 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1545 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1546 LexicalScope *AScope = AList[i];
1547 DISubprogram SP(AScope->getScopeNode());
1549 // Collect info for variables that were optimized out.
1550 DIArray Variables = SP.getVariables();
1551 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1552 DIVariable DV(Variables.getElement(i));
1553 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1555 // Check that DbgVariable for DV wasn't created earlier, when
1556 // findAbstractVariable() was called for inlined instance of DV.
1557 LLVMContext &Ctx = DV->getContext();
1558 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1559 if (AbstractVariables.lookup(CleanDV))
1561 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1562 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1565 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1566 constructScopeDIE(TheCU, AScope);
1569 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1571 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1572 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1574 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1575 MMI->getFrameMoves()));
1578 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1579 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1580 DeleteContainerPointers(I->second);
1581 ScopeVariables.clear();
1582 DeleteContainerPointers(CurrentFnArguments);
1583 UserVariables.clear();
1585 AbstractVariables.clear();
1586 LabelsBeforeInsn.clear();
1587 LabelsAfterInsn.clear();
1591 // Register a source line with debug info. Returns the unique label that was
1592 // emitted and which provides correspondence to the source line list.
1593 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1599 DIDescriptor Scope(S);
1601 if (Scope.isCompileUnit()) {
1602 DICompileUnit CU(S);
1603 Fn = CU.getFilename();
1604 Dir = CU.getDirectory();
1605 } else if (Scope.isFile()) {
1607 Fn = F.getFilename();
1608 Dir = F.getDirectory();
1609 } else if (Scope.isSubprogram()) {
1611 Fn = SP.getFilename();
1612 Dir = SP.getDirectory();
1613 } else if (Scope.isLexicalBlockFile()) {
1614 DILexicalBlockFile DBF(S);
1615 Fn = DBF.getFilename();
1616 Dir = DBF.getDirectory();
1617 } else if (Scope.isLexicalBlock()) {
1618 DILexicalBlock DB(S);
1619 Fn = DB.getFilename();
1620 Dir = DB.getDirectory();
1622 llvm_unreachable("Unexpected scope info");
1624 Src = getOrCreateSourceID(Fn, Dir);
1626 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1629 //===----------------------------------------------------------------------===//
1631 //===----------------------------------------------------------------------===//
1633 // Compute the size and offset of a DIE.
1635 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1636 // Get the children.
1637 const std::vector<DIE *> &Children = Die->getChildren();
1639 // Record the abbreviation.
1640 assignAbbrevNumber(Die->getAbbrev());
1642 // Get the abbreviation for this DIE.
1643 unsigned AbbrevNumber = Die->getAbbrevNumber();
1644 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1647 Die->setOffset(Offset);
1649 // Start the size with the size of abbreviation code.
1650 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1652 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1653 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1655 // Size the DIE attribute values.
1656 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1657 // Size attribute value.
1658 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1660 // Size the DIE children if any.
1661 if (!Children.empty()) {
1662 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1663 "Children flag not set");
1665 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1666 Offset = computeSizeAndOffset(Children[j], Offset);
1668 // End of children marker.
1669 Offset += sizeof(int8_t);
1672 Die->setSize(Offset - Die->getOffset());
1676 // Compute the size and offset of all the DIEs.
1677 void DwarfDebug::computeSizeAndOffsets() {
1680 sizeof(int32_t) + // Length of Compilation Unit Info
1681 sizeof(int16_t) + // DWARF version number
1682 sizeof(int32_t) + // Offset Into Abbrev. Section
1683 sizeof(int8_t); // Pointer Size (in bytes)
1685 computeSizeAndOffset(FissionCU->getCUDie(), Offset);
1687 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1688 E = CUMap.end(); I != E; ++I) {
1689 // Compute size of compile unit header.
1691 sizeof(int32_t) + // Length of Compilation Unit Info
1692 sizeof(int16_t) + // DWARF version number
1693 sizeof(int32_t) + // Offset Into Abbrev. Section
1694 sizeof(int8_t); // Pointer Size (in bytes)
1695 computeSizeAndOffset(I->second->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 (!useDwarfFission())
1853 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoSection());
1855 emitFissionSkeletonCU(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 Fission 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::constructFissionCU(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);
2354 void DwarfDebug::emitFissionSkeletonCU(const MCSection *Section) {
2355 Asm->OutStreamer.SwitchSection(Section);
2356 DIE *Die = FissionCU->getCUDie();
2358 // Emit the compile units header.
2359 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_begin",
2360 FissionCU->getUniqueID()));
2362 // Emit size of content not including length itself
2363 unsigned ContentSize = Die->getSize() +
2364 sizeof(int16_t) + // DWARF version number
2365 sizeof(int32_t) + // Offset Into Abbrev. Section
2366 sizeof(int8_t); // Pointer Size (in bytes)
2368 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2369 Asm->EmitInt32(ContentSize);
2370 Asm->OutStreamer.AddComment("DWARF version number");
2371 Asm->EmitInt16(dwarf::DWARF_VERSION);
2372 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2373 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2374 DwarfAbbrevSectionSym);
2375 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2376 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2379 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_end",
2380 FissionCU->getUniqueID()));
2385 // Emit the .debug_info.dwo section for fission. This contains the compile
2386 // units that would normally be in debug_info.
2387 void DwarfDebug::emitDebugInfoDWO() {
2388 assert(useDwarfFission() && "Got fission?");
2389 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoDWOSection());