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 DISubprogram SP = DISubprogram(DS);
446 TheCU->addAccelName(SP.getName(), ScopeDIE);
448 // If the linkage name is different than the name, go ahead and output
449 // that as well into the name table.
450 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
451 TheCU->addAccelName(SP.getLinkageName(), ScopeDIE);
457 /// GetOrCreateSourceID - Look up the source id with the given directory and
458 /// source file names. If none currently exists, create a new id and insert it
459 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
461 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
463 // If FE did not provide a file name, then assume stdin.
464 if (FileName.empty())
465 return GetOrCreateSourceID("<stdin>", StringRef());
467 // TODO: this might not belong here. See if we can factor this better.
468 if (DirName == CompilationDir)
471 unsigned SrcId = SourceIdMap.size()+1;
472 std::pair<std::string, std::string> SourceName =
473 std::make_pair(FileName, DirName);
474 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
475 make_pair(SourceName, SrcId);
477 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
479 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
483 // Print out a .file directive to specify files for .loc directives.
484 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
490 /// constructCompileUnit - Create new CompileUnit for the given
491 /// metadata node with tag DW_TAG_compile_unit.
492 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
493 DICompileUnit DIUnit(N);
494 StringRef FN = DIUnit.getFilename();
495 CompilationDir = DIUnit.getDirectory();
496 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
498 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
499 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
500 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
501 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
502 DIUnit.getLanguage());
503 NewCU->addString(Die, dwarf::DW_AT_name, FN);
504 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
505 // simplifies debug range entries.
506 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
507 // DW_AT_stmt_list is a offset of line number information for this
508 // compile unit in debug_line section.
509 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
510 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
511 Asm->GetTempSymbol("section_line"));
513 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
515 if (!CompilationDir.empty())
516 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
517 if (DIUnit.isOptimized())
518 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
520 StringRef Flags = DIUnit.getFlags();
522 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
524 if (unsigned RVer = DIUnit.getRunTimeVersion())
525 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
526 dwarf::DW_FORM_data1, RVer);
530 CUMap.insert(std::make_pair(N, NewCU));
534 static bool isObjCClass(StringRef Name) {
535 return Name.startswith("+") || Name.startswith("-");
538 static bool hasObjCCategory(StringRef Name) {
539 if (!isObjCClass(Name)) return false;
541 size_t pos = Name.find(')');
542 if (pos != std::string::npos) {
543 if (Name[pos+1] != ' ') return false;
549 static void getObjCClassCategory(StringRef In, StringRef &Class,
550 StringRef &Category) {
551 if (!hasObjCCategory(In)) {
552 Class = In.slice(In.find('[') + 1, In.find(' '));
557 Class = In.slice(In.find('[') + 1, In.find('('));
558 Category = In.slice(In.find('[') + 1, In.find(' '));
562 static StringRef getObjCMethodName(StringRef In) {
563 return In.slice(In.find(' ') + 1, In.find(']'));
566 /// construct SubprogramDIE - Construct subprogram DIE.
567 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
569 CompileUnit *&CURef = SPMap[N];
575 if (!SP.isDefinition())
576 // This is a method declaration which will be handled while constructing
580 DISubprogram SPDecl = SP.getFunctionDeclaration();
582 if (SPDecl.isSubprogram()) {
583 DeclDie = TheCU->getOrCreateSubprogramDIE(SPDecl);
586 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
589 // Refer function declaration directly.
590 TheCU->addDIEEntry(SubprogramDie, dwarf::DW_AT_specification,
591 dwarf::DW_FORM_ref4, DeclDie);
595 TheCU->insertDIE(N, SubprogramDie);
597 // Add to context owner.
598 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
600 // Add to Accel Names
601 TheCU->addAccelName(SP.getName(), SubprogramDie);
603 // If the linkage name is different than the name, go ahead and output
604 // that as well into the name table.
605 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
606 TheCU->addAccelName(SP.getLinkageName(), SubprogramDie);
608 // If this is an Objective-C selector name add it to the ObjC accelerator too.
609 if (isObjCClass(SP.getName())) {
610 StringRef Class, Category;
611 getObjCClassCategory(SP.getName(), Class, Category);
612 TheCU->addAccelObjC(Class, SubprogramDie);
614 TheCU->addAccelObjC(Category, SubprogramDie);
615 // Also add the base method name to the name table.
616 TheCU->addAccelName(getObjCMethodName(SP.getName()), SubprogramDie);
622 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
623 /// as llvm.dbg.enum and llvm.dbg.ty
624 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
625 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
626 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
627 const MDNode *N = NMD->getOperand(i);
628 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
629 constructSubprogramDIE(CU, N);
632 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
633 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
634 const MDNode *N = NMD->getOperand(i);
635 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
636 CU->createGlobalVariableDIE(N);
639 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
640 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
641 DIType Ty(NMD->getOperand(i));
642 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
643 CU->getOrCreateTypeDIE(Ty);
646 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
647 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
648 DIType Ty(NMD->getOperand(i));
649 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
650 CU->getOrCreateTypeDIE(Ty);
654 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
655 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
656 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
657 DebugInfoFinder DbgFinder;
658 DbgFinder.processModule(*M);
660 bool HasDebugInfo = false;
661 // Scan all the compile-units to see if there are any marked as the main
662 // unit. If not, we do not generate debug info.
663 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
664 E = DbgFinder.compile_unit_end(); I != E; ++I) {
665 if (DICompileUnit(*I).isMain()) {
670 if (!HasDebugInfo) return false;
672 // Create all the compile unit DIEs.
673 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
674 E = DbgFinder.compile_unit_end(); I != E; ++I)
675 constructCompileUnit(*I);
677 // Create DIEs for each global variable.
678 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
679 E = DbgFinder.global_variable_end(); I != E; ++I) {
680 const MDNode *N = *I;
681 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
682 CU->createGlobalVariableDIE(N);
685 // Create DIEs for each subprogram.
686 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
687 E = DbgFinder.subprogram_end(); I != E; ++I) {
688 const MDNode *N = *I;
689 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
690 constructSubprogramDIE(CU, N);
696 /// beginModule - Emit all Dwarf sections that should come prior to the
697 /// content. Create global DIEs and emit initial debug info sections.
698 /// This is invoked by the target AsmPrinter.
699 void DwarfDebug::beginModule(Module *M) {
700 if (DisableDebugInfoPrinting)
703 // If module has named metadata anchors then use them, otherwise scan the
704 // module using debug info finder to collect debug info.
705 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
707 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
708 DICompileUnit CUNode(CU_Nodes->getOperand(i));
709 CompileUnit *CU = constructCompileUnit(CUNode);
710 DIArray GVs = CUNode.getGlobalVariables();
711 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
712 CU->createGlobalVariableDIE(GVs.getElement(i));
713 DIArray SPs = CUNode.getSubprograms();
714 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
715 constructSubprogramDIE(CU, SPs.getElement(i));
716 DIArray EnumTypes = CUNode.getEnumTypes();
717 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
718 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
719 DIArray RetainedTypes = CUNode.getRetainedTypes();
720 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
721 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
723 } else if (!collectLegacyDebugInfo(M))
726 collectInfoFromNamedMDNodes(M);
728 // Tell MMI that we have debug info.
729 MMI->setDebugInfoAvailability(true);
731 // Emit initial sections.
734 // Prime section data.
735 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
738 /// endModule - Emit all Dwarf sections that should come after the content.
740 void DwarfDebug::endModule() {
741 if (!FirstCU) return;
742 const Module *M = MMI->getModule();
743 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
745 // Collect info for variables that were optimized out.
746 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
747 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
748 DICompileUnit TheCU(CU_Nodes->getOperand(i));
749 DIArray Subprograms = TheCU.getSubprograms();
750 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
751 DISubprogram SP(Subprograms.getElement(i));
752 if (ProcessedSPNodes.count(SP) != 0) continue;
753 if (!SP.Verify()) continue;
754 if (!SP.isDefinition()) continue;
755 DIArray Variables = SP.getVariables();
756 if (Variables.getNumElements() == 0) continue;
758 LexicalScope *Scope =
759 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
760 DeadFnScopeMap[SP] = Scope;
762 // Construct subprogram DIE and add variables DIEs.
763 CompileUnit *SPCU = CUMap.lookup(TheCU);
764 assert(SPCU && "Unable to find Compile Unit!");
765 constructSubprogramDIE(SPCU, SP);
766 DIE *ScopeDIE = SPCU->getDIE(SP);
767 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
768 DIVariable DV(Variables.getElement(vi));
769 if (!DV.Verify()) continue;
770 DbgVariable *NewVar = new DbgVariable(DV, NULL);
771 if (DIE *VariableDIE =
772 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
773 ScopeDIE->addChild(VariableDIE);
779 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
780 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
781 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
783 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
786 // Emit DW_AT_containing_type attribute to connect types with their
787 // vtable holding type.
788 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
789 CUE = CUMap.end(); CUI != CUE; ++CUI) {
790 CompileUnit *TheCU = CUI->second;
791 TheCU->constructContainingTypeDIEs();
794 // Standard sections final addresses.
795 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
796 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
797 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
798 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
800 // End text sections.
801 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
802 Asm->OutStreamer.SwitchSection(SectionMap[i]);
803 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
806 // Compute DIE offsets and sizes.
807 computeSizeAndOffsets();
809 // Emit all the DIEs into a debug info section
812 // Corresponding abbreviations into a abbrev section.
815 // Emit info into a dwarf accelerator table sections.
816 if (DwarfAccelTables) {
819 emitAccelNamespaces();
823 // Emit info into a debug pubtypes section.
826 // Emit info into a debug loc section.
829 // Emit info into a debug aranges section.
832 // Emit info into a debug ranges section.
835 // Emit info into a debug macinfo section.
839 emitDebugInlineInfo();
841 // Emit info into a debug str section.
845 DeleteContainerSeconds(DeadFnScopeMap);
847 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
848 E = CUMap.end(); I != E; ++I)
850 FirstCU = NULL; // Reset for the next Module, if any.
853 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
854 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
856 LLVMContext &Ctx = DV->getContext();
857 // More then one inlined variable corresponds to one abstract variable.
858 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
859 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
861 return AbsDbgVariable;
863 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
867 AbsDbgVariable = new DbgVariable(Var, NULL);
868 addScopeVariable(Scope, AbsDbgVariable);
869 AbstractVariables[Var] = AbsDbgVariable;
870 return AbsDbgVariable;
873 /// addCurrentFnArgument - If Var is a current function argument then add
874 /// it to CurrentFnArguments list.
875 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
876 DbgVariable *Var, LexicalScope *Scope) {
877 if (!LScopes.isCurrentFunctionScope(Scope))
879 DIVariable DV = Var->getVariable();
880 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
882 unsigned ArgNo = DV.getArgNumber();
886 size_t Size = CurrentFnArguments.size();
888 CurrentFnArguments.resize(MF->getFunction()->arg_size());
889 // llvm::Function argument size is not good indicator of how many
890 // arguments does the function have at source level.
892 CurrentFnArguments.resize(ArgNo * 2);
893 CurrentFnArguments[ArgNo - 1] = Var;
897 /// collectVariableInfoFromMMITable - Collect variable information from
898 /// side table maintained by MMI.
900 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
901 SmallPtrSet<const MDNode *, 16> &Processed) {
902 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
903 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
904 VE = VMap.end(); VI != VE; ++VI) {
905 const MDNode *Var = VI->first;
907 Processed.insert(Var);
909 const std::pair<unsigned, DebugLoc> &VP = VI->second;
911 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
913 // If variable scope is not found then skip this variable.
917 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
918 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
919 RegVar->setFrameIndex(VP.first);
920 if (!addCurrentFnArgument(MF, RegVar, Scope))
921 addScopeVariable(Scope, RegVar);
923 AbsDbgVariable->setFrameIndex(VP.first);
927 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
928 /// DBG_VALUE instruction, is in a defined reg.
929 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
930 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
931 return MI->getNumOperands() == 3 &&
932 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
933 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
936 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
938 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
939 const MCSymbol *FLabel,
940 const MCSymbol *SLabel,
941 const MachineInstr *MI) {
942 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
944 if (MI->getNumOperands() != 3) {
945 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
946 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
948 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
949 MachineLocation MLoc;
950 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
951 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
953 if (MI->getOperand(0).isImm())
954 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
955 if (MI->getOperand(0).isFPImm())
956 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
957 if (MI->getOperand(0).isCImm())
958 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
960 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
961 return DotDebugLocEntry();
964 /// collectVariableInfo - Find variables for each lexical scope.
966 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
967 SmallPtrSet<const MDNode *, 16> &Processed) {
969 /// collection info from MMI table.
970 collectVariableInfoFromMMITable(MF, Processed);
972 for (SmallVectorImpl<const MDNode*>::const_iterator
973 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
975 const MDNode *Var = *UVI;
976 if (Processed.count(Var))
979 // History contains relevant DBG_VALUE instructions for Var and instructions
981 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
984 const MachineInstr *MInsn = History.front();
987 LexicalScope *Scope = NULL;
988 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
989 DISubprogram(DV.getContext()).describes(MF->getFunction()))
990 Scope = LScopes.getCurrentFunctionScope();
992 if (DV.getVersion() <= LLVMDebugVersion9)
993 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
995 if (MDNode *IA = DV.getInlinedAt())
996 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
998 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1001 // If variable scope is not found then skip this variable.
1005 Processed.insert(DV);
1006 assert(MInsn->isDebugValue() && "History must begin with debug value");
1007 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1008 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1009 if (!addCurrentFnArgument(MF, RegVar, Scope))
1010 addScopeVariable(Scope, RegVar);
1012 AbsVar->setMInsn(MInsn);
1014 // Simple ranges that are fully coalesced.
1015 if (History.size() <= 1 || (History.size() == 2 &&
1016 MInsn->isIdenticalTo(History.back()))) {
1017 RegVar->setMInsn(MInsn);
1021 // handle multiple DBG_VALUE instructions describing one variable.
1022 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1024 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1025 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1026 const MachineInstr *Begin = *HI;
1027 assert(Begin->isDebugValue() && "Invalid History entry");
1029 // Check if DBG_VALUE is truncating a range.
1030 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1031 && !Begin->getOperand(0).getReg())
1034 // Compute the range for a register location.
1035 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1036 const MCSymbol *SLabel = 0;
1039 // If Begin is the last instruction in History then its value is valid
1040 // until the end of the function.
1041 SLabel = FunctionEndSym;
1043 const MachineInstr *End = HI[1];
1044 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1045 << "\t" << *Begin << "\t" << *End << "\n");
1046 if (End->isDebugValue())
1047 SLabel = getLabelBeforeInsn(End);
1049 // End is a normal instruction clobbering the range.
1050 SLabel = getLabelAfterInsn(End);
1051 assert(SLabel && "Forgot label after clobber instruction");
1056 // The value is valid until the next DBG_VALUE or clobber.
1057 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1059 DotDebugLocEntries.push_back(DotDebugLocEntry());
1062 // Collect info for variables that were optimized out.
1063 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1064 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1065 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1066 DIVariable DV(Variables.getElement(i));
1067 if (!DV || !DV.Verify() || !Processed.insert(DV))
1069 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1070 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1074 /// getLabelBeforeInsn - Return Label preceding the instruction.
1075 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1076 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1077 assert(Label && "Didn't insert label before instruction");
1081 /// getLabelAfterInsn - Return Label immediately following the instruction.
1082 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1083 return LabelsAfterInsn.lookup(MI);
1086 /// beginInstruction - Process beginning of an instruction.
1087 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1088 // Check if source location changes, but ignore DBG_VALUE locations.
1089 if (!MI->isDebugValue()) {
1090 DebugLoc DL = MI->getDebugLoc();
1091 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1092 unsigned Flags = DWARF2_FLAG_IS_STMT;
1094 if (DL == PrologEndLoc) {
1095 Flags |= DWARF2_FLAG_PROLOGUE_END;
1096 PrologEndLoc = DebugLoc();
1098 if (!DL.isUnknown()) {
1099 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1100 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1102 recordSourceLine(0, 0, 0, 0);
1106 // Insert labels where requested.
1107 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1108 LabelsBeforeInsn.find(MI);
1111 if (I == LabelsBeforeInsn.end())
1114 // Label already assigned.
1119 PrevLabel = MMI->getContext().CreateTempSymbol();
1120 Asm->OutStreamer.EmitLabel(PrevLabel);
1122 I->second = PrevLabel;
1125 /// endInstruction - Process end of an instruction.
1126 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1127 // Don't create a new label after DBG_VALUE instructions.
1128 // They don't generate code.
1129 if (!MI->isDebugValue())
1132 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1133 LabelsAfterInsn.find(MI);
1136 if (I == LabelsAfterInsn.end())
1139 // Label already assigned.
1143 // We need a label after this instruction.
1145 PrevLabel = MMI->getContext().CreateTempSymbol();
1146 Asm->OutStreamer.EmitLabel(PrevLabel);
1148 I->second = PrevLabel;
1151 /// identifyScopeMarkers() -
1152 /// Each LexicalScope has first instruction and last instruction to mark
1153 /// beginning and end of a scope respectively. Create an inverse map that list
1154 /// scopes starts (and ends) with an instruction. One instruction may start (or
1155 /// end) multiple scopes. Ignore scopes that are not reachable.
1156 void DwarfDebug::identifyScopeMarkers() {
1157 SmallVector<LexicalScope *, 4> WorkList;
1158 WorkList.push_back(LScopes.getCurrentFunctionScope());
1159 while (!WorkList.empty()) {
1160 LexicalScope *S = WorkList.pop_back_val();
1162 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1163 if (!Children.empty())
1164 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1165 SE = Children.end(); SI != SE; ++SI)
1166 WorkList.push_back(*SI);
1168 if (S->isAbstractScope())
1171 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1174 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1175 RE = Ranges.end(); RI != RE; ++RI) {
1176 assert(RI->first && "InsnRange does not have first instruction!");
1177 assert(RI->second && "InsnRange does not have second instruction!");
1178 requestLabelBeforeInsn(RI->first);
1179 requestLabelAfterInsn(RI->second);
1184 /// getScopeNode - Get MDNode for DebugLoc's scope.
1185 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1186 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1187 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1188 return DL.getScope(Ctx);
1191 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1192 /// line number info for the function.
1193 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1194 const MDNode *Scope = getScopeNode(DL, Ctx);
1195 DISubprogram SP = getDISubprogram(Scope);
1197 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1201 /// beginFunction - Gather pre-function debug information. Assumes being
1202 /// emitted immediately after the function entry point.
1203 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1204 if (!MMI->hasDebugInfo()) return;
1205 LScopes.initialize(*MF);
1206 if (LScopes.empty()) return;
1207 identifyScopeMarkers();
1209 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1210 Asm->getFunctionNumber());
1211 // Assumes in correct section after the entry point.
1212 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1214 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1216 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1217 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1218 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1220 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1222 bool AtBlockEntry = true;
1223 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1225 const MachineInstr *MI = II;
1227 if (MI->isDebugValue()) {
1228 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1230 // Keep track of user variables.
1232 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1234 // Variable is in a register, we need to check for clobbers.
1235 if (isDbgValueInDefinedReg(MI))
1236 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1238 // Check the history of this variable.
1239 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1240 if (History.empty()) {
1241 UserVariables.push_back(Var);
1242 // The first mention of a function argument gets the FunctionBeginSym
1243 // label, so arguments are visible when breaking at function entry.
1245 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1246 DISubprogram(getDISubprogram(DV.getContext()))
1247 .describes(MF->getFunction()))
1248 LabelsBeforeInsn[MI] = FunctionBeginSym;
1250 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1251 const MachineInstr *Prev = History.back();
1252 if (Prev->isDebugValue()) {
1253 // Coalesce identical entries at the end of History.
1254 if (History.size() >= 2 &&
1255 Prev->isIdenticalTo(History[History.size() - 2])) {
1256 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1258 << "\t" << *History[History.size() - 2] << "\n");
1262 // Terminate old register assignments that don't reach MI;
1263 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1264 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1265 isDbgValueInDefinedReg(Prev)) {
1266 // Previous register assignment needs to terminate at the end of
1268 MachineBasicBlock::const_iterator LastMI =
1269 PrevMBB->getLastNonDebugInstr();
1270 if (LastMI == PrevMBB->end()) {
1271 // Drop DBG_VALUE for empty range.
1272 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1273 << "\t" << *Prev << "\n");
1277 // Terminate after LastMI.
1278 History.push_back(LastMI);
1283 History.push_back(MI);
1285 // Not a DBG_VALUE instruction.
1287 AtBlockEntry = false;
1289 // First known non DBG_VALUE location marks beginning of function
1291 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1292 PrologEndLoc = MI->getDebugLoc();
1294 // Check if the instruction clobbers any registers with debug vars.
1295 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1296 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1297 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1299 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1300 unsigned Reg = *AI; ++AI) {
1301 const MDNode *Var = LiveUserVar[Reg];
1304 // Reg is now clobbered.
1305 LiveUserVar[Reg] = 0;
1307 // Was MD last defined by a DBG_VALUE referring to Reg?
1308 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1309 if (HistI == DbgValues.end())
1311 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1312 if (History.empty())
1314 const MachineInstr *Prev = History.back();
1315 // Sanity-check: Register assignments are terminated at the end of
1317 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1319 // Is the variable still in Reg?
1320 if (!isDbgValueInDefinedReg(Prev) ||
1321 Prev->getOperand(0).getReg() != Reg)
1323 // Var is clobbered. Make sure the next instruction gets a label.
1324 History.push_back(MI);
1331 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1333 SmallVectorImpl<const MachineInstr*> &History = I->second;
1334 if (History.empty())
1337 // Make sure the final register assignments are terminated.
1338 const MachineInstr *Prev = History.back();
1339 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1340 const MachineBasicBlock *PrevMBB = Prev->getParent();
1341 MachineBasicBlock::const_iterator LastMI =
1342 PrevMBB->getLastNonDebugInstr();
1343 if (LastMI == PrevMBB->end())
1344 // Drop DBG_VALUE for empty range.
1347 // Terminate after LastMI.
1348 History.push_back(LastMI);
1351 // Request labels for the full history.
1352 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1353 const MachineInstr *MI = History[i];
1354 if (MI->isDebugValue())
1355 requestLabelBeforeInsn(MI);
1357 requestLabelAfterInsn(MI);
1361 PrevInstLoc = DebugLoc();
1362 PrevLabel = FunctionBeginSym;
1364 // Record beginning of function.
1365 if (!PrologEndLoc.isUnknown()) {
1366 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1367 MF->getFunction()->getContext());
1368 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1369 FnStartDL.getScope(MF->getFunction()->getContext()),
1370 DWARF2_FLAG_IS_STMT);
1374 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1375 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1376 ScopeVariables[LS].push_back(Var);
1377 // Vars.push_back(Var);
1380 /// endFunction - Gather and emit post-function debug information.
1382 void DwarfDebug::endFunction(const MachineFunction *MF) {
1383 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1385 // Define end label for subprogram.
1386 FunctionEndSym = Asm->GetTempSymbol("func_end",
1387 Asm->getFunctionNumber());
1388 // Assumes in correct section after the entry point.
1389 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1391 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1392 collectVariableInfo(MF, ProcessedVars);
1394 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1395 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1396 assert(TheCU && "Unable to find compile unit!");
1398 // Construct abstract scopes.
1399 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1400 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1401 LexicalScope *AScope = AList[i];
1402 DISubprogram SP(AScope->getScopeNode());
1404 // Collect info for variables that were optimized out.
1405 DIArray Variables = SP.getVariables();
1406 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1407 DIVariable DV(Variables.getElement(i));
1408 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1410 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1411 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1414 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1415 constructScopeDIE(TheCU, AScope);
1418 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1420 if (!DisableFramePointerElim(*MF))
1421 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1422 dwarf::DW_FORM_flag, 1);
1424 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1425 MMI->getFrameMoves()));
1428 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1429 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1430 DeleteContainerPointers(I->second);
1431 ScopeVariables.clear();
1432 DeleteContainerPointers(CurrentFnArguments);
1433 UserVariables.clear();
1435 AbstractVariables.clear();
1436 LabelsBeforeInsn.clear();
1437 LabelsAfterInsn.clear();
1441 /// recordSourceLine - Register a source line with debug info. Returns the
1442 /// unique label that was emitted and which provides correspondence to
1443 /// the source line list.
1444 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1450 DIDescriptor Scope(S);
1452 if (Scope.isCompileUnit()) {
1453 DICompileUnit CU(S);
1454 Fn = CU.getFilename();
1455 Dir = CU.getDirectory();
1456 } else if (Scope.isFile()) {
1458 Fn = F.getFilename();
1459 Dir = F.getDirectory();
1460 } else if (Scope.isSubprogram()) {
1462 Fn = SP.getFilename();
1463 Dir = SP.getDirectory();
1464 } else if (Scope.isLexicalBlockFile()) {
1465 DILexicalBlockFile DBF(S);
1466 Fn = DBF.getFilename();
1467 Dir = DBF.getDirectory();
1468 } else if (Scope.isLexicalBlock()) {
1469 DILexicalBlock DB(S);
1470 Fn = DB.getFilename();
1471 Dir = DB.getDirectory();
1473 assert(0 && "Unexpected scope info");
1475 Src = GetOrCreateSourceID(Fn, Dir);
1477 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1480 //===----------------------------------------------------------------------===//
1482 //===----------------------------------------------------------------------===//
1484 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1487 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1488 // Get the children.
1489 const std::vector<DIE *> &Children = Die->getChildren();
1491 // If not last sibling and has children then add sibling offset attribute.
1492 if (!Last && !Children.empty())
1493 Die->addSiblingOffset(DIEValueAllocator);
1495 // Record the abbreviation.
1496 assignAbbrevNumber(Die->getAbbrev());
1498 // Get the abbreviation for this DIE.
1499 unsigned AbbrevNumber = Die->getAbbrevNumber();
1500 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1503 Die->setOffset(Offset);
1505 // Start the size with the size of abbreviation code.
1506 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1508 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1509 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1511 // Size the DIE attribute values.
1512 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1513 // Size attribute value.
1514 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1516 // Size the DIE children if any.
1517 if (!Children.empty()) {
1518 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1519 "Children flag not set");
1521 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1522 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1524 // End of children marker.
1525 Offset += sizeof(int8_t);
1528 Die->setSize(Offset - Die->getOffset());
1532 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1534 void DwarfDebug::computeSizeAndOffsets() {
1535 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1536 E = CUMap.end(); I != E; ++I) {
1537 // Compute size of compile unit header.
1539 sizeof(int32_t) + // Length of Compilation Unit Info
1540 sizeof(int16_t) + // DWARF version number
1541 sizeof(int32_t) + // Offset Into Abbrev. Section
1542 sizeof(int8_t); // Pointer Size (in bytes)
1543 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1547 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1548 /// the start of each one.
1549 void DwarfDebug::EmitSectionLabels() {
1550 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1552 // Dwarf sections base addresses.
1553 DwarfInfoSectionSym =
1554 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1555 DwarfAbbrevSectionSym =
1556 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1557 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1559 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1560 EmitSectionSym(Asm, MacroInfo);
1562 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1563 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1564 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1565 DwarfStrSectionSym =
1566 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1567 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1570 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1571 "section_debug_loc");
1573 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1574 EmitSectionSym(Asm, TLOF.getDataSection());
1577 /// emitDIE - Recursively emits a debug information entry.
1579 void DwarfDebug::emitDIE(DIE *Die) {
1580 // Get the abbreviation for this DIE.
1581 unsigned AbbrevNumber = Die->getAbbrevNumber();
1582 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1584 // Emit the code (index) for the abbreviation.
1585 if (Asm->isVerbose())
1586 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1587 Twine::utohexstr(Die->getOffset()) + ":0x" +
1588 Twine::utohexstr(Die->getSize()) + " " +
1589 dwarf::TagString(Abbrev->getTag()));
1590 Asm->EmitULEB128(AbbrevNumber);
1592 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1593 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1595 // Emit the DIE attribute values.
1596 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1597 unsigned Attr = AbbrevData[i].getAttribute();
1598 unsigned Form = AbbrevData[i].getForm();
1599 assert(Form && "Too many attributes for DIE (check abbreviation)");
1601 if (Asm->isVerbose())
1602 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1605 case dwarf::DW_AT_sibling:
1606 Asm->EmitInt32(Die->getSiblingOffset());
1608 case dwarf::DW_AT_abstract_origin: {
1609 DIEEntry *E = cast<DIEEntry>(Values[i]);
1610 DIE *Origin = E->getEntry();
1611 unsigned Addr = Origin->getOffset();
1612 Asm->EmitInt32(Addr);
1615 case dwarf::DW_AT_ranges: {
1616 // DW_AT_range Value encodes offset in debug_range section.
1617 DIEInteger *V = cast<DIEInteger>(Values[i]);
1619 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1620 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1624 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1626 DwarfDebugRangeSectionSym,
1631 case dwarf::DW_AT_location: {
1632 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1633 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1635 Values[i]->EmitValue(Asm, Form);
1638 case dwarf::DW_AT_accessibility: {
1639 if (Asm->isVerbose()) {
1640 DIEInteger *V = cast<DIEInteger>(Values[i]);
1641 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1643 Values[i]->EmitValue(Asm, Form);
1647 // Emit an attribute using the defined form.
1648 Values[i]->EmitValue(Asm, Form);
1653 // Emit the DIE children if any.
1654 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1655 const std::vector<DIE *> &Children = Die->getChildren();
1657 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1658 emitDIE(Children[j]);
1660 if (Asm->isVerbose())
1661 Asm->OutStreamer.AddComment("End Of Children Mark");
1666 /// emitDebugInfo - Emit the debug info section.
1668 void DwarfDebug::emitDebugInfo() {
1669 // Start debug info section.
1670 Asm->OutStreamer.SwitchSection(
1671 Asm->getObjFileLowering().getDwarfInfoSection());
1672 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1673 E = CUMap.end(); I != E; ++I) {
1674 CompileUnit *TheCU = I->second;
1675 DIE *Die = TheCU->getCUDie();
1677 // Emit the compile units header.
1678 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1681 // Emit size of content not including length itself
1682 unsigned ContentSize = Die->getSize() +
1683 sizeof(int16_t) + // DWARF version number
1684 sizeof(int32_t) + // Offset Into Abbrev. Section
1685 sizeof(int8_t); // Pointer Size (in bytes)
1687 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1688 Asm->EmitInt32(ContentSize);
1689 Asm->OutStreamer.AddComment("DWARF version number");
1690 Asm->EmitInt16(dwarf::DWARF_VERSION);
1691 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1692 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1693 DwarfAbbrevSectionSym);
1694 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1695 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1698 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1702 /// emitAbbreviations - Emit the abbreviation section.
1704 void DwarfDebug::emitAbbreviations() const {
1705 // Check to see if it is worth the effort.
1706 if (!Abbreviations.empty()) {
1707 // Start the debug abbrev section.
1708 Asm->OutStreamer.SwitchSection(
1709 Asm->getObjFileLowering().getDwarfAbbrevSection());
1711 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1713 // For each abbrevation.
1714 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1715 // Get abbreviation data
1716 const DIEAbbrev *Abbrev = Abbreviations[i];
1718 // Emit the abbrevations code (base 1 index.)
1719 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1721 // Emit the abbreviations data.
1725 // Mark end of abbreviations.
1726 Asm->EmitULEB128(0, "EOM(3)");
1728 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1732 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1733 /// the line matrix.
1735 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1736 // Define last address of section.
1737 Asm->OutStreamer.AddComment("Extended Op");
1740 Asm->OutStreamer.AddComment("Op size");
1741 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1742 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1743 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1745 Asm->OutStreamer.AddComment("Section end label");
1747 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1748 Asm->getTargetData().getPointerSize(),
1751 // Mark end of matrix.
1752 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1758 /// emitAccelNames - Emit visible names into a hashed accelerator table
1760 void DwarfDebug::emitAccelNames() {
1761 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1762 dwarf::DW_FORM_data4));
1763 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1764 E = CUMap.end(); I != E; ++I) {
1765 CompileUnit *TheCU = I->second;
1766 const StringMap<DIE*> &Names = TheCU->getAccelNames();
1767 for (StringMap<DIE*>::const_iterator
1768 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1769 const char *Name = GI->getKeyData();
1770 DIE *Entity = GI->second;
1771 AT.AddName(Name, Entity);
1775 AT.FinalizeTable(Asm, "Names");
1776 Asm->OutStreamer.SwitchSection(
1777 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1778 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1779 Asm->OutStreamer.EmitLabel(SectionBegin);
1781 // Emit the full data.
1782 AT.Emit(Asm, SectionBegin, this);
1785 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1786 /// accelerator table section.
1787 void DwarfDebug::emitAccelObjC() {
1788 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1789 dwarf::DW_FORM_data4));
1790 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1791 E = CUMap.end(); I != E; ++I) {
1792 CompileUnit *TheCU = I->second;
1793 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1794 for (StringMap<std::vector<DIE*> >::const_iterator
1795 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1796 const char *Name = GI->getKeyData();
1797 std::vector<DIE *> Entities = GI->second;
1798 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1799 DE = Entities.end(); DI != DE; ++DI)
1800 AT.AddName(Name, (*DI));
1804 AT.FinalizeTable(Asm, "ObjC");
1805 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1806 .getDwarfAccelObjCSection());
1807 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1808 Asm->OutStreamer.EmitLabel(SectionBegin);
1810 // Emit the full data.
1811 AT.Emit(Asm, SectionBegin, this);
1814 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1816 void DwarfDebug::emitAccelNamespaces() {
1817 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1818 dwarf::DW_FORM_data4));
1819 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1820 E = CUMap.end(); I != E; ++I) {
1821 CompileUnit *TheCU = I->second;
1822 const StringMap<DIE*> &Names = TheCU->getAccelNamespace();
1823 for (StringMap<DIE*>::const_iterator
1824 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1825 const char *Name = GI->getKeyData();
1826 DIE *Entity = GI->second;
1827 AT.AddName(Name, Entity);
1831 AT.FinalizeTable(Asm, "namespac");
1832 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1833 .getDwarfAccelNamespaceSection());
1834 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1835 Asm->OutStreamer.EmitLabel(SectionBegin);
1837 // Emit the full data.
1838 AT.Emit(Asm, SectionBegin, this);
1841 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1842 void DwarfDebug::emitAccelTypes() {
1843 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1844 dwarf::DW_FORM_data4));
1845 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1846 E = CUMap.end(); I != E; ++I) {
1847 CompileUnit *TheCU = I->second;
1848 const StringMap<DIE*> &Names = 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 void DwarfDebug::emitDebugPubTypes() {
1868 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1869 E = CUMap.end(); I != E; ++I) {
1870 CompileUnit *TheCU = I->second;
1871 // Start the dwarf pubtypes section.
1872 Asm->OutStreamer.SwitchSection(
1873 Asm->getObjFileLowering().getDwarfPubTypesSection());
1874 Asm->OutStreamer.AddComment("Length of Public Types Info");
1875 Asm->EmitLabelDifference(
1876 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1877 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1879 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1882 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1883 Asm->EmitInt16(dwarf::DWARF_VERSION);
1885 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1886 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1887 DwarfInfoSectionSym);
1889 Asm->OutStreamer.AddComment("Compilation Unit Length");
1890 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1891 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1894 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1895 for (StringMap<DIE*>::const_iterator
1896 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1897 const char *Name = GI->getKeyData();
1898 DIE *Entity = GI->second;
1900 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1901 Asm->EmitInt32(Entity->getOffset());
1903 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1904 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1907 Asm->OutStreamer.AddComment("End Mark");
1909 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1914 /// emitDebugStr - Emit visible names into a debug str section.
1916 void DwarfDebug::emitDebugStr() {
1917 // Check to see if it is worth the effort.
1918 if (StringPool.empty()) return;
1920 // Start the dwarf str section.
1921 Asm->OutStreamer.SwitchSection(
1922 Asm->getObjFileLowering().getDwarfStrSection());
1924 // Get all of the string pool entries and put them in an array by their ID so
1925 // we can sort them.
1926 SmallVector<std::pair<unsigned,
1927 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1929 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1930 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1931 Entries.push_back(std::make_pair(I->second.second, &*I));
1933 array_pod_sort(Entries.begin(), Entries.end());
1935 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1936 // Emit a label for reference from debug information entries.
1937 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1939 // Emit the string itself.
1940 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1941 Entries[i].second->getKeyLength()+1),
1946 /// emitDebugLoc - Emit visible names into a debug loc section.
1948 void DwarfDebug::emitDebugLoc() {
1949 if (DotDebugLocEntries.empty())
1952 for (SmallVector<DotDebugLocEntry, 4>::iterator
1953 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1955 DotDebugLocEntry &Entry = *I;
1956 if (I + 1 != DotDebugLocEntries.end())
1960 // Start the dwarf loc section.
1961 Asm->OutStreamer.SwitchSection(
1962 Asm->getObjFileLowering().getDwarfLocSection());
1963 unsigned char Size = Asm->getTargetData().getPointerSize();
1964 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1966 for (SmallVector<DotDebugLocEntry, 4>::iterator
1967 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1968 I != E; ++I, ++index) {
1969 DotDebugLocEntry &Entry = *I;
1970 if (Entry.isMerged()) continue;
1971 if (Entry.isEmpty()) {
1972 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1973 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1974 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1976 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1977 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1978 DIVariable DV(Entry.Variable);
1979 Asm->OutStreamer.AddComment("Loc expr size");
1980 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1981 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1982 Asm->EmitLabelDifference(end, begin, 2);
1983 Asm->OutStreamer.EmitLabel(begin);
1984 if (Entry.isInt()) {
1985 DIBasicType BTy(DV.getType());
1987 (BTy.getEncoding() == dwarf::DW_ATE_signed
1988 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1989 Asm->OutStreamer.AddComment("DW_OP_consts");
1990 Asm->EmitInt8(dwarf::DW_OP_consts);
1991 Asm->EmitSLEB128(Entry.getInt());
1993 Asm->OutStreamer.AddComment("DW_OP_constu");
1994 Asm->EmitInt8(dwarf::DW_OP_constu);
1995 Asm->EmitULEB128(Entry.getInt());
1997 } else if (Entry.isLocation()) {
1998 if (!DV.hasComplexAddress())
2000 Asm->EmitDwarfRegOp(Entry.Loc);
2002 // Complex address entry.
2003 unsigned N = DV.getNumAddrElements();
2005 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2006 if (Entry.Loc.getOffset()) {
2008 Asm->EmitDwarfRegOp(Entry.Loc);
2009 Asm->OutStreamer.AddComment("DW_OP_deref");
2010 Asm->EmitInt8(dwarf::DW_OP_deref);
2011 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2012 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2013 Asm->EmitSLEB128(DV.getAddrElement(1));
2015 // If first address element is OpPlus then emit
2016 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2017 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2018 Asm->EmitDwarfRegOp(Loc);
2022 Asm->EmitDwarfRegOp(Entry.Loc);
2025 // Emit remaining complex address elements.
2026 for (; i < N; ++i) {
2027 uint64_t Element = DV.getAddrElement(i);
2028 if (Element == DIBuilder::OpPlus) {
2029 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2030 Asm->EmitULEB128(DV.getAddrElement(++i));
2031 } else if (Element == DIBuilder::OpDeref)
2032 Asm->EmitInt8(dwarf::DW_OP_deref);
2033 else llvm_unreachable("unknown Opcode found in complex address");
2037 // else ... ignore constant fp. There is not any good way to
2038 // to represent them here in dwarf.
2039 Asm->OutStreamer.EmitLabel(end);
2044 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2046 void DwarfDebug::EmitDebugARanges() {
2047 // Start the dwarf aranges section.
2048 Asm->OutStreamer.SwitchSection(
2049 Asm->getObjFileLowering().getDwarfARangesSection());
2052 /// emitDebugRanges - Emit visible names into a debug ranges section.
2054 void DwarfDebug::emitDebugRanges() {
2055 // Start the dwarf ranges section.
2056 Asm->OutStreamer.SwitchSection(
2057 Asm->getObjFileLowering().getDwarfRangesSection());
2058 unsigned char Size = Asm->getTargetData().getPointerSize();
2059 for (SmallVector<const MCSymbol *, 8>::iterator
2060 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2063 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2065 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2069 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2071 void DwarfDebug::emitDebugMacInfo() {
2072 if (const MCSection *LineInfo =
2073 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2074 // Start the dwarf macinfo section.
2075 Asm->OutStreamer.SwitchSection(LineInfo);
2079 /// emitDebugInlineInfo - Emit inline info using following format.
2081 /// 1. length of section
2082 /// 2. Dwarf version number
2083 /// 3. address size.
2085 /// Entries (one "entry" for each function that was inlined):
2087 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2088 /// otherwise offset into __debug_str for regular function name.
2089 /// 2. offset into __debug_str section for regular function name.
2090 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2091 /// instances for the function.
2093 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2094 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2095 /// __debug_info section, and the low_pc is the starting address for the
2096 /// inlining instance.
2097 void DwarfDebug::emitDebugInlineInfo() {
2098 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2104 Asm->OutStreamer.SwitchSection(
2105 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2107 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2108 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2109 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2111 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2113 Asm->OutStreamer.AddComment("Dwarf Version");
2114 Asm->EmitInt16(dwarf::DWARF_VERSION);
2115 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2116 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2118 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2119 E = InlinedSPNodes.end(); I != E; ++I) {
2121 const MDNode *Node = *I;
2122 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2123 = InlineInfo.find(Node);
2124 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2125 DISubprogram SP(Node);
2126 StringRef LName = SP.getLinkageName();
2127 StringRef Name = SP.getName();
2129 Asm->OutStreamer.AddComment("MIPS linkage name");
2130 if (LName.empty()) {
2131 Asm->OutStreamer.EmitBytes(Name, 0);
2132 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2134 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2135 DwarfStrSectionSym);
2137 Asm->OutStreamer.AddComment("Function name");
2138 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2139 Asm->EmitULEB128(Labels.size(), "Inline count");
2141 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2142 LE = Labels.end(); LI != LE; ++LI) {
2143 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2144 Asm->EmitInt32(LI->second->getOffset());
2146 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2147 Asm->OutStreamer.EmitSymbolValue(LI->first,
2148 Asm->getTargetData().getPointerSize(),0);
2152 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));