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/Constants.h"
20 #include "llvm/DebugInfo.h"
21 #include "llvm/DIBuilder.h"
22 #include "llvm/Module.h"
23 #include "llvm/Instructions.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCSection.h"
28 #include "llvm/MC/MCStreamer.h"
29 #include "llvm/MC/MCSymbol.h"
30 #include "llvm/DataLayout.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetOptions.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/ADT/Triple.h"
40 #include "llvm/Support/CommandLine.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/ValueHandle.h"
44 #include "llvm/Support/FormattedStream.h"
45 #include "llvm/Support/Timer.h"
46 #include "llvm/Support/Path.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),
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 unsigned ID = getOrCreateSourceID(FN, CompilationDir);
620 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
621 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die,
623 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
624 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
625 DIUnit.getLanguage());
626 NewCU->addString(Die, dwarf::DW_AT_name, FN);
627 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
629 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
630 // DW_AT_stmt_list is a offset of line number information for this
631 // compile unit in debug_line section.
632 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
633 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
634 Asm->GetTempSymbol("section_line"));
636 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
638 if (!CompilationDir.empty())
639 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
640 if (DIUnit.isOptimized())
641 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
643 StringRef Flags = DIUnit.getFlags();
645 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
647 if (unsigned RVer = DIUnit.getRunTimeVersion())
648 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
649 dwarf::DW_FORM_data1, RVer);
653 if (useDwarfFission() && !FissionCU)
654 FissionCU = constructFissionCU(N);
656 CUMap.insert(std::make_pair(N, NewCU));
660 // Construct subprogram DIE.
661 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
663 CompileUnit *&CURef = SPMap[N];
669 if (!SP.isDefinition())
670 // This is a method declaration which will be handled while constructing
674 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
677 TheCU->insertDIE(N, SubprogramDie);
679 // Add to context owner.
680 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
685 // Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
686 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
687 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
688 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
689 const MDNode *N = NMD->getOperand(i);
690 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
691 constructSubprogramDIE(CU, N);
694 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
695 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
696 const MDNode *N = NMD->getOperand(i);
697 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
698 CU->createGlobalVariableDIE(N);
701 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
702 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
703 DIType Ty(NMD->getOperand(i));
704 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
705 CU->getOrCreateTypeDIE(Ty);
708 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
709 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
710 DIType Ty(NMD->getOperand(i));
711 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
712 CU->getOrCreateTypeDIE(Ty);
716 // Collect debug info using DebugInfoFinder.
717 // FIXME - Remove this when dragonegg switches to DIBuilder.
718 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
719 DebugInfoFinder DbgFinder;
720 DbgFinder.processModule(*M);
722 bool HasDebugInfo = false;
723 // Scan all the compile-units to see if there are any marked as the main
724 // unit. If not, we do not generate debug info.
725 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
726 E = DbgFinder.compile_unit_end(); I != E; ++I) {
727 if (DICompileUnit(*I).isMain()) {
732 if (!HasDebugInfo) return false;
734 // Create all the compile unit DIEs.
735 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
736 E = DbgFinder.compile_unit_end(); I != E; ++I)
737 constructCompileUnit(*I);
739 // Create DIEs for each global variable.
740 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
741 E = DbgFinder.global_variable_end(); I != E; ++I) {
742 const MDNode *N = *I;
743 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
744 CU->createGlobalVariableDIE(N);
747 // Create DIEs for each subprogram.
748 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
749 E = DbgFinder.subprogram_end(); I != E; ++I) {
750 const MDNode *N = *I;
751 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
752 constructSubprogramDIE(CU, N);
758 // Emit all Dwarf sections that should come prior to the content. Create
759 // global DIEs and emit initial debug info sections. This is invoked by
760 // the target AsmPrinter.
761 void DwarfDebug::beginModule() {
762 if (DisableDebugInfoPrinting)
765 const Module *M = MMI->getModule();
767 // If module has named metadata anchors then use them, otherwise scan the
768 // module using debug info finder to collect debug info.
769 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
771 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
772 DICompileUnit CUNode(CU_Nodes->getOperand(i));
773 CompileUnit *CU = constructCompileUnit(CUNode);
774 DIArray GVs = CUNode.getGlobalVariables();
775 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
776 CU->createGlobalVariableDIE(GVs.getElement(i));
777 DIArray SPs = CUNode.getSubprograms();
778 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
779 constructSubprogramDIE(CU, SPs.getElement(i));
780 DIArray EnumTypes = CUNode.getEnumTypes();
781 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
782 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
783 DIArray RetainedTypes = CUNode.getRetainedTypes();
784 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
785 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
787 } else if (!collectLegacyDebugInfo(M))
790 collectInfoFromNamedMDNodes(M);
792 // Tell MMI that we have debug info.
793 MMI->setDebugInfoAvailability(true);
795 // Prime section data.
796 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
799 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
800 void DwarfDebug::computeInlinedDIEs() {
801 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
802 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
803 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
805 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
807 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
808 AE = AbstractSPDies.end(); AI != AE; ++AI) {
809 DIE *ISP = AI->second;
810 if (InlinedSubprogramDIEs.count(ISP))
812 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
816 // Collect info for variables that were optimized out.
817 void DwarfDebug::collectDeadVariables() {
818 const Module *M = MMI->getModule();
819 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
821 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
822 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
823 DICompileUnit TheCU(CU_Nodes->getOperand(i));
824 DIArray Subprograms = TheCU.getSubprograms();
825 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
826 DISubprogram SP(Subprograms.getElement(i));
827 if (ProcessedSPNodes.count(SP) != 0) continue;
828 if (!SP.Verify()) continue;
829 if (!SP.isDefinition()) continue;
830 DIArray Variables = SP.getVariables();
831 if (Variables.getNumElements() == 0) continue;
833 LexicalScope *Scope =
834 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
835 DeadFnScopeMap[SP] = Scope;
837 // Construct subprogram DIE and add variables DIEs.
838 CompileUnit *SPCU = CUMap.lookup(TheCU);
839 assert(SPCU && "Unable to find Compile Unit!");
840 constructSubprogramDIE(SPCU, SP);
841 DIE *ScopeDIE = SPCU->getDIE(SP);
842 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
843 DIVariable DV(Variables.getElement(vi));
844 if (!DV.Verify()) continue;
845 DbgVariable *NewVar = new DbgVariable(DV, NULL);
846 if (DIE *VariableDIE =
847 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
848 ScopeDIE->addChild(VariableDIE);
853 DeleteContainerSeconds(DeadFnScopeMap);
856 void DwarfDebug::finalizeModuleInfo() {
857 // Collect info for variables that were optimized out.
858 collectDeadVariables();
860 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
861 computeInlinedDIEs();
863 // Emit DW_AT_containing_type attribute to connect types with their
864 // vtable holding type.
865 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
866 CUE = CUMap.end(); CUI != CUE; ++CUI) {
867 CompileUnit *TheCU = CUI->second;
868 TheCU->constructContainingTypeDIEs();
871 // Compute DIE offsets and sizes.
872 computeSizeAndOffsets();
875 void DwarfDebug::endSections() {
876 // Standard sections final addresses.
877 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
878 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
879 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
880 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
882 // End text sections.
883 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
884 Asm->OutStreamer.SwitchSection(SectionMap[I]);
885 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
889 // Emit all Dwarf sections that should come after the content.
890 void DwarfDebug::endModule() {
892 if (!FirstCU) return;
894 // End any existing sections.
895 // TODO: Does this need to happen?
898 // Finalize the debug info for the module.
899 finalizeModuleInfo();
901 // Emit initial sections.
904 if (!useDwarfFission()) {
905 // Emit all the DIEs into a debug info section.
908 // Corresponding abbreviations into a abbrev section.
911 // Emit info into a debug loc section.
914 // Emit info into a debug aranges section.
917 // Emit info into a debug ranges section.
920 // Emit info into a debug macinfo section.
924 // TODO: When we don't need the option anymore we
925 // can remove all of the code that this section
927 if (useDarwinGDBCompat())
928 emitDebugInlineInfo();
930 // TODO: Fill this in for Fission sections and separate
931 // out information into new sections.
933 // Emit the debug info section and compile units.
937 // Corresponding abbreviations into a abbrev section.
940 // Emit info into a debug loc section.
943 // Emit info into a debug aranges section.
946 // Emit info into a debug ranges section.
949 // Emit info into a debug macinfo section.
953 // TODO: When we don't need the option anymore we
954 // can remove all of the code that this section
956 if (useDarwinGDBCompat())
957 emitDebugInlineInfo();
960 // Emit info into the dwarf accelerator table sections.
961 if (useDwarfAccelTables()) {
964 emitAccelNamespaces();
968 // Emit info into a debug pubtypes section.
969 // TODO: When we don't need the option anymore we can
970 // remove all of the code that adds to the table.
971 if (useDarwinGDBCompat())
974 // Finally emit string information into a string table.
979 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
980 E = CUMap.end(); I != E; ++I)
982 // Reset these for the next Module if we have one.
987 // Find abstract variable, if any, associated with Var.
988 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
990 LLVMContext &Ctx = DV->getContext();
991 // More then one inlined variable corresponds to one abstract variable.
992 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
993 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
995 return AbsDbgVariable;
997 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1001 AbsDbgVariable = new DbgVariable(Var, NULL);
1002 addScopeVariable(Scope, AbsDbgVariable);
1003 AbstractVariables[Var] = AbsDbgVariable;
1004 return AbsDbgVariable;
1007 // If Var is a current function argument then add it to CurrentFnArguments list.
1008 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1009 DbgVariable *Var, LexicalScope *Scope) {
1010 if (!LScopes.isCurrentFunctionScope(Scope))
1012 DIVariable DV = Var->getVariable();
1013 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1015 unsigned ArgNo = DV.getArgNumber();
1019 size_t Size = CurrentFnArguments.size();
1021 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1022 // llvm::Function argument size is not good indicator of how many
1023 // arguments does the function have at source level.
1025 CurrentFnArguments.resize(ArgNo * 2);
1026 CurrentFnArguments[ArgNo - 1] = Var;
1030 // Collect variable information from side table maintained by MMI.
1032 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1033 SmallPtrSet<const MDNode *, 16> &Processed) {
1034 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1035 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1036 VE = VMap.end(); VI != VE; ++VI) {
1037 const MDNode *Var = VI->first;
1039 Processed.insert(Var);
1041 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1043 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1045 // If variable scope is not found then skip this variable.
1049 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1050 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1051 RegVar->setFrameIndex(VP.first);
1052 if (!addCurrentFnArgument(MF, RegVar, Scope))
1053 addScopeVariable(Scope, RegVar);
1055 AbsDbgVariable->setFrameIndex(VP.first);
1059 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1061 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1062 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1063 return MI->getNumOperands() == 3 &&
1064 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1065 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1068 // Get .debug_loc entry for the instruction range starting at MI.
1069 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1070 const MCSymbol *FLabel,
1071 const MCSymbol *SLabel,
1072 const MachineInstr *MI) {
1073 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1075 if (MI->getNumOperands() != 3) {
1076 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1077 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1079 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1080 MachineLocation MLoc;
1081 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1082 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1084 if (MI->getOperand(0).isImm())
1085 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1086 if (MI->getOperand(0).isFPImm())
1087 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1088 if (MI->getOperand(0).isCImm())
1089 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1091 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1094 // Find variables for each lexical scope.
1096 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1097 SmallPtrSet<const MDNode *, 16> &Processed) {
1099 // collection info from MMI table.
1100 collectVariableInfoFromMMITable(MF, Processed);
1102 for (SmallVectorImpl<const MDNode*>::const_iterator
1103 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1105 const MDNode *Var = *UVI;
1106 if (Processed.count(Var))
1109 // History contains relevant DBG_VALUE instructions for Var and instructions
1111 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1112 if (History.empty())
1114 const MachineInstr *MInsn = History.front();
1117 LexicalScope *Scope = NULL;
1118 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1119 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1120 Scope = LScopes.getCurrentFunctionScope();
1122 if (DV.getVersion() <= LLVMDebugVersion9)
1123 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1125 if (MDNode *IA = DV.getInlinedAt())
1126 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1128 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1131 // If variable scope is not found then skip this variable.
1135 Processed.insert(DV);
1136 assert(MInsn->isDebugValue() && "History must begin with debug value");
1137 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1138 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1139 if (!addCurrentFnArgument(MF, RegVar, Scope))
1140 addScopeVariable(Scope, RegVar);
1142 AbsVar->setMInsn(MInsn);
1144 // Simplify ranges that are fully coalesced.
1145 if (History.size() <= 1 || (History.size() == 2 &&
1146 MInsn->isIdenticalTo(History.back()))) {
1147 RegVar->setMInsn(MInsn);
1151 // handle multiple DBG_VALUE instructions describing one variable.
1152 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1154 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1155 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1156 const MachineInstr *Begin = *HI;
1157 assert(Begin->isDebugValue() && "Invalid History entry");
1159 // Check if DBG_VALUE is truncating a range.
1160 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1161 && !Begin->getOperand(0).getReg())
1164 // Compute the range for a register location.
1165 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1166 const MCSymbol *SLabel = 0;
1169 // If Begin is the last instruction in History then its value is valid
1170 // until the end of the function.
1171 SLabel = FunctionEndSym;
1173 const MachineInstr *End = HI[1];
1174 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1175 << "\t" << *Begin << "\t" << *End << "\n");
1176 if (End->isDebugValue())
1177 SLabel = getLabelBeforeInsn(End);
1179 // End is a normal instruction clobbering the range.
1180 SLabel = getLabelAfterInsn(End);
1181 assert(SLabel && "Forgot label after clobber instruction");
1186 // The value is valid until the next DBG_VALUE or clobber.
1187 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1190 DotDebugLocEntries.push_back(DotDebugLocEntry());
1193 // Collect info for variables that were optimized out.
1194 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1195 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1196 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1197 DIVariable DV(Variables.getElement(i));
1198 if (!DV || !DV.Verify() || !Processed.insert(DV))
1200 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1201 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1205 // Return Label preceding the instruction.
1206 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1207 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1208 assert(Label && "Didn't insert label before instruction");
1212 // Return Label immediately following the instruction.
1213 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1214 return LabelsAfterInsn.lookup(MI);
1217 // Process beginning of an instruction.
1218 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1219 // Check if source location changes, but ignore DBG_VALUE locations.
1220 if (!MI->isDebugValue()) {
1221 DebugLoc DL = MI->getDebugLoc();
1222 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1225 if (DL == PrologEndLoc) {
1226 Flags |= DWARF2_FLAG_PROLOGUE_END;
1227 PrologEndLoc = DebugLoc();
1229 if (PrologEndLoc.isUnknown())
1230 Flags |= DWARF2_FLAG_IS_STMT;
1232 if (!DL.isUnknown()) {
1233 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1234 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1236 recordSourceLine(0, 0, 0, 0);
1240 // Insert labels where requested.
1241 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1242 LabelsBeforeInsn.find(MI);
1245 if (I == LabelsBeforeInsn.end())
1248 // Label already assigned.
1253 PrevLabel = MMI->getContext().CreateTempSymbol();
1254 Asm->OutStreamer.EmitLabel(PrevLabel);
1256 I->second = PrevLabel;
1259 // Process end of an instruction.
1260 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1261 // Don't create a new label after DBG_VALUE instructions.
1262 // They don't generate code.
1263 if (!MI->isDebugValue())
1266 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1267 LabelsAfterInsn.find(MI);
1270 if (I == LabelsAfterInsn.end())
1273 // Label already assigned.
1277 // We need a label after this instruction.
1279 PrevLabel = MMI->getContext().CreateTempSymbol();
1280 Asm->OutStreamer.EmitLabel(PrevLabel);
1282 I->second = PrevLabel;
1285 // Each LexicalScope has first instruction and last instruction to mark
1286 // beginning and end of a scope respectively. Create an inverse map that list
1287 // scopes starts (and ends) with an instruction. One instruction may start (or
1288 // end) multiple scopes. Ignore scopes that are not reachable.
1289 void DwarfDebug::identifyScopeMarkers() {
1290 SmallVector<LexicalScope *, 4> WorkList;
1291 WorkList.push_back(LScopes.getCurrentFunctionScope());
1292 while (!WorkList.empty()) {
1293 LexicalScope *S = WorkList.pop_back_val();
1295 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1296 if (!Children.empty())
1297 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1298 SE = Children.end(); SI != SE; ++SI)
1299 WorkList.push_back(*SI);
1301 if (S->isAbstractScope())
1304 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1307 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1308 RE = Ranges.end(); RI != RE; ++RI) {
1309 assert(RI->first && "InsnRange does not have first instruction!");
1310 assert(RI->second && "InsnRange does not have second instruction!");
1311 requestLabelBeforeInsn(RI->first);
1312 requestLabelAfterInsn(RI->second);
1317 // Get MDNode for DebugLoc's scope.
1318 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1319 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1320 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1321 return DL.getScope(Ctx);
1324 // Walk up the scope chain of given debug loc and find line number info
1325 // for the function.
1326 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1327 const MDNode *Scope = getScopeNode(DL, Ctx);
1328 DISubprogram SP = getDISubprogram(Scope);
1330 // Check for number of operands since the compatibility is
1332 if (SP->getNumOperands() > 19)
1333 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1335 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1341 // Gather pre-function debug information. Assumes being called immediately
1342 // after the function entry point has been emitted.
1343 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1344 if (!MMI->hasDebugInfo()) return;
1345 LScopes.initialize(*MF);
1346 if (LScopes.empty()) return;
1347 identifyScopeMarkers();
1349 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1350 Asm->getFunctionNumber());
1351 // Assumes in correct section after the entry point.
1352 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1354 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1356 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1357 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1358 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1360 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1362 bool AtBlockEntry = true;
1363 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1365 const MachineInstr *MI = II;
1367 if (MI->isDebugValue()) {
1368 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1370 // Keep track of user variables.
1372 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1374 // Variable is in a register, we need to check for clobbers.
1375 if (isDbgValueInDefinedReg(MI))
1376 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1378 // Check the history of this variable.
1379 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1380 if (History.empty()) {
1381 UserVariables.push_back(Var);
1382 // The first mention of a function argument gets the FunctionBeginSym
1383 // label, so arguments are visible when breaking at function entry.
1385 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1386 DISubprogram(getDISubprogram(DV.getContext()))
1387 .describes(MF->getFunction()))
1388 LabelsBeforeInsn[MI] = FunctionBeginSym;
1390 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1391 const MachineInstr *Prev = History.back();
1392 if (Prev->isDebugValue()) {
1393 // Coalesce identical entries at the end of History.
1394 if (History.size() >= 2 &&
1395 Prev->isIdenticalTo(History[History.size() - 2])) {
1396 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1398 << "\t" << *History[History.size() - 2] << "\n");
1402 // Terminate old register assignments that don't reach MI;
1403 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1404 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1405 isDbgValueInDefinedReg(Prev)) {
1406 // Previous register assignment needs to terminate at the end of
1408 MachineBasicBlock::const_iterator LastMI =
1409 PrevMBB->getLastNonDebugInstr();
1410 if (LastMI == PrevMBB->end()) {
1411 // Drop DBG_VALUE for empty range.
1412 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1413 << "\t" << *Prev << "\n");
1417 // Terminate after LastMI.
1418 History.push_back(LastMI);
1423 History.push_back(MI);
1425 // Not a DBG_VALUE instruction.
1427 AtBlockEntry = false;
1429 // First known non-DBG_VALUE and non-frame setup location marks
1430 // the beginning of the function body.
1431 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1432 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1433 PrologEndLoc = MI->getDebugLoc();
1435 // Check if the instruction clobbers any registers with debug vars.
1436 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1437 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1438 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1440 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1441 AI.isValid(); ++AI) {
1443 const MDNode *Var = LiveUserVar[Reg];
1446 // Reg is now clobbered.
1447 LiveUserVar[Reg] = 0;
1449 // Was MD last defined by a DBG_VALUE referring to Reg?
1450 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1451 if (HistI == DbgValues.end())
1453 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1454 if (History.empty())
1456 const MachineInstr *Prev = History.back();
1457 // Sanity-check: Register assignments are terminated at the end of
1459 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1461 // Is the variable still in Reg?
1462 if (!isDbgValueInDefinedReg(Prev) ||
1463 Prev->getOperand(0).getReg() != Reg)
1465 // Var is clobbered. Make sure the next instruction gets a label.
1466 History.push_back(MI);
1473 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1475 SmallVectorImpl<const MachineInstr*> &History = I->second;
1476 if (History.empty())
1479 // Make sure the final register assignments are terminated.
1480 const MachineInstr *Prev = History.back();
1481 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1482 const MachineBasicBlock *PrevMBB = Prev->getParent();
1483 MachineBasicBlock::const_iterator LastMI =
1484 PrevMBB->getLastNonDebugInstr();
1485 if (LastMI == PrevMBB->end())
1486 // Drop DBG_VALUE for empty range.
1489 // Terminate after LastMI.
1490 History.push_back(LastMI);
1493 // Request labels for the full history.
1494 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1495 const MachineInstr *MI = History[i];
1496 if (MI->isDebugValue())
1497 requestLabelBeforeInsn(MI);
1499 requestLabelAfterInsn(MI);
1503 PrevInstLoc = DebugLoc();
1504 PrevLabel = FunctionBeginSym;
1506 // Record beginning of function.
1507 if (!PrologEndLoc.isUnknown()) {
1508 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1509 MF->getFunction()->getContext());
1510 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1511 FnStartDL.getScope(MF->getFunction()->getContext()),
1516 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1517 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1518 ScopeVariables[LS].push_back(Var);
1519 // Vars.push_back(Var);
1522 // Gather and emit post-function debug information.
1523 void DwarfDebug::endFunction(const MachineFunction *MF) {
1524 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1526 // Define end label for subprogram.
1527 FunctionEndSym = Asm->GetTempSymbol("func_end",
1528 Asm->getFunctionNumber());
1529 // Assumes in correct section after the entry point.
1530 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1532 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1533 collectVariableInfo(MF, ProcessedVars);
1535 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1536 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1537 assert(TheCU && "Unable to find compile unit!");
1539 // Construct abstract scopes.
1540 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1541 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1542 LexicalScope *AScope = AList[i];
1543 DISubprogram SP(AScope->getScopeNode());
1545 // Collect info for variables that were optimized out.
1546 DIArray Variables = SP.getVariables();
1547 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1548 DIVariable DV(Variables.getElement(i));
1549 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1551 // Check that DbgVariable for DV wasn't created earlier, when
1552 // findAbstractVariable() was called for inlined instance of DV.
1553 LLVMContext &Ctx = DV->getContext();
1554 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1555 if (AbstractVariables.lookup(CleanDV))
1557 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1558 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1561 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1562 constructScopeDIE(TheCU, AScope);
1565 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1567 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1568 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1570 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1571 MMI->getFrameMoves()));
1574 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1575 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1576 DeleteContainerPointers(I->second);
1577 ScopeVariables.clear();
1578 DeleteContainerPointers(CurrentFnArguments);
1579 UserVariables.clear();
1581 AbstractVariables.clear();
1582 LabelsBeforeInsn.clear();
1583 LabelsAfterInsn.clear();
1587 // Register a source line with debug info. Returns the unique label that was
1588 // emitted and which provides correspondence to the source line list.
1589 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1595 DIDescriptor Scope(S);
1597 if (Scope.isCompileUnit()) {
1598 DICompileUnit CU(S);
1599 Fn = CU.getFilename();
1600 Dir = CU.getDirectory();
1601 } else if (Scope.isFile()) {
1603 Fn = F.getFilename();
1604 Dir = F.getDirectory();
1605 } else if (Scope.isSubprogram()) {
1607 Fn = SP.getFilename();
1608 Dir = SP.getDirectory();
1609 } else if (Scope.isLexicalBlockFile()) {
1610 DILexicalBlockFile DBF(S);
1611 Fn = DBF.getFilename();
1612 Dir = DBF.getDirectory();
1613 } else if (Scope.isLexicalBlock()) {
1614 DILexicalBlock DB(S);
1615 Fn = DB.getFilename();
1616 Dir = DB.getDirectory();
1618 llvm_unreachable("Unexpected scope info");
1620 Src = getOrCreateSourceID(Fn, Dir);
1622 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1625 //===----------------------------------------------------------------------===//
1627 //===----------------------------------------------------------------------===//
1629 // Compute the size and offset of a DIE.
1631 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1632 // Get the children.
1633 const std::vector<DIE *> &Children = Die->getChildren();
1635 // Record the abbreviation.
1636 assignAbbrevNumber(Die->getAbbrev());
1638 // Get the abbreviation for this DIE.
1639 unsigned AbbrevNumber = Die->getAbbrevNumber();
1640 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1643 Die->setOffset(Offset);
1645 // Start the size with the size of abbreviation code.
1646 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1648 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1649 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1651 // Size the DIE attribute values.
1652 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1653 // Size attribute value.
1654 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1656 // Size the DIE children if any.
1657 if (!Children.empty()) {
1658 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1659 "Children flag not set");
1661 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1662 Offset = computeSizeAndOffset(Children[j], Offset);
1664 // End of children marker.
1665 Offset += sizeof(int8_t);
1668 Die->setSize(Offset - Die->getOffset());
1672 // Compute the size and offset of all the DIEs.
1673 void DwarfDebug::computeSizeAndOffsets() {
1676 sizeof(int32_t) + // Length of Compilation Unit Info
1677 sizeof(int16_t) + // DWARF version number
1678 sizeof(int32_t) + // Offset Into Abbrev. Section
1679 sizeof(int8_t); // Pointer Size (in bytes)
1681 computeSizeAndOffset(FissionCU->getCUDie(), Offset);
1683 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1684 E = CUMap.end(); I != E; ++I) {
1685 // Compute size of compile unit header.
1687 sizeof(int32_t) + // Length of Compilation Unit Info
1688 sizeof(int16_t) + // DWARF version number
1689 sizeof(int32_t) + // Offset Into Abbrev. Section
1690 sizeof(int8_t); // Pointer Size (in bytes)
1691 computeSizeAndOffset(I->second->getCUDie(), Offset);
1695 // Emit initial Dwarf sections with a label at the start of each one.
1696 void DwarfDebug::emitSectionLabels() {
1697 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1699 // Dwarf sections base addresses.
1700 DwarfInfoSectionSym =
1701 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1702 DwarfAbbrevSectionSym =
1703 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1704 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1706 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1707 emitSectionSym(Asm, MacroInfo);
1709 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1710 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1711 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1712 DwarfStrSectionSym =
1713 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1714 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1717 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1718 "section_debug_loc");
1720 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1721 emitSectionSym(Asm, TLOF.getDataSection());
1724 // Recursively emits a debug information entry.
1725 void DwarfDebug::emitDIE(DIE *Die) {
1726 // Get the abbreviation for this DIE.
1727 unsigned AbbrevNumber = Die->getAbbrevNumber();
1728 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1730 // Emit the code (index) for the abbreviation.
1731 if (Asm->isVerbose())
1732 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1733 Twine::utohexstr(Die->getOffset()) + ":0x" +
1734 Twine::utohexstr(Die->getSize()) + " " +
1735 dwarf::TagString(Abbrev->getTag()));
1736 Asm->EmitULEB128(AbbrevNumber);
1738 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1739 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1741 // Emit the DIE attribute values.
1742 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1743 unsigned Attr = AbbrevData[i].getAttribute();
1744 unsigned Form = AbbrevData[i].getForm();
1745 assert(Form && "Too many attributes for DIE (check abbreviation)");
1747 if (Asm->isVerbose())
1748 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1751 case dwarf::DW_AT_abstract_origin: {
1752 DIEEntry *E = cast<DIEEntry>(Values[i]);
1753 DIE *Origin = E->getEntry();
1754 unsigned Addr = Origin->getOffset();
1755 Asm->EmitInt32(Addr);
1758 case dwarf::DW_AT_ranges: {
1759 // DW_AT_range Value encodes offset in debug_range section.
1760 DIEInteger *V = cast<DIEInteger>(Values[i]);
1762 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1763 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1767 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1769 DwarfDebugRangeSectionSym,
1774 case dwarf::DW_AT_location: {
1775 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1776 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1777 Asm->EmitLabelReference(L->getValue(), 4);
1779 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1781 Values[i]->EmitValue(Asm, Form);
1785 case dwarf::DW_AT_accessibility: {
1786 if (Asm->isVerbose()) {
1787 DIEInteger *V = cast<DIEInteger>(Values[i]);
1788 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1790 Values[i]->EmitValue(Asm, Form);
1794 // Emit an attribute using the defined form.
1795 Values[i]->EmitValue(Asm, Form);
1800 // Emit the DIE children if any.
1801 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1802 const std::vector<DIE *> &Children = Die->getChildren();
1804 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1805 emitDIE(Children[j]);
1807 if (Asm->isVerbose())
1808 Asm->OutStreamer.AddComment("End Of Children Mark");
1813 void DwarfDebug::emitCompileUnits(const MCSection *Section) {
1814 Asm->OutStreamer.SwitchSection(Section);
1815 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1816 E = CUMap.end(); I != E; ++I) {
1817 CompileUnit *TheCU = I->second;
1818 DIE *Die = TheCU->getCUDie();
1820 // Emit the compile units header.
1821 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1824 // Emit size of content not including length itself
1825 unsigned ContentSize = Die->getSize() +
1826 sizeof(int16_t) + // DWARF version number
1827 sizeof(int32_t) + // Offset Into Abbrev. Section
1828 sizeof(int8_t); // Pointer Size (in bytes)
1830 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1831 Asm->EmitInt32(ContentSize);
1832 Asm->OutStreamer.AddComment("DWARF version number");
1833 Asm->EmitInt16(dwarf::DWARF_VERSION);
1834 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1835 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1836 DwarfAbbrevSectionSym);
1837 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1838 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1841 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1845 // Emit the debug info section.
1846 void DwarfDebug::emitDebugInfo() {
1847 if (!useDwarfFission())
1848 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoSection());
1850 emitFissionSkeletonCU(Asm->getObjFileLowering().getDwarfInfoSection());
1853 // Emit the abbreviation section.
1854 void DwarfDebug::emitAbbreviations() {
1855 // Check to see if it is worth the effort.
1856 if (!Abbreviations.empty()) {
1857 // Start the debug abbrev section.
1858 Asm->OutStreamer.SwitchSection(
1859 Asm->getObjFileLowering().getDwarfAbbrevSection());
1861 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1863 // For each abbrevation.
1864 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1865 // Get abbreviation data
1866 const DIEAbbrev *Abbrev = Abbreviations[i];
1868 // Emit the abbrevations code (base 1 index.)
1869 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1871 // Emit the abbreviations data.
1875 // Mark end of abbreviations.
1876 Asm->EmitULEB128(0, "EOM(3)");
1878 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1882 // Emit the last address of the section and the end of the line matrix.
1883 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1884 // Define last address of section.
1885 Asm->OutStreamer.AddComment("Extended Op");
1888 Asm->OutStreamer.AddComment("Op size");
1889 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1890 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1891 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1893 Asm->OutStreamer.AddComment("Section end label");
1895 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1896 Asm->getDataLayout().getPointerSize(),
1899 // Mark end of matrix.
1900 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1906 // Emit visible names into a hashed accelerator table section.
1907 void DwarfDebug::emitAccelNames() {
1908 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1909 dwarf::DW_FORM_data4));
1910 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1911 E = CUMap.end(); I != E; ++I) {
1912 CompileUnit *TheCU = I->second;
1913 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1914 for (StringMap<std::vector<DIE*> >::const_iterator
1915 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1916 const char *Name = GI->getKeyData();
1917 const std::vector<DIE *> &Entities = GI->second;
1918 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1919 DE = Entities.end(); DI != DE; ++DI)
1920 AT.AddName(Name, (*DI));
1924 AT.FinalizeTable(Asm, "Names");
1925 Asm->OutStreamer.SwitchSection(
1926 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1927 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1928 Asm->OutStreamer.EmitLabel(SectionBegin);
1930 // Emit the full data.
1931 AT.Emit(Asm, SectionBegin, this);
1934 // Emit objective C classes and categories into a hashed accelerator table section.
1935 void DwarfDebug::emitAccelObjC() {
1936 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1937 dwarf::DW_FORM_data4));
1938 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1939 E = CUMap.end(); I != E; ++I) {
1940 CompileUnit *TheCU = I->second;
1941 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1942 for (StringMap<std::vector<DIE*> >::const_iterator
1943 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1944 const char *Name = GI->getKeyData();
1945 const std::vector<DIE *> &Entities = GI->second;
1946 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1947 DE = Entities.end(); DI != DE; ++DI)
1948 AT.AddName(Name, (*DI));
1952 AT.FinalizeTable(Asm, "ObjC");
1953 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1954 .getDwarfAccelObjCSection());
1955 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1956 Asm->OutStreamer.EmitLabel(SectionBegin);
1958 // Emit the full data.
1959 AT.Emit(Asm, SectionBegin, this);
1962 // Emit namespace dies into a hashed accelerator table.
1963 void DwarfDebug::emitAccelNamespaces() {
1964 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1965 dwarf::DW_FORM_data4));
1966 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1967 E = CUMap.end(); I != E; ++I) {
1968 CompileUnit *TheCU = I->second;
1969 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1970 for (StringMap<std::vector<DIE*> >::const_iterator
1971 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1972 const char *Name = GI->getKeyData();
1973 const std::vector<DIE *> &Entities = GI->second;
1974 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1975 DE = Entities.end(); DI != DE; ++DI)
1976 AT.AddName(Name, (*DI));
1980 AT.FinalizeTable(Asm, "namespac");
1981 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1982 .getDwarfAccelNamespaceSection());
1983 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1984 Asm->OutStreamer.EmitLabel(SectionBegin);
1986 // Emit the full data.
1987 AT.Emit(Asm, SectionBegin, this);
1990 // Emit type dies into a hashed accelerator table.
1991 void DwarfDebug::emitAccelTypes() {
1992 std::vector<DwarfAccelTable::Atom> Atoms;
1993 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1994 dwarf::DW_FORM_data4));
1995 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1996 dwarf::DW_FORM_data2));
1997 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1998 dwarf::DW_FORM_data1));
1999 DwarfAccelTable AT(Atoms);
2000 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2001 E = CUMap.end(); I != E; ++I) {
2002 CompileUnit *TheCU = I->second;
2003 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2004 = TheCU->getAccelTypes();
2005 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2006 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2007 const char *Name = GI->getKeyData();
2008 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2009 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2010 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2011 AT.AddName(Name, (*DI).first, (*DI).second);
2015 AT.FinalizeTable(Asm, "types");
2016 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2017 .getDwarfAccelTypesSection());
2018 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2019 Asm->OutStreamer.EmitLabel(SectionBegin);
2021 // Emit the full data.
2022 AT.Emit(Asm, SectionBegin, this);
2025 void DwarfDebug::emitDebugPubTypes() {
2026 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2027 E = CUMap.end(); I != E; ++I) {
2028 CompileUnit *TheCU = I->second;
2029 // Start the dwarf pubtypes section.
2030 Asm->OutStreamer.SwitchSection(
2031 Asm->getObjFileLowering().getDwarfPubTypesSection());
2032 Asm->OutStreamer.AddComment("Length of Public Types Info");
2033 Asm->EmitLabelDifference(
2034 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2035 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2037 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2040 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2041 Asm->EmitInt16(dwarf::DWARF_VERSION);
2043 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2044 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2045 DwarfInfoSectionSym);
2047 Asm->OutStreamer.AddComment("Compilation Unit Length");
2048 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2049 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2052 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2053 for (StringMap<DIE*>::const_iterator
2054 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2055 const char *Name = GI->getKeyData();
2056 DIE *Entity = GI->second;
2058 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2059 Asm->EmitInt32(Entity->getOffset());
2061 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2062 // Emit the name with a terminating null byte.
2063 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2066 Asm->OutStreamer.AddComment("End Mark");
2068 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2073 // Emit visible names into a debug str section.
2074 void DwarfDebug::emitDebugStr() {
2075 // Check to see if it is worth the effort.
2076 if (StringPool.empty()) return;
2078 // Start the dwarf str section.
2079 Asm->OutStreamer.SwitchSection(
2080 Asm->getObjFileLowering().getDwarfStrSection());
2082 // Get all of the string pool entries and put them in an array by their ID so
2083 // we can sort them.
2084 SmallVector<std::pair<unsigned,
2085 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2087 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2088 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2089 Entries.push_back(std::make_pair(I->second.second, &*I));
2091 array_pod_sort(Entries.begin(), Entries.end());
2093 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2094 // Emit a label for reference from debug information entries.
2095 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2097 // Emit the string itself with a terminating null byte.
2098 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2099 Entries[i].second->getKeyLength()+1),
2104 // Emit visible names into a debug loc section.
2105 void DwarfDebug::emitDebugLoc() {
2106 if (DotDebugLocEntries.empty())
2109 for (SmallVector<DotDebugLocEntry, 4>::iterator
2110 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2112 DotDebugLocEntry &Entry = *I;
2113 if (I + 1 != DotDebugLocEntries.end())
2117 // Start the dwarf loc section.
2118 Asm->OutStreamer.SwitchSection(
2119 Asm->getObjFileLowering().getDwarfLocSection());
2120 unsigned char Size = Asm->getDataLayout().getPointerSize();
2121 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2123 for (SmallVector<DotDebugLocEntry, 4>::iterator
2124 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2125 I != E; ++I, ++index) {
2126 DotDebugLocEntry &Entry = *I;
2127 if (Entry.isMerged()) continue;
2128 if (Entry.isEmpty()) {
2129 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2130 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2131 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2133 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2134 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2135 DIVariable DV(Entry.Variable);
2136 Asm->OutStreamer.AddComment("Loc expr size");
2137 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2138 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2139 Asm->EmitLabelDifference(end, begin, 2);
2140 Asm->OutStreamer.EmitLabel(begin);
2141 if (Entry.isInt()) {
2142 DIBasicType BTy(DV.getType());
2144 (BTy.getEncoding() == dwarf::DW_ATE_signed
2145 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2146 Asm->OutStreamer.AddComment("DW_OP_consts");
2147 Asm->EmitInt8(dwarf::DW_OP_consts);
2148 Asm->EmitSLEB128(Entry.getInt());
2150 Asm->OutStreamer.AddComment("DW_OP_constu");
2151 Asm->EmitInt8(dwarf::DW_OP_constu);
2152 Asm->EmitULEB128(Entry.getInt());
2154 } else if (Entry.isLocation()) {
2155 if (!DV.hasComplexAddress())
2157 Asm->EmitDwarfRegOp(Entry.Loc);
2159 // Complex address entry.
2160 unsigned N = DV.getNumAddrElements();
2162 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2163 if (Entry.Loc.getOffset()) {
2165 Asm->EmitDwarfRegOp(Entry.Loc);
2166 Asm->OutStreamer.AddComment("DW_OP_deref");
2167 Asm->EmitInt8(dwarf::DW_OP_deref);
2168 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2169 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2170 Asm->EmitSLEB128(DV.getAddrElement(1));
2172 // If first address element is OpPlus then emit
2173 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2174 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2175 Asm->EmitDwarfRegOp(Loc);
2179 Asm->EmitDwarfRegOp(Entry.Loc);
2182 // Emit remaining complex address elements.
2183 for (; i < N; ++i) {
2184 uint64_t Element = DV.getAddrElement(i);
2185 if (Element == DIBuilder::OpPlus) {
2186 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2187 Asm->EmitULEB128(DV.getAddrElement(++i));
2188 } else if (Element == DIBuilder::OpDeref) {
2189 if (!Entry.Loc.isReg())
2190 Asm->EmitInt8(dwarf::DW_OP_deref);
2192 llvm_unreachable("unknown Opcode found in complex address");
2196 // else ... ignore constant fp. There is not any good way to
2197 // to represent them here in dwarf.
2198 Asm->OutStreamer.EmitLabel(end);
2203 // Emit visible names into a debug aranges section.
2204 void DwarfDebug::emitDebugARanges() {
2205 // Start the dwarf aranges section.
2206 Asm->OutStreamer.SwitchSection(
2207 Asm->getObjFileLowering().getDwarfARangesSection());
2210 // Emit visible names into a debug ranges section.
2211 void DwarfDebug::emitDebugRanges() {
2212 // Start the dwarf ranges section.
2213 Asm->OutStreamer.SwitchSection(
2214 Asm->getObjFileLowering().getDwarfRangesSection());
2215 unsigned char Size = Asm->getDataLayout().getPointerSize();
2216 for (SmallVector<const MCSymbol *, 8>::iterator
2217 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2220 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2222 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2226 // Emit visible names into a debug macinfo section.
2227 void DwarfDebug::emitDebugMacInfo() {
2228 if (const MCSection *LineInfo =
2229 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2230 // Start the dwarf macinfo section.
2231 Asm->OutStreamer.SwitchSection(LineInfo);
2235 // Emit inline info using following format.
2237 // 1. length of section
2238 // 2. Dwarf version number
2241 // Entries (one "entry" for each function that was inlined):
2243 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2244 // otherwise offset into __debug_str for regular function name.
2245 // 2. offset into __debug_str section for regular function name.
2246 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2247 // instances for the function.
2249 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2250 // inlined instance; the die_offset points to the inlined_subroutine die in the
2251 // __debug_info section, and the low_pc is the starting address for the
2252 // inlining instance.
2253 void DwarfDebug::emitDebugInlineInfo() {
2254 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2260 Asm->OutStreamer.SwitchSection(
2261 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2263 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2264 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2265 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2267 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2269 Asm->OutStreamer.AddComment("Dwarf Version");
2270 Asm->EmitInt16(dwarf::DWARF_VERSION);
2271 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2272 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2274 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2275 E = InlinedSPNodes.end(); I != E; ++I) {
2277 const MDNode *Node = *I;
2278 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2279 = InlineInfo.find(Node);
2280 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2281 DISubprogram SP(Node);
2282 StringRef LName = SP.getLinkageName();
2283 StringRef Name = SP.getName();
2285 Asm->OutStreamer.AddComment("MIPS linkage name");
2287 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2289 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2290 DwarfStrSectionSym);
2292 Asm->OutStreamer.AddComment("Function name");
2293 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2294 Asm->EmitULEB128(Labels.size(), "Inline count");
2296 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2297 LE = Labels.end(); LI != LE; ++LI) {
2298 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2299 Asm->EmitInt32(LI->second->getOffset());
2301 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2302 Asm->OutStreamer.EmitSymbolValue(LI->first,
2303 Asm->getDataLayout().getPointerSize(),0);
2307 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2310 // DWARF5 Experimental Fission emitters.
2312 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2313 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2314 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2315 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2316 CompileUnit *DwarfDebug::constructFissionCU(const MDNode *N) {
2317 DICompileUnit DIUnit(N);
2318 StringRef FN = DIUnit.getFilename();
2319 CompilationDir = DIUnit.getDirectory();
2320 unsigned ID = getOrCreateSourceID(FN, CompilationDir);
2322 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2323 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die,
2325 // FIXME: This should be the .dwo file.
2326 NewCU->addString(Die, dwarf::DW_AT_GNU_dwo_name, FN);
2328 // FIXME: We also need DW_AT_addr_base and DW_AT_dwo_id.
2330 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2332 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2333 // DW_AT_stmt_list is a offset of line number information for this
2334 // compile unit in debug_line section.
2335 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2336 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
2337 Asm->GetTempSymbol("section_line"));
2339 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
2341 if (!CompilationDir.empty())
2342 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2347 void DwarfDebug::emitFissionSkeletonCU(const MCSection *Section) {
2348 Asm->OutStreamer.SwitchSection(Section);
2349 DIE *Die = FissionCU->getCUDie();
2351 // Emit the compile units header.
2352 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_begin",
2353 FissionCU->getID()));
2355 // Emit size of content not including length itself
2356 unsigned ContentSize = Die->getSize() +
2357 sizeof(int16_t) + // DWARF version number
2358 sizeof(int32_t) + // Offset Into Abbrev. Section
2359 sizeof(int8_t); // Pointer Size (in bytes)
2361 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2362 Asm->EmitInt32(ContentSize);
2363 Asm->OutStreamer.AddComment("DWARF version number");
2364 Asm->EmitInt16(dwarf::DWARF_VERSION);
2365 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2366 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2367 DwarfAbbrevSectionSym);
2368 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2369 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2372 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("skel_info_end", FissionCU->getID()));
2377 // Emit the .debug_info.dwo section for fission. This contains the compile
2378 // units that would normally be in debug_info.
2379 void DwarfDebug::emitDebugInfoDWO() {
2380 assert(useDwarfFission() && "Got fission?");
2381 emitCompileUnits(Asm->getObjFileLowering().getDwarfInfoDWOSection());