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), FissionCU(0),
157 AbbreviationsSet(InitAbbreviationsSetSize),
158 SourceIdMap(DIEValueAllocator), StringPool(DIEValueAllocator),
159 PrevLabel(NULL), GlobalCUIndexCount(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 DWARF2_FLAG_IS_STMT);
1518 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1519 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1520 ScopeVariables[LS].push_back(Var);
1521 // Vars.push_back(Var);
1524 // Gather and emit post-function debug information.
1525 void DwarfDebug::endFunction(const MachineFunction *MF) {
1526 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1528 // Define end label for subprogram.
1529 FunctionEndSym = Asm->GetTempSymbol("func_end",
1530 Asm->getFunctionNumber());
1531 // Assumes in correct section after the entry point.
1532 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1534 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1535 collectVariableInfo(MF, ProcessedVars);
1537 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1538 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1539 assert(TheCU && "Unable to find compile unit!");
1541 // Construct abstract scopes.
1542 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1543 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1544 LexicalScope *AScope = AList[i];
1545 DISubprogram SP(AScope->getScopeNode());
1547 // Collect info for variables that were optimized out.
1548 DIArray Variables = SP.getVariables();
1549 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1550 DIVariable DV(Variables.getElement(i));
1551 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1553 // Check that DbgVariable for DV wasn't created earlier, when
1554 // findAbstractVariable() was called for inlined instance of DV.
1555 LLVMContext &Ctx = DV->getContext();
1556 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1557 if (AbstractVariables.lookup(CleanDV))
1559 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1560 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1563 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1564 constructScopeDIE(TheCU, AScope);
1567 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1569 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1570 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1572 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1573 MMI->getFrameMoves()));
1576 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1577 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1578 DeleteContainerPointers(I->second);
1579 ScopeVariables.clear();
1580 DeleteContainerPointers(CurrentFnArguments);
1581 UserVariables.clear();
1583 AbstractVariables.clear();
1584 LabelsBeforeInsn.clear();
1585 LabelsAfterInsn.clear();
1589 // Register a source line with debug info. Returns the unique label that was
1590 // emitted and which provides correspondence to the source line list.
1591 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1597 DIDescriptor Scope(S);
1599 if (Scope.isCompileUnit()) {
1600 DICompileUnit CU(S);
1601 Fn = CU.getFilename();
1602 Dir = CU.getDirectory();
1603 } else if (Scope.isFile()) {
1605 Fn = F.getFilename();
1606 Dir = F.getDirectory();
1607 } else if (Scope.isSubprogram()) {
1609 Fn = SP.getFilename();
1610 Dir = SP.getDirectory();
1611 } else if (Scope.isLexicalBlockFile()) {
1612 DILexicalBlockFile DBF(S);
1613 Fn = DBF.getFilename();
1614 Dir = DBF.getDirectory();
1615 } else if (Scope.isLexicalBlock()) {
1616 DILexicalBlock DB(S);
1617 Fn = DB.getFilename();
1618 Dir = DB.getDirectory();
1620 llvm_unreachable("Unexpected scope info");
1622 Src = getOrCreateSourceID(Fn, Dir);
1624 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1627 //===----------------------------------------------------------------------===//
1629 //===----------------------------------------------------------------------===//
1631 // Compute the size and offset of a DIE.
1633 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1634 // Get the children.
1635 const std::vector<DIE *> &Children = Die->getChildren();
1637 // Record the abbreviation.
1638 assignAbbrevNumber(Die->getAbbrev());
1640 // Get the abbreviation for this DIE.
1641 unsigned AbbrevNumber = Die->getAbbrevNumber();
1642 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1645 Die->setOffset(Offset);
1647 // Start the size with the size of abbreviation code.
1648 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1650 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1651 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1653 // Size the DIE attribute values.
1654 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1655 // Size attribute value.
1656 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1658 // Size the DIE children if any.
1659 if (!Children.empty()) {
1660 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1661 "Children flag not set");
1663 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1664 Offset = computeSizeAndOffset(Children[j], Offset);
1666 // End of children marker.
1667 Offset += sizeof(int8_t);
1670 Die->setSize(Offset - Die->getOffset());
1674 // Compute the size and offset of all the DIEs.
1675 void DwarfDebug::computeSizeAndOffsets() {
1678 sizeof(int32_t) + // Length of Compilation Unit Info
1679 sizeof(int16_t) + // DWARF version number
1680 sizeof(int32_t) + // Offset Into Abbrev. Section
1681 sizeof(int8_t); // Pointer Size (in bytes)
1683 computeSizeAndOffset(FissionCU->getCUDie(), Offset);
1685 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1686 E = CUMap.end(); I != E; ++I) {
1687 // Compute size of compile unit header.
1689 sizeof(int32_t) + // Length of Compilation Unit Info
1690 sizeof(int16_t) + // DWARF version number
1691 sizeof(int32_t) + // Offset Into Abbrev. Section
1692 sizeof(int8_t); // Pointer Size (in bytes)
1693 computeSizeAndOffset(I->second->getCUDie(), Offset);
1697 // Emit initial Dwarf sections with a label at the start of each one.
1698 void DwarfDebug::emitSectionLabels() {
1699 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1701 // Dwarf sections base addresses.
1702 DwarfInfoSectionSym =
1703 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1704 DwarfAbbrevSectionSym =
1705 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1706 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1708 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1709 emitSectionSym(Asm, MacroInfo);
1711 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1712 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1713 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1714 DwarfStrSectionSym =
1715 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1716 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1719 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1720 "section_debug_loc");
1722 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1723 emitSectionSym(Asm, TLOF.getDataSection());
1726 // Recursively emits a debug information entry.
1727 void DwarfDebug::emitDIE(DIE *Die) {
1728 // Get the abbreviation for this DIE.
1729 unsigned AbbrevNumber = Die->getAbbrevNumber();
1730 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1732 // Emit the code (index) for the abbreviation.
1733 if (Asm->isVerbose())
1734 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1735 Twine::utohexstr(Die->getOffset()) + ":0x" +
1736 Twine::utohexstr(Die->getSize()) + " " +
1737 dwarf::TagString(Abbrev->getTag()));
1738 Asm->EmitULEB128(AbbrevNumber);
1740 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1741 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1743 // Emit the DIE attribute values.
1744 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1745 unsigned Attr = AbbrevData[i].getAttribute();
1746 unsigned Form = AbbrevData[i].getForm();
1747 assert(Form && "Too many attributes for DIE (check abbreviation)");
1749 if (Asm->isVerbose())
1750 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1753 case dwarf::DW_AT_abstract_origin: {
1754 DIEEntry *E = cast<DIEEntry>(Values[i]);
1755 DIE *Origin = E->getEntry();
1756 unsigned Addr = Origin->getOffset();
1757 Asm->EmitInt32(Addr);
1760 case dwarf::DW_AT_ranges: {
1761 // DW_AT_range Value encodes offset in debug_range section.
1762 DIEInteger *V = cast<DIEInteger>(Values[i]);
1764 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1765 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1769 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1771 DwarfDebugRangeSectionSym,
1776 case dwarf::DW_AT_location: {
1777 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1778 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1779 Asm->EmitLabelReference(L->getValue(), 4);
1781 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1783 Values[i]->EmitValue(Asm, Form);
1787 case dwarf::DW_AT_accessibility: {
1788 if (Asm->isVerbose()) {
1789 DIEInteger *V = cast<DIEInteger>(Values[i]);
1790 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1792 Values[i]->EmitValue(Asm, Form);
1796 // Emit an attribute using the defined form.
1797 Values[i]->EmitValue(Asm, Form);
1802 // Emit the DIE children if any.
1803 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1804 const std::vector<DIE *> &Children = Die->getChildren();
1806 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1807 emitDIE(Children[j]);
1809 if (Asm->isVerbose())
1810 Asm->OutStreamer.AddComment("End Of Children Mark");
1815 void DwarfDebug::emitCompileUnits(const MCSection *Section) {
1816 Asm->OutStreamer.SwitchSection(Section);
1817 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1818 E = CUMap.end(); I != E; ++I) {
1819 CompileUnit *TheCU = I->second;
1820 DIE *Die = TheCU->getCUDie();
1822 // Emit the compile units header.
1823 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1824 TheCU->getUniqueID()));
1826 // Emit size of content not including length itself
1827 unsigned ContentSize = Die->getSize() +
1828 sizeof(int16_t) + // DWARF version number
1829 sizeof(int32_t) + // Offset Into Abbrev. Section
1830 sizeof(int8_t); // Pointer Size (in bytes)
1832 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1833 Asm->EmitInt32(ContentSize);
1834 Asm->OutStreamer.AddComment("DWARF version number");
1835 Asm->EmitInt16(dwarf::DWARF_VERSION);
1836 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1837 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1838 DwarfAbbrevSectionSym);
1839 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1840 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1843 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end",
1844 TheCU->getUniqueID()));
1848 // Emit the debug info section.
1849 void DwarfDebug::emitDebugInfo() {
1850 if (!useDwarfFission())
1851 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoSection());
1853 emitFissionSkeletonCU(Asm->getObjFileLowering().getDwarfInfoSection());
1856 // Emit the abbreviation section.
1857 void DwarfDebug::emitAbbreviations() {
1858 // Check to see if it is worth the effort.
1859 if (!Abbreviations.empty()) {
1860 // Start the debug abbrev section.
1861 Asm->OutStreamer.SwitchSection(
1862 Asm->getObjFileLowering().getDwarfAbbrevSection());
1864 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1866 // For each abbrevation.
1867 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1868 // Get abbreviation data
1869 const DIEAbbrev *Abbrev = Abbreviations[i];
1871 // Emit the abbrevations code (base 1 index.)
1872 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1874 // Emit the abbreviations data.
1878 // Mark end of abbreviations.
1879 Asm->EmitULEB128(0, "EOM(3)");
1881 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1885 // Emit the last address of the section and the end of the line matrix.
1886 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1887 // Define last address of section.
1888 Asm->OutStreamer.AddComment("Extended Op");
1891 Asm->OutStreamer.AddComment("Op size");
1892 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1893 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1894 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1896 Asm->OutStreamer.AddComment("Section end label");
1898 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1899 Asm->getDataLayout().getPointerSize(),
1902 // Mark end of matrix.
1903 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1909 // Emit visible names into a hashed accelerator table section.
1910 void DwarfDebug::emitAccelNames() {
1911 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1912 dwarf::DW_FORM_data4));
1913 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1914 E = CUMap.end(); I != E; ++I) {
1915 CompileUnit *TheCU = I->second;
1916 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1917 for (StringMap<std::vector<DIE*> >::const_iterator
1918 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1919 const char *Name = GI->getKeyData();
1920 const std::vector<DIE *> &Entities = GI->second;
1921 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1922 DE = Entities.end(); DI != DE; ++DI)
1923 AT.AddName(Name, (*DI));
1927 AT.FinalizeTable(Asm, "Names");
1928 Asm->OutStreamer.SwitchSection(
1929 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1930 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1931 Asm->OutStreamer.EmitLabel(SectionBegin);
1933 // Emit the full data.
1934 AT.Emit(Asm, SectionBegin, this);
1937 // Emit objective C classes and categories into a hashed accelerator table section.
1938 void DwarfDebug::emitAccelObjC() {
1939 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1940 dwarf::DW_FORM_data4));
1941 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1942 E = CUMap.end(); I != E; ++I) {
1943 CompileUnit *TheCU = I->second;
1944 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1945 for (StringMap<std::vector<DIE*> >::const_iterator
1946 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1947 const char *Name = GI->getKeyData();
1948 const std::vector<DIE *> &Entities = GI->second;
1949 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1950 DE = Entities.end(); DI != DE; ++DI)
1951 AT.AddName(Name, (*DI));
1955 AT.FinalizeTable(Asm, "ObjC");
1956 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1957 .getDwarfAccelObjCSection());
1958 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1959 Asm->OutStreamer.EmitLabel(SectionBegin);
1961 // Emit the full data.
1962 AT.Emit(Asm, SectionBegin, this);
1965 // Emit namespace dies into a hashed accelerator table.
1966 void DwarfDebug::emitAccelNamespaces() {
1967 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1968 dwarf::DW_FORM_data4));
1969 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1970 E = CUMap.end(); I != E; ++I) {
1971 CompileUnit *TheCU = I->second;
1972 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1973 for (StringMap<std::vector<DIE*> >::const_iterator
1974 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1975 const char *Name = GI->getKeyData();
1976 const std::vector<DIE *> &Entities = GI->second;
1977 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1978 DE = Entities.end(); DI != DE; ++DI)
1979 AT.AddName(Name, (*DI));
1983 AT.FinalizeTable(Asm, "namespac");
1984 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1985 .getDwarfAccelNamespaceSection());
1986 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1987 Asm->OutStreamer.EmitLabel(SectionBegin);
1989 // Emit the full data.
1990 AT.Emit(Asm, SectionBegin, this);
1993 // Emit type dies into a hashed accelerator table.
1994 void DwarfDebug::emitAccelTypes() {
1995 std::vector<DwarfAccelTable::Atom> Atoms;
1996 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1997 dwarf::DW_FORM_data4));
1998 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1999 dwarf::DW_FORM_data2));
2000 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2001 dwarf::DW_FORM_data1));
2002 DwarfAccelTable AT(Atoms);
2003 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2004 E = CUMap.end(); I != E; ++I) {
2005 CompileUnit *TheCU = I->second;
2006 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2007 = TheCU->getAccelTypes();
2008 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2009 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2010 const char *Name = GI->getKeyData();
2011 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2012 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2013 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2014 AT.AddName(Name, (*DI).first, (*DI).second);
2018 AT.FinalizeTable(Asm, "types");
2019 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2020 .getDwarfAccelTypesSection());
2021 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2022 Asm->OutStreamer.EmitLabel(SectionBegin);
2024 // Emit the full data.
2025 AT.Emit(Asm, SectionBegin, this);
2028 void DwarfDebug::emitDebugPubTypes() {
2029 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2030 E = CUMap.end(); I != E; ++I) {
2031 CompileUnit *TheCU = I->second;
2032 // Start the dwarf pubtypes section.
2033 Asm->OutStreamer.SwitchSection(
2034 Asm->getObjFileLowering().getDwarfPubTypesSection());
2035 Asm->OutStreamer.AddComment("Length of Public Types Info");
2036 Asm->EmitLabelDifference(
2037 Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2038 Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2040 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2041 TheCU->getUniqueID()));
2043 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2044 Asm->EmitInt16(dwarf::DWARF_VERSION);
2046 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2047 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin",
2048 TheCU->getUniqueID()),
2049 DwarfInfoSectionSym);
2051 Asm->OutStreamer.AddComment("Compilation Unit Length");
2052 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end",
2053 TheCU->getUniqueID()),
2054 Asm->GetTempSymbol("info_begin",
2055 TheCU->getUniqueID()),
2058 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2059 for (StringMap<DIE*>::const_iterator
2060 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2061 const char *Name = GI->getKeyData();
2062 DIE *Entity = GI->second;
2064 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2065 Asm->EmitInt32(Entity->getOffset());
2067 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2068 // Emit the name with a terminating null byte.
2069 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2072 Asm->OutStreamer.AddComment("End Mark");
2074 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2075 TheCU->getUniqueID()));
2079 // Emit visible names into a debug str section.
2080 void DwarfDebug::emitDebugStr() {
2081 // Check to see if it is worth the effort.
2082 if (StringPool.empty()) return;
2084 // Start the dwarf str section.
2085 Asm->OutStreamer.SwitchSection(
2086 Asm->getObjFileLowering().getDwarfStrSection());
2088 // Get all of the string pool entries and put them in an array by their ID so
2089 // we can sort them.
2090 SmallVector<std::pair<unsigned,
2091 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2093 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2094 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2095 Entries.push_back(std::make_pair(I->second.second, &*I));
2097 array_pod_sort(Entries.begin(), Entries.end());
2099 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2100 // Emit a label for reference from debug information entries.
2101 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2103 // Emit the string itself with a terminating null byte.
2104 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2105 Entries[i].second->getKeyLength()+1),
2110 // Emit visible names into a debug loc section.
2111 void DwarfDebug::emitDebugLoc() {
2112 if (DotDebugLocEntries.empty())
2115 for (SmallVector<DotDebugLocEntry, 4>::iterator
2116 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2118 DotDebugLocEntry &Entry = *I;
2119 if (I + 1 != DotDebugLocEntries.end())
2123 // Start the dwarf loc section.
2124 Asm->OutStreamer.SwitchSection(
2125 Asm->getObjFileLowering().getDwarfLocSection());
2126 unsigned char Size = Asm->getDataLayout().getPointerSize();
2127 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2129 for (SmallVector<DotDebugLocEntry, 4>::iterator
2130 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2131 I != E; ++I, ++index) {
2132 DotDebugLocEntry &Entry = *I;
2133 if (Entry.isMerged()) continue;
2134 if (Entry.isEmpty()) {
2135 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2136 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2137 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2139 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2140 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2141 DIVariable DV(Entry.Variable);
2142 Asm->OutStreamer.AddComment("Loc expr size");
2143 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2144 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2145 Asm->EmitLabelDifference(end, begin, 2);
2146 Asm->OutStreamer.EmitLabel(begin);
2147 if (Entry.isInt()) {
2148 DIBasicType BTy(DV.getType());
2150 (BTy.getEncoding() == dwarf::DW_ATE_signed
2151 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2152 Asm->OutStreamer.AddComment("DW_OP_consts");
2153 Asm->EmitInt8(dwarf::DW_OP_consts);
2154 Asm->EmitSLEB128(Entry.getInt());
2156 Asm->OutStreamer.AddComment("DW_OP_constu");
2157 Asm->EmitInt8(dwarf::DW_OP_constu);
2158 Asm->EmitULEB128(Entry.getInt());
2160 } else if (Entry.isLocation()) {
2161 if (!DV.hasComplexAddress())
2163 Asm->EmitDwarfRegOp(Entry.Loc);
2165 // Complex address entry.
2166 unsigned N = DV.getNumAddrElements();
2168 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2169 if (Entry.Loc.getOffset()) {
2171 Asm->EmitDwarfRegOp(Entry.Loc);
2172 Asm->OutStreamer.AddComment("DW_OP_deref");
2173 Asm->EmitInt8(dwarf::DW_OP_deref);
2174 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2175 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2176 Asm->EmitSLEB128(DV.getAddrElement(1));
2178 // If first address element is OpPlus then emit
2179 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2180 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2181 Asm->EmitDwarfRegOp(Loc);
2185 Asm->EmitDwarfRegOp(Entry.Loc);
2188 // Emit remaining complex address elements.
2189 for (; i < N; ++i) {
2190 uint64_t Element = DV.getAddrElement(i);
2191 if (Element == DIBuilder::OpPlus) {
2192 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2193 Asm->EmitULEB128(DV.getAddrElement(++i));
2194 } else if (Element == DIBuilder::OpDeref) {
2195 if (!Entry.Loc.isReg())
2196 Asm->EmitInt8(dwarf::DW_OP_deref);
2198 llvm_unreachable("unknown Opcode found in complex address");
2202 // else ... ignore constant fp. There is not any good way to
2203 // to represent them here in dwarf.
2204 Asm->OutStreamer.EmitLabel(end);
2209 // Emit visible names into a debug aranges section.
2210 void DwarfDebug::emitDebugARanges() {
2211 // Start the dwarf aranges section.
2212 Asm->OutStreamer.SwitchSection(
2213 Asm->getObjFileLowering().getDwarfARangesSection());
2216 // Emit visible names into a debug ranges section.
2217 void DwarfDebug::emitDebugRanges() {
2218 // Start the dwarf ranges section.
2219 Asm->OutStreamer.SwitchSection(
2220 Asm->getObjFileLowering().getDwarfRangesSection());
2221 unsigned char Size = Asm->getDataLayout().getPointerSize();
2222 for (SmallVector<const MCSymbol *, 8>::iterator
2223 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2226 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2228 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2232 // Emit visible names into a debug macinfo section.
2233 void DwarfDebug::emitDebugMacInfo() {
2234 if (const MCSection *LineInfo =
2235 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2236 // Start the dwarf macinfo section.
2237 Asm->OutStreamer.SwitchSection(LineInfo);
2241 // Emit inline info using following format.
2243 // 1. length of section
2244 // 2. Dwarf version number
2247 // Entries (one "entry" for each function that was inlined):
2249 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2250 // otherwise offset into __debug_str for regular function name.
2251 // 2. offset into __debug_str section for regular function name.
2252 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2253 // instances for the function.
2255 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2256 // inlined instance; the die_offset points to the inlined_subroutine die in the
2257 // __debug_info section, and the low_pc is the starting address for the
2258 // inlining instance.
2259 void DwarfDebug::emitDebugInlineInfo() {
2260 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2266 Asm->OutStreamer.SwitchSection(
2267 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2269 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2270 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2271 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2273 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2275 Asm->OutStreamer.AddComment("Dwarf Version");
2276 Asm->EmitInt16(dwarf::DWARF_VERSION);
2277 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2278 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2280 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2281 E = InlinedSPNodes.end(); I != E; ++I) {
2283 const MDNode *Node = *I;
2284 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2285 = InlineInfo.find(Node);
2286 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2287 DISubprogram SP(Node);
2288 StringRef LName = SP.getLinkageName();
2289 StringRef Name = SP.getName();
2291 Asm->OutStreamer.AddComment("MIPS linkage name");
2293 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2295 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2296 DwarfStrSectionSym);
2298 Asm->OutStreamer.AddComment("Function name");
2299 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2300 Asm->EmitULEB128(Labels.size(), "Inline count");
2302 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2303 LE = Labels.end(); LI != LE; ++LI) {
2304 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2305 Asm->EmitInt32(LI->second->getOffset());
2307 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2308 Asm->OutStreamer.EmitSymbolValue(LI->first,
2309 Asm->getDataLayout().getPointerSize(),0);
2313 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2316 // DWARF5 Experimental Fission emitters.
2318 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2319 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2320 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2321 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2322 CompileUnit *DwarfDebug::constructFissionCU(const MDNode *N) {
2323 DICompileUnit DIUnit(N);
2324 StringRef FN = DIUnit.getFilename();
2325 CompilationDir = DIUnit.getDirectory();
2327 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2328 CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2329 DIUnit.getLanguage(), Die, Asm, this);
2330 // FIXME: This should be the .dwo file.
2331 NewCU->addString(Die, dwarf::DW_AT_GNU_dwo_name, FN);
2333 // FIXME: We also need DW_AT_addr_base and DW_AT_dwo_id.
2335 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2337 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2338 // DW_AT_stmt_list is a offset of line number information for this
2339 // compile unit in debug_line section.
2340 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2341 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
2342 Asm->GetTempSymbol("section_line"));
2344 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
2346 if (!CompilationDir.empty())
2347 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2352 void DwarfDebug::emitFissionSkeletonCU(const MCSection *Section) {
2353 Asm->OutStreamer.SwitchSection(Section);
2354 DIE *Die = FissionCU->getCUDie();
2356 // Emit the compile units header.
2357 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_begin",
2358 FissionCU->getUniqueID()));
2360 // Emit size of content not including length itself
2361 unsigned ContentSize = Die->getSize() +
2362 sizeof(int16_t) + // DWARF version number
2363 sizeof(int32_t) + // Offset Into Abbrev. Section
2364 sizeof(int8_t); // Pointer Size (in bytes)
2366 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2367 Asm->EmitInt32(ContentSize);
2368 Asm->OutStreamer.AddComment("DWARF version number");
2369 Asm->EmitInt16(dwarf::DWARF_VERSION);
2370 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2371 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2372 DwarfAbbrevSectionSym);
2373 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2374 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2377 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_end",
2378 FissionCU->getUniqueID()));
2383 // Emit the .debug_info.dwo section for fission. This contains the compile
2384 // units that would normally be in debug_info.
2385 void DwarfDebug::emitDebugInfoDWO() {
2386 assert(useDwarfFission() && "Got fission?");
2387 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoDWOSection());