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/DebugInfo.h"
21 #include "llvm/DIBuilder.h"
22 #include "llvm/Module.h"
23 #include "llvm/Instructions.h"
24 #include "llvm/CodeGen/MachineFunction.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCSection.h"
28 #include "llvm/MC/MCStreamer.h"
29 #include "llvm/MC/MCSymbol.h"
30 #include "llvm/DataLayout.h"
31 #include "llvm/Target/TargetFrameLowering.h"
32 #include "llvm/Target/TargetLoweringObjectFile.h"
33 #include "llvm/Target/TargetMachine.h"
34 #include "llvm/Target/TargetRegisterInfo.h"
35 #include "llvm/Target/TargetOptions.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/ADT/Triple.h"
40 #include "llvm/Support/CommandLine.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/ValueHandle.h"
44 #include "llvm/Support/FormattedStream.h"
45 #include "llvm/Support/Timer.h"
46 #include "llvm/Support/Path.h"
49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
51 cl::desc("Disable debug info printing"));
53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
54 cl::desc("Make an absence of debug location information explicit."),
59 Default, Enable, Disable
63 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
64 cl::desc("Output prototype dwarf accelerator tables."),
66 clEnumVal(Default, "Default for platform"),
67 clEnumVal(Enable, "Enabled"),
68 clEnumVal(Disable, "Disabled"),
72 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
73 cl::desc("Compatibility with Darwin gdb."),
75 clEnumVal(Default, "Default for platform"),
76 clEnumVal(Enable, "Enabled"),
77 clEnumVal(Disable, "Disabled"),
82 const char *DWARFGroupName = "DWARF Emission";
83 const char *DbgTimerName = "DWARF Debug Writer";
84 } // end anonymous namespace
86 //===----------------------------------------------------------------------===//
88 /// Configuration values for initial hash set sizes (log2).
90 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
94 DIType DbgVariable::getType() const {
95 DIType Ty = Var.getType();
96 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
98 if (Var.isBlockByrefVariable()) {
99 /* Byref variables, in Blocks, are declared by the programmer as
100 "SomeType VarName;", but the compiler creates a
101 __Block_byref_x_VarName struct, and gives the variable VarName
102 either the struct, or a pointer to the struct, as its type. This
103 is necessary for various behind-the-scenes things the compiler
104 needs to do with by-reference variables in blocks.
106 However, as far as the original *programmer* is concerned, the
107 variable should still have type 'SomeType', as originally declared.
109 The following function dives into the __Block_byref_x_VarName
110 struct to find the original type of the variable. This will be
111 passed back to the code generating the type for the Debug
112 Information Entry for the variable 'VarName'. 'VarName' will then
113 have the original type 'SomeType' in its debug information.
115 The original type 'SomeType' will be the type of the field named
116 'VarName' inside the __Block_byref_x_VarName struct.
118 NOTE: In order for this to not completely fail on the debugger
119 side, the Debug Information Entry for the variable VarName needs to
120 have a DW_AT_location that tells the debugger how to unwind through
121 the pointers and __Block_byref_x_VarName struct to find the actual
122 value of the variable. The function addBlockByrefType does this. */
124 unsigned tag = Ty.getTag();
126 if (tag == dwarf::DW_TAG_pointer_type) {
127 DIDerivedType DTy = DIDerivedType(Ty);
128 subType = DTy.getTypeDerivedFrom();
131 DICompositeType blockStruct = DICompositeType(subType);
132 DIArray Elements = blockStruct.getTypeArray();
134 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
135 DIDescriptor Element = Elements.getElement(i);
136 DIDerivedType DT = DIDerivedType(Element);
137 if (getName() == DT.getName())
138 return (DT.getTypeDerivedFrom());
144 } // end llvm namespace
146 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
147 : Asm(A), MMI(Asm->MMI), FirstCU(0),
148 AbbreviationsSet(InitAbbreviationsSetSize),
149 SourceIdMap(DIEValueAllocator), StringPool(DIEValueAllocator),
151 NextStringPoolNumber = 0;
153 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
154 DwarfStrSectionSym = TextSectionSym = 0;
155 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
156 FunctionBeginSym = FunctionEndSym = 0;
158 // Turn on accelerator tables and older gdb compatibility
160 bool isDarwin = Triple(M->getTargetTriple()).isOSDarwin();
161 if (DarwinGDBCompat == Default) {
163 isDarwinGDBCompat = true;
165 isDarwinGDBCompat = false;
167 isDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
169 if (DwarfAccelTables == Default) {
171 hasDwarfAccelTables = true;
173 hasDwarfAccelTables = false;
175 hasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
178 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
182 DwarfDebug::~DwarfDebug() {
185 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
186 /// temporary label to it if SymbolStem is specified.
187 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
188 const char *SymbolStem = 0) {
189 Asm->OutStreamer.SwitchSection(Section);
190 if (!SymbolStem) return 0;
192 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
193 Asm->OutStreamer.EmitLabel(TmpSym);
197 MCSymbol *DwarfDebug::getStringPool() {
198 return Asm->GetTempSymbol("section_str");
201 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
202 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
203 if (Entry.first) return Entry.first;
205 Entry.second = NextStringPoolNumber++;
206 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
209 /// assignAbbrevNumber - Define a unique number for the abbreviation.
211 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
212 // Profile the node so that we can make it unique.
216 // Check the set for priors.
217 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
219 // If it's newly added.
220 if (InSet == &Abbrev) {
221 // Add to abbreviation list.
222 Abbreviations.push_back(&Abbrev);
224 // Assign the vector position + 1 as its number.
225 Abbrev.setNumber(Abbreviations.size());
227 // Assign existing abbreviation number.
228 Abbrev.setNumber(InSet->getNumber());
232 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
233 /// printer to not emit usual symbol prefix before the symbol name is used then
234 /// return linkage name after skipping this special LLVM prefix.
235 static StringRef getRealLinkageName(StringRef LinkageName) {
237 if (LinkageName.startswith(StringRef(&One, 1)))
238 return LinkageName.substr(1);
242 static bool isObjCClass(StringRef Name) {
243 return Name.startswith("+") || Name.startswith("-");
246 static bool hasObjCCategory(StringRef Name) {
247 if (!isObjCClass(Name)) return false;
249 size_t pos = Name.find(')');
250 if (pos != std::string::npos) {
251 if (Name[pos+1] != ' ') return false;
257 static void getObjCClassCategory(StringRef In, StringRef &Class,
258 StringRef &Category) {
259 if (!hasObjCCategory(In)) {
260 Class = In.slice(In.find('[') + 1, In.find(' '));
265 Class = In.slice(In.find('[') + 1, In.find('('));
266 Category = In.slice(In.find('[') + 1, In.find(' '));
270 static StringRef getObjCMethodName(StringRef In) {
271 return In.slice(In.find(' ') + 1, In.find(']'));
274 // Add the various names to the Dwarf accelerator table names.
275 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
277 if (!SP.isDefinition()) return;
279 TheCU->addAccelName(SP.getName(), Die);
281 // If the linkage name is different than the name, go ahead and output
282 // that as well into the name table.
283 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
284 TheCU->addAccelName(SP.getLinkageName(), Die);
286 // If this is an Objective-C selector name add it to the ObjC accelerator
288 if (isObjCClass(SP.getName())) {
289 StringRef Class, Category;
290 getObjCClassCategory(SP.getName(), Class, Category);
291 TheCU->addAccelObjC(Class, Die);
293 TheCU->addAccelObjC(Category, Die);
294 // Also add the base method name to the name table.
295 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
299 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
300 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
301 /// If there are global variables in this scope then create and insert
302 /// DIEs for these variables.
303 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
304 const MDNode *SPNode) {
305 DIE *SPDie = SPCU->getDIE(SPNode);
307 assert(SPDie && "Unable to find subprogram DIE!");
308 DISubprogram SP(SPNode);
310 // Pick up abstract subprogram DIE.
311 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
312 SPDie = new DIE(dwarf::DW_TAG_subprogram);
313 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
314 dwarf::DW_FORM_ref4, AbsSPDIE);
317 DISubprogram SPDecl = SP.getFunctionDeclaration();
318 if (!SPDecl.isSubprogram()) {
319 // There is not any need to generate specification DIE for a function
320 // defined at compile unit level. If a function is defined inside another
321 // function then gdb prefers the definition at top level and but does not
322 // expect specification DIE in parent function. So avoid creating
323 // specification DIE for a function defined inside a function.
324 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
325 !SP.getContext().isFile() &&
326 !isSubprogramContext(SP.getContext())) {
327 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
330 DICompositeType SPTy = SP.getType();
331 DIArray Args = SPTy.getTypeArray();
332 unsigned SPTag = SPTy.getTag();
333 if (SPTag == dwarf::DW_TAG_subroutine_type)
334 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
335 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
336 DIType ATy = DIType(Args.getElement(i));
337 SPCU->addType(Arg, ATy);
338 if (ATy.isArtificial())
339 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
340 if (ATy.isObjectPointer())
341 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
342 dwarf::DW_FORM_ref4, Arg);
343 SPDie->addChild(Arg);
345 DIE *SPDeclDie = SPDie;
346 SPDie = new DIE(dwarf::DW_TAG_subprogram);
347 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
354 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
355 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
356 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
357 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
358 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
359 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
360 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
362 // Add name to the name table, we do this here because we're guaranteed
363 // to have concrete versions of our DW_TAG_subprogram nodes.
364 addSubprogramNames(SPCU, SP, SPDie);
369 /// constructLexicalScope - Construct new DW_TAG_lexical_block
370 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
371 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
372 LexicalScope *Scope) {
373 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
374 if (Scope->isAbstractScope())
377 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
381 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
382 if (Ranges.size() > 1) {
383 // .debug_range section has not been laid out yet. Emit offset in
384 // .debug_range as a uint, size 4, for now. emitDIE will handle
385 // DW_AT_ranges appropriately.
386 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
387 DebugRangeSymbols.size()
388 * Asm->getDataLayout().getPointerSize());
389 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
390 RE = Ranges.end(); RI != RE; ++RI) {
391 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
392 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
394 DebugRangeSymbols.push_back(NULL);
395 DebugRangeSymbols.push_back(NULL);
399 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
400 const MCSymbol *End = getLabelAfterInsn(RI->second);
402 if (End == 0) return 0;
404 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
405 assert(End->isDefined() && "Invalid end label for an inlined scope!");
407 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
408 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
413 /// constructInlinedScopeDIE - This scope represents inlined body of
414 /// a function. Construct DIE to represent this concrete inlined copy
416 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
417 LexicalScope *Scope) {
418 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
419 assert(Ranges.empty() == false &&
420 "LexicalScope does not have instruction markers!");
422 if (!Scope->getScopeNode())
424 DIScope DS(Scope->getScopeNode());
425 DISubprogram InlinedSP = getDISubprogram(DS);
426 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
428 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
432 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
433 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
434 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
436 if (StartLabel == 0 || EndLabel == 0) {
437 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
439 assert(StartLabel->isDefined() &&
440 "Invalid starting label for an inlined scope!");
441 assert(EndLabel->isDefined() &&
442 "Invalid end label for an inlined scope!");
444 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
445 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
446 dwarf::DW_FORM_ref4, OriginDIE);
448 if (Ranges.size() > 1) {
449 // .debug_range section has not been laid out yet. Emit offset in
450 // .debug_range as a uint, size 4, for now. emitDIE will handle
451 // DW_AT_ranges appropriately.
452 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
453 DebugRangeSymbols.size()
454 * Asm->getDataLayout().getPointerSize());
455 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
456 RE = Ranges.end(); RI != RE; ++RI) {
457 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
458 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
460 DebugRangeSymbols.push_back(NULL);
461 DebugRangeSymbols.push_back(NULL);
463 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
465 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
469 InlinedSubprogramDIEs.insert(OriginDIE);
471 // Track the start label for this inlined function.
472 //.debug_inlined section specification does not clearly state how
473 // to emit inlined scope that is split into multiple instruction ranges.
474 // For now, use first instruction range and emit low_pc/high_pc pair and
475 // corresponding .debug_inlined section entry for this pair.
476 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
477 I = InlineInfo.find(InlinedSP);
479 if (I == InlineInfo.end()) {
480 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
481 InlinedSPNodes.push_back(InlinedSP);
483 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
485 DILocation DL(Scope->getInlinedAt());
486 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
487 GetOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
488 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
490 // Add name to the name table, we do this here because we're guaranteed
491 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
492 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
497 /// constructScopeDIE - Construct a DIE for this scope.
498 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
499 if (!Scope || !Scope->getScopeNode())
502 SmallVector<DIE *, 8> Children;
503 DIE *ObjectPointer = NULL;
505 // Collect arguments for current function.
506 if (LScopes.isCurrentFunctionScope(Scope))
507 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
508 if (DbgVariable *ArgDV = CurrentFnArguments[i])
510 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
511 Children.push_back(Arg);
512 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
515 // Collect lexical scope children first.
516 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
517 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
519 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
520 Children.push_back(Variable);
521 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
523 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
524 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
525 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
526 Children.push_back(Nested);
527 DIScope DS(Scope->getScopeNode());
528 DIE *ScopeDIE = NULL;
529 if (Scope->getInlinedAt())
530 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
531 else if (DS.isSubprogram()) {
532 ProcessedSPNodes.insert(DS);
533 if (Scope->isAbstractScope()) {
534 ScopeDIE = TheCU->getDIE(DS);
535 // Note down abstract DIE.
537 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
540 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
543 // There is no need to emit empty lexical block DIE.
544 if (Children.empty())
546 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
549 if (!ScopeDIE) return NULL;
552 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
553 E = Children.end(); I != E; ++I)
554 ScopeDIE->addChild(*I);
556 if (DS.isSubprogram() && ObjectPointer != NULL)
557 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
558 dwarf::DW_FORM_ref4, ObjectPointer);
560 if (DS.isSubprogram())
561 TheCU->addPubTypes(DISubprogram(DS));
566 /// GetOrCreateSourceID - Look up the source id with the given directory and
567 /// source file names. If none currently exists, create a new id and insert it
568 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
570 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
572 // If FE did not provide a file name, then assume stdin.
573 if (FileName.empty())
574 return GetOrCreateSourceID("<stdin>", StringRef());
576 // TODO: this might not belong here. See if we can factor this better.
577 if (DirName == CompilationDir)
580 unsigned SrcId = SourceIdMap.size()+1;
582 // We look up the file/dir pair by concatenating them with a zero byte.
583 SmallString<128> NamePair;
585 NamePair += '\0'; // Zero bytes are not allowed in paths.
586 NamePair += FileName;
588 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
589 if (Ent.getValue() != SrcId)
590 return Ent.getValue();
592 // Print out a .file directive to specify files for .loc directives.
593 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
598 /// constructCompileUnit - Create new CompileUnit for the given
599 /// metadata node with tag DW_TAG_compile_unit.
600 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
601 DICompileUnit DIUnit(N);
602 StringRef FN = DIUnit.getFilename();
603 CompilationDir = DIUnit.getDirectory();
604 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
606 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
607 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die,
609 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
610 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
611 DIUnit.getLanguage());
612 NewCU->addString(Die, dwarf::DW_AT_name, FN);
613 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
615 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
616 // DW_AT_stmt_list is a offset of line number information for this
617 // compile unit in debug_line section.
618 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
619 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
620 Asm->GetTempSymbol("section_line"));
622 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
624 if (!CompilationDir.empty())
625 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
626 if (DIUnit.isOptimized())
627 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
629 StringRef Flags = DIUnit.getFlags();
631 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
633 if (unsigned RVer = DIUnit.getRunTimeVersion())
634 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
635 dwarf::DW_FORM_data1, RVer);
639 CUMap.insert(std::make_pair(N, NewCU));
643 /// construct SubprogramDIE - Construct subprogram DIE.
644 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
646 CompileUnit *&CURef = SPMap[N];
652 if (!SP.isDefinition())
653 // This is a method declaration which will be handled while constructing
657 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
660 TheCU->insertDIE(N, SubprogramDie);
662 // Add to context owner.
663 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
668 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
669 /// as llvm.dbg.enum and llvm.dbg.ty
670 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
671 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
672 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
673 const MDNode *N = NMD->getOperand(i);
674 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
675 constructSubprogramDIE(CU, N);
678 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
679 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
680 const MDNode *N = NMD->getOperand(i);
681 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
682 CU->createGlobalVariableDIE(N);
685 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
686 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
687 DIType Ty(NMD->getOperand(i));
688 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
689 CU->getOrCreateTypeDIE(Ty);
692 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
693 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
694 DIType Ty(NMD->getOperand(i));
695 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
696 CU->getOrCreateTypeDIE(Ty);
700 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
701 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
702 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
703 DebugInfoFinder DbgFinder;
704 DbgFinder.processModule(*M);
706 bool HasDebugInfo = false;
707 // Scan all the compile-units to see if there are any marked as the main
708 // unit. If not, we do not generate debug info.
709 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
710 E = DbgFinder.compile_unit_end(); I != E; ++I) {
711 if (DICompileUnit(*I).isMain()) {
716 if (!HasDebugInfo) return false;
718 // Create all the compile unit DIEs.
719 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
720 E = DbgFinder.compile_unit_end(); I != E; ++I)
721 constructCompileUnit(*I);
723 // Create DIEs for each global variable.
724 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
725 E = DbgFinder.global_variable_end(); I != E; ++I) {
726 const MDNode *N = *I;
727 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
728 CU->createGlobalVariableDIE(N);
731 // Create DIEs for each subprogram.
732 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
733 E = DbgFinder.subprogram_end(); I != E; ++I) {
734 const MDNode *N = *I;
735 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
736 constructSubprogramDIE(CU, N);
742 /// beginModule - Emit all Dwarf sections that should come prior to the
743 /// content. Create global DIEs and emit initial debug info sections.
744 /// This is invoked by the target AsmPrinter.
745 void DwarfDebug::beginModule(Module *M) {
746 if (DisableDebugInfoPrinting)
749 // If module has named metadata anchors then use them, otherwise scan the
750 // module using debug info finder to collect debug info.
751 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
753 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
754 DICompileUnit CUNode(CU_Nodes->getOperand(i));
755 CompileUnit *CU = constructCompileUnit(CUNode);
756 DIArray GVs = CUNode.getGlobalVariables();
757 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
758 CU->createGlobalVariableDIE(GVs.getElement(i));
759 DIArray SPs = CUNode.getSubprograms();
760 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
761 constructSubprogramDIE(CU, SPs.getElement(i));
762 DIArray EnumTypes = CUNode.getEnumTypes();
763 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
764 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
765 DIArray RetainedTypes = CUNode.getRetainedTypes();
766 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
767 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
769 } else if (!collectLegacyDebugInfo(M))
772 collectInfoFromNamedMDNodes(M);
774 // Tell MMI that we have debug info.
775 MMI->setDebugInfoAvailability(true);
777 // Emit initial sections.
780 // Prime section data.
781 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
784 /// endModule - Emit all Dwarf sections that should come after the content.
786 void DwarfDebug::endModule() {
787 if (!FirstCU) return;
788 const Module *M = MMI->getModule();
789 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
791 // Collect info for variables that were optimized out.
792 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
793 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
794 DICompileUnit TheCU(CU_Nodes->getOperand(i));
795 DIArray Subprograms = TheCU.getSubprograms();
796 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
797 DISubprogram SP(Subprograms.getElement(i));
798 if (ProcessedSPNodes.count(SP) != 0) continue;
799 if (!SP.Verify()) continue;
800 if (!SP.isDefinition()) continue;
801 DIArray Variables = SP.getVariables();
802 if (Variables.getNumElements() == 0) continue;
804 LexicalScope *Scope =
805 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
806 DeadFnScopeMap[SP] = Scope;
808 // Construct subprogram DIE and add variables DIEs.
809 CompileUnit *SPCU = CUMap.lookup(TheCU);
810 assert(SPCU && "Unable to find Compile Unit!");
811 constructSubprogramDIE(SPCU, SP);
812 DIE *ScopeDIE = SPCU->getDIE(SP);
813 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
814 DIVariable DV(Variables.getElement(vi));
815 if (!DV.Verify()) continue;
816 DbgVariable *NewVar = new DbgVariable(DV, NULL);
817 if (DIE *VariableDIE =
818 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
819 ScopeDIE->addChild(VariableDIE);
825 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
826 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
827 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
829 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
831 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
832 AE = AbstractSPDies.end(); AI != AE; ++AI) {
833 DIE *ISP = AI->second;
834 if (InlinedSubprogramDIEs.count(ISP))
836 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
839 // Emit DW_AT_containing_type attribute to connect types with their
840 // vtable holding type.
841 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
842 CUE = CUMap.end(); CUI != CUE; ++CUI) {
843 CompileUnit *TheCU = CUI->second;
844 TheCU->constructContainingTypeDIEs();
847 // Standard sections final addresses.
848 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
849 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
850 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
851 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
853 // End text sections.
854 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
855 Asm->OutStreamer.SwitchSection(SectionMap[I]);
856 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
859 // Compute DIE offsets and sizes.
860 computeSizeAndOffsets();
862 // Emit all the DIEs into a debug info section
865 // Corresponding abbreviations into a abbrev section.
868 // Emit info into the dwarf accelerator table sections.
869 if (useDwarfAccelTables()) {
872 emitAccelNamespaces();
876 // Emit info into a debug pubtypes section.
877 // TODO: When we don't need the option anymore we can
878 // remove all of the code that adds to the table.
879 if (useDarwinGDBCompat())
882 // Emit info into a debug loc section.
885 // Emit info into a debug aranges section.
888 // Emit info into a debug ranges section.
891 // Emit info into a debug macinfo section.
895 // TODO: When we don't need the option anymore we
896 // can remove all of the code that this section
898 if (useDarwinGDBCompat())
899 emitDebugInlineInfo();
901 // Emit info into a debug str section.
905 DeleteContainerSeconds(DeadFnScopeMap);
907 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
908 E = CUMap.end(); I != E; ++I)
910 FirstCU = NULL; // Reset for the next Module, if any.
913 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
914 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
916 LLVMContext &Ctx = DV->getContext();
917 // More then one inlined variable corresponds to one abstract variable.
918 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
919 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
921 return AbsDbgVariable;
923 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
927 AbsDbgVariable = new DbgVariable(Var, NULL);
928 addScopeVariable(Scope, AbsDbgVariable);
929 AbstractVariables[Var] = AbsDbgVariable;
930 return AbsDbgVariable;
933 /// addCurrentFnArgument - If Var is a current function argument then add
934 /// it to CurrentFnArguments list.
935 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
936 DbgVariable *Var, LexicalScope *Scope) {
937 if (!LScopes.isCurrentFunctionScope(Scope))
939 DIVariable DV = Var->getVariable();
940 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
942 unsigned ArgNo = DV.getArgNumber();
946 size_t Size = CurrentFnArguments.size();
948 CurrentFnArguments.resize(MF->getFunction()->arg_size());
949 // llvm::Function argument size is not good indicator of how many
950 // arguments does the function have at source level.
952 CurrentFnArguments.resize(ArgNo * 2);
953 CurrentFnArguments[ArgNo - 1] = Var;
957 /// collectVariableInfoFromMMITable - Collect variable information from
958 /// side table maintained by MMI.
960 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
961 SmallPtrSet<const MDNode *, 16> &Processed) {
962 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
963 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
964 VE = VMap.end(); VI != VE; ++VI) {
965 const MDNode *Var = VI->first;
967 Processed.insert(Var);
969 const std::pair<unsigned, DebugLoc> &VP = VI->second;
971 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
973 // If variable scope is not found then skip this variable.
977 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
978 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
979 RegVar->setFrameIndex(VP.first);
980 if (!addCurrentFnArgument(MF, RegVar, Scope))
981 addScopeVariable(Scope, RegVar);
983 AbsDbgVariable->setFrameIndex(VP.first);
987 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
988 /// DBG_VALUE instruction, is in a defined reg.
989 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
990 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
991 return MI->getNumOperands() == 3 &&
992 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
993 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
996 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
998 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
999 const MCSymbol *FLabel,
1000 const MCSymbol *SLabel,
1001 const MachineInstr *MI) {
1002 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1004 if (MI->getNumOperands() != 3) {
1005 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1006 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1008 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1009 MachineLocation MLoc;
1010 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1011 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1013 if (MI->getOperand(0).isImm())
1014 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1015 if (MI->getOperand(0).isFPImm())
1016 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1017 if (MI->getOperand(0).isCImm())
1018 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1020 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1023 /// collectVariableInfo - Find variables for each lexical scope.
1025 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1026 SmallPtrSet<const MDNode *, 16> &Processed) {
1028 /// collection info from MMI table.
1029 collectVariableInfoFromMMITable(MF, Processed);
1031 for (SmallVectorImpl<const MDNode*>::const_iterator
1032 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1034 const MDNode *Var = *UVI;
1035 if (Processed.count(Var))
1038 // History contains relevant DBG_VALUE instructions for Var and instructions
1040 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1041 if (History.empty())
1043 const MachineInstr *MInsn = History.front();
1046 LexicalScope *Scope = NULL;
1047 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1048 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1049 Scope = LScopes.getCurrentFunctionScope();
1051 if (DV.getVersion() <= LLVMDebugVersion9)
1052 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1054 if (MDNode *IA = DV.getInlinedAt())
1055 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1057 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1060 // If variable scope is not found then skip this variable.
1064 Processed.insert(DV);
1065 assert(MInsn->isDebugValue() && "History must begin with debug value");
1066 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1067 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1068 if (!addCurrentFnArgument(MF, RegVar, Scope))
1069 addScopeVariable(Scope, RegVar);
1071 AbsVar->setMInsn(MInsn);
1073 // Simplify ranges that are fully coalesced.
1074 if (History.size() <= 1 || (History.size() == 2 &&
1075 MInsn->isIdenticalTo(History.back()))) {
1076 RegVar->setMInsn(MInsn);
1080 // handle multiple DBG_VALUE instructions describing one variable.
1081 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1083 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1084 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1085 const MachineInstr *Begin = *HI;
1086 assert(Begin->isDebugValue() && "Invalid History entry");
1088 // Check if DBG_VALUE is truncating a range.
1089 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1090 && !Begin->getOperand(0).getReg())
1093 // Compute the range for a register location.
1094 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1095 const MCSymbol *SLabel = 0;
1098 // If Begin is the last instruction in History then its value is valid
1099 // until the end of the function.
1100 SLabel = FunctionEndSym;
1102 const MachineInstr *End = HI[1];
1103 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1104 << "\t" << *Begin << "\t" << *End << "\n");
1105 if (End->isDebugValue())
1106 SLabel = getLabelBeforeInsn(End);
1108 // End is a normal instruction clobbering the range.
1109 SLabel = getLabelAfterInsn(End);
1110 assert(SLabel && "Forgot label after clobber instruction");
1115 // The value is valid until the next DBG_VALUE or clobber.
1116 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1119 DotDebugLocEntries.push_back(DotDebugLocEntry());
1122 // Collect info for variables that were optimized out.
1123 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1124 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1125 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1126 DIVariable DV(Variables.getElement(i));
1127 if (!DV || !DV.Verify() || !Processed.insert(DV))
1129 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1130 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1134 /// getLabelBeforeInsn - Return Label preceding the instruction.
1135 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1136 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1137 assert(Label && "Didn't insert label before instruction");
1141 /// getLabelAfterInsn - Return Label immediately following the instruction.
1142 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1143 return LabelsAfterInsn.lookup(MI);
1146 /// beginInstruction - Process beginning of an instruction.
1147 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1148 // Check if source location changes, but ignore DBG_VALUE locations.
1149 if (!MI->isDebugValue()) {
1150 DebugLoc DL = MI->getDebugLoc();
1151 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1154 if (DL == PrologEndLoc) {
1155 Flags |= DWARF2_FLAG_PROLOGUE_END;
1156 PrologEndLoc = DebugLoc();
1158 if (PrologEndLoc.isUnknown())
1159 Flags |= DWARF2_FLAG_IS_STMT;
1161 if (!DL.isUnknown()) {
1162 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1163 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1165 recordSourceLine(0, 0, 0, 0);
1169 // Insert labels where requested.
1170 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1171 LabelsBeforeInsn.find(MI);
1174 if (I == LabelsBeforeInsn.end())
1177 // Label already assigned.
1182 PrevLabel = MMI->getContext().CreateTempSymbol();
1183 Asm->OutStreamer.EmitLabel(PrevLabel);
1185 I->second = PrevLabel;
1188 /// endInstruction - Process end of an instruction.
1189 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1190 // Don't create a new label after DBG_VALUE instructions.
1191 // They don't generate code.
1192 if (!MI->isDebugValue())
1195 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1196 LabelsAfterInsn.find(MI);
1199 if (I == LabelsAfterInsn.end())
1202 // Label already assigned.
1206 // We need a label after this instruction.
1208 PrevLabel = MMI->getContext().CreateTempSymbol();
1209 Asm->OutStreamer.EmitLabel(PrevLabel);
1211 I->second = PrevLabel;
1214 /// identifyScopeMarkers() -
1215 /// Each LexicalScope has first instruction and last instruction to mark
1216 /// beginning and end of a scope respectively. Create an inverse map that list
1217 /// scopes starts (and ends) with an instruction. One instruction may start (or
1218 /// end) multiple scopes. Ignore scopes that are not reachable.
1219 void DwarfDebug::identifyScopeMarkers() {
1220 SmallVector<LexicalScope *, 4> WorkList;
1221 WorkList.push_back(LScopes.getCurrentFunctionScope());
1222 while (!WorkList.empty()) {
1223 LexicalScope *S = WorkList.pop_back_val();
1225 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1226 if (!Children.empty())
1227 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1228 SE = Children.end(); SI != SE; ++SI)
1229 WorkList.push_back(*SI);
1231 if (S->isAbstractScope())
1234 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1237 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1238 RE = Ranges.end(); RI != RE; ++RI) {
1239 assert(RI->first && "InsnRange does not have first instruction!");
1240 assert(RI->second && "InsnRange does not have second instruction!");
1241 requestLabelBeforeInsn(RI->first);
1242 requestLabelAfterInsn(RI->second);
1247 /// getScopeNode - Get MDNode for DebugLoc's scope.
1248 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1249 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1250 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1251 return DL.getScope(Ctx);
1254 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1255 /// line number info for the function.
1256 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1257 const MDNode *Scope = getScopeNode(DL, Ctx);
1258 DISubprogram SP = getDISubprogram(Scope);
1260 // Check for number of operands since the compatibility is
1262 if (SP->getNumOperands() > 19)
1263 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1265 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1271 /// beginFunction - Gather pre-function debug information. Assumes being
1272 /// emitted immediately after the function entry point.
1273 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1274 if (!MMI->hasDebugInfo()) return;
1275 LScopes.initialize(*MF);
1276 if (LScopes.empty()) return;
1277 identifyScopeMarkers();
1279 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1280 Asm->getFunctionNumber());
1281 // Assumes in correct section after the entry point.
1282 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1284 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1286 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1287 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1288 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1290 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1292 bool AtBlockEntry = true;
1293 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1295 const MachineInstr *MI = II;
1297 if (MI->isDebugValue()) {
1298 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1300 // Keep track of user variables.
1302 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1304 // Variable is in a register, we need to check for clobbers.
1305 if (isDbgValueInDefinedReg(MI))
1306 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1308 // Check the history of this variable.
1309 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1310 if (History.empty()) {
1311 UserVariables.push_back(Var);
1312 // The first mention of a function argument gets the FunctionBeginSym
1313 // label, so arguments are visible when breaking at function entry.
1315 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1316 DISubprogram(getDISubprogram(DV.getContext()))
1317 .describes(MF->getFunction()))
1318 LabelsBeforeInsn[MI] = FunctionBeginSym;
1320 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1321 const MachineInstr *Prev = History.back();
1322 if (Prev->isDebugValue()) {
1323 // Coalesce identical entries at the end of History.
1324 if (History.size() >= 2 &&
1325 Prev->isIdenticalTo(History[History.size() - 2])) {
1326 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1328 << "\t" << *History[History.size() - 2] << "\n");
1332 // Terminate old register assignments that don't reach MI;
1333 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1334 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1335 isDbgValueInDefinedReg(Prev)) {
1336 // Previous register assignment needs to terminate at the end of
1338 MachineBasicBlock::const_iterator LastMI =
1339 PrevMBB->getLastNonDebugInstr();
1340 if (LastMI == PrevMBB->end()) {
1341 // Drop DBG_VALUE for empty range.
1342 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1343 << "\t" << *Prev << "\n");
1347 // Terminate after LastMI.
1348 History.push_back(LastMI);
1353 History.push_back(MI);
1355 // Not a DBG_VALUE instruction.
1357 AtBlockEntry = false;
1359 // First known non-DBG_VALUE and non-frame setup location marks
1360 // the beginning of the function body.
1361 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1362 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1363 PrologEndLoc = MI->getDebugLoc();
1365 // Check if the instruction clobbers any registers with debug vars.
1366 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1367 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1368 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1370 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1371 AI.isValid(); ++AI) {
1373 const MDNode *Var = LiveUserVar[Reg];
1376 // Reg is now clobbered.
1377 LiveUserVar[Reg] = 0;
1379 // Was MD last defined by a DBG_VALUE referring to Reg?
1380 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1381 if (HistI == DbgValues.end())
1383 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1384 if (History.empty())
1386 const MachineInstr *Prev = History.back();
1387 // Sanity-check: Register assignments are terminated at the end of
1389 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1391 // Is the variable still in Reg?
1392 if (!isDbgValueInDefinedReg(Prev) ||
1393 Prev->getOperand(0).getReg() != Reg)
1395 // Var is clobbered. Make sure the next instruction gets a label.
1396 History.push_back(MI);
1403 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1405 SmallVectorImpl<const MachineInstr*> &History = I->second;
1406 if (History.empty())
1409 // Make sure the final register assignments are terminated.
1410 const MachineInstr *Prev = History.back();
1411 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1412 const MachineBasicBlock *PrevMBB = Prev->getParent();
1413 MachineBasicBlock::const_iterator LastMI =
1414 PrevMBB->getLastNonDebugInstr();
1415 if (LastMI == PrevMBB->end())
1416 // Drop DBG_VALUE for empty range.
1419 // Terminate after LastMI.
1420 History.push_back(LastMI);
1423 // Request labels for the full history.
1424 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1425 const MachineInstr *MI = History[i];
1426 if (MI->isDebugValue())
1427 requestLabelBeforeInsn(MI);
1429 requestLabelAfterInsn(MI);
1433 PrevInstLoc = DebugLoc();
1434 PrevLabel = FunctionBeginSym;
1436 // Record beginning of function.
1437 if (!PrologEndLoc.isUnknown()) {
1438 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1439 MF->getFunction()->getContext());
1440 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1441 FnStartDL.getScope(MF->getFunction()->getContext()),
1446 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1447 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1448 ScopeVariables[LS].push_back(Var);
1449 // Vars.push_back(Var);
1452 /// endFunction - Gather and emit post-function debug information.
1454 void DwarfDebug::endFunction(const MachineFunction *MF) {
1455 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1457 // Define end label for subprogram.
1458 FunctionEndSym = Asm->GetTempSymbol("func_end",
1459 Asm->getFunctionNumber());
1460 // Assumes in correct section after the entry point.
1461 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1463 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1464 collectVariableInfo(MF, ProcessedVars);
1466 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1467 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1468 assert(TheCU && "Unable to find compile unit!");
1470 // Construct abstract scopes.
1471 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1472 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1473 LexicalScope *AScope = AList[i];
1474 DISubprogram SP(AScope->getScopeNode());
1476 // Collect info for variables that were optimized out.
1477 DIArray Variables = SP.getVariables();
1478 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1479 DIVariable DV(Variables.getElement(i));
1480 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1482 // Check that DbgVariable for DV wasn't created earlier, when
1483 // findAbstractVariable() was called for inlined instance of DV.
1484 LLVMContext &Ctx = DV->getContext();
1485 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1486 if (AbstractVariables.lookup(CleanDV))
1488 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1489 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1492 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1493 constructScopeDIE(TheCU, AScope);
1496 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1498 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1499 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1501 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1502 MMI->getFrameMoves()));
1505 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1506 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1507 DeleteContainerPointers(I->second);
1508 ScopeVariables.clear();
1509 DeleteContainerPointers(CurrentFnArguments);
1510 UserVariables.clear();
1512 AbstractVariables.clear();
1513 LabelsBeforeInsn.clear();
1514 LabelsAfterInsn.clear();
1518 /// recordSourceLine - Register a source line with debug info. Returns the
1519 /// unique label that was emitted and which provides correspondence to
1520 /// the source line list.
1521 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1527 DIDescriptor Scope(S);
1529 if (Scope.isCompileUnit()) {
1530 DICompileUnit CU(S);
1531 Fn = CU.getFilename();
1532 Dir = CU.getDirectory();
1533 } else if (Scope.isFile()) {
1535 Fn = F.getFilename();
1536 Dir = F.getDirectory();
1537 } else if (Scope.isSubprogram()) {
1539 Fn = SP.getFilename();
1540 Dir = SP.getDirectory();
1541 } else if (Scope.isLexicalBlockFile()) {
1542 DILexicalBlockFile DBF(S);
1543 Fn = DBF.getFilename();
1544 Dir = DBF.getDirectory();
1545 } else if (Scope.isLexicalBlock()) {
1546 DILexicalBlock DB(S);
1547 Fn = DB.getFilename();
1548 Dir = DB.getDirectory();
1550 llvm_unreachable("Unexpected scope info");
1552 Src = GetOrCreateSourceID(Fn, Dir);
1554 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1557 //===----------------------------------------------------------------------===//
1559 //===----------------------------------------------------------------------===//
1561 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1564 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1565 // Get the children.
1566 const std::vector<DIE *> &Children = Die->getChildren();
1568 // Record the abbreviation.
1569 assignAbbrevNumber(Die->getAbbrev());
1571 // Get the abbreviation for this DIE.
1572 unsigned AbbrevNumber = Die->getAbbrevNumber();
1573 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1576 Die->setOffset(Offset);
1578 // Start the size with the size of abbreviation code.
1579 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1581 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1582 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1584 // Size the DIE attribute values.
1585 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1586 // Size attribute value.
1587 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1589 // Size the DIE children if any.
1590 if (!Children.empty()) {
1591 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1592 "Children flag not set");
1594 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1595 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1597 // End of children marker.
1598 Offset += sizeof(int8_t);
1601 Die->setSize(Offset - Die->getOffset());
1605 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1607 void DwarfDebug::computeSizeAndOffsets() {
1608 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1609 E = CUMap.end(); I != E; ++I) {
1610 // Compute size of compile unit header.
1612 sizeof(int32_t) + // Length of Compilation Unit Info
1613 sizeof(int16_t) + // DWARF version number
1614 sizeof(int32_t) + // Offset Into Abbrev. Section
1615 sizeof(int8_t); // Pointer Size (in bytes)
1616 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1620 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1621 /// the start of each one.
1622 void DwarfDebug::EmitSectionLabels() {
1623 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1625 // Dwarf sections base addresses.
1626 DwarfInfoSectionSym =
1627 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1628 DwarfAbbrevSectionSym =
1629 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1630 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1632 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1633 EmitSectionSym(Asm, MacroInfo);
1635 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1636 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1637 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1638 DwarfStrSectionSym =
1639 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1640 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1643 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1644 "section_debug_loc");
1646 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1647 EmitSectionSym(Asm, TLOF.getDataSection());
1650 /// emitDIE - Recursively emits a debug information entry.
1652 void DwarfDebug::emitDIE(DIE *Die) {
1653 // Get the abbreviation for this DIE.
1654 unsigned AbbrevNumber = Die->getAbbrevNumber();
1655 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1657 // Emit the code (index) for the abbreviation.
1658 if (Asm->isVerbose())
1659 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1660 Twine::utohexstr(Die->getOffset()) + ":0x" +
1661 Twine::utohexstr(Die->getSize()) + " " +
1662 dwarf::TagString(Abbrev->getTag()));
1663 Asm->EmitULEB128(AbbrevNumber);
1665 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1666 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1668 // Emit the DIE attribute values.
1669 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1670 unsigned Attr = AbbrevData[i].getAttribute();
1671 unsigned Form = AbbrevData[i].getForm();
1672 assert(Form && "Too many attributes for DIE (check abbreviation)");
1674 if (Asm->isVerbose())
1675 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1678 case dwarf::DW_AT_abstract_origin: {
1679 DIEEntry *E = cast<DIEEntry>(Values[i]);
1680 DIE *Origin = E->getEntry();
1681 unsigned Addr = Origin->getOffset();
1682 Asm->EmitInt32(Addr);
1685 case dwarf::DW_AT_ranges: {
1686 // DW_AT_range Value encodes offset in debug_range section.
1687 DIEInteger *V = cast<DIEInteger>(Values[i]);
1689 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1690 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1694 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1696 DwarfDebugRangeSectionSym,
1701 case dwarf::DW_AT_location: {
1702 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1703 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1704 Asm->EmitLabelReference(L->getValue(), 4);
1706 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1708 Values[i]->EmitValue(Asm, Form);
1712 case dwarf::DW_AT_accessibility: {
1713 if (Asm->isVerbose()) {
1714 DIEInteger *V = cast<DIEInteger>(Values[i]);
1715 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1717 Values[i]->EmitValue(Asm, Form);
1721 // Emit an attribute using the defined form.
1722 Values[i]->EmitValue(Asm, Form);
1727 // Emit the DIE children if any.
1728 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1729 const std::vector<DIE *> &Children = Die->getChildren();
1731 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1732 emitDIE(Children[j]);
1734 if (Asm->isVerbose())
1735 Asm->OutStreamer.AddComment("End Of Children Mark");
1740 /// emitDebugInfo - Emit the debug info section.
1742 void DwarfDebug::emitDebugInfo() {
1743 // Start debug info section.
1744 Asm->OutStreamer.SwitchSection(
1745 Asm->getObjFileLowering().getDwarfInfoSection());
1746 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1747 E = CUMap.end(); I != E; ++I) {
1748 CompileUnit *TheCU = I->second;
1749 DIE *Die = TheCU->getCUDie();
1751 // Emit the compile units header.
1752 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1755 // Emit size of content not including length itself
1756 unsigned ContentSize = Die->getSize() +
1757 sizeof(int16_t) + // DWARF version number
1758 sizeof(int32_t) + // Offset Into Abbrev. Section
1759 sizeof(int8_t); // Pointer Size (in bytes)
1761 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1762 Asm->EmitInt32(ContentSize);
1763 Asm->OutStreamer.AddComment("DWARF version number");
1764 Asm->EmitInt16(dwarf::DWARF_VERSION);
1765 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1766 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1767 DwarfAbbrevSectionSym);
1768 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1769 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1772 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1776 /// emitAbbreviations - Emit the abbreviation section.
1778 void DwarfDebug::emitAbbreviations() const {
1779 // Check to see if it is worth the effort.
1780 if (!Abbreviations.empty()) {
1781 // Start the debug abbrev section.
1782 Asm->OutStreamer.SwitchSection(
1783 Asm->getObjFileLowering().getDwarfAbbrevSection());
1785 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1787 // For each abbrevation.
1788 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1789 // Get abbreviation data
1790 const DIEAbbrev *Abbrev = Abbreviations[i];
1792 // Emit the abbrevations code (base 1 index.)
1793 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1795 // Emit the abbreviations data.
1799 // Mark end of abbreviations.
1800 Asm->EmitULEB128(0, "EOM(3)");
1802 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1806 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1807 /// the line matrix.
1809 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1810 // Define last address of section.
1811 Asm->OutStreamer.AddComment("Extended Op");
1814 Asm->OutStreamer.AddComment("Op size");
1815 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1816 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1817 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1819 Asm->OutStreamer.AddComment("Section end label");
1821 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1822 Asm->getDataLayout().getPointerSize(),
1825 // Mark end of matrix.
1826 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1832 /// emitAccelNames - Emit visible names into a hashed accelerator table
1834 void DwarfDebug::emitAccelNames() {
1835 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1836 dwarf::DW_FORM_data4));
1837 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1838 E = CUMap.end(); I != E; ++I) {
1839 CompileUnit *TheCU = I->second;
1840 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1841 for (StringMap<std::vector<DIE*> >::const_iterator
1842 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1843 const char *Name = GI->getKeyData();
1844 const std::vector<DIE *> &Entities = GI->second;
1845 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1846 DE = Entities.end(); DI != DE; ++DI)
1847 AT.AddName(Name, (*DI));
1851 AT.FinalizeTable(Asm, "Names");
1852 Asm->OutStreamer.SwitchSection(
1853 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1854 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1855 Asm->OutStreamer.EmitLabel(SectionBegin);
1857 // Emit the full data.
1858 AT.Emit(Asm, SectionBegin, this);
1861 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1862 /// accelerator table section.
1863 void DwarfDebug::emitAccelObjC() {
1864 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1865 dwarf::DW_FORM_data4));
1866 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1867 E = CUMap.end(); I != E; ++I) {
1868 CompileUnit *TheCU = I->second;
1869 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1870 for (StringMap<std::vector<DIE*> >::const_iterator
1871 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1872 const char *Name = GI->getKeyData();
1873 const std::vector<DIE *> &Entities = GI->second;
1874 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1875 DE = Entities.end(); DI != DE; ++DI)
1876 AT.AddName(Name, (*DI));
1880 AT.FinalizeTable(Asm, "ObjC");
1881 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1882 .getDwarfAccelObjCSection());
1883 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1884 Asm->OutStreamer.EmitLabel(SectionBegin);
1886 // Emit the full data.
1887 AT.Emit(Asm, SectionBegin, this);
1890 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1892 void DwarfDebug::emitAccelNamespaces() {
1893 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1894 dwarf::DW_FORM_data4));
1895 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1896 E = CUMap.end(); I != E; ++I) {
1897 CompileUnit *TheCU = I->second;
1898 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1899 for (StringMap<std::vector<DIE*> >::const_iterator
1900 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1901 const char *Name = GI->getKeyData();
1902 const std::vector<DIE *> &Entities = GI->second;
1903 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1904 DE = Entities.end(); DI != DE; ++DI)
1905 AT.AddName(Name, (*DI));
1909 AT.FinalizeTable(Asm, "namespac");
1910 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1911 .getDwarfAccelNamespaceSection());
1912 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1913 Asm->OutStreamer.EmitLabel(SectionBegin);
1915 // Emit the full data.
1916 AT.Emit(Asm, SectionBegin, this);
1919 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1920 void DwarfDebug::emitAccelTypes() {
1921 std::vector<DwarfAccelTable::Atom> Atoms;
1922 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1923 dwarf::DW_FORM_data4));
1924 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1925 dwarf::DW_FORM_data2));
1926 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1927 dwarf::DW_FORM_data1));
1928 DwarfAccelTable AT(Atoms);
1929 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1930 E = CUMap.end(); I != E; ++I) {
1931 CompileUnit *TheCU = I->second;
1932 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1933 = TheCU->getAccelTypes();
1934 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1935 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1936 const char *Name = GI->getKeyData();
1937 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1938 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1939 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1940 AT.AddName(Name, (*DI).first, (*DI).second);
1944 AT.FinalizeTable(Asm, "types");
1945 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1946 .getDwarfAccelTypesSection());
1947 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1948 Asm->OutStreamer.EmitLabel(SectionBegin);
1950 // Emit the full data.
1951 AT.Emit(Asm, SectionBegin, this);
1954 void DwarfDebug::emitDebugPubTypes() {
1955 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1956 E = CUMap.end(); I != E; ++I) {
1957 CompileUnit *TheCU = I->second;
1958 // Start the dwarf pubtypes section.
1959 Asm->OutStreamer.SwitchSection(
1960 Asm->getObjFileLowering().getDwarfPubTypesSection());
1961 Asm->OutStreamer.AddComment("Length of Public Types Info");
1962 Asm->EmitLabelDifference(
1963 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1964 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1966 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1969 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1970 Asm->EmitInt16(dwarf::DWARF_VERSION);
1972 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1973 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1974 DwarfInfoSectionSym);
1976 Asm->OutStreamer.AddComment("Compilation Unit Length");
1977 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1978 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1981 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1982 for (StringMap<DIE*>::const_iterator
1983 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1984 const char *Name = GI->getKeyData();
1985 DIE *Entity = GI->second;
1987 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1988 Asm->EmitInt32(Entity->getOffset());
1990 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1991 // Emit the name with a terminating null byte.
1992 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1995 Asm->OutStreamer.AddComment("End Mark");
1997 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2002 /// emitDebugStr - Emit visible names into a debug str section.
2004 void DwarfDebug::emitDebugStr() {
2005 // Check to see if it is worth the effort.
2006 if (StringPool.empty()) return;
2008 // Start the dwarf str section.
2009 Asm->OutStreamer.SwitchSection(
2010 Asm->getObjFileLowering().getDwarfStrSection());
2012 // Get all of the string pool entries and put them in an array by their ID so
2013 // we can sort them.
2014 SmallVector<std::pair<unsigned,
2015 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2017 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2018 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2019 Entries.push_back(std::make_pair(I->second.second, &*I));
2021 array_pod_sort(Entries.begin(), Entries.end());
2023 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2024 // Emit a label for reference from debug information entries.
2025 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2027 // Emit the string itself with a terminating null byte.
2028 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2029 Entries[i].second->getKeyLength()+1),
2034 /// emitDebugLoc - Emit visible names into a debug loc section.
2036 void DwarfDebug::emitDebugLoc() {
2037 if (DotDebugLocEntries.empty())
2040 for (SmallVector<DotDebugLocEntry, 4>::iterator
2041 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2043 DotDebugLocEntry &Entry = *I;
2044 if (I + 1 != DotDebugLocEntries.end())
2048 // Start the dwarf loc section.
2049 Asm->OutStreamer.SwitchSection(
2050 Asm->getObjFileLowering().getDwarfLocSection());
2051 unsigned char Size = Asm->getDataLayout().getPointerSize();
2052 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2054 for (SmallVector<DotDebugLocEntry, 4>::iterator
2055 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2056 I != E; ++I, ++index) {
2057 DotDebugLocEntry &Entry = *I;
2058 if (Entry.isMerged()) continue;
2059 if (Entry.isEmpty()) {
2060 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2061 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2062 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2064 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2065 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2066 DIVariable DV(Entry.Variable);
2067 Asm->OutStreamer.AddComment("Loc expr size");
2068 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2069 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2070 Asm->EmitLabelDifference(end, begin, 2);
2071 Asm->OutStreamer.EmitLabel(begin);
2072 if (Entry.isInt()) {
2073 DIBasicType BTy(DV.getType());
2075 (BTy.getEncoding() == dwarf::DW_ATE_signed
2076 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2077 Asm->OutStreamer.AddComment("DW_OP_consts");
2078 Asm->EmitInt8(dwarf::DW_OP_consts);
2079 Asm->EmitSLEB128(Entry.getInt());
2081 Asm->OutStreamer.AddComment("DW_OP_constu");
2082 Asm->EmitInt8(dwarf::DW_OP_constu);
2083 Asm->EmitULEB128(Entry.getInt());
2085 } else if (Entry.isLocation()) {
2086 if (!DV.hasComplexAddress())
2088 Asm->EmitDwarfRegOp(Entry.Loc);
2090 // Complex address entry.
2091 unsigned N = DV.getNumAddrElements();
2093 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2094 if (Entry.Loc.getOffset()) {
2096 Asm->EmitDwarfRegOp(Entry.Loc);
2097 Asm->OutStreamer.AddComment("DW_OP_deref");
2098 Asm->EmitInt8(dwarf::DW_OP_deref);
2099 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2100 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2101 Asm->EmitSLEB128(DV.getAddrElement(1));
2103 // If first address element is OpPlus then emit
2104 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2105 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2106 Asm->EmitDwarfRegOp(Loc);
2110 Asm->EmitDwarfRegOp(Entry.Loc);
2113 // Emit remaining complex address elements.
2114 for (; i < N; ++i) {
2115 uint64_t Element = DV.getAddrElement(i);
2116 if (Element == DIBuilder::OpPlus) {
2117 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2118 Asm->EmitULEB128(DV.getAddrElement(++i));
2119 } else if (Element == DIBuilder::OpDeref) {
2120 if (!Entry.Loc.isReg())
2121 Asm->EmitInt8(dwarf::DW_OP_deref);
2123 llvm_unreachable("unknown Opcode found in complex address");
2127 // else ... ignore constant fp. There is not any good way to
2128 // to represent them here in dwarf.
2129 Asm->OutStreamer.EmitLabel(end);
2134 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2136 void DwarfDebug::EmitDebugARanges() {
2137 // Start the dwarf aranges section.
2138 Asm->OutStreamer.SwitchSection(
2139 Asm->getObjFileLowering().getDwarfARangesSection());
2142 /// emitDebugRanges - Emit visible names into a debug ranges section.
2144 void DwarfDebug::emitDebugRanges() {
2145 // Start the dwarf ranges section.
2146 Asm->OutStreamer.SwitchSection(
2147 Asm->getObjFileLowering().getDwarfRangesSection());
2148 unsigned char Size = Asm->getDataLayout().getPointerSize();
2149 for (SmallVector<const MCSymbol *, 8>::iterator
2150 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2153 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2155 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2159 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2161 void DwarfDebug::emitDebugMacInfo() {
2162 if (const MCSection *LineInfo =
2163 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2164 // Start the dwarf macinfo section.
2165 Asm->OutStreamer.SwitchSection(LineInfo);
2169 /// emitDebugInlineInfo - Emit inline info using following format.
2171 /// 1. length of section
2172 /// 2. Dwarf version number
2173 /// 3. address size.
2175 /// Entries (one "entry" for each function that was inlined):
2177 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2178 /// otherwise offset into __debug_str for regular function name.
2179 /// 2. offset into __debug_str section for regular function name.
2180 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2181 /// instances for the function.
2183 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2184 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2185 /// __debug_info section, and the low_pc is the starting address for the
2186 /// inlining instance.
2187 void DwarfDebug::emitDebugInlineInfo() {
2188 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2194 Asm->OutStreamer.SwitchSection(
2195 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2197 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2198 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2199 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2201 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2203 Asm->OutStreamer.AddComment("Dwarf Version");
2204 Asm->EmitInt16(dwarf::DWARF_VERSION);
2205 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2206 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2208 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2209 E = InlinedSPNodes.end(); I != E; ++I) {
2211 const MDNode *Node = *I;
2212 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2213 = InlineInfo.find(Node);
2214 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2215 DISubprogram SP(Node);
2216 StringRef LName = SP.getLinkageName();
2217 StringRef Name = SP.getName();
2219 Asm->OutStreamer.AddComment("MIPS linkage name");
2221 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2223 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2224 DwarfStrSectionSym);
2226 Asm->OutStreamer.AddComment("Function name");
2227 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2228 Asm->EmitULEB128(Labels.size(), "Inline count");
2230 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2231 LE = Labels.end(); LI != LE; ++LI) {
2232 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2233 Asm->EmitInt32(LI->second->getOffset());
2235 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2236 Asm->OutStreamer.EmitSymbolValue(LI->first,
2237 Asm->getDataLayout().getPointerSize(),0);
2241 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));