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 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(Args.getElement(i));
330 SPCU->addType(Arg, ATy);
331 if (ATy.isArtificial())
332 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
333 if (ATy.isObjectPointer())
334 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
335 dwarf::DW_FORM_ref4, Arg);
336 SPDie->addChild(Arg);
338 DIE *SPDeclDie = SPDie;
339 SPDie = new DIE(dwarf::DW_TAG_subprogram);
340 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
345 // Pick up abstract subprogram DIE.
346 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
347 SPDie = new DIE(dwarf::DW_TAG_subprogram);
348 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
349 dwarf::DW_FORM_ref4, AbsSPDIE);
353 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
354 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
355 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
356 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
357 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
358 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
359 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
361 // Add name to the name table, we do this here because we're guaranteed
362 // to have concrete versions of our DW_TAG_subprogram nodes.
363 addSubprogramNames(SPCU, SP, SPDie);
368 /// constructLexicalScope - Construct new DW_TAG_lexical_block
369 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
370 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
371 LexicalScope *Scope) {
372 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
373 if (Scope->isAbstractScope())
376 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
380 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
381 if (Ranges.size() > 1) {
382 // .debug_range section has not been laid out yet. Emit offset in
383 // .debug_range as a uint, size 4, for now. emitDIE will handle
384 // DW_AT_ranges appropriately.
385 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
386 DebugRangeSymbols.size()
387 * Asm->getDataLayout().getPointerSize());
388 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
389 RE = Ranges.end(); RI != RE; ++RI) {
390 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
391 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
393 DebugRangeSymbols.push_back(NULL);
394 DebugRangeSymbols.push_back(NULL);
398 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
399 const MCSymbol *End = getLabelAfterInsn(RI->second);
401 if (End == 0) return 0;
403 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
404 assert(End->isDefined() && "Invalid end label for an inlined scope!");
406 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
407 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
412 /// constructInlinedScopeDIE - This scope represents inlined body of
413 /// a function. Construct DIE to represent this concrete inlined copy
415 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
416 LexicalScope *Scope) {
417 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
418 assert(Ranges.empty() == false &&
419 "LexicalScope does not have instruction markers!");
421 if (!Scope->getScopeNode())
423 DIScope DS(Scope->getScopeNode());
424 DISubprogram InlinedSP = getDISubprogram(DS);
425 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
427 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
431 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
432 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
433 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
435 if (StartLabel == 0 || EndLabel == 0) {
436 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
438 assert(StartLabel->isDefined() &&
439 "Invalid starting label for an inlined scope!");
440 assert(EndLabel->isDefined() &&
441 "Invalid end label for an inlined scope!");
443 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
444 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
445 dwarf::DW_FORM_ref4, OriginDIE);
447 if (Ranges.size() > 1) {
448 // .debug_range section has not been laid out yet. Emit offset in
449 // .debug_range as a uint, size 4, for now. emitDIE will handle
450 // DW_AT_ranges appropriately.
451 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
452 DebugRangeSymbols.size()
453 * Asm->getDataLayout().getPointerSize());
454 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
455 RE = Ranges.end(); RI != RE; ++RI) {
456 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
457 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
459 DebugRangeSymbols.push_back(NULL);
460 DebugRangeSymbols.push_back(NULL);
462 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
464 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
468 InlinedSubprogramDIEs.insert(OriginDIE);
470 // Track the start label for this inlined function.
471 //.debug_inlined section specification does not clearly state how
472 // to emit inlined scope that is split into multiple instruction ranges.
473 // For now, use first instruction range and emit low_pc/high_pc pair and
474 // corresponding .debug_inlined section entry for this pair.
475 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
476 I = InlineInfo.find(InlinedSP);
478 if (I == InlineInfo.end()) {
479 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
480 InlinedSPNodes.push_back(InlinedSP);
482 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
484 DILocation DL(Scope->getInlinedAt());
485 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
486 GetOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
487 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
489 // Add name to the name table, we do this here because we're guaranteed
490 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
491 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
496 /// constructScopeDIE - Construct a DIE for this scope.
497 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
498 if (!Scope || !Scope->getScopeNode())
501 SmallVector<DIE *, 8> Children;
502 DIE *ObjectPointer = NULL;
504 // Collect arguments for current function.
505 if (LScopes.isCurrentFunctionScope(Scope))
506 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
507 if (DbgVariable *ArgDV = CurrentFnArguments[i])
509 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
510 Children.push_back(Arg);
511 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
514 // Collect lexical scope children first.
515 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
516 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
518 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
519 Children.push_back(Variable);
520 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
522 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
523 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
524 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
525 Children.push_back(Nested);
526 DIScope DS(Scope->getScopeNode());
527 DIE *ScopeDIE = NULL;
528 if (Scope->getInlinedAt())
529 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
530 else if (DS.isSubprogram()) {
531 ProcessedSPNodes.insert(DS);
532 if (Scope->isAbstractScope()) {
533 ScopeDIE = TheCU->getDIE(DS);
534 // Note down abstract DIE.
536 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
539 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
542 // There is no need to emit empty lexical block DIE.
543 if (Children.empty())
545 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
548 if (!ScopeDIE) return NULL;
551 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
552 E = Children.end(); I != E; ++I)
553 ScopeDIE->addChild(*I);
555 if (DS.isSubprogram() && ObjectPointer != NULL)
556 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
557 dwarf::DW_FORM_ref4, ObjectPointer);
559 if (DS.isSubprogram())
560 TheCU->addPubTypes(DISubprogram(DS));
565 /// GetOrCreateSourceID - Look up the source id with the given directory and
566 /// source file names. If none currently exists, create a new id and insert it
567 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
569 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
571 // If FE did not provide a file name, then assume stdin.
572 if (FileName.empty())
573 return GetOrCreateSourceID("<stdin>", StringRef());
575 // TODO: this might not belong here. See if we can factor this better.
576 if (DirName == CompilationDir)
579 unsigned SrcId = SourceIdMap.size()+1;
581 // We look up the file/dir pair by concatenating them with a zero byte.
582 SmallString<128> NamePair;
584 NamePair += '\0'; // Zero bytes are not allowed in paths.
585 NamePair += FileName;
587 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
588 if (Ent.getValue() != SrcId)
589 return Ent.getValue();
591 // Print out a .file directive to specify files for .loc directives.
592 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
597 /// constructCompileUnit - Create new CompileUnit for the given
598 /// metadata node with tag DW_TAG_compile_unit.
599 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
600 DICompileUnit DIUnit(N);
601 StringRef FN = DIUnit.getFilename();
602 CompilationDir = DIUnit.getDirectory();
603 unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
605 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
606 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die,
608 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
609 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
610 DIUnit.getLanguage());
611 NewCU->addString(Die, dwarf::DW_AT_name, FN);
612 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
614 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
615 // DW_AT_stmt_list is a offset of line number information for this
616 // compile unit in debug_line section.
617 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
618 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
619 Asm->GetTempSymbol("section_line"));
621 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
623 if (!CompilationDir.empty())
624 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
625 if (DIUnit.isOptimized())
626 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
628 StringRef Flags = DIUnit.getFlags();
630 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
632 if (unsigned RVer = DIUnit.getRunTimeVersion())
633 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
634 dwarf::DW_FORM_data1, RVer);
638 CUMap.insert(std::make_pair(N, NewCU));
642 /// construct SubprogramDIE - Construct subprogram DIE.
643 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
645 CompileUnit *&CURef = SPMap[N];
651 if (!SP.isDefinition())
652 // This is a method declaration which will be handled while constructing
656 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
659 TheCU->insertDIE(N, SubprogramDie);
661 // Add to context owner.
662 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
667 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
668 /// as llvm.dbg.enum and llvm.dbg.ty
669 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
670 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
671 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
672 const MDNode *N = NMD->getOperand(i);
673 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
674 constructSubprogramDIE(CU, N);
677 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
678 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
679 const MDNode *N = NMD->getOperand(i);
680 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
681 CU->createGlobalVariableDIE(N);
684 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
685 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
686 DIType Ty(NMD->getOperand(i));
687 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
688 CU->getOrCreateTypeDIE(Ty);
691 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
692 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
693 DIType Ty(NMD->getOperand(i));
694 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
695 CU->getOrCreateTypeDIE(Ty);
699 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
700 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
701 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
702 DebugInfoFinder DbgFinder;
703 DbgFinder.processModule(*M);
705 bool HasDebugInfo = false;
706 // Scan all the compile-units to see if there are any marked as the main
707 // unit. If not, we do not generate debug info.
708 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
709 E = DbgFinder.compile_unit_end(); I != E; ++I) {
710 if (DICompileUnit(*I).isMain()) {
715 if (!HasDebugInfo) return false;
717 // Create all the compile unit DIEs.
718 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
719 E = DbgFinder.compile_unit_end(); I != E; ++I)
720 constructCompileUnit(*I);
722 // Create DIEs for each global variable.
723 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
724 E = DbgFinder.global_variable_end(); I != E; ++I) {
725 const MDNode *N = *I;
726 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
727 CU->createGlobalVariableDIE(N);
730 // Create DIEs for each subprogram.
731 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
732 E = DbgFinder.subprogram_end(); I != E; ++I) {
733 const MDNode *N = *I;
734 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
735 constructSubprogramDIE(CU, N);
741 /// beginModule - Emit all Dwarf sections that should come prior to the
742 /// content. Create global DIEs and emit initial debug info sections.
743 /// This is invoked by the target AsmPrinter.
744 void DwarfDebug::beginModule(Module *M) {
745 if (DisableDebugInfoPrinting)
748 // If module has named metadata anchors then use them, otherwise scan the
749 // module using debug info finder to collect debug info.
750 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
752 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
753 DICompileUnit CUNode(CU_Nodes->getOperand(i));
754 CompileUnit *CU = constructCompileUnit(CUNode);
755 DIArray GVs = CUNode.getGlobalVariables();
756 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
757 CU->createGlobalVariableDIE(GVs.getElement(i));
758 DIArray SPs = CUNode.getSubprograms();
759 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
760 constructSubprogramDIE(CU, SPs.getElement(i));
761 DIArray EnumTypes = CUNode.getEnumTypes();
762 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
763 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
764 DIArray RetainedTypes = CUNode.getRetainedTypes();
765 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
766 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
768 } else if (!collectLegacyDebugInfo(M))
771 collectInfoFromNamedMDNodes(M);
773 // Tell MMI that we have debug info.
774 MMI->setDebugInfoAvailability(true);
776 // Emit initial sections.
779 // Prime section data.
780 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
783 /// endModule - Emit all Dwarf sections that should come after the content.
785 void DwarfDebug::endModule() {
786 if (!FirstCU) return;
787 const Module *M = MMI->getModule();
788 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
790 // Collect info for variables that were optimized out.
791 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
792 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
793 DICompileUnit TheCU(CU_Nodes->getOperand(i));
794 DIArray Subprograms = TheCU.getSubprograms();
795 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
796 DISubprogram SP(Subprograms.getElement(i));
797 if (ProcessedSPNodes.count(SP) != 0) continue;
798 if (!SP.Verify()) continue;
799 if (!SP.isDefinition()) continue;
800 DIArray Variables = SP.getVariables();
801 if (Variables.getNumElements() == 0) continue;
803 LexicalScope *Scope =
804 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
805 DeadFnScopeMap[SP] = Scope;
807 // Construct subprogram DIE and add variables DIEs.
808 CompileUnit *SPCU = CUMap.lookup(TheCU);
809 assert(SPCU && "Unable to find Compile Unit!");
810 constructSubprogramDIE(SPCU, SP);
811 DIE *ScopeDIE = SPCU->getDIE(SP);
812 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
813 DIVariable DV(Variables.getElement(vi));
814 if (!DV.Verify()) continue;
815 DbgVariable *NewVar = new DbgVariable(DV, NULL);
816 if (DIE *VariableDIE =
817 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
818 ScopeDIE->addChild(VariableDIE);
824 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
825 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
826 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
828 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
830 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
831 AE = AbstractSPDies.end(); AI != AE; ++AI) {
832 DIE *ISP = AI->second;
833 if (InlinedSubprogramDIEs.count(ISP))
835 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
838 // Emit DW_AT_containing_type attribute to connect types with their
839 // vtable holding type.
840 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
841 CUE = CUMap.end(); CUI != CUE; ++CUI) {
842 CompileUnit *TheCU = CUI->second;
843 TheCU->constructContainingTypeDIEs();
846 // Standard sections final addresses.
847 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
848 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
849 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
850 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
852 // End text sections.
853 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
854 Asm->OutStreamer.SwitchSection(SectionMap[I]);
855 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
858 // Compute DIE offsets and sizes.
859 computeSizeAndOffsets();
861 // Emit all the DIEs into a debug info section
864 // Corresponding abbreviations into a abbrev section.
867 // Emit info into the dwarf accelerator table sections.
868 if (useDwarfAccelTables()) {
871 emitAccelNamespaces();
875 // Emit info into a debug pubtypes section.
876 // TODO: When we don't need the option anymore we can
877 // remove all of the code that adds to the table.
878 if (useDarwinGDBCompat())
881 // Emit info into a debug loc section.
884 // Emit info into a debug aranges section.
887 // Emit info into a debug ranges section.
890 // Emit info into a debug macinfo section.
894 // TODO: When we don't need the option anymore we
895 // can remove all of the code that this section
897 if (useDarwinGDBCompat())
898 emitDebugInlineInfo();
900 // Emit info into a debug str section.
904 DeleteContainerSeconds(DeadFnScopeMap);
906 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
907 E = CUMap.end(); I != E; ++I)
909 FirstCU = NULL; // Reset for the next Module, if any.
912 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
913 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
915 LLVMContext &Ctx = DV->getContext();
916 // More then one inlined variable corresponds to one abstract variable.
917 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
918 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
920 return AbsDbgVariable;
922 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
926 AbsDbgVariable = new DbgVariable(Var, NULL);
927 addScopeVariable(Scope, AbsDbgVariable);
928 AbstractVariables[Var] = AbsDbgVariable;
929 return AbsDbgVariable;
932 /// addCurrentFnArgument - If Var is a current function argument then add
933 /// it to CurrentFnArguments list.
934 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
935 DbgVariable *Var, LexicalScope *Scope) {
936 if (!LScopes.isCurrentFunctionScope(Scope))
938 DIVariable DV = Var->getVariable();
939 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
941 unsigned ArgNo = DV.getArgNumber();
945 size_t Size = CurrentFnArguments.size();
947 CurrentFnArguments.resize(MF->getFunction()->arg_size());
948 // llvm::Function argument size is not good indicator of how many
949 // arguments does the function have at source level.
951 CurrentFnArguments.resize(ArgNo * 2);
952 CurrentFnArguments[ArgNo - 1] = Var;
956 /// collectVariableInfoFromMMITable - Collect variable information from
957 /// side table maintained by MMI.
959 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
960 SmallPtrSet<const MDNode *, 16> &Processed) {
961 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
962 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
963 VE = VMap.end(); VI != VE; ++VI) {
964 const MDNode *Var = VI->first;
966 Processed.insert(Var);
968 const std::pair<unsigned, DebugLoc> &VP = VI->second;
970 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
972 // If variable scope is not found then skip this variable.
976 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
977 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
978 RegVar->setFrameIndex(VP.first);
979 if (!addCurrentFnArgument(MF, RegVar, Scope))
980 addScopeVariable(Scope, RegVar);
982 AbsDbgVariable->setFrameIndex(VP.first);
986 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
987 /// DBG_VALUE instruction, is in a defined reg.
988 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
989 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
990 return MI->getNumOperands() == 3 &&
991 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
992 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
995 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
997 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
998 const MCSymbol *FLabel,
999 const MCSymbol *SLabel,
1000 const MachineInstr *MI) {
1001 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1003 if (MI->getNumOperands() != 3) {
1004 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1005 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1007 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1008 MachineLocation MLoc;
1009 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1010 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1012 if (MI->getOperand(0).isImm())
1013 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1014 if (MI->getOperand(0).isFPImm())
1015 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1016 if (MI->getOperand(0).isCImm())
1017 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1019 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1022 /// collectVariableInfo - Find variables for each lexical scope.
1024 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1025 SmallPtrSet<const MDNode *, 16> &Processed) {
1027 /// collection info from MMI table.
1028 collectVariableInfoFromMMITable(MF, Processed);
1030 for (SmallVectorImpl<const MDNode*>::const_iterator
1031 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1033 const MDNode *Var = *UVI;
1034 if (Processed.count(Var))
1037 // History contains relevant DBG_VALUE instructions for Var and instructions
1039 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1040 if (History.empty())
1042 const MachineInstr *MInsn = History.front();
1045 LexicalScope *Scope = NULL;
1046 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1047 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1048 Scope = LScopes.getCurrentFunctionScope();
1050 if (DV.getVersion() <= LLVMDebugVersion9)
1051 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1053 if (MDNode *IA = DV.getInlinedAt())
1054 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1056 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1059 // If variable scope is not found then skip this variable.
1063 Processed.insert(DV);
1064 assert(MInsn->isDebugValue() && "History must begin with debug value");
1065 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1066 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1067 if (!addCurrentFnArgument(MF, RegVar, Scope))
1068 addScopeVariable(Scope, RegVar);
1070 AbsVar->setMInsn(MInsn);
1072 // Simplify ranges that are fully coalesced.
1073 if (History.size() <= 1 || (History.size() == 2 &&
1074 MInsn->isIdenticalTo(History.back()))) {
1075 RegVar->setMInsn(MInsn);
1079 // handle multiple DBG_VALUE instructions describing one variable.
1080 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1082 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1083 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1084 const MachineInstr *Begin = *HI;
1085 assert(Begin->isDebugValue() && "Invalid History entry");
1087 // Check if DBG_VALUE is truncating a range.
1088 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1089 && !Begin->getOperand(0).getReg())
1092 // Compute the range for a register location.
1093 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1094 const MCSymbol *SLabel = 0;
1097 // If Begin is the last instruction in History then its value is valid
1098 // until the end of the function.
1099 SLabel = FunctionEndSym;
1101 const MachineInstr *End = HI[1];
1102 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1103 << "\t" << *Begin << "\t" << *End << "\n");
1104 if (End->isDebugValue())
1105 SLabel = getLabelBeforeInsn(End);
1107 // End is a normal instruction clobbering the range.
1108 SLabel = getLabelAfterInsn(End);
1109 assert(SLabel && "Forgot label after clobber instruction");
1114 // The value is valid until the next DBG_VALUE or clobber.
1115 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1118 DotDebugLocEntries.push_back(DotDebugLocEntry());
1121 // Collect info for variables that were optimized out.
1122 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1123 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1124 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1125 DIVariable DV(Variables.getElement(i));
1126 if (!DV || !DV.Verify() || !Processed.insert(DV))
1128 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1129 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1133 /// getLabelBeforeInsn - Return Label preceding the instruction.
1134 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1135 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1136 assert(Label && "Didn't insert label before instruction");
1140 /// getLabelAfterInsn - Return Label immediately following the instruction.
1141 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1142 return LabelsAfterInsn.lookup(MI);
1145 /// beginInstruction - Process beginning of an instruction.
1146 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1147 // Check if source location changes, but ignore DBG_VALUE locations.
1148 if (!MI->isDebugValue()) {
1149 DebugLoc DL = MI->getDebugLoc();
1150 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1153 if (DL == PrologEndLoc) {
1154 Flags |= DWARF2_FLAG_PROLOGUE_END;
1155 PrologEndLoc = DebugLoc();
1157 if (PrologEndLoc.isUnknown())
1158 Flags |= DWARF2_FLAG_IS_STMT;
1160 if (!DL.isUnknown()) {
1161 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1162 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1164 recordSourceLine(0, 0, 0, 0);
1168 // Insert labels where requested.
1169 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1170 LabelsBeforeInsn.find(MI);
1173 if (I == LabelsBeforeInsn.end())
1176 // Label already assigned.
1181 PrevLabel = MMI->getContext().CreateTempSymbol();
1182 Asm->OutStreamer.EmitLabel(PrevLabel);
1184 I->second = PrevLabel;
1187 /// endInstruction - Process end of an instruction.
1188 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1189 // Don't create a new label after DBG_VALUE instructions.
1190 // They don't generate code.
1191 if (!MI->isDebugValue())
1194 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1195 LabelsAfterInsn.find(MI);
1198 if (I == LabelsAfterInsn.end())
1201 // Label already assigned.
1205 // We need a label after this instruction.
1207 PrevLabel = MMI->getContext().CreateTempSymbol();
1208 Asm->OutStreamer.EmitLabel(PrevLabel);
1210 I->second = PrevLabel;
1213 /// identifyScopeMarkers() -
1214 /// Each LexicalScope has first instruction and last instruction to mark
1215 /// beginning and end of a scope respectively. Create an inverse map that list
1216 /// scopes starts (and ends) with an instruction. One instruction may start (or
1217 /// end) multiple scopes. Ignore scopes that are not reachable.
1218 void DwarfDebug::identifyScopeMarkers() {
1219 SmallVector<LexicalScope *, 4> WorkList;
1220 WorkList.push_back(LScopes.getCurrentFunctionScope());
1221 while (!WorkList.empty()) {
1222 LexicalScope *S = WorkList.pop_back_val();
1224 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1225 if (!Children.empty())
1226 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1227 SE = Children.end(); SI != SE; ++SI)
1228 WorkList.push_back(*SI);
1230 if (S->isAbstractScope())
1233 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1236 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1237 RE = Ranges.end(); RI != RE; ++RI) {
1238 assert(RI->first && "InsnRange does not have first instruction!");
1239 assert(RI->second && "InsnRange does not have second instruction!");
1240 requestLabelBeforeInsn(RI->first);
1241 requestLabelAfterInsn(RI->second);
1246 /// getScopeNode - Get MDNode for DebugLoc's scope.
1247 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1248 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1249 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1250 return DL.getScope(Ctx);
1253 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1254 /// line number info for the function.
1255 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1256 const MDNode *Scope = getScopeNode(DL, Ctx);
1257 DISubprogram SP = getDISubprogram(Scope);
1259 // Check for number of operands since the compatibility is
1261 if (SP->getNumOperands() > 19)
1262 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1264 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1270 /// beginFunction - Gather pre-function debug information. Assumes being
1271 /// emitted immediately after the function entry point.
1272 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1273 if (!MMI->hasDebugInfo()) return;
1274 LScopes.initialize(*MF);
1275 if (LScopes.empty()) return;
1276 identifyScopeMarkers();
1278 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1279 Asm->getFunctionNumber());
1280 // Assumes in correct section after the entry point.
1281 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1283 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1285 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1286 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1287 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1289 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1291 bool AtBlockEntry = true;
1292 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1294 const MachineInstr *MI = II;
1296 if (MI->isDebugValue()) {
1297 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1299 // Keep track of user variables.
1301 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1303 // Variable is in a register, we need to check for clobbers.
1304 if (isDbgValueInDefinedReg(MI))
1305 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1307 // Check the history of this variable.
1308 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1309 if (History.empty()) {
1310 UserVariables.push_back(Var);
1311 // The first mention of a function argument gets the FunctionBeginSym
1312 // label, so arguments are visible when breaking at function entry.
1314 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1315 DISubprogram(getDISubprogram(DV.getContext()))
1316 .describes(MF->getFunction()))
1317 LabelsBeforeInsn[MI] = FunctionBeginSym;
1319 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1320 const MachineInstr *Prev = History.back();
1321 if (Prev->isDebugValue()) {
1322 // Coalesce identical entries at the end of History.
1323 if (History.size() >= 2 &&
1324 Prev->isIdenticalTo(History[History.size() - 2])) {
1325 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1327 << "\t" << *History[History.size() - 2] << "\n");
1331 // Terminate old register assignments that don't reach MI;
1332 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1333 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1334 isDbgValueInDefinedReg(Prev)) {
1335 // Previous register assignment needs to terminate at the end of
1337 MachineBasicBlock::const_iterator LastMI =
1338 PrevMBB->getLastNonDebugInstr();
1339 if (LastMI == PrevMBB->end()) {
1340 // Drop DBG_VALUE for empty range.
1341 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1342 << "\t" << *Prev << "\n");
1346 // Terminate after LastMI.
1347 History.push_back(LastMI);
1352 History.push_back(MI);
1354 // Not a DBG_VALUE instruction.
1356 AtBlockEntry = false;
1358 // First known non-DBG_VALUE and non-frame setup location marks
1359 // the beginning of the function body.
1360 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1361 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1362 PrologEndLoc = MI->getDebugLoc();
1364 // Check if the instruction clobbers any registers with debug vars.
1365 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1366 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1367 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1369 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1370 AI.isValid(); ++AI) {
1372 const MDNode *Var = LiveUserVar[Reg];
1375 // Reg is now clobbered.
1376 LiveUserVar[Reg] = 0;
1378 // Was MD last defined by a DBG_VALUE referring to Reg?
1379 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1380 if (HistI == DbgValues.end())
1382 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1383 if (History.empty())
1385 const MachineInstr *Prev = History.back();
1386 // Sanity-check: Register assignments are terminated at the end of
1388 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1390 // Is the variable still in Reg?
1391 if (!isDbgValueInDefinedReg(Prev) ||
1392 Prev->getOperand(0).getReg() != Reg)
1394 // Var is clobbered. Make sure the next instruction gets a label.
1395 History.push_back(MI);
1402 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1404 SmallVectorImpl<const MachineInstr*> &History = I->second;
1405 if (History.empty())
1408 // Make sure the final register assignments are terminated.
1409 const MachineInstr *Prev = History.back();
1410 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1411 const MachineBasicBlock *PrevMBB = Prev->getParent();
1412 MachineBasicBlock::const_iterator LastMI =
1413 PrevMBB->getLastNonDebugInstr();
1414 if (LastMI == PrevMBB->end())
1415 // Drop DBG_VALUE for empty range.
1418 // Terminate after LastMI.
1419 History.push_back(LastMI);
1422 // Request labels for the full history.
1423 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1424 const MachineInstr *MI = History[i];
1425 if (MI->isDebugValue())
1426 requestLabelBeforeInsn(MI);
1428 requestLabelAfterInsn(MI);
1432 PrevInstLoc = DebugLoc();
1433 PrevLabel = FunctionBeginSym;
1435 // Record beginning of function.
1436 if (!PrologEndLoc.isUnknown()) {
1437 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1438 MF->getFunction()->getContext());
1439 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1440 FnStartDL.getScope(MF->getFunction()->getContext()),
1445 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1446 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1447 ScopeVariables[LS].push_back(Var);
1448 // Vars.push_back(Var);
1451 /// endFunction - Gather and emit post-function debug information.
1453 void DwarfDebug::endFunction(const MachineFunction *MF) {
1454 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1456 // Define end label for subprogram.
1457 FunctionEndSym = Asm->GetTempSymbol("func_end",
1458 Asm->getFunctionNumber());
1459 // Assumes in correct section after the entry point.
1460 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1462 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1463 collectVariableInfo(MF, ProcessedVars);
1465 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1466 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1467 assert(TheCU && "Unable to find compile unit!");
1469 // Construct abstract scopes.
1470 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1471 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1472 LexicalScope *AScope = AList[i];
1473 DISubprogram SP(AScope->getScopeNode());
1475 // Collect info for variables that were optimized out.
1476 DIArray Variables = SP.getVariables();
1477 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1478 DIVariable DV(Variables.getElement(i));
1479 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1481 // Check that DbgVariable for DV wasn't created earlier, when
1482 // findAbstractVariable() was called for inlined instance of DV.
1483 LLVMContext &Ctx = DV->getContext();
1484 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1485 if (AbstractVariables.lookup(CleanDV))
1487 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1488 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1491 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1492 constructScopeDIE(TheCU, AScope);
1495 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1497 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1498 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1500 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1501 MMI->getFrameMoves()));
1504 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1505 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1506 DeleteContainerPointers(I->second);
1507 ScopeVariables.clear();
1508 DeleteContainerPointers(CurrentFnArguments);
1509 UserVariables.clear();
1511 AbstractVariables.clear();
1512 LabelsBeforeInsn.clear();
1513 LabelsAfterInsn.clear();
1517 /// recordSourceLine - Register a source line with debug info. Returns the
1518 /// unique label that was emitted and which provides correspondence to
1519 /// the source line list.
1520 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1526 DIDescriptor Scope(S);
1528 if (Scope.isCompileUnit()) {
1529 DICompileUnit CU(S);
1530 Fn = CU.getFilename();
1531 Dir = CU.getDirectory();
1532 } else if (Scope.isFile()) {
1534 Fn = F.getFilename();
1535 Dir = F.getDirectory();
1536 } else if (Scope.isSubprogram()) {
1538 Fn = SP.getFilename();
1539 Dir = SP.getDirectory();
1540 } else if (Scope.isLexicalBlockFile()) {
1541 DILexicalBlockFile DBF(S);
1542 Fn = DBF.getFilename();
1543 Dir = DBF.getDirectory();
1544 } else if (Scope.isLexicalBlock()) {
1545 DILexicalBlock DB(S);
1546 Fn = DB.getFilename();
1547 Dir = DB.getDirectory();
1549 llvm_unreachable("Unexpected scope info");
1551 Src = GetOrCreateSourceID(Fn, Dir);
1553 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1556 //===----------------------------------------------------------------------===//
1558 //===----------------------------------------------------------------------===//
1560 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1563 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1564 // Get the children.
1565 const std::vector<DIE *> &Children = Die->getChildren();
1567 // Record the abbreviation.
1568 assignAbbrevNumber(Die->getAbbrev());
1570 // Get the abbreviation for this DIE.
1571 unsigned AbbrevNumber = Die->getAbbrevNumber();
1572 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1575 Die->setOffset(Offset);
1577 // Start the size with the size of abbreviation code.
1578 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1580 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1581 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1583 // Size the DIE attribute values.
1584 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1585 // Size attribute value.
1586 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1588 // Size the DIE children if any.
1589 if (!Children.empty()) {
1590 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1591 "Children flag not set");
1593 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1594 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1596 // End of children marker.
1597 Offset += sizeof(int8_t);
1600 Die->setSize(Offset - Die->getOffset());
1604 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1606 void DwarfDebug::computeSizeAndOffsets() {
1607 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1608 E = CUMap.end(); I != E; ++I) {
1609 // Compute size of compile unit header.
1611 sizeof(int32_t) + // Length of Compilation Unit Info
1612 sizeof(int16_t) + // DWARF version number
1613 sizeof(int32_t) + // Offset Into Abbrev. Section
1614 sizeof(int8_t); // Pointer Size (in bytes)
1615 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1619 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1620 /// the start of each one.
1621 void DwarfDebug::EmitSectionLabels() {
1622 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1624 // Dwarf sections base addresses.
1625 DwarfInfoSectionSym =
1626 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1627 DwarfAbbrevSectionSym =
1628 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1629 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1631 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1632 EmitSectionSym(Asm, MacroInfo);
1634 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1635 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1636 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1637 DwarfStrSectionSym =
1638 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1639 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1642 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1643 "section_debug_loc");
1645 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1646 EmitSectionSym(Asm, TLOF.getDataSection());
1649 /// emitDIE - Recursively emits a debug information entry.
1651 void DwarfDebug::emitDIE(DIE *Die) {
1652 // Get the abbreviation for this DIE.
1653 unsigned AbbrevNumber = Die->getAbbrevNumber();
1654 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1656 // Emit the code (index) for the abbreviation.
1657 if (Asm->isVerbose())
1658 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1659 Twine::utohexstr(Die->getOffset()) + ":0x" +
1660 Twine::utohexstr(Die->getSize()) + " " +
1661 dwarf::TagString(Abbrev->getTag()));
1662 Asm->EmitULEB128(AbbrevNumber);
1664 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1665 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1667 // Emit the DIE attribute values.
1668 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1669 unsigned Attr = AbbrevData[i].getAttribute();
1670 unsigned Form = AbbrevData[i].getForm();
1671 assert(Form && "Too many attributes for DIE (check abbreviation)");
1673 if (Asm->isVerbose())
1674 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1677 case dwarf::DW_AT_abstract_origin: {
1678 DIEEntry *E = cast<DIEEntry>(Values[i]);
1679 DIE *Origin = E->getEntry();
1680 unsigned Addr = Origin->getOffset();
1681 Asm->EmitInt32(Addr);
1684 case dwarf::DW_AT_ranges: {
1685 // DW_AT_range Value encodes offset in debug_range section.
1686 DIEInteger *V = cast<DIEInteger>(Values[i]);
1688 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1689 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1693 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1695 DwarfDebugRangeSectionSym,
1700 case dwarf::DW_AT_location: {
1701 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1702 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1703 Asm->EmitLabelReference(L->getValue(), 4);
1705 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1707 Values[i]->EmitValue(Asm, Form);
1711 case dwarf::DW_AT_accessibility: {
1712 if (Asm->isVerbose()) {
1713 DIEInteger *V = cast<DIEInteger>(Values[i]);
1714 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1716 Values[i]->EmitValue(Asm, Form);
1720 // Emit an attribute using the defined form.
1721 Values[i]->EmitValue(Asm, Form);
1726 // Emit the DIE children if any.
1727 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1728 const std::vector<DIE *> &Children = Die->getChildren();
1730 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1731 emitDIE(Children[j]);
1733 if (Asm->isVerbose())
1734 Asm->OutStreamer.AddComment("End Of Children Mark");
1739 /// emitDebugInfo - Emit the debug info section.
1741 void DwarfDebug::emitDebugInfo() {
1742 // Start debug info section.
1743 Asm->OutStreamer.SwitchSection(
1744 Asm->getObjFileLowering().getDwarfInfoSection());
1745 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1746 E = CUMap.end(); I != E; ++I) {
1747 CompileUnit *TheCU = I->second;
1748 DIE *Die = TheCU->getCUDie();
1750 // Emit the compile units header.
1751 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1754 // Emit size of content not including length itself
1755 unsigned ContentSize = Die->getSize() +
1756 sizeof(int16_t) + // DWARF version number
1757 sizeof(int32_t) + // Offset Into Abbrev. Section
1758 sizeof(int8_t); // Pointer Size (in bytes)
1760 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1761 Asm->EmitInt32(ContentSize);
1762 Asm->OutStreamer.AddComment("DWARF version number");
1763 Asm->EmitInt16(dwarf::DWARF_VERSION);
1764 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1765 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1766 DwarfAbbrevSectionSym);
1767 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1768 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1771 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1775 /// emitAbbreviations - Emit the abbreviation section.
1777 void DwarfDebug::emitAbbreviations() const {
1778 // Check to see if it is worth the effort.
1779 if (!Abbreviations.empty()) {
1780 // Start the debug abbrev section.
1781 Asm->OutStreamer.SwitchSection(
1782 Asm->getObjFileLowering().getDwarfAbbrevSection());
1784 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1786 // For each abbrevation.
1787 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1788 // Get abbreviation data
1789 const DIEAbbrev *Abbrev = Abbreviations[i];
1791 // Emit the abbrevations code (base 1 index.)
1792 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1794 // Emit the abbreviations data.
1798 // Mark end of abbreviations.
1799 Asm->EmitULEB128(0, "EOM(3)");
1801 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1805 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1806 /// the line matrix.
1808 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1809 // Define last address of section.
1810 Asm->OutStreamer.AddComment("Extended Op");
1813 Asm->OutStreamer.AddComment("Op size");
1814 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1815 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1816 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1818 Asm->OutStreamer.AddComment("Section end label");
1820 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1821 Asm->getDataLayout().getPointerSize(),
1824 // Mark end of matrix.
1825 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1831 /// emitAccelNames - Emit visible names into a hashed accelerator table
1833 void DwarfDebug::emitAccelNames() {
1834 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1835 dwarf::DW_FORM_data4));
1836 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1837 E = CUMap.end(); I != E; ++I) {
1838 CompileUnit *TheCU = I->second;
1839 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1840 for (StringMap<std::vector<DIE*> >::const_iterator
1841 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1842 const char *Name = GI->getKeyData();
1843 const std::vector<DIE *> &Entities = GI->second;
1844 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1845 DE = Entities.end(); DI != DE; ++DI)
1846 AT.AddName(Name, (*DI));
1850 AT.FinalizeTable(Asm, "Names");
1851 Asm->OutStreamer.SwitchSection(
1852 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1853 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1854 Asm->OutStreamer.EmitLabel(SectionBegin);
1856 // Emit the full data.
1857 AT.Emit(Asm, SectionBegin, this);
1860 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1861 /// accelerator table section.
1862 void DwarfDebug::emitAccelObjC() {
1863 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1864 dwarf::DW_FORM_data4));
1865 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1866 E = CUMap.end(); I != E; ++I) {
1867 CompileUnit *TheCU = I->second;
1868 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1869 for (StringMap<std::vector<DIE*> >::const_iterator
1870 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1871 const char *Name = GI->getKeyData();
1872 const std::vector<DIE *> &Entities = GI->second;
1873 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1874 DE = Entities.end(); DI != DE; ++DI)
1875 AT.AddName(Name, (*DI));
1879 AT.FinalizeTable(Asm, "ObjC");
1880 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1881 .getDwarfAccelObjCSection());
1882 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1883 Asm->OutStreamer.EmitLabel(SectionBegin);
1885 // Emit the full data.
1886 AT.Emit(Asm, SectionBegin, this);
1889 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1891 void DwarfDebug::emitAccelNamespaces() {
1892 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1893 dwarf::DW_FORM_data4));
1894 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1895 E = CUMap.end(); I != E; ++I) {
1896 CompileUnit *TheCU = I->second;
1897 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1898 for (StringMap<std::vector<DIE*> >::const_iterator
1899 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1900 const char *Name = GI->getKeyData();
1901 const std::vector<DIE *> &Entities = GI->second;
1902 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1903 DE = Entities.end(); DI != DE; ++DI)
1904 AT.AddName(Name, (*DI));
1908 AT.FinalizeTable(Asm, "namespac");
1909 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1910 .getDwarfAccelNamespaceSection());
1911 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1912 Asm->OutStreamer.EmitLabel(SectionBegin);
1914 // Emit the full data.
1915 AT.Emit(Asm, SectionBegin, this);
1918 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1919 void DwarfDebug::emitAccelTypes() {
1920 std::vector<DwarfAccelTable::Atom> Atoms;
1921 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1922 dwarf::DW_FORM_data4));
1923 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1924 dwarf::DW_FORM_data2));
1925 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1926 dwarf::DW_FORM_data1));
1927 DwarfAccelTable AT(Atoms);
1928 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1929 E = CUMap.end(); I != E; ++I) {
1930 CompileUnit *TheCU = I->second;
1931 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1932 = TheCU->getAccelTypes();
1933 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1934 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1935 const char *Name = GI->getKeyData();
1936 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1937 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1938 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1939 AT.AddName(Name, (*DI).first, (*DI).second);
1943 AT.FinalizeTable(Asm, "types");
1944 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1945 .getDwarfAccelTypesSection());
1946 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1947 Asm->OutStreamer.EmitLabel(SectionBegin);
1949 // Emit the full data.
1950 AT.Emit(Asm, SectionBegin, this);
1953 void DwarfDebug::emitDebugPubTypes() {
1954 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1955 E = CUMap.end(); I != E; ++I) {
1956 CompileUnit *TheCU = I->second;
1957 // Start the dwarf pubtypes section.
1958 Asm->OutStreamer.SwitchSection(
1959 Asm->getObjFileLowering().getDwarfPubTypesSection());
1960 Asm->OutStreamer.AddComment("Length of Public Types Info");
1961 Asm->EmitLabelDifference(
1962 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1963 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1965 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1968 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1969 Asm->EmitInt16(dwarf::DWARF_VERSION);
1971 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1972 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1973 DwarfInfoSectionSym);
1975 Asm->OutStreamer.AddComment("Compilation Unit Length");
1976 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1977 Asm->GetTempSymbol("info_begin", TheCU->getID()),
1980 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1981 for (StringMap<DIE*>::const_iterator
1982 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1983 const char *Name = GI->getKeyData();
1984 DIE *Entity = GI->second;
1986 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1987 Asm->EmitInt32(Entity->getOffset());
1989 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1990 // Emit the name with a terminating null byte.
1991 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1994 Asm->OutStreamer.AddComment("End Mark");
1996 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2001 /// emitDebugStr - Emit visible names into a debug str section.
2003 void DwarfDebug::emitDebugStr() {
2004 // Check to see if it is worth the effort.
2005 if (StringPool.empty()) return;
2007 // Start the dwarf str section.
2008 Asm->OutStreamer.SwitchSection(
2009 Asm->getObjFileLowering().getDwarfStrSection());
2011 // Get all of the string pool entries and put them in an array by their ID so
2012 // we can sort them.
2013 SmallVector<std::pair<unsigned,
2014 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2016 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2017 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2018 Entries.push_back(std::make_pair(I->second.second, &*I));
2020 array_pod_sort(Entries.begin(), Entries.end());
2022 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2023 // Emit a label for reference from debug information entries.
2024 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2026 // Emit the string itself with a terminating null byte.
2027 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2028 Entries[i].second->getKeyLength()+1),
2033 /// emitDebugLoc - Emit visible names into a debug loc section.
2035 void DwarfDebug::emitDebugLoc() {
2036 if (DotDebugLocEntries.empty())
2039 for (SmallVector<DotDebugLocEntry, 4>::iterator
2040 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2042 DotDebugLocEntry &Entry = *I;
2043 if (I + 1 != DotDebugLocEntries.end())
2047 // Start the dwarf loc section.
2048 Asm->OutStreamer.SwitchSection(
2049 Asm->getObjFileLowering().getDwarfLocSection());
2050 unsigned char Size = Asm->getDataLayout().getPointerSize();
2051 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2053 for (SmallVector<DotDebugLocEntry, 4>::iterator
2054 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2055 I != E; ++I, ++index) {
2056 DotDebugLocEntry &Entry = *I;
2057 if (Entry.isMerged()) continue;
2058 if (Entry.isEmpty()) {
2059 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2060 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2061 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2063 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2064 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2065 DIVariable DV(Entry.Variable);
2066 Asm->OutStreamer.AddComment("Loc expr size");
2067 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2068 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2069 Asm->EmitLabelDifference(end, begin, 2);
2070 Asm->OutStreamer.EmitLabel(begin);
2071 if (Entry.isInt()) {
2072 DIBasicType BTy(DV.getType());
2074 (BTy.getEncoding() == dwarf::DW_ATE_signed
2075 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2076 Asm->OutStreamer.AddComment("DW_OP_consts");
2077 Asm->EmitInt8(dwarf::DW_OP_consts);
2078 Asm->EmitSLEB128(Entry.getInt());
2080 Asm->OutStreamer.AddComment("DW_OP_constu");
2081 Asm->EmitInt8(dwarf::DW_OP_constu);
2082 Asm->EmitULEB128(Entry.getInt());
2084 } else if (Entry.isLocation()) {
2085 if (!DV.hasComplexAddress())
2087 Asm->EmitDwarfRegOp(Entry.Loc);
2089 // Complex address entry.
2090 unsigned N = DV.getNumAddrElements();
2092 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2093 if (Entry.Loc.getOffset()) {
2095 Asm->EmitDwarfRegOp(Entry.Loc);
2096 Asm->OutStreamer.AddComment("DW_OP_deref");
2097 Asm->EmitInt8(dwarf::DW_OP_deref);
2098 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2099 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2100 Asm->EmitSLEB128(DV.getAddrElement(1));
2102 // If first address element is OpPlus then emit
2103 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2104 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2105 Asm->EmitDwarfRegOp(Loc);
2109 Asm->EmitDwarfRegOp(Entry.Loc);
2112 // Emit remaining complex address elements.
2113 for (; i < N; ++i) {
2114 uint64_t Element = DV.getAddrElement(i);
2115 if (Element == DIBuilder::OpPlus) {
2116 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2117 Asm->EmitULEB128(DV.getAddrElement(++i));
2118 } else if (Element == DIBuilder::OpDeref) {
2119 if (!Entry.Loc.isReg())
2120 Asm->EmitInt8(dwarf::DW_OP_deref);
2122 llvm_unreachable("unknown Opcode found in complex address");
2126 // else ... ignore constant fp. There is not any good way to
2127 // to represent them here in dwarf.
2128 Asm->OutStreamer.EmitLabel(end);
2133 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2135 void DwarfDebug::EmitDebugARanges() {
2136 // Start the dwarf aranges section.
2137 Asm->OutStreamer.SwitchSection(
2138 Asm->getObjFileLowering().getDwarfARangesSection());
2141 /// emitDebugRanges - Emit visible names into a debug ranges section.
2143 void DwarfDebug::emitDebugRanges() {
2144 // Start the dwarf ranges section.
2145 Asm->OutStreamer.SwitchSection(
2146 Asm->getObjFileLowering().getDwarfRangesSection());
2147 unsigned char Size = Asm->getDataLayout().getPointerSize();
2148 for (SmallVector<const MCSymbol *, 8>::iterator
2149 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2152 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2154 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2158 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2160 void DwarfDebug::emitDebugMacInfo() {
2161 if (const MCSection *LineInfo =
2162 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2163 // Start the dwarf macinfo section.
2164 Asm->OutStreamer.SwitchSection(LineInfo);
2168 /// emitDebugInlineInfo - Emit inline info using following format.
2170 /// 1. length of section
2171 /// 2. Dwarf version number
2172 /// 3. address size.
2174 /// Entries (one "entry" for each function that was inlined):
2176 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2177 /// otherwise offset into __debug_str for regular function name.
2178 /// 2. offset into __debug_str section for regular function name.
2179 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2180 /// instances for the function.
2182 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2183 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2184 /// __debug_info section, and the low_pc is the starting address for the
2185 /// inlining instance.
2186 void DwarfDebug::emitDebugInlineInfo() {
2187 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2193 Asm->OutStreamer.SwitchSection(
2194 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2196 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2197 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2198 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2200 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2202 Asm->OutStreamer.AddComment("Dwarf Version");
2203 Asm->EmitInt16(dwarf::DWARF_VERSION);
2204 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2205 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2207 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2208 E = InlinedSPNodes.end(); I != E; ++I) {
2210 const MDNode *Node = *I;
2211 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2212 = InlineInfo.find(Node);
2213 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2214 DISubprogram SP(Node);
2215 StringRef LName = SP.getLinkageName();
2216 StringRef Name = SP.getName();
2218 Asm->OutStreamer.AddComment("MIPS linkage name");
2220 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2222 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2223 DwarfStrSectionSym);
2225 Asm->OutStreamer.AddComment("Function name");
2226 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2227 Asm->EmitULEB128(Labels.size(), "Inline count");
2229 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2230 LE = Labels.end(); LI != LE; ++LI) {
2231 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2232 Asm->EmitInt32(LI->second->getOffset());
2234 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2235 Asm->OutStreamer.EmitSymbolValue(LI->first,
2236 Asm->getDataLayout().getPointerSize(),0);
2240 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));