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 "DwarfCompileUnit.h"
18 #include "llvm/Constants.h"
19 #include "llvm/Module.h"
20 #include "llvm/Instructions.h"
21 #include "llvm/CodeGen/MachineFunction.h"
22 #include "llvm/CodeGen/MachineModuleInfo.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCSection.h"
25 #include "llvm/MC/MCStreamer.h"
26 #include "llvm/MC/MCSymbol.h"
27 #include "llvm/Target/Mangler.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Target/TargetFrameLowering.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetRegisterInfo.h"
33 #include "llvm/Target/TargetOptions.h"
34 #include "llvm/Analysis/DebugInfo.h"
35 #include "llvm/Analysis/DIBuilder.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/ValueHandle.h"
43 #include "llvm/Support/FormattedStream.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Support/Path.h"
48 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
49 cl::desc("Print DbgScope information for each machine instruction"));
51 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
53 cl::desc("Disable debug info printing"));
55 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
56 cl::desc("Make an absence of debug location information explicit."),
60 const char *DWARFGroupName = "DWARF Emission";
61 const char *DbgTimerName = "DWARF Debug Writer";
62 } // end anonymous namespace
64 //===----------------------------------------------------------------------===//
66 /// Configuration values for initial hash set sizes (log2).
68 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
72 DIType DbgVariable::getType() const {
73 DIType Ty = Var.getType();
74 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
76 if (Var.isBlockByrefVariable()) {
77 /* Byref variables, in Blocks, are declared by the programmer as
78 "SomeType VarName;", but the compiler creates a
79 __Block_byref_x_VarName struct, and gives the variable VarName
80 either the struct, or a pointer to the struct, as its type. This
81 is necessary for various behind-the-scenes things the compiler
82 needs to do with by-reference variables in blocks.
84 However, as far as the original *programmer* is concerned, the
85 variable should still have type 'SomeType', as originally declared.
87 The following function dives into the __Block_byref_x_VarName
88 struct to find the original type of the variable. This will be
89 passed back to the code generating the type for the Debug
90 Information Entry for the variable 'VarName'. 'VarName' will then
91 have the original type 'SomeType' in its debug information.
93 The original type 'SomeType' will be the type of the field named
94 'VarName' inside the __Block_byref_x_VarName struct.
96 NOTE: In order for this to not completely fail on the debugger
97 side, the Debug Information Entry for the variable VarName needs to
98 have a DW_AT_location that tells the debugger how to unwind through
99 the pointers and __Block_byref_x_VarName struct to find the actual
100 value of the variable. The function addBlockByrefType does this. */
102 unsigned tag = Ty.getTag();
104 if (tag == dwarf::DW_TAG_pointer_type) {
105 DIDerivedType DTy = DIDerivedType(Ty);
106 subType = DTy.getTypeDerivedFrom();
109 DICompositeType blockStruct = DICompositeType(subType);
110 DIArray Elements = blockStruct.getTypeArray();
112 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
113 DIDescriptor Element = Elements.getElement(i);
114 DIDerivedType DT = DIDerivedType(Element);
115 if (getName() == DT.getName())
116 return (DT.getTypeDerivedFrom());
123 //===----------------------------------------------------------------------===//
124 /// DbgRange - This is used to track range of instructions with identical
125 /// debug info scope.
127 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
129 //===----------------------------------------------------------------------===//
130 /// DbgScope - This class is used to track scope information.
133 DbgScope *Parent; // Parent to this scope.
134 DIDescriptor Desc; // Debug info descriptor for scope.
135 // Location at which this scope is inlined.
136 AssertingVH<const MDNode> InlinedAtLocation;
137 bool AbstractScope; // Abstract Scope
138 const MachineInstr *LastInsn; // Last instruction of this scope.
139 const MachineInstr *FirstInsn; // First instruction of this scope.
140 unsigned DFSIn, DFSOut;
141 // Scopes defined in scope. Contents not owned.
142 SmallVector<DbgScope *, 4> Scopes;
143 // Variables declared in scope. Contents owned.
144 SmallVector<DbgVariable *, 8> Variables;
145 SmallVector<DbgRange, 4> Ranges;
146 // Private state for dump()
147 mutable unsigned IndentLevel;
149 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
150 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
151 LastInsn(0), FirstInsn(0),
152 DFSIn(0), DFSOut(0), IndentLevel(0) {}
156 DbgScope *getParent() const { return Parent; }
157 void setParent(DbgScope *P) { Parent = P; }
158 DIDescriptor getDesc() const { return Desc; }
159 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
160 const MDNode *getScopeNode() const { return Desc; }
161 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
162 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
163 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
165 /// openInsnRange - This scope covers instruction range starting from MI.
166 void openInsnRange(const MachineInstr *MI) {
171 Parent->openInsnRange(MI);
174 /// extendInsnRange - Extend the current instruction range covered by
176 void extendInsnRange(const MachineInstr *MI) {
177 assert (FirstInsn && "MI Range is not open!");
180 Parent->extendInsnRange(MI);
183 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
184 /// until now. This is used when a new scope is encountered while walking
185 /// machine instructions.
186 void closeInsnRange(DbgScope *NewScope = NULL) {
187 assert (LastInsn && "Last insn missing!");
188 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
191 // If Parent dominates NewScope then do not close Parent's instruction
193 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
194 Parent->closeInsnRange(NewScope);
197 void setAbstractScope() { AbstractScope = true; }
198 bool isAbstractScope() const { return AbstractScope; }
200 // Depth First Search support to walk and manipulate DbgScope hierarchy.
201 unsigned getDFSOut() const { return DFSOut; }
202 void setDFSOut(unsigned O) { DFSOut = O; }
203 unsigned getDFSIn() const { return DFSIn; }
204 void setDFSIn(unsigned I) { DFSIn = I; }
205 bool dominates(const DbgScope *S) {
208 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
213 /// addScope - Add a scope to the scope.
215 void addScope(DbgScope *S) { Scopes.push_back(S); }
217 /// addVariable - Add a variable to the scope.
219 void addVariable(DbgVariable *V) { Variables.push_back(V); }
226 } // end llvm namespace
229 void DbgScope::dump() const {
230 raw_ostream &err = dbgs();
231 err.indent(IndentLevel);
232 err << "DFSIn: " << DFSIn << " DFSOut: " << DFSOut << "\n";
233 const MDNode *N = Desc;
236 err << "Abstract Scope\n";
240 err << "Children ...\n";
241 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
242 if (Scopes[i] != this)
249 DbgScope::~DbgScope() {
250 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
254 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
255 : Asm(A), MMI(Asm->MMI), FirstCU(0),
256 AbbreviationsSet(InitAbbreviationsSetSize),
257 CurrentFnDbgScope(0), PrevLabel(NULL) {
258 NextStringPoolNumber = 0;
260 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
261 DwarfStrSectionSym = TextSectionSym = 0;
262 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
263 FunctionBeginSym = FunctionEndSym = 0;
265 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
269 DwarfDebug::~DwarfDebug() {
272 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
273 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
274 if (Entry.first) return Entry.first;
276 Entry.second = NextStringPoolNumber++;
277 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
281 /// assignAbbrevNumber - Define a unique number for the abbreviation.
283 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
284 // Profile the node so that we can make it unique.
288 // Check the set for priors.
289 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
291 // If it's newly added.
292 if (InSet == &Abbrev) {
293 // Add to abbreviation list.
294 Abbreviations.push_back(&Abbrev);
296 // Assign the vector position + 1 as its number.
297 Abbrev.setNumber(Abbreviations.size());
299 // Assign existing abbreviation number.
300 Abbrev.setNumber(InSet->getNumber());
304 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
305 /// printer to not emit usual symbol prefix before the symbol name is used then
306 /// return linkage name after skipping this special LLVM prefix.
307 static StringRef getRealLinkageName(StringRef LinkageName) {
309 if (LinkageName.startswith(StringRef(&One, 1)))
310 return LinkageName.substr(1);
314 /// createSubprogramDIE - Create new DIE using SP.
315 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
316 CompileUnit *SPCU = getCompileUnit(SP);
317 DIE *SPDie = SPCU->getDIE(SP);
321 SPDie = new DIE(dwarf::DW_TAG_subprogram);
323 // DW_TAG_inlined_subroutine may refer to this DIE.
324 SPCU->insertDIE(SP, SPDie);
326 // Add to context owner.
327 SPCU->addToContextOwner(SPDie, SP.getContext());
329 // Add function template parameters.
330 SPCU->addTemplateParams(*SPDie, SP.getTemplateParams());
332 StringRef LinkageName = SP.getLinkageName();
333 if (!LinkageName.empty())
334 SPCU->addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
335 getRealLinkageName(LinkageName));
337 // If this DIE is going to refer declaration info using AT_specification
338 // then there is no need to add other attributes.
339 if (SP.getFunctionDeclaration().isSubprogram())
342 // Constructors and operators for anonymous aggregates do not have names.
343 if (!SP.getName().empty())
344 SPCU->addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
347 SPCU->addSourceLine(SPDie, SP);
349 if (SP.isPrototyped())
350 SPCU->addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
353 DICompositeType SPTy = SP.getType();
354 DIArray Args = SPTy.getTypeArray();
355 unsigned SPTag = SPTy.getTag();
357 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
358 SPCU->addType(SPDie, SPTy);
360 SPCU->addType(SPDie, DIType(Args.getElement(0)));
362 unsigned VK = SP.getVirtuality();
364 SPCU->addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
365 DIEBlock *Block = SPCU->getDIEBlock();
366 SPCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
367 SPCU->addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
368 SPCU->addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
369 ContainingTypeMap.insert(std::make_pair(SPDie,
370 SP.getContainingType()));
373 if (!SP.isDefinition()) {
374 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
376 // Add arguments. Do not add arguments for subprogram definition. They will
377 // be handled while processing variables.
378 DICompositeType SPTy = SP.getType();
379 DIArray Args = SPTy.getTypeArray();
380 unsigned SPTag = SPTy.getTag();
382 if (SPTag == dwarf::DW_TAG_subroutine_type)
383 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
384 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
385 DIType ATy = DIType(DIType(Args.getElement(i)));
386 SPCU->addType(Arg, ATy);
387 if (ATy.isArtificial())
388 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
389 SPDie->addChild(Arg);
393 if (SP.isArtificial())
394 SPCU->addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
396 if (!SP.isLocalToUnit())
397 SPCU->addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
399 if (SP.isOptimized())
400 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
402 if (unsigned isa = Asm->getISAEncoding()) {
403 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
409 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
410 assert(N && "Invalid Scope encoding!");
412 DbgScope *AScope = AbstractScopes.lookup(N);
416 DbgScope *Parent = NULL;
418 DIDescriptor Scope(N);
419 if (Scope.isLexicalBlock()) {
420 DILexicalBlock DB(N);
421 DIDescriptor ParentDesc = DB.getContext();
422 Parent = getOrCreateAbstractScope(ParentDesc);
425 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
428 Parent->addScope(AScope);
429 AScope->setAbstractScope();
430 AbstractScopes[N] = AScope;
431 if (DIDescriptor(N).isSubprogram())
432 AbstractScopesList.push_back(AScope);
436 /// isSubprogramContext - Return true if Context is either a subprogram
437 /// or another context nested inside a subprogram.
438 static bool isSubprogramContext(const MDNode *Context) {
441 DIDescriptor D(Context);
442 if (D.isSubprogram())
445 return isSubprogramContext(DIType(Context).getContext());
449 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
450 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
451 /// If there are global variables in this scope then create and insert
452 /// DIEs for these variables.
453 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
454 CompileUnit *SPCU = getCompileUnit(SPNode);
455 DIE *SPDie = SPCU->getDIE(SPNode);
457 assert(SPDie && "Unable to find subprogram DIE!");
458 DISubprogram SP(SPNode);
460 DISubprogram SPDecl = SP.getFunctionDeclaration();
461 if (SPDecl.isSubprogram())
462 // Refer function declaration directly.
463 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
464 createSubprogramDIE(SPDecl));
466 // There is not any need to generate specification DIE for a function
467 // defined at compile unit level. If a function is defined inside another
468 // function then gdb prefers the definition at top level and but does not
469 // expect specification DIE in parent function. So avoid creating
470 // specification DIE for a function defined inside a function.
471 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
472 !SP.getContext().isFile() &&
473 !isSubprogramContext(SP.getContext())) {
474 SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
477 DICompositeType SPTy = SP.getType();
478 DIArray Args = SPTy.getTypeArray();
479 unsigned SPTag = SPTy.getTag();
480 if (SPTag == dwarf::DW_TAG_subroutine_type)
481 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
482 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
483 DIType ATy = DIType(DIType(Args.getElement(i)));
484 SPCU->addType(Arg, ATy);
485 if (ATy.isArtificial())
486 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
487 SPDie->addChild(Arg);
489 DIE *SPDeclDie = SPDie;
490 SPDie = new DIE(dwarf::DW_TAG_subprogram);
491 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
496 // Pick up abstract subprogram DIE.
497 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
498 SPDie = new DIE(dwarf::DW_TAG_subprogram);
499 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
500 dwarf::DW_FORM_ref4, AbsSPDIE);
504 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
505 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
506 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
507 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
508 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
509 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
510 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
515 /// constructLexicalScope - Construct new DW_TAG_lexical_block
516 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
517 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
520 if (Scope->isAbstractScope())
523 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
527 CompileUnit *TheCU = getCompileUnit(Scope->getScopeNode());
528 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
529 if (Ranges.size() > 1) {
530 // .debug_range section has not been laid out yet. Emit offset in
531 // .debug_range as a uint, size 4, for now. emitDIE will handle
532 // DW_AT_ranges appropriately.
533 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
534 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
535 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
536 RE = Ranges.end(); RI != RE; ++RI) {
537 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
538 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
540 DebugRangeSymbols.push_back(NULL);
541 DebugRangeSymbols.push_back(NULL);
545 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
546 const MCSymbol *End = getLabelAfterInsn(RI->second);
548 if (End == 0) return 0;
550 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
551 assert(End->isDefined() && "Invalid end label for an inlined scope!");
553 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
554 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
559 /// constructInlinedScopeDIE - This scope represents inlined body of
560 /// a function. Construct DIE to represent this concrete inlined copy
562 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
564 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
565 assert (Ranges.empty() == false
566 && "DbgScope does not have instruction markers!");
568 if (!Scope->getScopeNode())
570 DIScope DS(Scope->getScopeNode());
571 DISubprogram InlinedSP = getDISubprogram(DS);
572 CompileUnit *TheCU = getCompileUnit(InlinedSP);
573 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
575 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
579 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
580 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
581 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
583 if (StartLabel == 0 || EndLabel == 0) {
584 assert (0 && "Unexpected Start and End labels for a inlined scope!");
587 assert(StartLabel->isDefined() &&
588 "Invalid starting label for an inlined scope!");
589 assert(EndLabel->isDefined() &&
590 "Invalid end label for an inlined scope!");
592 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
593 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
594 dwarf::DW_FORM_ref4, OriginDIE);
596 if (Ranges.size() > 1) {
597 // .debug_range section has not been laid out yet. Emit offset in
598 // .debug_range as a uint, size 4, for now. emitDIE will handle
599 // DW_AT_ranges appropriately.
600 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
601 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
602 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
603 RE = Ranges.end(); RI != RE; ++RI) {
604 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
605 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
607 DebugRangeSymbols.push_back(NULL);
608 DebugRangeSymbols.push_back(NULL);
610 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
611 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
614 InlinedSubprogramDIEs.insert(OriginDIE);
616 // Track the start label for this inlined function.
617 //.debug_inlined section specification does not clearly state how
618 // to emit inlined scope that is split into multiple instruction ranges.
619 // For now, use first instruction range and emit low_pc/high_pc pair and
620 // corresponding .debug_inlined section entry for this pair.
621 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
622 I = InlineInfo.find(InlinedSP);
624 if (I == InlineInfo.end()) {
625 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
627 InlinedSPNodes.push_back(InlinedSP);
629 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
631 DILocation DL(Scope->getInlinedAt());
632 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
633 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
638 /// isUnsignedDIType - Return true if type encoding is unsigned.
639 static bool isUnsignedDIType(DIType Ty) {
640 DIDerivedType DTy(Ty);
642 return isUnsignedDIType(DTy.getTypeDerivedFrom());
646 unsigned Encoding = BTy.getEncoding();
647 if (Encoding == dwarf::DW_ATE_unsigned ||
648 Encoding == dwarf::DW_ATE_unsigned_char)
654 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
655 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
656 StringRef Name = DV->getName();
660 // Translate tag to proper Dwarf tag. The result variable is dropped for
663 switch (DV->getTag()) {
664 case dwarf::DW_TAG_return_variable:
666 case dwarf::DW_TAG_arg_variable:
667 Tag = dwarf::DW_TAG_formal_parameter;
669 case dwarf::DW_TAG_auto_variable: // fall thru
671 Tag = dwarf::DW_TAG_variable;
675 // Define variable debug information entry.
676 DIE *VariableDie = new DIE(Tag);
677 CompileUnit *VariableCU = getCompileUnit(DV->getVariable());
679 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
680 V2AVI = VarToAbstractVarMap.find(DV);
681 if (V2AVI != VarToAbstractVarMap.end())
682 AbsDIE = V2AVI->second->getDIE();
685 VariableCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
686 dwarf::DW_FORM_ref4, AbsDIE);
688 VariableCU->addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
690 VariableCU->addSourceLine(VariableDie, DV->getVariable());
692 // Add variable type.
693 VariableCU->addType(VariableDie, DV->getType());
696 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
697 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
698 dwarf::DW_FORM_flag, 1);
699 else if (DIVariable(DV->getVariable()).isArtificial())
700 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
701 dwarf::DW_FORM_flag, 1);
703 if (Scope->isAbstractScope()) {
704 DV->setDIE(VariableDie);
708 // Add variable address.
710 unsigned Offset = DV->getDotDebugLocOffset();
712 VariableCU->addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
713 Asm->GetTempSymbol("debug_loc", Offset));
714 DV->setDIE(VariableDie);
715 UseDotDebugLocEntry.insert(VariableDie);
719 // Check if variable is described by a DBG_VALUE instruction.
720 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
721 DbgVariableToDbgInstMap.find(DV);
722 if (DVI != DbgVariableToDbgInstMap.end()) {
723 const MachineInstr *DVInsn = DVI->second;
724 bool updated = false;
725 if (DVInsn->getNumOperands() == 3) {
726 if (DVInsn->getOperand(0).isReg()) {
727 const MachineOperand RegOp = DVInsn->getOperand(0);
728 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
729 if (DVInsn->getOperand(1).isImm() &&
730 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
731 unsigned FrameReg = 0;
732 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
734 TFI->getFrameIndexReference(*Asm->MF,
735 DVInsn->getOperand(1).getImm(),
737 MachineLocation Location(FrameReg, Offset);
738 VariableCU->addVariableAddress(DV, VariableDie, Location);
740 } else if (RegOp.getReg())
741 VariableCU->addVariableAddress(DV, VariableDie,
742 MachineLocation(RegOp.getReg()));
745 else if (DVInsn->getOperand(0).isImm())
747 VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0),
749 else if (DVInsn->getOperand(0).isFPImm())
751 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
752 else if (DVInsn->getOperand(0).isCImm())
754 VariableCU->addConstantValue(VariableDie,
755 DVInsn->getOperand(0).getCImm(),
756 isUnsignedDIType(DV->getType()));
758 VariableCU->addVariableAddress(DV, VariableDie,
759 Asm->getDebugValueLocation(DVInsn));
763 // If variableDie is not updated then DBG_VALUE instruction does not
764 // have valid variable info.
768 DV->setDIE(VariableDie);
772 // .. else use frame index, if available.
774 if (findVariableFrameIndex(DV, &FI)) {
775 unsigned FrameReg = 0;
776 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
778 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
779 MachineLocation Location(FrameReg, Offset);
780 VariableCU->addVariableAddress(DV, VariableDie, Location);
783 DV->setDIE(VariableDie);
788 /// constructScopeDIE - Construct a DIE for this scope.
789 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
790 if (!Scope || !Scope->getScopeNode())
793 SmallVector <DIE *, 8> Children;
795 // Collect arguments for current function.
796 if (Scope == CurrentFnDbgScope)
797 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
798 if (DbgVariable *ArgDV = CurrentFnArguments[i])
799 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
800 Children.push_back(Arg);
802 // Collect lexical scope childrens first.
803 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
804 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
805 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
806 Children.push_back(Variable);
807 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
808 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
809 if (DIE *Nested = constructScopeDIE(Scopes[j]))
810 Children.push_back(Nested);
811 DIScope DS(Scope->getScopeNode());
812 DIE *ScopeDIE = NULL;
813 if (Scope->getInlinedAt())
814 ScopeDIE = constructInlinedScopeDIE(Scope);
815 else if (DS.isSubprogram()) {
816 ProcessedSPNodes.insert(DS);
817 if (Scope->isAbstractScope()) {
818 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
819 // Note down abstract DIE.
821 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
824 ScopeDIE = updateSubprogramScopeDIE(DS);
827 // There is no need to emit empty lexical block DIE.
828 if (Children.empty())
830 ScopeDIE = constructLexicalScopeDIE(Scope);
833 if (!ScopeDIE) return NULL;
836 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
837 E = Children.end(); I != E; ++I)
838 ScopeDIE->addChild(*I);
840 if (DS.isSubprogram())
841 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
846 /// GetOrCreateSourceID - Look up the source id with the given directory and
847 /// source file names. If none currently exists, create a new id and insert it
848 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
851 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
853 // If FE did not provide a file name, then assume stdin.
854 if (FileName.empty())
855 return GetOrCreateSourceID("<stdin>", StringRef());
857 // MCStream expects full path name as filename.
858 if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
859 SmallString<128> FullPathName = DirName;
860 sys::path::append(FullPathName, FileName);
861 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
862 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
865 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
866 if (Entry.getValue())
867 return Entry.getValue();
869 unsigned SrcId = SourceIdMap.size();
870 Entry.setValue(SrcId);
872 // Print out a .file directive to specify files for .loc directives.
873 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
878 /// constructCompileUnit - Create new CompileUnit for the given
879 /// metadata node with tag DW_TAG_compile_unit.
880 void DwarfDebug::constructCompileUnit(const MDNode *N) {
881 DICompileUnit DIUnit(N);
882 StringRef FN = DIUnit.getFilename();
883 StringRef Dir = DIUnit.getDirectory();
884 unsigned ID = GetOrCreateSourceID(FN, Dir);
886 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
887 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
888 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
889 DIUnit.getProducer());
890 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
891 DIUnit.getLanguage());
892 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
893 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
894 // simplifies debug range entries.
895 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
896 // DW_AT_stmt_list is a offset of line number information for this
897 // compile unit in debug_line section.
898 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
899 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
900 Asm->GetTempSymbol("section_line"));
902 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
905 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
906 if (DIUnit.isOptimized())
907 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
909 StringRef Flags = DIUnit.getFlags();
911 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
913 unsigned RVer = DIUnit.getRunTimeVersion();
915 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
916 dwarf::DW_FORM_data1, RVer);
920 CUMap.insert(std::make_pair(N, NewCU));
923 /// getCompileUnit - Get CompileUnit DIE.
924 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
925 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
927 const MDNode *CUNode = NULL;
928 if (D.isCompileUnit())
930 else if (D.isSubprogram())
931 CUNode = DISubprogram(N).getCompileUnit();
933 CUNode = DIType(N).getCompileUnit();
934 else if (D.isGlobalVariable())
935 CUNode = DIGlobalVariable(N).getCompileUnit();
936 else if (D.isVariable())
937 CUNode = DIVariable(N).getCompileUnit();
938 else if (D.isNameSpace())
939 CUNode = DINameSpace(N).getCompileUnit();
941 CUNode = DIFile(N).getCompileUnit();
945 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
946 = CUMap.find(CUNode);
947 if (I == CUMap.end())
952 // Return const expression if value is a GEP to access merged global
954 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
955 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
956 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
957 if (!CE || CE->getNumOperands() != 3 ||
958 CE->getOpcode() != Instruction::GetElementPtr)
961 // First operand points to a global value.
962 if (!isa<GlobalValue>(CE->getOperand(0)))
965 // Second operand is zero.
966 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
967 if (!CI || !CI->isZero())
970 // Third operand is offset.
971 if (!isa<ConstantInt>(CE->getOperand(2)))
977 /// constructGlobalVariableDIE - Construct global variable DIE.
978 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
979 DIGlobalVariable GV(N);
981 // If debug information is malformed then ignore it.
982 if (GV.Verify() == false)
985 // Check for pre-existence.
986 CompileUnit *TheCU = getCompileUnit(N);
987 if (TheCU->getDIE(GV))
990 DIType GTy = GV.getType();
991 DIE *VariableDIE = new DIE(GV.getTag());
993 bool isGlobalVariable = GV.getGlobal() != NULL;
996 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
997 GV.getDisplayName());
998 StringRef LinkageName = GV.getLinkageName();
999 if (!LinkageName.empty() && isGlobalVariable)
1000 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1001 dwarf::DW_FORM_string,
1002 getRealLinkageName(LinkageName));
1004 TheCU->addType(VariableDIE, GTy);
1006 // Add scoping info.
1007 if (!GV.isLocalToUnit()) {
1008 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1009 // Expose as global.
1010 TheCU->addGlobal(GV.getName(), VariableDIE);
1012 // Add line number info.
1013 TheCU->addSourceLine(VariableDIE, GV);
1015 TheCU->insertDIE(N, VariableDIE);
1016 // Add to context owner.
1017 DIDescriptor GVContext = GV.getContext();
1018 TheCU->addToContextOwner(VariableDIE, GVContext);
1020 if (isGlobalVariable) {
1021 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1022 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1023 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1024 Asm->Mang->getSymbol(GV.getGlobal()));
1025 // Do not create specification DIE if context is either compile unit
1027 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1028 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1029 // Create specification DIE.
1030 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1031 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1032 dwarf::DW_FORM_ref4, VariableDIE);
1033 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1034 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1035 TheCU->addDie(VariableSpecDIE);
1037 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1039 } else if (const ConstantInt *CI =
1040 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1041 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1042 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1043 // GV is a merged global.
1044 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1045 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1046 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1047 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1048 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1049 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1050 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1051 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1052 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1058 /// construct SubprogramDIE - Construct subprogram DIE.
1059 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1062 // Check for pre-existence.
1063 CompileUnit *TheCU = getCompileUnit(N);
1064 if (TheCU->getDIE(N))
1067 if (!SP.isDefinition())
1068 // This is a method declaration which will be handled while constructing
1072 DIE *SubprogramDie = createSubprogramDIE(SP);
1075 TheCU->insertDIE(N, SubprogramDie);
1077 // Add to context owner.
1078 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1080 // Expose as global.
1081 TheCU->addGlobal(SP.getName(), SubprogramDie);
1086 /// beginModule - Emit all Dwarf sections that should come prior to the
1087 /// content. Create global DIEs and emit initial debug info sections.
1088 /// This is invoked by the target AsmPrinter.
1089 void DwarfDebug::beginModule(Module *M) {
1090 if (DisableDebugInfoPrinting)
1093 // If module has named metadata anchors then use them, otherwise scan the
1094 // module using debug info finder to collect debug info.
1095 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1098 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1099 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1100 if (!GV_Nodes && !SP_Nodes)
1101 // If there are not any global variables or any functions then
1102 // there is not any debug info in this module.
1105 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1106 constructCompileUnit(CU_Nodes->getOperand(i));
1109 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1110 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1113 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1114 constructSubprogramDIE(SP_Nodes->getOperand(i));
1118 DebugInfoFinder DbgFinder;
1119 DbgFinder.processModule(*M);
1121 bool HasDebugInfo = false;
1122 // Scan all the compile-units to see if there are any marked as the main
1123 // unit. If not, we do not generate debug info.
1124 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1125 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1126 if (DICompileUnit(*I).isMain()) {
1127 HasDebugInfo = true;
1131 if (!HasDebugInfo) return;
1133 // Create all the compile unit DIEs.
1134 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1135 E = DbgFinder.compile_unit_end(); I != E; ++I)
1136 constructCompileUnit(*I);
1138 // Create DIEs for each global variable.
1139 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1140 E = DbgFinder.global_variable_end(); I != E; ++I)
1141 constructGlobalVariableDIE(*I);
1143 // Create DIEs for each subprogram.
1144 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1145 E = DbgFinder.subprogram_end(); I != E; ++I)
1146 constructSubprogramDIE(*I);
1149 // Tell MMI that we have debug info.
1150 MMI->setDebugInfoAvailability(true);
1152 // Emit initial sections.
1153 EmitSectionLabels();
1155 //getOrCreateTypeDIE
1156 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1157 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1158 DIType Ty(NMD->getOperand(i));
1159 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1162 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1163 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1164 DIType Ty(NMD->getOperand(i));
1165 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1168 // Prime section data.
1169 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1172 /// endModule - Emit all Dwarf sections that should come after the content.
1174 void DwarfDebug::endModule() {
1175 if (!FirstCU) return;
1176 const Module *M = MMI->getModule();
1177 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1178 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1179 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1180 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1181 DISubprogram SP(AllSPs->getOperand(SI));
1182 if (!SP.Verify()) continue;
1184 // Collect info for variables that were optimized out.
1185 if (!SP.isDefinition()) continue;
1186 StringRef FName = SP.getLinkageName();
1188 FName = SP.getName();
1189 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1191 unsigned E = NMD->getNumOperands();
1193 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1194 DeadFnScopeMap[SP] = Scope;
1195 for (unsigned I = 0; I != E; ++I) {
1196 DIVariable DV(NMD->getOperand(I));
1197 if (!DV.Verify()) continue;
1198 Scope->addVariable(new DbgVariable(DV));
1201 // Construct subprogram DIE and add variables DIEs.
1202 constructSubprogramDIE(SP);
1203 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1204 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1205 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1206 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1208 ScopeDIE->addChild(VariableDIE);
1213 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1214 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1215 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1217 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1220 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1221 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1222 DIE *SPDie = CI->first;
1223 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1225 DIE *NDie = getCompileUnit(N)->getDIE(N);
1226 if (!NDie) continue;
1227 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1228 dwarf::DW_FORM_ref4, NDie);
1231 // Standard sections final addresses.
1232 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1233 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1234 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1235 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1237 // End text sections.
1238 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1239 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1240 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1243 // Compute DIE offsets and sizes.
1244 computeSizeAndOffsets();
1246 // Emit all the DIEs into a debug info section
1249 // Corresponding abbreviations into a abbrev section.
1250 emitAbbreviations();
1252 // Emit info into a debug pubnames section.
1253 emitDebugPubNames();
1255 // Emit info into a debug pubtypes section.
1256 emitDebugPubTypes();
1258 // Emit info into a debug loc section.
1261 // Emit info into a debug aranges section.
1264 // Emit info into a debug ranges section.
1267 // Emit info into a debug macinfo section.
1270 // Emit inline info.
1271 emitDebugInlineInfo();
1273 // Emit info into a debug str section.
1277 DeleteContainerSeconds(DeadFnScopeMap);
1278 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1279 E = CUMap.end(); I != E; ++I)
1281 FirstCU = NULL; // Reset for the next Module, if any.
1284 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1285 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1286 DebugLoc ScopeLoc) {
1287 LLVMContext &Ctx = DV->getContext();
1289 // More then one inlined variable corresponds to one abstract variable.
1290 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1292 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1294 return AbsDbgVariable;
1297 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1301 AbsDbgVariable = new DbgVariable(Var);
1302 Scope->addVariable(AbsDbgVariable);
1303 AbstractVariables[Var] = AbsDbgVariable;
1304 return AbsDbgVariable;
1307 /// addCurrentFnArgument - If Var is a current function argument then add
1308 /// it to CurrentFnArguments list.
1309 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1310 DbgVariable *Var, DbgScope *Scope) {
1311 if (Scope != CurrentFnDbgScope)
1313 DIVariable DV = Var->getVariable();
1314 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1316 unsigned ArgNo = DV.getArgNumber();
1320 size_t Size = CurrentFnArguments.size();
1322 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1323 // llvm::Function argument size is not good indicator of how many
1324 // arguments does the function have at source level.
1326 CurrentFnArguments.resize(ArgNo * 2);
1327 CurrentFnArguments[ArgNo - 1] = Var;
1331 /// collectVariableInfoFromMMITable - Collect variable information from
1332 /// side table maintained by MMI.
1334 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1335 SmallPtrSet<const MDNode *, 16> &Processed) {
1336 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1337 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1338 VE = VMap.end(); VI != VE; ++VI) {
1339 const MDNode *Var = VI->first;
1341 Processed.insert(Var);
1343 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1345 DbgScope *Scope = findDbgScope(VP.second);
1347 // If variable scope is not found then skip this variable.
1351 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1352 DbgVariable *RegVar = new DbgVariable(DV);
1353 recordVariableFrameIndex(RegVar, VP.first);
1354 if (!addCurrentFnArgument(MF, RegVar, Scope))
1355 Scope->addVariable(RegVar);
1356 if (AbsDbgVariable) {
1357 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1358 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1363 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1364 /// DBG_VALUE instruction, is in a defined reg.
1365 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1366 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1367 return MI->getNumOperands() == 3 &&
1368 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1369 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1372 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
1374 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1375 const MCSymbol *FLabel,
1376 const MCSymbol *SLabel,
1377 const MachineInstr *MI) {
1378 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1380 if (MI->getNumOperands() != 3) {
1381 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1382 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1384 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1385 MachineLocation MLoc;
1386 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1387 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1389 if (MI->getOperand(0).isImm())
1390 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1391 if (MI->getOperand(0).isFPImm())
1392 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1393 if (MI->getOperand(0).isCImm())
1394 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1396 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
1397 return DotDebugLocEntry();
1400 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1402 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1403 SmallPtrSet<const MDNode *, 16> &Processed) {
1405 /// collection info from MMI table.
1406 collectVariableInfoFromMMITable(MF, Processed);
1408 for (SmallVectorImpl<const MDNode*>::const_iterator
1409 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1411 const MDNode *Var = *UVI;
1412 if (Processed.count(Var))
1415 // History contains relevant DBG_VALUE instructions for Var and instructions
1417 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1418 if (History.empty())
1420 const MachineInstr *MInsn = History.front();
1423 DbgScope *Scope = NULL;
1424 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1425 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1426 Scope = CurrentFnDbgScope;
1428 if (DV.getVersion() <= LLVMDebugVersion9)
1429 Scope = findDbgScope(MInsn->getDebugLoc());
1431 if (MDNode *IA = DV.getInlinedAt())
1432 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
1434 Scope = DbgScopeMap.lookup(cast<MDNode>(DV->getOperand(1)));
1437 // If variable scope is not found then skip this variable.
1441 Processed.insert(DV);
1442 assert(MInsn->isDebugValue() && "History must begin with debug value");
1443 DbgVariable *RegVar = new DbgVariable(DV);
1444 if (!addCurrentFnArgument(MF, RegVar, Scope))
1445 Scope->addVariable(RegVar);
1446 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1447 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1448 VarToAbstractVarMap[RegVar] = AbsVar;
1451 // Simple ranges that are fully coalesced.
1452 if (History.size() <= 1 || (History.size() == 2 &&
1453 MInsn->isIdenticalTo(History.back()))) {
1454 DbgVariableToDbgInstMap[RegVar] = MInsn;
1458 // handle multiple DBG_VALUE instructions describing one variable.
1459 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1461 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1462 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1463 const MachineInstr *Begin = *HI;
1464 assert(Begin->isDebugValue() && "Invalid History entry");
1466 // Check if DBG_VALUE is truncating a range.
1467 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1468 && !Begin->getOperand(0).getReg())
1471 // Compute the range for a register location.
1472 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1473 const MCSymbol *SLabel = 0;
1476 // If Begin is the last instruction in History then its value is valid
1477 // until the end of the function.
1478 SLabel = FunctionEndSym;
1480 const MachineInstr *End = HI[1];
1481 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1482 << "\t" << *Begin << "\t" << *End << "\n");
1483 if (End->isDebugValue())
1484 SLabel = getLabelBeforeInsn(End);
1486 // End is a normal instruction clobbering the range.
1487 SLabel = getLabelAfterInsn(End);
1488 assert(SLabel && "Forgot label after clobber instruction");
1493 // The value is valid until the next DBG_VALUE or clobber.
1494 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1496 DotDebugLocEntries.push_back(DotDebugLocEntry());
1499 // Collect info for variables that were optimized out.
1500 const Function *F = MF->getFunction();
1501 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1502 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1503 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1504 if (!DV || !Processed.insert(DV))
1506 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1508 Scope->addVariable(new DbgVariable(DV));
1513 /// getLabelBeforeInsn - Return Label preceding the instruction.
1514 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1515 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1516 assert(Label && "Didn't insert label before instruction");
1520 /// getLabelAfterInsn - Return Label immediately following the instruction.
1521 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1522 return LabelsAfterInsn.lookup(MI);
1525 /// beginInstruction - Process beginning of an instruction.
1526 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1527 // Check if source location changes, but ignore DBG_VALUE locations.
1528 if (!MI->isDebugValue()) {
1529 DebugLoc DL = MI->getDebugLoc();
1530 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1531 unsigned Flags = DWARF2_FLAG_IS_STMT;
1533 if (DL == PrologEndLoc) {
1534 Flags |= DWARF2_FLAG_PROLOGUE_END;
1535 PrologEndLoc = DebugLoc();
1537 if (!DL.isUnknown()) {
1538 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1539 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1541 recordSourceLine(0, 0, 0, 0);
1545 // Insert labels where requested.
1546 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1547 LabelsBeforeInsn.find(MI);
1550 if (I == LabelsBeforeInsn.end())
1553 // Label already assigned.
1558 PrevLabel = MMI->getContext().CreateTempSymbol();
1559 Asm->OutStreamer.EmitLabel(PrevLabel);
1561 I->second = PrevLabel;
1564 /// endInstruction - Process end of an instruction.
1565 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1566 // Don't create a new label after DBG_VALUE instructions.
1567 // They don't generate code.
1568 if (!MI->isDebugValue())
1571 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1572 LabelsAfterInsn.find(MI);
1575 if (I == LabelsAfterInsn.end())
1578 // Label already assigned.
1582 // We need a label after this instruction.
1584 PrevLabel = MMI->getContext().CreateTempSymbol();
1585 Asm->OutStreamer.EmitLabel(PrevLabel);
1587 I->second = PrevLabel;
1590 /// getOrCreateRegularScope - Create regular DbgScope.
1591 DbgScope *DwarfDebug::getOrCreateRegularScope(MDNode *Scope) {
1592 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1595 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1596 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1597 if (DIDescriptor(Scope).isLexicalBlock()) {
1599 getOrCreateDbgScope(DebugLoc::getFromDILexicalBlock(Scope));
1600 WScope->setParent(Parent);
1601 Parent->addScope(WScope);
1602 } else if (DIDescriptor(Scope).isSubprogram()
1603 && DISubprogram(Scope).describes(Asm->MF->getFunction()))
1604 CurrentFnDbgScope = WScope;
1609 /// getOrCreateInlinedScope - Create inlined scope.
1610 DbgScope *DwarfDebug::getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt){
1611 DbgScope *InlinedScope = DbgScopeMap.lookup(InlinedAt);
1613 return InlinedScope;
1615 InlinedScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1616 DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt);
1617 InlinedDbgScopeMap[InlinedLoc] = InlinedScope;
1618 DbgScopeMap[InlinedAt] = InlinedScope;
1619 DbgScope *Parent = getOrCreateDbgScope(InlinedLoc);
1620 InlinedScope->setParent(Parent);
1621 Parent->addScope(InlinedScope);
1622 return InlinedScope;
1625 /// getOrCreateDbgScope - Create DbgScope for the scope.
1626 DbgScope *DwarfDebug::getOrCreateDbgScope(DebugLoc DL) {
1627 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1628 MDNode *Scope = NULL;
1629 MDNode *InlinedAt = NULL;
1630 DL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1632 return getOrCreateRegularScope(Scope);
1634 // Create an abstract scope for inlined function.
1635 getOrCreateAbstractScope(Scope);
1636 // Create an inlined scope for inlined function.
1637 return getOrCreateInlinedScope(Scope, InlinedAt);
1640 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1642 static void calculateDominanceGraph(DbgScope *Scope) {
1643 assert (Scope && "Unable to calculate scop edominance graph!");
1644 SmallVector<DbgScope *, 4> WorkStack;
1645 WorkStack.push_back(Scope);
1646 unsigned Counter = 0;
1647 while (!WorkStack.empty()) {
1648 DbgScope *WS = WorkStack.back();
1649 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1650 bool visitedChildren = false;
1651 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1652 SE = Children.end(); SI != SE; ++SI) {
1653 DbgScope *ChildScope = *SI;
1654 if (!ChildScope->getDFSOut()) {
1655 WorkStack.push_back(ChildScope);
1656 visitedChildren = true;
1657 ChildScope->setDFSIn(++Counter);
1660 dbgs() << "calculate dbgscope dom: In " << Counter << "\n";
1665 if (!visitedChildren) {
1666 WorkStack.pop_back();
1667 WS->setDFSOut(++Counter);
1670 dbgs() << "calculate dbgscope dom: In " << WS->getDFSIn()
1671 << " Out " << Counter << "\n";
1677 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1679 void printDbgScopeInfo(const MachineFunction *MF,
1680 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1683 LLVMContext &Ctx = MF->getFunction()->getContext();
1684 unsigned PrevDFSIn = 0;
1685 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1687 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1689 const MachineInstr *MInsn = II;
1690 MDNode *Scope = NULL;
1691 MDNode *InlinedAt = NULL;
1693 // Check if instruction has valid location information.
1694 DebugLoc MIDL = MInsn->getDebugLoc();
1695 if (!MIDL.isUnknown()) {
1696 MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1700 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1701 MI2ScopeMap.find(MInsn);
1702 if (DI != MI2ScopeMap.end()) {
1703 DbgScope *S = DI->second;
1704 dbgs() << S->getDFSIn();
1705 PrevDFSIn = S->getDFSIn();
1707 dbgs() << PrevDFSIn;
1709 dbgs() << " [ x" << PrevDFSIn;
1717 /// extractScopeInformation - Scan machine instructions in this function
1718 /// and collect DbgScopes. Return true, if at least one scope was found.
1719 bool DwarfDebug::extractScopeInformation() {
1720 // If scope information was extracted using .dbg intrinsics then there is not
1721 // any need to extract these information by scanning each instruction.
1722 if (!DbgScopeMap.empty())
1725 // Scan each instruction and create scopes. First build working set of scopes.
1726 SmallVector<DbgRange, 4> MIRanges;
1727 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1728 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1730 const MachineInstr *RangeBeginMI = NULL;
1731 const MachineInstr *PrevMI = NULL;
1733 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1735 const MachineInstr *MInsn = II;
1737 // Check if instruction has valid location information.
1738 const DebugLoc MIDL = MInsn->getDebugLoc();
1739 if (MIDL.isUnknown()) {
1744 // If scope has not changed then skip this instruction.
1745 if (MIDL == PrevDL) {
1750 // Ignore DBG_VALUE. It does not contribute to any instruction in output.
1751 if (MInsn->isDebugValue())
1755 // If we have already seen a beginning of an instruction range and
1756 // current instruction scope does not match scope of first instruction
1757 // in this range then create a new instruction range.
1758 DEBUG(dbgs() << "Creating new instruction range :\n");
1759 DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI);
1760 DEBUG(dbgs() << "End Range at " << *PrevMI);
1761 DEBUG(dbgs() << "Next Range starting at " << *MInsn);
1762 DEBUG(dbgs() << "------------------------\n");
1763 DbgRange R(RangeBeginMI, PrevMI);
1764 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1765 MIRanges.push_back(R);
1768 // This is a beginning of a new instruction range.
1769 RangeBeginMI = MInsn;
1771 // Reset previous markers.
1776 // Create last instruction range.
1777 if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) {
1778 DbgRange R(RangeBeginMI, PrevMI);
1779 MIRanges.push_back(R);
1780 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1784 if (!CurrentFnDbgScope)
1787 calculateDominanceGraph(CurrentFnDbgScope);
1789 printDbgScopeInfo(Asm->MF, MI2ScopeMap);
1791 // Find ranges of instructions covered by each DbgScope;
1792 DbgScope *PrevDbgScope = NULL;
1793 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1794 RE = MIRanges.end(); RI != RE; ++RI) {
1795 const DbgRange &R = *RI;
1796 DbgScope *S = MI2ScopeMap.lookup(R.first);
1797 assert (S && "Lost DbgScope for a machine instruction!");
1798 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1799 PrevDbgScope->closeInsnRange(S);
1800 S->openInsnRange(R.first);
1801 S->extendInsnRange(R.second);
1806 PrevDbgScope->closeInsnRange();
1808 identifyScopeMarkers();
1810 return !DbgScopeMap.empty();
1813 /// identifyScopeMarkers() -
1814 /// Each DbgScope has first instruction and last instruction to mark beginning
1815 /// and end of a scope respectively. Create an inverse map that list scopes
1816 /// starts (and ends) with an instruction. One instruction may start (or end)
1817 /// multiple scopes. Ignore scopes that are not reachable.
1818 void DwarfDebug::identifyScopeMarkers() {
1819 SmallVector<DbgScope *, 4> WorkList;
1820 WorkList.push_back(CurrentFnDbgScope);
1821 while (!WorkList.empty()) {
1822 DbgScope *S = WorkList.pop_back_val();
1824 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1825 if (!Children.empty())
1826 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1827 SE = Children.end(); SI != SE; ++SI)
1828 WorkList.push_back(*SI);
1830 if (S->isAbstractScope())
1833 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1836 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1837 RE = Ranges.end(); RI != RE; ++RI) {
1838 assert(RI->first && "DbgRange does not have first instruction!");
1839 assert(RI->second && "DbgRange does not have second instruction!");
1840 requestLabelBeforeInsn(RI->first);
1841 requestLabelAfterInsn(RI->second);
1846 /// getScopeNode - Get MDNode for DebugLoc's scope.
1847 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1848 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1849 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1850 return DL.getScope(Ctx);
1853 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1854 /// line number info for the function.
1855 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1856 const MDNode *Scope = getScopeNode(DL, Ctx);
1857 DISubprogram SP = getDISubprogram(Scope);
1859 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1863 /// beginFunction - Gather pre-function debug information. Assumes being
1864 /// emitted immediately after the function entry point.
1865 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1866 if (!MMI->hasDebugInfo()) return;
1867 if (!extractScopeInformation()) return;
1869 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1870 Asm->getFunctionNumber());
1871 // Assumes in correct section after the entry point.
1872 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1874 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1876 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1877 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1878 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1880 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1882 bool AtBlockEntry = true;
1883 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1885 const MachineInstr *MI = II;
1887 if (MI->isDebugValue()) {
1888 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1890 // Keep track of user variables.
1892 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1894 // Variable is in a register, we need to check for clobbers.
1895 if (isDbgValueInDefinedReg(MI))
1896 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1898 // Check the history of this variable.
1899 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1900 if (History.empty()) {
1901 UserVariables.push_back(Var);
1902 // The first mention of a function argument gets the FunctionBeginSym
1903 // label, so arguments are visible when breaking at function entry.
1905 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1906 DISubprogram(getDISubprogram(DV.getContext()))
1907 .describes(MF->getFunction()))
1908 LabelsBeforeInsn[MI] = FunctionBeginSym;
1910 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1911 const MachineInstr *Prev = History.back();
1912 if (Prev->isDebugValue()) {
1913 // Coalesce identical entries at the end of History.
1914 if (History.size() >= 2 &&
1915 Prev->isIdenticalTo(History[History.size() - 2])) {
1916 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1918 << "\t" << *History[History.size() - 2] << "\n");
1922 // Terminate old register assignments that don't reach MI;
1923 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1924 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1925 isDbgValueInDefinedReg(Prev)) {
1926 // Previous register assignment needs to terminate at the end of
1928 MachineBasicBlock::const_iterator LastMI =
1929 PrevMBB->getLastNonDebugInstr();
1930 if (LastMI == PrevMBB->end()) {
1931 // Drop DBG_VALUE for empty range.
1932 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1933 << "\t" << *Prev << "\n");
1937 // Terminate after LastMI.
1938 History.push_back(LastMI);
1943 History.push_back(MI);
1945 // Not a DBG_VALUE instruction.
1947 AtBlockEntry = false;
1949 // First known non DBG_VALUE location marks beginning of function
1951 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1952 PrologEndLoc = MI->getDebugLoc();
1954 // Check if the instruction clobbers any registers with debug vars.
1955 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1956 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1957 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1959 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1960 unsigned Reg = *AI; ++AI) {
1961 const MDNode *Var = LiveUserVar[Reg];
1964 // Reg is now clobbered.
1965 LiveUserVar[Reg] = 0;
1967 // Was MD last defined by a DBG_VALUE referring to Reg?
1968 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1969 if (HistI == DbgValues.end())
1971 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1972 if (History.empty())
1974 const MachineInstr *Prev = History.back();
1975 // Sanity-check: Register assignments are terminated at the end of
1977 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1979 // Is the variable still in Reg?
1980 if (!isDbgValueInDefinedReg(Prev) ||
1981 Prev->getOperand(0).getReg() != Reg)
1983 // Var is clobbered. Make sure the next instruction gets a label.
1984 History.push_back(MI);
1991 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1993 SmallVectorImpl<const MachineInstr*> &History = I->second;
1994 if (History.empty())
1997 // Make sure the final register assignments are terminated.
1998 const MachineInstr *Prev = History.back();
1999 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
2000 const MachineBasicBlock *PrevMBB = Prev->getParent();
2001 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
2002 if (LastMI == PrevMBB->end())
2003 // Drop DBG_VALUE for empty range.
2006 // Terminate after LastMI.
2007 History.push_back(LastMI);
2010 // Request labels for the full history.
2011 for (unsigned i = 0, e = History.size(); i != e; ++i) {
2012 const MachineInstr *MI = History[i];
2013 if (MI->isDebugValue())
2014 requestLabelBeforeInsn(MI);
2016 requestLabelAfterInsn(MI);
2020 PrevInstLoc = DebugLoc();
2021 PrevLabel = FunctionBeginSym;
2023 // Record beginning of function.
2024 if (!PrologEndLoc.isUnknown()) {
2025 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
2026 MF->getFunction()->getContext());
2027 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
2028 FnStartDL.getScope(MF->getFunction()->getContext()),
2029 DWARF2_FLAG_IS_STMT);
2033 /// endFunction - Gather and emit post-function debug information.
2035 void DwarfDebug::endFunction(const MachineFunction *MF) {
2036 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2038 if (CurrentFnDbgScope) {
2040 // Define end label for subprogram.
2041 FunctionEndSym = Asm->GetTempSymbol("func_end",
2042 Asm->getFunctionNumber());
2043 // Assumes in correct section after the entry point.
2044 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2046 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2047 collectVariableInfo(MF, ProcessedVars);
2049 // Construct abstract scopes.
2050 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2051 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2052 DISubprogram SP((*AI)->getScopeNode());
2054 // Collect info for variables that were optimized out.
2055 StringRef FName = SP.getLinkageName();
2057 FName = SP.getName();
2058 if (NamedMDNode *NMD =
2059 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2060 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2061 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2062 if (!DV || !ProcessedVars.insert(DV))
2064 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2066 Scope->addVariable(new DbgVariable(DV));
2070 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2071 constructScopeDIE(*AI);
2074 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2076 if (!DisableFramePointerElim(*MF))
2077 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2078 dwarf::DW_AT_APPLE_omit_frame_ptr,
2079 dwarf::DW_FORM_flag, 1);
2082 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2083 MMI->getFrameMoves()));
2087 CurrentFnDbgScope = NULL;
2088 DeleteContainerPointers(CurrentFnArguments);
2089 DbgVariableToFrameIndexMap.clear();
2090 VarToAbstractVarMap.clear();
2091 DbgVariableToDbgInstMap.clear();
2092 InlinedDbgScopeMap.clear();
2093 DeleteContainerSeconds(DbgScopeMap);
2094 UserVariables.clear();
2096 DeleteContainerSeconds(AbstractScopes);
2097 AbstractScopesList.clear();
2098 AbstractVariables.clear();
2099 LabelsBeforeInsn.clear();
2100 LabelsAfterInsn.clear();
2104 /// recordVariableFrameIndex - Record a variable's index.
2105 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2106 assert (V && "Invalid DbgVariable!");
2107 DbgVariableToFrameIndexMap[V] = Index;
2110 /// findVariableFrameIndex - Return true if frame index for the variable
2111 /// is found. Update FI to hold value of the index.
2112 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2113 assert (V && "Invalid DbgVariable!");
2114 DenseMap<const DbgVariable *, int>::iterator I =
2115 DbgVariableToFrameIndexMap.find(V);
2116 if (I == DbgVariableToFrameIndexMap.end())
2122 /// findDbgScope - Find DbgScope for the debug loc.
2123 DbgScope *DwarfDebug::findDbgScope(DebugLoc DL) {
2127 DbgScope *Scope = NULL;
2128 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2129 if (MDNode *IA = DL.getInlinedAt(Ctx))
2130 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
2132 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2137 /// recordSourceLine - Register a source line with debug info. Returns the
2138 /// unique label that was emitted and which provides correspondence to
2139 /// the source line list.
2140 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2146 DIDescriptor Scope(S);
2148 if (Scope.isCompileUnit()) {
2149 DICompileUnit CU(S);
2150 Fn = CU.getFilename();
2151 Dir = CU.getDirectory();
2152 } else if (Scope.isFile()) {
2154 Fn = F.getFilename();
2155 Dir = F.getDirectory();
2156 } else if (Scope.isSubprogram()) {
2158 Fn = SP.getFilename();
2159 Dir = SP.getDirectory();
2160 } else if (Scope.isLexicalBlock()) {
2161 DILexicalBlock DB(S);
2162 Fn = DB.getFilename();
2163 Dir = DB.getDirectory();
2165 assert(0 && "Unexpected scope info");
2167 Src = GetOrCreateSourceID(Fn, Dir);
2169 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
2172 //===----------------------------------------------------------------------===//
2174 //===----------------------------------------------------------------------===//
2176 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2179 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2180 // Get the children.
2181 const std::vector<DIE *> &Children = Die->getChildren();
2183 // If not last sibling and has children then add sibling offset attribute.
2184 if (!Last && !Children.empty())
2185 Die->addSiblingOffset(DIEValueAllocator);
2187 // Record the abbreviation.
2188 assignAbbrevNumber(Die->getAbbrev());
2190 // Get the abbreviation for this DIE.
2191 unsigned AbbrevNumber = Die->getAbbrevNumber();
2192 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2195 Die->setOffset(Offset);
2197 // Start the size with the size of abbreviation code.
2198 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2200 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2201 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2203 // Size the DIE attribute values.
2204 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2205 // Size attribute value.
2206 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2208 // Size the DIE children if any.
2209 if (!Children.empty()) {
2210 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2211 "Children flag not set");
2213 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2214 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2216 // End of children marker.
2217 Offset += sizeof(int8_t);
2220 Die->setSize(Offset - Die->getOffset());
2224 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2226 void DwarfDebug::computeSizeAndOffsets() {
2227 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2228 E = CUMap.end(); I != E; ++I) {
2229 // Compute size of compile unit header.
2231 sizeof(int32_t) + // Length of Compilation Unit Info
2232 sizeof(int16_t) + // DWARF version number
2233 sizeof(int32_t) + // Offset Into Abbrev. Section
2234 sizeof(int8_t); // Pointer Size (in bytes)
2235 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2239 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2240 /// temporary label to it if SymbolStem is specified.
2241 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2242 const char *SymbolStem = 0) {
2243 Asm->OutStreamer.SwitchSection(Section);
2244 if (!SymbolStem) return 0;
2246 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2247 Asm->OutStreamer.EmitLabel(TmpSym);
2251 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2252 /// the start of each one.
2253 void DwarfDebug::EmitSectionLabels() {
2254 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2256 // Dwarf sections base addresses.
2257 DwarfInfoSectionSym =
2258 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2259 DwarfAbbrevSectionSym =
2260 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2261 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2263 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2264 EmitSectionSym(Asm, MacroInfo);
2266 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2267 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2268 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2269 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2270 DwarfStrSectionSym =
2271 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2272 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2275 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2276 "section_debug_loc");
2278 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2279 EmitSectionSym(Asm, TLOF.getDataSection());
2282 /// emitDIE - Recursively emits a debug information entry.
2284 void DwarfDebug::emitDIE(DIE *Die) {
2285 // Get the abbreviation for this DIE.
2286 unsigned AbbrevNumber = Die->getAbbrevNumber();
2287 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2289 // Emit the code (index) for the abbreviation.
2290 if (Asm->isVerbose())
2291 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2292 Twine::utohexstr(Die->getOffset()) + ":0x" +
2293 Twine::utohexstr(Die->getSize()) + " " +
2294 dwarf::TagString(Abbrev->getTag()));
2295 Asm->EmitULEB128(AbbrevNumber);
2297 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2298 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2300 // Emit the DIE attribute values.
2301 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2302 unsigned Attr = AbbrevData[i].getAttribute();
2303 unsigned Form = AbbrevData[i].getForm();
2304 assert(Form && "Too many attributes for DIE (check abbreviation)");
2306 if (Asm->isVerbose())
2307 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2310 case dwarf::DW_AT_sibling:
2311 Asm->EmitInt32(Die->getSiblingOffset());
2313 case dwarf::DW_AT_abstract_origin: {
2314 DIEEntry *E = cast<DIEEntry>(Values[i]);
2315 DIE *Origin = E->getEntry();
2316 unsigned Addr = Origin->getOffset();
2317 Asm->EmitInt32(Addr);
2320 case dwarf::DW_AT_ranges: {
2321 // DW_AT_range Value encodes offset in debug_range section.
2322 DIEInteger *V = cast<DIEInteger>(Values[i]);
2324 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2325 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2329 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2331 DwarfDebugRangeSectionSym,
2336 case dwarf::DW_AT_location: {
2337 if (UseDotDebugLocEntry.count(Die) != 0) {
2338 DIELabel *L = cast<DIELabel>(Values[i]);
2339 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2341 Values[i]->EmitValue(Asm, Form);
2344 case dwarf::DW_AT_accessibility: {
2345 if (Asm->isVerbose()) {
2346 DIEInteger *V = cast<DIEInteger>(Values[i]);
2347 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2349 Values[i]->EmitValue(Asm, Form);
2353 // Emit an attribute using the defined form.
2354 Values[i]->EmitValue(Asm, Form);
2359 // Emit the DIE children if any.
2360 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2361 const std::vector<DIE *> &Children = Die->getChildren();
2363 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2364 emitDIE(Children[j]);
2366 if (Asm->isVerbose())
2367 Asm->OutStreamer.AddComment("End Of Children Mark");
2372 /// emitDebugInfo - Emit the debug info section.
2374 void DwarfDebug::emitDebugInfo() {
2375 // Start debug info section.
2376 Asm->OutStreamer.SwitchSection(
2377 Asm->getObjFileLowering().getDwarfInfoSection());
2378 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2379 E = CUMap.end(); I != E; ++I) {
2380 CompileUnit *TheCU = I->second;
2381 DIE *Die = TheCU->getCUDie();
2383 // Emit the compile units header.
2384 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2387 // Emit size of content not including length itself
2388 unsigned ContentSize = Die->getSize() +
2389 sizeof(int16_t) + // DWARF version number
2390 sizeof(int32_t) + // Offset Into Abbrev. Section
2391 sizeof(int8_t); // Pointer Size (in bytes)
2393 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2394 Asm->EmitInt32(ContentSize);
2395 Asm->OutStreamer.AddComment("DWARF version number");
2396 Asm->EmitInt16(dwarf::DWARF_VERSION);
2397 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2398 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2399 DwarfAbbrevSectionSym);
2400 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2401 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2404 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2408 /// emitAbbreviations - Emit the abbreviation section.
2410 void DwarfDebug::emitAbbreviations() const {
2411 // Check to see if it is worth the effort.
2412 if (!Abbreviations.empty()) {
2413 // Start the debug abbrev section.
2414 Asm->OutStreamer.SwitchSection(
2415 Asm->getObjFileLowering().getDwarfAbbrevSection());
2417 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2419 // For each abbrevation.
2420 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2421 // Get abbreviation data
2422 const DIEAbbrev *Abbrev = Abbreviations[i];
2424 // Emit the abbrevations code (base 1 index.)
2425 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2427 // Emit the abbreviations data.
2431 // Mark end of abbreviations.
2432 Asm->EmitULEB128(0, "EOM(3)");
2434 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2438 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2439 /// the line matrix.
2441 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2442 // Define last address of section.
2443 Asm->OutStreamer.AddComment("Extended Op");
2446 Asm->OutStreamer.AddComment("Op size");
2447 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2448 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2449 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2451 Asm->OutStreamer.AddComment("Section end label");
2453 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2454 Asm->getTargetData().getPointerSize(),
2457 // Mark end of matrix.
2458 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2464 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2466 void DwarfDebug::emitDebugPubNames() {
2467 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2468 E = CUMap.end(); I != E; ++I) {
2469 CompileUnit *TheCU = I->second;
2470 // Start the dwarf pubnames section.
2471 Asm->OutStreamer.SwitchSection(
2472 Asm->getObjFileLowering().getDwarfPubNamesSection());
2474 Asm->OutStreamer.AddComment("Length of Public Names Info");
2475 Asm->EmitLabelDifference(
2476 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2477 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2479 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2482 Asm->OutStreamer.AddComment("DWARF Version");
2483 Asm->EmitInt16(dwarf::DWARF_VERSION);
2485 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2486 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2487 DwarfInfoSectionSym);
2489 Asm->OutStreamer.AddComment("Compilation Unit Length");
2490 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2491 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2494 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2495 for (StringMap<DIE*>::const_iterator
2496 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2497 const char *Name = GI->getKeyData();
2498 DIE *Entity = GI->second;
2500 Asm->OutStreamer.AddComment("DIE offset");
2501 Asm->EmitInt32(Entity->getOffset());
2503 if (Asm->isVerbose())
2504 Asm->OutStreamer.AddComment("External Name");
2505 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2508 Asm->OutStreamer.AddComment("End Mark");
2510 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2515 void DwarfDebug::emitDebugPubTypes() {
2516 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2517 E = CUMap.end(); I != E; ++I) {
2518 CompileUnit *TheCU = I->second;
2519 // Start the dwarf pubnames section.
2520 Asm->OutStreamer.SwitchSection(
2521 Asm->getObjFileLowering().getDwarfPubTypesSection());
2522 Asm->OutStreamer.AddComment("Length of Public Types Info");
2523 Asm->EmitLabelDifference(
2524 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2525 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2527 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2530 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2531 Asm->EmitInt16(dwarf::DWARF_VERSION);
2533 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2534 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2535 DwarfInfoSectionSym);
2537 Asm->OutStreamer.AddComment("Compilation Unit Length");
2538 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2539 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2542 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2543 for (StringMap<DIE*>::const_iterator
2544 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2545 const char *Name = GI->getKeyData();
2546 DIE *Entity = GI->second;
2548 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2549 Asm->EmitInt32(Entity->getOffset());
2551 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2552 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2555 Asm->OutStreamer.AddComment("End Mark");
2557 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2562 /// emitDebugStr - Emit visible names into a debug str section.
2564 void DwarfDebug::emitDebugStr() {
2565 // Check to see if it is worth the effort.
2566 if (StringPool.empty()) return;
2568 // Start the dwarf str section.
2569 Asm->OutStreamer.SwitchSection(
2570 Asm->getObjFileLowering().getDwarfStrSection());
2572 // Get all of the string pool entries and put them in an array by their ID so
2573 // we can sort them.
2574 SmallVector<std::pair<unsigned,
2575 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2577 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2578 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2579 Entries.push_back(std::make_pair(I->second.second, &*I));
2581 array_pod_sort(Entries.begin(), Entries.end());
2583 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2584 // Emit a label for reference from debug information entries.
2585 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2587 // Emit the string itself.
2588 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2592 /// emitDebugLoc - Emit visible names into a debug loc section.
2594 void DwarfDebug::emitDebugLoc() {
2595 if (DotDebugLocEntries.empty())
2598 for (SmallVector<DotDebugLocEntry, 4>::iterator
2599 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2601 DotDebugLocEntry &Entry = *I;
2602 if (I + 1 != DotDebugLocEntries.end())
2606 // Start the dwarf loc section.
2607 Asm->OutStreamer.SwitchSection(
2608 Asm->getObjFileLowering().getDwarfLocSection());
2609 unsigned char Size = Asm->getTargetData().getPointerSize();
2610 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2612 for (SmallVector<DotDebugLocEntry, 4>::iterator
2613 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2614 I != E; ++I, ++index) {
2615 DotDebugLocEntry &Entry = *I;
2616 if (Entry.isMerged()) continue;
2617 if (Entry.isEmpty()) {
2618 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2619 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2620 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2622 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2623 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2624 DIVariable DV(Entry.Variable);
2625 Asm->OutStreamer.AddComment("Loc expr size");
2626 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2627 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2628 Asm->EmitLabelDifference(end, begin, 2);
2629 Asm->OutStreamer.EmitLabel(begin);
2630 if (Entry.isInt()) {
2631 DIBasicType BTy(DV.getType());
2633 (BTy.getEncoding() == dwarf::DW_ATE_signed
2634 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2635 Asm->OutStreamer.AddComment("DW_OP_consts");
2636 Asm->EmitInt8(dwarf::DW_OP_consts);
2637 Asm->EmitSLEB128(Entry.getInt());
2639 Asm->OutStreamer.AddComment("DW_OP_constu");
2640 Asm->EmitInt8(dwarf::DW_OP_constu);
2641 Asm->EmitULEB128(Entry.getInt());
2643 } else if (Entry.isLocation()) {
2644 if (!DV.hasComplexAddress())
2646 Asm->EmitDwarfRegOp(Entry.Loc);
2648 // Complex address entry.
2649 unsigned N = DV.getNumAddrElements();
2651 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2652 if (Entry.Loc.getOffset()) {
2654 Asm->EmitDwarfRegOp(Entry.Loc);
2655 Asm->OutStreamer.AddComment("DW_OP_deref");
2656 Asm->EmitInt8(dwarf::DW_OP_deref);
2657 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2658 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2659 Asm->EmitSLEB128(DV.getAddrElement(1));
2661 // If first address element is OpPlus then emit
2662 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2663 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2664 Asm->EmitDwarfRegOp(Loc);
2668 Asm->EmitDwarfRegOp(Entry.Loc);
2671 // Emit remaining complex address elements.
2672 for (; i < N; ++i) {
2673 uint64_t Element = DV.getAddrElement(i);
2674 if (Element == DIBuilder::OpPlus) {
2675 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2676 Asm->EmitULEB128(DV.getAddrElement(++i));
2677 } else if (Element == DIBuilder::OpDeref)
2678 Asm->EmitInt8(dwarf::DW_OP_deref);
2679 else llvm_unreachable("unknown Opcode found in complex address");
2683 // else ... ignore constant fp. There is not any good way to
2684 // to represent them here in dwarf.
2685 Asm->OutStreamer.EmitLabel(end);
2690 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2692 void DwarfDebug::EmitDebugARanges() {
2693 // Start the dwarf aranges section.
2694 Asm->OutStreamer.SwitchSection(
2695 Asm->getObjFileLowering().getDwarfARangesSection());
2698 /// emitDebugRanges - Emit visible names into a debug ranges section.
2700 void DwarfDebug::emitDebugRanges() {
2701 // Start the dwarf ranges section.
2702 Asm->OutStreamer.SwitchSection(
2703 Asm->getObjFileLowering().getDwarfRangesSection());
2704 unsigned char Size = Asm->getTargetData().getPointerSize();
2705 for (SmallVector<const MCSymbol *, 8>::iterator
2706 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2709 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2711 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2715 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2717 void DwarfDebug::emitDebugMacInfo() {
2718 if (const MCSection *LineInfo =
2719 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2720 // Start the dwarf macinfo section.
2721 Asm->OutStreamer.SwitchSection(LineInfo);
2725 /// emitDebugInlineInfo - Emit inline info using following format.
2727 /// 1. length of section
2728 /// 2. Dwarf version number
2729 /// 3. address size.
2731 /// Entries (one "entry" for each function that was inlined):
2733 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2734 /// otherwise offset into __debug_str for regular function name.
2735 /// 2. offset into __debug_str section for regular function name.
2736 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2737 /// instances for the function.
2739 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2740 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2741 /// __debug_info section, and the low_pc is the starting address for the
2742 /// inlining instance.
2743 void DwarfDebug::emitDebugInlineInfo() {
2744 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2750 Asm->OutStreamer.SwitchSection(
2751 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2753 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2754 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2755 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2757 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2759 Asm->OutStreamer.AddComment("Dwarf Version");
2760 Asm->EmitInt16(dwarf::DWARF_VERSION);
2761 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2762 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2764 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2765 E = InlinedSPNodes.end(); I != E; ++I) {
2767 const MDNode *Node = *I;
2768 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2769 = InlineInfo.find(Node);
2770 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2771 DISubprogram SP(Node);
2772 StringRef LName = SP.getLinkageName();
2773 StringRef Name = SP.getName();
2775 Asm->OutStreamer.AddComment("MIPS linkage name");
2776 if (LName.empty()) {
2777 Asm->OutStreamer.EmitBytes(Name, 0);
2778 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2780 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2781 DwarfStrSectionSym);
2783 Asm->OutStreamer.AddComment("Function name");
2784 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2785 Asm->EmitULEB128(Labels.size(), "Inline count");
2787 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2788 LE = Labels.end(); LI != LE; ++LI) {
2789 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2790 Asm->EmitInt32(LI->second->getOffset());
2792 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2793 Asm->OutStreamer.EmitSymbolValue(LI->first,
2794 Asm->getTargetData().getPointerSize(),0);
2798 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));