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 /// EmitSectionSym - 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 /// assignAbbrevNumber - 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 /// getRealLinkageName - 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 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
314 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
315 /// If there are global variables in this scope then create and insert
316 /// DIEs for these variables.
317 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
318 const MDNode *SPNode) {
319 DIE *SPDie = SPCU->getDIE(SPNode);
321 assert(SPDie && "Unable to find subprogram DIE!");
322 DISubprogram SP(SPNode);
324 // If we're updating an abstract DIE, then we will be adding the children and
325 // object pointer later on. But what we don't want to do is process the
326 // concrete DIE twice.
327 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
328 // Pick up abstract subprogram DIE.
329 SPDie = new DIE(dwarf::DW_TAG_subprogram);
330 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
331 dwarf::DW_FORM_ref4, AbsSPDIE);
334 DISubprogram SPDecl = SP.getFunctionDeclaration();
335 if (!SPDecl.isSubprogram()) {
336 // There is not any need to generate specification DIE for a function
337 // defined at compile unit level. If a function is defined inside another
338 // function then gdb prefers the definition at top level and but does not
339 // expect specification DIE in parent function. So avoid creating
340 // specification DIE for a function defined inside a function.
341 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
342 !SP.getContext().isFile() &&
343 !isSubprogramContext(SP.getContext())) {
344 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
347 DICompositeType SPTy = SP.getType();
348 DIArray Args = SPTy.getTypeArray();
349 unsigned SPTag = SPTy.getTag();
350 if (SPTag == dwarf::DW_TAG_subroutine_type)
351 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
352 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
353 DIType ATy = DIType(Args.getElement(i));
354 SPCU->addType(Arg, ATy);
355 if (ATy.isArtificial())
356 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
357 if (ATy.isObjectPointer())
358 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
359 dwarf::DW_FORM_ref4, Arg);
360 SPDie->addChild(Arg);
362 DIE *SPDeclDie = SPDie;
363 SPDie = new DIE(dwarf::DW_TAG_subprogram);
364 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
365 dwarf::DW_FORM_ref4, SPDeclDie);
371 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
372 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
373 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
374 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
375 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
376 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
377 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
379 // Add name to the name table, we do this here because we're guaranteed
380 // to have concrete versions of our DW_TAG_subprogram nodes.
381 addSubprogramNames(SPCU, SP, SPDie);
386 /// constructLexicalScope - Construct new DW_TAG_lexical_block
387 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
388 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
389 LexicalScope *Scope) {
390 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
391 if (Scope->isAbstractScope())
394 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
398 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
399 if (Ranges.size() > 1) {
400 // .debug_range section has not been laid out yet. Emit offset in
401 // .debug_range as a uint, size 4, for now. emitDIE will handle
402 // DW_AT_ranges appropriately.
403 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
404 DebugRangeSymbols.size()
405 * Asm->getDataLayout().getPointerSize());
406 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
407 RE = Ranges.end(); RI != RE; ++RI) {
408 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
409 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
411 DebugRangeSymbols.push_back(NULL);
412 DebugRangeSymbols.push_back(NULL);
416 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
417 const MCSymbol *End = getLabelAfterInsn(RI->second);
419 if (End == 0) return 0;
421 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
422 assert(End->isDefined() && "Invalid end label for an inlined scope!");
424 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
425 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
430 /// constructInlinedScopeDIE - This scope represents inlined body of
431 /// a function. Construct DIE to represent this concrete inlined copy
433 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
434 LexicalScope *Scope) {
435 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
436 assert(Ranges.empty() == false &&
437 "LexicalScope does not have instruction markers!");
439 if (!Scope->getScopeNode())
441 DIScope DS(Scope->getScopeNode());
442 DISubprogram InlinedSP = getDISubprogram(DS);
443 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
445 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
449 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
450 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
451 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
453 if (StartLabel == 0 || EndLabel == 0) {
454 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
456 assert(StartLabel->isDefined() &&
457 "Invalid starting label for an inlined scope!");
458 assert(EndLabel->isDefined() &&
459 "Invalid end label for an inlined scope!");
461 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
462 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
463 dwarf::DW_FORM_ref4, OriginDIE);
465 if (Ranges.size() > 1) {
466 // .debug_range section has not been laid out yet. Emit offset in
467 // .debug_range as a uint, size 4, for now. emitDIE will handle
468 // DW_AT_ranges appropriately.
469 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
470 DebugRangeSymbols.size()
471 * Asm->getDataLayout().getPointerSize());
472 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
473 RE = Ranges.end(); RI != RE; ++RI) {
474 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
475 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
477 DebugRangeSymbols.push_back(NULL);
478 DebugRangeSymbols.push_back(NULL);
480 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
482 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
486 InlinedSubprogramDIEs.insert(OriginDIE);
488 // Track the start label for this inlined function.
489 //.debug_inlined section specification does not clearly state how
490 // to emit inlined scope that is split into multiple instruction ranges.
491 // For now, use first instruction range and emit low_pc/high_pc pair and
492 // corresponding .debug_inlined section entry for this pair.
493 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
494 I = InlineInfo.find(InlinedSP);
496 if (I == InlineInfo.end()) {
497 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
498 InlinedSPNodes.push_back(InlinedSP);
500 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
502 DILocation DL(Scope->getInlinedAt());
503 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
504 GetOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
505 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
507 // Add name to the name table, we do this here because we're guaranteed
508 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
509 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
514 /// constructScopeDIE - Construct a DIE for this scope.
515 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
516 if (!Scope || !Scope->getScopeNode())
519 SmallVector<DIE *, 8> Children;
520 DIE *ObjectPointer = NULL;
522 // Collect arguments for current function.
523 if (LScopes.isCurrentFunctionScope(Scope))
524 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
525 if (DbgVariable *ArgDV = CurrentFnArguments[i])
527 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
528 Children.push_back(Arg);
529 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
532 // Collect lexical scope children first.
533 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
534 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
536 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
537 Children.push_back(Variable);
538 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
540 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
541 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
542 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
543 Children.push_back(Nested);
544 DIScope DS(Scope->getScopeNode());
545 DIE *ScopeDIE = NULL;
546 if (Scope->getInlinedAt())
547 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
548 else if (DS.isSubprogram()) {
549 ProcessedSPNodes.insert(DS);
550 if (Scope->isAbstractScope()) {
551 ScopeDIE = TheCU->getDIE(DS);
552 // Note down abstract DIE.
554 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
557 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
560 // There is no need to emit empty lexical block DIE.
561 if (Children.empty())
563 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
566 if (!ScopeDIE) return NULL;
569 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
570 E = Children.end(); I != E; ++I)
571 ScopeDIE->addChild(*I);
573 if (DS.isSubprogram() && ObjectPointer != NULL)
574 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
575 dwarf::DW_FORM_ref4, ObjectPointer);
577 if (DS.isSubprogram())
578 TheCU->addPubTypes(DISubprogram(DS));
583 /// GetOrCreateSourceID - Look up the source id with the given directory and
584 /// source file names. If none currently exists, create a new id and insert it
585 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
587 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
589 // If FE did not provide a file name, then assume stdin.
590 if (FileName.empty())
591 return GetOrCreateSourceID("<stdin>", StringRef());
593 // TODO: this might not belong here. See if we can factor this better.
594 if (DirName == CompilationDir)
597 unsigned SrcId = SourceIdMap.size()+1;
599 // We look up the file/dir pair by concatenating them with a zero byte.
600 SmallString<128> NamePair;
602 NamePair += '\0'; // Zero bytes are not allowed in paths.
603 NamePair += FileName;
605 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
606 if (Ent.getValue() != SrcId)
607 return Ent.getValue();
609 // Print out a .file directive to specify files for .loc directives.
610 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
615 /// constructCompileUnit - Create new CompileUnit for the given
616 /// metadata node with tag DW_TAG_compile_unit.
617 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
618 DICompileUnit DIUnit(N);
619 StringRef FN = DIUnit.getFilename();
620 CompilationDir = DIUnit.getDirectory();
621 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
623 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
624 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die,
626 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
627 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
628 DIUnit.getLanguage());
629 NewCU->addString(Die, dwarf::DW_AT_name, FN);
630 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
632 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
633 // DW_AT_stmt_list is a offset of line number information for this
634 // compile unit in debug_line section.
635 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
636 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
637 Asm->GetTempSymbol("section_line"));
639 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
641 if (!CompilationDir.empty())
642 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
643 if (DIUnit.isOptimized())
644 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
646 StringRef Flags = DIUnit.getFlags();
648 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
650 if (unsigned RVer = DIUnit.getRunTimeVersion())
651 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
652 dwarf::DW_FORM_data1, RVer);
656 CUMap.insert(std::make_pair(N, NewCU));
660 /// construct SubprogramDIE - 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 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
686 /// as llvm.dbg.enum and llvm.dbg.ty
687 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
688 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
689 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
690 const MDNode *N = NMD->getOperand(i);
691 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
692 constructSubprogramDIE(CU, N);
695 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
696 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
697 const MDNode *N = NMD->getOperand(i);
698 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
699 CU->createGlobalVariableDIE(N);
702 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
703 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
704 DIType Ty(NMD->getOperand(i));
705 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
706 CU->getOrCreateTypeDIE(Ty);
709 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
710 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
711 DIType Ty(NMD->getOperand(i));
712 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
713 CU->getOrCreateTypeDIE(Ty);
717 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
718 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
719 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
720 DebugInfoFinder DbgFinder;
721 DbgFinder.processModule(*M);
723 bool HasDebugInfo = false;
724 // Scan all the compile-units to see if there are any marked as the main
725 // unit. If not, we do not generate debug info.
726 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
727 E = DbgFinder.compile_unit_end(); I != E; ++I) {
728 if (DICompileUnit(*I).isMain()) {
733 if (!HasDebugInfo) return false;
735 // Create all the compile unit DIEs.
736 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
737 E = DbgFinder.compile_unit_end(); I != E; ++I)
738 constructCompileUnit(*I);
740 // Create DIEs for each global variable.
741 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
742 E = DbgFinder.global_variable_end(); I != E; ++I) {
743 const MDNode *N = *I;
744 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
745 CU->createGlobalVariableDIE(N);
748 // Create DIEs for each subprogram.
749 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
750 E = DbgFinder.subprogram_end(); I != E; ++I) {
751 const MDNode *N = *I;
752 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
753 constructSubprogramDIE(CU, N);
759 /// beginModule - Emit all Dwarf sections that should come prior to the
760 /// content. Create global DIEs and emit initial debug info sections.
761 /// This is invoked by the target AsmPrinter.
762 void DwarfDebug::beginModule() {
763 if (DisableDebugInfoPrinting)
766 const Module *M = MMI->getModule();
768 // If module has named metadata anchors then use them, otherwise scan the
769 // module using debug info finder to collect debug info.
770 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
772 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
773 DICompileUnit CUNode(CU_Nodes->getOperand(i));
774 CompileUnit *CU = constructCompileUnit(CUNode);
775 DIArray GVs = CUNode.getGlobalVariables();
776 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
777 CU->createGlobalVariableDIE(GVs.getElement(i));
778 DIArray SPs = CUNode.getSubprograms();
779 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
780 constructSubprogramDIE(CU, SPs.getElement(i));
781 DIArray EnumTypes = CUNode.getEnumTypes();
782 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
783 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
784 DIArray RetainedTypes = CUNode.getRetainedTypes();
785 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
786 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
788 } else if (!collectLegacyDebugInfo(M))
791 collectInfoFromNamedMDNodes(M);
793 // Tell MMI that we have debug info.
794 MMI->setDebugInfoAvailability(true);
796 // Prime section data.
797 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
800 /// endModule - Emit all Dwarf sections that should come after the content.
802 void DwarfDebug::endModule() {
804 if (!FirstCU) return;
806 const Module *M = MMI->getModule();
807 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
809 // Collect info for variables that were optimized out.
810 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
811 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
812 DICompileUnit TheCU(CU_Nodes->getOperand(i));
813 DIArray Subprograms = TheCU.getSubprograms();
814 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
815 DISubprogram SP(Subprograms.getElement(i));
816 if (ProcessedSPNodes.count(SP) != 0) continue;
817 if (!SP.Verify()) continue;
818 if (!SP.isDefinition()) continue;
819 DIArray Variables = SP.getVariables();
820 if (Variables.getNumElements() == 0) continue;
822 LexicalScope *Scope =
823 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
824 DeadFnScopeMap[SP] = Scope;
826 // Construct subprogram DIE and add variables DIEs.
827 CompileUnit *SPCU = CUMap.lookup(TheCU);
828 assert(SPCU && "Unable to find Compile Unit!");
829 constructSubprogramDIE(SPCU, SP);
830 DIE *ScopeDIE = SPCU->getDIE(SP);
831 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
832 DIVariable DV(Variables.getElement(vi));
833 if (!DV.Verify()) continue;
834 DbgVariable *NewVar = new DbgVariable(DV, NULL);
835 if (DIE *VariableDIE =
836 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
837 ScopeDIE->addChild(VariableDIE);
843 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
844 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
845 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
847 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
849 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
850 AE = AbstractSPDies.end(); AI != AE; ++AI) {
851 DIE *ISP = AI->second;
852 if (InlinedSubprogramDIEs.count(ISP))
854 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
857 // Emit DW_AT_containing_type attribute to connect types with their
858 // vtable holding type.
859 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
860 CUE = CUMap.end(); CUI != CUE; ++CUI) {
861 CompileUnit *TheCU = CUI->second;
862 TheCU->constructContainingTypeDIEs();
865 // Standard sections final addresses.
866 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
867 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
868 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
869 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
871 // End text sections.
872 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
873 Asm->OutStreamer.SwitchSection(SectionMap[I]);
874 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
877 // Compute DIE offsets and sizes.
878 computeSizeAndOffsets();
880 // Emit initial sections.
883 // Emit all the DIEs into a debug info section
886 // Corresponding abbreviations into a abbrev section.
889 // Emit info into the dwarf accelerator table sections.
890 if (useDwarfAccelTables()) {
893 emitAccelNamespaces();
897 // Emit info into a debug pubtypes section.
898 // TODO: When we don't need the option anymore we can
899 // remove all of the code that adds to the table.
900 if (useDarwinGDBCompat())
903 // Emit info into a debug loc section.
906 // Emit info into a debug aranges section.
909 // Emit info into a debug ranges section.
912 // Emit info into a debug macinfo section.
916 // TODO: When we don't need the option anymore we
917 // can remove all of the code that this section
919 if (useDarwinGDBCompat())
920 emitDebugInlineInfo();
922 // Emit info into a debug str section.
926 DeleteContainerSeconds(DeadFnScopeMap);
928 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
929 E = CUMap.end(); I != E; ++I)
931 FirstCU = NULL; // Reset for the next Module, if any.
934 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
935 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
937 LLVMContext &Ctx = DV->getContext();
938 // More then one inlined variable corresponds to one abstract variable.
939 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
940 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
942 return AbsDbgVariable;
944 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
948 AbsDbgVariable = new DbgVariable(Var, NULL);
949 addScopeVariable(Scope, AbsDbgVariable);
950 AbstractVariables[Var] = AbsDbgVariable;
951 return AbsDbgVariable;
954 /// addCurrentFnArgument - If Var is a current function argument then add
955 /// it to CurrentFnArguments list.
956 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
957 DbgVariable *Var, LexicalScope *Scope) {
958 if (!LScopes.isCurrentFunctionScope(Scope))
960 DIVariable DV = Var->getVariable();
961 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
963 unsigned ArgNo = DV.getArgNumber();
967 size_t Size = CurrentFnArguments.size();
969 CurrentFnArguments.resize(MF->getFunction()->arg_size());
970 // llvm::Function argument size is not good indicator of how many
971 // arguments does the function have at source level.
973 CurrentFnArguments.resize(ArgNo * 2);
974 CurrentFnArguments[ArgNo - 1] = Var;
978 /// collectVariableInfoFromMMITable - Collect variable information from
979 /// side table maintained by MMI.
981 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
982 SmallPtrSet<const MDNode *, 16> &Processed) {
983 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
984 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
985 VE = VMap.end(); VI != VE; ++VI) {
986 const MDNode *Var = VI->first;
988 Processed.insert(Var);
990 const std::pair<unsigned, DebugLoc> &VP = VI->second;
992 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
994 // If variable scope is not found then skip this variable.
998 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
999 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1000 RegVar->setFrameIndex(VP.first);
1001 if (!addCurrentFnArgument(MF, RegVar, Scope))
1002 addScopeVariable(Scope, RegVar);
1004 AbsDbgVariable->setFrameIndex(VP.first);
1008 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1009 /// DBG_VALUE instruction, is in a defined reg.
1010 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1011 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1012 return MI->getNumOperands() == 3 &&
1013 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1014 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1017 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
1019 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1020 const MCSymbol *FLabel,
1021 const MCSymbol *SLabel,
1022 const MachineInstr *MI) {
1023 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1025 if (MI->getNumOperands() != 3) {
1026 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1027 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1029 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1030 MachineLocation MLoc;
1031 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1032 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1034 if (MI->getOperand(0).isImm())
1035 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1036 if (MI->getOperand(0).isFPImm())
1037 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1038 if (MI->getOperand(0).isCImm())
1039 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1041 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1044 /// collectVariableInfo - Find variables for each lexical scope.
1046 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1047 SmallPtrSet<const MDNode *, 16> &Processed) {
1049 /// collection info from MMI table.
1050 collectVariableInfoFromMMITable(MF, Processed);
1052 for (SmallVectorImpl<const MDNode*>::const_iterator
1053 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1055 const MDNode *Var = *UVI;
1056 if (Processed.count(Var))
1059 // History contains relevant DBG_VALUE instructions for Var and instructions
1061 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1062 if (History.empty())
1064 const MachineInstr *MInsn = History.front();
1067 LexicalScope *Scope = NULL;
1068 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1069 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1070 Scope = LScopes.getCurrentFunctionScope();
1072 if (DV.getVersion() <= LLVMDebugVersion9)
1073 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1075 if (MDNode *IA = DV.getInlinedAt())
1076 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1078 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1081 // If variable scope is not found then skip this variable.
1085 Processed.insert(DV);
1086 assert(MInsn->isDebugValue() && "History must begin with debug value");
1087 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1088 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1089 if (!addCurrentFnArgument(MF, RegVar, Scope))
1090 addScopeVariable(Scope, RegVar);
1092 AbsVar->setMInsn(MInsn);
1094 // Simplify ranges that are fully coalesced.
1095 if (History.size() <= 1 || (History.size() == 2 &&
1096 MInsn->isIdenticalTo(History.back()))) {
1097 RegVar->setMInsn(MInsn);
1101 // handle multiple DBG_VALUE instructions describing one variable.
1102 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1104 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1105 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1106 const MachineInstr *Begin = *HI;
1107 assert(Begin->isDebugValue() && "Invalid History entry");
1109 // Check if DBG_VALUE is truncating a range.
1110 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1111 && !Begin->getOperand(0).getReg())
1114 // Compute the range for a register location.
1115 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1116 const MCSymbol *SLabel = 0;
1119 // If Begin is the last instruction in History then its value is valid
1120 // until the end of the function.
1121 SLabel = FunctionEndSym;
1123 const MachineInstr *End = HI[1];
1124 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1125 << "\t" << *Begin << "\t" << *End << "\n");
1126 if (End->isDebugValue())
1127 SLabel = getLabelBeforeInsn(End);
1129 // End is a normal instruction clobbering the range.
1130 SLabel = getLabelAfterInsn(End);
1131 assert(SLabel && "Forgot label after clobber instruction");
1136 // The value is valid until the next DBG_VALUE or clobber.
1137 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1140 DotDebugLocEntries.push_back(DotDebugLocEntry());
1143 // Collect info for variables that were optimized out.
1144 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1145 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1146 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1147 DIVariable DV(Variables.getElement(i));
1148 if (!DV || !DV.Verify() || !Processed.insert(DV))
1150 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1151 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1155 /// getLabelBeforeInsn - Return Label preceding the instruction.
1156 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1157 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1158 assert(Label && "Didn't insert label before instruction");
1162 /// getLabelAfterInsn - Return Label immediately following the instruction.
1163 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1164 return LabelsAfterInsn.lookup(MI);
1167 /// beginInstruction - Process beginning of an instruction.
1168 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1169 // Check if source location changes, but ignore DBG_VALUE locations.
1170 if (!MI->isDebugValue()) {
1171 DebugLoc DL = MI->getDebugLoc();
1172 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1175 if (DL == PrologEndLoc) {
1176 Flags |= DWARF2_FLAG_PROLOGUE_END;
1177 PrologEndLoc = DebugLoc();
1179 if (PrologEndLoc.isUnknown())
1180 Flags |= DWARF2_FLAG_IS_STMT;
1182 if (!DL.isUnknown()) {
1183 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1184 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1186 recordSourceLine(0, 0, 0, 0);
1190 // Insert labels where requested.
1191 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1192 LabelsBeforeInsn.find(MI);
1195 if (I == LabelsBeforeInsn.end())
1198 // Label already assigned.
1203 PrevLabel = MMI->getContext().CreateTempSymbol();
1204 Asm->OutStreamer.EmitLabel(PrevLabel);
1206 I->second = PrevLabel;
1209 /// endInstruction - Process end of an instruction.
1210 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1211 // Don't create a new label after DBG_VALUE instructions.
1212 // They don't generate code.
1213 if (!MI->isDebugValue())
1216 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1217 LabelsAfterInsn.find(MI);
1220 if (I == LabelsAfterInsn.end())
1223 // Label already assigned.
1227 // We need a label after this instruction.
1229 PrevLabel = MMI->getContext().CreateTempSymbol();
1230 Asm->OutStreamer.EmitLabel(PrevLabel);
1232 I->second = PrevLabel;
1235 /// identifyScopeMarkers() -
1236 /// Each LexicalScope has first instruction and last instruction to mark
1237 /// beginning and end of a scope respectively. Create an inverse map that list
1238 /// scopes starts (and ends) with an instruction. One instruction may start (or
1239 /// end) multiple scopes. Ignore scopes that are not reachable.
1240 void DwarfDebug::identifyScopeMarkers() {
1241 SmallVector<LexicalScope *, 4> WorkList;
1242 WorkList.push_back(LScopes.getCurrentFunctionScope());
1243 while (!WorkList.empty()) {
1244 LexicalScope *S = WorkList.pop_back_val();
1246 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1247 if (!Children.empty())
1248 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1249 SE = Children.end(); SI != SE; ++SI)
1250 WorkList.push_back(*SI);
1252 if (S->isAbstractScope())
1255 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1258 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1259 RE = Ranges.end(); RI != RE; ++RI) {
1260 assert(RI->first && "InsnRange does not have first instruction!");
1261 assert(RI->second && "InsnRange does not have second instruction!");
1262 requestLabelBeforeInsn(RI->first);
1263 requestLabelAfterInsn(RI->second);
1268 /// getScopeNode - Get MDNode for DebugLoc's scope.
1269 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1270 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1271 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1272 return DL.getScope(Ctx);
1275 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1276 /// line number info for the function.
1277 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1278 const MDNode *Scope = getScopeNode(DL, Ctx);
1279 DISubprogram SP = getDISubprogram(Scope);
1281 // Check for number of operands since the compatibility is
1283 if (SP->getNumOperands() > 19)
1284 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1286 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1292 /// beginFunction - Gather pre-function debug information. Assumes being
1293 /// emitted immediately after the function entry point.
1294 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1295 if (!MMI->hasDebugInfo()) return;
1296 LScopes.initialize(*MF);
1297 if (LScopes.empty()) return;
1298 identifyScopeMarkers();
1300 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1301 Asm->getFunctionNumber());
1302 // Assumes in correct section after the entry point.
1303 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1305 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1307 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1308 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1309 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1311 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1313 bool AtBlockEntry = true;
1314 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1316 const MachineInstr *MI = II;
1318 if (MI->isDebugValue()) {
1319 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1321 // Keep track of user variables.
1323 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1325 // Variable is in a register, we need to check for clobbers.
1326 if (isDbgValueInDefinedReg(MI))
1327 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1329 // Check the history of this variable.
1330 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1331 if (History.empty()) {
1332 UserVariables.push_back(Var);
1333 // The first mention of a function argument gets the FunctionBeginSym
1334 // label, so arguments are visible when breaking at function entry.
1336 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1337 DISubprogram(getDISubprogram(DV.getContext()))
1338 .describes(MF->getFunction()))
1339 LabelsBeforeInsn[MI] = FunctionBeginSym;
1341 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1342 const MachineInstr *Prev = History.back();
1343 if (Prev->isDebugValue()) {
1344 // Coalesce identical entries at the end of History.
1345 if (History.size() >= 2 &&
1346 Prev->isIdenticalTo(History[History.size() - 2])) {
1347 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1349 << "\t" << *History[History.size() - 2] << "\n");
1353 // Terminate old register assignments that don't reach MI;
1354 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1355 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1356 isDbgValueInDefinedReg(Prev)) {
1357 // Previous register assignment needs to terminate at the end of
1359 MachineBasicBlock::const_iterator LastMI =
1360 PrevMBB->getLastNonDebugInstr();
1361 if (LastMI == PrevMBB->end()) {
1362 // Drop DBG_VALUE for empty range.
1363 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1364 << "\t" << *Prev << "\n");
1368 // Terminate after LastMI.
1369 History.push_back(LastMI);
1374 History.push_back(MI);
1376 // Not a DBG_VALUE instruction.
1378 AtBlockEntry = false;
1380 // First known non-DBG_VALUE and non-frame setup location marks
1381 // the beginning of the function body.
1382 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1383 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1384 PrologEndLoc = MI->getDebugLoc();
1386 // Check if the instruction clobbers any registers with debug vars.
1387 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1388 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1389 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1391 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1392 AI.isValid(); ++AI) {
1394 const MDNode *Var = LiveUserVar[Reg];
1397 // Reg is now clobbered.
1398 LiveUserVar[Reg] = 0;
1400 // Was MD last defined by a DBG_VALUE referring to Reg?
1401 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1402 if (HistI == DbgValues.end())
1404 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1405 if (History.empty())
1407 const MachineInstr *Prev = History.back();
1408 // Sanity-check: Register assignments are terminated at the end of
1410 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1412 // Is the variable still in Reg?
1413 if (!isDbgValueInDefinedReg(Prev) ||
1414 Prev->getOperand(0).getReg() != Reg)
1416 // Var is clobbered. Make sure the next instruction gets a label.
1417 History.push_back(MI);
1424 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1426 SmallVectorImpl<const MachineInstr*> &History = I->second;
1427 if (History.empty())
1430 // Make sure the final register assignments are terminated.
1431 const MachineInstr *Prev = History.back();
1432 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1433 const MachineBasicBlock *PrevMBB = Prev->getParent();
1434 MachineBasicBlock::const_iterator LastMI =
1435 PrevMBB->getLastNonDebugInstr();
1436 if (LastMI == PrevMBB->end())
1437 // Drop DBG_VALUE for empty range.
1440 // Terminate after LastMI.
1441 History.push_back(LastMI);
1444 // Request labels for the full history.
1445 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1446 const MachineInstr *MI = History[i];
1447 if (MI->isDebugValue())
1448 requestLabelBeforeInsn(MI);
1450 requestLabelAfterInsn(MI);
1454 PrevInstLoc = DebugLoc();
1455 PrevLabel = FunctionBeginSym;
1457 // Record beginning of function.
1458 if (!PrologEndLoc.isUnknown()) {
1459 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1460 MF->getFunction()->getContext());
1461 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1462 FnStartDL.getScope(MF->getFunction()->getContext()),
1467 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1468 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1469 ScopeVariables[LS].push_back(Var);
1470 // Vars.push_back(Var);
1473 /// endFunction - Gather and emit post-function debug information.
1475 void DwarfDebug::endFunction(const MachineFunction *MF) {
1476 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1478 // Define end label for subprogram.
1479 FunctionEndSym = Asm->GetTempSymbol("func_end",
1480 Asm->getFunctionNumber());
1481 // Assumes in correct section after the entry point.
1482 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1484 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1485 collectVariableInfo(MF, ProcessedVars);
1487 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1488 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1489 assert(TheCU && "Unable to find compile unit!");
1491 // Construct abstract scopes.
1492 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1493 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1494 LexicalScope *AScope = AList[i];
1495 DISubprogram SP(AScope->getScopeNode());
1497 // Collect info for variables that were optimized out.
1498 DIArray Variables = SP.getVariables();
1499 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1500 DIVariable DV(Variables.getElement(i));
1501 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1503 // Check that DbgVariable for DV wasn't created earlier, when
1504 // findAbstractVariable() was called for inlined instance of DV.
1505 LLVMContext &Ctx = DV->getContext();
1506 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1507 if (AbstractVariables.lookup(CleanDV))
1509 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1510 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1513 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1514 constructScopeDIE(TheCU, AScope);
1517 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1519 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1520 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1522 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1523 MMI->getFrameMoves()));
1526 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1527 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1528 DeleteContainerPointers(I->second);
1529 ScopeVariables.clear();
1530 DeleteContainerPointers(CurrentFnArguments);
1531 UserVariables.clear();
1533 AbstractVariables.clear();
1534 LabelsBeforeInsn.clear();
1535 LabelsAfterInsn.clear();
1539 /// recordSourceLine - Register a source line with debug info. Returns the
1540 /// unique label that was emitted and which provides correspondence to
1541 /// the source line list.
1542 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1548 DIDescriptor Scope(S);
1550 if (Scope.isCompileUnit()) {
1551 DICompileUnit CU(S);
1552 Fn = CU.getFilename();
1553 Dir = CU.getDirectory();
1554 } else if (Scope.isFile()) {
1556 Fn = F.getFilename();
1557 Dir = F.getDirectory();
1558 } else if (Scope.isSubprogram()) {
1560 Fn = SP.getFilename();
1561 Dir = SP.getDirectory();
1562 } else if (Scope.isLexicalBlockFile()) {
1563 DILexicalBlockFile DBF(S);
1564 Fn = DBF.getFilename();
1565 Dir = DBF.getDirectory();
1566 } else if (Scope.isLexicalBlock()) {
1567 DILexicalBlock DB(S);
1568 Fn = DB.getFilename();
1569 Dir = DB.getDirectory();
1571 llvm_unreachable("Unexpected scope info");
1573 Src = GetOrCreateSourceID(Fn, Dir);
1575 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1578 //===----------------------------------------------------------------------===//
1580 //===----------------------------------------------------------------------===//
1582 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1585 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1586 // Get the children.
1587 const std::vector<DIE *> &Children = Die->getChildren();
1589 // Record the abbreviation.
1590 assignAbbrevNumber(Die->getAbbrev());
1592 // Get the abbreviation for this DIE.
1593 unsigned AbbrevNumber = Die->getAbbrevNumber();
1594 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1597 Die->setOffset(Offset);
1599 // Start the size with the size of abbreviation code.
1600 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1602 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1603 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1605 // Size the DIE attribute values.
1606 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1607 // Size attribute value.
1608 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1610 // Size the DIE children if any.
1611 if (!Children.empty()) {
1612 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1613 "Children flag not set");
1615 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1616 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1618 // End of children marker.
1619 Offset += sizeof(int8_t);
1622 Die->setSize(Offset - Die->getOffset());
1626 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1628 void DwarfDebug::computeSizeAndOffsets() {
1629 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1630 E = CUMap.end(); I != E; ++I) {
1631 // Compute size of compile unit header.
1633 sizeof(int32_t) + // Length of Compilation Unit Info
1634 sizeof(int16_t) + // DWARF version number
1635 sizeof(int32_t) + // Offset Into Abbrev. Section
1636 sizeof(int8_t); // Pointer Size (in bytes)
1637 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1641 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1642 /// the start of each one.
1643 void DwarfDebug::EmitSectionLabels() {
1644 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1646 // Dwarf sections base addresses.
1647 DwarfInfoSectionSym =
1648 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1649 DwarfAbbrevSectionSym =
1650 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1651 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1653 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1654 EmitSectionSym(Asm, MacroInfo);
1656 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1657 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1658 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1659 DwarfStrSectionSym =
1660 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1661 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1664 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1665 "section_debug_loc");
1667 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1668 EmitSectionSym(Asm, TLOF.getDataSection());
1671 /// emitDIE - Recursively emits a debug information entry.
1673 void DwarfDebug::emitDIE(DIE *Die) {
1674 // Get the abbreviation for this DIE.
1675 unsigned AbbrevNumber = Die->getAbbrevNumber();
1676 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1678 // Emit the code (index) for the abbreviation.
1679 if (Asm->isVerbose())
1680 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1681 Twine::utohexstr(Die->getOffset()) + ":0x" +
1682 Twine::utohexstr(Die->getSize()) + " " +
1683 dwarf::TagString(Abbrev->getTag()));
1684 Asm->EmitULEB128(AbbrevNumber);
1686 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1687 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1689 // Emit the DIE attribute values.
1690 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1691 unsigned Attr = AbbrevData[i].getAttribute();
1692 unsigned Form = AbbrevData[i].getForm();
1693 assert(Form && "Too many attributes for DIE (check abbreviation)");
1695 if (Asm->isVerbose())
1696 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1699 case dwarf::DW_AT_abstract_origin: {
1700 DIEEntry *E = cast<DIEEntry>(Values[i]);
1701 DIE *Origin = E->getEntry();
1702 unsigned Addr = Origin->getOffset();
1703 Asm->EmitInt32(Addr);
1706 case dwarf::DW_AT_ranges: {
1707 // DW_AT_range Value encodes offset in debug_range section.
1708 DIEInteger *V = cast<DIEInteger>(Values[i]);
1710 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1711 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1715 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1717 DwarfDebugRangeSectionSym,
1722 case dwarf::DW_AT_location: {
1723 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1724 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1725 Asm->EmitLabelReference(L->getValue(), 4);
1727 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1729 Values[i]->EmitValue(Asm, Form);
1733 case dwarf::DW_AT_accessibility: {
1734 if (Asm->isVerbose()) {
1735 DIEInteger *V = cast<DIEInteger>(Values[i]);
1736 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1738 Values[i]->EmitValue(Asm, Form);
1742 // Emit an attribute using the defined form.
1743 Values[i]->EmitValue(Asm, Form);
1748 // Emit the DIE children if any.
1749 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1750 const std::vector<DIE *> &Children = Die->getChildren();
1752 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1753 emitDIE(Children[j]);
1755 if (Asm->isVerbose())
1756 Asm->OutStreamer.AddComment("End Of Children Mark");
1761 /// emitDebugInfo - Emit the debug info section.
1763 void DwarfDebug::emitDebugInfo() {
1764 // Start debug info section.
1765 Asm->OutStreamer.SwitchSection(
1766 Asm->getObjFileLowering().getDwarfInfoSection());
1767 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1768 E = CUMap.end(); I != E; ++I) {
1769 CompileUnit *TheCU = I->second;
1770 DIE *Die = TheCU->getCUDie();
1772 // Emit the compile units header.
1773 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1776 // Emit size of content not including length itself
1777 unsigned ContentSize = Die->getSize() +
1778 sizeof(int16_t) + // DWARF version number
1779 sizeof(int32_t) + // Offset Into Abbrev. Section
1780 sizeof(int8_t); // Pointer Size (in bytes)
1782 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1783 Asm->EmitInt32(ContentSize);
1784 Asm->OutStreamer.AddComment("DWARF version number");
1785 Asm->EmitInt16(dwarf::DWARF_VERSION);
1786 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1787 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1788 DwarfAbbrevSectionSym);
1789 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1790 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1793 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1797 /// emitAbbreviations - Emit the abbreviation section.
1799 void DwarfDebug::emitAbbreviations() const {
1800 // Check to see if it is worth the effort.
1801 if (!Abbreviations.empty()) {
1802 // Start the debug abbrev section.
1803 Asm->OutStreamer.SwitchSection(
1804 Asm->getObjFileLowering().getDwarfAbbrevSection());
1806 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1808 // For each abbrevation.
1809 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1810 // Get abbreviation data
1811 const DIEAbbrev *Abbrev = Abbreviations[i];
1813 // Emit the abbrevations code (base 1 index.)
1814 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1816 // Emit the abbreviations data.
1820 // Mark end of abbreviations.
1821 Asm->EmitULEB128(0, "EOM(3)");
1823 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1827 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1828 /// the line matrix.
1830 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1831 // Define last address of section.
1832 Asm->OutStreamer.AddComment("Extended Op");
1835 Asm->OutStreamer.AddComment("Op size");
1836 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1837 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1838 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1840 Asm->OutStreamer.AddComment("Section end label");
1842 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1843 Asm->getDataLayout().getPointerSize(),
1846 // Mark end of matrix.
1847 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1853 /// emitAccelNames - Emit visible names into a hashed accelerator table
1855 void DwarfDebug::emitAccelNames() {
1856 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1857 dwarf::DW_FORM_data4));
1858 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1859 E = CUMap.end(); I != E; ++I) {
1860 CompileUnit *TheCU = I->second;
1861 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1862 for (StringMap<std::vector<DIE*> >::const_iterator
1863 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1864 const char *Name = GI->getKeyData();
1865 const std::vector<DIE *> &Entities = GI->second;
1866 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1867 DE = Entities.end(); DI != DE; ++DI)
1868 AT.AddName(Name, (*DI));
1872 AT.FinalizeTable(Asm, "Names");
1873 Asm->OutStreamer.SwitchSection(
1874 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1875 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1876 Asm->OutStreamer.EmitLabel(SectionBegin);
1878 // Emit the full data.
1879 AT.Emit(Asm, SectionBegin, this);
1882 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1883 /// accelerator table section.
1884 void DwarfDebug::emitAccelObjC() {
1885 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1886 dwarf::DW_FORM_data4));
1887 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1888 E = CUMap.end(); I != E; ++I) {
1889 CompileUnit *TheCU = I->second;
1890 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1891 for (StringMap<std::vector<DIE*> >::const_iterator
1892 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1893 const char *Name = GI->getKeyData();
1894 const std::vector<DIE *> &Entities = GI->second;
1895 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1896 DE = Entities.end(); DI != DE; ++DI)
1897 AT.AddName(Name, (*DI));
1901 AT.FinalizeTable(Asm, "ObjC");
1902 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1903 .getDwarfAccelObjCSection());
1904 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1905 Asm->OutStreamer.EmitLabel(SectionBegin);
1907 // Emit the full data.
1908 AT.Emit(Asm, SectionBegin, this);
1911 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1913 void DwarfDebug::emitAccelNamespaces() {
1914 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1915 dwarf::DW_FORM_data4));
1916 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1917 E = CUMap.end(); I != E; ++I) {
1918 CompileUnit *TheCU = I->second;
1919 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1920 for (StringMap<std::vector<DIE*> >::const_iterator
1921 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1922 const char *Name = GI->getKeyData();
1923 const std::vector<DIE *> &Entities = GI->second;
1924 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1925 DE = Entities.end(); DI != DE; ++DI)
1926 AT.AddName(Name, (*DI));
1930 AT.FinalizeTable(Asm, "namespac");
1931 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1932 .getDwarfAccelNamespaceSection());
1933 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1934 Asm->OutStreamer.EmitLabel(SectionBegin);
1936 // Emit the full data.
1937 AT.Emit(Asm, SectionBegin, this);
1940 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1941 void DwarfDebug::emitAccelTypes() {
1942 std::vector<DwarfAccelTable::Atom> Atoms;
1943 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1944 dwarf::DW_FORM_data4));
1945 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1946 dwarf::DW_FORM_data2));
1947 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1948 dwarf::DW_FORM_data1));
1949 DwarfAccelTable AT(Atoms);
1950 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1951 E = CUMap.end(); I != E; ++I) {
1952 CompileUnit *TheCU = I->second;
1953 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1954 = TheCU->getAccelTypes();
1955 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1956 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1957 const char *Name = GI->getKeyData();
1958 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1959 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1960 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1961 AT.AddName(Name, (*DI).first, (*DI).second);
1965 AT.FinalizeTable(Asm, "types");
1966 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1967 .getDwarfAccelTypesSection());
1968 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1969 Asm->OutStreamer.EmitLabel(SectionBegin);
1971 // Emit the full data.
1972 AT.Emit(Asm, SectionBegin, this);
1975 void DwarfDebug::emitDebugPubTypes() {
1976 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1977 E = CUMap.end(); I != E; ++I) {
1978 CompileUnit *TheCU = I->second;
1979 // Start the dwarf pubtypes section.
1980 Asm->OutStreamer.SwitchSection(
1981 Asm->getObjFileLowering().getDwarfPubTypesSection());
1982 Asm->OutStreamer.AddComment("Length of Public Types Info");
1983 Asm->EmitLabelDifference(
1984 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1985 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1987 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1990 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1991 Asm->EmitInt16(dwarf::DWARF_VERSION);
1993 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1994 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1995 DwarfInfoSectionSym);
1997 Asm->OutStreamer.AddComment("Compilation Unit Length");
1998 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1999 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2002 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2003 for (StringMap<DIE*>::const_iterator
2004 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2005 const char *Name = GI->getKeyData();
2006 DIE *Entity = GI->second;
2008 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2009 Asm->EmitInt32(Entity->getOffset());
2011 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2012 // Emit the name with a terminating null byte.
2013 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2016 Asm->OutStreamer.AddComment("End Mark");
2018 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2023 /// emitDebugStr - Emit visible names into a debug str section.
2025 void DwarfDebug::emitDebugStr() {
2026 // Check to see if it is worth the effort.
2027 if (StringPool.empty()) return;
2029 // Start the dwarf str section.
2030 Asm->OutStreamer.SwitchSection(
2031 Asm->getObjFileLowering().getDwarfStrSection());
2033 // Get all of the string pool entries and put them in an array by their ID so
2034 // we can sort them.
2035 SmallVector<std::pair<unsigned,
2036 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2038 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2039 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2040 Entries.push_back(std::make_pair(I->second.second, &*I));
2042 array_pod_sort(Entries.begin(), Entries.end());
2044 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2045 // Emit a label for reference from debug information entries.
2046 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2048 // Emit the string itself with a terminating null byte.
2049 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2050 Entries[i].second->getKeyLength()+1),
2055 /// emitDebugLoc - Emit visible names into a debug loc section.
2057 void DwarfDebug::emitDebugLoc() {
2058 if (DotDebugLocEntries.empty())
2061 for (SmallVector<DotDebugLocEntry, 4>::iterator
2062 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2064 DotDebugLocEntry &Entry = *I;
2065 if (I + 1 != DotDebugLocEntries.end())
2069 // Start the dwarf loc section.
2070 Asm->OutStreamer.SwitchSection(
2071 Asm->getObjFileLowering().getDwarfLocSection());
2072 unsigned char Size = Asm->getDataLayout().getPointerSize();
2073 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2075 for (SmallVector<DotDebugLocEntry, 4>::iterator
2076 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2077 I != E; ++I, ++index) {
2078 DotDebugLocEntry &Entry = *I;
2079 if (Entry.isMerged()) continue;
2080 if (Entry.isEmpty()) {
2081 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2082 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2083 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2085 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2086 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2087 DIVariable DV(Entry.Variable);
2088 Asm->OutStreamer.AddComment("Loc expr size");
2089 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2090 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2091 Asm->EmitLabelDifference(end, begin, 2);
2092 Asm->OutStreamer.EmitLabel(begin);
2093 if (Entry.isInt()) {
2094 DIBasicType BTy(DV.getType());
2096 (BTy.getEncoding() == dwarf::DW_ATE_signed
2097 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2098 Asm->OutStreamer.AddComment("DW_OP_consts");
2099 Asm->EmitInt8(dwarf::DW_OP_consts);
2100 Asm->EmitSLEB128(Entry.getInt());
2102 Asm->OutStreamer.AddComment("DW_OP_constu");
2103 Asm->EmitInt8(dwarf::DW_OP_constu);
2104 Asm->EmitULEB128(Entry.getInt());
2106 } else if (Entry.isLocation()) {
2107 if (!DV.hasComplexAddress())
2109 Asm->EmitDwarfRegOp(Entry.Loc);
2111 // Complex address entry.
2112 unsigned N = DV.getNumAddrElements();
2114 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2115 if (Entry.Loc.getOffset()) {
2117 Asm->EmitDwarfRegOp(Entry.Loc);
2118 Asm->OutStreamer.AddComment("DW_OP_deref");
2119 Asm->EmitInt8(dwarf::DW_OP_deref);
2120 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2121 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2122 Asm->EmitSLEB128(DV.getAddrElement(1));
2124 // If first address element is OpPlus then emit
2125 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2126 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2127 Asm->EmitDwarfRegOp(Loc);
2131 Asm->EmitDwarfRegOp(Entry.Loc);
2134 // Emit remaining complex address elements.
2135 for (; i < N; ++i) {
2136 uint64_t Element = DV.getAddrElement(i);
2137 if (Element == DIBuilder::OpPlus) {
2138 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2139 Asm->EmitULEB128(DV.getAddrElement(++i));
2140 } else if (Element == DIBuilder::OpDeref) {
2141 if (!Entry.Loc.isReg())
2142 Asm->EmitInt8(dwarf::DW_OP_deref);
2144 llvm_unreachable("unknown Opcode found in complex address");
2148 // else ... ignore constant fp. There is not any good way to
2149 // to represent them here in dwarf.
2150 Asm->OutStreamer.EmitLabel(end);
2155 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2157 void DwarfDebug::EmitDebugARanges() {
2158 // Start the dwarf aranges section.
2159 Asm->OutStreamer.SwitchSection(
2160 Asm->getObjFileLowering().getDwarfARangesSection());
2163 /// emitDebugRanges - Emit visible names into a debug ranges section.
2165 void DwarfDebug::emitDebugRanges() {
2166 // Start the dwarf ranges section.
2167 Asm->OutStreamer.SwitchSection(
2168 Asm->getObjFileLowering().getDwarfRangesSection());
2169 unsigned char Size = Asm->getDataLayout().getPointerSize();
2170 for (SmallVector<const MCSymbol *, 8>::iterator
2171 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2174 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2176 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2180 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2182 void DwarfDebug::emitDebugMacInfo() {
2183 if (const MCSection *LineInfo =
2184 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2185 // Start the dwarf macinfo section.
2186 Asm->OutStreamer.SwitchSection(LineInfo);
2190 /// emitDebugInlineInfo - Emit inline info using following format.
2192 /// 1. length of section
2193 /// 2. Dwarf version number
2194 /// 3. address size.
2196 /// Entries (one "entry" for each function that was inlined):
2198 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2199 /// otherwise offset into __debug_str for regular function name.
2200 /// 2. offset into __debug_str section for regular function name.
2201 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2202 /// instances for the function.
2204 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2205 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2206 /// __debug_info section, and the low_pc is the starting address for the
2207 /// inlining instance.
2208 void DwarfDebug::emitDebugInlineInfo() {
2209 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2215 Asm->OutStreamer.SwitchSection(
2216 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2218 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2219 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2220 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2222 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2224 Asm->OutStreamer.AddComment("Dwarf Version");
2225 Asm->EmitInt16(dwarf::DWARF_VERSION);
2226 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2227 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2229 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2230 E = InlinedSPNodes.end(); I != E; ++I) {
2232 const MDNode *Node = *I;
2233 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2234 = InlineInfo.find(Node);
2235 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2236 DISubprogram SP(Node);
2237 StringRef LName = SP.getLinkageName();
2238 StringRef Name = SP.getName();
2240 Asm->OutStreamer.AddComment("MIPS linkage name");
2242 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2244 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2245 DwarfStrSectionSym);
2247 Asm->OutStreamer.AddComment("Function name");
2248 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2249 Asm->EmitULEB128(Labels.size(), "Inline count");
2251 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2252 LE = Labels.end(); LI != LE; ++LI) {
2253 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2254 Asm->EmitInt32(LI->second->getOffset());
2256 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2257 Asm->OutStreamer.EmitSymbolValue(LI->first,
2258 Asm->getDataLayout().getPointerSize(),0);
2262 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));