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"),
81 static cl::opt<DefaultOnOff> DwarfFission("dwarf-fission", cl::Hidden,
82 cl::desc("Output prototype dwarf fission."),
84 clEnumVal(Default, "Default for platform"),
85 clEnumVal(Enable, "Enabled"),
86 clEnumVal(Disable, "Disabled"),
91 const char *DWARFGroupName = "DWARF Emission";
92 const char *DbgTimerName = "DWARF Debug Writer";
93 } // end anonymous namespace
95 //===----------------------------------------------------------------------===//
97 /// Configuration values for initial hash set sizes (log2).
99 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
103 DIType DbgVariable::getType() const {
104 DIType Ty = Var.getType();
105 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
106 // addresses instead.
107 if (Var.isBlockByrefVariable()) {
108 /* Byref variables, in Blocks, are declared by the programmer as
109 "SomeType VarName;", but the compiler creates a
110 __Block_byref_x_VarName struct, and gives the variable VarName
111 either the struct, or a pointer to the struct, as its type. This
112 is necessary for various behind-the-scenes things the compiler
113 needs to do with by-reference variables in blocks.
115 However, as far as the original *programmer* is concerned, the
116 variable should still have type 'SomeType', as originally declared.
118 The following function dives into the __Block_byref_x_VarName
119 struct to find the original type of the variable. This will be
120 passed back to the code generating the type for the Debug
121 Information Entry for the variable 'VarName'. 'VarName' will then
122 have the original type 'SomeType' in its debug information.
124 The original type 'SomeType' will be the type of the field named
125 'VarName' inside the __Block_byref_x_VarName struct.
127 NOTE: In order for this to not completely fail on the debugger
128 side, the Debug Information Entry for the variable VarName needs to
129 have a DW_AT_location that tells the debugger how to unwind through
130 the pointers and __Block_byref_x_VarName struct to find the actual
131 value of the variable. The function addBlockByrefType does this. */
133 unsigned tag = Ty.getTag();
135 if (tag == dwarf::DW_TAG_pointer_type) {
136 DIDerivedType DTy = DIDerivedType(Ty);
137 subType = DTy.getTypeDerivedFrom();
140 DICompositeType blockStruct = DICompositeType(subType);
141 DIArray Elements = blockStruct.getTypeArray();
143 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
144 DIDescriptor Element = Elements.getElement(i);
145 DIDerivedType DT = DIDerivedType(Element);
146 if (getName() == DT.getName())
147 return (DT.getTypeDerivedFrom());
153 } // end llvm namespace
155 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
156 : Asm(A), MMI(Asm->MMI), FirstCU(0),
157 AbbreviationsSet(InitAbbreviationsSetSize),
158 SourceIdMap(DIEValueAllocator), StringPool(DIEValueAllocator),
160 NextStringPoolNumber = 0;
162 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
163 DwarfStrSectionSym = TextSectionSym = 0;
164 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
165 FunctionBeginSym = FunctionEndSym = 0;
167 // Turn on accelerator tables and older gdb compatibility
169 bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
170 if (DarwinGDBCompat == Default) {
172 IsDarwinGDBCompat = true;
174 IsDarwinGDBCompat = false;
176 IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
178 if (DwarfAccelTables == Default) {
180 HasDwarfAccelTables = true;
182 HasDwarfAccelTables = false;
184 HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
186 if (DwarfFission == Default)
187 HasDwarfFission = false;
189 HasDwarfFission = DwarfFission == Enable ? true : false;
192 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
196 DwarfDebug::~DwarfDebug() {
199 /// emitSectionSym - Switch to the specified MCSection and emit an assembler
200 /// temporary label to it if SymbolStem is specified.
201 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
202 const char *SymbolStem = 0) {
203 Asm->OutStreamer.SwitchSection(Section);
204 if (!SymbolStem) return 0;
206 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
207 Asm->OutStreamer.EmitLabel(TmpSym);
211 MCSymbol *DwarfDebug::getStringPool() {
212 return Asm->GetTempSymbol("section_str");
215 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
216 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
217 if (Entry.first) return Entry.first;
219 Entry.second = NextStringPoolNumber++;
220 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
223 /// assignAbbrevNumber - Define a unique number for the abbreviation.
225 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
226 // Profile the node so that we can make it unique.
230 // Check the set for priors.
231 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
233 // If it's newly added.
234 if (InSet == &Abbrev) {
235 // Add to abbreviation list.
236 Abbreviations.push_back(&Abbrev);
238 // Assign the vector position + 1 as its number.
239 Abbrev.setNumber(Abbreviations.size());
241 // Assign existing abbreviation number.
242 Abbrev.setNumber(InSet->getNumber());
246 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
247 /// printer to not emit usual symbol prefix before the symbol name is used then
248 /// return linkage name after skipping this special LLVM prefix.
249 static StringRef getRealLinkageName(StringRef LinkageName) {
251 if (LinkageName.startswith(StringRef(&One, 1)))
252 return LinkageName.substr(1);
256 static bool isObjCClass(StringRef Name) {
257 return Name.startswith("+") || Name.startswith("-");
260 static bool hasObjCCategory(StringRef Name) {
261 if (!isObjCClass(Name)) return false;
263 size_t pos = Name.find(')');
264 if (pos != std::string::npos) {
265 if (Name[pos+1] != ' ') return false;
271 static void getObjCClassCategory(StringRef In, StringRef &Class,
272 StringRef &Category) {
273 if (!hasObjCCategory(In)) {
274 Class = In.slice(In.find('[') + 1, In.find(' '));
279 Class = In.slice(In.find('[') + 1, In.find('('));
280 Category = In.slice(In.find('[') + 1, In.find(' '));
284 static StringRef getObjCMethodName(StringRef In) {
285 return In.slice(In.find(' ') + 1, In.find(']'));
288 // Add the various names to the Dwarf accelerator table names.
289 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
291 if (!SP.isDefinition()) return;
293 TheCU->addAccelName(SP.getName(), Die);
295 // If the linkage name is different than the name, go ahead and output
296 // that as well into the name table.
297 if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
298 TheCU->addAccelName(SP.getLinkageName(), Die);
300 // If this is an Objective-C selector name add it to the ObjC accelerator
302 if (isObjCClass(SP.getName())) {
303 StringRef Class, Category;
304 getObjCClassCategory(SP.getName(), Class, Category);
305 TheCU->addAccelObjC(Class, Die);
307 TheCU->addAccelObjC(Category, Die);
308 // Also add the base method name to the name table.
309 TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
313 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
314 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
315 /// If there are global variables in this scope then create and insert
316 /// DIEs for these variables.
317 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
318 const MDNode *SPNode) {
319 DIE *SPDie = SPCU->getDIE(SPNode);
321 assert(SPDie && "Unable to find subprogram DIE!");
322 DISubprogram SP(SPNode);
324 // If we're updating an abstract DIE, then we will be adding the children and
325 // object pointer later on. But what we don't want to do is process the
326 // concrete DIE twice.
327 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
328 // Pick up abstract subprogram DIE.
329 SPDie = new DIE(dwarf::DW_TAG_subprogram);
330 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
331 dwarf::DW_FORM_ref4, AbsSPDIE);
334 DISubprogram SPDecl = SP.getFunctionDeclaration();
335 if (!SPDecl.isSubprogram()) {
336 // There is not any need to generate specification DIE for a function
337 // defined at compile unit level. If a function is defined inside another
338 // function then gdb prefers the definition at top level and but does not
339 // expect specification DIE in parent function. So avoid creating
340 // specification DIE for a function defined inside a function.
341 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
342 !SP.getContext().isFile() &&
343 !isSubprogramContext(SP.getContext())) {
344 SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
347 DICompositeType SPTy = SP.getType();
348 DIArray Args = SPTy.getTypeArray();
349 unsigned SPTag = SPTy.getTag();
350 if (SPTag == dwarf::DW_TAG_subroutine_type)
351 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
352 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
353 DIType ATy = DIType(Args.getElement(i));
354 SPCU->addType(Arg, ATy);
355 if (ATy.isArtificial())
356 SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
357 if (ATy.isObjectPointer())
358 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
359 dwarf::DW_FORM_ref4, Arg);
360 SPDie->addChild(Arg);
362 DIE *SPDeclDie = SPDie;
363 SPDie = new DIE(dwarf::DW_TAG_subprogram);
364 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
365 dwarf::DW_FORM_ref4, SPDeclDie);
371 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
372 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
373 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
374 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
375 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
376 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
377 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
379 // Add name to the name table, we do this here because we're guaranteed
380 // to have concrete versions of our DW_TAG_subprogram nodes.
381 addSubprogramNames(SPCU, SP, SPDie);
386 /// constructLexicalScope - Construct new DW_TAG_lexical_block
387 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
388 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
389 LexicalScope *Scope) {
390 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
391 if (Scope->isAbstractScope())
394 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
398 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
399 if (Ranges.size() > 1) {
400 // .debug_range section has not been laid out yet. Emit offset in
401 // .debug_range as a uint, size 4, for now. emitDIE will handle
402 // DW_AT_ranges appropriately.
403 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
404 DebugRangeSymbols.size()
405 * Asm->getDataLayout().getPointerSize());
406 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
407 RE = Ranges.end(); RI != RE; ++RI) {
408 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
409 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
411 DebugRangeSymbols.push_back(NULL);
412 DebugRangeSymbols.push_back(NULL);
416 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
417 const MCSymbol *End = getLabelAfterInsn(RI->second);
419 if (End == 0) return 0;
421 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
422 assert(End->isDefined() && "Invalid end label for an inlined scope!");
424 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
425 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
430 /// constructInlinedScopeDIE - This scope represents inlined body of
431 /// a function. Construct DIE to represent this concrete inlined copy
433 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
434 LexicalScope *Scope) {
435 const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
436 assert(Ranges.empty() == false &&
437 "LexicalScope does not have instruction markers!");
439 if (!Scope->getScopeNode())
441 DIScope DS(Scope->getScopeNode());
442 DISubprogram InlinedSP = getDISubprogram(DS);
443 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
445 DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
449 SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
450 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
451 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
453 if (StartLabel == 0 || EndLabel == 0) {
454 llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
456 assert(StartLabel->isDefined() &&
457 "Invalid starting label for an inlined scope!");
458 assert(EndLabel->isDefined() &&
459 "Invalid end label for an inlined scope!");
461 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
462 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
463 dwarf::DW_FORM_ref4, OriginDIE);
465 if (Ranges.size() > 1) {
466 // .debug_range section has not been laid out yet. Emit offset in
467 // .debug_range as a uint, size 4, for now. emitDIE will handle
468 // DW_AT_ranges appropriately.
469 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
470 DebugRangeSymbols.size()
471 * Asm->getDataLayout().getPointerSize());
472 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
473 RE = Ranges.end(); RI != RE; ++RI) {
474 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
475 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
477 DebugRangeSymbols.push_back(NULL);
478 DebugRangeSymbols.push_back(NULL);
480 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
482 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
486 InlinedSubprogramDIEs.insert(OriginDIE);
488 // Track the start label for this inlined function.
489 //.debug_inlined section specification does not clearly state how
490 // to emit inlined scope that is split into multiple instruction ranges.
491 // For now, use first instruction range and emit low_pc/high_pc pair and
492 // corresponding .debug_inlined section entry for this pair.
493 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
494 I = InlineInfo.find(InlinedSP);
496 if (I == InlineInfo.end()) {
497 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
498 InlinedSPNodes.push_back(InlinedSP);
500 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
502 DILocation DL(Scope->getInlinedAt());
503 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
504 getOrCreateSourceID(DL.getFilename(), DL.getDirectory()));
505 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
507 // Add name to the name table, we do this here because we're guaranteed
508 // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
509 addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
514 /// constructScopeDIE - Construct a DIE for this scope.
515 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
516 if (!Scope || !Scope->getScopeNode())
519 SmallVector<DIE *, 8> Children;
520 DIE *ObjectPointer = NULL;
522 // Collect arguments for current function.
523 if (LScopes.isCurrentFunctionScope(Scope))
524 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
525 if (DbgVariable *ArgDV = CurrentFnArguments[i])
527 TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
528 Children.push_back(Arg);
529 if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
532 // Collect lexical scope children first.
533 const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
534 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
536 TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
537 Children.push_back(Variable);
538 if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
540 const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
541 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
542 if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
543 Children.push_back(Nested);
544 DIScope DS(Scope->getScopeNode());
545 DIE *ScopeDIE = NULL;
546 if (Scope->getInlinedAt())
547 ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
548 else if (DS.isSubprogram()) {
549 ProcessedSPNodes.insert(DS);
550 if (Scope->isAbstractScope()) {
551 ScopeDIE = TheCU->getDIE(DS);
552 // Note down abstract DIE.
554 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
557 ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
560 // There is no need to emit empty lexical block DIE.
561 if (Children.empty())
563 ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
566 if (!ScopeDIE) return NULL;
569 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
570 E = Children.end(); I != E; ++I)
571 ScopeDIE->addChild(*I);
573 if (DS.isSubprogram() && ObjectPointer != NULL)
574 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
575 dwarf::DW_FORM_ref4, ObjectPointer);
577 if (DS.isSubprogram())
578 TheCU->addPubTypes(DISubprogram(DS));
583 /// getOrCreateSourceID - Look up the source id with the given directory and
584 /// source file names. If none currently exists, create a new id and insert it
585 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
587 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
589 // If FE did not provide a file name, then assume stdin.
590 if (FileName.empty())
591 return getOrCreateSourceID("<stdin>", StringRef());
593 // TODO: this might not belong here. See if we can factor this better.
594 if (DirName == CompilationDir)
597 unsigned SrcId = SourceIdMap.size()+1;
599 // We look up the file/dir pair by concatenating them with a zero byte.
600 SmallString<128> NamePair;
602 NamePair += '\0'; // Zero bytes are not allowed in paths.
603 NamePair += FileName;
605 StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
606 if (Ent.getValue() != SrcId)
607 return Ent.getValue();
609 // Print out a .file directive to specify files for .loc directives.
610 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName);
615 /// constructCompileUnit - Create new CompileUnit for the given
616 /// metadata node with tag DW_TAG_compile_unit.
617 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
618 DICompileUnit DIUnit(N);
619 StringRef FN = DIUnit.getFilename();
620 CompilationDir = DIUnit.getDirectory();
621 unsigned ID = getOrCreateSourceID(FN, CompilationDir);
623 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
624 CompileUnit *NewCU = new CompileUnit(ID, DIUnit.getLanguage(), Die,
626 NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
627 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
628 DIUnit.getLanguage());
629 NewCU->addString(Die, dwarf::DW_AT_name, FN);
630 // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
632 NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
633 // DW_AT_stmt_list is a offset of line number information for this
634 // compile unit in debug_line section.
635 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
636 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
637 Asm->GetTempSymbol("section_line"));
639 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
641 if (!CompilationDir.empty())
642 NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
643 if (DIUnit.isOptimized())
644 NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
646 StringRef Flags = DIUnit.getFlags();
648 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
650 if (unsigned RVer = DIUnit.getRunTimeVersion())
651 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
652 dwarf::DW_FORM_data1, RVer);
656 CUMap.insert(std::make_pair(N, NewCU));
660 /// construct SubprogramDIE - Construct subprogram DIE.
661 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
663 CompileUnit *&CURef = SPMap[N];
669 if (!SP.isDefinition())
670 // This is a method declaration which will be handled while constructing
674 DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
677 TheCU->insertDIE(N, SubprogramDie);
679 // Add to context owner.
680 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
685 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
686 /// as llvm.dbg.enum and llvm.dbg.ty
687 void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
688 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
689 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
690 const MDNode *N = NMD->getOperand(i);
691 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
692 constructSubprogramDIE(CU, N);
695 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
696 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
697 const MDNode *N = NMD->getOperand(i);
698 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
699 CU->createGlobalVariableDIE(N);
702 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
703 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
704 DIType Ty(NMD->getOperand(i));
705 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
706 CU->getOrCreateTypeDIE(Ty);
709 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
710 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
711 DIType Ty(NMD->getOperand(i));
712 if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
713 CU->getOrCreateTypeDIE(Ty);
717 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
718 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
719 bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
720 DebugInfoFinder DbgFinder;
721 DbgFinder.processModule(*M);
723 bool HasDebugInfo = false;
724 // Scan all the compile-units to see if there are any marked as the main
725 // unit. If not, we do not generate debug info.
726 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
727 E = DbgFinder.compile_unit_end(); I != E; ++I) {
728 if (DICompileUnit(*I).isMain()) {
733 if (!HasDebugInfo) return false;
735 // Create all the compile unit DIEs.
736 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
737 E = DbgFinder.compile_unit_end(); I != E; ++I)
738 constructCompileUnit(*I);
740 // Create DIEs for each global variable.
741 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
742 E = DbgFinder.global_variable_end(); I != E; ++I) {
743 const MDNode *N = *I;
744 if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
745 CU->createGlobalVariableDIE(N);
748 // Create DIEs for each subprogram.
749 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
750 E = DbgFinder.subprogram_end(); I != E; ++I) {
751 const MDNode *N = *I;
752 if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
753 constructSubprogramDIE(CU, N);
759 /// beginModule - Emit all Dwarf sections that should come prior to the
760 /// content. Create global DIEs and emit initial debug info sections.
761 /// This is invoked by the target AsmPrinter.
762 void DwarfDebug::beginModule() {
763 if (DisableDebugInfoPrinting)
766 const Module *M = MMI->getModule();
768 // If module has named metadata anchors then use them, otherwise scan the
769 // module using debug info finder to collect debug info.
770 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
772 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
773 DICompileUnit CUNode(CU_Nodes->getOperand(i));
774 CompileUnit *CU = constructCompileUnit(CUNode);
775 DIArray GVs = CUNode.getGlobalVariables();
776 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
777 CU->createGlobalVariableDIE(GVs.getElement(i));
778 DIArray SPs = CUNode.getSubprograms();
779 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
780 constructSubprogramDIE(CU, SPs.getElement(i));
781 DIArray EnumTypes = CUNode.getEnumTypes();
782 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
783 CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
784 DIArray RetainedTypes = CUNode.getRetainedTypes();
785 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
786 CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
788 } else if (!collectLegacyDebugInfo(M))
791 collectInfoFromNamedMDNodes(M);
793 // Tell MMI that we have debug info.
794 MMI->setDebugInfoAvailability(true);
796 // Prime section data.
797 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
800 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
801 void DwarfDebug::computeInlinedDIEs() {
802 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
803 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
804 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
806 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
808 for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
809 AE = AbstractSPDies.end(); AI != AE; ++AI) {
810 DIE *ISP = AI->second;
811 if (InlinedSubprogramDIEs.count(ISP))
813 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
817 // Collect info for variables that were optimized out.
818 void DwarfDebug::collectDeadVariables() {
819 const Module *M = MMI->getModule();
820 DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
822 if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
823 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
824 DICompileUnit TheCU(CU_Nodes->getOperand(i));
825 DIArray Subprograms = TheCU.getSubprograms();
826 for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
827 DISubprogram SP(Subprograms.getElement(i));
828 if (ProcessedSPNodes.count(SP) != 0) continue;
829 if (!SP.Verify()) continue;
830 if (!SP.isDefinition()) continue;
831 DIArray Variables = SP.getVariables();
832 if (Variables.getNumElements() == 0) continue;
834 LexicalScope *Scope =
835 new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
836 DeadFnScopeMap[SP] = Scope;
838 // Construct subprogram DIE and add variables DIEs.
839 CompileUnit *SPCU = CUMap.lookup(TheCU);
840 assert(SPCU && "Unable to find Compile Unit!");
841 constructSubprogramDIE(SPCU, SP);
842 DIE *ScopeDIE = SPCU->getDIE(SP);
843 for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
844 DIVariable DV(Variables.getElement(vi));
845 if (!DV.Verify()) continue;
846 DbgVariable *NewVar = new DbgVariable(DV, NULL);
847 if (DIE *VariableDIE =
848 SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
849 ScopeDIE->addChild(VariableDIE);
854 DeleteContainerSeconds(DeadFnScopeMap);
857 void DwarfDebug::finalizeModuleInfo() {
858 // Collect info for variables that were optimized out.
859 collectDeadVariables();
861 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
862 computeInlinedDIEs();
864 // Emit DW_AT_containing_type attribute to connect types with their
865 // vtable holding type.
866 for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
867 CUE = CUMap.end(); CUI != CUE; ++CUI) {
868 CompileUnit *TheCU = CUI->second;
869 TheCU->constructContainingTypeDIEs();
872 // Compute DIE offsets and sizes.
873 computeSizeAndOffsets();
876 void DwarfDebug::endSections() {
877 // Standard sections final addresses.
878 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
879 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
880 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
881 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
883 // End text sections.
884 for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
885 Asm->OutStreamer.SwitchSection(SectionMap[I]);
886 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
890 /// endModule - Emit all Dwarf sections that should come after the content.
892 void DwarfDebug::endModule() {
894 if (!FirstCU) return;
896 // End any existing sections.
897 // TODO: Does this need to happen?
900 // Finalize the debug info for the module.
901 finalizeModuleInfo();
903 // Emit initial sections.
906 if (!useDwarfFission()) {
907 // Emit all the DIEs into a debug info section.
910 // Corresponding abbreviations into a abbrev section.
913 // Emit info into a debug loc section.
916 // Emit info into a debug aranges section.
919 // Emit info into a debug ranges section.
922 // Emit info into a debug macinfo section.
926 // TODO: When we don't need the option anymore we
927 // can remove all of the code that this section
929 if (useDarwinGDBCompat())
930 emitDebugInlineInfo();
932 // Emit info into a debug str section.
935 // TODO: Fill this in for Fission sections and separate
936 // out information into new sections.
938 // Emit all the DIEs into a debug info section.
941 // Corresponding abbreviations into a abbrev section.
944 // Emit info into a debug loc section.
947 // Emit info into a debug aranges section.
950 // Emit info into a debug ranges section.
953 // Emit info into a debug macinfo section.
957 // TODO: When we don't need the option anymore we
958 // can remove all of the code that this section
960 if (useDarwinGDBCompat())
961 emitDebugInlineInfo();
963 // Emit info into a debug str section.
967 // Emit info into the dwarf accelerator table sections.
968 if (useDwarfAccelTables()) {
971 emitAccelNamespaces();
975 // Emit info into a debug pubtypes section.
976 // TODO: When we don't need the option anymore we can
977 // remove all of the code that adds to the table.
978 if (useDarwinGDBCompat())
983 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
984 E = CUMap.end(); I != E; ++I)
986 FirstCU = NULL; // Reset for the next Module, if any.
989 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
990 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
992 LLVMContext &Ctx = DV->getContext();
993 // More then one inlined variable corresponds to one abstract variable.
994 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
995 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
997 return AbsDbgVariable;
999 LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1003 AbsDbgVariable = new DbgVariable(Var, NULL);
1004 addScopeVariable(Scope, AbsDbgVariable);
1005 AbstractVariables[Var] = AbsDbgVariable;
1006 return AbsDbgVariable;
1009 /// addCurrentFnArgument - If Var is a current function argument then add
1010 /// it to CurrentFnArguments list.
1011 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1012 DbgVariable *Var, LexicalScope *Scope) {
1013 if (!LScopes.isCurrentFunctionScope(Scope))
1015 DIVariable DV = Var->getVariable();
1016 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1018 unsigned ArgNo = DV.getArgNumber();
1022 size_t Size = CurrentFnArguments.size();
1024 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1025 // llvm::Function argument size is not good indicator of how many
1026 // arguments does the function have at source level.
1028 CurrentFnArguments.resize(ArgNo * 2);
1029 CurrentFnArguments[ArgNo - 1] = Var;
1033 /// collectVariableInfoFromMMITable - Collect variable information from
1034 /// side table maintained by MMI.
1036 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1037 SmallPtrSet<const MDNode *, 16> &Processed) {
1038 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1039 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1040 VE = VMap.end(); VI != VE; ++VI) {
1041 const MDNode *Var = VI->first;
1043 Processed.insert(Var);
1045 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1047 LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1049 // If variable scope is not found then skip this variable.
1053 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1054 DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1055 RegVar->setFrameIndex(VP.first);
1056 if (!addCurrentFnArgument(MF, RegVar, Scope))
1057 addScopeVariable(Scope, RegVar);
1059 AbsDbgVariable->setFrameIndex(VP.first);
1063 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1064 /// DBG_VALUE instruction, is in a defined reg.
1065 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1066 assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1067 return MI->getNumOperands() == 3 &&
1068 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1069 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1072 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
1074 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1075 const MCSymbol *FLabel,
1076 const MCSymbol *SLabel,
1077 const MachineInstr *MI) {
1078 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1080 if (MI->getNumOperands() != 3) {
1081 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1082 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1084 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1085 MachineLocation MLoc;
1086 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1087 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1089 if (MI->getOperand(0).isImm())
1090 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1091 if (MI->getOperand(0).isFPImm())
1092 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1093 if (MI->getOperand(0).isCImm())
1094 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1096 llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1099 /// collectVariableInfo - Find variables for each lexical scope.
1101 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1102 SmallPtrSet<const MDNode *, 16> &Processed) {
1104 /// collection info from MMI table.
1105 collectVariableInfoFromMMITable(MF, Processed);
1107 for (SmallVectorImpl<const MDNode*>::const_iterator
1108 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1110 const MDNode *Var = *UVI;
1111 if (Processed.count(Var))
1114 // History contains relevant DBG_VALUE instructions for Var and instructions
1116 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1117 if (History.empty())
1119 const MachineInstr *MInsn = History.front();
1122 LexicalScope *Scope = NULL;
1123 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1124 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1125 Scope = LScopes.getCurrentFunctionScope();
1127 if (DV.getVersion() <= LLVMDebugVersion9)
1128 Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1130 if (MDNode *IA = DV.getInlinedAt())
1131 Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1133 Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1136 // If variable scope is not found then skip this variable.
1140 Processed.insert(DV);
1141 assert(MInsn->isDebugValue() && "History must begin with debug value");
1142 DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1143 DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1144 if (!addCurrentFnArgument(MF, RegVar, Scope))
1145 addScopeVariable(Scope, RegVar);
1147 AbsVar->setMInsn(MInsn);
1149 // Simplify ranges that are fully coalesced.
1150 if (History.size() <= 1 || (History.size() == 2 &&
1151 MInsn->isIdenticalTo(History.back()))) {
1152 RegVar->setMInsn(MInsn);
1156 // handle multiple DBG_VALUE instructions describing one variable.
1157 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1159 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1160 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1161 const MachineInstr *Begin = *HI;
1162 assert(Begin->isDebugValue() && "Invalid History entry");
1164 // Check if DBG_VALUE is truncating a range.
1165 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1166 && !Begin->getOperand(0).getReg())
1169 // Compute the range for a register location.
1170 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1171 const MCSymbol *SLabel = 0;
1174 // If Begin is the last instruction in History then its value is valid
1175 // until the end of the function.
1176 SLabel = FunctionEndSym;
1178 const MachineInstr *End = HI[1];
1179 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1180 << "\t" << *Begin << "\t" << *End << "\n");
1181 if (End->isDebugValue())
1182 SLabel = getLabelBeforeInsn(End);
1184 // End is a normal instruction clobbering the range.
1185 SLabel = getLabelAfterInsn(End);
1186 assert(SLabel && "Forgot label after clobber instruction");
1191 // The value is valid until the next DBG_VALUE or clobber.
1192 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1195 DotDebugLocEntries.push_back(DotDebugLocEntry());
1198 // Collect info for variables that were optimized out.
1199 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1200 DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1201 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1202 DIVariable DV(Variables.getElement(i));
1203 if (!DV || !DV.Verify() || !Processed.insert(DV))
1205 if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1206 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1210 /// getLabelBeforeInsn - Return Label preceding the instruction.
1211 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1212 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1213 assert(Label && "Didn't insert label before instruction");
1217 /// getLabelAfterInsn - Return Label immediately following the instruction.
1218 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1219 return LabelsAfterInsn.lookup(MI);
1222 /// beginInstruction - Process beginning of an instruction.
1223 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1224 // Check if source location changes, but ignore DBG_VALUE locations.
1225 if (!MI->isDebugValue()) {
1226 DebugLoc DL = MI->getDebugLoc();
1227 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1230 if (DL == PrologEndLoc) {
1231 Flags |= DWARF2_FLAG_PROLOGUE_END;
1232 PrologEndLoc = DebugLoc();
1234 if (PrologEndLoc.isUnknown())
1235 Flags |= DWARF2_FLAG_IS_STMT;
1237 if (!DL.isUnknown()) {
1238 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1239 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1241 recordSourceLine(0, 0, 0, 0);
1245 // Insert labels where requested.
1246 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1247 LabelsBeforeInsn.find(MI);
1250 if (I == LabelsBeforeInsn.end())
1253 // Label already assigned.
1258 PrevLabel = MMI->getContext().CreateTempSymbol();
1259 Asm->OutStreamer.EmitLabel(PrevLabel);
1261 I->second = PrevLabel;
1264 /// endInstruction - Process end of an instruction.
1265 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1266 // Don't create a new label after DBG_VALUE instructions.
1267 // They don't generate code.
1268 if (!MI->isDebugValue())
1271 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1272 LabelsAfterInsn.find(MI);
1275 if (I == LabelsAfterInsn.end())
1278 // Label already assigned.
1282 // We need a label after this instruction.
1284 PrevLabel = MMI->getContext().CreateTempSymbol();
1285 Asm->OutStreamer.EmitLabel(PrevLabel);
1287 I->second = PrevLabel;
1290 /// identifyScopeMarkers() -
1291 /// Each LexicalScope has first instruction and last instruction to mark
1292 /// beginning and end of a scope respectively. Create an inverse map that list
1293 /// scopes starts (and ends) with an instruction. One instruction may start (or
1294 /// end) multiple scopes. Ignore scopes that are not reachable.
1295 void DwarfDebug::identifyScopeMarkers() {
1296 SmallVector<LexicalScope *, 4> WorkList;
1297 WorkList.push_back(LScopes.getCurrentFunctionScope());
1298 while (!WorkList.empty()) {
1299 LexicalScope *S = WorkList.pop_back_val();
1301 const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1302 if (!Children.empty())
1303 for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1304 SE = Children.end(); SI != SE; ++SI)
1305 WorkList.push_back(*SI);
1307 if (S->isAbstractScope())
1310 const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1313 for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1314 RE = Ranges.end(); RI != RE; ++RI) {
1315 assert(RI->first && "InsnRange does not have first instruction!");
1316 assert(RI->second && "InsnRange does not have second instruction!");
1317 requestLabelBeforeInsn(RI->first);
1318 requestLabelAfterInsn(RI->second);
1323 /// getScopeNode - Get MDNode for DebugLoc's scope.
1324 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1325 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1326 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1327 return DL.getScope(Ctx);
1330 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1331 /// line number info for the function.
1332 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1333 const MDNode *Scope = getScopeNode(DL, Ctx);
1334 DISubprogram SP = getDISubprogram(Scope);
1336 // Check for number of operands since the compatibility is
1338 if (SP->getNumOperands() > 19)
1339 return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1341 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1347 /// beginFunction - Gather pre-function debug information. Assumes being
1348 /// emitted immediately after the function entry point.
1349 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1350 if (!MMI->hasDebugInfo()) return;
1351 LScopes.initialize(*MF);
1352 if (LScopes.empty()) return;
1353 identifyScopeMarkers();
1355 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1356 Asm->getFunctionNumber());
1357 // Assumes in correct section after the entry point.
1358 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1360 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1362 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1363 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1364 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1366 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1368 bool AtBlockEntry = true;
1369 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1371 const MachineInstr *MI = II;
1373 if (MI->isDebugValue()) {
1374 assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1376 // Keep track of user variables.
1378 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1380 // Variable is in a register, we need to check for clobbers.
1381 if (isDbgValueInDefinedReg(MI))
1382 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1384 // Check the history of this variable.
1385 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1386 if (History.empty()) {
1387 UserVariables.push_back(Var);
1388 // The first mention of a function argument gets the FunctionBeginSym
1389 // label, so arguments are visible when breaking at function entry.
1391 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1392 DISubprogram(getDISubprogram(DV.getContext()))
1393 .describes(MF->getFunction()))
1394 LabelsBeforeInsn[MI] = FunctionBeginSym;
1396 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1397 const MachineInstr *Prev = History.back();
1398 if (Prev->isDebugValue()) {
1399 // Coalesce identical entries at the end of History.
1400 if (History.size() >= 2 &&
1401 Prev->isIdenticalTo(History[History.size() - 2])) {
1402 DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1404 << "\t" << *History[History.size() - 2] << "\n");
1408 // Terminate old register assignments that don't reach MI;
1409 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1410 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1411 isDbgValueInDefinedReg(Prev)) {
1412 // Previous register assignment needs to terminate at the end of
1414 MachineBasicBlock::const_iterator LastMI =
1415 PrevMBB->getLastNonDebugInstr();
1416 if (LastMI == PrevMBB->end()) {
1417 // Drop DBG_VALUE for empty range.
1418 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1419 << "\t" << *Prev << "\n");
1423 // Terminate after LastMI.
1424 History.push_back(LastMI);
1429 History.push_back(MI);
1431 // Not a DBG_VALUE instruction.
1433 AtBlockEntry = false;
1435 // First known non-DBG_VALUE and non-frame setup location marks
1436 // the beginning of the function body.
1437 if (!MI->getFlag(MachineInstr::FrameSetup) &&
1438 (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1439 PrologEndLoc = MI->getDebugLoc();
1441 // Check if the instruction clobbers any registers with debug vars.
1442 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1443 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1444 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1446 for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1447 AI.isValid(); ++AI) {
1449 const MDNode *Var = LiveUserVar[Reg];
1452 // Reg is now clobbered.
1453 LiveUserVar[Reg] = 0;
1455 // Was MD last defined by a DBG_VALUE referring to Reg?
1456 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1457 if (HistI == DbgValues.end())
1459 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1460 if (History.empty())
1462 const MachineInstr *Prev = History.back();
1463 // Sanity-check: Register assignments are terminated at the end of
1465 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1467 // Is the variable still in Reg?
1468 if (!isDbgValueInDefinedReg(Prev) ||
1469 Prev->getOperand(0).getReg() != Reg)
1471 // Var is clobbered. Make sure the next instruction gets a label.
1472 History.push_back(MI);
1479 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1481 SmallVectorImpl<const MachineInstr*> &History = I->second;
1482 if (History.empty())
1485 // Make sure the final register assignments are terminated.
1486 const MachineInstr *Prev = History.back();
1487 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1488 const MachineBasicBlock *PrevMBB = Prev->getParent();
1489 MachineBasicBlock::const_iterator LastMI =
1490 PrevMBB->getLastNonDebugInstr();
1491 if (LastMI == PrevMBB->end())
1492 // Drop DBG_VALUE for empty range.
1495 // Terminate after LastMI.
1496 History.push_back(LastMI);
1499 // Request labels for the full history.
1500 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1501 const MachineInstr *MI = History[i];
1502 if (MI->isDebugValue())
1503 requestLabelBeforeInsn(MI);
1505 requestLabelAfterInsn(MI);
1509 PrevInstLoc = DebugLoc();
1510 PrevLabel = FunctionBeginSym;
1512 // Record beginning of function.
1513 if (!PrologEndLoc.isUnknown()) {
1514 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1515 MF->getFunction()->getContext());
1516 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1517 FnStartDL.getScope(MF->getFunction()->getContext()),
1522 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1523 // SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1524 ScopeVariables[LS].push_back(Var);
1525 // Vars.push_back(Var);
1528 /// endFunction - Gather and emit post-function debug information.
1530 void DwarfDebug::endFunction(const MachineFunction *MF) {
1531 if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1533 // Define end label for subprogram.
1534 FunctionEndSym = Asm->GetTempSymbol("func_end",
1535 Asm->getFunctionNumber());
1536 // Assumes in correct section after the entry point.
1537 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1539 SmallPtrSet<const MDNode *, 16> ProcessedVars;
1540 collectVariableInfo(MF, ProcessedVars);
1542 LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1543 CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1544 assert(TheCU && "Unable to find compile unit!");
1546 // Construct abstract scopes.
1547 ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1548 for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1549 LexicalScope *AScope = AList[i];
1550 DISubprogram SP(AScope->getScopeNode());
1552 // Collect info for variables that were optimized out.
1553 DIArray Variables = SP.getVariables();
1554 for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1555 DIVariable DV(Variables.getElement(i));
1556 if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1558 // Check that DbgVariable for DV wasn't created earlier, when
1559 // findAbstractVariable() was called for inlined instance of DV.
1560 LLVMContext &Ctx = DV->getContext();
1561 DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1562 if (AbstractVariables.lookup(CleanDV))
1564 if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1565 addScopeVariable(Scope, new DbgVariable(DV, NULL));
1568 if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1569 constructScopeDIE(TheCU, AScope);
1572 DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1574 if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1575 TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1577 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1578 MMI->getFrameMoves()));
1581 for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1582 I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1583 DeleteContainerPointers(I->second);
1584 ScopeVariables.clear();
1585 DeleteContainerPointers(CurrentFnArguments);
1586 UserVariables.clear();
1588 AbstractVariables.clear();
1589 LabelsBeforeInsn.clear();
1590 LabelsAfterInsn.clear();
1594 /// recordSourceLine - Register a source line with debug info. Returns the
1595 /// unique label that was emitted and which provides correspondence to
1596 /// the source line list.
1597 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1603 DIDescriptor Scope(S);
1605 if (Scope.isCompileUnit()) {
1606 DICompileUnit CU(S);
1607 Fn = CU.getFilename();
1608 Dir = CU.getDirectory();
1609 } else if (Scope.isFile()) {
1611 Fn = F.getFilename();
1612 Dir = F.getDirectory();
1613 } else if (Scope.isSubprogram()) {
1615 Fn = SP.getFilename();
1616 Dir = SP.getDirectory();
1617 } else if (Scope.isLexicalBlockFile()) {
1618 DILexicalBlockFile DBF(S);
1619 Fn = DBF.getFilename();
1620 Dir = DBF.getDirectory();
1621 } else if (Scope.isLexicalBlock()) {
1622 DILexicalBlock DB(S);
1623 Fn = DB.getFilename();
1624 Dir = DB.getDirectory();
1626 llvm_unreachable("Unexpected scope info");
1628 Src = getOrCreateSourceID(Fn, Dir);
1630 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1633 //===----------------------------------------------------------------------===//
1635 //===----------------------------------------------------------------------===//
1637 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1640 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1641 // Get the children.
1642 const std::vector<DIE *> &Children = Die->getChildren();
1644 // Record the abbreviation.
1645 assignAbbrevNumber(Die->getAbbrev());
1647 // Get the abbreviation for this DIE.
1648 unsigned AbbrevNumber = Die->getAbbrevNumber();
1649 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1652 Die->setOffset(Offset);
1654 // Start the size with the size of abbreviation code.
1655 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1657 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1658 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1660 // Size the DIE attribute values.
1661 for (unsigned i = 0, N = Values.size(); i < N; ++i)
1662 // Size attribute value.
1663 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1665 // Size the DIE children if any.
1666 if (!Children.empty()) {
1667 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1668 "Children flag not set");
1670 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1671 Offset = computeSizeAndOffset(Children[j], Offset);
1673 // End of children marker.
1674 Offset += sizeof(int8_t);
1677 Die->setSize(Offset - Die->getOffset());
1681 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1683 void DwarfDebug::computeSizeAndOffsets() {
1684 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1685 E = CUMap.end(); I != E; ++I) {
1686 // Compute size of compile unit header.
1688 sizeof(int32_t) + // Length of Compilation Unit Info
1689 sizeof(int16_t) + // DWARF version number
1690 sizeof(int32_t) + // Offset Into Abbrev. Section
1691 sizeof(int8_t); // Pointer Size (in bytes)
1692 computeSizeAndOffset(I->second->getCUDie(), Offset);
1696 /// emitSectionLabels - Emit initial Dwarf sections with a label at
1697 /// the start of each one.
1698 void DwarfDebug::emitSectionLabels() {
1699 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1701 // Dwarf sections base addresses.
1702 DwarfInfoSectionSym =
1703 emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1704 DwarfAbbrevSectionSym =
1705 emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1706 emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1708 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1709 emitSectionSym(Asm, MacroInfo);
1711 emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1712 emitSectionSym(Asm, TLOF.getDwarfLocSection());
1713 emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1714 DwarfStrSectionSym =
1715 emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1716 DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1719 DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1720 "section_debug_loc");
1722 TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1723 emitSectionSym(Asm, TLOF.getDataSection());
1726 /// emitDIE - Recursively emits a debug information entry.
1728 void DwarfDebug::emitDIE(DIE *Die) {
1729 // Get the abbreviation for this DIE.
1730 unsigned AbbrevNumber = Die->getAbbrevNumber();
1731 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1733 // Emit the code (index) for the abbreviation.
1734 if (Asm->isVerbose())
1735 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1736 Twine::utohexstr(Die->getOffset()) + ":0x" +
1737 Twine::utohexstr(Die->getSize()) + " " +
1738 dwarf::TagString(Abbrev->getTag()));
1739 Asm->EmitULEB128(AbbrevNumber);
1741 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1742 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1744 // Emit the DIE attribute values.
1745 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1746 unsigned Attr = AbbrevData[i].getAttribute();
1747 unsigned Form = AbbrevData[i].getForm();
1748 assert(Form && "Too many attributes for DIE (check abbreviation)");
1750 if (Asm->isVerbose())
1751 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1754 case dwarf::DW_AT_abstract_origin: {
1755 DIEEntry *E = cast<DIEEntry>(Values[i]);
1756 DIE *Origin = E->getEntry();
1757 unsigned Addr = Origin->getOffset();
1758 Asm->EmitInt32(Addr);
1761 case dwarf::DW_AT_ranges: {
1762 // DW_AT_range Value encodes offset in debug_range section.
1763 DIEInteger *V = cast<DIEInteger>(Values[i]);
1765 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1766 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1770 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1772 DwarfDebugRangeSectionSym,
1777 case dwarf::DW_AT_location: {
1778 if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1779 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1780 Asm->EmitLabelReference(L->getValue(), 4);
1782 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1784 Values[i]->EmitValue(Asm, Form);
1788 case dwarf::DW_AT_accessibility: {
1789 if (Asm->isVerbose()) {
1790 DIEInteger *V = cast<DIEInteger>(Values[i]);
1791 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1793 Values[i]->EmitValue(Asm, Form);
1797 // Emit an attribute using the defined form.
1798 Values[i]->EmitValue(Asm, Form);
1803 // Emit the DIE children if any.
1804 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1805 const std::vector<DIE *> &Children = Die->getChildren();
1807 for (unsigned j = 0, M = Children.size(); j < M; ++j)
1808 emitDIE(Children[j]);
1810 if (Asm->isVerbose())
1811 Asm->OutStreamer.AddComment("End Of Children Mark");
1816 /// emitDebugInfo - Emit the debug info section.
1818 void DwarfDebug::emitDebugInfo() {
1819 // Start debug info section.
1820 Asm->OutStreamer.SwitchSection(
1821 Asm->getObjFileLowering().getDwarfInfoSection());
1822 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1823 E = CUMap.end(); I != E; ++I) {
1824 CompileUnit *TheCU = I->second;
1825 DIE *Die = TheCU->getCUDie();
1827 // Emit the compile units header.
1828 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1831 // Emit size of content not including length itself
1832 unsigned ContentSize = Die->getSize() +
1833 sizeof(int16_t) + // DWARF version number
1834 sizeof(int32_t) + // Offset Into Abbrev. Section
1835 sizeof(int8_t); // Pointer Size (in bytes)
1837 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1838 Asm->EmitInt32(ContentSize);
1839 Asm->OutStreamer.AddComment("DWARF version number");
1840 Asm->EmitInt16(dwarf::DWARF_VERSION);
1841 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1842 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1843 DwarfAbbrevSectionSym);
1844 Asm->OutStreamer.AddComment("Address Size (in bytes)");
1845 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1848 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1852 /// emitAbbreviations - Emit the abbreviation section.
1854 void DwarfDebug::emitAbbreviations() {
1855 // Check to see if it is worth the effort.
1856 if (!Abbreviations.empty()) {
1857 // Start the debug abbrev section.
1858 Asm->OutStreamer.SwitchSection(
1859 Asm->getObjFileLowering().getDwarfAbbrevSection());
1861 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1863 // For each abbrevation.
1864 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1865 // Get abbreviation data
1866 const DIEAbbrev *Abbrev = Abbreviations[i];
1868 // Emit the abbrevations code (base 1 index.)
1869 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1871 // Emit the abbreviations data.
1875 // Mark end of abbreviations.
1876 Asm->EmitULEB128(0, "EOM(3)");
1878 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1882 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1883 /// the line matrix.
1885 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1886 // Define last address of section.
1887 Asm->OutStreamer.AddComment("Extended Op");
1890 Asm->OutStreamer.AddComment("Op size");
1891 Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1892 Asm->OutStreamer.AddComment("DW_LNE_set_address");
1893 Asm->EmitInt8(dwarf::DW_LNE_set_address);
1895 Asm->OutStreamer.AddComment("Section end label");
1897 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1898 Asm->getDataLayout().getPointerSize(),
1901 // Mark end of matrix.
1902 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1908 /// emitAccelNames - Emit visible names into a hashed accelerator table
1910 void DwarfDebug::emitAccelNames() {
1911 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1912 dwarf::DW_FORM_data4));
1913 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1914 E = CUMap.end(); I != E; ++I) {
1915 CompileUnit *TheCU = I->second;
1916 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1917 for (StringMap<std::vector<DIE*> >::const_iterator
1918 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1919 const char *Name = GI->getKeyData();
1920 const std::vector<DIE *> &Entities = GI->second;
1921 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1922 DE = Entities.end(); DI != DE; ++DI)
1923 AT.AddName(Name, (*DI));
1927 AT.FinalizeTable(Asm, "Names");
1928 Asm->OutStreamer.SwitchSection(
1929 Asm->getObjFileLowering().getDwarfAccelNamesSection());
1930 MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1931 Asm->OutStreamer.EmitLabel(SectionBegin);
1933 // Emit the full data.
1934 AT.Emit(Asm, SectionBegin, this);
1937 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1938 /// accelerator table section.
1939 void DwarfDebug::emitAccelObjC() {
1940 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1941 dwarf::DW_FORM_data4));
1942 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1943 E = CUMap.end(); I != E; ++I) {
1944 CompileUnit *TheCU = I->second;
1945 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1946 for (StringMap<std::vector<DIE*> >::const_iterator
1947 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1948 const char *Name = GI->getKeyData();
1949 const std::vector<DIE *> &Entities = GI->second;
1950 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1951 DE = Entities.end(); DI != DE; ++DI)
1952 AT.AddName(Name, (*DI));
1956 AT.FinalizeTable(Asm, "ObjC");
1957 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1958 .getDwarfAccelObjCSection());
1959 MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1960 Asm->OutStreamer.EmitLabel(SectionBegin);
1962 // Emit the full data.
1963 AT.Emit(Asm, SectionBegin, this);
1966 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1968 void DwarfDebug::emitAccelNamespaces() {
1969 DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1970 dwarf::DW_FORM_data4));
1971 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1972 E = CUMap.end(); I != E; ++I) {
1973 CompileUnit *TheCU = I->second;
1974 const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1975 for (StringMap<std::vector<DIE*> >::const_iterator
1976 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1977 const char *Name = GI->getKeyData();
1978 const std::vector<DIE *> &Entities = GI->second;
1979 for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1980 DE = Entities.end(); DI != DE; ++DI)
1981 AT.AddName(Name, (*DI));
1985 AT.FinalizeTable(Asm, "namespac");
1986 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1987 .getDwarfAccelNamespaceSection());
1988 MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1989 Asm->OutStreamer.EmitLabel(SectionBegin);
1991 // Emit the full data.
1992 AT.Emit(Asm, SectionBegin, this);
1995 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1996 void DwarfDebug::emitAccelTypes() {
1997 std::vector<DwarfAccelTable::Atom> Atoms;
1998 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1999 dwarf::DW_FORM_data4));
2000 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2001 dwarf::DW_FORM_data2));
2002 Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2003 dwarf::DW_FORM_data1));
2004 DwarfAccelTable AT(Atoms);
2005 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2006 E = CUMap.end(); I != E; ++I) {
2007 CompileUnit *TheCU = I->second;
2008 const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2009 = TheCU->getAccelTypes();
2010 for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2011 GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2012 const char *Name = GI->getKeyData();
2013 const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2014 for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2015 = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2016 AT.AddName(Name, (*DI).first, (*DI).second);
2020 AT.FinalizeTable(Asm, "types");
2021 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2022 .getDwarfAccelTypesSection());
2023 MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2024 Asm->OutStreamer.EmitLabel(SectionBegin);
2026 // Emit the full data.
2027 AT.Emit(Asm, SectionBegin, this);
2030 void DwarfDebug::emitDebugPubTypes() {
2031 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2032 E = CUMap.end(); I != E; ++I) {
2033 CompileUnit *TheCU = I->second;
2034 // Start the dwarf pubtypes section.
2035 Asm->OutStreamer.SwitchSection(
2036 Asm->getObjFileLowering().getDwarfPubTypesSection());
2037 Asm->OutStreamer.AddComment("Length of Public Types Info");
2038 Asm->EmitLabelDifference(
2039 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2040 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2042 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2045 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2046 Asm->EmitInt16(dwarf::DWARF_VERSION);
2048 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2049 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2050 DwarfInfoSectionSym);
2052 Asm->OutStreamer.AddComment("Compilation Unit Length");
2053 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2054 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2057 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2058 for (StringMap<DIE*>::const_iterator
2059 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2060 const char *Name = GI->getKeyData();
2061 DIE *Entity = GI->second;
2063 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2064 Asm->EmitInt32(Entity->getOffset());
2066 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2067 // Emit the name with a terminating null byte.
2068 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2071 Asm->OutStreamer.AddComment("End Mark");
2073 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2078 /// emitDebugStr - Emit visible names into a debug str section.
2080 void DwarfDebug::emitDebugStr() {
2081 // Check to see if it is worth the effort.
2082 if (StringPool.empty()) return;
2084 // Start the dwarf str section.
2085 Asm->OutStreamer.SwitchSection(
2086 Asm->getObjFileLowering().getDwarfStrSection());
2088 // Get all of the string pool entries and put them in an array by their ID so
2089 // we can sort them.
2090 SmallVector<std::pair<unsigned,
2091 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2093 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2094 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2095 Entries.push_back(std::make_pair(I->second.second, &*I));
2097 array_pod_sort(Entries.begin(), Entries.end());
2099 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2100 // Emit a label for reference from debug information entries.
2101 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2103 // Emit the string itself with a terminating null byte.
2104 Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2105 Entries[i].second->getKeyLength()+1),
2110 /// emitDebugLoc - Emit visible names into a debug loc section.
2112 void DwarfDebug::emitDebugLoc() {
2113 if (DotDebugLocEntries.empty())
2116 for (SmallVector<DotDebugLocEntry, 4>::iterator
2117 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2119 DotDebugLocEntry &Entry = *I;
2120 if (I + 1 != DotDebugLocEntries.end())
2124 // Start the dwarf loc section.
2125 Asm->OutStreamer.SwitchSection(
2126 Asm->getObjFileLowering().getDwarfLocSection());
2127 unsigned char Size = Asm->getDataLayout().getPointerSize();
2128 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2130 for (SmallVector<DotDebugLocEntry, 4>::iterator
2131 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2132 I != E; ++I, ++index) {
2133 DotDebugLocEntry &Entry = *I;
2134 if (Entry.isMerged()) continue;
2135 if (Entry.isEmpty()) {
2136 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2137 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2138 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2140 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2141 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2142 DIVariable DV(Entry.Variable);
2143 Asm->OutStreamer.AddComment("Loc expr size");
2144 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2145 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2146 Asm->EmitLabelDifference(end, begin, 2);
2147 Asm->OutStreamer.EmitLabel(begin);
2148 if (Entry.isInt()) {
2149 DIBasicType BTy(DV.getType());
2151 (BTy.getEncoding() == dwarf::DW_ATE_signed
2152 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2153 Asm->OutStreamer.AddComment("DW_OP_consts");
2154 Asm->EmitInt8(dwarf::DW_OP_consts);
2155 Asm->EmitSLEB128(Entry.getInt());
2157 Asm->OutStreamer.AddComment("DW_OP_constu");
2158 Asm->EmitInt8(dwarf::DW_OP_constu);
2159 Asm->EmitULEB128(Entry.getInt());
2161 } else if (Entry.isLocation()) {
2162 if (!DV.hasComplexAddress())
2164 Asm->EmitDwarfRegOp(Entry.Loc);
2166 // Complex address entry.
2167 unsigned N = DV.getNumAddrElements();
2169 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2170 if (Entry.Loc.getOffset()) {
2172 Asm->EmitDwarfRegOp(Entry.Loc);
2173 Asm->OutStreamer.AddComment("DW_OP_deref");
2174 Asm->EmitInt8(dwarf::DW_OP_deref);
2175 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2176 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2177 Asm->EmitSLEB128(DV.getAddrElement(1));
2179 // If first address element is OpPlus then emit
2180 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2181 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2182 Asm->EmitDwarfRegOp(Loc);
2186 Asm->EmitDwarfRegOp(Entry.Loc);
2189 // Emit remaining complex address elements.
2190 for (; i < N; ++i) {
2191 uint64_t Element = DV.getAddrElement(i);
2192 if (Element == DIBuilder::OpPlus) {
2193 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2194 Asm->EmitULEB128(DV.getAddrElement(++i));
2195 } else if (Element == DIBuilder::OpDeref) {
2196 if (!Entry.Loc.isReg())
2197 Asm->EmitInt8(dwarf::DW_OP_deref);
2199 llvm_unreachable("unknown Opcode found in complex address");
2203 // else ... ignore constant fp. There is not any good way to
2204 // to represent them here in dwarf.
2205 Asm->OutStreamer.EmitLabel(end);
2210 /// emitDebugARanges - Emit visible names into a debug aranges section.
2212 void DwarfDebug::emitDebugARanges() {
2213 // Start the dwarf aranges section.
2214 Asm->OutStreamer.SwitchSection(
2215 Asm->getObjFileLowering().getDwarfARangesSection());
2218 /// emitDebugRanges - Emit visible names into a debug ranges section.
2220 void DwarfDebug::emitDebugRanges() {
2221 // Start the dwarf ranges section.
2222 Asm->OutStreamer.SwitchSection(
2223 Asm->getObjFileLowering().getDwarfRangesSection());
2224 unsigned char Size = Asm->getDataLayout().getPointerSize();
2225 for (SmallVector<const MCSymbol *, 8>::iterator
2226 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2229 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2231 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2235 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2237 void DwarfDebug::emitDebugMacInfo() {
2238 if (const MCSection *LineInfo =
2239 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2240 // Start the dwarf macinfo section.
2241 Asm->OutStreamer.SwitchSection(LineInfo);
2245 /// emitDebugInlineInfo - Emit inline info using following format.
2247 /// 1. length of section
2248 /// 2. Dwarf version number
2249 /// 3. address size.
2251 /// Entries (one "entry" for each function that was inlined):
2253 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2254 /// otherwise offset into __debug_str for regular function name.
2255 /// 2. offset into __debug_str section for regular function name.
2256 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2257 /// instances for the function.
2259 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2260 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2261 /// __debug_info section, and the low_pc is the starting address for the
2262 /// inlining instance.
2263 void DwarfDebug::emitDebugInlineInfo() {
2264 if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2270 Asm->OutStreamer.SwitchSection(
2271 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2273 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2274 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2275 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2277 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2279 Asm->OutStreamer.AddComment("Dwarf Version");
2280 Asm->EmitInt16(dwarf::DWARF_VERSION);
2281 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2282 Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2284 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2285 E = InlinedSPNodes.end(); I != E; ++I) {
2287 const MDNode *Node = *I;
2288 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2289 = InlineInfo.find(Node);
2290 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2291 DISubprogram SP(Node);
2292 StringRef LName = SP.getLinkageName();
2293 StringRef Name = SP.getName();
2295 Asm->OutStreamer.AddComment("MIPS linkage name");
2297 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2299 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2300 DwarfStrSectionSym);
2302 Asm->OutStreamer.AddComment("Function name");
2303 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2304 Asm->EmitULEB128(Labels.size(), "Inline count");
2306 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2307 LE = Labels.end(); LI != LE; ++LI) {
2308 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2309 Asm->EmitInt32(LI->second->getOffset());
2311 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2312 Asm->OutStreamer.EmitSymbolValue(LI->first,
2313 Asm->getDataLayout().getPointerSize(),0);
2317 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));