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/Target/TargetData.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 DISubprogram SPDecl = SP.getFunctionDeclaration();
311 if (!SPDecl.isSubprogram()) {
312 // There is not any need to generate specification DIE for a function
313 // defined at compile unit level. If a function is defined inside another
314 // function then gdb prefers the definition at top level and but does not
315 // expect specification DIE in parent function. So avoid creating
316 // specification DIE for a function defined inside a function.
317 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
318 !SP.getContext().isFile() &&
319 !isSubprogramContext(SP.getContext())) {
320 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
323 DICompositeType SPTy = SP.getType();
324 DIArray Args = SPTy.getTypeArray();
325 unsigned SPTag = SPTy.getTag();
326 if (SPTag == dwarf::DW_TAG_subroutine_type)
327 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
328 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
329 DIType ATy = DIType(DIType(Args.getElement(i)));
330 SPCU->addType(Arg, ATy);
331 if (ATy.isArtificial())
332 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
333 SPDie->addChild(Arg);
335 DIE *SPDeclDie = SPDie;
336 SPDie = new DIE(dwarf::DW_TAG_subprogram);
337 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
342 // Pick up abstract subprogram DIE.
343 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
344 SPDie = new DIE(dwarf::DW_TAG_subprogram);
345 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
346 dwarf::DW_FORM_ref4, AbsSPDIE);
350 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
351 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
352 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
353 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
354 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
355 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
356 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
358 // Add name to the name table, we do this here because we're guaranteed
359 // to have concrete versions of our DW_TAG_subprogram nodes.
360 addSubprogramNames(SPCU, SP, SPDie);
365 /// constructLexicalScope - Construct new DW_TAG_lexical_block
366 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
367 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
368 LexicalScope *Scope) {
369 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
370 if (Scope->isAbstractScope())
373 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
377 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
378 if (Ranges.size() > 1) {
379 // .debug_range section has not been laid out yet. Emit offset in
380 // .debug_range as a uint, size 4, for now. emitDIE will handle
381 // DW_AT_ranges appropriately.
382 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
383 DebugRangeSymbols.size()
384 * Asm->getTargetData().getPointerSize());
385 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
386 RE = Ranges.end(); RI != RE; ++RI) {
387 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
388 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
390 DebugRangeSymbols.push_back(NULL);
391 DebugRangeSymbols.push_back(NULL);
395 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
396 const MCSymbol *End = getLabelAfterInsn(RI->second);
398 if (End == 0) return 0;
400 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
401 assert(End->isDefined() && "Invalid end label for an inlined scope!");
403 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
404 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
409 /// constructInlinedScopeDIE - This scope represents inlined body of
410 /// a function. Construct DIE to represent this concrete inlined copy
412 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
413 LexicalScope *Scope) {
414 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
415 assert(Ranges.empty() == false &&
416 "LexicalScope does not have instruction markers!");
418 if (!Scope->getScopeNode())
420 DIScope DS(Scope->getScopeNode());
421 DISubprogram InlinedSP = getDISubprogram(DS);
422 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
424 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
428 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
429 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
430 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
432 if (StartLabel == 0 || EndLabel == 0) {
433 llvm_unreachable("Unexpected Start and End labels for a inlined scope!");
435 assert(StartLabel->isDefined() &&
436 "Invalid starting label for an inlined scope!");
437 assert(EndLabel->isDefined() &&
438 "Invalid end label for an inlined scope!");
440 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
441 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
442 dwarf::DW_FORM_ref4, OriginDIE);
444 if (Ranges.size() > 1) {
445 // .debug_range section has not been laid out yet. Emit offset in
446 // .debug_range as a uint, size 4, for now. emitDIE will handle
447 // DW_AT_ranges appropriately.
448 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
449 DebugRangeSymbols.size()
450 * Asm->getTargetData().getPointerSize());
451 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
452 RE = Ranges.end(); RI != RE; ++RI) {
453 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
454 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
456 DebugRangeSymbols.push_back(NULL);
457 DebugRangeSymbols.push_back(NULL);
459 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
461 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
465 InlinedSubprogramDIEs.insert(OriginDIE);
467 // Track the start label for this inlined function.
468 //.debug_inlined section specification does not clearly state how
469 // to emit inlined scope that is split into multiple instruction ranges.
470 // For now, use first instruction range and emit low_pc/high_pc pair and
471 // corresponding .debug_inlined section entry for this pair.
472 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
473 I = InlineInfo.find(InlinedSP);
475 if (I == InlineInfo.end()) {
476 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
477 InlinedSPNodes.push_back(InlinedSP);
479 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
481 DILocation DL(Scope->getInlinedAt());
482 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
483 GetOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
484 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
486 // Add name to the name table, we do this here because we're guaranteed
487 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
488 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
493 /// constructScopeDIE - Construct a DIE for this scope.
494 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
495 if (!Scope || !Scope->getScopeNode())
498 SmallVector<DIE *, 8> Children;
500 // Collect arguments for current function.
501 if (LScopes.isCurrentFunctionScope(Scope))
502 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
503 if (DbgVariable *ArgDV = CurrentFnArguments[i])
505 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
506 Children.push_back(Arg);
508 // Collect lexical scope children first.
509 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
510 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
512 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
513 Children.push_back(Variable);
514 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
515 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
516 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
517 Children.push_back(Nested);
518 DIScope DS(Scope->getScopeNode());
519 DIE *ScopeDIE = NULL;
520 if (Scope->getInlinedAt())
521 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
522 else if (DS.isSubprogram()) {
523 ProcessedSPNodes.insert(DS);
524 if (Scope->isAbstractScope()) {
525 ScopeDIE = TheCU->getDIE(DS);
526 // Note down abstract DIE.
528 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
531 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
534 // There is no need to emit empty lexical block DIE.
535 if (Children.empty())
537 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
540 if (!ScopeDIE) return NULL;
543 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
544 E = Children.end(); I != E; ++I)
545 ScopeDIE->addChild(*I);
547 if (DS.isSubprogram())
548 TheCU->addPubTypes(DISubprogram(DS));
553 /// GetOrCreateSourceID - Look up the source id with the given directory and
554 /// source file names. If none currently exists, create a new id and insert it
555 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
557 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
559 // If FE did not provide a file name, then assume stdin.
560 if (FileName.empty())
561 return GetOrCreateSourceID("<stdin>", StringRef());
563 // TODO: this might not belong here. See if we can factor this better.
564 if (DirName == CompilationDir)
567 unsigned SrcId = SourceIdMap.size()+1;
569 // We look up the file/dir pair by concatenating them with a zero byte.
570 SmallString<128> NamePair;
572 NamePair += '\0'; // Zero bytes are not allowed in paths.
573 NamePair += FileName;
575 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
576 if (Ent.getValue() != SrcId)
577 return Ent.getValue();
579 // Print out a .file directive to specify files for .loc directives.
580 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
585 /// constructCompileUnit - Create new CompileUnit for the given
586 /// metadata node with tag DW_TAG_compile_unit.
587 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
588 DICompileUnit DIUnit(N);
589 StringRef FN = DIUnit.getFilename();
590 CompilationDir = DIUnit.getDirectory();
591 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
593 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
594 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die, Asm, this);
595 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
596 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
597 DIUnit.getLanguage());
598 NewCU->addString(Die, dwarf::DW_AT_name, FN);
599 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
601 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
602 // DW_AT_stmt_list is a offset of line number information for this
603 // compile unit in debug_line section.
604 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
605 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
606 Asm->GetTempSymbol("section_line"));
608 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
610 if (!CompilationDir.empty())
611 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
612 if (DIUnit.isOptimized())
613 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
615 StringRef Flags = DIUnit.getFlags();
617 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
619 if (unsigned RVer = DIUnit.getRunTimeVersion())
620 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
621 dwarf::DW_FORM_data1, RVer);
625 CUMap.insert(std::make_pair(N, NewCU));
629 /// construct SubprogramDIE - Construct subprogram DIE.
630 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
632 CompileUnit *&CURef = SPMap[N];
638 if (!SP.isDefinition())
639 // This is a method declaration which will be handled while constructing
643 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
646 TheCU->insertDIE(N, SubprogramDie);
648 // Add to context owner.
649 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
654 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
655 /// as llvm.dbg.enum and llvm.dbg.ty
656 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
657 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
658 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
659 const MDNode *N = NMD->getOperand(i);
660 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
661 constructSubprogramDIE(CU, N);
664 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
665 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
666 const MDNode *N = NMD->getOperand(i);
667 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
668 CU->createGlobalVariableDIE(N);
671 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
672 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
673 DIType Ty(NMD->getOperand(i));
674 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
675 CU->getOrCreateTypeDIE(Ty);
678 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
679 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
680 DIType Ty(NMD->getOperand(i));
681 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
682 CU->getOrCreateTypeDIE(Ty);
686 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
687 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
688 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
689 DebugInfoFinder DbgFinder;
690 DbgFinder.processModule(*M);
692 bool HasDebugInfo = false;
693 // Scan all the compile-units to see if there are any marked as the main
694 // unit. If not, we do not generate debug info.
695 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
696 E = DbgFinder.compile_unit_end(); I != E; ++I) {
697 if (DICompileUnit(*I).isMain()) {
702 if (!HasDebugInfo) return false;
704 // Create all the compile unit DIEs.
705 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
706 E = DbgFinder.compile_unit_end(); I != E; ++I)
707 constructCompileUnit(*I);
709 // Create DIEs for each global variable.
710 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
711 E = DbgFinder.global_variable_end(); I != E; ++I) {
712 const MDNode *N = *I;
713 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
714 CU->createGlobalVariableDIE(N);
717 // Create DIEs for each subprogram.
718 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
719 E = DbgFinder.subprogram_end(); I != E; ++I) {
720 const MDNode *N = *I;
721 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
722 constructSubprogramDIE(CU, N);
728 /// beginModule - Emit all Dwarf sections that should come prior to the
729 /// content. Create global DIEs and emit initial debug info sections.
730 /// This is invoked by the target AsmPrinter.
731 void DwarfDebug::beginModule(Module *M) {
732 if (DisableDebugInfoPrinting)
735 // If module has named metadata anchors then use them, otherwise scan the
736 // module using debug info finder to collect debug info.
737 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
739 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
740 DICompileUnit CUNode(CU_Nodes->getOperand(i));
741 CompileUnit *CU = constructCompileUnit(CUNode);
742 DIArray GVs = CUNode.getGlobalVariables();
743 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
744 CU->createGlobalVariableDIE(GVs.getElement(i));
745 DIArray SPs = CUNode.getSubprograms();
746 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
747 constructSubprogramDIE(CU, SPs.getElement(i));
748 DIArray EnumTypes = CUNode.getEnumTypes();
749 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
750 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
751 DIArray RetainedTypes = CUNode.getRetainedTypes();
752 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
753 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
755 } else if (!collectLegacyDebugInfo(M))
758 collectInfoFromNamedMDNodes(M);
760 // Tell MMI that we have debug info.
761 MMI->setDebugInfoAvailability(true);
763 // Emit initial sections.
766 // Prime section data.
767 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
770 /// endModule - Emit all Dwarf sections that should come after the content.
772 void DwarfDebug::endModule() {
773 if (!FirstCU) return;
774 const Module *M = MMI->getModule();
775 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
777 // Collect info for variables that were optimized out.
778 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
779 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
780 DICompileUnit TheCU(CU_Nodes->getOperand(i));
781 DIArray Subprograms = TheCU.getSubprograms();
782 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
783 DISubprogram SP(Subprograms.getElement(i));
784 if (ProcessedSPNodes.count(SP) != 0) continue;
785 if (!SP.Verify()) continue;
786 if (!SP.isDefinition()) continue;
787 DIArray Variables = SP.getVariables();
788 if (Variables.getNumElements() == 0) continue;
790 LexicalScope *Scope =
791 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
792 DeadFnScopeMap[SP] = Scope;
794 // Construct subprogram DIE and add variables DIEs.
795 CompileUnit *SPCU = CUMap.lookup(TheCU);
796 assert(SPCU && "Unable to find Compile Unit!");
797 constructSubprogramDIE(SPCU, SP);
798 DIE *ScopeDIE = SPCU->getDIE(SP);
799 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
800 DIVariable DV(Variables.getElement(vi));
801 if (!DV.Verify()) continue;
802 DbgVariable *NewVar = new DbgVariable(DV, NULL);
803 if (DIE *VariableDIE =
804 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
805 ScopeDIE->addChild(VariableDIE);
811 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
812 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
813 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
815 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
817 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
818 AE = AbstractSPDies.end(); AI != AE; ++AI) {
819 DIE *ISP = AI->second;
820 if (InlinedSubprogramDIEs.count(ISP))
822 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
825 // Emit DW_AT_containing_type attribute to connect types with their
826 // vtable holding type.
827 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
828 CUE = CUMap.end(); CUI != CUE; ++CUI) {
829 CompileUnit *TheCU = CUI->second;
830 TheCU->constructContainingTypeDIEs();
833 // Standard sections final addresses.
834 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
835 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
836 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
837 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
839 // End text sections.
840 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
841 Asm->OutStreamer.SwitchSection(SectionMap[i]);
842 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
845 // Compute DIE offsets and sizes.
846 computeSizeAndOffsets();
848 // Emit all the DIEs into a debug info section
851 // Corresponding abbreviations into a abbrev section.
854 // Emit info into the dwarf accelerator table sections.
855 if (useDwarfAccelTables()) {
858 emitAccelNamespaces();
862 // Emit info into a debug pubtypes section.
863 // TODO: When we don't need the option anymore we can
864 // remove all of the code that adds to the table.
865 if (useDarwinGDBCompat())
868 // Emit info into a debug loc section.
871 // Emit info into a debug aranges section.
874 // Emit info into a debug ranges section.
877 // Emit info into a debug macinfo section.
881 // TODO: When we don't need the option anymore we
882 // can remove all of the code that this section
884 if (useDarwinGDBCompat())
885 emitDebugInlineInfo();
887 // Emit info into a debug str section.
891 DeleteContainerSeconds(DeadFnScopeMap);
893 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
894 E = CUMap.end(); I != E; ++I)
896 FirstCU = NULL; // Reset for the next Module, if any.
899 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
900 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
902 LLVMContext &Ctx = DV->getContext();
903 // More then one inlined variable corresponds to one abstract variable.
904 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
905 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
907 return AbsDbgVariable;
909 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
913 AbsDbgVariable = new DbgVariable(Var, NULL);
914 addScopeVariable(Scope, AbsDbgVariable);
915 AbstractVariables[Var] = AbsDbgVariable;
916 return AbsDbgVariable;
919 /// addCurrentFnArgument - If Var is a current function argument then add
920 /// it to CurrentFnArguments list.
921 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
922 DbgVariable *Var, LexicalScope *Scope) {
923 if (!LScopes.isCurrentFunctionScope(Scope))
925 DIVariable DV = Var->getVariable();
926 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
928 unsigned ArgNo = DV.getArgNumber();
932 size_t Size = CurrentFnArguments.size();
934 CurrentFnArguments.resize(MF->getFunction()->arg_size());
935 // llvm::Function argument size is not good indicator of how many
936 // arguments does the function have at source level.
938 CurrentFnArguments.resize(ArgNo * 2);
939 CurrentFnArguments[ArgNo - 1] = Var;
943 /// collectVariableInfoFromMMITable - Collect variable information from
944 /// side table maintained by MMI.
946 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
947 SmallPtrSet<const MDNode *, 16> &Processed) {
948 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
949 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
950 VE = VMap.end(); VI != VE; ++VI) {
951 const MDNode *Var = VI->first;
953 Processed.insert(Var);
955 const std::pair<unsigned, DebugLoc> &VP = VI->second;
957 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
959 // If variable scope is not found then skip this variable.
963 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
964 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
965 RegVar->setFrameIndex(VP.first);
966 if (!addCurrentFnArgument(MF, RegVar, Scope))
967 addScopeVariable(Scope, RegVar);
969 AbsDbgVariable->setFrameIndex(VP.first);
973 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
974 /// DBG_VALUE instruction, is in a defined reg.
975 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
976 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
977 return MI->getNumOperands() == 3 &&
978 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
979 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
982 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
984 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
985 const MCSymbol *FLabel,
986 const MCSymbol *SLabel,
987 const MachineInstr *MI) {
988 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
990 if (MI->getNumOperands() != 3) {
991 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
992 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
994 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
995 MachineLocation MLoc;
996 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
997 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
999 if (MI->getOperand(0).isImm())
1000 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1001 if (MI->getOperand(0).isFPImm())
1002 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1003 if (MI->getOperand(0).isCImm())
1004 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1006 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1009 /// collectVariableInfo - Find variables for each lexical scope.
1011 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1012 SmallPtrSet<const MDNode *, 16> &Processed) {
1014 /// collection info from MMI table.
1015 collectVariableInfoFromMMITable(MF, Processed);
1017 for (SmallVectorImpl<const MDNode*>::const_iterator
1018 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1020 const MDNode *Var = *UVI;
1021 if (Processed.count(Var))
1024 // History contains relevant DBG_VALUE instructions for Var and instructions
1026 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1027 if (History.empty())
1029 const MachineInstr *MInsn = History.front();
1032 LexicalScope *Scope = NULL;
1033 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1034 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1035 Scope = LScopes.getCurrentFunctionScope();
1037 if (DV.getVersion() <= LLVMDebugVersion9)
1038 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1040 if (MDNode *IA = DV.getInlinedAt())
1041 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1043 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1046 // If variable scope is not found then skip this variable.
1050 Processed.insert(DV);
1051 assert(MInsn->isDebugValue() && "History must begin with debug value");
1052 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1053 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1054 if (!addCurrentFnArgument(MF, RegVar, Scope))
1055 addScopeVariable(Scope, RegVar);
1057 AbsVar->setMInsn(MInsn);
1059 // Simple ranges that are fully coalesced.
1060 if (History.size() <= 1 || (History.size() == 2 &&
1061 MInsn->isIdenticalTo(History.back()))) {
1062 RegVar->setMInsn(MInsn);
1066 // handle multiple DBG_VALUE instructions describing one variable.
1067 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1069 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1070 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1071 const MachineInstr *Begin = *HI;
1072 assert(Begin->isDebugValue() && "Invalid History entry");
1074 // Check if DBG_VALUE is truncating a range.
1075 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1076 && !Begin->getOperand(0).getReg())
1079 // Compute the range for a register location.
1080 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1081 const MCSymbol *SLabel = 0;
1084 // If Begin is the last instruction in History then its value is valid
1085 // until the end of the function.
1086 SLabel = FunctionEndSym;
1088 const MachineInstr *End = HI[1];
1089 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1090 << "\t" << *Begin << "\t" << *End << "\n");
1091 if (End->isDebugValue())
1092 SLabel = getLabelBeforeInsn(End);
1094 // End is a normal instruction clobbering the range.
1095 SLabel = getLabelAfterInsn(End);
1096 assert(SLabel && "Forgot label after clobber instruction");
1101 // The value is valid until the next DBG_VALUE or clobber.
1102 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1105 DotDebugLocEntries.push_back(DotDebugLocEntry());
1108 // Collect info for variables that were optimized out.
1109 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1110 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1111 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1112 DIVariable DV(Variables.getElement(i));
1113 if (!DV || !DV.Verify() || !Processed.insert(DV))
1115 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1116 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1120 /// getLabelBeforeInsn - Return Label preceding the instruction.
1121 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1122 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1123 assert(Label && "Didn't insert label before instruction");
1127 /// getLabelAfterInsn - Return Label immediately following the instruction.
1128 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1129 return LabelsAfterInsn.lookup(MI);
1132 /// beginInstruction - Process beginning of an instruction.
1133 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1134 // Check if source location changes, but ignore DBG_VALUE locations.
1135 if (!MI->isDebugValue()) {
1136 DebugLoc DL = MI->getDebugLoc();
1137 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1140 if (DL == PrologEndLoc) {
1141 Flags |= DWARF2_FLAG_PROLOGUE_END;
1142 PrologEndLoc = DebugLoc();
1144 if (PrologEndLoc.isUnknown())
1145 Flags |= DWARF2_FLAG_IS_STMT;
1147 if (!DL.isUnknown()) {
1148 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1149 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1151 recordSourceLine(0, 0, 0, 0);
1155 // Insert labels where requested.
1156 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1157 LabelsBeforeInsn.find(MI);
1160 if (I == LabelsBeforeInsn.end())
1163 // Label already assigned.
1168 PrevLabel = MMI->getContext().CreateTempSymbol();
1169 Asm->OutStreamer.EmitLabel(PrevLabel);
1171 I->second = PrevLabel;
1174 /// endInstruction - Process end of an instruction.
1175 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1176 // Don't create a new label after DBG_VALUE instructions.
1177 // They don't generate code.
1178 if (!MI->isDebugValue())
1181 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1182 LabelsAfterInsn.find(MI);
1185 if (I == LabelsAfterInsn.end())
1188 // Label already assigned.
1192 // We need a label after this instruction.
1194 PrevLabel = MMI->getContext().CreateTempSymbol();
1195 Asm->OutStreamer.EmitLabel(PrevLabel);
1197 I->second = PrevLabel;
1200 /// identifyScopeMarkers() -
1201 /// Each LexicalScope has first instruction and last instruction to mark
1202 /// beginning and end of a scope respectively. Create an inverse map that list
1203 /// scopes starts (and ends) with an instruction. One instruction may start (or
1204 /// end) multiple scopes. Ignore scopes that are not reachable.
1205 void DwarfDebug::identifyScopeMarkers() {
1206 SmallVector<LexicalScope *, 4> WorkList;
1207 WorkList.push_back(LScopes.getCurrentFunctionScope());
1208 while (!WorkList.empty()) {
1209 LexicalScope *S = WorkList.pop_back_val();
1211 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1212 if (!Children.empty())
1213 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1214 SE = Children.end(); SI != SE; ++SI)
1215 WorkList.push_back(*SI);
1217 if (S->isAbstractScope())
1220 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1223 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1224 RE = Ranges.end(); RI != RE; ++RI) {
1225 assert(RI->first && "InsnRange does not have first instruction!");
1226 assert(RI->second && "InsnRange does not have second instruction!");
1227 requestLabelBeforeInsn(RI->first);
1228 requestLabelAfterInsn(RI->second);
1233 /// getScopeNode - Get MDNode for DebugLoc's scope.
1234 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1235 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1236 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1237 return DL.getScope(Ctx);
1240 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1241 /// line number info for the function.
1242 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1243 const MDNode *Scope = getScopeNode(DL, Ctx);
1244 DISubprogram SP = getDISubprogram(Scope);
1246 // Check for number of operands since the compatibility is
1248 if (SP->getNumOperands() > 19)
1249 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1251 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1257 /// beginFunction - Gather pre-function debug information. Assumes being
1258 /// emitted immediately after the function entry point.
1259 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1260 if (!MMI->hasDebugInfo()) return;
1261 LScopes.initialize(*MF);
1262 if (LScopes.empty()) return;
1263 identifyScopeMarkers();
1265 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1266 Asm->getFunctionNumber());
1267 // Assumes in correct section after the entry point.
1268 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1270 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1272 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1273 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1274 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1276 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1278 bool AtBlockEntry = true;
1279 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1281 const MachineInstr *MI = II;
1283 if (MI->isDebugValue()) {
1284 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1286 // Keep track of user variables.
1288 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1290 // Variable is in a register, we need to check for clobbers.
1291 if (isDbgValueInDefinedReg(MI))
1292 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1294 // Check the history of this variable.
1295 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1296 if (History.empty()) {
1297 UserVariables.push_back(Var);
1298 // The first mention of a function argument gets the FunctionBeginSym
1299 // label, so arguments are visible when breaking at function entry.
1301 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1302 DISubprogram(getDISubprogram(DV.getContext()))
1303 .describes(MF->getFunction()))
1304 LabelsBeforeInsn[MI] = FunctionBeginSym;
1306 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1307 const MachineInstr *Prev = History.back();
1308 if (Prev->isDebugValue()) {
1309 // Coalesce identical entries at the end of History.
1310 if (History.size() >= 2 &&
1311 Prev->isIdenticalTo(History[History.size() - 2])) {
1312 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1314 << "\t" << *History[History.size() - 2] << "\n");
1318 // Terminate old register assignments that don't reach MI;
1319 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1320 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1321 isDbgValueInDefinedReg(Prev)) {
1322 // Previous register assignment needs to terminate at the end of
1324 MachineBasicBlock::const_iterator LastMI =
1325 PrevMBB->getLastNonDebugInstr();
1326 if (LastMI == PrevMBB->end()) {
1327 // Drop DBG_VALUE for empty range.
1328 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1329 << "\t" << *Prev << "\n");
1333 // Terminate after LastMI.
1334 History.push_back(LastMI);
1339 History.push_back(MI);
1341 // Not a DBG_VALUE instruction.
1343 AtBlockEntry = false;
1345 // First known non DBG_VALUE location marks beginning of function
1347 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1348 PrologEndLoc = MI->getDebugLoc();
1350 // Check if the instruction clobbers any registers with debug vars.
1351 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1352 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1353 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1355 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1356 AI.isValid(); ++AI) {
1358 const MDNode *Var = LiveUserVar[Reg];
1361 // Reg is now clobbered.
1362 LiveUserVar[Reg] = 0;
1364 // Was MD last defined by a DBG_VALUE referring to Reg?
1365 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1366 if (HistI == DbgValues.end())
1368 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1369 if (History.empty())
1371 const MachineInstr *Prev = History.back();
1372 // Sanity-check: Register assignments are terminated at the end of
1374 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1376 // Is the variable still in Reg?
1377 if (!isDbgValueInDefinedReg(Prev) ||
1378 Prev->getOperand(0).getReg() != Reg)
1380 // Var is clobbered. Make sure the next instruction gets a label.
1381 History.push_back(MI);
1388 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1390 SmallVectorImpl<const MachineInstr*> &History = I->second;
1391 if (History.empty())
1394 // Make sure the final register assignments are terminated.
1395 const MachineInstr *Prev = History.back();
1396 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1397 const MachineBasicBlock *PrevMBB = Prev->getParent();
1398 MachineBasicBlock::const_iterator LastMI =
1399 PrevMBB->getLastNonDebugInstr();
1400 if (LastMI == PrevMBB->end())
1401 // Drop DBG_VALUE for empty range.
1404 // Terminate after LastMI.
1405 History.push_back(LastMI);
1408 // Request labels for the full history.
1409 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1410 const MachineInstr *MI = History[i];
1411 if (MI->isDebugValue())
1412 requestLabelBeforeInsn(MI);
1414 requestLabelAfterInsn(MI);
1418 PrevInstLoc = DebugLoc();
1419 PrevLabel = FunctionBeginSym;
1421 // Record beginning of function.
1422 if (!PrologEndLoc.isUnknown()) {
1423 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1424 MF->getFunction()->getContext());
1425 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1426 FnStartDL.getScope(MF->getFunction()->getContext()),
1427 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0);
1431 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1432 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1433 ScopeVariables[LS].push_back(Var);
1434 // Vars.push_back(Var);
1437 /// endFunction - Gather and emit post-function debug information.
1439 void DwarfDebug::endFunction(const MachineFunction *MF) {
1440 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1442 // Define end label for subprogram.
1443 FunctionEndSym = Asm->GetTempSymbol("func_end",
1444 Asm->getFunctionNumber());
1445 // Assumes in correct section after the entry point.
1446 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1448 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1449 collectVariableInfo(MF, ProcessedVars);
1451 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1452 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1453 assert(TheCU && "Unable to find compile unit!");
1455 // Construct abstract scopes.
1456 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1457 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1458 LexicalScope *AScope = AList[i];
1459 DISubprogram SP(AScope->getScopeNode());
1461 // Collect info for variables that were optimized out.
1462 DIArray Variables = SP.getVariables();
1463 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1464 DIVariable DV(Variables.getElement(i));
1465 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1467 // Check that DbgVariable for DV wasn't created earlier, when
1468 // findAbstractVariable() was called for inlined instance of DV.
1469 LLVMContext &Ctx = DV->getContext();
1470 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1471 if (AbstractVariables.lookup(CleanDV))
1473 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1474 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1477 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1478 constructScopeDIE(TheCU, AScope);
1481 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1483 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1484 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1486 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1487 MMI->getFrameMoves()));
1490 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1491 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1492 DeleteContainerPointers(I->second);
1493 ScopeVariables.clear();
1494 DeleteContainerPointers(CurrentFnArguments);
1495 UserVariables.clear();
1497 AbstractVariables.clear();
1498 LabelsBeforeInsn.clear();
1499 LabelsAfterInsn.clear();
1503 /// recordSourceLine - Register a source line with debug info. Returns the
1504 /// unique label that was emitted and which provides correspondence to
1505 /// the source line list.
1506 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1512 DIDescriptor Scope(S);
1514 if (Scope.isCompileUnit()) {
1515 DICompileUnit CU(S);
1516 Fn = CU.getFilename();
1517 Dir = CU.getDirectory();
1518 } else if (Scope.isFile()) {
1520 Fn = F.getFilename();
1521 Dir = F.getDirectory();
1522 } else if (Scope.isSubprogram()) {
1524 Fn = SP.getFilename();
1525 Dir = SP.getDirectory();
1526 } else if (Scope.isLexicalBlockFile()) {
1527 DILexicalBlockFile DBF(S);
1528 Fn = DBF.getFilename();
1529 Dir = DBF.getDirectory();
1530 } else if (Scope.isLexicalBlock()) {
1531 DILexicalBlock DB(S);
1532 Fn = DB.getFilename();
1533 Dir = DB.getDirectory();
1535 llvm_unreachable("Unexpected scope info");
1537 Src = GetOrCreateSourceID(Fn, Dir);
1539 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1542 //===----------------------------------------------------------------------===//
1544 //===----------------------------------------------------------------------===//
1546 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1549 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1550 // Get the children.
1551 const std::vector<DIE *> &Children = Die->getChildren();
1553 // Record the abbreviation.
1554 assignAbbrevNumber(Die->getAbbrev());
1556 // Get the abbreviation for this DIE.
1557 unsigned AbbrevNumber = Die->getAbbrevNumber();
1558 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1561 Die->setOffset(Offset);
1563 // Start the size with the size of abbreviation code.
1564 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1566 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1567 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1569 // Size the DIE attribute values.
1570 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1571 // Size attribute value.
1572 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1574 // Size the DIE children if any.
1575 if (!Children.empty()) {
1576 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1577 "Children flag not set");
1579 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1580 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1582 // End of children marker.
1583 Offset += sizeof(int8_t);
1586 Die->setSize(Offset - Die->getOffset());
1590 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1592 void DwarfDebug::computeSizeAndOffsets() {
1593 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1594 E = CUMap.end(); I != E; ++I) {
1595 // Compute size of compile unit header.
1597 sizeof(int32_t) + // Length of Compilation Unit Info
1598 sizeof(int16_t) + // DWARF version number
1599 sizeof(int32_t) + // Offset Into Abbrev. Section
1600 sizeof(int8_t); // Pointer Size (in bytes)
1601 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1605 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1606 /// the start of each one.
1607 void DwarfDebug::EmitSectionLabels() {
1608 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1610 // Dwarf sections base addresses.
1611 DwarfInfoSectionSym =
1612 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1613 DwarfAbbrevSectionSym =
1614 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1615 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1617 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1618 EmitSectionSym(Asm, MacroInfo);
1620 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1621 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1622 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1623 DwarfStrSectionSym =
1624 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1625 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1628 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1629 "section_debug_loc");
1631 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1632 EmitSectionSym(Asm, TLOF.getDataSection());
1635 /// emitDIE - Recursively emits a debug information entry.
1637 void DwarfDebug::emitDIE(DIE *Die) {
1638 // Get the abbreviation for this DIE.
1639 unsigned AbbrevNumber = Die->getAbbrevNumber();
1640 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1642 // Emit the code (index) for the abbreviation.
1643 if (Asm->isVerbose())
1644 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1645 Twine::utohexstr(Die->getOffset()) + ":0x" +
1646 Twine::utohexstr(Die->getSize()) + " " +
1647 dwarf::TagString(Abbrev->getTag()));
1648 Asm->EmitULEB128(AbbrevNumber);
1650 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1651 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1653 // Emit the DIE attribute values.
1654 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1655 unsigned Attr = AbbrevData[i].getAttribute();
1656 unsigned Form = AbbrevData[i].getForm();
1657 assert(Form && "Too many attributes for DIE (check abbreviation)");
1659 if (Asm->isVerbose())
1660 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1663 case dwarf::DW_AT_abstract_origin: {
1664 DIEEntry *E = cast<DIEEntry>(Values[i]);
1665 DIE *Origin = E->getEntry();
1666 unsigned Addr = Origin->getOffset();
1667 Asm->EmitInt32(Addr);
1670 case dwarf::DW_AT_ranges: {
1671 // DW_AT_range Value encodes offset in debug_range section.
1672 DIEInteger *V = cast<DIEInteger>(Values[i]);
1674 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1675 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1679 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1681 DwarfDebugRangeSectionSym,
1686 case dwarf::DW_AT_location: {
1687 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1688 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1689 Asm->EmitLabelReference(L->getValue(), 4);
1691 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1693 Values[i]->EmitValue(Asm, Form);
1697 case dwarf::DW_AT_accessibility: {
1698 if (Asm->isVerbose()) {
1699 DIEInteger *V = cast<DIEInteger>(Values[i]);
1700 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1702 Values[i]->EmitValue(Asm, Form);
1706 // Emit an attribute using the defined form.
1707 Values[i]->EmitValue(Asm, Form);
1712 // Emit the DIE children if any.
1713 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1714 const std::vector<DIE *> &Children = Die->getChildren();
1716 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1717 emitDIE(Children[j]);
1719 if (Asm->isVerbose())
1720 Asm->OutStreamer.AddComment("End Of Children Mark");
1725 /// emitDebugInfo - Emit the debug info section.
1727 void DwarfDebug::emitDebugInfo() {
1728 // Start debug info section.
1729 Asm->OutStreamer.SwitchSection(
1730 Asm->getObjFileLowering().getDwarfInfoSection());
1731 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1732 E = CUMap.end(); I != E; ++I) {
1733 CompileUnit *TheCU = I->second;
1734 DIE *Die = TheCU->getCUDie();
1736 // Emit the compile units header.
1737 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1740 // Emit size of content not including length itself
1741 unsigned ContentSize = Die->getSize() +
1742 sizeof(int16_t) + // DWARF version number
1743 sizeof(int32_t) + // Offset Into Abbrev. Section
1744 sizeof(int8_t); // Pointer Size (in bytes)
1746 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1747 Asm->EmitInt32(ContentSize);
1748 Asm->OutStreamer.AddComment("DWARF version number");
1749 Asm->EmitInt16(dwarf::DWARF_VERSION);
1750 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1751 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1752 DwarfAbbrevSectionSym);
1753 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1754 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1757 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1761 /// emitAbbreviations - Emit the abbreviation section.
1763 void DwarfDebug::emitAbbreviations() const {
1764 // Check to see if it is worth the effort.
1765 if (!Abbreviations.empty()) {
1766 // Start the debug abbrev section.
1767 Asm->OutStreamer.SwitchSection(
1768 Asm->getObjFileLowering().getDwarfAbbrevSection());
1770 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1772 // For each abbrevation.
1773 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1774 // Get abbreviation data
1775 const DIEAbbrev *Abbrev = Abbreviations[i];
1777 // Emit the abbrevations code (base 1 index.)
1778 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1780 // Emit the abbreviations data.
1784 // Mark end of abbreviations.
1785 Asm->EmitULEB128(0, "EOM(3)");
1787 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1791 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1792 /// the line matrix.
1794 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1795 // Define last address of section.
1796 Asm->OutStreamer.AddComment("Extended Op");
1799 Asm->OutStreamer.AddComment("Op size");
1800 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1801 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1802 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1804 Asm->OutStreamer.AddComment("Section end label");
1806 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1807 Asm->getTargetData().getPointerSize(),
1810 // Mark end of matrix.
1811 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1817 /// emitAccelNames - Emit visible names into a hashed accelerator table
1819 void DwarfDebug::emitAccelNames() {
1820 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1821 dwarf::DW_FORM_data4));
1822 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1823 E = CUMap.end(); I != E; ++I) {
1824 CompileUnit *TheCU = I->second;
1825 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1826 for (StringMap<std::vector<DIE*> >::const_iterator
1827 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1828 const char *Name = GI->getKeyData();
1829 const std::vector<DIE *> &Entities = GI->second;
1830 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1831 DE = Entities.end(); DI != DE; ++DI)
1832 AT.AddName(Name, (*DI));
1836 AT.FinalizeTable(Asm, "Names");
1837 Asm->OutStreamer.SwitchSection(
1838 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1839 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1840 Asm->OutStreamer.EmitLabel(SectionBegin);
1842 // Emit the full data.
1843 AT.Emit(Asm, SectionBegin, this);
1846 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1847 /// accelerator table section.
1848 void DwarfDebug::emitAccelObjC() {
1849 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1850 dwarf::DW_FORM_data4));
1851 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1852 E = CUMap.end(); I != E; ++I) {
1853 CompileUnit *TheCU = I->second;
1854 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1855 for (StringMap<std::vector<DIE*> >::const_iterator
1856 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1857 const char *Name = GI->getKeyData();
1858 const std::vector<DIE *> &Entities = GI->second;
1859 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1860 DE = Entities.end(); DI != DE; ++DI)
1861 AT.AddName(Name, (*DI));
1865 AT.FinalizeTable(Asm, "ObjC");
1866 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1867 .getDwarfAccelObjCSection());
1868 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1869 Asm->OutStreamer.EmitLabel(SectionBegin);
1871 // Emit the full data.
1872 AT.Emit(Asm, SectionBegin, this);
1875 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1877 void DwarfDebug::emitAccelNamespaces() {
1878 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1879 dwarf::DW_FORM_data4));
1880 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1881 E = CUMap.end(); I != E; ++I) {
1882 CompileUnit *TheCU = I->second;
1883 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1884 for (StringMap<std::vector<DIE*> >::const_iterator
1885 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1886 const char *Name = GI->getKeyData();
1887 const std::vector<DIE *> &Entities = GI->second;
1888 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1889 DE = Entities.end(); DI != DE; ++DI)
1890 AT.AddName(Name, (*DI));
1894 AT.FinalizeTable(Asm, "namespac");
1895 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1896 .getDwarfAccelNamespaceSection());
1897 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1898 Asm->OutStreamer.EmitLabel(SectionBegin);
1900 // Emit the full data.
1901 AT.Emit(Asm, SectionBegin, this);
1904 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1905 void DwarfDebug::emitAccelTypes() {
1906 std::vector<DwarfAccelTable::Atom> Atoms;
1907 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1908 dwarf::DW_FORM_data4));
1909 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1910 dwarf::DW_FORM_data2));
1911 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1912 dwarf::DW_FORM_data1));
1913 DwarfAccelTable AT(Atoms);
1914 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1915 E = CUMap.end(); I != E; ++I) {
1916 CompileUnit *TheCU = I->second;
1917 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1918 = TheCU->getAccelTypes();
1919 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1920 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1921 const char *Name = GI->getKeyData();
1922 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1923 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1924 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1925 AT.AddName(Name, (*DI).first, (*DI).second);
1929 AT.FinalizeTable(Asm, "types");
1930 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1931 .getDwarfAccelTypesSection());
1932 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1933 Asm->OutStreamer.EmitLabel(SectionBegin);
1935 // Emit the full data.
1936 AT.Emit(Asm, SectionBegin, this);
1939 void DwarfDebug::emitDebugPubTypes() {
1940 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1941 E = CUMap.end(); I != E; ++I) {
1942 CompileUnit *TheCU = I->second;
1943 // Start the dwarf pubtypes section.
1944 Asm->OutStreamer.SwitchSection(
1945 Asm->getObjFileLowering().getDwarfPubTypesSection());
1946 Asm->OutStreamer.AddComment("Length of Public Types Info");
1947 Asm->EmitLabelDifference(
1948 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1949 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1951 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1954 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1955 Asm->EmitInt16(dwarf::DWARF_VERSION);
1957 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1958 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1959 DwarfInfoSectionSym);
1961 Asm->OutStreamer.AddComment("Compilation Unit Length");
1962 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1963 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1966 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1967 for (StringMap<DIE*>::const_iterator
1968 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1969 const char *Name = GI->getKeyData();
1970 DIE *Entity = GI->second;
1972 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1973 Asm->EmitInt32(Entity->getOffset());
1975 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1976 // Emit the name with a terminating null byte.
1977 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1980 Asm->OutStreamer.AddComment("End Mark");
1982 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1987 /// emitDebugStr - Emit visible names into a debug str section.
1989 void DwarfDebug::emitDebugStr() {
1990 // Check to see if it is worth the effort.
1991 if (StringPool.empty()) return;
1993 // Start the dwarf str section.
1994 Asm->OutStreamer.SwitchSection(
1995 Asm->getObjFileLowering().getDwarfStrSection());
1997 // Get all of the string pool entries and put them in an array by their ID so
1998 // we can sort them.
1999 SmallVector<std::pair<unsigned,
2000 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2002 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2003 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2004 Entries.push_back(std::make_pair(I->second.second, &*I));
2006 array_pod_sort(Entries.begin(), Entries.end());
2008 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2009 // Emit a label for reference from debug information entries.
2010 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2012 // Emit the string itself with a terminating null byte.
2013 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2014 Entries[i].second->getKeyLength()+1),
2019 /// emitDebugLoc - Emit visible names into a debug loc section.
2021 void DwarfDebug::emitDebugLoc() {
2022 if (DotDebugLocEntries.empty())
2025 for (SmallVector<DotDebugLocEntry, 4>::iterator
2026 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2028 DotDebugLocEntry &Entry = *I;
2029 if (I + 1 != DotDebugLocEntries.end())
2033 // Start the dwarf loc section.
2034 Asm->OutStreamer.SwitchSection(
2035 Asm->getObjFileLowering().getDwarfLocSection());
2036 unsigned char Size = Asm->getTargetData().getPointerSize();
2037 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2039 for (SmallVector<DotDebugLocEntry, 4>::iterator
2040 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2041 I != E; ++I, ++index) {
2042 DotDebugLocEntry &Entry = *I;
2043 if (Entry.isMerged()) continue;
2044 if (Entry.isEmpty()) {
2045 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2046 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2047 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2049 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2050 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2051 DIVariable DV(Entry.Variable);
2052 Asm->OutStreamer.AddComment("Loc expr size");
2053 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2054 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2055 Asm->EmitLabelDifference(end, begin, 2);
2056 Asm->OutStreamer.EmitLabel(begin);
2057 if (Entry.isInt()) {
2058 DIBasicType BTy(DV.getType());
2060 (BTy.getEncoding() == dwarf::DW_ATE_signed
2061 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2062 Asm->OutStreamer.AddComment("DW_OP_consts");
2063 Asm->EmitInt8(dwarf::DW_OP_consts);
2064 Asm->EmitSLEB128(Entry.getInt());
2066 Asm->OutStreamer.AddComment("DW_OP_constu");
2067 Asm->EmitInt8(dwarf::DW_OP_constu);
2068 Asm->EmitULEB128(Entry.getInt());
2070 } else if (Entry.isLocation()) {
2071 if (!DV.hasComplexAddress())
2073 Asm->EmitDwarfRegOp(Entry.Loc);
2075 // Complex address entry.
2076 unsigned N = DV.getNumAddrElements();
2078 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2079 if (Entry.Loc.getOffset()) {
2081 Asm->EmitDwarfRegOp(Entry.Loc);
2082 Asm->OutStreamer.AddComment("DW_OP_deref");
2083 Asm->EmitInt8(dwarf::DW_OP_deref);
2084 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2085 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2086 Asm->EmitSLEB128(DV.getAddrElement(1));
2088 // If first address element is OpPlus then emit
2089 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2090 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2091 Asm->EmitDwarfRegOp(Loc);
2095 Asm->EmitDwarfRegOp(Entry.Loc);
2098 // Emit remaining complex address elements.
2099 for (; i < N; ++i) {
2100 uint64_t Element = DV.getAddrElement(i);
2101 if (Element == DIBuilder::OpPlus) {
2102 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2103 Asm->EmitULEB128(DV.getAddrElement(++i));
2104 } else if (Element == DIBuilder::OpDeref) {
2105 if (!Entry.Loc.isReg())
2106 Asm->EmitInt8(dwarf::DW_OP_deref);
2108 llvm_unreachable("unknown Opcode found in complex address");
2112 // else ... ignore constant fp. There is not any good way to
2113 // to represent them here in dwarf.
2114 Asm->OutStreamer.EmitLabel(end);
2119 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2121 void DwarfDebug::EmitDebugARanges() {
2122 // Start the dwarf aranges section.
2123 Asm->OutStreamer.SwitchSection(
2124 Asm->getObjFileLowering().getDwarfARangesSection());
2127 /// emitDebugRanges - Emit visible names into a debug ranges section.
2129 void DwarfDebug::emitDebugRanges() {
2130 // Start the dwarf ranges section.
2131 Asm->OutStreamer.SwitchSection(
2132 Asm->getObjFileLowering().getDwarfRangesSection());
2133 unsigned char Size = Asm->getTargetData().getPointerSize();
2134 for (SmallVector<const MCSymbol *, 8>::iterator
2135 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2138 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2140 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2144 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2146 void DwarfDebug::emitDebugMacInfo() {
2147 if (const MCSection *LineInfo =
2148 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2149 // Start the dwarf macinfo section.
2150 Asm->OutStreamer.SwitchSection(LineInfo);
2154 /// emitDebugInlineInfo - Emit inline info using following format.
2156 /// 1. length of section
2157 /// 2. Dwarf version number
2158 /// 3. address size.
2160 /// Entries (one "entry" for each function that was inlined):
2162 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2163 /// otherwise offset into __debug_str for regular function name.
2164 /// 2. offset into __debug_str section for regular function name.
2165 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2166 /// instances for the function.
2168 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2169 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2170 /// __debug_info section, and the low_pc is the starting address for the
2171 /// inlining instance.
2172 void DwarfDebug::emitDebugInlineInfo() {
2173 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2179 Asm->OutStreamer.SwitchSection(
2180 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2182 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2183 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2184 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2186 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2188 Asm->OutStreamer.AddComment("Dwarf Version");
2189 Asm->EmitInt16(dwarf::DWARF_VERSION);
2190 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2191 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2193 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2194 E = InlinedSPNodes.end(); I != E; ++I) {
2196 const MDNode *Node = *I;
2197 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2198 = InlineInfo.find(Node);
2199 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2200 DISubprogram SP(Node);
2201 StringRef LName = SP.getLinkageName();
2202 StringRef Name = SP.getName();
2204 Asm->OutStreamer.AddComment("MIPS linkage name");
2206 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2208 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2209 DwarfStrSectionSym);
2211 Asm->OutStreamer.AddComment("Function name");
2212 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2213 Asm->EmitULEB128(Labels.size(), "Inline count");
2215 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2216 LE = Labels.end(); LI != LE; ++LI) {
2217 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2218 Asm->EmitInt32(LI->second->getOffset());
2220 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2221 Asm->OutStreamer.EmitSymbolValue(LI->first,
2222 Asm->getTargetData().getPointerSize(),0);
2226 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));