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(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(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(Module *M) {
763 if (DisableDebugInfoPrinting)
766 // If module has named metadata anchors then use them, otherwise scan the
767 // module using debug info finder to collect debug info.
768 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
770 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
771 DICompileUnit CUNode(CU_Nodes->getOperand(i));
772 CompileUnit *CU = constructCompileUnit(CUNode);
773 DIArray GVs = CUNode.getGlobalVariables();
774 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
775 CU->createGlobalVariableDIE(GVs.getElement(i));
776 DIArray SPs = CUNode.getSubprograms();
777 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
778 constructSubprogramDIE(CU, SPs.getElement(i));
779 DIArray EnumTypes = CUNode.getEnumTypes();
780 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
781 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
782 DIArray RetainedTypes = CUNode.getRetainedTypes();
783 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
784 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
786 } else if (!collectLegacyDebugInfo(M))
789 collectInfoFromNamedMDNodes(M);
791 // Tell MMI that we have debug info.
792 MMI->setDebugInfoAvailability(true);
794 // Prime section data.
795 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
798 /// endModule - Emit all Dwarf sections that should come after the content.
800 void DwarfDebug::endModule() {
801 if (!FirstCU) return;
802 const Module *M = MMI->getModule();
803 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
805 // Collect info for variables that were optimized out.
806 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
807 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
808 DICompileUnit TheCU(CU_Nodes->getOperand(i));
809 DIArray Subprograms = TheCU.getSubprograms();
810 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
811 DISubprogram SP(Subprograms.getElement(i));
812 if (ProcessedSPNodes.count(SP) != 0) continue;
813 if (!SP.Verify()) continue;
814 if (!SP.isDefinition()) continue;
815 DIArray Variables = SP.getVariables();
816 if (Variables.getNumElements() == 0) continue;
818 LexicalScope *Scope =
819 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
820 DeadFnScopeMap[SP] = Scope;
822 // Construct subprogram DIE and add variables DIEs.
823 CompileUnit *SPCU = CUMap.lookup(TheCU);
824 assert(SPCU && "Unable to find Compile Unit!");
825 constructSubprogramDIE(SPCU, SP);
826 DIE *ScopeDIE = SPCU->getDIE(SP);
827 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
828 DIVariable DV(Variables.getElement(vi));
829 if (!DV.Verify()) continue;
830 DbgVariable *NewVar = new DbgVariable(DV, NULL);
831 if (DIE *VariableDIE =
832 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
833 ScopeDIE->addChild(VariableDIE);
839 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
840 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
841 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
843 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
845 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
846 AE = AbstractSPDies.end(); AI != AE; ++AI) {
847 DIE *ISP = AI->second;
848 if (InlinedSubprogramDIEs.count(ISP))
850 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
853 // Emit DW_AT_containing_type attribute to connect types with their
854 // vtable holding type.
855 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
856 CUE = CUMap.end(); CUI != CUE; ++CUI) {
857 CompileUnit *TheCU = CUI->second;
858 TheCU->constructContainingTypeDIEs();
861 // Standard sections final addresses.
862 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
863 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
864 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
865 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
867 // End text sections.
868 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
869 Asm->OutStreamer.SwitchSection(SectionMap[I]);
870 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
873 // Compute DIE offsets and sizes.
874 computeSizeAndOffsets();
876 // Emit initial sections.
879 // Emit all the DIEs into a debug info section
882 // Corresponding abbreviations into a abbrev section.
885 // Emit info into the dwarf accelerator table sections.
886 if (useDwarfAccelTables()) {
889 emitAccelNamespaces();
893 // Emit info into a debug pubtypes section.
894 // TODO: When we don't need the option anymore we can
895 // remove all of the code that adds to the table.
896 if (useDarwinGDBCompat())
899 // Emit info into a debug loc section.
902 // Emit info into a debug aranges section.
905 // Emit info into a debug ranges section.
908 // Emit info into a debug macinfo section.
912 // TODO: When we don't need the option anymore we
913 // can remove all of the code that this section
915 if (useDarwinGDBCompat())
916 emitDebugInlineInfo();
918 // Emit info into a debug str section.
922 DeleteContainerSeconds(DeadFnScopeMap);
924 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
925 E = CUMap.end(); I != E; ++I)
927 FirstCU = NULL; // Reset for the next Module, if any.
930 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
931 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
933 LLVMContext &Ctx = DV->getContext();
934 // More then one inlined variable corresponds to one abstract variable.
935 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
936 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
938 return AbsDbgVariable;
940 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
944 AbsDbgVariable = new DbgVariable(Var, NULL);
945 addScopeVariable(Scope, AbsDbgVariable);
946 AbstractVariables[Var] = AbsDbgVariable;
947 return AbsDbgVariable;
950 /// addCurrentFnArgument - If Var is a current function argument then add
951 /// it to CurrentFnArguments list.
952 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
953 DbgVariable *Var, LexicalScope *Scope) {
954 if (!LScopes.isCurrentFunctionScope(Scope))
956 DIVariable DV = Var->getVariable();
957 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
959 unsigned ArgNo = DV.getArgNumber();
963 size_t Size = CurrentFnArguments.size();
965 CurrentFnArguments.resize(MF->getFunction()->arg_size());
966 // llvm::Function argument size is not good indicator of how many
967 // arguments does the function have at source level.
969 CurrentFnArguments.resize(ArgNo * 2);
970 CurrentFnArguments[ArgNo - 1] = Var;
974 /// collectVariableInfoFromMMITable - Collect variable information from
975 /// side table maintained by MMI.
977 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
978 SmallPtrSet<const MDNode *, 16> &Processed) {
979 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
980 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
981 VE = VMap.end(); VI != VE; ++VI) {
982 const MDNode *Var = VI->first;
984 Processed.insert(Var);
986 const std::pair<unsigned, DebugLoc> &VP = VI->second;
988 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
990 // If variable scope is not found then skip this variable.
994 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
995 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
996 RegVar->setFrameIndex(VP.first);
997 if (!addCurrentFnArgument(MF, RegVar, Scope))
998 addScopeVariable(Scope, RegVar);
1000 AbsDbgVariable->setFrameIndex(VP.first);
1004 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1005 /// DBG_VALUE instruction, is in a defined reg.
1006 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1007 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1008 return MI->getNumOperands() == 3 &&
1009 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1010 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1013 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
1015 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1016 const MCSymbol *FLabel,
1017 const MCSymbol *SLabel,
1018 const MachineInstr *MI) {
1019 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1021 if (MI->getNumOperands() != 3) {
1022 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1023 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1025 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1026 MachineLocation MLoc;
1027 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1028 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1030 if (MI->getOperand(0).isImm())
1031 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1032 if (MI->getOperand(0).isFPImm())
1033 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1034 if (MI->getOperand(0).isCImm())
1035 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1037 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1040 /// collectVariableInfo - Find variables for each lexical scope.
1042 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1043 SmallPtrSet<const MDNode *, 16> &Processed) {
1045 /// collection info from MMI table.
1046 collectVariableInfoFromMMITable(MF, Processed);
1048 for (SmallVectorImpl<const MDNode*>::const_iterator
1049 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1051 const MDNode *Var = *UVI;
1052 if (Processed.count(Var))
1055 // History contains relevant DBG_VALUE instructions for Var and instructions
1057 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1058 if (History.empty())
1060 const MachineInstr *MInsn = History.front();
1063 LexicalScope *Scope = NULL;
1064 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1065 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1066 Scope = LScopes.getCurrentFunctionScope();
1068 if (DV.getVersion() <= LLVMDebugVersion9)
1069 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1071 if (MDNode *IA = DV.getInlinedAt())
1072 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1074 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1077 // If variable scope is not found then skip this variable.
1081 Processed.insert(DV);
1082 assert(MInsn->isDebugValue() && "History must begin with debug value");
1083 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1084 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1085 if (!addCurrentFnArgument(MF, RegVar, Scope))
1086 addScopeVariable(Scope, RegVar);
1088 AbsVar->setMInsn(MInsn);
1090 // Simplify ranges that are fully coalesced.
1091 if (History.size() <= 1 || (History.size() == 2 &&
1092 MInsn->isIdenticalTo(History.back()))) {
1093 RegVar->setMInsn(MInsn);
1097 // handle multiple DBG_VALUE instructions describing one variable.
1098 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1100 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1101 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1102 const MachineInstr *Begin = *HI;
1103 assert(Begin->isDebugValue() && "Invalid History entry");
1105 // Check if DBG_VALUE is truncating a range.
1106 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1107 && !Begin->getOperand(0).getReg())
1110 // Compute the range for a register location.
1111 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1112 const MCSymbol *SLabel = 0;
1115 // If Begin is the last instruction in History then its value is valid
1116 // until the end of the function.
1117 SLabel = FunctionEndSym;
1119 const MachineInstr *End = HI[1];
1120 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1121 << "\t" << *Begin << "\t" << *End << "\n");
1122 if (End->isDebugValue())
1123 SLabel = getLabelBeforeInsn(End);
1125 // End is a normal instruction clobbering the range.
1126 SLabel = getLabelAfterInsn(End);
1127 assert(SLabel && "Forgot label after clobber instruction");
1132 // The value is valid until the next DBG_VALUE or clobber.
1133 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1136 DotDebugLocEntries.push_back(DotDebugLocEntry());
1139 // Collect info for variables that were optimized out.
1140 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1141 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1142 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1143 DIVariable DV(Variables.getElement(i));
1144 if (!DV || !DV.Verify() || !Processed.insert(DV))
1146 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1147 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1151 /// getLabelBeforeInsn - Return Label preceding the instruction.
1152 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1153 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1154 assert(Label && "Didn't insert label before instruction");
1158 /// getLabelAfterInsn - Return Label immediately following the instruction.
1159 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1160 return LabelsAfterInsn.lookup(MI);
1163 /// beginInstruction - Process beginning of an instruction.
1164 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1165 // Check if source location changes, but ignore DBG_VALUE locations.
1166 if (!MI->isDebugValue()) {
1167 DebugLoc DL = MI->getDebugLoc();
1168 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1171 if (DL == PrologEndLoc) {
1172 Flags |= DWARF2_FLAG_PROLOGUE_END;
1173 PrologEndLoc = DebugLoc();
1175 if (PrologEndLoc.isUnknown())
1176 Flags |= DWARF2_FLAG_IS_STMT;
1178 if (!DL.isUnknown()) {
1179 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1180 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1182 recordSourceLine(0, 0, 0, 0);
1186 // Insert labels where requested.
1187 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1188 LabelsBeforeInsn.find(MI);
1191 if (I == LabelsBeforeInsn.end())
1194 // Label already assigned.
1199 PrevLabel = MMI->getContext().CreateTempSymbol();
1200 Asm->OutStreamer.EmitLabel(PrevLabel);
1202 I->second = PrevLabel;
1205 /// endInstruction - Process end of an instruction.
1206 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1207 // Don't create a new label after DBG_VALUE instructions.
1208 // They don't generate code.
1209 if (!MI->isDebugValue())
1212 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1213 LabelsAfterInsn.find(MI);
1216 if (I == LabelsAfterInsn.end())
1219 // Label already assigned.
1223 // We need a label after this instruction.
1225 PrevLabel = MMI->getContext().CreateTempSymbol();
1226 Asm->OutStreamer.EmitLabel(PrevLabel);
1228 I->second = PrevLabel;
1231 /// identifyScopeMarkers() -
1232 /// Each LexicalScope has first instruction and last instruction to mark
1233 /// beginning and end of a scope respectively. Create an inverse map that list
1234 /// scopes starts (and ends) with an instruction. One instruction may start (or
1235 /// end) multiple scopes. Ignore scopes that are not reachable.
1236 void DwarfDebug::identifyScopeMarkers() {
1237 SmallVector<LexicalScope *, 4> WorkList;
1238 WorkList.push_back(LScopes.getCurrentFunctionScope());
1239 while (!WorkList.empty()) {
1240 LexicalScope *S = WorkList.pop_back_val();
1242 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1243 if (!Children.empty())
1244 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1245 SE = Children.end(); SI != SE; ++SI)
1246 WorkList.push_back(*SI);
1248 if (S->isAbstractScope())
1251 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1254 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1255 RE = Ranges.end(); RI != RE; ++RI) {
1256 assert(RI->first && "InsnRange does not have first instruction!");
1257 assert(RI->second && "InsnRange does not have second instruction!");
1258 requestLabelBeforeInsn(RI->first);
1259 requestLabelAfterInsn(RI->second);
1264 /// getScopeNode - Get MDNode for DebugLoc's scope.
1265 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1266 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1267 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1268 return DL.getScope(Ctx);
1271 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1272 /// line number info for the function.
1273 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1274 const MDNode *Scope = getScopeNode(DL, Ctx);
1275 DISubprogram SP = getDISubprogram(Scope);
1277 // Check for number of operands since the compatibility is
1279 if (SP->getNumOperands() > 19)
1280 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1282 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1288 /// beginFunction - Gather pre-function debug information. Assumes being
1289 /// emitted immediately after the function entry point.
1290 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1291 if (!MMI->hasDebugInfo()) return;
1292 LScopes.initialize(*MF);
1293 if (LScopes.empty()) return;
1294 identifyScopeMarkers();
1296 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1297 Asm->getFunctionNumber());
1298 // Assumes in correct section after the entry point.
1299 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1301 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1303 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1304 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1305 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1307 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1309 bool AtBlockEntry = true;
1310 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1312 const MachineInstr *MI = II;
1314 if (MI->isDebugValue()) {
1315 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1317 // Keep track of user variables.
1319 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1321 // Variable is in a register, we need to check for clobbers.
1322 if (isDbgValueInDefinedReg(MI))
1323 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1325 // Check the history of this variable.
1326 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1327 if (History.empty()) {
1328 UserVariables.push_back(Var);
1329 // The first mention of a function argument gets the FunctionBeginSym
1330 // label, so arguments are visible when breaking at function entry.
1332 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1333 DISubprogram(getDISubprogram(DV.getContext()))
1334 .describes(MF->getFunction()))
1335 LabelsBeforeInsn[MI] = FunctionBeginSym;
1337 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1338 const MachineInstr *Prev = History.back();
1339 if (Prev->isDebugValue()) {
1340 // Coalesce identical entries at the end of History.
1341 if (History.size() >= 2 &&
1342 Prev->isIdenticalTo(History[History.size() - 2])) {
1343 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1345 << "\t" << *History[History.size() - 2] << "\n");
1349 // Terminate old register assignments that don't reach MI;
1350 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1351 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1352 isDbgValueInDefinedReg(Prev)) {
1353 // Previous register assignment needs to terminate at the end of
1355 MachineBasicBlock::const_iterator LastMI =
1356 PrevMBB->getLastNonDebugInstr();
1357 if (LastMI == PrevMBB->end()) {
1358 // Drop DBG_VALUE for empty range.
1359 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1360 << "\t" << *Prev << "\n");
1364 // Terminate after LastMI.
1365 History.push_back(LastMI);
1370 History.push_back(MI);
1372 // Not a DBG_VALUE instruction.
1374 AtBlockEntry = false;
1376 // First known non-DBG_VALUE and non-frame setup location marks
1377 // the beginning of the function body.
1378 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1379 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1380 PrologEndLoc = MI->getDebugLoc();
1382 // Check if the instruction clobbers any registers with debug vars.
1383 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1384 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1385 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1387 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1388 AI.isValid(); ++AI) {
1390 const MDNode *Var = LiveUserVar[Reg];
1393 // Reg is now clobbered.
1394 LiveUserVar[Reg] = 0;
1396 // Was MD last defined by a DBG_VALUE referring to Reg?
1397 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1398 if (HistI == DbgValues.end())
1400 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1401 if (History.empty())
1403 const MachineInstr *Prev = History.back();
1404 // Sanity-check: Register assignments are terminated at the end of
1406 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1408 // Is the variable still in Reg?
1409 if (!isDbgValueInDefinedReg(Prev) ||
1410 Prev->getOperand(0).getReg() != Reg)
1412 // Var is clobbered. Make sure the next instruction gets a label.
1413 History.push_back(MI);
1420 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1422 SmallVectorImpl<const MachineInstr*> &History = I->second;
1423 if (History.empty())
1426 // Make sure the final register assignments are terminated.
1427 const MachineInstr *Prev = History.back();
1428 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1429 const MachineBasicBlock *PrevMBB = Prev->getParent();
1430 MachineBasicBlock::const_iterator LastMI =
1431 PrevMBB->getLastNonDebugInstr();
1432 if (LastMI == PrevMBB->end())
1433 // Drop DBG_VALUE for empty range.
1436 // Terminate after LastMI.
1437 History.push_back(LastMI);
1440 // Request labels for the full history.
1441 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1442 const MachineInstr *MI = History[i];
1443 if (MI->isDebugValue())
1444 requestLabelBeforeInsn(MI);
1446 requestLabelAfterInsn(MI);
1450 PrevInstLoc = DebugLoc();
1451 PrevLabel = FunctionBeginSym;
1453 // Record beginning of function.
1454 if (!PrologEndLoc.isUnknown()) {
1455 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1456 MF->getFunction()->getContext());
1457 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1458 FnStartDL.getScope(MF->getFunction()->getContext()),
1463 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1464 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1465 ScopeVariables[LS].push_back(Var);
1466 // Vars.push_back(Var);
1469 /// endFunction - Gather and emit post-function debug information.
1471 void DwarfDebug::endFunction(const MachineFunction *MF) {
1472 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1474 // Define end label for subprogram.
1475 FunctionEndSym = Asm->GetTempSymbol("func_end",
1476 Asm->getFunctionNumber());
1477 // Assumes in correct section after the entry point.
1478 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1480 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1481 collectVariableInfo(MF, ProcessedVars);
1483 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1484 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1485 assert(TheCU && "Unable to find compile unit!");
1487 // Construct abstract scopes.
1488 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1489 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1490 LexicalScope *AScope = AList[i];
1491 DISubprogram SP(AScope->getScopeNode());
1493 // Collect info for variables that were optimized out.
1494 DIArray Variables = SP.getVariables();
1495 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1496 DIVariable DV(Variables.getElement(i));
1497 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1499 // Check that DbgVariable for DV wasn't created earlier, when
1500 // findAbstractVariable() was called for inlined instance of DV.
1501 LLVMContext &Ctx = DV->getContext();
1502 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1503 if (AbstractVariables.lookup(CleanDV))
1505 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1506 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1509 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1510 constructScopeDIE(TheCU, AScope);
1513 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1515 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1516 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1518 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1519 MMI->getFrameMoves()));
1522 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1523 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1524 DeleteContainerPointers(I->second);
1525 ScopeVariables.clear();
1526 DeleteContainerPointers(CurrentFnArguments);
1527 UserVariables.clear();
1529 AbstractVariables.clear();
1530 LabelsBeforeInsn.clear();
1531 LabelsAfterInsn.clear();
1535 /// recordSourceLine - Register a source line with debug info. Returns the
1536 /// unique label that was emitted and which provides correspondence to
1537 /// the source line list.
1538 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1544 DIDescriptor Scope(S);
1546 if (Scope.isCompileUnit()) {
1547 DICompileUnit CU(S);
1548 Fn = CU.getFilename();
1549 Dir = CU.getDirectory();
1550 } else if (Scope.isFile()) {
1552 Fn = F.getFilename();
1553 Dir = F.getDirectory();
1554 } else if (Scope.isSubprogram()) {
1556 Fn = SP.getFilename();
1557 Dir = SP.getDirectory();
1558 } else if (Scope.isLexicalBlockFile()) {
1559 DILexicalBlockFile DBF(S);
1560 Fn = DBF.getFilename();
1561 Dir = DBF.getDirectory();
1562 } else if (Scope.isLexicalBlock()) {
1563 DILexicalBlock DB(S);
1564 Fn = DB.getFilename();
1565 Dir = DB.getDirectory();
1567 llvm_unreachable("Unexpected scope info");
1569 Src = GetOrCreateSourceID(Fn, Dir);
1571 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1574 //===----------------------------------------------------------------------===//
1576 //===----------------------------------------------------------------------===//
1578 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1581 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1582 // Get the children.
1583 const std::vector<DIE *> &Children = Die->getChildren();
1585 // Record the abbreviation.
1586 assignAbbrevNumber(Die->getAbbrev());
1588 // Get the abbreviation for this DIE.
1589 unsigned AbbrevNumber = Die->getAbbrevNumber();
1590 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1593 Die->setOffset(Offset);
1595 // Start the size with the size of abbreviation code.
1596 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1598 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1599 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1601 // Size the DIE attribute values.
1602 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1603 // Size attribute value.
1604 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1606 // Size the DIE children if any.
1607 if (!Children.empty()) {
1608 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1609 "Children flag not set");
1611 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1612 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1614 // End of children marker.
1615 Offset += sizeof(int8_t);
1618 Die->setSize(Offset - Die->getOffset());
1622 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1624 void DwarfDebug::computeSizeAndOffsets() {
1625 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1626 E = CUMap.end(); I != E; ++I) {
1627 // Compute size of compile unit header.
1629 sizeof(int32_t) + // Length of Compilation Unit Info
1630 sizeof(int16_t) + // DWARF version number
1631 sizeof(int32_t) + // Offset Into Abbrev. Section
1632 sizeof(int8_t); // Pointer Size (in bytes)
1633 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1637 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1638 /// the start of each one.
1639 void DwarfDebug::EmitSectionLabels() {
1640 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1642 // Dwarf sections base addresses.
1643 DwarfInfoSectionSym =
1644 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1645 DwarfAbbrevSectionSym =
1646 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1647 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1649 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1650 EmitSectionSym(Asm, MacroInfo);
1652 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1653 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1654 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1655 DwarfStrSectionSym =
1656 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1657 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1660 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1661 "section_debug_loc");
1663 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1664 EmitSectionSym(Asm, TLOF.getDataSection());
1667 /// emitDIE - Recursively emits a debug information entry.
1669 void DwarfDebug::emitDIE(DIE *Die) {
1670 // Get the abbreviation for this DIE.
1671 unsigned AbbrevNumber = Die->getAbbrevNumber();
1672 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1674 // Emit the code (index) for the abbreviation.
1675 if (Asm->isVerbose())
1676 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1677 Twine::utohexstr(Die->getOffset()) + ":0x" +
1678 Twine::utohexstr(Die->getSize()) + " " +
1679 dwarf::TagString(Abbrev->getTag()));
1680 Asm->EmitULEB128(AbbrevNumber);
1682 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1683 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1685 // Emit the DIE attribute values.
1686 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1687 unsigned Attr = AbbrevData[i].getAttribute();
1688 unsigned Form = AbbrevData[i].getForm();
1689 assert(Form && "Too many attributes for DIE (check abbreviation)");
1691 if (Asm->isVerbose())
1692 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1695 case dwarf::DW_AT_abstract_origin: {
1696 DIEEntry *E = cast<DIEEntry>(Values[i]);
1697 DIE *Origin = E->getEntry();
1698 unsigned Addr = Origin->getOffset();
1699 Asm->EmitInt32(Addr);
1702 case dwarf::DW_AT_ranges: {
1703 // DW_AT_range Value encodes offset in debug_range section.
1704 DIEInteger *V = cast<DIEInteger>(Values[i]);
1706 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1707 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1711 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1713 DwarfDebugRangeSectionSym,
1718 case dwarf::DW_AT_location: {
1719 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1720 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1721 Asm->EmitLabelReference(L->getValue(), 4);
1723 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1725 Values[i]->EmitValue(Asm, Form);
1729 case dwarf::DW_AT_accessibility: {
1730 if (Asm->isVerbose()) {
1731 DIEInteger *V = cast<DIEInteger>(Values[i]);
1732 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1734 Values[i]->EmitValue(Asm, Form);
1738 // Emit an attribute using the defined form.
1739 Values[i]->EmitValue(Asm, Form);
1744 // Emit the DIE children if any.
1745 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1746 const std::vector<DIE *> &Children = Die->getChildren();
1748 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1749 emitDIE(Children[j]);
1751 if (Asm->isVerbose())
1752 Asm->OutStreamer.AddComment("End Of Children Mark");
1757 /// emitDebugInfo - Emit the debug info section.
1759 void DwarfDebug::emitDebugInfo() {
1760 // Start debug info section.
1761 Asm->OutStreamer.SwitchSection(
1762 Asm->getObjFileLowering().getDwarfInfoSection());
1763 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1764 E = CUMap.end(); I != E; ++I) {
1765 CompileUnit *TheCU = I->second;
1766 DIE *Die = TheCU->getCUDie();
1768 // Emit the compile units header.
1769 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1772 // Emit size of content not including length itself
1773 unsigned ContentSize = Die->getSize() +
1774 sizeof(int16_t) + // DWARF version number
1775 sizeof(int32_t) + // Offset Into Abbrev. Section
1776 sizeof(int8_t); // Pointer Size (in bytes)
1778 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1779 Asm->EmitInt32(ContentSize);
1780 Asm->OutStreamer.AddComment("DWARF version number");
1781 Asm->EmitInt16(dwarf::DWARF_VERSION);
1782 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1783 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1784 DwarfAbbrevSectionSym);
1785 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1786 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1789 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1793 /// emitAbbreviations - Emit the abbreviation section.
1795 void DwarfDebug::emitAbbreviations() const {
1796 // Check to see if it is worth the effort.
1797 if (!Abbreviations.empty()) {
1798 // Start the debug abbrev section.
1799 Asm->OutStreamer.SwitchSection(
1800 Asm->getObjFileLowering().getDwarfAbbrevSection());
1802 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1804 // For each abbrevation.
1805 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1806 // Get abbreviation data
1807 const DIEAbbrev *Abbrev = Abbreviations[i];
1809 // Emit the abbrevations code (base 1 index.)
1810 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1812 // Emit the abbreviations data.
1816 // Mark end of abbreviations.
1817 Asm->EmitULEB128(0, "EOM(3)");
1819 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1823 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1824 /// the line matrix.
1826 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1827 // Define last address of section.
1828 Asm->OutStreamer.AddComment("Extended Op");
1831 Asm->OutStreamer.AddComment("Op size");
1832 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1833 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1834 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1836 Asm->OutStreamer.AddComment("Section end label");
1838 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1839 Asm->getDataLayout().getPointerSize(),
1842 // Mark end of matrix.
1843 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1849 /// emitAccelNames - Emit visible names into a hashed accelerator table
1851 void DwarfDebug::emitAccelNames() {
1852 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1853 dwarf::DW_FORM_data4));
1854 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1855 E = CUMap.end(); I != E; ++I) {
1856 CompileUnit *TheCU = I->second;
1857 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1858 for (StringMap<std::vector<DIE*> >::const_iterator
1859 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1860 const char *Name = GI->getKeyData();
1861 const std::vector<DIE *> &Entities = GI->second;
1862 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1863 DE = Entities.end(); DI != DE; ++DI)
1864 AT.AddName(Name, (*DI));
1868 AT.FinalizeTable(Asm, "Names");
1869 Asm->OutStreamer.SwitchSection(
1870 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1871 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1872 Asm->OutStreamer.EmitLabel(SectionBegin);
1874 // Emit the full data.
1875 AT.Emit(Asm, SectionBegin, this);
1878 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1879 /// accelerator table section.
1880 void DwarfDebug::emitAccelObjC() {
1881 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1882 dwarf::DW_FORM_data4));
1883 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1884 E = CUMap.end(); I != E; ++I) {
1885 CompileUnit *TheCU = I->second;
1886 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1887 for (StringMap<std::vector<DIE*> >::const_iterator
1888 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1889 const char *Name = GI->getKeyData();
1890 const std::vector<DIE *> &Entities = GI->second;
1891 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1892 DE = Entities.end(); DI != DE; ++DI)
1893 AT.AddName(Name, (*DI));
1897 AT.FinalizeTable(Asm, "ObjC");
1898 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1899 .getDwarfAccelObjCSection());
1900 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1901 Asm->OutStreamer.EmitLabel(SectionBegin);
1903 // Emit the full data.
1904 AT.Emit(Asm, SectionBegin, this);
1907 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1909 void DwarfDebug::emitAccelNamespaces() {
1910 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1911 dwarf::DW_FORM_data4));
1912 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1913 E = CUMap.end(); I != E; ++I) {
1914 CompileUnit *TheCU = I->second;
1915 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1916 for (StringMap<std::vector<DIE*> >::const_iterator
1917 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1918 const char *Name = GI->getKeyData();
1919 const std::vector<DIE *> &Entities = GI->second;
1920 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1921 DE = Entities.end(); DI != DE; ++DI)
1922 AT.AddName(Name, (*DI));
1926 AT.FinalizeTable(Asm, "namespac");
1927 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1928 .getDwarfAccelNamespaceSection());
1929 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1930 Asm->OutStreamer.EmitLabel(SectionBegin);
1932 // Emit the full data.
1933 AT.Emit(Asm, SectionBegin, this);
1936 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1937 void DwarfDebug::emitAccelTypes() {
1938 std::vector<DwarfAccelTable::Atom> Atoms;
1939 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1940 dwarf::DW_FORM_data4));
1941 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1942 dwarf::DW_FORM_data2));
1943 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1944 dwarf::DW_FORM_data1));
1945 DwarfAccelTable AT(Atoms);
1946 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1947 E = CUMap.end(); I != E; ++I) {
1948 CompileUnit *TheCU = I->second;
1949 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1950 = TheCU->getAccelTypes();
1951 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1952 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1953 const char *Name = GI->getKeyData();
1954 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1955 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1956 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1957 AT.AddName(Name, (*DI).first, (*DI).second);
1961 AT.FinalizeTable(Asm, "types");
1962 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1963 .getDwarfAccelTypesSection());
1964 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1965 Asm->OutStreamer.EmitLabel(SectionBegin);
1967 // Emit the full data.
1968 AT.Emit(Asm, SectionBegin, this);
1971 void DwarfDebug::emitDebugPubTypes() {
1972 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1973 E = CUMap.end(); I != E; ++I) {
1974 CompileUnit *TheCU = I->second;
1975 // Start the dwarf pubtypes section.
1976 Asm->OutStreamer.SwitchSection(
1977 Asm->getObjFileLowering().getDwarfPubTypesSection());
1978 Asm->OutStreamer.AddComment("Length of Public Types Info");
1979 Asm->EmitLabelDifference(
1980 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1981 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1983 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1986 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1987 Asm->EmitInt16(dwarf::DWARF_VERSION);
1989 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1990 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1991 DwarfInfoSectionSym);
1993 Asm->OutStreamer.AddComment("Compilation Unit Length");
1994 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1995 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1998 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1999 for (StringMap<DIE*>::const_iterator
2000 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2001 const char *Name = GI->getKeyData();
2002 DIE *Entity = GI->second;
2004 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2005 Asm->EmitInt32(Entity->getOffset());
2007 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2008 // Emit the name with a terminating null byte.
2009 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2012 Asm->OutStreamer.AddComment("End Mark");
2014 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2019 /// emitDebugStr - Emit visible names into a debug str section.
2021 void DwarfDebug::emitDebugStr() {
2022 // Check to see if it is worth the effort.
2023 if (StringPool.empty()) return;
2025 // Start the dwarf str section.
2026 Asm->OutStreamer.SwitchSection(
2027 Asm->getObjFileLowering().getDwarfStrSection());
2029 // Get all of the string pool entries and put them in an array by their ID so
2030 // we can sort them.
2031 SmallVector<std::pair<unsigned,
2032 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2034 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2035 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2036 Entries.push_back(std::make_pair(I->second.second, &*I));
2038 array_pod_sort(Entries.begin(), Entries.end());
2040 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2041 // Emit a label for reference from debug information entries.
2042 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2044 // Emit the string itself with a terminating null byte.
2045 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2046 Entries[i].second->getKeyLength()+1),
2051 /// emitDebugLoc - Emit visible names into a debug loc section.
2053 void DwarfDebug::emitDebugLoc() {
2054 if (DotDebugLocEntries.empty())
2057 for (SmallVector<DotDebugLocEntry, 4>::iterator
2058 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2060 DotDebugLocEntry &Entry = *I;
2061 if (I + 1 != DotDebugLocEntries.end())
2065 // Start the dwarf loc section.
2066 Asm->OutStreamer.SwitchSection(
2067 Asm->getObjFileLowering().getDwarfLocSection());
2068 unsigned char Size = Asm->getDataLayout().getPointerSize();
2069 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2071 for (SmallVector<DotDebugLocEntry, 4>::iterator
2072 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2073 I != E; ++I, ++index) {
2074 DotDebugLocEntry &Entry = *I;
2075 if (Entry.isMerged()) continue;
2076 if (Entry.isEmpty()) {
2077 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2078 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2079 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2081 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2082 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2083 DIVariable DV(Entry.Variable);
2084 Asm->OutStreamer.AddComment("Loc expr size");
2085 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2086 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2087 Asm->EmitLabelDifference(end, begin, 2);
2088 Asm->OutStreamer.EmitLabel(begin);
2089 if (Entry.isInt()) {
2090 DIBasicType BTy(DV.getType());
2092 (BTy.getEncoding() == dwarf::DW_ATE_signed
2093 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2094 Asm->OutStreamer.AddComment("DW_OP_consts");
2095 Asm->EmitInt8(dwarf::DW_OP_consts);
2096 Asm->EmitSLEB128(Entry.getInt());
2098 Asm->OutStreamer.AddComment("DW_OP_constu");
2099 Asm->EmitInt8(dwarf::DW_OP_constu);
2100 Asm->EmitULEB128(Entry.getInt());
2102 } else if (Entry.isLocation()) {
2103 if (!DV.hasComplexAddress())
2105 Asm->EmitDwarfRegOp(Entry.Loc);
2107 // Complex address entry.
2108 unsigned N = DV.getNumAddrElements();
2110 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2111 if (Entry.Loc.getOffset()) {
2113 Asm->EmitDwarfRegOp(Entry.Loc);
2114 Asm->OutStreamer.AddComment("DW_OP_deref");
2115 Asm->EmitInt8(dwarf::DW_OP_deref);
2116 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2117 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2118 Asm->EmitSLEB128(DV.getAddrElement(1));
2120 // If first address element is OpPlus then emit
2121 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2122 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2123 Asm->EmitDwarfRegOp(Loc);
2127 Asm->EmitDwarfRegOp(Entry.Loc);
2130 // Emit remaining complex address elements.
2131 for (; i < N; ++i) {
2132 uint64_t Element = DV.getAddrElement(i);
2133 if (Element == DIBuilder::OpPlus) {
2134 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2135 Asm->EmitULEB128(DV.getAddrElement(++i));
2136 } else if (Element == DIBuilder::OpDeref) {
2137 if (!Entry.Loc.isReg())
2138 Asm->EmitInt8(dwarf::DW_OP_deref);
2140 llvm_unreachable("unknown Opcode found in complex address");
2144 // else ... ignore constant fp. There is not any good way to
2145 // to represent them here in dwarf.
2146 Asm->OutStreamer.EmitLabel(end);
2151 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2153 void DwarfDebug::EmitDebugARanges() {
2154 // Start the dwarf aranges section.
2155 Asm->OutStreamer.SwitchSection(
2156 Asm->getObjFileLowering().getDwarfARangesSection());
2159 /// emitDebugRanges - Emit visible names into a debug ranges section.
2161 void DwarfDebug::emitDebugRanges() {
2162 // Start the dwarf ranges section.
2163 Asm->OutStreamer.SwitchSection(
2164 Asm->getObjFileLowering().getDwarfRangesSection());
2165 unsigned char Size = Asm->getDataLayout().getPointerSize();
2166 for (SmallVector<const MCSymbol *, 8>::iterator
2167 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2170 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2172 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2176 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2178 void DwarfDebug::emitDebugMacInfo() {
2179 if (const MCSection *LineInfo =
2180 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2181 // Start the dwarf macinfo section.
2182 Asm->OutStreamer.SwitchSection(LineInfo);
2186 /// emitDebugInlineInfo - Emit inline info using following format.
2188 /// 1. length of section
2189 /// 2. Dwarf version number
2190 /// 3. address size.
2192 /// Entries (one "entry" for each function that was inlined):
2194 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2195 /// otherwise offset into __debug_str for regular function name.
2196 /// 2. offset into __debug_str section for regular function name.
2197 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2198 /// instances for the function.
2200 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2201 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2202 /// __debug_info section, and the low_pc is the starting address for the
2203 /// inlining instance.
2204 void DwarfDebug::emitDebugInlineInfo() {
2205 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2211 Asm->OutStreamer.SwitchSection(
2212 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2214 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2215 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2216 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2218 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2220 Asm->OutStreamer.AddComment("Dwarf Version");
2221 Asm->EmitInt16(dwarf::DWARF_VERSION);
2222 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2223 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2225 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2226 E = InlinedSPNodes.end(); I != E; ++I) {
2228 const MDNode *Node = *I;
2229 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2230 = InlineInfo.find(Node);
2231 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2232 DISubprogram SP(Node);
2233 StringRef LName = SP.getLinkageName();
2234 StringRef Name = SP.getName();
2236 Asm->OutStreamer.AddComment("MIPS linkage name");
2238 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2240 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2241 DwarfStrSectionSym);
2243 Asm->OutStreamer.AddComment("Function name");
2244 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2245 Asm->EmitULEB128(Labels.size(), "Inline count");
2247 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2248 LE = Labels.end(); LI != LE; ++LI) {
2249 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2250 Asm->EmitInt32(LI->second->getOffset());
2252 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2253 Asm->OutStreamer.EmitSymbolValue(LI->first,
2254 Asm->getDataLayout().getPointerSize(),0);
2258 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));