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 MCSymbol *DwarfDebug::getDwarfStrSectionSym(void) {
169 if (DwarfStrSectionSym) return DwarfStrSectionSym;
171 EmitSectionSym(Asm, Asm->getObjFileLowering().getDwarfStrSection(),
173 return DwarfStrSectionSym;
176 /// assignAbbrevNumber - Define a unique number for the abbreviation.
178 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
179 // Profile the node so that we can make it unique.
183 // Check the set for priors.
184 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
186 // If it's newly added.
187 if (InSet == &Abbrev) {
188 // Add to abbreviation list.
189 Abbreviations.push_back(&Abbrev);
191 // Assign the vector position + 1 as its number.
192 Abbrev.setNumber(Abbreviations.size());
194 // Assign existing abbreviation number.
195 Abbrev.setNumber(InSet->getNumber());
199 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
200 /// printer to not emit usual symbol prefix before the symbol name is used then
201 /// return linkage name after skipping this special LLVM prefix.
202 static StringRef getRealLinkageName(StringRef LinkageName) {
204 if (LinkageName.startswith(StringRef(&One, 1)))
205 return LinkageName.substr(1);
209 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
210 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
211 /// If there are global variables in this scope then create and insert
212 /// DIEs for these variables.
213 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
214 const MDNode *SPNode) {
215 DIE *SPDie = SPCU->getDIE(SPNode);
217 assert(SPDie && "Unable to find subprogram DIE!");
218 DISubprogram SP(SPNode);
220 DISubprogram SPDecl = SP.getFunctionDeclaration();
221 if (!SPDecl.isSubprogram()) {
222 // There is not any need to generate specification DIE for a function
223 // defined at compile unit level. If a function is defined inside another
224 // function then gdb prefers the definition at top level and but does not
225 // expect specification DIE in parent function. So avoid creating
226 // specification DIE for a function defined inside a function.
227 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
228 !SP.getContext().isFile() &&
229 !isSubprogramContext(SP.getContext())) {
230 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
233 DICompositeType SPTy = SP.getType();
234 DIArray Args = SPTy.getTypeArray();
235 unsigned SPTag = SPTy.getTag();
236 if (SPTag == dwarf::DW_TAG_subroutine_type)
237 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
238 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
239 DIType ATy = DIType(DIType(Args.getElement(i)));
240 SPCU->addType(Arg, ATy);
241 if (ATy.isArtificial())
242 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
243 SPDie->addChild(Arg);
245 DIE *SPDeclDie = SPDie;
246 SPDie = new DIE(dwarf::DW_TAG_subprogram);
247 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
252 // Pick up abstract subprogram DIE.
253 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
254 SPDie = new DIE(dwarf::DW_TAG_subprogram);
255 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
256 dwarf::DW_FORM_ref4, AbsSPDIE);
260 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
261 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
262 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
263 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
264 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
265 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
266 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
271 /// constructLexicalScope - Construct new DW_TAG_lexical_block
272 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
273 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
274 LexicalScope *Scope) {
275 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
276 if (Scope->isAbstractScope())
279 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
283 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
284 if (Ranges.size() > 1) {
285 // .debug_range section has not been laid out yet. Emit offset in
286 // .debug_range as a uint, size 4, for now. emitDIE will handle
287 // DW_AT_ranges appropriately.
288 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
289 DebugRangeSymbols.size()
290 * Asm->getTargetData().getPointerSize());
291 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
292 RE = Ranges.end(); RI != RE; ++RI) {
293 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
294 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
296 DebugRangeSymbols.push_back(NULL);
297 DebugRangeSymbols.push_back(NULL);
301 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
302 const MCSymbol *End = getLabelAfterInsn(RI->second);
304 if (End == 0) return 0;
306 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
307 assert(End->isDefined() && "Invalid end label for an inlined scope!");
309 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
310 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
315 /// constructInlinedScopeDIE - This scope represents inlined body of
316 /// a function. Construct DIE to represent this concrete inlined copy
318 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
319 LexicalScope *Scope) {
320 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
321 assert(Ranges.empty() == false &&
322 "LexicalScope does not have instruction markers!");
324 if (!Scope->getScopeNode())
326 DIScope DS(Scope->getScopeNode());
327 DISubprogram InlinedSP = getDISubprogram(DS);
328 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
330 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
334 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
335 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
336 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
338 if (StartLabel == 0 || EndLabel == 0) {
339 assert(0 && "Unexpected Start and End labels for a inlined scope!");
342 assert(StartLabel->isDefined() &&
343 "Invalid starting label for an inlined scope!");
344 assert(EndLabel->isDefined() &&
345 "Invalid end label for an inlined scope!");
347 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
348 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
349 dwarf::DW_FORM_ref4, OriginDIE);
351 if (Ranges.size() > 1) {
352 // .debug_range section has not been laid out yet. Emit offset in
353 // .debug_range as a uint, size 4, for now. emitDIE will handle
354 // DW_AT_ranges appropriately.
355 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
356 DebugRangeSymbols.size()
357 * Asm->getTargetData().getPointerSize());
358 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
359 RE = Ranges.end(); RI != RE; ++RI) {
360 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
361 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
363 DebugRangeSymbols.push_back(NULL);
364 DebugRangeSymbols.push_back(NULL);
366 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
368 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
372 InlinedSubprogramDIEs.insert(OriginDIE);
374 // Track the start label for this inlined function.
375 //.debug_inlined section specification does not clearly state how
376 // to emit inlined scope that is split into multiple instruction ranges.
377 // For now, use first instruction range and emit low_pc/high_pc pair and
378 // corresponding .debug_inlined section entry for this pair.
379 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
380 I = InlineInfo.find(InlinedSP);
382 if (I == InlineInfo.end()) {
383 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
384 InlinedSPNodes.push_back(InlinedSP);
386 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
388 DILocation DL(Scope->getInlinedAt());
389 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
390 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
395 /// constructScopeDIE - Construct a DIE for this scope.
396 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
397 if (!Scope || !Scope->getScopeNode())
400 SmallVector<DIE *, 8> Children;
402 // Collect arguments for current function.
403 if (LScopes.isCurrentFunctionScope(Scope))
404 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
405 if (DbgVariable *ArgDV = CurrentFnArguments[i])
407 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
408 Children.push_back(Arg);
410 // Collect lexical scope children first.
411 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
412 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
414 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
415 Children.push_back(Variable);
416 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
417 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
418 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
419 Children.push_back(Nested);
420 DIScope DS(Scope->getScopeNode());
421 DIE *ScopeDIE = NULL;
422 if (Scope->getInlinedAt())
423 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
424 else if (DS.isSubprogram()) {
425 ProcessedSPNodes.insert(DS);
426 if (Scope->isAbstractScope()) {
427 ScopeDIE = TheCU->getDIE(DS);
428 // Note down abstract DIE.
430 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
433 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
436 // There is no need to emit empty lexical block DIE.
437 if (Children.empty())
439 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
442 if (!ScopeDIE) return NULL;
445 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
446 E = Children.end(); I != E; ++I)
447 ScopeDIE->addChild(*I);
449 if (DS.isSubprogram())
450 TheCU->addPubTypes(DISubprogram(DS));
452 if (DS.isSubprogram() && !Scope->isAbstractScope())
453 TheCU->addAccelName(DISubprogram(DS).getName(), ScopeDIE);
458 /// GetOrCreateSourceID - Look up the source id with the given directory and
459 /// source file names. If none currently exists, create a new id and insert it
460 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
462 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
464 // If FE did not provide a file name, then assume stdin.
465 if (FileName.empty())
466 return GetOrCreateSourceID("<stdin>", StringRef());
468 // TODO: this might not belong here. See if we can factor this better.
469 if (DirName == CompilationDir)
472 unsigned SrcId = SourceIdMap.size()+1;
473 std::pair<std::string, std::string> SourceName =
474 std::make_pair(FileName, DirName);
475 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
476 make_pair(SourceName, SrcId);
478 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
480 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
484 // Print out a .file directive to specify files for .loc directives.
485 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
491 /// constructCompileUnit - Create new CompileUnit for the given
492 /// metadata node with tag DW_TAG_compile_unit.
493 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
494 DICompileUnit DIUnit(N);
495 StringRef FN = DIUnit.getFilename();
496 CompilationDir = DIUnit.getDirectory();
497 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
499 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
500 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
501 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
502 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
503 DIUnit.getLanguage());
504 NewCU->addString(Die, dwarf::DW_AT_name, FN);
505 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
506 // simplifies debug range entries.
507 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
508 // DW_AT_stmt_list is a offset of line number information for this
509 // compile unit in debug_line section.
510 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
511 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
512 Asm->GetTempSymbol("section_line"));
514 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
516 if (!CompilationDir.empty())
517 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
518 if (DIUnit.isOptimized())
519 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
521 StringRef Flags = DIUnit.getFlags();
523 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
525 if (unsigned RVer = DIUnit.getRunTimeVersion())
526 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
527 dwarf::DW_FORM_data1, RVer);
531 CUMap.insert(std::make_pair(N, NewCU));
535 static bool isObjCClass(StringRef Name) {
536 return Name[0] == '+' || Name[0] == '-';
539 static bool hasObjCCategory(StringRef Name) {
540 if (Name[0] != '+' && Name[0] != '-')
543 size_t pos = Name.find(')');
544 if (pos != std::string::npos) {
545 if (Name[pos+1] != ' ') return false;
552 static void getObjCClassCategory(StringRef In, StringRef &Class,
553 StringRef &Category) {
554 if (!hasObjCCategory(In)) {
555 Class = In.slice(In.find('[') + 1, In.find(' '));
560 Class = In.slice(In.find('[') + 1, In.find('('));
561 Category = In.slice(In.find('[') + 1, In.find(' '));
565 /// construct SubprogramDIE - Construct subprogram DIE.
566 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
568 CompileUnit *&CURef = SPMap[N];
574 if (!SP.isDefinition())
575 // This is a method declaration which will be handled while constructing
579 DISubprogram SPDecl = SP.getFunctionDeclaration();
581 if (SPDecl.isSubprogram()) {
582 DeclDie = TheCU->getOrCreateSubprogramDIE(SPDecl);
585 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
588 // Refer function declaration directly.
589 TheCU->addDIEEntry(SubprogramDie, dwarf::DW_AT_specification,
590 dwarf::DW_FORM_ref4, DeclDie);
594 TheCU->insertDIE(N, SubprogramDie);
596 // Add to context owner.
597 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
600 TheCU->addGlobal(SP.getName(), SubprogramDie);
602 // Add to Accel Names
603 TheCU->addAccelName(SP.getName(), SubprogramDie);
605 // If this is an Objective-C selector name add it to the ObjC accelerator too.
606 if (isObjCClass(SP.getName())) {
607 StringRef Class, Category;
608 getObjCClassCategory(SP.getName(), Class, Category);
609 TheCU->addAccelObjC(Class, SubprogramDie);
611 TheCU->addAccelObjC(Category, SubprogramDie);
617 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
618 /// as llvm.dbg.enum and llvm.dbg.ty
619 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
620 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
621 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
622 const MDNode *N = NMD->getOperand(i);
623 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
624 constructSubprogramDIE(CU, N);
627 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
628 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
629 const MDNode *N = NMD->getOperand(i);
630 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
631 CU->createGlobalVariableDIE(N);
634 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
635 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
636 DIType Ty(NMD->getOperand(i));
637 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
638 CU->getOrCreateTypeDIE(Ty);
641 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
642 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
643 DIType Ty(NMD->getOperand(i));
644 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
645 CU->getOrCreateTypeDIE(Ty);
649 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
650 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
651 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
652 DebugInfoFinder DbgFinder;
653 DbgFinder.processModule(*M);
655 bool HasDebugInfo = false;
656 // Scan all the compile-units to see if there are any marked as the main
657 // unit. If not, we do not generate debug info.
658 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
659 E = DbgFinder.compile_unit_end(); I != E; ++I) {
660 if (DICompileUnit(*I).isMain()) {
665 if (!HasDebugInfo) return false;
667 // Create all the compile unit DIEs.
668 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
669 E = DbgFinder.compile_unit_end(); I != E; ++I)
670 constructCompileUnit(*I);
672 // Create DIEs for each global variable.
673 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
674 E = DbgFinder.global_variable_end(); I != E; ++I) {
675 const MDNode *N = *I;
676 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
677 CU->createGlobalVariableDIE(N);
680 // Create DIEs for each subprogram.
681 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
682 E = DbgFinder.subprogram_end(); I != E; ++I) {
683 const MDNode *N = *I;
684 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
685 constructSubprogramDIE(CU, N);
691 /// beginModule - Emit all Dwarf sections that should come prior to the
692 /// content. Create global DIEs and emit initial debug info sections.
693 /// This is invoked by the target AsmPrinter.
694 void DwarfDebug::beginModule(Module *M) {
695 if (DisableDebugInfoPrinting)
698 // If module has named metadata anchors then use them, otherwise scan the
699 // module using debug info finder to collect debug info.
700 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
702 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
703 DICompileUnit CUNode(CU_Nodes->getOperand(i));
704 CompileUnit *CU = constructCompileUnit(CUNode);
705 DIArray GVs = CUNode.getGlobalVariables();
706 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
707 CU->createGlobalVariableDIE(GVs.getElement(i));
708 DIArray SPs = CUNode.getSubprograms();
709 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
710 constructSubprogramDIE(CU, SPs.getElement(i));
711 DIArray EnumTypes = CUNode.getEnumTypes();
712 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
713 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
714 DIArray RetainedTypes = CUNode.getRetainedTypes();
715 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
716 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
718 } else if (!collectLegacyDebugInfo(M))
721 collectInfoFromNamedMDNodes(M);
723 // Tell MMI that we have debug info.
724 MMI->setDebugInfoAvailability(true);
726 // Emit initial sections.
729 // Prime section data.
730 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
733 /// endModule - Emit all Dwarf sections that should come after the content.
735 void DwarfDebug::endModule() {
736 if (!FirstCU) return;
737 const Module *M = MMI->getModule();
738 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
740 // Collect info for variables that were optimized out.
741 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
742 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
743 DICompileUnit TheCU(CU_Nodes->getOperand(i));
744 DIArray Subprograms = TheCU.getSubprograms();
745 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
746 DISubprogram SP(Subprograms.getElement(i));
747 if (ProcessedSPNodes.count(SP) != 0) continue;
748 if (!SP.Verify()) continue;
749 if (!SP.isDefinition()) continue;
750 DIArray Variables = SP.getVariables();
751 if (Variables.getNumElements() == 0) continue;
753 LexicalScope *Scope =
754 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
755 DeadFnScopeMap[SP] = Scope;
757 // Construct subprogram DIE and add variables DIEs.
758 CompileUnit *SPCU = CUMap.lookup(TheCU);
759 assert(SPCU && "Unable to find Compile Unit!");
760 constructSubprogramDIE(SPCU, SP);
761 DIE *ScopeDIE = SPCU->getDIE(SP);
762 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
763 DIVariable DV(Variables.getElement(vi));
764 if (!DV.Verify()) continue;
765 DbgVariable *NewVar = new DbgVariable(DV, NULL);
766 if (DIE *VariableDIE =
767 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
768 ScopeDIE->addChild(VariableDIE);
774 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
775 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
776 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
778 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
781 // Emit DW_AT_containing_type attribute to connect types with their
782 // vtable holding type.
783 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
784 CUE = CUMap.end(); CUI != CUE; ++CUI) {
785 CompileUnit *TheCU = CUI->second;
786 TheCU->constructContainingTypeDIEs();
789 // Standard sections final addresses.
790 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
791 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
792 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
793 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
795 // End text sections.
796 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
797 Asm->OutStreamer.SwitchSection(SectionMap[i]);
798 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
801 // Compute DIE offsets and sizes.
802 computeSizeAndOffsets();
804 // Emit all the DIEs into a debug info section
807 // Corresponding abbreviations into a abbrev section.
810 // Emit info into a dwarf accelerator table sections.
811 if (DwarfAccelTables) {
814 emitAccelNamespaces();
818 // Emit info into a debug pubnames section.
821 // Emit info into a debug pubtypes section.
824 // Emit info into a debug loc section.
827 // Emit info into a debug aranges section.
830 // Emit info into a debug ranges section.
833 // Emit info into a debug macinfo section.
837 emitDebugInlineInfo();
839 // Emit info into a debug str section.
843 DeleteContainerSeconds(DeadFnScopeMap);
845 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
846 E = CUMap.end(); I != E; ++I)
848 FirstCU = NULL; // Reset for the next Module, if any.
851 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
852 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
854 LLVMContext &Ctx = DV->getContext();
855 // More then one inlined variable corresponds to one abstract variable.
856 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
857 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
859 return AbsDbgVariable;
861 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
865 AbsDbgVariable = new DbgVariable(Var, NULL);
866 addScopeVariable(Scope, AbsDbgVariable);
867 AbstractVariables[Var] = AbsDbgVariable;
868 return AbsDbgVariable;
871 /// addCurrentFnArgument - If Var is a current function argument then add
872 /// it to CurrentFnArguments list.
873 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
874 DbgVariable *Var, LexicalScope *Scope) {
875 if (!LScopes.isCurrentFunctionScope(Scope))
877 DIVariable DV = Var->getVariable();
878 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
880 unsigned ArgNo = DV.getArgNumber();
884 size_t Size = CurrentFnArguments.size();
886 CurrentFnArguments.resize(MF->getFunction()->arg_size());
887 // llvm::Function argument size is not good indicator of how many
888 // arguments does the function have at source level.
890 CurrentFnArguments.resize(ArgNo * 2);
891 CurrentFnArguments[ArgNo - 1] = Var;
895 /// collectVariableInfoFromMMITable - Collect variable information from
896 /// side table maintained by MMI.
898 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
899 SmallPtrSet<const MDNode *, 16> &Processed) {
900 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
901 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
902 VE = VMap.end(); VI != VE; ++VI) {
903 const MDNode *Var = VI->first;
905 Processed.insert(Var);
907 const std::pair<unsigned, DebugLoc> &VP = VI->second;
909 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
911 // If variable scope is not found then skip this variable.
915 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
916 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
917 RegVar->setFrameIndex(VP.first);
918 if (!addCurrentFnArgument(MF, RegVar, Scope))
919 addScopeVariable(Scope, RegVar);
921 AbsDbgVariable->setFrameIndex(VP.first);
925 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
926 /// DBG_VALUE instruction, is in a defined reg.
927 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
928 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
929 return MI->getNumOperands() == 3 &&
930 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
931 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
934 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
936 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
937 const MCSymbol *FLabel,
938 const MCSymbol *SLabel,
939 const MachineInstr *MI) {
940 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
942 if (MI->getNumOperands() != 3) {
943 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
944 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
946 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
947 MachineLocation MLoc;
948 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
949 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
951 if (MI->getOperand(0).isImm())
952 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
953 if (MI->getOperand(0).isFPImm())
954 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
955 if (MI->getOperand(0).isCImm())
956 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
958 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
959 return DotDebugLocEntry();
962 /// collectVariableInfo - Find variables for each lexical scope.
964 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
965 SmallPtrSet<const MDNode *, 16> &Processed) {
967 /// collection info from MMI table.
968 collectVariableInfoFromMMITable(MF, Processed);
970 for (SmallVectorImpl<const MDNode*>::const_iterator
971 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
973 const MDNode *Var = *UVI;
974 if (Processed.count(Var))
977 // History contains relevant DBG_VALUE instructions for Var and instructions
979 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
982 const MachineInstr *MInsn = History.front();
985 LexicalScope *Scope = NULL;
986 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
987 DISubprogram(DV.getContext()).describes(MF->getFunction()))
988 Scope = LScopes.getCurrentFunctionScope();
990 if (DV.getVersion() <= LLVMDebugVersion9)
991 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
993 if (MDNode *IA = DV.getInlinedAt())
994 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
996 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
999 // If variable scope is not found then skip this variable.
1003 Processed.insert(DV);
1004 assert(MInsn->isDebugValue() && "History must begin with debug value");
1005 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1006 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1007 if (!addCurrentFnArgument(MF, RegVar, Scope))
1008 addScopeVariable(Scope, RegVar);
1010 AbsVar->setMInsn(MInsn);
1012 // Simple ranges that are fully coalesced.
1013 if (History.size() <= 1 || (History.size() == 2 &&
1014 MInsn->isIdenticalTo(History.back()))) {
1015 RegVar->setMInsn(MInsn);
1019 // handle multiple DBG_VALUE instructions describing one variable.
1020 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1022 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1023 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1024 const MachineInstr *Begin = *HI;
1025 assert(Begin->isDebugValue() && "Invalid History entry");
1027 // Check if DBG_VALUE is truncating a range.
1028 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1029 && !Begin->getOperand(0).getReg())
1032 // Compute the range for a register location.
1033 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1034 const MCSymbol *SLabel = 0;
1037 // If Begin is the last instruction in History then its value is valid
1038 // until the end of the function.
1039 SLabel = FunctionEndSym;
1041 const MachineInstr *End = HI[1];
1042 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1043 << "\t" << *Begin << "\t" << *End << "\n");
1044 if (End->isDebugValue())
1045 SLabel = getLabelBeforeInsn(End);
1047 // End is a normal instruction clobbering the range.
1048 SLabel = getLabelAfterInsn(End);
1049 assert(SLabel && "Forgot label after clobber instruction");
1054 // The value is valid until the next DBG_VALUE or clobber.
1055 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1057 DotDebugLocEntries.push_back(DotDebugLocEntry());
1060 // Collect info for variables that were optimized out.
1061 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1062 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1063 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1064 DIVariable DV(Variables.getElement(i));
1065 if (!DV || !DV.Verify() || !Processed.insert(DV))
1067 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1068 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1072 /// getLabelBeforeInsn - Return Label preceding the instruction.
1073 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1074 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1075 assert(Label && "Didn't insert label before instruction");
1079 /// getLabelAfterInsn - Return Label immediately following the instruction.
1080 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1081 return LabelsAfterInsn.lookup(MI);
1084 /// beginInstruction - Process beginning of an instruction.
1085 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1086 // Check if source location changes, but ignore DBG_VALUE locations.
1087 if (!MI->isDebugValue()) {
1088 DebugLoc DL = MI->getDebugLoc();
1089 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1090 unsigned Flags = DWARF2_FLAG_IS_STMT;
1092 if (DL == PrologEndLoc) {
1093 Flags |= DWARF2_FLAG_PROLOGUE_END;
1094 PrologEndLoc = DebugLoc();
1096 if (!DL.isUnknown()) {
1097 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1098 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1100 recordSourceLine(0, 0, 0, 0);
1104 // Insert labels where requested.
1105 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1106 LabelsBeforeInsn.find(MI);
1109 if (I == LabelsBeforeInsn.end())
1112 // Label already assigned.
1117 PrevLabel = MMI->getContext().CreateTempSymbol();
1118 Asm->OutStreamer.EmitLabel(PrevLabel);
1120 I->second = PrevLabel;
1123 /// endInstruction - Process end of an instruction.
1124 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1125 // Don't create a new label after DBG_VALUE instructions.
1126 // They don't generate code.
1127 if (!MI->isDebugValue())
1130 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1131 LabelsAfterInsn.find(MI);
1134 if (I == LabelsAfterInsn.end())
1137 // Label already assigned.
1141 // We need a label after this instruction.
1143 PrevLabel = MMI->getContext().CreateTempSymbol();
1144 Asm->OutStreamer.EmitLabel(PrevLabel);
1146 I->second = PrevLabel;
1149 /// identifyScopeMarkers() -
1150 /// Each LexicalScope has first instruction and last instruction to mark
1151 /// beginning and end of a scope respectively. Create an inverse map that list
1152 /// scopes starts (and ends) with an instruction. One instruction may start (or
1153 /// end) multiple scopes. Ignore scopes that are not reachable.
1154 void DwarfDebug::identifyScopeMarkers() {
1155 SmallVector<LexicalScope *, 4> WorkList;
1156 WorkList.push_back(LScopes.getCurrentFunctionScope());
1157 while (!WorkList.empty()) {
1158 LexicalScope *S = WorkList.pop_back_val();
1160 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1161 if (!Children.empty())
1162 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1163 SE = Children.end(); SI != SE; ++SI)
1164 WorkList.push_back(*SI);
1166 if (S->isAbstractScope())
1169 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1172 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1173 RE = Ranges.end(); RI != RE; ++RI) {
1174 assert(RI->first && "InsnRange does not have first instruction!");
1175 assert(RI->second && "InsnRange does not have second instruction!");
1176 requestLabelBeforeInsn(RI->first);
1177 requestLabelAfterInsn(RI->second);
1182 /// getScopeNode - Get MDNode for DebugLoc's scope.
1183 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1184 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1185 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1186 return DL.getScope(Ctx);
1189 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1190 /// line number info for the function.
1191 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1192 const MDNode *Scope = getScopeNode(DL, Ctx);
1193 DISubprogram SP = getDISubprogram(Scope);
1195 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1199 /// beginFunction - Gather pre-function debug information. Assumes being
1200 /// emitted immediately after the function entry point.
1201 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1202 if (!MMI->hasDebugInfo()) return;
1203 LScopes.initialize(*MF);
1204 if (LScopes.empty()) return;
1205 identifyScopeMarkers();
1207 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1208 Asm->getFunctionNumber());
1209 // Assumes in correct section after the entry point.
1210 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1212 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1214 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1215 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1216 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1218 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1220 bool AtBlockEntry = true;
1221 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1223 const MachineInstr *MI = II;
1225 if (MI->isDebugValue()) {
1226 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1228 // Keep track of user variables.
1230 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1232 // Variable is in a register, we need to check for clobbers.
1233 if (isDbgValueInDefinedReg(MI))
1234 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1236 // Check the history of this variable.
1237 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1238 if (History.empty()) {
1239 UserVariables.push_back(Var);
1240 // The first mention of a function argument gets the FunctionBeginSym
1241 // label, so arguments are visible when breaking at function entry.
1243 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1244 DISubprogram(getDISubprogram(DV.getContext()))
1245 .describes(MF->getFunction()))
1246 LabelsBeforeInsn[MI] = FunctionBeginSym;
1248 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1249 const MachineInstr *Prev = History.back();
1250 if (Prev->isDebugValue()) {
1251 // Coalesce identical entries at the end of History.
1252 if (History.size() >= 2 &&
1253 Prev->isIdenticalTo(History[History.size() - 2])) {
1254 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1256 << "\t" << *History[History.size() - 2] << "\n");
1260 // Terminate old register assignments that don't reach MI;
1261 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1262 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1263 isDbgValueInDefinedReg(Prev)) {
1264 // Previous register assignment needs to terminate at the end of
1266 MachineBasicBlock::const_iterator LastMI =
1267 PrevMBB->getLastNonDebugInstr();
1268 if (LastMI == PrevMBB->end()) {
1269 // Drop DBG_VALUE for empty range.
1270 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1271 << "\t" << *Prev << "\n");
1275 // Terminate after LastMI.
1276 History.push_back(LastMI);
1281 History.push_back(MI);
1283 // Not a DBG_VALUE instruction.
1285 AtBlockEntry = false;
1287 // First known non DBG_VALUE location marks beginning of function
1289 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1290 PrologEndLoc = MI->getDebugLoc();
1292 // Check if the instruction clobbers any registers with debug vars.
1293 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1294 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1295 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1297 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1298 unsigned Reg = *AI; ++AI) {
1299 const MDNode *Var = LiveUserVar[Reg];
1302 // Reg is now clobbered.
1303 LiveUserVar[Reg] = 0;
1305 // Was MD last defined by a DBG_VALUE referring to Reg?
1306 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1307 if (HistI == DbgValues.end())
1309 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1310 if (History.empty())
1312 const MachineInstr *Prev = History.back();
1313 // Sanity-check: Register assignments are terminated at the end of
1315 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1317 // Is the variable still in Reg?
1318 if (!isDbgValueInDefinedReg(Prev) ||
1319 Prev->getOperand(0).getReg() != Reg)
1321 // Var is clobbered. Make sure the next instruction gets a label.
1322 History.push_back(MI);
1329 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1331 SmallVectorImpl<const MachineInstr*> &History = I->second;
1332 if (History.empty())
1335 // Make sure the final register assignments are terminated.
1336 const MachineInstr *Prev = History.back();
1337 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1338 const MachineBasicBlock *PrevMBB = Prev->getParent();
1339 MachineBasicBlock::const_iterator LastMI =
1340 PrevMBB->getLastNonDebugInstr();
1341 if (LastMI == PrevMBB->end())
1342 // Drop DBG_VALUE for empty range.
1345 // Terminate after LastMI.
1346 History.push_back(LastMI);
1349 // Request labels for the full history.
1350 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1351 const MachineInstr *MI = History[i];
1352 if (MI->isDebugValue())
1353 requestLabelBeforeInsn(MI);
1355 requestLabelAfterInsn(MI);
1359 PrevInstLoc = DebugLoc();
1360 PrevLabel = FunctionBeginSym;
1362 // Record beginning of function.
1363 if (!PrologEndLoc.isUnknown()) {
1364 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1365 MF->getFunction()->getContext());
1366 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1367 FnStartDL.getScope(MF->getFunction()->getContext()),
1368 DWARF2_FLAG_IS_STMT);
1372 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1373 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1374 ScopeVariables[LS].push_back(Var);
1375 // Vars.push_back(Var);
1378 /// endFunction - Gather and emit post-function debug information.
1380 void DwarfDebug::endFunction(const MachineFunction *MF) {
1381 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1383 // Define end label for subprogram.
1384 FunctionEndSym = Asm->GetTempSymbol("func_end",
1385 Asm->getFunctionNumber());
1386 // Assumes in correct section after the entry point.
1387 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1389 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1390 collectVariableInfo(MF, ProcessedVars);
1392 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1393 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1394 assert(TheCU && "Unable to find compile unit!");
1396 // Construct abstract scopes.
1397 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1398 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1399 LexicalScope *AScope = AList[i];
1400 DISubprogram SP(AScope->getScopeNode());
1402 // Collect info for variables that were optimized out.
1403 DIArray Variables = SP.getVariables();
1404 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1405 DIVariable DV(Variables.getElement(i));
1406 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1408 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1409 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1412 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1413 constructScopeDIE(TheCU, AScope);
1416 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1418 if (!DisableFramePointerElim(*MF))
1419 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1420 dwarf::DW_FORM_flag, 1);
1422 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1423 MMI->getFrameMoves()));
1426 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1427 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1428 DeleteContainerPointers(I->second);
1429 ScopeVariables.clear();
1430 DeleteContainerPointers(CurrentFnArguments);
1431 UserVariables.clear();
1433 AbstractVariables.clear();
1434 LabelsBeforeInsn.clear();
1435 LabelsAfterInsn.clear();
1439 /// recordSourceLine - Register a source line with debug info. Returns the
1440 /// unique label that was emitted and which provides correspondence to
1441 /// the source line list.
1442 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1448 DIDescriptor Scope(S);
1450 if (Scope.isCompileUnit()) {
1451 DICompileUnit CU(S);
1452 Fn = CU.getFilename();
1453 Dir = CU.getDirectory();
1454 } else if (Scope.isFile()) {
1456 Fn = F.getFilename();
1457 Dir = F.getDirectory();
1458 } else if (Scope.isSubprogram()) {
1460 Fn = SP.getFilename();
1461 Dir = SP.getDirectory();
1462 } else if (Scope.isLexicalBlockFile()) {
1463 DILexicalBlockFile DBF(S);
1464 Fn = DBF.getFilename();
1465 Dir = DBF.getDirectory();
1466 } else if (Scope.isLexicalBlock()) {
1467 DILexicalBlock DB(S);
1468 Fn = DB.getFilename();
1469 Dir = DB.getDirectory();
1471 assert(0 && "Unexpected scope info");
1473 Src = GetOrCreateSourceID(Fn, Dir);
1475 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1478 //===----------------------------------------------------------------------===//
1480 //===----------------------------------------------------------------------===//
1482 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1485 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1486 // Get the children.
1487 const std::vector<DIE *> &Children = Die->getChildren();
1489 // If not last sibling and has children then add sibling offset attribute.
1490 if (!Last && !Children.empty())
1491 Die->addSiblingOffset(DIEValueAllocator);
1493 // Record the abbreviation.
1494 assignAbbrevNumber(Die->getAbbrev());
1496 // Get the abbreviation for this DIE.
1497 unsigned AbbrevNumber = Die->getAbbrevNumber();
1498 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1501 Die->setOffset(Offset);
1503 // Start the size with the size of abbreviation code.
1504 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1506 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1507 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1509 // Size the DIE attribute values.
1510 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1511 // Size attribute value.
1512 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1514 // Size the DIE children if any.
1515 if (!Children.empty()) {
1516 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1517 "Children flag not set");
1519 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1520 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1522 // End of children marker.
1523 Offset += sizeof(int8_t);
1526 Die->setSize(Offset - Die->getOffset());
1530 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1532 void DwarfDebug::computeSizeAndOffsets() {
1533 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1534 E = CUMap.end(); I != E; ++I) {
1535 // Compute size of compile unit header.
1537 sizeof(int32_t) + // Length of Compilation Unit Info
1538 sizeof(int16_t) + // DWARF version number
1539 sizeof(int32_t) + // Offset Into Abbrev. Section
1540 sizeof(int8_t); // Pointer Size (in bytes)
1541 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1545 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1546 /// the start of each one.
1547 void DwarfDebug::EmitSectionLabels() {
1548 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1550 // Dwarf sections base addresses.
1551 DwarfInfoSectionSym =
1552 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1553 DwarfAbbrevSectionSym =
1554 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1555 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1557 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1558 EmitSectionSym(Asm, MacroInfo);
1560 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1561 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1562 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1563 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1564 DwarfStrSectionSym =
1565 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1566 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1569 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1570 "section_debug_loc");
1572 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1573 EmitSectionSym(Asm, TLOF.getDataSection());
1576 /// emitDIE - Recursively emits a debug information entry.
1578 void DwarfDebug::emitDIE(DIE *Die) {
1579 // Get the abbreviation for this DIE.
1580 unsigned AbbrevNumber = Die->getAbbrevNumber();
1581 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1583 // Emit the code (index) for the abbreviation.
1584 if (Asm->isVerbose())
1585 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1586 Twine::utohexstr(Die->getOffset()) + ":0x" +
1587 Twine::utohexstr(Die->getSize()) + " " +
1588 dwarf::TagString(Abbrev->getTag()));
1589 Asm->EmitULEB128(AbbrevNumber);
1591 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1592 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1594 // Emit the DIE attribute values.
1595 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1596 unsigned Attr = AbbrevData[i].getAttribute();
1597 unsigned Form = AbbrevData[i].getForm();
1598 assert(Form && "Too many attributes for DIE (check abbreviation)");
1600 if (Asm->isVerbose())
1601 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1604 case dwarf::DW_AT_sibling:
1605 Asm->EmitInt32(Die->getSiblingOffset());
1607 case dwarf::DW_AT_abstract_origin: {
1608 DIEEntry *E = cast<DIEEntry>(Values[i]);
1609 DIE *Origin = E->getEntry();
1610 unsigned Addr = Origin->getOffset();
1611 Asm->EmitInt32(Addr);
1614 case dwarf::DW_AT_ranges: {
1615 // DW_AT_range Value encodes offset in debug_range section.
1616 DIEInteger *V = cast<DIEInteger>(Values[i]);
1618 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1619 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1623 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1625 DwarfDebugRangeSectionSym,
1630 case dwarf::DW_AT_location: {
1631 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1632 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1634 Values[i]->EmitValue(Asm, Form);
1637 case dwarf::DW_AT_accessibility: {
1638 if (Asm->isVerbose()) {
1639 DIEInteger *V = cast<DIEInteger>(Values[i]);
1640 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1642 Values[i]->EmitValue(Asm, Form);
1646 // Emit an attribute using the defined form.
1647 Values[i]->EmitValue(Asm, Form);
1652 // Emit the DIE children if any.
1653 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1654 const std::vector<DIE *> &Children = Die->getChildren();
1656 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1657 emitDIE(Children[j]);
1659 if (Asm->isVerbose())
1660 Asm->OutStreamer.AddComment("End Of Children Mark");
1665 /// emitDebugInfo - Emit the debug info section.
1667 void DwarfDebug::emitDebugInfo() {
1668 // Start debug info section.
1669 Asm->OutStreamer.SwitchSection(
1670 Asm->getObjFileLowering().getDwarfInfoSection());
1671 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1672 E = CUMap.end(); I != E; ++I) {
1673 CompileUnit *TheCU = I->second;
1674 DIE *Die = TheCU->getCUDie();
1676 // Emit the compile units header.
1677 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1680 // Emit size of content not including length itself
1681 unsigned ContentSize = Die->getSize() +
1682 sizeof(int16_t) + // DWARF version number
1683 sizeof(int32_t) + // Offset Into Abbrev. Section
1684 sizeof(int8_t); // Pointer Size (in bytes)
1686 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1687 Asm->EmitInt32(ContentSize);
1688 Asm->OutStreamer.AddComment("DWARF version number");
1689 Asm->EmitInt16(dwarf::DWARF_VERSION);
1690 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1691 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1692 DwarfAbbrevSectionSym);
1693 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1694 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1697 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1701 /// emitAbbreviations - Emit the abbreviation section.
1703 void DwarfDebug::emitAbbreviations() const {
1704 // Check to see if it is worth the effort.
1705 if (!Abbreviations.empty()) {
1706 // Start the debug abbrev section.
1707 Asm->OutStreamer.SwitchSection(
1708 Asm->getObjFileLowering().getDwarfAbbrevSection());
1710 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1712 // For each abbrevation.
1713 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1714 // Get abbreviation data
1715 const DIEAbbrev *Abbrev = Abbreviations[i];
1717 // Emit the abbrevations code (base 1 index.)
1718 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1720 // Emit the abbreviations data.
1724 // Mark end of abbreviations.
1725 Asm->EmitULEB128(0, "EOM(3)");
1727 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1731 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1732 /// the line matrix.
1734 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1735 // Define last address of section.
1736 Asm->OutStreamer.AddComment("Extended Op");
1739 Asm->OutStreamer.AddComment("Op size");
1740 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1741 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1742 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1744 Asm->OutStreamer.AddComment("Section end label");
1746 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1747 Asm->getTargetData().getPointerSize(),
1750 // Mark end of matrix.
1751 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1757 /// emitAccelNames - Emit visible names into a hashed accelerator table
1759 void DwarfDebug::emitAccelNames() {
1760 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1761 dwarf::DW_FORM_data4));
1762 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1763 E = CUMap.end(); I != E; ++I) {
1764 CompileUnit *TheCU = I->second;
1765 const StringMap<DIE*> &Names = TheCU->getAccelNames();
1766 for (StringMap<DIE*>::const_iterator
1767 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1768 const char *Name = GI->getKeyData();
1769 DIE *Entity = GI->second;
1770 AT.AddName(Name, Entity);
1774 AT.FinalizeTable(Asm, "Names");
1775 Asm->OutStreamer.SwitchSection(
1776 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1777 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1778 Asm->OutStreamer.EmitLabel(SectionBegin);
1780 // Emit the full data.
1781 AT.Emit(Asm, SectionBegin, this);
1784 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1785 /// accelerator table section.
1786 void DwarfDebug::emitAccelObjC() {
1787 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1788 dwarf::DW_FORM_data4));
1789 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1790 E = CUMap.end(); I != E; ++I) {
1791 CompileUnit *TheCU = I->second;
1792 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1793 for (StringMap<std::vector<DIE*> >::const_iterator
1794 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1795 const char *Name = GI->getKeyData();
1796 std::vector<DIE *> Entities = GI->second;
1797 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1798 DE = Entities.end(); DI != DE; ++DI)
1799 AT.AddName(Name, (*DI));
1803 AT.FinalizeTable(Asm, "ObjC");
1804 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1805 .getDwarfAccelObjCSection());
1806 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1807 Asm->OutStreamer.EmitLabel(SectionBegin);
1809 // Emit the full data.
1810 AT.Emit(Asm, SectionBegin, this);
1813 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1815 void DwarfDebug::emitAccelNamespaces() {
1816 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1817 dwarf::DW_FORM_data4));
1818 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1819 E = CUMap.end(); I != E; ++I) {
1820 CompileUnit *TheCU = I->second;
1821 const StringMap<DIE*> &Names = TheCU->getAccelNamespace();
1822 for (StringMap<DIE*>::const_iterator
1823 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1824 const char *Name = GI->getKeyData();
1825 DIE *Entity = GI->second;
1826 AT.AddName(Name, Entity);
1830 AT.FinalizeTable(Asm, "namespac");
1831 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1832 .getDwarfAccelNamespaceSection());
1833 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1834 Asm->OutStreamer.EmitLabel(SectionBegin);
1836 // Emit the full data.
1837 AT.Emit(Asm, SectionBegin, this);
1840 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1841 void DwarfDebug::emitAccelTypes() {
1842 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1843 dwarf::DW_FORM_data4));
1844 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1845 E = CUMap.end(); I != E; ++I) {
1846 CompileUnit *TheCU = I->second;
1847 const StringMap<DIE*> &Names = TheCU->getGlobalTypes();
1848 //TODO: TheCU->getAccelTypes();
1849 for (StringMap<DIE*>::const_iterator
1850 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1851 const char *Name = GI->getKeyData();
1852 DIE *Entity = GI->second;
1853 AT.AddName(Name, Entity);
1857 AT.FinalizeTable(Asm, "types");
1858 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1859 .getDwarfAccelTypesSection());
1860 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1861 Asm->OutStreamer.EmitLabel(SectionBegin);
1863 // Emit the full data.
1864 AT.Emit(Asm, SectionBegin, this);
1867 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1869 void DwarfDebug::emitDebugPubNames() {
1870 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1871 E = CUMap.end(); I != E; ++I) {
1872 CompileUnit *TheCU = I->second;
1873 // Start the dwarf pubnames section.
1874 Asm->OutStreamer.SwitchSection(
1875 Asm->getObjFileLowering().getDwarfPubNamesSection());
1877 Asm->OutStreamer.AddComment("Length of Public Names Info");
1878 Asm->EmitLabelDifference(
1879 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
1880 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
1882 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
1885 Asm->OutStreamer.AddComment("DWARF Version");
1886 Asm->EmitInt16(dwarf::DWARF_VERSION);
1888 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1889 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1890 DwarfInfoSectionSym);
1892 Asm->OutStreamer.AddComment("Compilation Unit Length");
1893 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1894 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1897 const StringMap<DIE*> &Globals = TheCU->getGlobals();
1898 for (StringMap<DIE*>::const_iterator
1899 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1900 const char *Name = GI->getKeyData();
1901 DIE *Entity = GI->second;
1903 Asm->OutStreamer.AddComment("DIE offset");
1904 Asm->EmitInt32(Entity->getOffset());
1906 if (Asm->isVerbose())
1907 Asm->OutStreamer.AddComment("External Name");
1908 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
1911 Asm->OutStreamer.AddComment("End Mark");
1913 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
1918 void DwarfDebug::emitDebugPubTypes() {
1919 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1920 E = CUMap.end(); I != E; ++I) {
1921 CompileUnit *TheCU = I->second;
1922 // Start the dwarf pubtypes section.
1923 Asm->OutStreamer.SwitchSection(
1924 Asm->getObjFileLowering().getDwarfPubTypesSection());
1925 Asm->OutStreamer.AddComment("Length of Public Types Info");
1926 Asm->EmitLabelDifference(
1927 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1928 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1930 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1933 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1934 Asm->EmitInt16(dwarf::DWARF_VERSION);
1936 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1937 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1938 DwarfInfoSectionSym);
1940 Asm->OutStreamer.AddComment("Compilation Unit Length");
1941 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1942 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1945 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1946 for (StringMap<DIE*>::const_iterator
1947 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1948 const char *Name = GI->getKeyData();
1949 DIE *Entity = GI->second;
1951 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1952 Asm->EmitInt32(Entity->getOffset());
1954 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1955 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1958 Asm->OutStreamer.AddComment("End Mark");
1960 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1965 /// emitDebugStr - Emit visible names into a debug str section.
1967 void DwarfDebug::emitDebugStr() {
1968 // Check to see if it is worth the effort.
1969 if (StringPool.empty()) return;
1971 // Start the dwarf str section.
1972 Asm->OutStreamer.SwitchSection(
1973 Asm->getObjFileLowering().getDwarfStrSection());
1975 // Get all of the string pool entries and put them in an array by their ID so
1976 // we can sort them.
1977 SmallVector<std::pair<unsigned,
1978 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1980 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1981 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1982 Entries.push_back(std::make_pair(I->second.second, &*I));
1984 array_pod_sort(Entries.begin(), Entries.end());
1986 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1987 // Emit a label for reference from debug information entries.
1988 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1990 // Emit the string itself.
1991 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
1992 Asm->OutStreamer.EmitZeros(1, 0);
1996 /// emitDebugLoc - Emit visible names into a debug loc section.
1998 void DwarfDebug::emitDebugLoc() {
1999 if (DotDebugLocEntries.empty())
2002 for (SmallVector<DotDebugLocEntry, 4>::iterator
2003 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2005 DotDebugLocEntry &Entry = *I;
2006 if (I + 1 != DotDebugLocEntries.end())
2010 // Start the dwarf loc section.
2011 Asm->OutStreamer.SwitchSection(
2012 Asm->getObjFileLowering().getDwarfLocSection());
2013 unsigned char Size = Asm->getTargetData().getPointerSize();
2014 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2016 for (SmallVector<DotDebugLocEntry, 4>::iterator
2017 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2018 I != E; ++I, ++index) {
2019 DotDebugLocEntry &Entry = *I;
2020 if (Entry.isMerged()) continue;
2021 if (Entry.isEmpty()) {
2022 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2023 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2024 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2026 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2027 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2028 DIVariable DV(Entry.Variable);
2029 Asm->OutStreamer.AddComment("Loc expr size");
2030 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2031 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2032 Asm->EmitLabelDifference(end, begin, 2);
2033 Asm->OutStreamer.EmitLabel(begin);
2034 if (Entry.isInt()) {
2035 DIBasicType BTy(DV.getType());
2037 (BTy.getEncoding() == dwarf::DW_ATE_signed
2038 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2039 Asm->OutStreamer.AddComment("DW_OP_consts");
2040 Asm->EmitInt8(dwarf::DW_OP_consts);
2041 Asm->EmitSLEB128(Entry.getInt());
2043 Asm->OutStreamer.AddComment("DW_OP_constu");
2044 Asm->EmitInt8(dwarf::DW_OP_constu);
2045 Asm->EmitULEB128(Entry.getInt());
2047 } else if (Entry.isLocation()) {
2048 if (!DV.hasComplexAddress())
2050 Asm->EmitDwarfRegOp(Entry.Loc);
2052 // Complex address entry.
2053 unsigned N = DV.getNumAddrElements();
2055 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2056 if (Entry.Loc.getOffset()) {
2058 Asm->EmitDwarfRegOp(Entry.Loc);
2059 Asm->OutStreamer.AddComment("DW_OP_deref");
2060 Asm->EmitInt8(dwarf::DW_OP_deref);
2061 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2062 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2063 Asm->EmitSLEB128(DV.getAddrElement(1));
2065 // If first address element is OpPlus then emit
2066 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2067 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2068 Asm->EmitDwarfRegOp(Loc);
2072 Asm->EmitDwarfRegOp(Entry.Loc);
2075 // Emit remaining complex address elements.
2076 for (; i < N; ++i) {
2077 uint64_t Element = DV.getAddrElement(i);
2078 if (Element == DIBuilder::OpPlus) {
2079 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2080 Asm->EmitULEB128(DV.getAddrElement(++i));
2081 } else if (Element == DIBuilder::OpDeref)
2082 Asm->EmitInt8(dwarf::DW_OP_deref);
2083 else llvm_unreachable("unknown Opcode found in complex address");
2087 // else ... ignore constant fp. There is not any good way to
2088 // to represent them here in dwarf.
2089 Asm->OutStreamer.EmitLabel(end);
2094 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2096 void DwarfDebug::EmitDebugARanges() {
2097 // Start the dwarf aranges section.
2098 Asm->OutStreamer.SwitchSection(
2099 Asm->getObjFileLowering().getDwarfARangesSection());
2102 /// emitDebugRanges - Emit visible names into a debug ranges section.
2104 void DwarfDebug::emitDebugRanges() {
2105 // Start the dwarf ranges section.
2106 Asm->OutStreamer.SwitchSection(
2107 Asm->getObjFileLowering().getDwarfRangesSection());
2108 unsigned char Size = Asm->getTargetData().getPointerSize();
2109 for (SmallVector<const MCSymbol *, 8>::iterator
2110 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2113 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2115 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2119 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2121 void DwarfDebug::emitDebugMacInfo() {
2122 if (const MCSection *LineInfo =
2123 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2124 // Start the dwarf macinfo section.
2125 Asm->OutStreamer.SwitchSection(LineInfo);
2129 /// emitDebugInlineInfo - Emit inline info using following format.
2131 /// 1. length of section
2132 /// 2. Dwarf version number
2133 /// 3. address size.
2135 /// Entries (one "entry" for each function that was inlined):
2137 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2138 /// otherwise offset into __debug_str for regular function name.
2139 /// 2. offset into __debug_str section for regular function name.
2140 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2141 /// instances for the function.
2143 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2144 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2145 /// __debug_info section, and the low_pc is the starting address for the
2146 /// inlining instance.
2147 void DwarfDebug::emitDebugInlineInfo() {
2148 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2154 Asm->OutStreamer.SwitchSection(
2155 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2157 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2158 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2159 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2161 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2163 Asm->OutStreamer.AddComment("Dwarf Version");
2164 Asm->EmitInt16(dwarf::DWARF_VERSION);
2165 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2166 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2168 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2169 E = InlinedSPNodes.end(); I != E; ++I) {
2171 const MDNode *Node = *I;
2172 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2173 = InlineInfo.find(Node);
2174 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2175 DISubprogram SP(Node);
2176 StringRef LName = SP.getLinkageName();
2177 StringRef Name = SP.getName();
2179 Asm->OutStreamer.AddComment("MIPS linkage name");
2180 if (LName.empty()) {
2181 Asm->OutStreamer.EmitBytes(Name, 0);
2182 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2184 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2185 DwarfStrSectionSym);
2187 Asm->OutStreamer.AddComment("Function name");
2188 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2189 Asm->EmitULEB128(Labels.size(), "Inline count");
2191 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2192 LE = Labels.end(); LI != LE; ++LI) {
2193 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2194 Asm->EmitInt32(LI->second->getOffset());
2196 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2197 Asm->OutStreamer.EmitSymbolValue(LI->first,
2198 Asm->getTargetData().getPointerSize(),0);
2202 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));