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/Module.h"
21 #include "llvm/Instructions.h"
22 #include "llvm/CodeGen/MachineFunction.h"
23 #include "llvm/CodeGen/MachineModuleInfo.h"
24 #include "llvm/MC/MCAsmInfo.h"
25 #include "llvm/MC/MCSection.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Target/TargetFrameLowering.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetRegisterInfo.h"
33 #include "llvm/Target/TargetOptions.h"
34 #include "llvm/Analysis/DebugInfo.h"
35 #include "llvm/Analysis/DIBuilder.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/ValueHandle.h"
43 #include "llvm/Support/FormattedStream.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Support/Path.h"
48 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
50 cl::desc("Disable debug info printing"));
52 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
53 cl::desc("Make an absence of debug location information explicit."),
56 static cl::opt<bool> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
57 cl::desc("Output prototype dwarf accelerator tables."),
61 const char *DWARFGroupName = "DWARF Emission";
62 const char *DbgTimerName = "DWARF Debug Writer";
63 } // end anonymous namespace
65 //===----------------------------------------------------------------------===//
67 /// Configuration values for initial hash set sizes (log2).
69 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
73 DIType DbgVariable::getType() const {
74 DIType Ty = Var.getType();
75 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
77 if (Var.isBlockByrefVariable()) {
78 /* Byref variables, in Blocks, are declared by the programmer as
79 "SomeType VarName;", but the compiler creates a
80 __Block_byref_x_VarName struct, and gives the variable VarName
81 either the struct, or a pointer to the struct, as its type. This
82 is necessary for various behind-the-scenes things the compiler
83 needs to do with by-reference variables in blocks.
85 However, as far as the original *programmer* is concerned, the
86 variable should still have type 'SomeType', as originally declared.
88 The following function dives into the __Block_byref_x_VarName
89 struct to find the original type of the variable. This will be
90 passed back to the code generating the type for the Debug
91 Information Entry for the variable 'VarName'. 'VarName' will then
92 have the original type 'SomeType' in its debug information.
94 The original type 'SomeType' will be the type of the field named
95 'VarName' inside the __Block_byref_x_VarName struct.
97 NOTE: In order for this to not completely fail on the debugger
98 side, the Debug Information Entry for the variable VarName needs to
99 have a DW_AT_location that tells the debugger how to unwind through
100 the pointers and __Block_byref_x_VarName struct to find the actual
101 value of the variable. The function addBlockByrefType does this. */
103 unsigned tag = Ty.getTag();
105 if (tag == dwarf::DW_TAG_pointer_type) {
106 DIDerivedType DTy = DIDerivedType(Ty);
107 subType = DTy.getTypeDerivedFrom();
110 DICompositeType blockStruct = DICompositeType(subType);
111 DIArray Elements = blockStruct.getTypeArray();
113 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
114 DIDescriptor Element = Elements.getElement(i);
115 DIDerivedType DT = DIDerivedType(Element);
116 if (getName() == DT.getName())
117 return (DT.getTypeDerivedFrom());
124 } // end llvm namespace
126 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
127 : Asm(A), MMI(Asm->MMI), FirstCU(0),
128 AbbreviationsSet(InitAbbreviationsSetSize),
130 NextStringPoolNumber = 0;
132 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
133 DwarfStrSectionSym = TextSectionSym = 0;
134 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
135 FunctionBeginSym = FunctionEndSym = 0;
137 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
141 DwarfDebug::~DwarfDebug() {
144 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
145 /// temporary label to it if SymbolStem is specified.
146 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
147 const char *SymbolStem = 0) {
148 Asm->OutStreamer.SwitchSection(Section);
149 if (!SymbolStem) return 0;
151 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
152 Asm->OutStreamer.EmitLabel(TmpSym);
156 MCSymbol *DwarfDebug::getStringPool() {
157 return Asm->GetTempSymbol("section_str");
160 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
161 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
162 if (Entry.first) return Entry.first;
164 Entry.second = NextStringPoolNumber++;
165 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
168 /// assignAbbrevNumber - Define a unique number for the abbreviation.
170 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
171 // Profile the node so that we can make it unique.
175 // Check the set for priors.
176 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
178 // If it's newly added.
179 if (InSet == &Abbrev) {
180 // Add to abbreviation list.
181 Abbreviations.push_back(&Abbrev);
183 // Assign the vector position + 1 as its number.
184 Abbrev.setNumber(Abbreviations.size());
186 // Assign existing abbreviation number.
187 Abbrev.setNumber(InSet->getNumber());
191 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
192 /// printer to not emit usual symbol prefix before the symbol name is used then
193 /// return linkage name after skipping this special LLVM prefix.
194 static StringRef getRealLinkageName(StringRef LinkageName) {
196 if (LinkageName.startswith(StringRef(&One, 1)))
197 return LinkageName.substr(1);
201 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
202 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
203 /// If there are global variables in this scope then create and insert
204 /// DIEs for these variables.
205 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
206 const MDNode *SPNode) {
207 DIE *SPDie = SPCU->getDIE(SPNode);
209 assert(SPDie && "Unable to find subprogram DIE!");
210 DISubprogram SP(SPNode);
212 DISubprogram SPDecl = SP.getFunctionDeclaration();
213 if (!SPDecl.isSubprogram()) {
214 // There is not any need to generate specification DIE for a function
215 // defined at compile unit level. If a function is defined inside another
216 // function then gdb prefers the definition at top level and but does not
217 // expect specification DIE in parent function. So avoid creating
218 // specification DIE for a function defined inside a function.
219 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
220 !SP.getContext().isFile() &&
221 !isSubprogramContext(SP.getContext())) {
222 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
225 DICompositeType SPTy = SP.getType();
226 DIArray Args = SPTy.getTypeArray();
227 unsigned SPTag = SPTy.getTag();
228 if (SPTag == dwarf::DW_TAG_subroutine_type)
229 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
230 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
231 DIType ATy = DIType(DIType(Args.getElement(i)));
232 SPCU->addType(Arg, ATy);
233 if (ATy.isArtificial())
234 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
235 SPDie->addChild(Arg);
237 DIE *SPDeclDie = SPDie;
238 SPDie = new DIE(dwarf::DW_TAG_subprogram);
239 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
244 // Pick up abstract subprogram DIE.
245 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
246 SPDie = new DIE(dwarf::DW_TAG_subprogram);
247 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
248 dwarf::DW_FORM_ref4, AbsSPDIE);
252 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
253 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
254 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
255 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
256 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
257 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
258 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
263 /// constructLexicalScope - Construct new DW_TAG_lexical_block
264 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
265 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
266 LexicalScope *Scope) {
267 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
268 if (Scope->isAbstractScope())
271 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
275 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
276 if (Ranges.size() > 1) {
277 // .debug_range section has not been laid out yet. Emit offset in
278 // .debug_range as a uint, size 4, for now. emitDIE will handle
279 // DW_AT_ranges appropriately.
280 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
281 DebugRangeSymbols.size()
282 * Asm->getTargetData().getPointerSize());
283 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
284 RE = Ranges.end(); RI != RE; ++RI) {
285 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
286 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
288 DebugRangeSymbols.push_back(NULL);
289 DebugRangeSymbols.push_back(NULL);
293 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
294 const MCSymbol *End = getLabelAfterInsn(RI->second);
296 if (End == 0) return 0;
298 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
299 assert(End->isDefined() && "Invalid end label for an inlined scope!");
301 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
302 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
307 /// constructInlinedScopeDIE - This scope represents inlined body of
308 /// a function. Construct DIE to represent this concrete inlined copy
310 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
311 LexicalScope *Scope) {
312 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
313 assert(Ranges.empty() == false &&
314 "LexicalScope does not have instruction markers!");
316 if (!Scope->getScopeNode())
318 DIScope DS(Scope->getScopeNode());
319 DISubprogram InlinedSP = getDISubprogram(DS);
320 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
322 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
326 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
327 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
328 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
330 if (StartLabel == 0 || EndLabel == 0) {
331 assert(0 && "Unexpected Start and End labels for a inlined scope!");
334 assert(StartLabel->isDefined() &&
335 "Invalid starting label for an inlined scope!");
336 assert(EndLabel->isDefined() &&
337 "Invalid end label for an inlined scope!");
339 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
340 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
341 dwarf::DW_FORM_ref4, OriginDIE);
343 if (Ranges.size() > 1) {
344 // .debug_range section has not been laid out yet. Emit offset in
345 // .debug_range as a uint, size 4, for now. emitDIE will handle
346 // DW_AT_ranges appropriately.
347 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
348 DebugRangeSymbols.size()
349 * Asm->getTargetData().getPointerSize());
350 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
351 RE = Ranges.end(); RI != RE; ++RI) {
352 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
353 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
355 DebugRangeSymbols.push_back(NULL);
356 DebugRangeSymbols.push_back(NULL);
358 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
360 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
364 InlinedSubprogramDIEs.insert(OriginDIE);
366 // Track the start label for this inlined function.
367 //.debug_inlined section specification does not clearly state how
368 // to emit inlined scope that is split into multiple instruction ranges.
369 // For now, use first instruction range and emit low_pc/high_pc pair and
370 // corresponding .debug_inlined section entry for this pair.
371 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
372 I = InlineInfo.find(InlinedSP);
374 if (I == InlineInfo.end()) {
375 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
376 InlinedSPNodes.push_back(InlinedSP);
378 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
380 DILocation DL(Scope->getInlinedAt());
381 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
382 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
387 /// constructScopeDIE - Construct a DIE for this scope.
388 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
389 if (!Scope || !Scope->getScopeNode())
392 SmallVector<DIE *, 8> Children;
394 // Collect arguments for current function.
395 if (LScopes.isCurrentFunctionScope(Scope))
396 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
397 if (DbgVariable *ArgDV = CurrentFnArguments[i])
399 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
400 Children.push_back(Arg);
402 // Collect lexical scope children first.
403 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
404 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
406 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
407 Children.push_back(Variable);
408 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
409 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
410 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
411 Children.push_back(Nested);
412 DIScope DS(Scope->getScopeNode());
413 DIE *ScopeDIE = NULL;
414 if (Scope->getInlinedAt())
415 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
416 else if (DS.isSubprogram()) {
417 ProcessedSPNodes.insert(DS);
418 if (Scope->isAbstractScope()) {
419 ScopeDIE = TheCU->getDIE(DS);
420 // Note down abstract DIE.
422 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
425 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
428 // There is no need to emit empty lexical block DIE.
429 if (Children.empty())
431 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
434 if (!ScopeDIE) return NULL;
437 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
438 E = Children.end(); I != E; ++I)
439 ScopeDIE->addChild(*I);
441 if (DS.isSubprogram())
442 TheCU->addPubTypes(DISubprogram(DS));
444 if (DS.isSubprogram() && !Scope->isAbstractScope())
445 TheCU->addAccelName(DISubprogram(DS).getName(), ScopeDIE);
450 /// GetOrCreateSourceID - Look up the source id with the given directory and
451 /// source file names. If none currently exists, create a new id and insert it
452 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
454 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
456 // If FE did not provide a file name, then assume stdin.
457 if (FileName.empty())
458 return GetOrCreateSourceID("<stdin>", StringRef());
460 // TODO: this might not belong here. See if we can factor this better.
461 if (DirName == CompilationDir)
464 unsigned SrcId = SourceIdMap.size()+1;
465 std::pair<std::string, std::string> SourceName =
466 std::make_pair(FileName, DirName);
467 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
468 make_pair(SourceName, SrcId);
470 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
472 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
476 // Print out a .file directive to specify files for .loc directives.
477 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
483 /// constructCompileUnit - Create new CompileUnit for the given
484 /// metadata node with tag DW_TAG_compile_unit.
485 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
486 DICompileUnit DIUnit(N);
487 StringRef FN = DIUnit.getFilename();
488 CompilationDir = DIUnit.getDirectory();
489 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
491 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
492 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
493 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
494 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
495 DIUnit.getLanguage());
496 NewCU->addString(Die, dwarf::DW_AT_name, FN);
497 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
498 // simplifies debug range entries.
499 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
500 // DW_AT_stmt_list is a offset of line number information for this
501 // compile unit in debug_line section.
502 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
503 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
504 Asm->GetTempSymbol("section_line"));
506 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
508 if (!CompilationDir.empty())
509 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
510 if (DIUnit.isOptimized())
511 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
513 StringRef Flags = DIUnit.getFlags();
515 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
517 if (unsigned RVer = DIUnit.getRunTimeVersion())
518 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
519 dwarf::DW_FORM_data1, RVer);
523 CUMap.insert(std::make_pair(N, NewCU));
527 static bool isObjCClass(StringRef Name) {
528 return Name.startswith("+") || Name.startswith("-");
531 static bool hasObjCCategory(StringRef Name) {
532 if (!isObjCClass(Name)) return false;
534 size_t pos = Name.find(')');
535 if (pos != std::string::npos) {
536 if (Name[pos+1] != ' ') return false;
542 static void getObjCClassCategory(StringRef In, StringRef &Class,
543 StringRef &Category) {
544 if (!hasObjCCategory(In)) {
545 Class = In.slice(In.find('[') + 1, In.find(' '));
550 Class = In.slice(In.find('[') + 1, In.find('('));
551 Category = In.slice(In.find('[') + 1, In.find(' '));
555 static StringRef getObjCMethodName(StringRef In) {
556 return In.slice(In.find(' ') + 1, In.find(']'));
559 /// construct SubprogramDIE - Construct subprogram DIE.
560 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
562 CompileUnit *&CURef = SPMap[N];
568 if (!SP.isDefinition())
569 // This is a method declaration which will be handled while constructing
573 DISubprogram SPDecl = SP.getFunctionDeclaration();
575 if (SPDecl.isSubprogram()) {
576 DeclDie = TheCU->getOrCreateSubprogramDIE(SPDecl);
579 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
582 // Refer function declaration directly.
583 TheCU->addDIEEntry(SubprogramDie, dwarf::DW_AT_specification,
584 dwarf::DW_FORM_ref4, DeclDie);
588 TheCU->insertDIE(N, SubprogramDie);
590 // Add to context owner.
591 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
594 TheCU->addGlobal(SP.getName(), SubprogramDie);
596 // Add to Accel Names
597 TheCU->addAccelName(SP.getName(), SubprogramDie);
599 // If this is an Objective-C selector name add it to the ObjC accelerator too.
600 if (isObjCClass(SP.getName())) {
601 StringRef Class, Category;
602 getObjCClassCategory(SP.getName(), Class, Category);
603 TheCU->addAccelObjC(Class, SubprogramDie);
605 TheCU->addAccelObjC(Category, SubprogramDie);
606 // Also add the base method name to the name table.
607 TheCU->addAccelName(getObjCMethodName(SP.getName()), SubprogramDie);
613 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
614 /// as llvm.dbg.enum and llvm.dbg.ty
615 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
616 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
617 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
618 const MDNode *N = NMD->getOperand(i);
619 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
620 constructSubprogramDIE(CU, N);
623 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
624 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
625 const MDNode *N = NMD->getOperand(i);
626 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
627 CU->createGlobalVariableDIE(N);
630 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
631 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
632 DIType Ty(NMD->getOperand(i));
633 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
634 CU->getOrCreateTypeDIE(Ty);
637 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
638 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
639 DIType Ty(NMD->getOperand(i));
640 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
641 CU->getOrCreateTypeDIE(Ty);
645 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
646 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
647 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
648 DebugInfoFinder DbgFinder;
649 DbgFinder.processModule(*M);
651 bool HasDebugInfo = false;
652 // Scan all the compile-units to see if there are any marked as the main
653 // unit. If not, we do not generate debug info.
654 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
655 E = DbgFinder.compile_unit_end(); I != E; ++I) {
656 if (DICompileUnit(*I).isMain()) {
661 if (!HasDebugInfo) return false;
663 // Create all the compile unit DIEs.
664 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
665 E = DbgFinder.compile_unit_end(); I != E; ++I)
666 constructCompileUnit(*I);
668 // Create DIEs for each global variable.
669 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
670 E = DbgFinder.global_variable_end(); I != E; ++I) {
671 const MDNode *N = *I;
672 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
673 CU->createGlobalVariableDIE(N);
676 // Create DIEs for each subprogram.
677 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
678 E = DbgFinder.subprogram_end(); I != E; ++I) {
679 const MDNode *N = *I;
680 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
681 constructSubprogramDIE(CU, N);
687 /// beginModule - Emit all Dwarf sections that should come prior to the
688 /// content. Create global DIEs and emit initial debug info sections.
689 /// This is invoked by the target AsmPrinter.
690 void DwarfDebug::beginModule(Module *M) {
691 if (DisableDebugInfoPrinting)
694 // If module has named metadata anchors then use them, otherwise scan the
695 // module using debug info finder to collect debug info.
696 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
698 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
699 DICompileUnit CUNode(CU_Nodes->getOperand(i));
700 CompileUnit *CU = constructCompileUnit(CUNode);
701 DIArray GVs = CUNode.getGlobalVariables();
702 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
703 CU->createGlobalVariableDIE(GVs.getElement(i));
704 DIArray SPs = CUNode.getSubprograms();
705 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
706 constructSubprogramDIE(CU, SPs.getElement(i));
707 DIArray EnumTypes = CUNode.getEnumTypes();
708 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
709 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
710 DIArray RetainedTypes = CUNode.getRetainedTypes();
711 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
712 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
714 } else if (!collectLegacyDebugInfo(M))
717 collectInfoFromNamedMDNodes(M);
719 // Tell MMI that we have debug info.
720 MMI->setDebugInfoAvailability(true);
722 // Emit initial sections.
725 // Prime section data.
726 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
729 /// endModule - Emit all Dwarf sections that should come after the content.
731 void DwarfDebug::endModule() {
732 if (!FirstCU) return;
733 const Module *M = MMI->getModule();
734 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
736 // Collect info for variables that were optimized out.
737 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
738 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
739 DICompileUnit TheCU(CU_Nodes->getOperand(i));
740 DIArray Subprograms = TheCU.getSubprograms();
741 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
742 DISubprogram SP(Subprograms.getElement(i));
743 if (ProcessedSPNodes.count(SP) != 0) continue;
744 if (!SP.Verify()) continue;
745 if (!SP.isDefinition()) continue;
746 DIArray Variables = SP.getVariables();
747 if (Variables.getNumElements() == 0) continue;
749 LexicalScope *Scope =
750 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
751 DeadFnScopeMap[SP] = Scope;
753 // Construct subprogram DIE and add variables DIEs.
754 CompileUnit *SPCU = CUMap.lookup(TheCU);
755 assert(SPCU && "Unable to find Compile Unit!");
756 constructSubprogramDIE(SPCU, SP);
757 DIE *ScopeDIE = SPCU->getDIE(SP);
758 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
759 DIVariable DV(Variables.getElement(vi));
760 if (!DV.Verify()) continue;
761 DbgVariable *NewVar = new DbgVariable(DV, NULL);
762 if (DIE *VariableDIE =
763 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
764 ScopeDIE->addChild(VariableDIE);
770 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
771 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
772 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
774 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
777 // Emit DW_AT_containing_type attribute to connect types with their
778 // vtable holding type.
779 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
780 CUE = CUMap.end(); CUI != CUE; ++CUI) {
781 CompileUnit *TheCU = CUI->second;
782 TheCU->constructContainingTypeDIEs();
785 // Standard sections final addresses.
786 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
787 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
788 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
789 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
791 // End text sections.
792 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
793 Asm->OutStreamer.SwitchSection(SectionMap[i]);
794 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
797 // Compute DIE offsets and sizes.
798 computeSizeAndOffsets();
800 // Emit all the DIEs into a debug info section
803 // Corresponding abbreviations into a abbrev section.
806 // Emit info into a dwarf accelerator table sections.
807 if (DwarfAccelTables) {
810 emitAccelNamespaces();
814 // Emit info into a debug pubnames section.
817 // Emit info into a debug pubtypes section.
820 // Emit info into a debug loc section.
823 // Emit info into a debug aranges section.
826 // Emit info into a debug ranges section.
829 // Emit info into a debug macinfo section.
833 emitDebugInlineInfo();
835 // Emit info into a debug str section.
839 DeleteContainerSeconds(DeadFnScopeMap);
841 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
842 E = CUMap.end(); I != E; ++I)
844 FirstCU = NULL; // Reset for the next Module, if any.
847 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
848 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
850 LLVMContext &Ctx = DV->getContext();
851 // More then one inlined variable corresponds to one abstract variable.
852 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
853 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
855 return AbsDbgVariable;
857 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
861 AbsDbgVariable = new DbgVariable(Var, NULL);
862 addScopeVariable(Scope, AbsDbgVariable);
863 AbstractVariables[Var] = AbsDbgVariable;
864 return AbsDbgVariable;
867 /// addCurrentFnArgument - If Var is a current function argument then add
868 /// it to CurrentFnArguments list.
869 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
870 DbgVariable *Var, LexicalScope *Scope) {
871 if (!LScopes.isCurrentFunctionScope(Scope))
873 DIVariable DV = Var->getVariable();
874 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
876 unsigned ArgNo = DV.getArgNumber();
880 size_t Size = CurrentFnArguments.size();
882 CurrentFnArguments.resize(MF->getFunction()->arg_size());
883 // llvm::Function argument size is not good indicator of how many
884 // arguments does the function have at source level.
886 CurrentFnArguments.resize(ArgNo * 2);
887 CurrentFnArguments[ArgNo - 1] = Var;
891 /// collectVariableInfoFromMMITable - Collect variable information from
892 /// side table maintained by MMI.
894 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
895 SmallPtrSet<const MDNode *, 16> &Processed) {
896 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
897 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
898 VE = VMap.end(); VI != VE; ++VI) {
899 const MDNode *Var = VI->first;
901 Processed.insert(Var);
903 const std::pair<unsigned, DebugLoc> &VP = VI->second;
905 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
907 // If variable scope is not found then skip this variable.
911 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
912 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
913 RegVar->setFrameIndex(VP.first);
914 if (!addCurrentFnArgument(MF, RegVar, Scope))
915 addScopeVariable(Scope, RegVar);
917 AbsDbgVariable->setFrameIndex(VP.first);
921 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
922 /// DBG_VALUE instruction, is in a defined reg.
923 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
924 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
925 return MI->getNumOperands() == 3 &&
926 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
927 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
930 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
932 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
933 const MCSymbol *FLabel,
934 const MCSymbol *SLabel,
935 const MachineInstr *MI) {
936 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
938 if (MI->getNumOperands() != 3) {
939 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
940 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
942 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
943 MachineLocation MLoc;
944 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
945 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
947 if (MI->getOperand(0).isImm())
948 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
949 if (MI->getOperand(0).isFPImm())
950 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
951 if (MI->getOperand(0).isCImm())
952 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
954 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
955 return DotDebugLocEntry();
958 /// collectVariableInfo - Find variables for each lexical scope.
960 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
961 SmallPtrSet<const MDNode *, 16> &Processed) {
963 /// collection info from MMI table.
964 collectVariableInfoFromMMITable(MF, Processed);
966 for (SmallVectorImpl<const MDNode*>::const_iterator
967 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
969 const MDNode *Var = *UVI;
970 if (Processed.count(Var))
973 // History contains relevant DBG_VALUE instructions for Var and instructions
975 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
978 const MachineInstr *MInsn = History.front();
981 LexicalScope *Scope = NULL;
982 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
983 DISubprogram(DV.getContext()).describes(MF->getFunction()))
984 Scope = LScopes.getCurrentFunctionScope();
986 if (DV.getVersion() <= LLVMDebugVersion9)
987 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
989 if (MDNode *IA = DV.getInlinedAt())
990 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
992 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
995 // If variable scope is not found then skip this variable.
999 Processed.insert(DV);
1000 assert(MInsn->isDebugValue() && "History must begin with debug value");
1001 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1002 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1003 if (!addCurrentFnArgument(MF, RegVar, Scope))
1004 addScopeVariable(Scope, RegVar);
1006 AbsVar->setMInsn(MInsn);
1008 // Simple ranges that are fully coalesced.
1009 if (History.size() <= 1 || (History.size() == 2 &&
1010 MInsn->isIdenticalTo(History.back()))) {
1011 RegVar->setMInsn(MInsn);
1015 // handle multiple DBG_VALUE instructions describing one variable.
1016 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1018 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1019 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1020 const MachineInstr *Begin = *HI;
1021 assert(Begin->isDebugValue() && "Invalid History entry");
1023 // Check if DBG_VALUE is truncating a range.
1024 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1025 && !Begin->getOperand(0).getReg())
1028 // Compute the range for a register location.
1029 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1030 const MCSymbol *SLabel = 0;
1033 // If Begin is the last instruction in History then its value is valid
1034 // until the end of the function.
1035 SLabel = FunctionEndSym;
1037 const MachineInstr *End = HI[1];
1038 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1039 << "\t" << *Begin << "\t" << *End << "\n");
1040 if (End->isDebugValue())
1041 SLabel = getLabelBeforeInsn(End);
1043 // End is a normal instruction clobbering the range.
1044 SLabel = getLabelAfterInsn(End);
1045 assert(SLabel && "Forgot label after clobber instruction");
1050 // The value is valid until the next DBG_VALUE or clobber.
1051 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1053 DotDebugLocEntries.push_back(DotDebugLocEntry());
1056 // Collect info for variables that were optimized out.
1057 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1058 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1059 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1060 DIVariable DV(Variables.getElement(i));
1061 if (!DV || !DV.Verify() || !Processed.insert(DV))
1063 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1064 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1068 /// getLabelBeforeInsn - Return Label preceding the instruction.
1069 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1070 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1071 assert(Label && "Didn't insert label before instruction");
1075 /// getLabelAfterInsn - Return Label immediately following the instruction.
1076 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1077 return LabelsAfterInsn.lookup(MI);
1080 /// beginInstruction - Process beginning of an instruction.
1081 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1082 // Check if source location changes, but ignore DBG_VALUE locations.
1083 if (!MI->isDebugValue()) {
1084 DebugLoc DL = MI->getDebugLoc();
1085 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1086 unsigned Flags = DWARF2_FLAG_IS_STMT;
1088 if (DL == PrologEndLoc) {
1089 Flags |= DWARF2_FLAG_PROLOGUE_END;
1090 PrologEndLoc = DebugLoc();
1092 if (!DL.isUnknown()) {
1093 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1094 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1096 recordSourceLine(0, 0, 0, 0);
1100 // Insert labels where requested.
1101 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1102 LabelsBeforeInsn.find(MI);
1105 if (I == LabelsBeforeInsn.end())
1108 // Label already assigned.
1113 PrevLabel = MMI->getContext().CreateTempSymbol();
1114 Asm->OutStreamer.EmitLabel(PrevLabel);
1116 I->second = PrevLabel;
1119 /// endInstruction - Process end of an instruction.
1120 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1121 // Don't create a new label after DBG_VALUE instructions.
1122 // They don't generate code.
1123 if (!MI->isDebugValue())
1126 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1127 LabelsAfterInsn.find(MI);
1130 if (I == LabelsAfterInsn.end())
1133 // Label already assigned.
1137 // We need a label after this instruction.
1139 PrevLabel = MMI->getContext().CreateTempSymbol();
1140 Asm->OutStreamer.EmitLabel(PrevLabel);
1142 I->second = PrevLabel;
1145 /// identifyScopeMarkers() -
1146 /// Each LexicalScope has first instruction and last instruction to mark
1147 /// beginning and end of a scope respectively. Create an inverse map that list
1148 /// scopes starts (and ends) with an instruction. One instruction may start (or
1149 /// end) multiple scopes. Ignore scopes that are not reachable.
1150 void DwarfDebug::identifyScopeMarkers() {
1151 SmallVector<LexicalScope *, 4> WorkList;
1152 WorkList.push_back(LScopes.getCurrentFunctionScope());
1153 while (!WorkList.empty()) {
1154 LexicalScope *S = WorkList.pop_back_val();
1156 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1157 if (!Children.empty())
1158 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1159 SE = Children.end(); SI != SE; ++SI)
1160 WorkList.push_back(*SI);
1162 if (S->isAbstractScope())
1165 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1168 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1169 RE = Ranges.end(); RI != RE; ++RI) {
1170 assert(RI->first && "InsnRange does not have first instruction!");
1171 assert(RI->second && "InsnRange does not have second instruction!");
1172 requestLabelBeforeInsn(RI->first);
1173 requestLabelAfterInsn(RI->second);
1178 /// getScopeNode - Get MDNode for DebugLoc's scope.
1179 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1180 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1181 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1182 return DL.getScope(Ctx);
1185 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1186 /// line number info for the function.
1187 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1188 const MDNode *Scope = getScopeNode(DL, Ctx);
1189 DISubprogram SP = getDISubprogram(Scope);
1191 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1195 /// beginFunction - Gather pre-function debug information. Assumes being
1196 /// emitted immediately after the function entry point.
1197 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1198 if (!MMI->hasDebugInfo()) return;
1199 LScopes.initialize(*MF);
1200 if (LScopes.empty()) return;
1201 identifyScopeMarkers();
1203 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1204 Asm->getFunctionNumber());
1205 // Assumes in correct section after the entry point.
1206 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1208 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1210 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1211 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1212 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1214 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1216 bool AtBlockEntry = true;
1217 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1219 const MachineInstr *MI = II;
1221 if (MI->isDebugValue()) {
1222 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1224 // Keep track of user variables.
1226 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1228 // Variable is in a register, we need to check for clobbers.
1229 if (isDbgValueInDefinedReg(MI))
1230 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1232 // Check the history of this variable.
1233 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1234 if (History.empty()) {
1235 UserVariables.push_back(Var);
1236 // The first mention of a function argument gets the FunctionBeginSym
1237 // label, so arguments are visible when breaking at function entry.
1239 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1240 DISubprogram(getDISubprogram(DV.getContext()))
1241 .describes(MF->getFunction()))
1242 LabelsBeforeInsn[MI] = FunctionBeginSym;
1244 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1245 const MachineInstr *Prev = History.back();
1246 if (Prev->isDebugValue()) {
1247 // Coalesce identical entries at the end of History.
1248 if (History.size() >= 2 &&
1249 Prev->isIdenticalTo(History[History.size() - 2])) {
1250 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1252 << "\t" << *History[History.size() - 2] << "\n");
1256 // Terminate old register assignments that don't reach MI;
1257 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1258 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1259 isDbgValueInDefinedReg(Prev)) {
1260 // Previous register assignment needs to terminate at the end of
1262 MachineBasicBlock::const_iterator LastMI =
1263 PrevMBB->getLastNonDebugInstr();
1264 if (LastMI == PrevMBB->end()) {
1265 // Drop DBG_VALUE for empty range.
1266 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1267 << "\t" << *Prev << "\n");
1271 // Terminate after LastMI.
1272 History.push_back(LastMI);
1277 History.push_back(MI);
1279 // Not a DBG_VALUE instruction.
1281 AtBlockEntry = false;
1283 // First known non DBG_VALUE location marks beginning of function
1285 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1286 PrologEndLoc = MI->getDebugLoc();
1288 // Check if the instruction clobbers any registers with debug vars.
1289 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1290 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1291 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1293 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1294 unsigned Reg = *AI; ++AI) {
1295 const MDNode *Var = LiveUserVar[Reg];
1298 // Reg is now clobbered.
1299 LiveUserVar[Reg] = 0;
1301 // Was MD last defined by a DBG_VALUE referring to Reg?
1302 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1303 if (HistI == DbgValues.end())
1305 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1306 if (History.empty())
1308 const MachineInstr *Prev = History.back();
1309 // Sanity-check: Register assignments are terminated at the end of
1311 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1313 // Is the variable still in Reg?
1314 if (!isDbgValueInDefinedReg(Prev) ||
1315 Prev->getOperand(0).getReg() != Reg)
1317 // Var is clobbered. Make sure the next instruction gets a label.
1318 History.push_back(MI);
1325 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1327 SmallVectorImpl<const MachineInstr*> &History = I->second;
1328 if (History.empty())
1331 // Make sure the final register assignments are terminated.
1332 const MachineInstr *Prev = History.back();
1333 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1334 const MachineBasicBlock *PrevMBB = Prev->getParent();
1335 MachineBasicBlock::const_iterator LastMI =
1336 PrevMBB->getLastNonDebugInstr();
1337 if (LastMI == PrevMBB->end())
1338 // Drop DBG_VALUE for empty range.
1341 // Terminate after LastMI.
1342 History.push_back(LastMI);
1345 // Request labels for the full history.
1346 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1347 const MachineInstr *MI = History[i];
1348 if (MI->isDebugValue())
1349 requestLabelBeforeInsn(MI);
1351 requestLabelAfterInsn(MI);
1355 PrevInstLoc = DebugLoc();
1356 PrevLabel = FunctionBeginSym;
1358 // Record beginning of function.
1359 if (!PrologEndLoc.isUnknown()) {
1360 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1361 MF->getFunction()->getContext());
1362 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1363 FnStartDL.getScope(MF->getFunction()->getContext()),
1364 DWARF2_FLAG_IS_STMT);
1368 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1369 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1370 ScopeVariables[LS].push_back(Var);
1371 // Vars.push_back(Var);
1374 /// endFunction - Gather and emit post-function debug information.
1376 void DwarfDebug::endFunction(const MachineFunction *MF) {
1377 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1379 // Define end label for subprogram.
1380 FunctionEndSym = Asm->GetTempSymbol("func_end",
1381 Asm->getFunctionNumber());
1382 // Assumes in correct section after the entry point.
1383 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1385 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1386 collectVariableInfo(MF, ProcessedVars);
1388 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1389 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1390 assert(TheCU && "Unable to find compile unit!");
1392 // Construct abstract scopes.
1393 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1394 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1395 LexicalScope *AScope = AList[i];
1396 DISubprogram SP(AScope->getScopeNode());
1398 // Collect info for variables that were optimized out.
1399 DIArray Variables = SP.getVariables();
1400 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1401 DIVariable DV(Variables.getElement(i));
1402 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1404 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1405 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1408 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1409 constructScopeDIE(TheCU, AScope);
1412 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1414 if (!DisableFramePointerElim(*MF))
1415 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1416 dwarf::DW_FORM_flag, 1);
1418 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1419 MMI->getFrameMoves()));
1422 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1423 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1424 DeleteContainerPointers(I->second);
1425 ScopeVariables.clear();
1426 DeleteContainerPointers(CurrentFnArguments);
1427 UserVariables.clear();
1429 AbstractVariables.clear();
1430 LabelsBeforeInsn.clear();
1431 LabelsAfterInsn.clear();
1435 /// recordSourceLine - Register a source line with debug info. Returns the
1436 /// unique label that was emitted and which provides correspondence to
1437 /// the source line list.
1438 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1444 DIDescriptor Scope(S);
1446 if (Scope.isCompileUnit()) {
1447 DICompileUnit CU(S);
1448 Fn = CU.getFilename();
1449 Dir = CU.getDirectory();
1450 } else if (Scope.isFile()) {
1452 Fn = F.getFilename();
1453 Dir = F.getDirectory();
1454 } else if (Scope.isSubprogram()) {
1456 Fn = SP.getFilename();
1457 Dir = SP.getDirectory();
1458 } else if (Scope.isLexicalBlockFile()) {
1459 DILexicalBlockFile DBF(S);
1460 Fn = DBF.getFilename();
1461 Dir = DBF.getDirectory();
1462 } else if (Scope.isLexicalBlock()) {
1463 DILexicalBlock DB(S);
1464 Fn = DB.getFilename();
1465 Dir = DB.getDirectory();
1467 assert(0 && "Unexpected scope info");
1469 Src = GetOrCreateSourceID(Fn, Dir);
1471 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1474 //===----------------------------------------------------------------------===//
1476 //===----------------------------------------------------------------------===//
1478 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1481 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1482 // Get the children.
1483 const std::vector<DIE *> &Children = Die->getChildren();
1485 // If not last sibling and has children then add sibling offset attribute.
1486 if (!Last && !Children.empty())
1487 Die->addSiblingOffset(DIEValueAllocator);
1489 // Record the abbreviation.
1490 assignAbbrevNumber(Die->getAbbrev());
1492 // Get the abbreviation for this DIE.
1493 unsigned AbbrevNumber = Die->getAbbrevNumber();
1494 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1497 Die->setOffset(Offset);
1499 // Start the size with the size of abbreviation code.
1500 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1502 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1503 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1505 // Size the DIE attribute values.
1506 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1507 // Size attribute value.
1508 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1510 // Size the DIE children if any.
1511 if (!Children.empty()) {
1512 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1513 "Children flag not set");
1515 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1516 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1518 // End of children marker.
1519 Offset += sizeof(int8_t);
1522 Die->setSize(Offset - Die->getOffset());
1526 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1528 void DwarfDebug::computeSizeAndOffsets() {
1529 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1530 E = CUMap.end(); I != E; ++I) {
1531 // Compute size of compile unit header.
1533 sizeof(int32_t) + // Length of Compilation Unit Info
1534 sizeof(int16_t) + // DWARF version number
1535 sizeof(int32_t) + // Offset Into Abbrev. Section
1536 sizeof(int8_t); // Pointer Size (in bytes)
1537 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1541 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1542 /// the start of each one.
1543 void DwarfDebug::EmitSectionLabels() {
1544 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1546 // Dwarf sections base addresses.
1547 DwarfInfoSectionSym =
1548 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1549 DwarfAbbrevSectionSym =
1550 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1551 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1553 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1554 EmitSectionSym(Asm, MacroInfo);
1556 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1557 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1558 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1559 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1560 DwarfStrSectionSym =
1561 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1562 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1565 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1566 "section_debug_loc");
1568 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1569 EmitSectionSym(Asm, TLOF.getDataSection());
1572 /// emitDIE - Recursively emits a debug information entry.
1574 void DwarfDebug::emitDIE(DIE *Die) {
1575 // Get the abbreviation for this DIE.
1576 unsigned AbbrevNumber = Die->getAbbrevNumber();
1577 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1579 // Emit the code (index) for the abbreviation.
1580 if (Asm->isVerbose())
1581 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1582 Twine::utohexstr(Die->getOffset()) + ":0x" +
1583 Twine::utohexstr(Die->getSize()) + " " +
1584 dwarf::TagString(Abbrev->getTag()));
1585 Asm->EmitULEB128(AbbrevNumber);
1587 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1588 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1590 // Emit the DIE attribute values.
1591 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1592 unsigned Attr = AbbrevData[i].getAttribute();
1593 unsigned Form = AbbrevData[i].getForm();
1594 assert(Form && "Too many attributes for DIE (check abbreviation)");
1596 if (Asm->isVerbose())
1597 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1600 case dwarf::DW_AT_sibling:
1601 Asm->EmitInt32(Die->getSiblingOffset());
1603 case dwarf::DW_AT_abstract_origin: {
1604 DIEEntry *E = cast<DIEEntry>(Values[i]);
1605 DIE *Origin = E->getEntry();
1606 unsigned Addr = Origin->getOffset();
1607 Asm->EmitInt32(Addr);
1610 case dwarf::DW_AT_ranges: {
1611 // DW_AT_range Value encodes offset in debug_range section.
1612 DIEInteger *V = cast<DIEInteger>(Values[i]);
1614 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1615 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1619 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1621 DwarfDebugRangeSectionSym,
1626 case dwarf::DW_AT_location: {
1627 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1628 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1630 Values[i]->EmitValue(Asm, Form);
1633 case dwarf::DW_AT_accessibility: {
1634 if (Asm->isVerbose()) {
1635 DIEInteger *V = cast<DIEInteger>(Values[i]);
1636 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1638 Values[i]->EmitValue(Asm, Form);
1642 // Emit an attribute using the defined form.
1643 Values[i]->EmitValue(Asm, Form);
1648 // Emit the DIE children if any.
1649 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1650 const std::vector<DIE *> &Children = Die->getChildren();
1652 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1653 emitDIE(Children[j]);
1655 if (Asm->isVerbose())
1656 Asm->OutStreamer.AddComment("End Of Children Mark");
1661 /// emitDebugInfo - Emit the debug info section.
1663 void DwarfDebug::emitDebugInfo() {
1664 // Start debug info section.
1665 Asm->OutStreamer.SwitchSection(
1666 Asm->getObjFileLowering().getDwarfInfoSection());
1667 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1668 E = CUMap.end(); I != E; ++I) {
1669 CompileUnit *TheCU = I->second;
1670 DIE *Die = TheCU->getCUDie();
1672 // Emit the compile units header.
1673 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1676 // Emit size of content not including length itself
1677 unsigned ContentSize = Die->getSize() +
1678 sizeof(int16_t) + // DWARF version number
1679 sizeof(int32_t) + // Offset Into Abbrev. Section
1680 sizeof(int8_t); // Pointer Size (in bytes)
1682 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1683 Asm->EmitInt32(ContentSize);
1684 Asm->OutStreamer.AddComment("DWARF version number");
1685 Asm->EmitInt16(dwarf::DWARF_VERSION);
1686 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1687 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1688 DwarfAbbrevSectionSym);
1689 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1690 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1693 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1697 /// emitAbbreviations - Emit the abbreviation section.
1699 void DwarfDebug::emitAbbreviations() const {
1700 // Check to see if it is worth the effort.
1701 if (!Abbreviations.empty()) {
1702 // Start the debug abbrev section.
1703 Asm->OutStreamer.SwitchSection(
1704 Asm->getObjFileLowering().getDwarfAbbrevSection());
1706 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1708 // For each abbrevation.
1709 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1710 // Get abbreviation data
1711 const DIEAbbrev *Abbrev = Abbreviations[i];
1713 // Emit the abbrevations code (base 1 index.)
1714 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1716 // Emit the abbreviations data.
1720 // Mark end of abbreviations.
1721 Asm->EmitULEB128(0, "EOM(3)");
1723 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1727 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1728 /// the line matrix.
1730 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1731 // Define last address of section.
1732 Asm->OutStreamer.AddComment("Extended Op");
1735 Asm->OutStreamer.AddComment("Op size");
1736 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1737 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1738 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1740 Asm->OutStreamer.AddComment("Section end label");
1742 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1743 Asm->getTargetData().getPointerSize(),
1746 // Mark end of matrix.
1747 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1753 /// emitAccelNames - Emit visible names into a hashed accelerator table
1755 void DwarfDebug::emitAccelNames() {
1756 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1757 dwarf::DW_FORM_data4));
1758 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1759 E = CUMap.end(); I != E; ++I) {
1760 CompileUnit *TheCU = I->second;
1761 const StringMap<DIE*> &Names = TheCU->getAccelNames();
1762 for (StringMap<DIE*>::const_iterator
1763 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1764 const char *Name = GI->getKeyData();
1765 DIE *Entity = GI->second;
1766 AT.AddName(Name, Entity);
1770 AT.FinalizeTable(Asm, "Names");
1771 Asm->OutStreamer.SwitchSection(
1772 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1773 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1774 Asm->OutStreamer.EmitLabel(SectionBegin);
1776 // Emit the full data.
1777 AT.Emit(Asm, SectionBegin, this);
1780 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1781 /// accelerator table section.
1782 void DwarfDebug::emitAccelObjC() {
1783 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1784 dwarf::DW_FORM_data4));
1785 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1786 E = CUMap.end(); I != E; ++I) {
1787 CompileUnit *TheCU = I->second;
1788 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1789 for (StringMap<std::vector<DIE*> >::const_iterator
1790 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1791 const char *Name = GI->getKeyData();
1792 std::vector<DIE *> Entities = GI->second;
1793 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1794 DE = Entities.end(); DI != DE; ++DI)
1795 AT.AddName(Name, (*DI));
1799 AT.FinalizeTable(Asm, "ObjC");
1800 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1801 .getDwarfAccelObjCSection());
1802 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1803 Asm->OutStreamer.EmitLabel(SectionBegin);
1805 // Emit the full data.
1806 AT.Emit(Asm, SectionBegin, this);
1809 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1811 void DwarfDebug::emitAccelNamespaces() {
1812 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1813 dwarf::DW_FORM_data4));
1814 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1815 E = CUMap.end(); I != E; ++I) {
1816 CompileUnit *TheCU = I->second;
1817 const StringMap<DIE*> &Names = TheCU->getAccelNamespace();
1818 for (StringMap<DIE*>::const_iterator
1819 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1820 const char *Name = GI->getKeyData();
1821 DIE *Entity = GI->second;
1822 AT.AddName(Name, Entity);
1826 AT.FinalizeTable(Asm, "namespac");
1827 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1828 .getDwarfAccelNamespaceSection());
1829 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1830 Asm->OutStreamer.EmitLabel(SectionBegin);
1832 // Emit the full data.
1833 AT.Emit(Asm, SectionBegin, this);
1836 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1837 void DwarfDebug::emitAccelTypes() {
1838 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1839 dwarf::DW_FORM_data4));
1840 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1841 E = CUMap.end(); I != E; ++I) {
1842 CompileUnit *TheCU = I->second;
1843 const StringMap<DIE*> &Names = TheCU->getAccelTypes();
1844 for (StringMap<DIE*>::const_iterator
1845 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1846 const char *Name = GI->getKeyData();
1847 DIE *Entity = GI->second;
1848 AT.AddName(Name, Entity);
1852 AT.FinalizeTable(Asm, "types");
1853 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1854 .getDwarfAccelTypesSection());
1855 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1856 Asm->OutStreamer.EmitLabel(SectionBegin);
1858 // Emit the full data.
1859 AT.Emit(Asm, SectionBegin, this);
1862 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1864 void DwarfDebug::emitDebugPubNames() {
1865 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1866 E = CUMap.end(); I != E; ++I) {
1867 CompileUnit *TheCU = I->second;
1868 // Start the dwarf pubnames section.
1869 Asm->OutStreamer.SwitchSection(
1870 Asm->getObjFileLowering().getDwarfPubNamesSection());
1872 Asm->OutStreamer.AddComment("Length of Public Names Info");
1873 Asm->EmitLabelDifference(
1874 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
1875 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
1877 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
1880 Asm->OutStreamer.AddComment("DWARF Version");
1881 Asm->EmitInt16(dwarf::DWARF_VERSION);
1883 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1884 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1885 DwarfInfoSectionSym);
1887 Asm->OutStreamer.AddComment("Compilation Unit Length");
1888 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1889 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1892 const StringMap<DIE*> &Globals = TheCU->getGlobals();
1893 for (StringMap<DIE*>::const_iterator
1894 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1895 const char *Name = GI->getKeyData();
1896 DIE *Entity = GI->second;
1898 Asm->OutStreamer.AddComment("DIE offset");
1899 Asm->EmitInt32(Entity->getOffset());
1901 if (Asm->isVerbose())
1902 Asm->OutStreamer.AddComment("External Name");
1903 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
1906 Asm->OutStreamer.AddComment("End Mark");
1908 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
1913 void DwarfDebug::emitDebugPubTypes() {
1914 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1915 E = CUMap.end(); I != E; ++I) {
1916 CompileUnit *TheCU = I->second;
1917 // Start the dwarf pubtypes section.
1918 Asm->OutStreamer.SwitchSection(
1919 Asm->getObjFileLowering().getDwarfPubTypesSection());
1920 Asm->OutStreamer.AddComment("Length of Public Types Info");
1921 Asm->EmitLabelDifference(
1922 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1923 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1925 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1928 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1929 Asm->EmitInt16(dwarf::DWARF_VERSION);
1931 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1932 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1933 DwarfInfoSectionSym);
1935 Asm->OutStreamer.AddComment("Compilation Unit Length");
1936 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1937 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1940 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1941 for (StringMap<DIE*>::const_iterator
1942 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1943 const char *Name = GI->getKeyData();
1944 DIE *Entity = GI->second;
1946 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1947 Asm->EmitInt32(Entity->getOffset());
1949 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1950 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1953 Asm->OutStreamer.AddComment("End Mark");
1955 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1960 /// emitDebugStr - Emit visible names into a debug str section.
1962 void DwarfDebug::emitDebugStr() {
1963 // Check to see if it is worth the effort.
1964 if (StringPool.empty()) return;
1966 // Start the dwarf str section.
1967 Asm->OutStreamer.SwitchSection(
1968 Asm->getObjFileLowering().getDwarfStrSection());
1970 // Get all of the string pool entries and put them in an array by their ID so
1971 // we can sort them.
1972 SmallVector<std::pair<unsigned,
1973 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1975 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1976 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1977 Entries.push_back(std::make_pair(I->second.second, &*I));
1979 array_pod_sort(Entries.begin(), Entries.end());
1981 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1982 // Emit a label for reference from debug information entries.
1983 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1985 // Emit the string itself.
1986 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
1987 Asm->OutStreamer.EmitZeros(1, 0);
1991 /// emitDebugLoc - Emit visible names into a debug loc section.
1993 void DwarfDebug::emitDebugLoc() {
1994 if (DotDebugLocEntries.empty())
1997 for (SmallVector<DotDebugLocEntry, 4>::iterator
1998 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2000 DotDebugLocEntry &Entry = *I;
2001 if (I + 1 != DotDebugLocEntries.end())
2005 // Start the dwarf loc section.
2006 Asm->OutStreamer.SwitchSection(
2007 Asm->getObjFileLowering().getDwarfLocSection());
2008 unsigned char Size = Asm->getTargetData().getPointerSize();
2009 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2011 for (SmallVector<DotDebugLocEntry, 4>::iterator
2012 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2013 I != E; ++I, ++index) {
2014 DotDebugLocEntry &Entry = *I;
2015 if (Entry.isMerged()) continue;
2016 if (Entry.isEmpty()) {
2017 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2018 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2019 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2021 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2022 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2023 DIVariable DV(Entry.Variable);
2024 Asm->OutStreamer.AddComment("Loc expr size");
2025 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2026 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2027 Asm->EmitLabelDifference(end, begin, 2);
2028 Asm->OutStreamer.EmitLabel(begin);
2029 if (Entry.isInt()) {
2030 DIBasicType BTy(DV.getType());
2032 (BTy.getEncoding() == dwarf::DW_ATE_signed
2033 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2034 Asm->OutStreamer.AddComment("DW_OP_consts");
2035 Asm->EmitInt8(dwarf::DW_OP_consts);
2036 Asm->EmitSLEB128(Entry.getInt());
2038 Asm->OutStreamer.AddComment("DW_OP_constu");
2039 Asm->EmitInt8(dwarf::DW_OP_constu);
2040 Asm->EmitULEB128(Entry.getInt());
2042 } else if (Entry.isLocation()) {
2043 if (!DV.hasComplexAddress())
2045 Asm->EmitDwarfRegOp(Entry.Loc);
2047 // Complex address entry.
2048 unsigned N = DV.getNumAddrElements();
2050 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2051 if (Entry.Loc.getOffset()) {
2053 Asm->EmitDwarfRegOp(Entry.Loc);
2054 Asm->OutStreamer.AddComment("DW_OP_deref");
2055 Asm->EmitInt8(dwarf::DW_OP_deref);
2056 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2057 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2058 Asm->EmitSLEB128(DV.getAddrElement(1));
2060 // If first address element is OpPlus then emit
2061 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2062 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2063 Asm->EmitDwarfRegOp(Loc);
2067 Asm->EmitDwarfRegOp(Entry.Loc);
2070 // Emit remaining complex address elements.
2071 for (; i < N; ++i) {
2072 uint64_t Element = DV.getAddrElement(i);
2073 if (Element == DIBuilder::OpPlus) {
2074 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2075 Asm->EmitULEB128(DV.getAddrElement(++i));
2076 } else if (Element == DIBuilder::OpDeref)
2077 Asm->EmitInt8(dwarf::DW_OP_deref);
2078 else llvm_unreachable("unknown Opcode found in complex address");
2082 // else ... ignore constant fp. There is not any good way to
2083 // to represent them here in dwarf.
2084 Asm->OutStreamer.EmitLabel(end);
2089 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2091 void DwarfDebug::EmitDebugARanges() {
2092 // Start the dwarf aranges section.
2093 Asm->OutStreamer.SwitchSection(
2094 Asm->getObjFileLowering().getDwarfARangesSection());
2097 /// emitDebugRanges - Emit visible names into a debug ranges section.
2099 void DwarfDebug::emitDebugRanges() {
2100 // Start the dwarf ranges section.
2101 Asm->OutStreamer.SwitchSection(
2102 Asm->getObjFileLowering().getDwarfRangesSection());
2103 unsigned char Size = Asm->getTargetData().getPointerSize();
2104 for (SmallVector<const MCSymbol *, 8>::iterator
2105 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2108 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2110 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2114 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2116 void DwarfDebug::emitDebugMacInfo() {
2117 if (const MCSection *LineInfo =
2118 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2119 // Start the dwarf macinfo section.
2120 Asm->OutStreamer.SwitchSection(LineInfo);
2124 /// emitDebugInlineInfo - Emit inline info using following format.
2126 /// 1. length of section
2127 /// 2. Dwarf version number
2128 /// 3. address size.
2130 /// Entries (one "entry" for each function that was inlined):
2132 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2133 /// otherwise offset into __debug_str for regular function name.
2134 /// 2. offset into __debug_str section for regular function name.
2135 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2136 /// instances for the function.
2138 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2139 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2140 /// __debug_info section, and the low_pc is the starting address for the
2141 /// inlining instance.
2142 void DwarfDebug::emitDebugInlineInfo() {
2143 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2149 Asm->OutStreamer.SwitchSection(
2150 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2152 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2153 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2154 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2156 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2158 Asm->OutStreamer.AddComment("Dwarf Version");
2159 Asm->EmitInt16(dwarf::DWARF_VERSION);
2160 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2161 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2163 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2164 E = InlinedSPNodes.end(); I != E; ++I) {
2166 const MDNode *Node = *I;
2167 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2168 = InlineInfo.find(Node);
2169 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2170 DISubprogram SP(Node);
2171 StringRef LName = SP.getLinkageName();
2172 StringRef Name = SP.getName();
2174 Asm->OutStreamer.AddComment("MIPS linkage name");
2175 if (LName.empty()) {
2176 Asm->OutStreamer.EmitBytes(Name, 0);
2177 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2179 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2180 DwarfStrSectionSym);
2182 Asm->OutStreamer.AddComment("Function name");
2183 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2184 Asm->EmitULEB128(Labels.size(), "Inline count");
2186 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2187 LE = Labels.end(); LI != LE; ++LI) {
2188 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2189 Asm->EmitInt32(LI->second->getOffset());
2191 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2192 Asm->OutStreamer.EmitSymbolValue(LI->first,
2193 Asm->getTargetData().getPointerSize(),0);
2197 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));