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 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
801 void DwarfDebug::computeInlinedDIEs() {
802 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
803 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
804 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
806 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
808 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
809 AE = AbstractSPDies.end(); AI != AE; ++AI) {
810 DIE *ISP = AI->second;
811 if (InlinedSubprogramDIEs.count(ISP))
813 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
817 // Collect info for variables that were optimized out.
818 void DwarfDebug::collectDeadVariables() {
819 const Module *M = MMI->getModule();
820 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
822 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
823 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
824 DICompileUnit TheCU(CU_Nodes->getOperand(i));
825 DIArray Subprograms = TheCU.getSubprograms();
826 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
827 DISubprogram SP(Subprograms.getElement(i));
828 if (ProcessedSPNodes.count(SP) != 0) continue;
829 if (!SP.Verify()) continue;
830 if (!SP.isDefinition()) continue;
831 DIArray Variables = SP.getVariables();
832 if (Variables.getNumElements() == 0) continue;
834 LexicalScope *Scope =
835 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
836 DeadFnScopeMap[SP] = Scope;
838 // Construct subprogram DIE and add variables DIEs.
839 CompileUnit *SPCU = CUMap.lookup(TheCU);
840 assert(SPCU && "Unable to find Compile Unit!");
841 constructSubprogramDIE(SPCU, SP);
842 DIE *ScopeDIE = SPCU->getDIE(SP);
843 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
844 DIVariable DV(Variables.getElement(vi));
845 if (!DV.Verify()) continue;
846 DbgVariable *NewVar = new DbgVariable(DV, NULL);
847 if (DIE *VariableDIE =
848 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
849 ScopeDIE->addChild(VariableDIE);
854 DeleteContainerSeconds(DeadFnScopeMap);
857 void DwarfDebug::finalizeModuleInfo() {
858 // Collect info for variables that were optimized out.
859 collectDeadVariables();
861 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
862 computeInlinedDIEs();
864 // Emit DW_AT_containing_type attribute to connect types with their
865 // vtable holding type.
866 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
867 CUE = CUMap.end(); CUI != CUE; ++CUI) {
868 CompileUnit *TheCU = CUI->second;
869 TheCU->constructContainingTypeDIEs();
872 // Compute DIE offsets and sizes.
873 computeSizeAndOffsets();
876 void DwarfDebug::endSections() {
877 // Standard sections final addresses.
878 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
879 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
880 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
881 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
883 // End text sections.
884 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
885 Asm->OutStreamer.SwitchSection(SectionMap[I]);
886 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
890 /// endModule - Emit all Dwarf sections that should come after the content.
892 void DwarfDebug::endModule() {
894 if (!FirstCU) return;
896 // End any existing sections.
897 // TODO: Does this need to happen?
900 // Finalize the debug info for the module.
901 finalizeModuleInfo();
903 // Emit initial sections.
906 // Emit all the DIEs into a debug info section
909 // Corresponding abbreviations into a abbrev section.
912 // Emit info into the dwarf accelerator table sections.
913 if (useDwarfAccelTables()) {
916 emitAccelNamespaces();
920 // Emit info into a debug pubtypes section.
921 // TODO: When we don't need the option anymore we can
922 // remove all of the code that adds to the table.
923 if (useDarwinGDBCompat())
926 // Emit info into a debug loc section.
929 // Emit info into a debug aranges section.
932 // Emit info into a debug ranges section.
935 // Emit info into a debug macinfo section.
939 // TODO: When we don't need the option anymore we
940 // can remove all of the code that this section
942 if (useDarwinGDBCompat())
943 emitDebugInlineInfo();
945 // Emit info into a debug str section.
950 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
951 E = CUMap.end(); I != E; ++I)
953 FirstCU = NULL; // Reset for the next Module, if any.
956 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
957 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
959 LLVMContext &Ctx = DV->getContext();
960 // More then one inlined variable corresponds to one abstract variable.
961 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
962 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
964 return AbsDbgVariable;
966 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
970 AbsDbgVariable = new DbgVariable(Var, NULL);
971 addScopeVariable(Scope, AbsDbgVariable);
972 AbstractVariables[Var] = AbsDbgVariable;
973 return AbsDbgVariable;
976 /// addCurrentFnArgument - If Var is a current function argument then add
977 /// it to CurrentFnArguments list.
978 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
979 DbgVariable *Var, LexicalScope *Scope) {
980 if (!LScopes.isCurrentFunctionScope(Scope))
982 DIVariable DV = Var->getVariable();
983 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
985 unsigned ArgNo = DV.getArgNumber();
989 size_t Size = CurrentFnArguments.size();
991 CurrentFnArguments.resize(MF->getFunction()->arg_size());
992 // llvm::Function argument size is not good indicator of how many
993 // arguments does the function have at source level.
995 CurrentFnArguments.resize(ArgNo * 2);
996 CurrentFnArguments[ArgNo - 1] = Var;
1000 /// collectVariableInfoFromMMITable - Collect variable information from
1001 /// side table maintained by MMI.
1003 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1004 SmallPtrSet<const MDNode *, 16> &Processed) {
1005 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1006 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1007 VE = VMap.end(); VI != VE; ++VI) {
1008 const MDNode *Var = VI->first;
1010 Processed.insert(Var);
1012 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1014 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1016 // If variable scope is not found then skip this variable.
1020 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1021 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1022 RegVar->setFrameIndex(VP.first);
1023 if (!addCurrentFnArgument(MF, RegVar, Scope))
1024 addScopeVariable(Scope, RegVar);
1026 AbsDbgVariable->setFrameIndex(VP.first);
1030 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1031 /// DBG_VALUE instruction, is in a defined reg.
1032 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1033 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1034 return MI->getNumOperands() == 3 &&
1035 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1036 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1039 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
1041 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1042 const MCSymbol *FLabel,
1043 const MCSymbol *SLabel,
1044 const MachineInstr *MI) {
1045 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1047 if (MI->getNumOperands() != 3) {
1048 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1049 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1051 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1052 MachineLocation MLoc;
1053 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1054 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1056 if (MI->getOperand(0).isImm())
1057 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1058 if (MI->getOperand(0).isFPImm())
1059 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1060 if (MI->getOperand(0).isCImm())
1061 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1063 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1066 /// collectVariableInfo - Find variables for each lexical scope.
1068 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1069 SmallPtrSet<const MDNode *, 16> &Processed) {
1071 /// collection info from MMI table.
1072 collectVariableInfoFromMMITable(MF, Processed);
1074 for (SmallVectorImpl<const MDNode*>::const_iterator
1075 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1077 const MDNode *Var = *UVI;
1078 if (Processed.count(Var))
1081 // History contains relevant DBG_VALUE instructions for Var and instructions
1083 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1084 if (History.empty())
1086 const MachineInstr *MInsn = History.front();
1089 LexicalScope *Scope = NULL;
1090 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1091 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1092 Scope = LScopes.getCurrentFunctionScope();
1094 if (DV.getVersion() <= LLVMDebugVersion9)
1095 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1097 if (MDNode *IA = DV.getInlinedAt())
1098 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1100 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1103 // If variable scope is not found then skip this variable.
1107 Processed.insert(DV);
1108 assert(MInsn->isDebugValue() && "History must begin with debug value");
1109 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1110 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1111 if (!addCurrentFnArgument(MF, RegVar, Scope))
1112 addScopeVariable(Scope, RegVar);
1114 AbsVar->setMInsn(MInsn);
1116 // Simplify ranges that are fully coalesced.
1117 if (History.size() <= 1 || (History.size() == 2 &&
1118 MInsn->isIdenticalTo(History.back()))) {
1119 RegVar->setMInsn(MInsn);
1123 // handle multiple DBG_VALUE instructions describing one variable.
1124 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1126 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1127 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1128 const MachineInstr *Begin = *HI;
1129 assert(Begin->isDebugValue() && "Invalid History entry");
1131 // Check if DBG_VALUE is truncating a range.
1132 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1133 && !Begin->getOperand(0).getReg())
1136 // Compute the range for a register location.
1137 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1138 const MCSymbol *SLabel = 0;
1141 // If Begin is the last instruction in History then its value is valid
1142 // until the end of the function.
1143 SLabel = FunctionEndSym;
1145 const MachineInstr *End = HI[1];
1146 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1147 << "\t" << *Begin << "\t" << *End << "\n");
1148 if (End->isDebugValue())
1149 SLabel = getLabelBeforeInsn(End);
1151 // End is a normal instruction clobbering the range.
1152 SLabel = getLabelAfterInsn(End);
1153 assert(SLabel && "Forgot label after clobber instruction");
1158 // The value is valid until the next DBG_VALUE or clobber.
1159 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1162 DotDebugLocEntries.push_back(DotDebugLocEntry());
1165 // Collect info for variables that were optimized out.
1166 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1167 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1168 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1169 DIVariable DV(Variables.getElement(i));
1170 if (!DV || !DV.Verify() || !Processed.insert(DV))
1172 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1173 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1177 /// getLabelBeforeInsn - Return Label preceding the instruction.
1178 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1179 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1180 assert(Label && "Didn't insert label before instruction");
1184 /// getLabelAfterInsn - Return Label immediately following the instruction.
1185 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1186 return LabelsAfterInsn.lookup(MI);
1189 /// beginInstruction - Process beginning of an instruction.
1190 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1191 // Check if source location changes, but ignore DBG_VALUE locations.
1192 if (!MI->isDebugValue()) {
1193 DebugLoc DL = MI->getDebugLoc();
1194 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1197 if (DL == PrologEndLoc) {
1198 Flags |= DWARF2_FLAG_PROLOGUE_END;
1199 PrologEndLoc = DebugLoc();
1201 if (PrologEndLoc.isUnknown())
1202 Flags |= DWARF2_FLAG_IS_STMT;
1204 if (!DL.isUnknown()) {
1205 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1206 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1208 recordSourceLine(0, 0, 0, 0);
1212 // Insert labels where requested.
1213 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1214 LabelsBeforeInsn.find(MI);
1217 if (I == LabelsBeforeInsn.end())
1220 // Label already assigned.
1225 PrevLabel = MMI->getContext().CreateTempSymbol();
1226 Asm->OutStreamer.EmitLabel(PrevLabel);
1228 I->second = PrevLabel;
1231 /// endInstruction - Process end of an instruction.
1232 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1233 // Don't create a new label after DBG_VALUE instructions.
1234 // They don't generate code.
1235 if (!MI->isDebugValue())
1238 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1239 LabelsAfterInsn.find(MI);
1242 if (I == LabelsAfterInsn.end())
1245 // Label already assigned.
1249 // We need a label after this instruction.
1251 PrevLabel = MMI->getContext().CreateTempSymbol();
1252 Asm->OutStreamer.EmitLabel(PrevLabel);
1254 I->second = PrevLabel;
1257 /// identifyScopeMarkers() -
1258 /// Each LexicalScope has first instruction and last instruction to mark
1259 /// beginning and end of a scope respectively. Create an inverse map that list
1260 /// scopes starts (and ends) with an instruction. One instruction may start (or
1261 /// end) multiple scopes. Ignore scopes that are not reachable.
1262 void DwarfDebug::identifyScopeMarkers() {
1263 SmallVector<LexicalScope *, 4> WorkList;
1264 WorkList.push_back(LScopes.getCurrentFunctionScope());
1265 while (!WorkList.empty()) {
1266 LexicalScope *S = WorkList.pop_back_val();
1268 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1269 if (!Children.empty())
1270 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1271 SE = Children.end(); SI != SE; ++SI)
1272 WorkList.push_back(*SI);
1274 if (S->isAbstractScope())
1277 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1280 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1281 RE = Ranges.end(); RI != RE; ++RI) {
1282 assert(RI->first && "InsnRange does not have first instruction!");
1283 assert(RI->second && "InsnRange does not have second instruction!");
1284 requestLabelBeforeInsn(RI->first);
1285 requestLabelAfterInsn(RI->second);
1290 /// getScopeNode - Get MDNode for DebugLoc's scope.
1291 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1292 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1293 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1294 return DL.getScope(Ctx);
1297 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1298 /// line number info for the function.
1299 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1300 const MDNode *Scope = getScopeNode(DL, Ctx);
1301 DISubprogram SP = getDISubprogram(Scope);
1303 // Check for number of operands since the compatibility is
1305 if (SP->getNumOperands() > 19)
1306 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1308 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1314 /// beginFunction - Gather pre-function debug information. Assumes being
1315 /// emitted immediately after the function entry point.
1316 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1317 if (!MMI->hasDebugInfo()) return;
1318 LScopes.initialize(*MF);
1319 if (LScopes.empty()) return;
1320 identifyScopeMarkers();
1322 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1323 Asm->getFunctionNumber());
1324 // Assumes in correct section after the entry point.
1325 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1327 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1329 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1330 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1331 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1333 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1335 bool AtBlockEntry = true;
1336 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1338 const MachineInstr *MI = II;
1340 if (MI->isDebugValue()) {
1341 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1343 // Keep track of user variables.
1345 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1347 // Variable is in a register, we need to check for clobbers.
1348 if (isDbgValueInDefinedReg(MI))
1349 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1351 // Check the history of this variable.
1352 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1353 if (History.empty()) {
1354 UserVariables.push_back(Var);
1355 // The first mention of a function argument gets the FunctionBeginSym
1356 // label, so arguments are visible when breaking at function entry.
1358 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1359 DISubprogram(getDISubprogram(DV.getContext()))
1360 .describes(MF->getFunction()))
1361 LabelsBeforeInsn[MI] = FunctionBeginSym;
1363 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1364 const MachineInstr *Prev = History.back();
1365 if (Prev->isDebugValue()) {
1366 // Coalesce identical entries at the end of History.
1367 if (History.size() >= 2 &&
1368 Prev->isIdenticalTo(History[History.size() - 2])) {
1369 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1371 << "\t" << *History[History.size() - 2] << "\n");
1375 // Terminate old register assignments that don't reach MI;
1376 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1377 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1378 isDbgValueInDefinedReg(Prev)) {
1379 // Previous register assignment needs to terminate at the end of
1381 MachineBasicBlock::const_iterator LastMI =
1382 PrevMBB->getLastNonDebugInstr();
1383 if (LastMI == PrevMBB->end()) {
1384 // Drop DBG_VALUE for empty range.
1385 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1386 << "\t" << *Prev << "\n");
1390 // Terminate after LastMI.
1391 History.push_back(LastMI);
1396 History.push_back(MI);
1398 // Not a DBG_VALUE instruction.
1400 AtBlockEntry = false;
1402 // First known non-DBG_VALUE and non-frame setup location marks
1403 // the beginning of the function body.
1404 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1405 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1406 PrologEndLoc = MI->getDebugLoc();
1408 // Check if the instruction clobbers any registers with debug vars.
1409 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1410 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1411 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1413 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1414 AI.isValid(); ++AI) {
1416 const MDNode *Var = LiveUserVar[Reg];
1419 // Reg is now clobbered.
1420 LiveUserVar[Reg] = 0;
1422 // Was MD last defined by a DBG_VALUE referring to Reg?
1423 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1424 if (HistI == DbgValues.end())
1426 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1427 if (History.empty())
1429 const MachineInstr *Prev = History.back();
1430 // Sanity-check: Register assignments are terminated at the end of
1432 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1434 // Is the variable still in Reg?
1435 if (!isDbgValueInDefinedReg(Prev) ||
1436 Prev->getOperand(0).getReg() != Reg)
1438 // Var is clobbered. Make sure the next instruction gets a label.
1439 History.push_back(MI);
1446 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1448 SmallVectorImpl<const MachineInstr*> &History = I->second;
1449 if (History.empty())
1452 // Make sure the final register assignments are terminated.
1453 const MachineInstr *Prev = History.back();
1454 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1455 const MachineBasicBlock *PrevMBB = Prev->getParent();
1456 MachineBasicBlock::const_iterator LastMI =
1457 PrevMBB->getLastNonDebugInstr();
1458 if (LastMI == PrevMBB->end())
1459 // Drop DBG_VALUE for empty range.
1462 // Terminate after LastMI.
1463 History.push_back(LastMI);
1466 // Request labels for the full history.
1467 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1468 const MachineInstr *MI = History[i];
1469 if (MI->isDebugValue())
1470 requestLabelBeforeInsn(MI);
1472 requestLabelAfterInsn(MI);
1476 PrevInstLoc = DebugLoc();
1477 PrevLabel = FunctionBeginSym;
1479 // Record beginning of function.
1480 if (!PrologEndLoc.isUnknown()) {
1481 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1482 MF->getFunction()->getContext());
1483 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1484 FnStartDL.getScope(MF->getFunction()->getContext()),
1489 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1490 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1491 ScopeVariables[LS].push_back(Var);
1492 // Vars.push_back(Var);
1495 /// endFunction - Gather and emit post-function debug information.
1497 void DwarfDebug::endFunction(const MachineFunction *MF) {
1498 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1500 // Define end label for subprogram.
1501 FunctionEndSym = Asm->GetTempSymbol("func_end",
1502 Asm->getFunctionNumber());
1503 // Assumes in correct section after the entry point.
1504 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1506 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1507 collectVariableInfo(MF, ProcessedVars);
1509 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1510 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1511 assert(TheCU && "Unable to find compile unit!");
1513 // Construct abstract scopes.
1514 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1515 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1516 LexicalScope *AScope = AList[i];
1517 DISubprogram SP(AScope->getScopeNode());
1519 // Collect info for variables that were optimized out.
1520 DIArray Variables = SP.getVariables();
1521 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1522 DIVariable DV(Variables.getElement(i));
1523 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1525 // Check that DbgVariable for DV wasn't created earlier, when
1526 // findAbstractVariable() was called for inlined instance of DV.
1527 LLVMContext &Ctx = DV->getContext();
1528 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1529 if (AbstractVariables.lookup(CleanDV))
1531 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1532 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1535 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1536 constructScopeDIE(TheCU, AScope);
1539 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1541 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1542 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1544 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1545 MMI->getFrameMoves()));
1548 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1549 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1550 DeleteContainerPointers(I->second);
1551 ScopeVariables.clear();
1552 DeleteContainerPointers(CurrentFnArguments);
1553 UserVariables.clear();
1555 AbstractVariables.clear();
1556 LabelsBeforeInsn.clear();
1557 LabelsAfterInsn.clear();
1561 /// recordSourceLine - Register a source line with debug info. Returns the
1562 /// unique label that was emitted and which provides correspondence to
1563 /// the source line list.
1564 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1570 DIDescriptor Scope(S);
1572 if (Scope.isCompileUnit()) {
1573 DICompileUnit CU(S);
1574 Fn = CU.getFilename();
1575 Dir = CU.getDirectory();
1576 } else if (Scope.isFile()) {
1578 Fn = F.getFilename();
1579 Dir = F.getDirectory();
1580 } else if (Scope.isSubprogram()) {
1582 Fn = SP.getFilename();
1583 Dir = SP.getDirectory();
1584 } else if (Scope.isLexicalBlockFile()) {
1585 DILexicalBlockFile DBF(S);
1586 Fn = DBF.getFilename();
1587 Dir = DBF.getDirectory();
1588 } else if (Scope.isLexicalBlock()) {
1589 DILexicalBlock DB(S);
1590 Fn = DB.getFilename();
1591 Dir = DB.getDirectory();
1593 llvm_unreachable("Unexpected scope info");
1595 Src = getOrCreateSourceID(Fn, Dir);
1597 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1600 //===----------------------------------------------------------------------===//
1602 //===----------------------------------------------------------------------===//
1604 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1607 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1608 // Get the children.
1609 const std::vector<DIE *> &Children = Die->getChildren();
1611 // Record the abbreviation.
1612 assignAbbrevNumber(Die->getAbbrev());
1614 // Get the abbreviation for this DIE.
1615 unsigned AbbrevNumber = Die->getAbbrevNumber();
1616 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1619 Die->setOffset(Offset);
1621 // Start the size with the size of abbreviation code.
1622 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1624 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1625 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1627 // Size the DIE attribute values.
1628 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1629 // Size attribute value.
1630 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1632 // Size the DIE children if any.
1633 if (!Children.empty()) {
1634 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1635 "Children flag not set");
1637 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1638 Offset = computeSizeAndOffset(Children[j], Offset);
1640 // End of children marker.
1641 Offset += sizeof(int8_t);
1644 Die->setSize(Offset - Die->getOffset());
1648 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1650 void DwarfDebug::computeSizeAndOffsets() {
1651 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1652 E = CUMap.end(); I != E; ++I) {
1653 // Compute size of compile unit header.
1655 sizeof(int32_t) + // Length of Compilation Unit Info
1656 sizeof(int16_t) + // DWARF version number
1657 sizeof(int32_t) + // Offset Into Abbrev. Section
1658 sizeof(int8_t); // Pointer Size (in bytes)
1659 computeSizeAndOffset(I->second->getCUDie(), Offset);
1663 /// emitSectionLabels - Emit initial Dwarf sections with a label at
1664 /// the start of each one.
1665 void DwarfDebug::emitSectionLabels() {
1666 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1668 // Dwarf sections base addresses.
1669 DwarfInfoSectionSym =
1670 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1671 DwarfAbbrevSectionSym =
1672 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1673 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1675 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1676 emitSectionSym(Asm, MacroInfo);
1678 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1679 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1680 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1681 DwarfStrSectionSym =
1682 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1683 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1686 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1687 "section_debug_loc");
1689 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1690 emitSectionSym(Asm, TLOF.getDataSection());
1693 /// emitDIE - Recursively emits a debug information entry.
1695 void DwarfDebug::emitDIE(DIE *Die) {
1696 // Get the abbreviation for this DIE.
1697 unsigned AbbrevNumber = Die->getAbbrevNumber();
1698 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1700 // Emit the code (index) for the abbreviation.
1701 if (Asm->isVerbose())
1702 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1703 Twine::utohexstr(Die->getOffset()) + ":0x" +
1704 Twine::utohexstr(Die->getSize()) + " " +
1705 dwarf::TagString(Abbrev->getTag()));
1706 Asm->EmitULEB128(AbbrevNumber);
1708 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1709 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1711 // Emit the DIE attribute values.
1712 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1713 unsigned Attr = AbbrevData[i].getAttribute();
1714 unsigned Form = AbbrevData[i].getForm();
1715 assert(Form && "Too many attributes for DIE (check abbreviation)");
1717 if (Asm->isVerbose())
1718 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1721 case dwarf::DW_AT_abstract_origin: {
1722 DIEEntry *E = cast<DIEEntry>(Values[i]);
1723 DIE *Origin = E->getEntry();
1724 unsigned Addr = Origin->getOffset();
1725 Asm->EmitInt32(Addr);
1728 case dwarf::DW_AT_ranges: {
1729 // DW_AT_range Value encodes offset in debug_range section.
1730 DIEInteger *V = cast<DIEInteger>(Values[i]);
1732 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1733 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1737 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1739 DwarfDebugRangeSectionSym,
1744 case dwarf::DW_AT_location: {
1745 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1746 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1747 Asm->EmitLabelReference(L->getValue(), 4);
1749 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1751 Values[i]->EmitValue(Asm, Form);
1755 case dwarf::DW_AT_accessibility: {
1756 if (Asm->isVerbose()) {
1757 DIEInteger *V = cast<DIEInteger>(Values[i]);
1758 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1760 Values[i]->EmitValue(Asm, Form);
1764 // Emit an attribute using the defined form.
1765 Values[i]->EmitValue(Asm, Form);
1770 // Emit the DIE children if any.
1771 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1772 const std::vector<DIE *> &Children = Die->getChildren();
1774 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1775 emitDIE(Children[j]);
1777 if (Asm->isVerbose())
1778 Asm->OutStreamer.AddComment("End Of Children Mark");
1783 /// emitDebugInfo - Emit the debug info section.
1785 void DwarfDebug::emitDebugInfo() {
1786 // Start debug info section.
1787 Asm->OutStreamer.SwitchSection(
1788 Asm->getObjFileLowering().getDwarfInfoSection());
1789 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1790 E = CUMap.end(); I != E; ++I) {
1791 CompileUnit *TheCU = I->second;
1792 DIE *Die = TheCU->getCUDie();
1794 // Emit the compile units header.
1795 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1798 // Emit size of content not including length itself
1799 unsigned ContentSize = Die->getSize() +
1800 sizeof(int16_t) + // DWARF version number
1801 sizeof(int32_t) + // Offset Into Abbrev. Section
1802 sizeof(int8_t); // Pointer Size (in bytes)
1804 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1805 Asm->EmitInt32(ContentSize);
1806 Asm->OutStreamer.AddComment("DWARF version number");
1807 Asm->EmitInt16(dwarf::DWARF_VERSION);
1808 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1809 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1810 DwarfAbbrevSectionSym);
1811 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1812 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1815 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1819 /// emitAbbreviations - Emit the abbreviation section.
1821 void DwarfDebug::emitAbbreviations() {
1822 // Check to see if it is worth the effort.
1823 if (!Abbreviations.empty()) {
1824 // Start the debug abbrev section.
1825 Asm->OutStreamer.SwitchSection(
1826 Asm->getObjFileLowering().getDwarfAbbrevSection());
1828 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1830 // For each abbrevation.
1831 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1832 // Get abbreviation data
1833 const DIEAbbrev *Abbrev = Abbreviations[i];
1835 // Emit the abbrevations code (base 1 index.)
1836 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1838 // Emit the abbreviations data.
1842 // Mark end of abbreviations.
1843 Asm->EmitULEB128(0, "EOM(3)");
1845 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1849 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1850 /// the line matrix.
1852 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1853 // Define last address of section.
1854 Asm->OutStreamer.AddComment("Extended Op");
1857 Asm->OutStreamer.AddComment("Op size");
1858 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1859 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1860 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1862 Asm->OutStreamer.AddComment("Section end label");
1864 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1865 Asm->getDataLayout().getPointerSize(),
1868 // Mark end of matrix.
1869 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1875 /// emitAccelNames - Emit visible names into a hashed accelerator table
1877 void DwarfDebug::emitAccelNames() {
1878 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1879 dwarf::DW_FORM_data4));
1880 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1881 E = CUMap.end(); I != E; ++I) {
1882 CompileUnit *TheCU = I->second;
1883 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1884 for (StringMap<std::vector<DIE*> >::const_iterator
1885 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1886 const char *Name = GI->getKeyData();
1887 const std::vector<DIE *> &Entities = GI->second;
1888 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1889 DE = Entities.end(); DI != DE; ++DI)
1890 AT.AddName(Name, (*DI));
1894 AT.FinalizeTable(Asm, "Names");
1895 Asm->OutStreamer.SwitchSection(
1896 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1897 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1898 Asm->OutStreamer.EmitLabel(SectionBegin);
1900 // Emit the full data.
1901 AT.Emit(Asm, SectionBegin, this);
1904 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1905 /// accelerator table section.
1906 void DwarfDebug::emitAccelObjC() {
1907 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1908 dwarf::DW_FORM_data4));
1909 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1910 E = CUMap.end(); I != E; ++I) {
1911 CompileUnit *TheCU = I->second;
1912 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1913 for (StringMap<std::vector<DIE*> >::const_iterator
1914 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1915 const char *Name = GI->getKeyData();
1916 const std::vector<DIE *> &Entities = GI->second;
1917 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1918 DE = Entities.end(); DI != DE; ++DI)
1919 AT.AddName(Name, (*DI));
1923 AT.FinalizeTable(Asm, "ObjC");
1924 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1925 .getDwarfAccelObjCSection());
1926 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1927 Asm->OutStreamer.EmitLabel(SectionBegin);
1929 // Emit the full data.
1930 AT.Emit(Asm, SectionBegin, this);
1933 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1935 void DwarfDebug::emitAccelNamespaces() {
1936 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1937 dwarf::DW_FORM_data4));
1938 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1939 E = CUMap.end(); I != E; ++I) {
1940 CompileUnit *TheCU = I->second;
1941 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1942 for (StringMap<std::vector<DIE*> >::const_iterator
1943 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1944 const char *Name = GI->getKeyData();
1945 const std::vector<DIE *> &Entities = GI->second;
1946 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1947 DE = Entities.end(); DI != DE; ++DI)
1948 AT.AddName(Name, (*DI));
1952 AT.FinalizeTable(Asm, "namespac");
1953 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1954 .getDwarfAccelNamespaceSection());
1955 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1956 Asm->OutStreamer.EmitLabel(SectionBegin);
1958 // Emit the full data.
1959 AT.Emit(Asm, SectionBegin, this);
1962 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1963 void DwarfDebug::emitAccelTypes() {
1964 std::vector<DwarfAccelTable::Atom> Atoms;
1965 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1966 dwarf::DW_FORM_data4));
1967 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1968 dwarf::DW_FORM_data2));
1969 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1970 dwarf::DW_FORM_data1));
1971 DwarfAccelTable AT(Atoms);
1972 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1973 E = CUMap.end(); I != E; ++I) {
1974 CompileUnit *TheCU = I->second;
1975 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1976 = TheCU->getAccelTypes();
1977 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1978 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1979 const char *Name = GI->getKeyData();
1980 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1981 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1982 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1983 AT.AddName(Name, (*DI).first, (*DI).second);
1987 AT.FinalizeTable(Asm, "types");
1988 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1989 .getDwarfAccelTypesSection());
1990 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1991 Asm->OutStreamer.EmitLabel(SectionBegin);
1993 // Emit the full data.
1994 AT.Emit(Asm, SectionBegin, this);
1997 void DwarfDebug::emitDebugPubTypes() {
1998 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1999 E = CUMap.end(); I != E; ++I) {
2000 CompileUnit *TheCU = I->second;
2001 // Start the dwarf pubtypes section.
2002 Asm->OutStreamer.SwitchSection(
2003 Asm->getObjFileLowering().getDwarfPubTypesSection());
2004 Asm->OutStreamer.AddComment("Length of Public Types Info");
2005 Asm->EmitLabelDifference(
2006 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2007 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2009 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2012 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2013 Asm->EmitInt16(dwarf::DWARF_VERSION);
2015 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2016 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2017 DwarfInfoSectionSym);
2019 Asm->OutStreamer.AddComment("Compilation Unit Length");
2020 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2021 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2024 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2025 for (StringMap<DIE*>::const_iterator
2026 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2027 const char *Name = GI->getKeyData();
2028 DIE *Entity = GI->second;
2030 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2031 Asm->EmitInt32(Entity->getOffset());
2033 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2034 // Emit the name with a terminating null byte.
2035 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2038 Asm->OutStreamer.AddComment("End Mark");
2040 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2045 /// emitDebugStr - Emit visible names into a debug str section.
2047 void DwarfDebug::emitDebugStr() {
2048 // Check to see if it is worth the effort.
2049 if (StringPool.empty()) return;
2051 // Start the dwarf str section.
2052 Asm->OutStreamer.SwitchSection(
2053 Asm->getObjFileLowering().getDwarfStrSection());
2055 // Get all of the string pool entries and put them in an array by their ID so
2056 // we can sort them.
2057 SmallVector<std::pair<unsigned,
2058 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2060 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2061 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2062 Entries.push_back(std::make_pair(I->second.second, &*I));
2064 array_pod_sort(Entries.begin(), Entries.end());
2066 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2067 // Emit a label for reference from debug information entries.
2068 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2070 // Emit the string itself with a terminating null byte.
2071 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2072 Entries[i].second->getKeyLength()+1),
2077 /// emitDebugLoc - Emit visible names into a debug loc section.
2079 void DwarfDebug::emitDebugLoc() {
2080 if (DotDebugLocEntries.empty())
2083 for (SmallVector<DotDebugLocEntry, 4>::iterator
2084 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2086 DotDebugLocEntry &Entry = *I;
2087 if (I + 1 != DotDebugLocEntries.end())
2091 // Start the dwarf loc section.
2092 Asm->OutStreamer.SwitchSection(
2093 Asm->getObjFileLowering().getDwarfLocSection());
2094 unsigned char Size = Asm->getDataLayout().getPointerSize();
2095 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2097 for (SmallVector<DotDebugLocEntry, 4>::iterator
2098 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2099 I != E; ++I, ++index) {
2100 DotDebugLocEntry &Entry = *I;
2101 if (Entry.isMerged()) continue;
2102 if (Entry.isEmpty()) {
2103 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2104 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2105 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2107 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2108 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2109 DIVariable DV(Entry.Variable);
2110 Asm->OutStreamer.AddComment("Loc expr size");
2111 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2112 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2113 Asm->EmitLabelDifference(end, begin, 2);
2114 Asm->OutStreamer.EmitLabel(begin);
2115 if (Entry.isInt()) {
2116 DIBasicType BTy(DV.getType());
2118 (BTy.getEncoding() == dwarf::DW_ATE_signed
2119 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2120 Asm->OutStreamer.AddComment("DW_OP_consts");
2121 Asm->EmitInt8(dwarf::DW_OP_consts);
2122 Asm->EmitSLEB128(Entry.getInt());
2124 Asm->OutStreamer.AddComment("DW_OP_constu");
2125 Asm->EmitInt8(dwarf::DW_OP_constu);
2126 Asm->EmitULEB128(Entry.getInt());
2128 } else if (Entry.isLocation()) {
2129 if (!DV.hasComplexAddress())
2131 Asm->EmitDwarfRegOp(Entry.Loc);
2133 // Complex address entry.
2134 unsigned N = DV.getNumAddrElements();
2136 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2137 if (Entry.Loc.getOffset()) {
2139 Asm->EmitDwarfRegOp(Entry.Loc);
2140 Asm->OutStreamer.AddComment("DW_OP_deref");
2141 Asm->EmitInt8(dwarf::DW_OP_deref);
2142 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2143 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2144 Asm->EmitSLEB128(DV.getAddrElement(1));
2146 // If first address element is OpPlus then emit
2147 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2148 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2149 Asm->EmitDwarfRegOp(Loc);
2153 Asm->EmitDwarfRegOp(Entry.Loc);
2156 // Emit remaining complex address elements.
2157 for (; i < N; ++i) {
2158 uint64_t Element = DV.getAddrElement(i);
2159 if (Element == DIBuilder::OpPlus) {
2160 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2161 Asm->EmitULEB128(DV.getAddrElement(++i));
2162 } else if (Element == DIBuilder::OpDeref) {
2163 if (!Entry.Loc.isReg())
2164 Asm->EmitInt8(dwarf::DW_OP_deref);
2166 llvm_unreachable("unknown Opcode found in complex address");
2170 // else ... ignore constant fp. There is not any good way to
2171 // to represent them here in dwarf.
2172 Asm->OutStreamer.EmitLabel(end);
2177 /// emitDebugARanges - Emit visible names into a debug aranges section.
2179 void DwarfDebug::emitDebugARanges() {
2180 // Start the dwarf aranges section.
2181 Asm->OutStreamer.SwitchSection(
2182 Asm->getObjFileLowering().getDwarfARangesSection());
2185 /// emitDebugRanges - Emit visible names into a debug ranges section.
2187 void DwarfDebug::emitDebugRanges() {
2188 // Start the dwarf ranges section.
2189 Asm->OutStreamer.SwitchSection(
2190 Asm->getObjFileLowering().getDwarfRangesSection());
2191 unsigned char Size = Asm->getDataLayout().getPointerSize();
2192 for (SmallVector<const MCSymbol *, 8>::iterator
2193 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2196 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2198 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2202 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2204 void DwarfDebug::emitDebugMacInfo() {
2205 if (const MCSection *LineInfo =
2206 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2207 // Start the dwarf macinfo section.
2208 Asm->OutStreamer.SwitchSection(LineInfo);
2212 /// emitDebugInlineInfo - Emit inline info using following format.
2214 /// 1. length of section
2215 /// 2. Dwarf version number
2216 /// 3. address size.
2218 /// Entries (one "entry" for each function that was inlined):
2220 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2221 /// otherwise offset into __debug_str for regular function name.
2222 /// 2. offset into __debug_str section for regular function name.
2223 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2224 /// instances for the function.
2226 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2227 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2228 /// __debug_info section, and the low_pc is the starting address for the
2229 /// inlining instance.
2230 void DwarfDebug::emitDebugInlineInfo() {
2231 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2237 Asm->OutStreamer.SwitchSection(
2238 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2240 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2241 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2242 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2244 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2246 Asm->OutStreamer.AddComment("Dwarf Version");
2247 Asm->EmitInt16(dwarf::DWARF_VERSION);
2248 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2249 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2251 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2252 E = InlinedSPNodes.end(); I != E; ++I) {
2254 const MDNode *Node = *I;
2255 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2256 = InlineInfo.find(Node);
2257 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2258 DISubprogram SP(Node);
2259 StringRef LName = SP.getLinkageName();
2260 StringRef Name = SP.getName();
2262 Asm->OutStreamer.AddComment("MIPS linkage name");
2264 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2266 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2267 DwarfStrSectionSym);
2269 Asm->OutStreamer.AddComment("Function name");
2270 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2271 Asm->EmitULEB128(Labels.size(), "Inline count");
2273 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2274 LE = Labels.end(); LI != LE; ++LI) {
2275 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2276 Asm->EmitInt32(LI->second->getOffset());
2278 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2279 Asm->OutStreamer.EmitSymbolValue(LI->first,
2280 Asm->getDataLayout().getPointerSize(),0);
2284 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));