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);
775 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
776 AE = AbstractSPDies.end(); AI != AE; ++AI) {
777 DIE *ISP = AI->second;
778 if (InlinedSubprogramDIEs.count(ISP))
780 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
783 // Emit DW_AT_containing_type attribute to connect types with their
784 // vtable holding type.
785 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
786 CUE = CUMap.end(); CUI != CUE; ++CUI) {
787 CompileUnit *TheCU = CUI->second;
788 TheCU->constructContainingTypeDIEs();
791 // Standard sections final addresses.
792 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
793 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
794 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
795 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
797 // End text sections.
798 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
799 Asm->OutStreamer.SwitchSection(SectionMap[i]);
800 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
803 // Compute DIE offsets and sizes.
804 computeSizeAndOffsets();
806 // Emit all the DIEs into a debug info section
809 // Corresponding abbreviations into a abbrev section.
812 // Emit info into a dwarf accelerator table sections.
813 if (DwarfAccelTables) {
816 emitAccelNamespaces();
820 // Emit info into a debug pubtypes section.
823 // Emit info into a debug loc section.
826 // Emit info into a debug aranges section.
829 // Emit info into a debug ranges section.
832 // Emit info into a debug macinfo section.
836 emitDebugInlineInfo();
838 // Emit info into a debug str section.
842 DeleteContainerSeconds(DeadFnScopeMap);
844 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
845 E = CUMap.end(); I != E; ++I)
847 FirstCU = NULL; // Reset for the next Module, if any.
850 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
851 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
853 LLVMContext &Ctx = DV->getContext();
854 // More then one inlined variable corresponds to one abstract variable.
855 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
856 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
858 return AbsDbgVariable;
860 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
864 AbsDbgVariable = new DbgVariable(Var, NULL);
865 addScopeVariable(Scope, AbsDbgVariable);
866 AbstractVariables[Var] = AbsDbgVariable;
867 return AbsDbgVariable;
870 /// addCurrentFnArgument - If Var is a current function argument then add
871 /// it to CurrentFnArguments list.
872 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
873 DbgVariable *Var, LexicalScope *Scope) {
874 if (!LScopes.isCurrentFunctionScope(Scope))
876 DIVariable DV = Var->getVariable();
877 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
879 unsigned ArgNo = DV.getArgNumber();
883 size_t Size = CurrentFnArguments.size();
885 CurrentFnArguments.resize(MF->getFunction()->arg_size());
886 // llvm::Function argument size is not good indicator of how many
887 // arguments does the function have at source level.
889 CurrentFnArguments.resize(ArgNo * 2);
890 CurrentFnArguments[ArgNo - 1] = Var;
894 /// collectVariableInfoFromMMITable - Collect variable information from
895 /// side table maintained by MMI.
897 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
898 SmallPtrSet<const MDNode *, 16> &Processed) {
899 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
900 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
901 VE = VMap.end(); VI != VE; ++VI) {
902 const MDNode *Var = VI->first;
904 Processed.insert(Var);
906 const std::pair<unsigned, DebugLoc> &VP = VI->second;
908 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
910 // If variable scope is not found then skip this variable.
914 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
915 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
916 RegVar->setFrameIndex(VP.first);
917 if (!addCurrentFnArgument(MF, RegVar, Scope))
918 addScopeVariable(Scope, RegVar);
920 AbsDbgVariable->setFrameIndex(VP.first);
924 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
925 /// DBG_VALUE instruction, is in a defined reg.
926 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
927 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
928 return MI->getNumOperands() == 3 &&
929 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
930 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
933 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
935 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
936 const MCSymbol *FLabel,
937 const MCSymbol *SLabel,
938 const MachineInstr *MI) {
939 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
941 if (MI->getNumOperands() != 3) {
942 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
943 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
945 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
946 MachineLocation MLoc;
947 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
948 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
950 if (MI->getOperand(0).isImm())
951 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
952 if (MI->getOperand(0).isFPImm())
953 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
954 if (MI->getOperand(0).isCImm())
955 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
957 assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
958 return DotDebugLocEntry();
961 /// collectVariableInfo - Find variables for each lexical scope.
963 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
964 SmallPtrSet<const MDNode *, 16> &Processed) {
966 /// collection info from MMI table.
967 collectVariableInfoFromMMITable(MF, Processed);
969 for (SmallVectorImpl<const MDNode*>::const_iterator
970 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
972 const MDNode *Var = *UVI;
973 if (Processed.count(Var))
976 // History contains relevant DBG_VALUE instructions for Var and instructions
978 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
981 const MachineInstr *MInsn = History.front();
984 LexicalScope *Scope = NULL;
985 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
986 DISubprogram(DV.getContext()).describes(MF->getFunction()))
987 Scope = LScopes.getCurrentFunctionScope();
989 if (DV.getVersion() <= LLVMDebugVersion9)
990 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
992 if (MDNode *IA = DV.getInlinedAt())
993 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
995 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
998 // If variable scope is not found then skip this variable.
1002 Processed.insert(DV);
1003 assert(MInsn->isDebugValue() && "History must begin with debug value");
1004 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1005 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1006 if (!addCurrentFnArgument(MF, RegVar, Scope))
1007 addScopeVariable(Scope, RegVar);
1009 AbsVar->setMInsn(MInsn);
1011 // Simple ranges that are fully coalesced.
1012 if (History.size() <= 1 || (History.size() == 2 &&
1013 MInsn->isIdenticalTo(History.back()))) {
1014 RegVar->setMInsn(MInsn);
1018 // handle multiple DBG_VALUE instructions describing one variable.
1019 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1021 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1022 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1023 const MachineInstr *Begin = *HI;
1024 assert(Begin->isDebugValue() && "Invalid History entry");
1026 // Check if DBG_VALUE is truncating a range.
1027 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1028 && !Begin->getOperand(0).getReg())
1031 // Compute the range for a register location.
1032 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1033 const MCSymbol *SLabel = 0;
1036 // If Begin is the last instruction in History then its value is valid
1037 // until the end of the function.
1038 SLabel = FunctionEndSym;
1040 const MachineInstr *End = HI[1];
1041 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1042 << "\t" << *Begin << "\t" << *End << "\n");
1043 if (End->isDebugValue())
1044 SLabel = getLabelBeforeInsn(End);
1046 // End is a normal instruction clobbering the range.
1047 SLabel = getLabelAfterInsn(End);
1048 assert(SLabel && "Forgot label after clobber instruction");
1053 // The value is valid until the next DBG_VALUE or clobber.
1054 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1056 DotDebugLocEntries.push_back(DotDebugLocEntry());
1059 // Collect info for variables that were optimized out.
1060 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1061 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1062 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1063 DIVariable DV(Variables.getElement(i));
1064 if (!DV || !DV.Verify() || !Processed.insert(DV))
1066 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1067 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1071 /// getLabelBeforeInsn - Return Label preceding the instruction.
1072 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1073 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1074 assert(Label && "Didn't insert label before instruction");
1078 /// getLabelAfterInsn - Return Label immediately following the instruction.
1079 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1080 return LabelsAfterInsn.lookup(MI);
1083 /// beginInstruction - Process beginning of an instruction.
1084 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1085 // Check if source location changes, but ignore DBG_VALUE locations.
1086 if (!MI->isDebugValue()) {
1087 DebugLoc DL = MI->getDebugLoc();
1088 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1089 unsigned Flags = DWARF2_FLAG_IS_STMT;
1091 if (DL == PrologEndLoc) {
1092 Flags |= DWARF2_FLAG_PROLOGUE_END;
1093 PrologEndLoc = DebugLoc();
1095 if (!DL.isUnknown()) {
1096 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1097 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1099 recordSourceLine(0, 0, 0, 0);
1103 // Insert labels where requested.
1104 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1105 LabelsBeforeInsn.find(MI);
1108 if (I == LabelsBeforeInsn.end())
1111 // Label already assigned.
1116 PrevLabel = MMI->getContext().CreateTempSymbol();
1117 Asm->OutStreamer.EmitLabel(PrevLabel);
1119 I->second = PrevLabel;
1122 /// endInstruction - Process end of an instruction.
1123 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1124 // Don't create a new label after DBG_VALUE instructions.
1125 // They don't generate code.
1126 if (!MI->isDebugValue())
1129 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1130 LabelsAfterInsn.find(MI);
1133 if (I == LabelsAfterInsn.end())
1136 // Label already assigned.
1140 // We need a label after this instruction.
1142 PrevLabel = MMI->getContext().CreateTempSymbol();
1143 Asm->OutStreamer.EmitLabel(PrevLabel);
1145 I->second = PrevLabel;
1148 /// identifyScopeMarkers() -
1149 /// Each LexicalScope has first instruction and last instruction to mark
1150 /// beginning and end of a scope respectively. Create an inverse map that list
1151 /// scopes starts (and ends) with an instruction. One instruction may start (or
1152 /// end) multiple scopes. Ignore scopes that are not reachable.
1153 void DwarfDebug::identifyScopeMarkers() {
1154 SmallVector<LexicalScope *, 4> WorkList;
1155 WorkList.push_back(LScopes.getCurrentFunctionScope());
1156 while (!WorkList.empty()) {
1157 LexicalScope *S = WorkList.pop_back_val();
1159 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1160 if (!Children.empty())
1161 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1162 SE = Children.end(); SI != SE; ++SI)
1163 WorkList.push_back(*SI);
1165 if (S->isAbstractScope())
1168 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1171 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1172 RE = Ranges.end(); RI != RE; ++RI) {
1173 assert(RI->first && "InsnRange does not have first instruction!");
1174 assert(RI->second && "InsnRange does not have second instruction!");
1175 requestLabelBeforeInsn(RI->first);
1176 requestLabelAfterInsn(RI->second);
1181 /// getScopeNode - Get MDNode for DebugLoc's scope.
1182 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1183 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1184 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1185 return DL.getScope(Ctx);
1188 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1189 /// line number info for the function.
1190 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1191 const MDNode *Scope = getScopeNode(DL, Ctx);
1192 DISubprogram SP = getDISubprogram(Scope);
1194 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1198 /// beginFunction - Gather pre-function debug information. Assumes being
1199 /// emitted immediately after the function entry point.
1200 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1201 if (!MMI->hasDebugInfo()) return;
1202 LScopes.initialize(*MF);
1203 if (LScopes.empty()) return;
1204 identifyScopeMarkers();
1206 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1207 Asm->getFunctionNumber());
1208 // Assumes in correct section after the entry point.
1209 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1211 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1213 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1214 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1215 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1217 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1219 bool AtBlockEntry = true;
1220 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1222 const MachineInstr *MI = II;
1224 if (MI->isDebugValue()) {
1225 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1227 // Keep track of user variables.
1229 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1231 // Variable is in a register, we need to check for clobbers.
1232 if (isDbgValueInDefinedReg(MI))
1233 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1235 // Check the history of this variable.
1236 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1237 if (History.empty()) {
1238 UserVariables.push_back(Var);
1239 // The first mention of a function argument gets the FunctionBeginSym
1240 // label, so arguments are visible when breaking at function entry.
1242 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1243 DISubprogram(getDISubprogram(DV.getContext()))
1244 .describes(MF->getFunction()))
1245 LabelsBeforeInsn[MI] = FunctionBeginSym;
1247 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1248 const MachineInstr *Prev = History.back();
1249 if (Prev->isDebugValue()) {
1250 // Coalesce identical entries at the end of History.
1251 if (History.size() >= 2 &&
1252 Prev->isIdenticalTo(History[History.size() - 2])) {
1253 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1255 << "\t" << *History[History.size() - 2] << "\n");
1259 // Terminate old register assignments that don't reach MI;
1260 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1261 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1262 isDbgValueInDefinedReg(Prev)) {
1263 // Previous register assignment needs to terminate at the end of
1265 MachineBasicBlock::const_iterator LastMI =
1266 PrevMBB->getLastNonDebugInstr();
1267 if (LastMI == PrevMBB->end()) {
1268 // Drop DBG_VALUE for empty range.
1269 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1270 << "\t" << *Prev << "\n");
1274 // Terminate after LastMI.
1275 History.push_back(LastMI);
1280 History.push_back(MI);
1282 // Not a DBG_VALUE instruction.
1284 AtBlockEntry = false;
1286 // First known non DBG_VALUE location marks beginning of function
1288 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1289 PrologEndLoc = MI->getDebugLoc();
1291 // Check if the instruction clobbers any registers with debug vars.
1292 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1293 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1294 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1296 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1297 unsigned Reg = *AI; ++AI) {
1298 const MDNode *Var = LiveUserVar[Reg];
1301 // Reg is now clobbered.
1302 LiveUserVar[Reg] = 0;
1304 // Was MD last defined by a DBG_VALUE referring to Reg?
1305 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1306 if (HistI == DbgValues.end())
1308 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1309 if (History.empty())
1311 const MachineInstr *Prev = History.back();
1312 // Sanity-check: Register assignments are terminated at the end of
1314 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1316 // Is the variable still in Reg?
1317 if (!isDbgValueInDefinedReg(Prev) ||
1318 Prev->getOperand(0).getReg() != Reg)
1320 // Var is clobbered. Make sure the next instruction gets a label.
1321 History.push_back(MI);
1328 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1330 SmallVectorImpl<const MachineInstr*> &History = I->second;
1331 if (History.empty())
1334 // Make sure the final register assignments are terminated.
1335 const MachineInstr *Prev = History.back();
1336 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1337 const MachineBasicBlock *PrevMBB = Prev->getParent();
1338 MachineBasicBlock::const_iterator LastMI =
1339 PrevMBB->getLastNonDebugInstr();
1340 if (LastMI == PrevMBB->end())
1341 // Drop DBG_VALUE for empty range.
1344 // Terminate after LastMI.
1345 History.push_back(LastMI);
1348 // Request labels for the full history.
1349 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1350 const MachineInstr *MI = History[i];
1351 if (MI->isDebugValue())
1352 requestLabelBeforeInsn(MI);
1354 requestLabelAfterInsn(MI);
1358 PrevInstLoc = DebugLoc();
1359 PrevLabel = FunctionBeginSym;
1361 // Record beginning of function.
1362 if (!PrologEndLoc.isUnknown()) {
1363 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1364 MF->getFunction()->getContext());
1365 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1366 FnStartDL.getScope(MF->getFunction()->getContext()),
1367 DWARF2_FLAG_IS_STMT);
1371 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1372 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1373 ScopeVariables[LS].push_back(Var);
1374 // Vars.push_back(Var);
1377 /// endFunction - Gather and emit post-function debug information.
1379 void DwarfDebug::endFunction(const MachineFunction *MF) {
1380 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1382 // Define end label for subprogram.
1383 FunctionEndSym = Asm->GetTempSymbol("func_end",
1384 Asm->getFunctionNumber());
1385 // Assumes in correct section after the entry point.
1386 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1388 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1389 collectVariableInfo(MF, ProcessedVars);
1391 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1392 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1393 assert(TheCU && "Unable to find compile unit!");
1395 // Construct abstract scopes.
1396 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1397 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1398 LexicalScope *AScope = AList[i];
1399 DISubprogram SP(AScope->getScopeNode());
1401 // Collect info for variables that were optimized out.
1402 DIArray Variables = SP.getVariables();
1403 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1404 DIVariable DV(Variables.getElement(i));
1405 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1407 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1408 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1411 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1412 constructScopeDIE(TheCU, AScope);
1415 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1417 if (!DisableFramePointerElim(*MF))
1418 TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1419 dwarf::DW_FORM_flag, 1);
1421 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1422 MMI->getFrameMoves()));
1425 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1426 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1427 DeleteContainerPointers(I->second);
1428 ScopeVariables.clear();
1429 DeleteContainerPointers(CurrentFnArguments);
1430 UserVariables.clear();
1432 AbstractVariables.clear();
1433 LabelsBeforeInsn.clear();
1434 LabelsAfterInsn.clear();
1438 /// recordSourceLine - Register a source line with debug info. Returns the
1439 /// unique label that was emitted and which provides correspondence to
1440 /// the source line list.
1441 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1447 DIDescriptor Scope(S);
1449 if (Scope.isCompileUnit()) {
1450 DICompileUnit CU(S);
1451 Fn = CU.getFilename();
1452 Dir = CU.getDirectory();
1453 } else if (Scope.isFile()) {
1455 Fn = F.getFilename();
1456 Dir = F.getDirectory();
1457 } else if (Scope.isSubprogram()) {
1459 Fn = SP.getFilename();
1460 Dir = SP.getDirectory();
1461 } else if (Scope.isLexicalBlockFile()) {
1462 DILexicalBlockFile DBF(S);
1463 Fn = DBF.getFilename();
1464 Dir = DBF.getDirectory();
1465 } else if (Scope.isLexicalBlock()) {
1466 DILexicalBlock DB(S);
1467 Fn = DB.getFilename();
1468 Dir = DB.getDirectory();
1470 assert(0 && "Unexpected scope info");
1472 Src = GetOrCreateSourceID(Fn, Dir);
1474 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1477 //===----------------------------------------------------------------------===//
1479 //===----------------------------------------------------------------------===//
1481 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1484 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1485 // Get the children.
1486 const std::vector<DIE *> &Children = Die->getChildren();
1488 // If not last sibling and has children then add sibling offset attribute.
1489 if (!Last && !Children.empty())
1490 Die->addSiblingOffset(DIEValueAllocator);
1492 // Record the abbreviation.
1493 assignAbbrevNumber(Die->getAbbrev());
1495 // Get the abbreviation for this DIE.
1496 unsigned AbbrevNumber = Die->getAbbrevNumber();
1497 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1500 Die->setOffset(Offset);
1502 // Start the size with the size of abbreviation code.
1503 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1505 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1506 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1508 // Size the DIE attribute values.
1509 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1510 // Size attribute value.
1511 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1513 // Size the DIE children if any.
1514 if (!Children.empty()) {
1515 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1516 "Children flag not set");
1518 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1519 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1521 // End of children marker.
1522 Offset += sizeof(int8_t);
1525 Die->setSize(Offset - Die->getOffset());
1529 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1531 void DwarfDebug::computeSizeAndOffsets() {
1532 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1533 E = CUMap.end(); I != E; ++I) {
1534 // Compute size of compile unit header.
1536 sizeof(int32_t) + // Length of Compilation Unit Info
1537 sizeof(int16_t) + // DWARF version number
1538 sizeof(int32_t) + // Offset Into Abbrev. Section
1539 sizeof(int8_t); // Pointer Size (in bytes)
1540 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1544 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1545 /// the start of each one.
1546 void DwarfDebug::EmitSectionLabels() {
1547 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1549 // Dwarf sections base addresses.
1550 DwarfInfoSectionSym =
1551 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1552 DwarfAbbrevSectionSym =
1553 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1554 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1556 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1557 EmitSectionSym(Asm, MacroInfo);
1559 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1560 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1561 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1562 DwarfStrSectionSym =
1563 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1564 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1567 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1568 "section_debug_loc");
1570 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1571 EmitSectionSym(Asm, TLOF.getDataSection());
1574 /// emitDIE - Recursively emits a debug information entry.
1576 void DwarfDebug::emitDIE(DIE *Die) {
1577 // Get the abbreviation for this DIE.
1578 unsigned AbbrevNumber = Die->getAbbrevNumber();
1579 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1581 // Emit the code (index) for the abbreviation.
1582 if (Asm->isVerbose())
1583 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1584 Twine::utohexstr(Die->getOffset()) + ":0x" +
1585 Twine::utohexstr(Die->getSize()) + " " +
1586 dwarf::TagString(Abbrev->getTag()));
1587 Asm->EmitULEB128(AbbrevNumber);
1589 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1590 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1592 // Emit the DIE attribute values.
1593 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1594 unsigned Attr = AbbrevData[i].getAttribute();
1595 unsigned Form = AbbrevData[i].getForm();
1596 assert(Form && "Too many attributes for DIE (check abbreviation)");
1598 if (Asm->isVerbose())
1599 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1602 case dwarf::DW_AT_sibling:
1603 Asm->EmitInt32(Die->getSiblingOffset());
1605 case dwarf::DW_AT_abstract_origin: {
1606 DIEEntry *E = cast<DIEEntry>(Values[i]);
1607 DIE *Origin = E->getEntry();
1608 unsigned Addr = Origin->getOffset();
1609 Asm->EmitInt32(Addr);
1612 case dwarf::DW_AT_ranges: {
1613 // DW_AT_range Value encodes offset in debug_range section.
1614 DIEInteger *V = cast<DIEInteger>(Values[i]);
1616 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1617 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1621 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1623 DwarfDebugRangeSectionSym,
1628 case dwarf::DW_AT_location: {
1629 if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1630 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1632 Values[i]->EmitValue(Asm, Form);
1635 case dwarf::DW_AT_accessibility: {
1636 if (Asm->isVerbose()) {
1637 DIEInteger *V = cast<DIEInteger>(Values[i]);
1638 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1640 Values[i]->EmitValue(Asm, Form);
1644 // Emit an attribute using the defined form.
1645 Values[i]->EmitValue(Asm, Form);
1650 // Emit the DIE children if any.
1651 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1652 const std::vector<DIE *> &Children = Die->getChildren();
1654 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1655 emitDIE(Children[j]);
1657 if (Asm->isVerbose())
1658 Asm->OutStreamer.AddComment("End Of Children Mark");
1663 /// emitDebugInfo - Emit the debug info section.
1665 void DwarfDebug::emitDebugInfo() {
1666 // Start debug info section.
1667 Asm->OutStreamer.SwitchSection(
1668 Asm->getObjFileLowering().getDwarfInfoSection());
1669 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1670 E = CUMap.end(); I != E; ++I) {
1671 CompileUnit *TheCU = I->second;
1672 DIE *Die = TheCU->getCUDie();
1674 // Emit the compile units header.
1675 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1678 // Emit size of content not including length itself
1679 unsigned ContentSize = Die->getSize() +
1680 sizeof(int16_t) + // DWARF version number
1681 sizeof(int32_t) + // Offset Into Abbrev. Section
1682 sizeof(int8_t); // Pointer Size (in bytes)
1684 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1685 Asm->EmitInt32(ContentSize);
1686 Asm->OutStreamer.AddComment("DWARF version number");
1687 Asm->EmitInt16(dwarf::DWARF_VERSION);
1688 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1689 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1690 DwarfAbbrevSectionSym);
1691 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1692 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1695 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1699 /// emitAbbreviations - Emit the abbreviation section.
1701 void DwarfDebug::emitAbbreviations() const {
1702 // Check to see if it is worth the effort.
1703 if (!Abbreviations.empty()) {
1704 // Start the debug abbrev section.
1705 Asm->OutStreamer.SwitchSection(
1706 Asm->getObjFileLowering().getDwarfAbbrevSection());
1708 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1710 // For each abbrevation.
1711 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1712 // Get abbreviation data
1713 const DIEAbbrev *Abbrev = Abbreviations[i];
1715 // Emit the abbrevations code (base 1 index.)
1716 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1718 // Emit the abbreviations data.
1722 // Mark end of abbreviations.
1723 Asm->EmitULEB128(0, "EOM(3)");
1725 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1729 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1730 /// the line matrix.
1732 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1733 // Define last address of section.
1734 Asm->OutStreamer.AddComment("Extended Op");
1737 Asm->OutStreamer.AddComment("Op size");
1738 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1739 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1740 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1742 Asm->OutStreamer.AddComment("Section end label");
1744 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1745 Asm->getTargetData().getPointerSize(),
1748 // Mark end of matrix.
1749 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1755 /// emitAccelNames - Emit visible names into a hashed accelerator table
1757 void DwarfDebug::emitAccelNames() {
1758 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1759 dwarf::DW_FORM_data4));
1760 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1761 E = CUMap.end(); I != E; ++I) {
1762 CompileUnit *TheCU = I->second;
1763 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1764 for (StringMap<std::vector<DIE*> >::const_iterator
1765 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1766 const char *Name = GI->getKeyData();
1767 std::vector<DIE *> Entities = GI->second;
1768 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1769 DE = Entities.end(); DI != DE; ++DI)
1770 AT.AddName(Name, (*DI));
1774 AT.FinalizeTable(Asm, "Names");
1775 Asm->OutStreamer.SwitchSection(
1776 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1777 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1778 Asm->OutStreamer.EmitLabel(SectionBegin);
1780 // Emit the full data.
1781 AT.Emit(Asm, SectionBegin, this);
1784 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1785 /// accelerator table section.
1786 void DwarfDebug::emitAccelObjC() {
1787 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1788 dwarf::DW_FORM_data4));
1789 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1790 E = CUMap.end(); I != E; ++I) {
1791 CompileUnit *TheCU = I->second;
1792 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1793 for (StringMap<std::vector<DIE*> >::const_iterator
1794 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1795 const char *Name = GI->getKeyData();
1796 std::vector<DIE *> Entities = GI->second;
1797 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1798 DE = Entities.end(); DI != DE; ++DI)
1799 AT.AddName(Name, (*DI));
1803 AT.FinalizeTable(Asm, "ObjC");
1804 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1805 .getDwarfAccelObjCSection());
1806 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1807 Asm->OutStreamer.EmitLabel(SectionBegin);
1809 // Emit the full data.
1810 AT.Emit(Asm, SectionBegin, this);
1813 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1815 void DwarfDebug::emitAccelNamespaces() {
1816 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1817 dwarf::DW_FORM_data4));
1818 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1819 E = CUMap.end(); I != E; ++I) {
1820 CompileUnit *TheCU = I->second;
1821 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1822 for (StringMap<std::vector<DIE*> >::const_iterator
1823 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1824 const char *Name = GI->getKeyData();
1825 std::vector<DIE *> Entities = GI->second;
1826 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1827 DE = Entities.end(); DI != DE; ++DI)
1828 AT.AddName(Name, (*DI));
1832 AT.FinalizeTable(Asm, "namespac");
1833 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1834 .getDwarfAccelNamespaceSection());
1835 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1836 Asm->OutStreamer.EmitLabel(SectionBegin);
1838 // Emit the full data.
1839 AT.Emit(Asm, SectionBegin, this);
1842 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1843 void DwarfDebug::emitAccelTypes() {
1844 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1845 dwarf::DW_FORM_data4));
1846 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1847 E = CUMap.end(); I != E; ++I) {
1848 CompileUnit *TheCU = I->second;
1849 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelTypes();
1850 for (StringMap<std::vector<DIE*> >::const_iterator
1851 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1852 const char *Name = GI->getKeyData();
1853 std::vector<DIE *> Entities = GI->second;
1854 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1855 DE= Entities.end(); DI !=DE; ++DI)
1856 AT.AddName(Name, (*DI));
1860 AT.FinalizeTable(Asm, "types");
1861 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1862 .getDwarfAccelTypesSection());
1863 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1864 Asm->OutStreamer.EmitLabel(SectionBegin);
1866 // Emit the full data.
1867 AT.Emit(Asm, SectionBegin, this);
1870 void DwarfDebug::emitDebugPubTypes() {
1871 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1872 E = CUMap.end(); I != E; ++I) {
1873 CompileUnit *TheCU = I->second;
1874 // Start the dwarf pubtypes section.
1875 Asm->OutStreamer.SwitchSection(
1876 Asm->getObjFileLowering().getDwarfPubTypesSection());
1877 Asm->OutStreamer.AddComment("Length of Public Types Info");
1878 Asm->EmitLabelDifference(
1879 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1880 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1882 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1885 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1886 Asm->EmitInt16(dwarf::DWARF_VERSION);
1888 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1889 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1890 DwarfInfoSectionSym);
1892 Asm->OutStreamer.AddComment("Compilation Unit Length");
1893 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1894 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1897 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1898 for (StringMap<DIE*>::const_iterator
1899 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1900 const char *Name = GI->getKeyData();
1901 DIE *Entity = GI->second;
1903 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1904 Asm->EmitInt32(Entity->getOffset());
1906 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1907 // Emit the name with a terminating null byte.
1908 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1911 Asm->OutStreamer.AddComment("End Mark");
1913 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1918 /// emitDebugStr - Emit visible names into a debug str section.
1920 void DwarfDebug::emitDebugStr() {
1921 // Check to see if it is worth the effort.
1922 if (StringPool.empty()) return;
1924 // Start the dwarf str section.
1925 Asm->OutStreamer.SwitchSection(
1926 Asm->getObjFileLowering().getDwarfStrSection());
1928 // Get all of the string pool entries and put them in an array by their ID so
1929 // we can sort them.
1930 SmallVector<std::pair<unsigned,
1931 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1933 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1934 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1935 Entries.push_back(std::make_pair(I->second.second, &*I));
1937 array_pod_sort(Entries.begin(), Entries.end());
1939 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1940 // Emit a label for reference from debug information entries.
1941 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1943 // Emit the string itself with a terminating null byte.
1944 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1945 Entries[i].second->getKeyLength()+1),
1950 /// emitDebugLoc - Emit visible names into a debug loc section.
1952 void DwarfDebug::emitDebugLoc() {
1953 if (DotDebugLocEntries.empty())
1956 for (SmallVector<DotDebugLocEntry, 4>::iterator
1957 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1959 DotDebugLocEntry &Entry = *I;
1960 if (I + 1 != DotDebugLocEntries.end())
1964 // Start the dwarf loc section.
1965 Asm->OutStreamer.SwitchSection(
1966 Asm->getObjFileLowering().getDwarfLocSection());
1967 unsigned char Size = Asm->getTargetData().getPointerSize();
1968 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1970 for (SmallVector<DotDebugLocEntry, 4>::iterator
1971 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1972 I != E; ++I, ++index) {
1973 DotDebugLocEntry &Entry = *I;
1974 if (Entry.isMerged()) continue;
1975 if (Entry.isEmpty()) {
1976 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1977 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1978 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1980 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1981 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1982 DIVariable DV(Entry.Variable);
1983 Asm->OutStreamer.AddComment("Loc expr size");
1984 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1985 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1986 Asm->EmitLabelDifference(end, begin, 2);
1987 Asm->OutStreamer.EmitLabel(begin);
1988 if (Entry.isInt()) {
1989 DIBasicType BTy(DV.getType());
1991 (BTy.getEncoding() == dwarf::DW_ATE_signed
1992 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1993 Asm->OutStreamer.AddComment("DW_OP_consts");
1994 Asm->EmitInt8(dwarf::DW_OP_consts);
1995 Asm->EmitSLEB128(Entry.getInt());
1997 Asm->OutStreamer.AddComment("DW_OP_constu");
1998 Asm->EmitInt8(dwarf::DW_OP_constu);
1999 Asm->EmitULEB128(Entry.getInt());
2001 } else if (Entry.isLocation()) {
2002 if (!DV.hasComplexAddress())
2004 Asm->EmitDwarfRegOp(Entry.Loc);
2006 // Complex address entry.
2007 unsigned N = DV.getNumAddrElements();
2009 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2010 if (Entry.Loc.getOffset()) {
2012 Asm->EmitDwarfRegOp(Entry.Loc);
2013 Asm->OutStreamer.AddComment("DW_OP_deref");
2014 Asm->EmitInt8(dwarf::DW_OP_deref);
2015 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2016 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2017 Asm->EmitSLEB128(DV.getAddrElement(1));
2019 // If first address element is OpPlus then emit
2020 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2021 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2022 Asm->EmitDwarfRegOp(Loc);
2026 Asm->EmitDwarfRegOp(Entry.Loc);
2029 // Emit remaining complex address elements.
2030 for (; i < N; ++i) {
2031 uint64_t Element = DV.getAddrElement(i);
2032 if (Element == DIBuilder::OpPlus) {
2033 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2034 Asm->EmitULEB128(DV.getAddrElement(++i));
2035 } else if (Element == DIBuilder::OpDeref)
2036 Asm->EmitInt8(dwarf::DW_OP_deref);
2037 else llvm_unreachable("unknown Opcode found in complex address");
2041 // else ... ignore constant fp. There is not any good way to
2042 // to represent them here in dwarf.
2043 Asm->OutStreamer.EmitLabel(end);
2048 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2050 void DwarfDebug::EmitDebugARanges() {
2051 // Start the dwarf aranges section.
2052 Asm->OutStreamer.SwitchSection(
2053 Asm->getObjFileLowering().getDwarfARangesSection());
2056 /// emitDebugRanges - Emit visible names into a debug ranges section.
2058 void DwarfDebug::emitDebugRanges() {
2059 // Start the dwarf ranges section.
2060 Asm->OutStreamer.SwitchSection(
2061 Asm->getObjFileLowering().getDwarfRangesSection());
2062 unsigned char Size = Asm->getTargetData().getPointerSize();
2063 for (SmallVector<const MCSymbol *, 8>::iterator
2064 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2067 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2069 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2073 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2075 void DwarfDebug::emitDebugMacInfo() {
2076 if (const MCSection *LineInfo =
2077 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2078 // Start the dwarf macinfo section.
2079 Asm->OutStreamer.SwitchSection(LineInfo);
2083 /// emitDebugInlineInfo - Emit inline info using following format.
2085 /// 1. length of section
2086 /// 2. Dwarf version number
2087 /// 3. address size.
2089 /// Entries (one "entry" for each function that was inlined):
2091 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2092 /// otherwise offset into __debug_str for regular function name.
2093 /// 2. offset into __debug_str section for regular function name.
2094 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2095 /// instances for the function.
2097 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2098 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2099 /// __debug_info section, and the low_pc is the starting address for the
2100 /// inlining instance.
2101 void DwarfDebug::emitDebugInlineInfo() {
2102 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2108 Asm->OutStreamer.SwitchSection(
2109 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2111 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2112 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2113 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2115 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2117 Asm->OutStreamer.AddComment("Dwarf Version");
2118 Asm->EmitInt16(dwarf::DWARF_VERSION);
2119 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2120 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2122 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2123 E = InlinedSPNodes.end(); I != E; ++I) {
2125 const MDNode *Node = *I;
2126 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2127 = InlineInfo.find(Node);
2128 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2129 DISubprogram SP(Node);
2130 StringRef LName = SP.getLinkageName();
2131 StringRef Name = SP.getName();
2133 Asm->OutStreamer.AddComment("MIPS linkage name");
2134 if (LName.empty()) {
2135 Asm->OutStreamer.EmitBytes(Name, 0);
2136 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2138 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2139 DwarfStrSectionSym);
2141 Asm->OutStreamer.AddComment("Function name");
2142 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2143 Asm->EmitULEB128(Labels.size(), "Inline count");
2145 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2146 LE = Labels.end(); LI != LE; ++LI) {
2147 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2148 Asm->EmitInt32(LI->second->getOffset());
2150 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2151 Asm->OutStreamer.EmitSymbolValue(LI->first,
2152 Asm->getTargetData().getPointerSize(),0);
2156 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));