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 static bool isObjCClass(StringRef Name) {
202 return Name.startswith("+") || Name.startswith("-");
205 static bool hasObjCCategory(StringRef Name) {
206 if (!isObjCClass(Name)) return false;
208 size_t pos = Name.find(')');
209 if (pos != std::string::npos) {
210 if (Name[pos+1] != ' ') return false;
216 static void getObjCClassCategory(StringRef In, StringRef &Class,
217 StringRef &Category) {
218 if (!hasObjCCategory(In)) {
219 Class = In.slice(In.find('[') + 1, In.find(' '));
224 Class = In.slice(In.find('[') + 1, In.find('('));
225 Category = In.slice(In.find('[') + 1, In.find(' '));
229 static StringRef getObjCMethodName(StringRef In) {
230 return In.slice(In.find(' ') + 1, In.find(']'));
233 // Add the various names to the Dwarf accelerator table names.
234 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
236 if (!SP.isDefinition()) return;
238 TheCU->addAccelName(SP.getName(), Die);
240 // If the linkage name is different than the name, go ahead and output
241 // that as well into the name table.
242 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
243 TheCU->addAccelName(SP.getLinkageName(), Die);
245 // If this is an Objective-C selector name add it to the ObjC accelerator
247 if (isObjCClass(SP.getName())) {
248 StringRef Class, Category;
249 getObjCClassCategory(SP.getName(), Class, Category);
250 TheCU->addAccelObjC(Class, Die);
252 TheCU->addAccelObjC(Category, Die);
253 // Also add the base method name to the name table.
254 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
258 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
259 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
260 /// If there are global variables in this scope then create and insert
261 /// DIEs for these variables.
262 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
263 const MDNode *SPNode) {
264 DIE *SPDie = SPCU->getDIE(SPNode);
266 assert(SPDie && "Unable to find subprogram DIE!");
267 DISubprogram SP(SPNode);
269 DISubprogram SPDecl = SP.getFunctionDeclaration();
270 if (!SPDecl.isSubprogram()) {
271 // There is not any need to generate specification DIE for a function
272 // defined at compile unit level. If a function is defined inside another
273 // function then gdb prefers the definition at top level and but does not
274 // expect specification DIE in parent function. So avoid creating
275 // specification DIE for a function defined inside a function.
276 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
277 !SP.getContext().isFile() &&
278 !isSubprogramContext(SP.getContext())) {
279 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
282 DICompositeType SPTy = SP.getType();
283 DIArray Args = SPTy.getTypeArray();
284 unsigned SPTag = SPTy.getTag();
285 if (SPTag == dwarf::DW_TAG_subroutine_type)
286 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
287 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
288 DIType ATy = DIType(DIType(Args.getElement(i)));
289 SPCU->addType(Arg, ATy);
290 if (ATy.isArtificial())
291 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
292 SPDie->addChild(Arg);
294 DIE *SPDeclDie = SPDie;
295 SPDie = new DIE(dwarf::DW_TAG_subprogram);
296 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
301 // Pick up abstract subprogram DIE.
302 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
303 SPDie = new DIE(dwarf::DW_TAG_subprogram);
304 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
305 dwarf::DW_FORM_ref4, AbsSPDIE);
309 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
310 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
311 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
312 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
313 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
314 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
315 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
317 // Add name to the name table, we do this here because we're guaranteed
318 // to have concrete versions of our DW_TAG_subprogram nodes.
319 addSubprogramNames(SPCU, SP, SPDie);
324 /// constructLexicalScope - Construct new DW_TAG_lexical_block
325 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
326 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
327 LexicalScope *Scope) {
328 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
329 if (Scope->isAbstractScope())
332 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
336 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
337 if (Ranges.size() > 1) {
338 // .debug_range section has not been laid out yet. Emit offset in
339 // .debug_range as a uint, size 4, for now. emitDIE will handle
340 // DW_AT_ranges appropriately.
341 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
342 DebugRangeSymbols.size()
343 * Asm->getTargetData().getPointerSize());
344 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
345 RE = Ranges.end(); RI != RE; ++RI) {
346 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
347 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
349 DebugRangeSymbols.push_back(NULL);
350 DebugRangeSymbols.push_back(NULL);
354 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
355 const MCSymbol *End = getLabelAfterInsn(RI->second);
357 if (End == 0) return 0;
359 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
360 assert(End->isDefined() && "Invalid end label for an inlined scope!");
362 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
363 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
368 /// constructInlinedScopeDIE - This scope represents inlined body of
369 /// a function. Construct DIE to represent this concrete inlined copy
371 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
372 LexicalScope *Scope) {
373 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
374 assert(Ranges.empty() == false &&
375 "LexicalScope does not have instruction markers!");
377 if (!Scope->getScopeNode())
379 DIScope DS(Scope->getScopeNode());
380 DISubprogram InlinedSP = getDISubprogram(DS);
381 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
383 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
387 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
388 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
389 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
391 if (StartLabel == 0 || EndLabel == 0) {
392 assert(0 && "Unexpected Start and End labels for a inlined scope!");
395 assert(StartLabel->isDefined() &&
396 "Invalid starting label for an inlined scope!");
397 assert(EndLabel->isDefined() &&
398 "Invalid end label for an inlined scope!");
400 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
401 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
402 dwarf::DW_FORM_ref4, OriginDIE);
404 if (Ranges.size() > 1) {
405 // .debug_range section has not been laid out yet. Emit offset in
406 // .debug_range as a uint, size 4, for now. emitDIE will handle
407 // DW_AT_ranges appropriately.
408 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
409 DebugRangeSymbols.size()
410 * Asm->getTargetData().getPointerSize());
411 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
412 RE = Ranges.end(); RI != RE; ++RI) {
413 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
414 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
416 DebugRangeSymbols.push_back(NULL);
417 DebugRangeSymbols.push_back(NULL);
419 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
421 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
425 InlinedSubprogramDIEs.insert(OriginDIE);
427 // Track the start label for this inlined function.
428 //.debug_inlined section specification does not clearly state how
429 // to emit inlined scope that is split into multiple instruction ranges.
430 // For now, use first instruction range and emit low_pc/high_pc pair and
431 // corresponding .debug_inlined section entry for this pair.
432 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
433 I = InlineInfo.find(InlinedSP);
435 if (I == InlineInfo.end()) {
436 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
437 InlinedSPNodes.push_back(InlinedSP);
439 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
441 DILocation DL(Scope->getInlinedAt());
442 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
443 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
450 /// constructScopeDIE - Construct a DIE for this scope.
451 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
452 if (!Scope || !Scope->getScopeNode())
455 SmallVector<DIE *, 8> Children;
457 // Collect arguments for current function.
458 if (LScopes.isCurrentFunctionScope(Scope))
459 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
460 if (DbgVariable *ArgDV = CurrentFnArguments[i])
462 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
463 Children.push_back(Arg);
465 // Collect lexical scope children first.
466 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
467 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
469 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
470 Children.push_back(Variable);
471 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
472 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
473 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
474 Children.push_back(Nested);
475 DIScope DS(Scope->getScopeNode());
476 DIE *ScopeDIE = NULL;
477 if (Scope->getInlinedAt())
478 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
479 else if (DS.isSubprogram()) {
480 ProcessedSPNodes.insert(DS);
481 if (Scope->isAbstractScope()) {
482 ScopeDIE = TheCU->getDIE(DS);
483 // Note down abstract DIE.
485 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
488 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
491 // There is no need to emit empty lexical block DIE.
492 if (Children.empty())
494 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
497 if (!ScopeDIE) return NULL;
500 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
501 E = Children.end(); I != E; ++I)
502 ScopeDIE->addChild(*I);
504 if (DS.isSubprogram())
505 TheCU->addPubTypes(DISubprogram(DS));
510 /// GetOrCreateSourceID - Look up the source id with the given directory and
511 /// source file names. If none currently exists, create a new id and insert it
512 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
514 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
516 // If FE did not provide a file name, then assume stdin.
517 if (FileName.empty())
518 return GetOrCreateSourceID("<stdin>", StringRef());
520 // TODO: this might not belong here. See if we can factor this better.
521 if (DirName == CompilationDir)
524 unsigned SrcId = SourceIdMap.size()+1;
525 std::pair<std::string, std::string> SourceName =
526 std::make_pair(FileName, DirName);
527 std::pair<std::pair<std::string, std::string>, unsigned> Entry =
528 make_pair(SourceName, SrcId);
530 std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
532 tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
536 // Print out a .file directive to specify files for .loc directives.
537 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
543 /// constructCompileUnit - Create new CompileUnit for the given
544 /// metadata node with tag DW_TAG_compile_unit.
545 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
546 DICompileUnit DIUnit(N);
547 StringRef FN = DIUnit.getFilename();
548 CompilationDir = DIUnit.getDirectory();
549 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
551 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
552 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
553 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
554 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
555 DIUnit.getLanguage());
556 NewCU->addString(Die, dwarf::DW_AT_name, FN);
557 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
558 // simplifies debug range entries.
559 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
560 // DW_AT_stmt_list is a offset of line number information for this
561 // compile unit in debug_line section.
562 if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
563 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
564 Asm->GetTempSymbol("section_line"));
566 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
568 if (!CompilationDir.empty())
569 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
570 if (DIUnit.isOptimized())
571 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
573 StringRef Flags = DIUnit.getFlags();
575 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
577 if (unsigned RVer = DIUnit.getRunTimeVersion())
578 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
579 dwarf::DW_FORM_data1, RVer);
583 CUMap.insert(std::make_pair(N, NewCU));
587 /// construct SubprogramDIE - Construct subprogram DIE.
588 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
590 CompileUnit *&CURef = SPMap[N];
596 if (!SP.isDefinition())
597 // This is a method declaration which will be handled while constructing
601 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
604 TheCU->insertDIE(N, SubprogramDie);
606 // Add to context owner.
607 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
612 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
613 /// as llvm.dbg.enum and llvm.dbg.ty
614 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
615 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
616 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
617 const MDNode *N = NMD->getOperand(i);
618 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
619 constructSubprogramDIE(CU, N);
622 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
623 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
624 const MDNode *N = NMD->getOperand(i);
625 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
626 CU->createGlobalVariableDIE(N);
629 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
630 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
631 DIType Ty(NMD->getOperand(i));
632 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
633 CU->getOrCreateTypeDIE(Ty);
636 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
637 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
638 DIType Ty(NMD->getOperand(i));
639 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
640 CU->getOrCreateTypeDIE(Ty);
644 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
645 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
646 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
647 DebugInfoFinder DbgFinder;
648 DbgFinder.processModule(*M);
650 bool HasDebugInfo = false;
651 // Scan all the compile-units to see if there are any marked as the main
652 // unit. If not, we do not generate debug info.
653 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
654 E = DbgFinder.compile_unit_end(); I != E; ++I) {
655 if (DICompileUnit(*I).isMain()) {
660 if (!HasDebugInfo) return false;
662 // Create all the compile unit DIEs.
663 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
664 E = DbgFinder.compile_unit_end(); I != E; ++I)
665 constructCompileUnit(*I);
667 // Create DIEs for each global variable.
668 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
669 E = DbgFinder.global_variable_end(); I != E; ++I) {
670 const MDNode *N = *I;
671 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
672 CU->createGlobalVariableDIE(N);
675 // Create DIEs for each subprogram.
676 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
677 E = DbgFinder.subprogram_end(); I != E; ++I) {
678 const MDNode *N = *I;
679 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
680 constructSubprogramDIE(CU, N);
686 /// beginModule - Emit all Dwarf sections that should come prior to the
687 /// content. Create global DIEs and emit initial debug info sections.
688 /// This is invoked by the target AsmPrinter.
689 void DwarfDebug::beginModule(Module *M) {
690 if (DisableDebugInfoPrinting)
693 // If module has named metadata anchors then use them, otherwise scan the
694 // module using debug info finder to collect debug info.
695 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
697 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
698 DICompileUnit CUNode(CU_Nodes->getOperand(i));
699 CompileUnit *CU = constructCompileUnit(CUNode);
700 DIArray GVs = CUNode.getGlobalVariables();
701 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
702 CU->createGlobalVariableDIE(GVs.getElement(i));
703 DIArray SPs = CUNode.getSubprograms();
704 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
705 constructSubprogramDIE(CU, SPs.getElement(i));
706 DIArray EnumTypes = CUNode.getEnumTypes();
707 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
708 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
709 DIArray RetainedTypes = CUNode.getRetainedTypes();
710 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
711 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
713 } else if (!collectLegacyDebugInfo(M))
716 collectInfoFromNamedMDNodes(M);
718 // Tell MMI that we have debug info.
719 MMI->setDebugInfoAvailability(true);
721 // Emit initial sections.
724 // Prime section data.
725 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
728 /// endModule - Emit all Dwarf sections that should come after the content.
730 void DwarfDebug::endModule() {
731 if (!FirstCU) return;
732 const Module *M = MMI->getModule();
733 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
735 // Collect info for variables that were optimized out.
736 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
737 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
738 DICompileUnit TheCU(CU_Nodes->getOperand(i));
739 DIArray Subprograms = TheCU.getSubprograms();
740 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
741 DISubprogram SP(Subprograms.getElement(i));
742 if (ProcessedSPNodes.count(SP) != 0) continue;
743 if (!SP.Verify()) continue;
744 if (!SP.isDefinition()) continue;
745 DIArray Variables = SP.getVariables();
746 if (Variables.getNumElements() == 0) continue;
748 LexicalScope *Scope =
749 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
750 DeadFnScopeMap[SP] = Scope;
752 // Construct subprogram DIE and add variables DIEs.
753 CompileUnit *SPCU = CUMap.lookup(TheCU);
754 assert(SPCU && "Unable to find Compile Unit!");
755 constructSubprogramDIE(SPCU, SP);
756 DIE *ScopeDIE = SPCU->getDIE(SP);
757 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
758 DIVariable DV(Variables.getElement(vi));
759 if (!DV.Verify()) continue;
760 DbgVariable *NewVar = new DbgVariable(DV, NULL);
761 if (DIE *VariableDIE =
762 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
763 ScopeDIE->addChild(VariableDIE);
769 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
770 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
771 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
773 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
776 // Emit DW_AT_containing_type attribute to connect types with their
777 // vtable holding type.
778 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
779 CUE = CUMap.end(); CUI != CUE; ++CUI) {
780 CompileUnit *TheCU = CUI->second;
781 TheCU->constructContainingTypeDIEs();
784 // Standard sections final addresses.
785 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
786 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
787 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
788 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
790 // End text sections.
791 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
792 Asm->OutStreamer.SwitchSection(SectionMap[i]);
793 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
796 // Compute DIE offsets and sizes.
797 computeSizeAndOffsets();
799 // Emit all the DIEs into a debug info section
802 // Corresponding abbreviations into a abbrev section.
805 // Emit info into a dwarf accelerator table sections.
806 if (DwarfAccelTables) {
809 emitAccelNamespaces();
813 // Emit info into a debug pubtypes section.
816 // Emit info into a debug loc section.
819 // Emit info into a debug aranges section.
822 // Emit info into a debug ranges section.
825 // Emit info into a debug macinfo section.
829 emitDebugInlineInfo();
831 // Emit info into a debug str section.
835 DeleteContainerSeconds(DeadFnScopeMap);
837 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
838 E = CUMap.end(); I != E; ++I)
840 FirstCU = NULL; // Reset for the next Module, if any.
843 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
844 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
846 LLVMContext &Ctx = DV->getContext();
847 // More then one inlined variable corresponds to one abstract variable.
848 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
849 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
851 return AbsDbgVariable;
853 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
857 AbsDbgVariable = new DbgVariable(Var, NULL);
858 addScopeVariable(Scope, AbsDbgVariable);
859 AbstractVariables[Var] = AbsDbgVariable;
860 return AbsDbgVariable;
863 /// addCurrentFnArgument - If Var is a current function argument then add
864 /// it to CurrentFnArguments list.
865 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
866 DbgVariable *Var, LexicalScope *Scope) {
867 if (!LScopes.isCurrentFunctionScope(Scope))
869 DIVariable DV = Var->getVariable();
870 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
872 unsigned ArgNo = DV.getArgNumber();
876 size_t Size = CurrentFnArguments.size();
878 CurrentFnArguments.resize(MF->getFunction()->arg_size());
879 // llvm::Function argument size is not good indicator of how many
880 // arguments does the function have at source level.
882 CurrentFnArguments.resize(ArgNo * 2);
883 CurrentFnArguments[ArgNo - 1] = Var;
887 /// collectVariableInfoFromMMITable - Collect variable information from
888 /// side table maintained by MMI.
890 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
891 SmallPtrSet<const MDNode *, 16> &Processed) {
892 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
893 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
894 VE = VMap.end(); VI != VE; ++VI) {
895 const MDNode *Var = VI->first;
897 Processed.insert(Var);
899 const std::pair<unsigned, DebugLoc> &VP = VI->second;
901 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
903 // If variable scope is not found then skip this variable.
907 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
908 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
909 RegVar->setFrameIndex(VP.first);
910 if (!addCurrentFnArgument(MF, RegVar, Scope))
911 addScopeVariable(Scope, RegVar);
913 AbsDbgVariable->setFrameIndex(VP.first);
917 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
918 /// DBG_VALUE instruction, is in a defined reg.
919 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
920 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
921 return MI->getNumOperands() == 3 &&
922 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
923 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
926 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
928 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
929 const MCSymbol *FLabel,
930 const MCSymbol *SLabel,
931 const MachineInstr *MI) {
932 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
934 if (MI->getNumOperands() != 3) {
935 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
936 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
938 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
939 MachineLocation MLoc;
940 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
941 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
943 if (MI->getOperand(0).isImm())
944 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
945 if (MI->getOperand(0).isFPImm())
946 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
947 if (MI->getOperand(0).isCImm())
948 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
950 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
951 return DotDebugLocEntry();
954 /// collectVariableInfo - Find variables for each lexical scope.
956 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
957 SmallPtrSet<const MDNode *, 16> &Processed) {
959 /// collection info from MMI table.
960 collectVariableInfoFromMMITable(MF, Processed);
962 for (SmallVectorImpl<const MDNode*>::const_iterator
963 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
965 const MDNode *Var = *UVI;
966 if (Processed.count(Var))
969 // History contains relevant DBG_VALUE instructions for Var and instructions
971 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
974 const MachineInstr *MInsn = History.front();
977 LexicalScope *Scope = NULL;
978 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
979 DISubprogram(DV.getContext()).describes(MF->getFunction()))
980 Scope = LScopes.getCurrentFunctionScope();
982 if (DV.getVersion() <= LLVMDebugVersion9)
983 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
985 if (MDNode *IA = DV.getInlinedAt())
986 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
988 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
991 // If variable scope is not found then skip this variable.
995 Processed.insert(DV);
996 assert(MInsn->isDebugValue() && "History must begin with debug value");
997 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
998 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
999 if (!addCurrentFnArgument(MF, RegVar, Scope))
1000 addScopeVariable(Scope, RegVar);
1002 AbsVar->setMInsn(MInsn);
1004 // Simple ranges that are fully coalesced.
1005 if (History.size() <= 1 || (History.size() == 2 &&
1006 MInsn->isIdenticalTo(History.back()))) {
1007 RegVar->setMInsn(MInsn);
1011 // handle multiple DBG_VALUE instructions describing one variable.
1012 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1014 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1015 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1016 const MachineInstr *Begin = *HI;
1017 assert(Begin->isDebugValue() && "Invalid History entry");
1019 // Check if DBG_VALUE is truncating a range.
1020 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1021 && !Begin->getOperand(0).getReg())
1024 // Compute the range for a register location.
1025 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1026 const MCSymbol *SLabel = 0;
1029 // If Begin is the last instruction in History then its value is valid
1030 // until the end of the function.
1031 SLabel = FunctionEndSym;
1033 const MachineInstr *End = HI[1];
1034 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1035 << "\t" << *Begin << "\t" << *End << "\n");
1036 if (End->isDebugValue())
1037 SLabel = getLabelBeforeInsn(End);
1039 // End is a normal instruction clobbering the range.
1040 SLabel = getLabelAfterInsn(End);
1041 assert(SLabel && "Forgot label after clobber instruction");
1046 // The value is valid until the next DBG_VALUE or clobber.
1047 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1049 DotDebugLocEntries.push_back(DotDebugLocEntry());
1052 // Collect info for variables that were optimized out.
1053 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1054 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1055 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1056 DIVariable DV(Variables.getElement(i));
1057 if (!DV || !DV.Verify() || !Processed.insert(DV))
1059 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1060 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1064 /// getLabelBeforeInsn - Return Label preceding the instruction.
1065 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1066 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1067 assert(Label && "Didn't insert label before instruction");
1071 /// getLabelAfterInsn - Return Label immediately following the instruction.
1072 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1073 return LabelsAfterInsn.lookup(MI);
1076 /// beginInstruction - Process beginning of an instruction.
1077 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1078 // Check if source location changes, but ignore DBG_VALUE locations.
1079 if (!MI->isDebugValue()) {
1080 DebugLoc DL = MI->getDebugLoc();
1081 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1082 unsigned Flags = DWARF2_FLAG_IS_STMT;
1084 if (DL == PrologEndLoc) {
1085 Flags |= DWARF2_FLAG_PROLOGUE_END;
1086 PrologEndLoc = DebugLoc();
1088 if (!DL.isUnknown()) {
1089 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1090 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1092 recordSourceLine(0, 0, 0, 0);
1096 // Insert labels where requested.
1097 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1098 LabelsBeforeInsn.find(MI);
1101 if (I == LabelsBeforeInsn.end())
1104 // Label already assigned.
1109 PrevLabel = MMI->getContext().CreateTempSymbol();
1110 Asm->OutStreamer.EmitLabel(PrevLabel);
1112 I->second = PrevLabel;
1115 /// endInstruction - Process end of an instruction.
1116 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1117 // Don't create a new label after DBG_VALUE instructions.
1118 // They don't generate code.
1119 if (!MI->isDebugValue())
1122 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1123 LabelsAfterInsn.find(MI);
1126 if (I == LabelsAfterInsn.end())
1129 // Label already assigned.
1133 // We need a label after this instruction.
1135 PrevLabel = MMI->getContext().CreateTempSymbol();
1136 Asm->OutStreamer.EmitLabel(PrevLabel);
1138 I->second = PrevLabel;
1141 /// identifyScopeMarkers() -
1142 /// Each LexicalScope has first instruction and last instruction to mark
1143 /// beginning and end of a scope respectively. Create an inverse map that list
1144 /// scopes starts (and ends) with an instruction. One instruction may start (or
1145 /// end) multiple scopes. Ignore scopes that are not reachable.
1146 void DwarfDebug::identifyScopeMarkers() {
1147 SmallVector<LexicalScope *, 4> WorkList;
1148 WorkList.push_back(LScopes.getCurrentFunctionScope());
1149 while (!WorkList.empty()) {
1150 LexicalScope *S = WorkList.pop_back_val();
1152 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1153 if (!Children.empty())
1154 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1155 SE = Children.end(); SI != SE; ++SI)
1156 WorkList.push_back(*SI);
1158 if (S->isAbstractScope())
1161 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1164 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1165 RE = Ranges.end(); RI != RE; ++RI) {
1166 assert(RI->first && "InsnRange does not have first instruction!");
1167 assert(RI->second && "InsnRange does not have second instruction!");
1168 requestLabelBeforeInsn(RI->first);
1169 requestLabelAfterInsn(RI->second);
1174 /// getScopeNode - Get MDNode for DebugLoc's scope.
1175 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1176 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1177 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1178 return DL.getScope(Ctx);
1181 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1182 /// line number info for the function.
1183 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1184 const MDNode *Scope = getScopeNode(DL, Ctx);
1185 DISubprogram SP = getDISubprogram(Scope);
1187 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1191 /// beginFunction - Gather pre-function debug information. Assumes being
1192 /// emitted immediately after the function entry point.
1193 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1194 if (!MMI->hasDebugInfo()) return;
1195 LScopes.initialize(*MF);
1196 if (LScopes.empty()) return;
1197 identifyScopeMarkers();
1199 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1200 Asm->getFunctionNumber());
1201 // Assumes in correct section after the entry point.
1202 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1204 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1206 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1207 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1208 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1210 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1212 bool AtBlockEntry = true;
1213 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1215 const MachineInstr *MI = II;
1217 if (MI->isDebugValue()) {
1218 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1220 // Keep track of user variables.
1222 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1224 // Variable is in a register, we need to check for clobbers.
1225 if (isDbgValueInDefinedReg(MI))
1226 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1228 // Check the history of this variable.
1229 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1230 if (History.empty()) {
1231 UserVariables.push_back(Var);
1232 // The first mention of a function argument gets the FunctionBeginSym
1233 // label, so arguments are visible when breaking at function entry.
1235 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1236 DISubprogram(getDISubprogram(DV.getContext()))
1237 .describes(MF->getFunction()))
1238 LabelsBeforeInsn[MI] = FunctionBeginSym;
1240 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1241 const MachineInstr *Prev = History.back();
1242 if (Prev->isDebugValue()) {
1243 // Coalesce identical entries at the end of History.
1244 if (History.size() >= 2 &&
1245 Prev->isIdenticalTo(History[History.size() - 2])) {
1246 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1248 << "\t" << *History[History.size() - 2] << "\n");
1252 // Terminate old register assignments that don't reach MI;
1253 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1254 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1255 isDbgValueInDefinedReg(Prev)) {
1256 // Previous register assignment needs to terminate at the end of
1258 MachineBasicBlock::const_iterator LastMI =
1259 PrevMBB->getLastNonDebugInstr();
1260 if (LastMI == PrevMBB->end()) {
1261 // Drop DBG_VALUE for empty range.
1262 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1263 << "\t" << *Prev << "\n");
1267 // Terminate after LastMI.
1268 History.push_back(LastMI);
1273 History.push_back(MI);
1275 // Not a DBG_VALUE instruction.
1277 AtBlockEntry = false;
1279 // First known non DBG_VALUE location marks beginning of function
1281 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1282 PrologEndLoc = MI->getDebugLoc();
1284 // Check if the instruction clobbers any registers with debug vars.
1285 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1286 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1287 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1289 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1290 unsigned Reg = *AI; ++AI) {
1291 const MDNode *Var = LiveUserVar[Reg];
1294 // Reg is now clobbered.
1295 LiveUserVar[Reg] = 0;
1297 // Was MD last defined by a DBG_VALUE referring to Reg?
1298 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1299 if (HistI == DbgValues.end())
1301 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1302 if (History.empty())
1304 const MachineInstr *Prev = History.back();
1305 // Sanity-check: Register assignments are terminated at the end of
1307 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1309 // Is the variable still in Reg?
1310 if (!isDbgValueInDefinedReg(Prev) ||
1311 Prev->getOperand(0).getReg() != Reg)
1313 // Var is clobbered. Make sure the next instruction gets a label.
1314 History.push_back(MI);
1321 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1323 SmallVectorImpl<const MachineInstr*> &History = I->second;
1324 if (History.empty())
1327 // Make sure the final register assignments are terminated.
1328 const MachineInstr *Prev = History.back();
1329 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1330 const MachineBasicBlock *PrevMBB = Prev->getParent();
1331 MachineBasicBlock::const_iterator LastMI =
1332 PrevMBB->getLastNonDebugInstr();
1333 if (LastMI == PrevMBB->end())
1334 // Drop DBG_VALUE for empty range.
1337 // Terminate after LastMI.
1338 History.push_back(LastMI);
1341 // Request labels for the full history.
1342 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1343 const MachineInstr *MI = History[i];
1344 if (MI->isDebugValue())
1345 requestLabelBeforeInsn(MI);
1347 requestLabelAfterInsn(MI);
1351 PrevInstLoc = DebugLoc();
1352 PrevLabel = FunctionBeginSym;
1354 // Record beginning of function.
1355 if (!PrologEndLoc.isUnknown()) {
1356 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1357 MF->getFunction()->getContext());
1358 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1359 FnStartDL.getScope(MF->getFunction()->getContext()),
1360 DWARF2_FLAG_IS_STMT);
1364 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1365 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1366 ScopeVariables[LS].push_back(Var);
1367 // Vars.push_back(Var);
1370 /// endFunction - Gather and emit post-function debug information.
1372 void DwarfDebug::endFunction(const MachineFunction *MF) {
1373 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1375 // Define end label for subprogram.
1376 FunctionEndSym = Asm->GetTempSymbol("func_end",
1377 Asm->getFunctionNumber());
1378 // Assumes in correct section after the entry point.
1379 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1381 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1382 collectVariableInfo(MF, ProcessedVars);
1384 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1385 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1386 assert(TheCU && "Unable to find compile unit!");
1388 // Construct abstract scopes.
1389 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1390 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1391 LexicalScope *AScope = AList[i];
1392 DISubprogram SP(AScope->getScopeNode());
1394 // Collect info for variables that were optimized out.
1395 DIArray Variables = SP.getVariables();
1396 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1397 DIVariable DV(Variables.getElement(i));
1398 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1400 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1401 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1404 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1405 constructScopeDIE(TheCU, AScope);
1408 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1410 if (!DisableFramePointerElim(*MF))
1411 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1412 dwarf::DW_FORM_flag, 1);
1414 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1415 MMI->getFrameMoves()));
1418 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1419 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1420 DeleteContainerPointers(I->second);
1421 ScopeVariables.clear();
1422 DeleteContainerPointers(CurrentFnArguments);
1423 UserVariables.clear();
1425 AbstractVariables.clear();
1426 LabelsBeforeInsn.clear();
1427 LabelsAfterInsn.clear();
1431 /// recordSourceLine - Register a source line with debug info. Returns the
1432 /// unique label that was emitted and which provides correspondence to
1433 /// the source line list.
1434 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1440 DIDescriptor Scope(S);
1442 if (Scope.isCompileUnit()) {
1443 DICompileUnit CU(S);
1444 Fn = CU.getFilename();
1445 Dir = CU.getDirectory();
1446 } else if (Scope.isFile()) {
1448 Fn = F.getFilename();
1449 Dir = F.getDirectory();
1450 } else if (Scope.isSubprogram()) {
1452 Fn = SP.getFilename();
1453 Dir = SP.getDirectory();
1454 } else if (Scope.isLexicalBlockFile()) {
1455 DILexicalBlockFile DBF(S);
1456 Fn = DBF.getFilename();
1457 Dir = DBF.getDirectory();
1458 } else if (Scope.isLexicalBlock()) {
1459 DILexicalBlock DB(S);
1460 Fn = DB.getFilename();
1461 Dir = DB.getDirectory();
1463 assert(0 && "Unexpected scope info");
1465 Src = GetOrCreateSourceID(Fn, Dir);
1467 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1470 //===----------------------------------------------------------------------===//
1472 //===----------------------------------------------------------------------===//
1474 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1477 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1478 // Get the children.
1479 const std::vector<DIE *> &Children = Die->getChildren();
1481 // If not last sibling and has children then add sibling offset attribute.
1482 if (!Last && !Children.empty())
1483 Die->addSiblingOffset(DIEValueAllocator);
1485 // Record the abbreviation.
1486 assignAbbrevNumber(Die->getAbbrev());
1488 // Get the abbreviation for this DIE.
1489 unsigned AbbrevNumber = Die->getAbbrevNumber();
1490 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1493 Die->setOffset(Offset);
1495 // Start the size with the size of abbreviation code.
1496 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1498 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1499 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1501 // Size the DIE attribute values.
1502 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1503 // Size attribute value.
1504 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1506 // Size the DIE children if any.
1507 if (!Children.empty()) {
1508 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1509 "Children flag not set");
1511 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1512 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1514 // End of children marker.
1515 Offset += sizeof(int8_t);
1518 Die->setSize(Offset - Die->getOffset());
1522 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1524 void DwarfDebug::computeSizeAndOffsets() {
1525 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1526 E = CUMap.end(); I != E; ++I) {
1527 // Compute size of compile unit header.
1529 sizeof(int32_t) + // Length of Compilation Unit Info
1530 sizeof(int16_t) + // DWARF version number
1531 sizeof(int32_t) + // Offset Into Abbrev. Section
1532 sizeof(int8_t); // Pointer Size (in bytes)
1533 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1537 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1538 /// the start of each one.
1539 void DwarfDebug::EmitSectionLabels() {
1540 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1542 // Dwarf sections base addresses.
1543 DwarfInfoSectionSym =
1544 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1545 DwarfAbbrevSectionSym =
1546 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1547 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1549 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1550 EmitSectionSym(Asm, MacroInfo);
1552 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1553 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1554 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1555 DwarfStrSectionSym =
1556 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1557 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1560 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1561 "section_debug_loc");
1563 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1564 EmitSectionSym(Asm, TLOF.getDataSection());
1567 /// emitDIE - Recursively emits a debug information entry.
1569 void DwarfDebug::emitDIE(DIE *Die) {
1570 // Get the abbreviation for this DIE.
1571 unsigned AbbrevNumber = Die->getAbbrevNumber();
1572 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1574 // Emit the code (index) for the abbreviation.
1575 if (Asm->isVerbose())
1576 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1577 Twine::utohexstr(Die->getOffset()) + ":0x" +
1578 Twine::utohexstr(Die->getSize()) + " " +
1579 dwarf::TagString(Abbrev->getTag()));
1580 Asm->EmitULEB128(AbbrevNumber);
1582 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1583 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1585 // Emit the DIE attribute values.
1586 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1587 unsigned Attr = AbbrevData[i].getAttribute();
1588 unsigned Form = AbbrevData[i].getForm();
1589 assert(Form && "Too many attributes for DIE (check abbreviation)");
1591 if (Asm->isVerbose())
1592 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1595 case dwarf::DW_AT_sibling:
1596 Asm->EmitInt32(Die->getSiblingOffset());
1598 case dwarf::DW_AT_abstract_origin: {
1599 DIEEntry *E = cast<DIEEntry>(Values[i]);
1600 DIE *Origin = E->getEntry();
1601 unsigned Addr = Origin->getOffset();
1602 Asm->EmitInt32(Addr);
1605 case dwarf::DW_AT_ranges: {
1606 // DW_AT_range Value encodes offset in debug_range section.
1607 DIEInteger *V = cast<DIEInteger>(Values[i]);
1609 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1610 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1614 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1616 DwarfDebugRangeSectionSym,
1621 case dwarf::DW_AT_location: {
1622 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1623 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1625 Values[i]->EmitValue(Asm, Form);
1628 case dwarf::DW_AT_accessibility: {
1629 if (Asm->isVerbose()) {
1630 DIEInteger *V = cast<DIEInteger>(Values[i]);
1631 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1633 Values[i]->EmitValue(Asm, Form);
1637 // Emit an attribute using the defined form.
1638 Values[i]->EmitValue(Asm, Form);
1643 // Emit the DIE children if any.
1644 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1645 const std::vector<DIE *> &Children = Die->getChildren();
1647 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1648 emitDIE(Children[j]);
1650 if (Asm->isVerbose())
1651 Asm->OutStreamer.AddComment("End Of Children Mark");
1656 /// emitDebugInfo - Emit the debug info section.
1658 void DwarfDebug::emitDebugInfo() {
1659 // Start debug info section.
1660 Asm->OutStreamer.SwitchSection(
1661 Asm->getObjFileLowering().getDwarfInfoSection());
1662 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1663 E = CUMap.end(); I != E; ++I) {
1664 CompileUnit *TheCU = I->second;
1665 DIE *Die = TheCU->getCUDie();
1667 // Emit the compile units header.
1668 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1671 // Emit size of content not including length itself
1672 unsigned ContentSize = Die->getSize() +
1673 sizeof(int16_t) + // DWARF version number
1674 sizeof(int32_t) + // Offset Into Abbrev. Section
1675 sizeof(int8_t); // Pointer Size (in bytes)
1677 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1678 Asm->EmitInt32(ContentSize);
1679 Asm->OutStreamer.AddComment("DWARF version number");
1680 Asm->EmitInt16(dwarf::DWARF_VERSION);
1681 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1682 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1683 DwarfAbbrevSectionSym);
1684 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1685 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1688 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1692 /// emitAbbreviations - Emit the abbreviation section.
1694 void DwarfDebug::emitAbbreviations() const {
1695 // Check to see if it is worth the effort.
1696 if (!Abbreviations.empty()) {
1697 // Start the debug abbrev section.
1698 Asm->OutStreamer.SwitchSection(
1699 Asm->getObjFileLowering().getDwarfAbbrevSection());
1701 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1703 // For each abbrevation.
1704 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1705 // Get abbreviation data
1706 const DIEAbbrev *Abbrev = Abbreviations[i];
1708 // Emit the abbrevations code (base 1 index.)
1709 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1711 // Emit the abbreviations data.
1715 // Mark end of abbreviations.
1716 Asm->EmitULEB128(0, "EOM(3)");
1718 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1722 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1723 /// the line matrix.
1725 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1726 // Define last address of section.
1727 Asm->OutStreamer.AddComment("Extended Op");
1730 Asm->OutStreamer.AddComment("Op size");
1731 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1732 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1733 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1735 Asm->OutStreamer.AddComment("Section end label");
1737 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1738 Asm->getTargetData().getPointerSize(),
1741 // Mark end of matrix.
1742 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1748 /// emitAccelNames - Emit visible names into a hashed accelerator table
1750 void DwarfDebug::emitAccelNames() {
1751 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1752 dwarf::DW_FORM_data4));
1753 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1754 E = CUMap.end(); I != E; ++I) {
1755 CompileUnit *TheCU = I->second;
1756 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1757 for (StringMap<std::vector<DIE*> >::const_iterator
1758 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1759 const char *Name = GI->getKeyData();
1760 std::vector<DIE *> Entities = GI->second;
1761 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1762 DE = Entities.end(); DI != DE; ++DI)
1763 AT.AddName(Name, (*DI));
1767 AT.FinalizeTable(Asm, "Names");
1768 Asm->OutStreamer.SwitchSection(
1769 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1770 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1771 Asm->OutStreamer.EmitLabel(SectionBegin);
1773 // Emit the full data.
1774 AT.Emit(Asm, SectionBegin, this);
1777 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1778 /// accelerator table section.
1779 void DwarfDebug::emitAccelObjC() {
1780 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1781 dwarf::DW_FORM_data4));
1782 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1783 E = CUMap.end(); I != E; ++I) {
1784 CompileUnit *TheCU = I->second;
1785 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1786 for (StringMap<std::vector<DIE*> >::const_iterator
1787 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1788 const char *Name = GI->getKeyData();
1789 std::vector<DIE *> Entities = GI->second;
1790 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1791 DE = Entities.end(); DI != DE; ++DI)
1792 AT.AddName(Name, (*DI));
1796 AT.FinalizeTable(Asm, "ObjC");
1797 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1798 .getDwarfAccelObjCSection());
1799 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1800 Asm->OutStreamer.EmitLabel(SectionBegin);
1802 // Emit the full data.
1803 AT.Emit(Asm, SectionBegin, this);
1806 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1808 void DwarfDebug::emitAccelNamespaces() {
1809 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1810 dwarf::DW_FORM_data4));
1811 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1812 E = CUMap.end(); I != E; ++I) {
1813 CompileUnit *TheCU = I->second;
1814 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1815 for (StringMap<std::vector<DIE*> >::const_iterator
1816 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1817 const char *Name = GI->getKeyData();
1818 std::vector<DIE *> Entities = GI->second;
1819 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1820 DE = Entities.end(); DI != DE; ++DI)
1821 AT.AddName(Name, (*DI));
1825 AT.FinalizeTable(Asm, "namespac");
1826 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1827 .getDwarfAccelNamespaceSection());
1828 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1829 Asm->OutStreamer.EmitLabel(SectionBegin);
1831 // Emit the full data.
1832 AT.Emit(Asm, SectionBegin, this);
1835 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1836 void DwarfDebug::emitAccelTypes() {
1837 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1838 dwarf::DW_FORM_data4));
1839 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1840 E = CUMap.end(); I != E; ++I) {
1841 CompileUnit *TheCU = I->second;
1842 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelTypes();
1843 for (StringMap<std::vector<DIE*> >::const_iterator
1844 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1845 const char *Name = GI->getKeyData();
1846 std::vector<DIE *> Entities = GI->second;
1847 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1848 DE= Entities.end(); DI !=DE; ++DI)
1849 AT.AddName(Name, (*DI));
1853 AT.FinalizeTable(Asm, "types");
1854 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1855 .getDwarfAccelTypesSection());
1856 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1857 Asm->OutStreamer.EmitLabel(SectionBegin);
1859 // Emit the full data.
1860 AT.Emit(Asm, SectionBegin, this);
1863 void DwarfDebug::emitDebugPubTypes() {
1864 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1865 E = CUMap.end(); I != E; ++I) {
1866 CompileUnit *TheCU = I->second;
1867 // Start the dwarf pubtypes section.
1868 Asm->OutStreamer.SwitchSection(
1869 Asm->getObjFileLowering().getDwarfPubTypesSection());
1870 Asm->OutStreamer.AddComment("Length of Public Types Info");
1871 Asm->EmitLabelDifference(
1872 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1873 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1875 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1878 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1879 Asm->EmitInt16(dwarf::DWARF_VERSION);
1881 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1882 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1883 DwarfInfoSectionSym);
1885 Asm->OutStreamer.AddComment("Compilation Unit Length");
1886 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1887 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1890 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1891 for (StringMap<DIE*>::const_iterator
1892 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1893 const char *Name = GI->getKeyData();
1894 DIE *Entity = GI->second;
1896 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1897 Asm->EmitInt32(Entity->getOffset());
1899 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1900 // Emit the name with a terminating null byte.
1901 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1904 Asm->OutStreamer.AddComment("End Mark");
1906 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1911 /// emitDebugStr - Emit visible names into a debug str section.
1913 void DwarfDebug::emitDebugStr() {
1914 // Check to see if it is worth the effort.
1915 if (StringPool.empty()) return;
1917 // Start the dwarf str section.
1918 Asm->OutStreamer.SwitchSection(
1919 Asm->getObjFileLowering().getDwarfStrSection());
1921 // Get all of the string pool entries and put them in an array by their ID so
1922 // we can sort them.
1923 SmallVector<std::pair<unsigned,
1924 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1926 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1927 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1928 Entries.push_back(std::make_pair(I->second.second, &*I));
1930 array_pod_sort(Entries.begin(), Entries.end());
1932 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1933 // Emit a label for reference from debug information entries.
1934 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1936 // Emit the string itself with a terminating null byte.
1937 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1938 Entries[i].second->getKeyLength()+1),
1943 /// emitDebugLoc - Emit visible names into a debug loc section.
1945 void DwarfDebug::emitDebugLoc() {
1946 if (DotDebugLocEntries.empty())
1949 for (SmallVector<DotDebugLocEntry, 4>::iterator
1950 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1952 DotDebugLocEntry &Entry = *I;
1953 if (I + 1 != DotDebugLocEntries.end())
1957 // Start the dwarf loc section.
1958 Asm->OutStreamer.SwitchSection(
1959 Asm->getObjFileLowering().getDwarfLocSection());
1960 unsigned char Size = Asm->getTargetData().getPointerSize();
1961 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1963 for (SmallVector<DotDebugLocEntry, 4>::iterator
1964 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1965 I != E; ++I, ++index) {
1966 DotDebugLocEntry &Entry = *I;
1967 if (Entry.isMerged()) continue;
1968 if (Entry.isEmpty()) {
1969 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1970 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1971 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1973 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1974 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1975 DIVariable DV(Entry.Variable);
1976 Asm->OutStreamer.AddComment("Loc expr size");
1977 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1978 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1979 Asm->EmitLabelDifference(end, begin, 2);
1980 Asm->OutStreamer.EmitLabel(begin);
1981 if (Entry.isInt()) {
1982 DIBasicType BTy(DV.getType());
1984 (BTy.getEncoding() == dwarf::DW_ATE_signed
1985 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1986 Asm->OutStreamer.AddComment("DW_OP_consts");
1987 Asm->EmitInt8(dwarf::DW_OP_consts);
1988 Asm->EmitSLEB128(Entry.getInt());
1990 Asm->OutStreamer.AddComment("DW_OP_constu");
1991 Asm->EmitInt8(dwarf::DW_OP_constu);
1992 Asm->EmitULEB128(Entry.getInt());
1994 } else if (Entry.isLocation()) {
1995 if (!DV.hasComplexAddress())
1997 Asm->EmitDwarfRegOp(Entry.Loc);
1999 // Complex address entry.
2000 unsigned N = DV.getNumAddrElements();
2002 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2003 if (Entry.Loc.getOffset()) {
2005 Asm->EmitDwarfRegOp(Entry.Loc);
2006 Asm->OutStreamer.AddComment("DW_OP_deref");
2007 Asm->EmitInt8(dwarf::DW_OP_deref);
2008 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2009 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2010 Asm->EmitSLEB128(DV.getAddrElement(1));
2012 // If first address element is OpPlus then emit
2013 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2014 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2015 Asm->EmitDwarfRegOp(Loc);
2019 Asm->EmitDwarfRegOp(Entry.Loc);
2022 // Emit remaining complex address elements.
2023 for (; i < N; ++i) {
2024 uint64_t Element = DV.getAddrElement(i);
2025 if (Element == DIBuilder::OpPlus) {
2026 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2027 Asm->EmitULEB128(DV.getAddrElement(++i));
2028 } else if (Element == DIBuilder::OpDeref)
2029 Asm->EmitInt8(dwarf::DW_OP_deref);
2030 else llvm_unreachable("unknown Opcode found in complex address");
2034 // else ... ignore constant fp. There is not any good way to
2035 // to represent them here in dwarf.
2036 Asm->OutStreamer.EmitLabel(end);
2041 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2043 void DwarfDebug::EmitDebugARanges() {
2044 // Start the dwarf aranges section.
2045 Asm->OutStreamer.SwitchSection(
2046 Asm->getObjFileLowering().getDwarfARangesSection());
2049 /// emitDebugRanges - Emit visible names into a debug ranges section.
2051 void DwarfDebug::emitDebugRanges() {
2052 // Start the dwarf ranges section.
2053 Asm->OutStreamer.SwitchSection(
2054 Asm->getObjFileLowering().getDwarfRangesSection());
2055 unsigned char Size = Asm->getTargetData().getPointerSize();
2056 for (SmallVector<const MCSymbol *, 8>::iterator
2057 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2060 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2062 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2066 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2068 void DwarfDebug::emitDebugMacInfo() {
2069 if (const MCSection *LineInfo =
2070 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2071 // Start the dwarf macinfo section.
2072 Asm->OutStreamer.SwitchSection(LineInfo);
2076 /// emitDebugInlineInfo - Emit inline info using following format.
2078 /// 1. length of section
2079 /// 2. Dwarf version number
2080 /// 3. address size.
2082 /// Entries (one "entry" for each function that was inlined):
2084 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2085 /// otherwise offset into __debug_str for regular function name.
2086 /// 2. offset into __debug_str section for regular function name.
2087 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2088 /// instances for the function.
2090 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2091 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2092 /// __debug_info section, and the low_pc is the starting address for the
2093 /// inlining instance.
2094 void DwarfDebug::emitDebugInlineInfo() {
2095 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2101 Asm->OutStreamer.SwitchSection(
2102 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2104 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2105 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2106 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2108 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2110 Asm->OutStreamer.AddComment("Dwarf Version");
2111 Asm->EmitInt16(dwarf::DWARF_VERSION);
2112 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2113 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2115 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2116 E = InlinedSPNodes.end(); I != E; ++I) {
2118 const MDNode *Node = *I;
2119 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2120 = InlineInfo.find(Node);
2121 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2122 DISubprogram SP(Node);
2123 StringRef LName = SP.getLinkageName();
2124 StringRef Name = SP.getName();
2126 Asm->OutStreamer.AddComment("MIPS linkage name");
2127 if (LName.empty()) {
2128 Asm->OutStreamer.EmitBytes(Name, 0);
2129 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2131 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2132 DwarfStrSectionSym);
2134 Asm->OutStreamer.AddComment("Function name");
2135 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2136 Asm->EmitULEB128(Labels.size(), "Inline count");
2138 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2139 LE = Labels.end(); LI != LE; ++LI) {
2140 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2141 Asm->EmitInt32(LI->second->getOffset());
2143 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2144 Asm->OutStreamer.EmitSymbolValue(LI->first,
2145 Asm->getTargetData().getPointerSize(),0);
2149 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));