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),
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 CUMap.insert(std::make_pair(N, NewCU));
657 // Construct subprogram DIE.
658 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
660 CompileUnit *&CURef = SPMap[N];
666 if (!SP.isDefinition())
667 // This is a method declaration which will be handled while constructing
671 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
674 TheCU->insertDIE(N, SubprogramDie);
676 // Add to context owner.
677 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
682 // Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
683 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
684 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
685 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
686 const MDNode *N = NMD->getOperand(i);
687 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
688 constructSubprogramDIE(CU, N);
691 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
692 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
693 const MDNode *N = NMD->getOperand(i);
694 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
695 CU->createGlobalVariableDIE(N);
698 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
699 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
700 DIType Ty(NMD->getOperand(i));
701 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
702 CU->getOrCreateTypeDIE(Ty);
705 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
706 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
707 DIType Ty(NMD->getOperand(i));
708 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
709 CU->getOrCreateTypeDIE(Ty);
713 // Collect debug info using DebugInfoFinder.
714 // FIXME - Remove this when dragonegg switches to DIBuilder.
715 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
716 DebugInfoFinder DbgFinder;
717 DbgFinder.processModule(*M);
719 bool HasDebugInfo = false;
720 // Scan all the compile-units to see if there are any marked as the main
721 // unit. If not, we do not generate debug info.
722 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
723 E = DbgFinder.compile_unit_end(); I != E; ++I) {
724 if (DICompileUnit(*I).isMain()) {
729 if (!HasDebugInfo) return false;
731 // Create all the compile unit DIEs.
732 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
733 E = DbgFinder.compile_unit_end(); I != E; ++I)
734 constructCompileUnit(*I);
736 // Create DIEs for each global variable.
737 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
738 E = DbgFinder.global_variable_end(); I != E; ++I) {
739 const MDNode *N = *I;
740 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
741 CU->createGlobalVariableDIE(N);
744 // Create DIEs for each subprogram.
745 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
746 E = DbgFinder.subprogram_end(); I != E; ++I) {
747 const MDNode *N = *I;
748 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
749 constructSubprogramDIE(CU, N);
755 // Emit all Dwarf sections that should come prior to the content. Create
756 // global DIEs and emit initial debug info sections. This is invoked by
757 // the target AsmPrinter.
758 void DwarfDebug::beginModule() {
759 if (DisableDebugInfoPrinting)
762 const Module *M = MMI->getModule();
764 // If module has named metadata anchors then use them, otherwise scan the
765 // module using debug info finder to collect debug info.
766 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
768 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
769 DICompileUnit CUNode(CU_Nodes->getOperand(i));
770 CompileUnit *CU = constructCompileUnit(CUNode);
771 DIArray GVs = CUNode.getGlobalVariables();
772 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
773 CU->createGlobalVariableDIE(GVs.getElement(i));
774 DIArray SPs = CUNode.getSubprograms();
775 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
776 constructSubprogramDIE(CU, SPs.getElement(i));
777 DIArray EnumTypes = CUNode.getEnumTypes();
778 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
779 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
780 DIArray RetainedTypes = CUNode.getRetainedTypes();
781 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
782 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
784 } else if (!collectLegacyDebugInfo(M))
787 collectInfoFromNamedMDNodes(M);
789 // Tell MMI that we have debug info.
790 MMI->setDebugInfoAvailability(true);
792 // Prime section data.
793 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
796 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
797 void DwarfDebug::computeInlinedDIEs() {
798 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
799 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
800 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
802 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
804 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
805 AE = AbstractSPDies.end(); AI != AE; ++AI) {
806 DIE *ISP = AI->second;
807 if (InlinedSubprogramDIEs.count(ISP))
809 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
813 // Collect info for variables that were optimized out.
814 void DwarfDebug::collectDeadVariables() {
815 const Module *M = MMI->getModule();
816 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
818 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
819 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
820 DICompileUnit TheCU(CU_Nodes->getOperand(i));
821 DIArray Subprograms = TheCU.getSubprograms();
822 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
823 DISubprogram SP(Subprograms.getElement(i));
824 if (ProcessedSPNodes.count(SP) != 0) continue;
825 if (!SP.Verify()) continue;
826 if (!SP.isDefinition()) continue;
827 DIArray Variables = SP.getVariables();
828 if (Variables.getNumElements() == 0) continue;
830 LexicalScope *Scope =
831 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
832 DeadFnScopeMap[SP] = Scope;
834 // Construct subprogram DIE and add variables DIEs.
835 CompileUnit *SPCU = CUMap.lookup(TheCU);
836 assert(SPCU && "Unable to find Compile Unit!");
837 constructSubprogramDIE(SPCU, SP);
838 DIE *ScopeDIE = SPCU->getDIE(SP);
839 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
840 DIVariable DV(Variables.getElement(vi));
841 if (!DV.Verify()) continue;
842 DbgVariable *NewVar = new DbgVariable(DV, NULL);
843 if (DIE *VariableDIE =
844 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
845 ScopeDIE->addChild(VariableDIE);
850 DeleteContainerSeconds(DeadFnScopeMap);
853 void DwarfDebug::finalizeModuleInfo() {
854 // Collect info for variables that were optimized out.
855 collectDeadVariables();
857 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
858 computeInlinedDIEs();
860 // Emit DW_AT_containing_type attribute to connect types with their
861 // vtable holding type.
862 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
863 CUE = CUMap.end(); CUI != CUE; ++CUI) {
864 CompileUnit *TheCU = CUI->second;
865 TheCU->constructContainingTypeDIEs();
868 // Compute DIE offsets and sizes.
869 computeSizeAndOffsets();
872 void DwarfDebug::endSections() {
873 // Standard sections final addresses.
874 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
875 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
876 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
877 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
879 // End text sections.
880 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
881 Asm->OutStreamer.SwitchSection(SectionMap[I]);
882 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
886 // Emit all Dwarf sections that should come after the content.
887 void DwarfDebug::endModule() {
889 if (!FirstCU) return;
891 // End any existing sections.
892 // TODO: Does this need to happen?
895 // Finalize the debug info for the module.
896 finalizeModuleInfo();
898 // Emit initial sections.
901 if (!useDwarfFission()) {
902 // Emit all the DIEs into a debug info section.
905 // Corresponding abbreviations into a abbrev section.
908 // Emit info into a debug loc section.
911 // Emit info into a debug aranges section.
914 // Emit info into a debug ranges section.
917 // Emit info into a debug macinfo section.
921 // TODO: When we don't need the option anymore we
922 // can remove all of the code that this section
924 if (useDarwinGDBCompat())
925 emitDebugInlineInfo();
927 // TODO: Fill this in for Fission sections and separate
928 // out information into new sections.
930 // Emit all the DIEs into a debug info section.
933 // Corresponding abbreviations into a abbrev section.
936 // Emit info into a debug loc section.
939 // Emit info into a debug aranges section.
942 // Emit info into a debug ranges section.
945 // Emit info into a debug macinfo section.
949 // TODO: When we don't need the option anymore we
950 // can remove all of the code that this section
952 if (useDarwinGDBCompat())
953 emitDebugInlineInfo();
956 // Emit info into the dwarf accelerator table sections.
957 if (useDwarfAccelTables()) {
960 emitAccelNamespaces();
964 // Emit info into a debug pubtypes section.
965 // TODO: When we don't need the option anymore we can
966 // remove all of the code that adds to the table.
967 if (useDarwinGDBCompat())
970 // Finally emit string information into a string table.
975 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
976 E = CUMap.end(); I != E; ++I)
978 FirstCU = NULL; // Reset for the next Module, if any.
981 // Find abstract variable, if any, associated with Var.
982 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
984 LLVMContext &Ctx = DV->getContext();
985 // More then one inlined variable corresponds to one abstract variable.
986 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
987 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
989 return AbsDbgVariable;
991 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
995 AbsDbgVariable = new DbgVariable(Var, NULL);
996 addScopeVariable(Scope, AbsDbgVariable);
997 AbstractVariables[Var] = AbsDbgVariable;
998 return AbsDbgVariable;
1001 // If Var is a current function argument then add it to CurrentFnArguments list.
1002 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1003 DbgVariable *Var, LexicalScope *Scope) {
1004 if (!LScopes.isCurrentFunctionScope(Scope))
1006 DIVariable DV = Var->getVariable();
1007 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1009 unsigned ArgNo = DV.getArgNumber();
1013 size_t Size = CurrentFnArguments.size();
1015 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1016 // llvm::Function argument size is not good indicator of how many
1017 // arguments does the function have at source level.
1019 CurrentFnArguments.resize(ArgNo * 2);
1020 CurrentFnArguments[ArgNo - 1] = Var;
1024 // Collect variable information from side table maintained by MMI.
1026 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1027 SmallPtrSet<const MDNode *, 16> &Processed) {
1028 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1029 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1030 VE = VMap.end(); VI != VE; ++VI) {
1031 const MDNode *Var = VI->first;
1033 Processed.insert(Var);
1035 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1037 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1039 // If variable scope is not found then skip this variable.
1043 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1044 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1045 RegVar->setFrameIndex(VP.first);
1046 if (!addCurrentFnArgument(MF, RegVar, Scope))
1047 addScopeVariable(Scope, RegVar);
1049 AbsDbgVariable->setFrameIndex(VP.first);
1053 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1055 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1056 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1057 return MI->getNumOperands() == 3 &&
1058 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1059 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1062 // Get .debug_loc entry for the instruction range starting at MI.
1063 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1064 const MCSymbol *FLabel,
1065 const MCSymbol *SLabel,
1066 const MachineInstr *MI) {
1067 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1069 if (MI->getNumOperands() != 3) {
1070 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1071 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1073 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1074 MachineLocation MLoc;
1075 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1076 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1078 if (MI->getOperand(0).isImm())
1079 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1080 if (MI->getOperand(0).isFPImm())
1081 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1082 if (MI->getOperand(0).isCImm())
1083 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1085 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1088 // Find variables for each lexical scope.
1090 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1091 SmallPtrSet<const MDNode *, 16> &Processed) {
1093 // collection info from MMI table.
1094 collectVariableInfoFromMMITable(MF, Processed);
1096 for (SmallVectorImpl<const MDNode*>::const_iterator
1097 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1099 const MDNode *Var = *UVI;
1100 if (Processed.count(Var))
1103 // History contains relevant DBG_VALUE instructions for Var and instructions
1105 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1106 if (History.empty())
1108 const MachineInstr *MInsn = History.front();
1111 LexicalScope *Scope = NULL;
1112 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1113 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1114 Scope = LScopes.getCurrentFunctionScope();
1116 if (DV.getVersion() <= LLVMDebugVersion9)
1117 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1119 if (MDNode *IA = DV.getInlinedAt())
1120 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1122 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1125 // If variable scope is not found then skip this variable.
1129 Processed.insert(DV);
1130 assert(MInsn->isDebugValue() && "History must begin with debug value");
1131 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1132 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1133 if (!addCurrentFnArgument(MF, RegVar, Scope))
1134 addScopeVariable(Scope, RegVar);
1136 AbsVar->setMInsn(MInsn);
1138 // Simplify ranges that are fully coalesced.
1139 if (History.size() <= 1 || (History.size() == 2 &&
1140 MInsn->isIdenticalTo(History.back()))) {
1141 RegVar->setMInsn(MInsn);
1145 // handle multiple DBG_VALUE instructions describing one variable.
1146 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1148 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1149 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1150 const MachineInstr *Begin = *HI;
1151 assert(Begin->isDebugValue() && "Invalid History entry");
1153 // Check if DBG_VALUE is truncating a range.
1154 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1155 && !Begin->getOperand(0).getReg())
1158 // Compute the range for a register location.
1159 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1160 const MCSymbol *SLabel = 0;
1163 // If Begin is the last instruction in History then its value is valid
1164 // until the end of the function.
1165 SLabel = FunctionEndSym;
1167 const MachineInstr *End = HI[1];
1168 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1169 << "\t" << *Begin << "\t" << *End << "\n");
1170 if (End->isDebugValue())
1171 SLabel = getLabelBeforeInsn(End);
1173 // End is a normal instruction clobbering the range.
1174 SLabel = getLabelAfterInsn(End);
1175 assert(SLabel && "Forgot label after clobber instruction");
1180 // The value is valid until the next DBG_VALUE or clobber.
1181 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1184 DotDebugLocEntries.push_back(DotDebugLocEntry());
1187 // Collect info for variables that were optimized out.
1188 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1189 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1190 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1191 DIVariable DV(Variables.getElement(i));
1192 if (!DV || !DV.Verify() || !Processed.insert(DV))
1194 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1195 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1199 // Return Label preceding the instruction.
1200 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1201 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1202 assert(Label && "Didn't insert label before instruction");
1206 // Return Label immediately following the instruction.
1207 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1208 return LabelsAfterInsn.lookup(MI);
1211 // Process beginning of an instruction.
1212 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1213 // Check if source location changes, but ignore DBG_VALUE locations.
1214 if (!MI->isDebugValue()) {
1215 DebugLoc DL = MI->getDebugLoc();
1216 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1219 if (DL == PrologEndLoc) {
1220 Flags |= DWARF2_FLAG_PROLOGUE_END;
1221 PrologEndLoc = DebugLoc();
1223 if (PrologEndLoc.isUnknown())
1224 Flags |= DWARF2_FLAG_IS_STMT;
1226 if (!DL.isUnknown()) {
1227 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1228 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1230 recordSourceLine(0, 0, 0, 0);
1234 // Insert labels where requested.
1235 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1236 LabelsBeforeInsn.find(MI);
1239 if (I == LabelsBeforeInsn.end())
1242 // Label already assigned.
1247 PrevLabel = MMI->getContext().CreateTempSymbol();
1248 Asm->OutStreamer.EmitLabel(PrevLabel);
1250 I->second = PrevLabel;
1253 // Process end of an instruction.
1254 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1255 // Don't create a new label after DBG_VALUE instructions.
1256 // They don't generate code.
1257 if (!MI->isDebugValue())
1260 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1261 LabelsAfterInsn.find(MI);
1264 if (I == LabelsAfterInsn.end())
1267 // Label already assigned.
1271 // We need a label after this instruction.
1273 PrevLabel = MMI->getContext().CreateTempSymbol();
1274 Asm->OutStreamer.EmitLabel(PrevLabel);
1276 I->second = PrevLabel;
1279 // Each LexicalScope has first instruction and last instruction to mark
1280 // beginning and end of a scope respectively. Create an inverse map that list
1281 // scopes starts (and ends) with an instruction. One instruction may start (or
1282 // end) multiple scopes. Ignore scopes that are not reachable.
1283 void DwarfDebug::identifyScopeMarkers() {
1284 SmallVector<LexicalScope *, 4> WorkList;
1285 WorkList.push_back(LScopes.getCurrentFunctionScope());
1286 while (!WorkList.empty()) {
1287 LexicalScope *S = WorkList.pop_back_val();
1289 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1290 if (!Children.empty())
1291 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1292 SE = Children.end(); SI != SE; ++SI)
1293 WorkList.push_back(*SI);
1295 if (S->isAbstractScope())
1298 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1301 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1302 RE = Ranges.end(); RI != RE; ++RI) {
1303 assert(RI->first && "InsnRange does not have first instruction!");
1304 assert(RI->second && "InsnRange does not have second instruction!");
1305 requestLabelBeforeInsn(RI->first);
1306 requestLabelAfterInsn(RI->second);
1311 // Get MDNode for DebugLoc's scope.
1312 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1313 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1314 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1315 return DL.getScope(Ctx);
1318 // Walk up the scope chain of given debug loc and find line number info
1319 // for the function.
1320 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1321 const MDNode *Scope = getScopeNode(DL, Ctx);
1322 DISubprogram SP = getDISubprogram(Scope);
1324 // Check for number of operands since the compatibility is
1326 if (SP->getNumOperands() > 19)
1327 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1329 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1335 // Gather pre-function debug information. Assumes being called immediately
1336 // after the function entry point has been emitted.
1337 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1338 if (!MMI->hasDebugInfo()) return;
1339 LScopes.initialize(*MF);
1340 if (LScopes.empty()) return;
1341 identifyScopeMarkers();
1343 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1344 Asm->getFunctionNumber());
1345 // Assumes in correct section after the entry point.
1346 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1348 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1350 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1351 // LiveUserVar - Map physreg numbers to the MDNode they contain.
1352 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1354 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1356 bool AtBlockEntry = true;
1357 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1359 const MachineInstr *MI = II;
1361 if (MI->isDebugValue()) {
1362 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1364 // Keep track of user variables.
1366 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1368 // Variable is in a register, we need to check for clobbers.
1369 if (isDbgValueInDefinedReg(MI))
1370 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1372 // Check the history of this variable.
1373 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1374 if (History.empty()) {
1375 UserVariables.push_back(Var);
1376 // The first mention of a function argument gets the FunctionBeginSym
1377 // label, so arguments are visible when breaking at function entry.
1379 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1380 DISubprogram(getDISubprogram(DV.getContext()))
1381 .describes(MF->getFunction()))
1382 LabelsBeforeInsn[MI] = FunctionBeginSym;
1384 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1385 const MachineInstr *Prev = History.back();
1386 if (Prev->isDebugValue()) {
1387 // Coalesce identical entries at the end of History.
1388 if (History.size() >= 2 &&
1389 Prev->isIdenticalTo(History[History.size() - 2])) {
1390 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1392 << "\t" << *History[History.size() - 2] << "\n");
1396 // Terminate old register assignments that don't reach MI;
1397 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1398 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1399 isDbgValueInDefinedReg(Prev)) {
1400 // Previous register assignment needs to terminate at the end of
1402 MachineBasicBlock::const_iterator LastMI =
1403 PrevMBB->getLastNonDebugInstr();
1404 if (LastMI == PrevMBB->end()) {
1405 // Drop DBG_VALUE for empty range.
1406 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1407 << "\t" << *Prev << "\n");
1411 // Terminate after LastMI.
1412 History.push_back(LastMI);
1417 History.push_back(MI);
1419 // Not a DBG_VALUE instruction.
1421 AtBlockEntry = false;
1423 // First known non-DBG_VALUE and non-frame setup location marks
1424 // the beginning of the function body.
1425 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1426 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1427 PrologEndLoc = MI->getDebugLoc();
1429 // Check if the instruction clobbers any registers with debug vars.
1430 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1431 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1432 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1434 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1435 AI.isValid(); ++AI) {
1437 const MDNode *Var = LiveUserVar[Reg];
1440 // Reg is now clobbered.
1441 LiveUserVar[Reg] = 0;
1443 // Was MD last defined by a DBG_VALUE referring to Reg?
1444 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1445 if (HistI == DbgValues.end())
1447 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1448 if (History.empty())
1450 const MachineInstr *Prev = History.back();
1451 // Sanity-check: Register assignments are terminated at the end of
1453 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1455 // Is the variable still in Reg?
1456 if (!isDbgValueInDefinedReg(Prev) ||
1457 Prev->getOperand(0).getReg() != Reg)
1459 // Var is clobbered. Make sure the next instruction gets a label.
1460 History.push_back(MI);
1467 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1469 SmallVectorImpl<const MachineInstr*> &History = I->second;
1470 if (History.empty())
1473 // Make sure the final register assignments are terminated.
1474 const MachineInstr *Prev = History.back();
1475 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1476 const MachineBasicBlock *PrevMBB = Prev->getParent();
1477 MachineBasicBlock::const_iterator LastMI =
1478 PrevMBB->getLastNonDebugInstr();
1479 if (LastMI == PrevMBB->end())
1480 // Drop DBG_VALUE for empty range.
1483 // Terminate after LastMI.
1484 History.push_back(LastMI);
1487 // Request labels for the full history.
1488 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1489 const MachineInstr *MI = History[i];
1490 if (MI->isDebugValue())
1491 requestLabelBeforeInsn(MI);
1493 requestLabelAfterInsn(MI);
1497 PrevInstLoc = DebugLoc();
1498 PrevLabel = FunctionBeginSym;
1500 // Record beginning of function.
1501 if (!PrologEndLoc.isUnknown()) {
1502 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1503 MF->getFunction()->getContext());
1504 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1505 FnStartDL.getScope(MF->getFunction()->getContext()),
1510 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1511 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1512 ScopeVariables[LS].push_back(Var);
1513 // Vars.push_back(Var);
1516 // Gather and emit post-function debug information.
1517 void DwarfDebug::endFunction(const MachineFunction *MF) {
1518 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1520 // Define end label for subprogram.
1521 FunctionEndSym = Asm->GetTempSymbol("func_end",
1522 Asm->getFunctionNumber());
1523 // Assumes in correct section after the entry point.
1524 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1526 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1527 collectVariableInfo(MF, ProcessedVars);
1529 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1530 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1531 assert(TheCU && "Unable to find compile unit!");
1533 // Construct abstract scopes.
1534 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1535 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1536 LexicalScope *AScope = AList[i];
1537 DISubprogram SP(AScope->getScopeNode());
1539 // Collect info for variables that were optimized out.
1540 DIArray Variables = SP.getVariables();
1541 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1542 DIVariable DV(Variables.getElement(i));
1543 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1545 // Check that DbgVariable for DV wasn't created earlier, when
1546 // findAbstractVariable() was called for inlined instance of DV.
1547 LLVMContext &Ctx = DV->getContext();
1548 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1549 if (AbstractVariables.lookup(CleanDV))
1551 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1552 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1555 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1556 constructScopeDIE(TheCU, AScope);
1559 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1561 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1562 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1564 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1565 MMI->getFrameMoves()));
1568 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1569 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1570 DeleteContainerPointers(I->second);
1571 ScopeVariables.clear();
1572 DeleteContainerPointers(CurrentFnArguments);
1573 UserVariables.clear();
1575 AbstractVariables.clear();
1576 LabelsBeforeInsn.clear();
1577 LabelsAfterInsn.clear();
1581 // Register a source line with debug info. Returns the unique label that was
1582 // emitted and which provides correspondence to the source line list.
1583 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1589 DIDescriptor Scope(S);
1591 if (Scope.isCompileUnit()) {
1592 DICompileUnit CU(S);
1593 Fn = CU.getFilename();
1594 Dir = CU.getDirectory();
1595 } else if (Scope.isFile()) {
1597 Fn = F.getFilename();
1598 Dir = F.getDirectory();
1599 } else if (Scope.isSubprogram()) {
1601 Fn = SP.getFilename();
1602 Dir = SP.getDirectory();
1603 } else if (Scope.isLexicalBlockFile()) {
1604 DILexicalBlockFile DBF(S);
1605 Fn = DBF.getFilename();
1606 Dir = DBF.getDirectory();
1607 } else if (Scope.isLexicalBlock()) {
1608 DILexicalBlock DB(S);
1609 Fn = DB.getFilename();
1610 Dir = DB.getDirectory();
1612 llvm_unreachable("Unexpected scope info");
1614 Src = getOrCreateSourceID(Fn, Dir);
1616 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1619 //===----------------------------------------------------------------------===//
1621 //===----------------------------------------------------------------------===//
1623 // Compute the size and offset of a DIE.
1625 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1626 // Get the children.
1627 const std::vector<DIE *> &Children = Die->getChildren();
1629 // Record the abbreviation.
1630 assignAbbrevNumber(Die->getAbbrev());
1632 // Get the abbreviation for this DIE.
1633 unsigned AbbrevNumber = Die->getAbbrevNumber();
1634 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1637 Die->setOffset(Offset);
1639 // Start the size with the size of abbreviation code.
1640 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1642 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1643 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1645 // Size the DIE attribute values.
1646 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1647 // Size attribute value.
1648 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1650 // Size the DIE children if any.
1651 if (!Children.empty()) {
1652 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1653 "Children flag not set");
1655 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1656 Offset = computeSizeAndOffset(Children[j], Offset);
1658 // End of children marker.
1659 Offset += sizeof(int8_t);
1662 Die->setSize(Offset - Die->getOffset());
1666 // Compute the size and offset of all the DIEs.
1667 void DwarfDebug::computeSizeAndOffsets() {
1668 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1669 E = CUMap.end(); I != E; ++I) {
1670 // Compute size of compile unit header.
1672 sizeof(int32_t) + // Length of Compilation Unit Info
1673 sizeof(int16_t) + // DWARF version number
1674 sizeof(int32_t) + // Offset Into Abbrev. Section
1675 sizeof(int8_t); // Pointer Size (in bytes)
1676 computeSizeAndOffset(I->second->getCUDie(), Offset);
1680 // Emit initial Dwarf sections with a label at the start of each one.
1681 void DwarfDebug::emitSectionLabels() {
1682 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1684 // Dwarf sections base addresses.
1685 DwarfInfoSectionSym =
1686 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1687 DwarfAbbrevSectionSym =
1688 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1689 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1691 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1692 emitSectionSym(Asm, MacroInfo);
1694 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1695 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1696 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1697 DwarfStrSectionSym =
1698 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1699 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1702 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1703 "section_debug_loc");
1705 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1706 emitSectionSym(Asm, TLOF.getDataSection());
1709 // Recursively emits a debug information entry.
1710 void DwarfDebug::emitDIE(DIE *Die) {
1711 // Get the abbreviation for this DIE.
1712 unsigned AbbrevNumber = Die->getAbbrevNumber();
1713 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1715 // Emit the code (index) for the abbreviation.
1716 if (Asm->isVerbose())
1717 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1718 Twine::utohexstr(Die->getOffset()) + ":0x" +
1719 Twine::utohexstr(Die->getSize()) + " " +
1720 dwarf::TagString(Abbrev->getTag()));
1721 Asm->EmitULEB128(AbbrevNumber);
1723 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1724 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1726 // Emit the DIE attribute values.
1727 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1728 unsigned Attr = AbbrevData[i].getAttribute();
1729 unsigned Form = AbbrevData[i].getForm();
1730 assert(Form && "Too many attributes for DIE (check abbreviation)");
1732 if (Asm->isVerbose())
1733 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1736 case dwarf::DW_AT_abstract_origin: {
1737 DIEEntry *E = cast<DIEEntry>(Values[i]);
1738 DIE *Origin = E->getEntry();
1739 unsigned Addr = Origin->getOffset();
1740 Asm->EmitInt32(Addr);
1743 case dwarf::DW_AT_ranges: {
1744 // DW_AT_range Value encodes offset in debug_range section.
1745 DIEInteger *V = cast<DIEInteger>(Values[i]);
1747 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1748 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1752 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1754 DwarfDebugRangeSectionSym,
1759 case dwarf::DW_AT_location: {
1760 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1761 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1762 Asm->EmitLabelReference(L->getValue(), 4);
1764 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1766 Values[i]->EmitValue(Asm, Form);
1770 case dwarf::DW_AT_accessibility: {
1771 if (Asm->isVerbose()) {
1772 DIEInteger *V = cast<DIEInteger>(Values[i]);
1773 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1775 Values[i]->EmitValue(Asm, Form);
1779 // Emit an attribute using the defined form.
1780 Values[i]->EmitValue(Asm, Form);
1785 // Emit the DIE children if any.
1786 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1787 const std::vector<DIE *> &Children = Die->getChildren();
1789 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1790 emitDIE(Children[j]);
1792 if (Asm->isVerbose())
1793 Asm->OutStreamer.AddComment("End Of Children Mark");
1798 // Emit the debug info section.
1799 void DwarfDebug::emitDebugInfo() {
1800 // Start debug info section.
1801 Asm->OutStreamer.SwitchSection(
1802 Asm->getObjFileLowering().getDwarfInfoSection());
1803 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1804 E = CUMap.end(); I != E; ++I) {
1805 CompileUnit *TheCU = I->second;
1806 DIE *Die = TheCU->getCUDie();
1808 // Emit the compile units header.
1809 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1812 // Emit size of content not including length itself
1813 unsigned ContentSize = Die->getSize() +
1814 sizeof(int16_t) + // DWARF version number
1815 sizeof(int32_t) + // Offset Into Abbrev. Section
1816 sizeof(int8_t); // Pointer Size (in bytes)
1818 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1819 Asm->EmitInt32(ContentSize);
1820 Asm->OutStreamer.AddComment("DWARF version number");
1821 Asm->EmitInt16(dwarf::DWARF_VERSION);
1822 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1823 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1824 DwarfAbbrevSectionSym);
1825 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1826 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1829 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1833 // Emit the abbreviation section.
1834 void DwarfDebug::emitAbbreviations() {
1835 // Check to see if it is worth the effort.
1836 if (!Abbreviations.empty()) {
1837 // Start the debug abbrev section.
1838 Asm->OutStreamer.SwitchSection(
1839 Asm->getObjFileLowering().getDwarfAbbrevSection());
1841 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1843 // For each abbrevation.
1844 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1845 // Get abbreviation data
1846 const DIEAbbrev *Abbrev = Abbreviations[i];
1848 // Emit the abbrevations code (base 1 index.)
1849 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1851 // Emit the abbreviations data.
1855 // Mark end of abbreviations.
1856 Asm->EmitULEB128(0, "EOM(3)");
1858 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1862 // Emit the last address of the section and the end of the line matrix.
1863 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1864 // Define last address of section.
1865 Asm->OutStreamer.AddComment("Extended Op");
1868 Asm->OutStreamer.AddComment("Op size");
1869 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1870 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1871 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1873 Asm->OutStreamer.AddComment("Section end label");
1875 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1876 Asm->getDataLayout().getPointerSize(),
1879 // Mark end of matrix.
1880 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1886 // Emit visible names into a hashed accelerator table section.
1887 void DwarfDebug::emitAccelNames() {
1888 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1889 dwarf::DW_FORM_data4));
1890 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1891 E = CUMap.end(); I != E; ++I) {
1892 CompileUnit *TheCU = I->second;
1893 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1894 for (StringMap<std::vector<DIE*> >::const_iterator
1895 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1896 const char *Name = GI->getKeyData();
1897 const std::vector<DIE *> &Entities = GI->second;
1898 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1899 DE = Entities.end(); DI != DE; ++DI)
1900 AT.AddName(Name, (*DI));
1904 AT.FinalizeTable(Asm, "Names");
1905 Asm->OutStreamer.SwitchSection(
1906 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1907 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1908 Asm->OutStreamer.EmitLabel(SectionBegin);
1910 // Emit the full data.
1911 AT.Emit(Asm, SectionBegin, this);
1914 // Emit objective C classes and categories into a hashed accelerator table section.
1915 void DwarfDebug::emitAccelObjC() {
1916 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1917 dwarf::DW_FORM_data4));
1918 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1919 E = CUMap.end(); I != E; ++I) {
1920 CompileUnit *TheCU = I->second;
1921 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1922 for (StringMap<std::vector<DIE*> >::const_iterator
1923 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1924 const char *Name = GI->getKeyData();
1925 const std::vector<DIE *> &Entities = GI->second;
1926 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1927 DE = Entities.end(); DI != DE; ++DI)
1928 AT.AddName(Name, (*DI));
1932 AT.FinalizeTable(Asm, "ObjC");
1933 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1934 .getDwarfAccelObjCSection());
1935 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1936 Asm->OutStreamer.EmitLabel(SectionBegin);
1938 // Emit the full data.
1939 AT.Emit(Asm, SectionBegin, this);
1942 // Emit namespace dies into a hashed accelerator table.
1943 void DwarfDebug::emitAccelNamespaces() {
1944 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1945 dwarf::DW_FORM_data4));
1946 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1947 E = CUMap.end(); I != E; ++I) {
1948 CompileUnit *TheCU = I->second;
1949 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1950 for (StringMap<std::vector<DIE*> >::const_iterator
1951 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1952 const char *Name = GI->getKeyData();
1953 const std::vector<DIE *> &Entities = GI->second;
1954 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1955 DE = Entities.end(); DI != DE; ++DI)
1956 AT.AddName(Name, (*DI));
1960 AT.FinalizeTable(Asm, "namespac");
1961 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1962 .getDwarfAccelNamespaceSection());
1963 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1964 Asm->OutStreamer.EmitLabel(SectionBegin);
1966 // Emit the full data.
1967 AT.Emit(Asm, SectionBegin, this);
1970 // Emit type dies into a hashed accelerator table.
1971 void DwarfDebug::emitAccelTypes() {
1972 std::vector<DwarfAccelTable::Atom> Atoms;
1973 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1974 dwarf::DW_FORM_data4));
1975 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1976 dwarf::DW_FORM_data2));
1977 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1978 dwarf::DW_FORM_data1));
1979 DwarfAccelTable AT(Atoms);
1980 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1981 E = CUMap.end(); I != E; ++I) {
1982 CompileUnit *TheCU = I->second;
1983 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1984 = TheCU->getAccelTypes();
1985 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1986 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1987 const char *Name = GI->getKeyData();
1988 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1989 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1990 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1991 AT.AddName(Name, (*DI).first, (*DI).second);
1995 AT.FinalizeTable(Asm, "types");
1996 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1997 .getDwarfAccelTypesSection());
1998 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1999 Asm->OutStreamer.EmitLabel(SectionBegin);
2001 // Emit the full data.
2002 AT.Emit(Asm, SectionBegin, this);
2005 void DwarfDebug::emitDebugPubTypes() {
2006 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2007 E = CUMap.end(); I != E; ++I) {
2008 CompileUnit *TheCU = I->second;
2009 // Start the dwarf pubtypes section.
2010 Asm->OutStreamer.SwitchSection(
2011 Asm->getObjFileLowering().getDwarfPubTypesSection());
2012 Asm->OutStreamer.AddComment("Length of Public Types Info");
2013 Asm->EmitLabelDifference(
2014 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2015 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2017 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2020 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2021 Asm->EmitInt16(dwarf::DWARF_VERSION);
2023 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2024 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2025 DwarfInfoSectionSym);
2027 Asm->OutStreamer.AddComment("Compilation Unit Length");
2028 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2029 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2032 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2033 for (StringMap<DIE*>::const_iterator
2034 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2035 const char *Name = GI->getKeyData();
2036 DIE *Entity = GI->second;
2038 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2039 Asm->EmitInt32(Entity->getOffset());
2041 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2042 // Emit the name with a terminating null byte.
2043 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2046 Asm->OutStreamer.AddComment("End Mark");
2048 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2053 // Emit visible names into a debug str section.
2054 void DwarfDebug::emitDebugStr() {
2055 // Check to see if it is worth the effort.
2056 if (StringPool.empty()) return;
2058 // Start the dwarf str section.
2059 Asm->OutStreamer.SwitchSection(
2060 Asm->getObjFileLowering().getDwarfStrSection());
2062 // Get all of the string pool entries and put them in an array by their ID so
2063 // we can sort them.
2064 SmallVector<std::pair<unsigned,
2065 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2067 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2068 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2069 Entries.push_back(std::make_pair(I->second.second, &*I));
2071 array_pod_sort(Entries.begin(), Entries.end());
2073 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2074 // Emit a label for reference from debug information entries.
2075 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2077 // Emit the string itself with a terminating null byte.
2078 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2079 Entries[i].second->getKeyLength()+1),
2084 // Emit visible names into a debug loc section.
2085 void DwarfDebug::emitDebugLoc() {
2086 if (DotDebugLocEntries.empty())
2089 for (SmallVector<DotDebugLocEntry, 4>::iterator
2090 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2092 DotDebugLocEntry &Entry = *I;
2093 if (I + 1 != DotDebugLocEntries.end())
2097 // Start the dwarf loc section.
2098 Asm->OutStreamer.SwitchSection(
2099 Asm->getObjFileLowering().getDwarfLocSection());
2100 unsigned char Size = Asm->getDataLayout().getPointerSize();
2101 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2103 for (SmallVector<DotDebugLocEntry, 4>::iterator
2104 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2105 I != E; ++I, ++index) {
2106 DotDebugLocEntry &Entry = *I;
2107 if (Entry.isMerged()) continue;
2108 if (Entry.isEmpty()) {
2109 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2110 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2111 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2113 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2114 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2115 DIVariable DV(Entry.Variable);
2116 Asm->OutStreamer.AddComment("Loc expr size");
2117 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2118 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2119 Asm->EmitLabelDifference(end, begin, 2);
2120 Asm->OutStreamer.EmitLabel(begin);
2121 if (Entry.isInt()) {
2122 DIBasicType BTy(DV.getType());
2124 (BTy.getEncoding() == dwarf::DW_ATE_signed
2125 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2126 Asm->OutStreamer.AddComment("DW_OP_consts");
2127 Asm->EmitInt8(dwarf::DW_OP_consts);
2128 Asm->EmitSLEB128(Entry.getInt());
2130 Asm->OutStreamer.AddComment("DW_OP_constu");
2131 Asm->EmitInt8(dwarf::DW_OP_constu);
2132 Asm->EmitULEB128(Entry.getInt());
2134 } else if (Entry.isLocation()) {
2135 if (!DV.hasComplexAddress())
2137 Asm->EmitDwarfRegOp(Entry.Loc);
2139 // Complex address entry.
2140 unsigned N = DV.getNumAddrElements();
2142 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2143 if (Entry.Loc.getOffset()) {
2145 Asm->EmitDwarfRegOp(Entry.Loc);
2146 Asm->OutStreamer.AddComment("DW_OP_deref");
2147 Asm->EmitInt8(dwarf::DW_OP_deref);
2148 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2149 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2150 Asm->EmitSLEB128(DV.getAddrElement(1));
2152 // If first address element is OpPlus then emit
2153 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2154 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2155 Asm->EmitDwarfRegOp(Loc);
2159 Asm->EmitDwarfRegOp(Entry.Loc);
2162 // Emit remaining complex address elements.
2163 for (; i < N; ++i) {
2164 uint64_t Element = DV.getAddrElement(i);
2165 if (Element == DIBuilder::OpPlus) {
2166 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2167 Asm->EmitULEB128(DV.getAddrElement(++i));
2168 } else if (Element == DIBuilder::OpDeref) {
2169 if (!Entry.Loc.isReg())
2170 Asm->EmitInt8(dwarf::DW_OP_deref);
2172 llvm_unreachable("unknown Opcode found in complex address");
2176 // else ... ignore constant fp. There is not any good way to
2177 // to represent them here in dwarf.
2178 Asm->OutStreamer.EmitLabel(end);
2183 // Emit visible names into a debug aranges section.
2184 void DwarfDebug::emitDebugARanges() {
2185 // Start the dwarf aranges section.
2186 Asm->OutStreamer.SwitchSection(
2187 Asm->getObjFileLowering().getDwarfARangesSection());
2190 // Emit visible names into a debug ranges section.
2191 void DwarfDebug::emitDebugRanges() {
2192 // Start the dwarf ranges section.
2193 Asm->OutStreamer.SwitchSection(
2194 Asm->getObjFileLowering().getDwarfRangesSection());
2195 unsigned char Size = Asm->getDataLayout().getPointerSize();
2196 for (SmallVector<const MCSymbol *, 8>::iterator
2197 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2200 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2202 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2206 // Emit visible names into a debug macinfo section.
2207 void DwarfDebug::emitDebugMacInfo() {
2208 if (const MCSection *LineInfo =
2209 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2210 // Start the dwarf macinfo section.
2211 Asm->OutStreamer.SwitchSection(LineInfo);
2215 // Emit inline info using following format.
2217 // 1. length of section
2218 // 2. Dwarf version number
2221 // Entries (one "entry" for each function that was inlined):
2223 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2224 // otherwise offset into __debug_str for regular function name.
2225 // 2. offset into __debug_str section for regular function name.
2226 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2227 // instances for the function.
2229 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2230 // inlined instance; the die_offset points to the inlined_subroutine die in the
2231 // __debug_info section, and the low_pc is the starting address for the
2232 // inlining instance.
2233 void DwarfDebug::emitDebugInlineInfo() {
2234 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2240 Asm->OutStreamer.SwitchSection(
2241 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2243 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2244 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2245 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2247 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2249 Asm->OutStreamer.AddComment("Dwarf Version");
2250 Asm->EmitInt16(dwarf::DWARF_VERSION);
2251 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2252 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2254 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2255 E = InlinedSPNodes.end(); I != E; ++I) {
2257 const MDNode *Node = *I;
2258 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2259 = InlineInfo.find(Node);
2260 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2261 DISubprogram SP(Node);
2262 StringRef LName = SP.getLinkageName();
2263 StringRef Name = SP.getName();
2265 Asm->OutStreamer.AddComment("MIPS linkage name");
2267 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2269 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2270 DwarfStrSectionSym);
2272 Asm->OutStreamer.AddComment("Function name");
2273 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2274 Asm->EmitULEB128(Labels.size(), "Inline count");
2276 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2277 LE = Labels.end(); LI != LE; ++LI) {
2278 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2279 Asm->EmitInt32(LI->second->getOffset());
2281 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2282 Asm->OutStreamer.EmitSymbolValue(LI->first,
2283 Asm->getDataLayout().getPointerSize(),0);
2287 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));