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 mainpluate 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 // FIXME : Handle getNumOperands != 3
726 if (DVInsn->getNumOperands() == 3) {
727 if (DVInsn->getOperand(0).isReg()) {
728 const MachineOperand RegOp = DVInsn->getOperand(0);
729 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
730 if (DVInsn->getOperand(1).isImm() &&
731 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
732 unsigned FrameReg = 0;
733 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
735 TFI->getFrameIndexReference(*Asm->MF,
736 DVInsn->getOperand(1).getImm(),
738 MachineLocation Location(FrameReg, Offset);
739 VariableCU->addVariableAddress(DV, VariableDie, Location);
741 } else if (RegOp.getReg())
742 VariableCU->addVariableAddress(DV, VariableDie,
743 MachineLocation(RegOp.getReg()));
746 else if (DVInsn->getOperand(0).isImm())
748 VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0),
750 else if (DVInsn->getOperand(0).isFPImm())
752 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
753 else if (DVInsn->getOperand(0).isCImm())
755 VariableCU->addConstantValue(VariableDie,
756 DVInsn->getOperand(0).getCImm(),
757 isUnsignedDIType(DV->getType()));
759 VariableCU->addVariableAddress(DV, VariableDie,
760 Asm->getDebugValueLocation(DVInsn));
764 // If variableDie is not updated then DBG_VALUE instruction does not
765 // have valid variable info.
769 DV->setDIE(VariableDie);
773 // .. else use frame index, if available.
775 if (findVariableFrameIndex(DV, &FI)) {
776 unsigned FrameReg = 0;
777 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
779 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
780 MachineLocation Location(FrameReg, Offset);
781 VariableCU->addVariableAddress(DV, VariableDie, Location);
784 DV->setDIE(VariableDie);
789 /// constructScopeDIE - Construct a DIE for this scope.
790 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
791 if (!Scope || !Scope->getScopeNode())
794 SmallVector <DIE *, 8> Children;
796 // Collect arguments for current function.
797 if (Scope == CurrentFnDbgScope)
798 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
799 if (DbgVariable *ArgDV = CurrentFnArguments[i])
800 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
801 Children.push_back(Arg);
803 // Collect lexical scope childrens first.
804 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
805 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
806 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
807 Children.push_back(Variable);
808 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
809 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
810 if (DIE *Nested = constructScopeDIE(Scopes[j]))
811 Children.push_back(Nested);
812 DIScope DS(Scope->getScopeNode());
813 DIE *ScopeDIE = NULL;
814 if (Scope->getInlinedAt())
815 ScopeDIE = constructInlinedScopeDIE(Scope);
816 else if (DS.isSubprogram()) {
817 ProcessedSPNodes.insert(DS);
818 if (Scope->isAbstractScope()) {
819 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
820 // Note down abstract DIE.
822 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
825 ScopeDIE = updateSubprogramScopeDIE(DS);
828 // There is no need to emit empty lexical block DIE.
829 if (Children.empty())
831 ScopeDIE = constructLexicalScopeDIE(Scope);
834 if (!ScopeDIE) return NULL;
837 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
838 E = Children.end(); I != E; ++I)
839 ScopeDIE->addChild(*I);
841 if (DS.isSubprogram())
842 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
847 /// GetOrCreateSourceID - Look up the source id with the given directory and
848 /// source file names. If none currently exists, create a new id and insert it
849 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
852 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
854 // If FE did not provide a file name, then assume stdin.
855 if (FileName.empty())
856 return GetOrCreateSourceID("<stdin>", StringRef());
858 // MCStream expects full path name as filename.
859 if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
860 SmallString<128> FullPathName = DirName;
861 sys::path::append(FullPathName, FileName);
862 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
863 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
866 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
867 if (Entry.getValue())
868 return Entry.getValue();
870 unsigned SrcId = SourceIdMap.size();
871 Entry.setValue(SrcId);
873 // Print out a .file directive to specify files for .loc directives.
874 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
879 /// constructCompileUnit - Create new CompileUnit for the given
880 /// metadata node with tag DW_TAG_compile_unit.
881 void DwarfDebug::constructCompileUnit(const MDNode *N) {
882 DICompileUnit DIUnit(N);
883 StringRef FN = DIUnit.getFilename();
884 StringRef Dir = DIUnit.getDirectory();
885 unsigned ID = GetOrCreateSourceID(FN, Dir);
887 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
888 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
889 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
890 DIUnit.getProducer());
891 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
892 DIUnit.getLanguage());
893 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
894 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
895 // simplifies debug range entries.
896 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
897 // DW_AT_stmt_list is a offset of line number information for this
898 // compile unit in debug_line section.
899 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
900 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
901 Asm->GetTempSymbol("section_line"));
903 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
906 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
907 if (DIUnit.isOptimized())
908 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
910 StringRef Flags = DIUnit.getFlags();
912 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
914 unsigned RVer = DIUnit.getRunTimeVersion();
916 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
917 dwarf::DW_FORM_data1, RVer);
921 CUMap.insert(std::make_pair(N, NewCU));
924 /// getCompielUnit - Get CompileUnit DIE.
925 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
926 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
928 const MDNode *CUNode = NULL;
929 if (D.isCompileUnit())
931 else if (D.isSubprogram())
932 CUNode = DISubprogram(N).getCompileUnit();
934 CUNode = DIType(N).getCompileUnit();
935 else if (D.isGlobalVariable())
936 CUNode = DIGlobalVariable(N).getCompileUnit();
937 else if (D.isVariable())
938 CUNode = DIVariable(N).getCompileUnit();
939 else if (D.isNameSpace())
940 CUNode = DINameSpace(N).getCompileUnit();
942 CUNode = DIFile(N).getCompileUnit();
946 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
947 = CUMap.find(CUNode);
948 if (I == CUMap.end())
953 // Return const exprssion if value is a GEP to access merged global
955 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
956 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
957 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
958 if (!CE || CE->getNumOperands() != 3 ||
959 CE->getOpcode() != Instruction::GetElementPtr)
962 // First operand points to a global value.
963 if (!isa<GlobalValue>(CE->getOperand(0)))
966 // Second operand is zero.
967 const ConstantInt *CI =
968 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
969 if (!CI || !CI->isZero())
972 // Third operand is offset.
973 if (!isa<ConstantInt>(CE->getOperand(2)))
979 /// constructGlobalVariableDIE - Construct global variable DIE.
980 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
981 DIGlobalVariable GV(N);
983 // If debug information is malformed then ignore it.
984 if (GV.Verify() == false)
987 // Check for pre-existence.
988 CompileUnit *TheCU = getCompileUnit(N);
989 if (TheCU->getDIE(GV))
992 DIType GTy = GV.getType();
993 DIE *VariableDIE = new DIE(GV.getTag());
995 bool isGlobalVariable = GV.getGlobal() != NULL;
998 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
999 GV.getDisplayName());
1000 StringRef LinkageName = GV.getLinkageName();
1001 if (!LinkageName.empty() && isGlobalVariable)
1002 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1003 dwarf::DW_FORM_string,
1004 getRealLinkageName(LinkageName));
1006 TheCU->addType(VariableDIE, GTy);
1008 // Add scoping info.
1009 if (!GV.isLocalToUnit()) {
1010 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1011 // Expose as global.
1012 TheCU->addGlobal(GV.getName(), VariableDIE);
1014 // Add line number info.
1015 TheCU->addSourceLine(VariableDIE, GV);
1017 TheCU->insertDIE(N, VariableDIE);
1018 // Add to context owner.
1019 DIDescriptor GVContext = GV.getContext();
1020 TheCU->addToContextOwner(VariableDIE, GVContext);
1022 if (isGlobalVariable) {
1023 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1024 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1025 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1026 Asm->Mang->getSymbol(GV.getGlobal()));
1027 // Do not create specification DIE if context is either compile unit
1029 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1030 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1031 // Create specification DIE.
1032 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1033 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1034 dwarf::DW_FORM_ref4, VariableDIE);
1035 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1036 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1037 TheCU->addDie(VariableSpecDIE);
1039 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1041 } else if (const ConstantInt *CI =
1042 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1043 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1044 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1045 // GV is a merged global.
1046 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1047 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1048 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1049 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1050 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1051 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1052 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1053 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1054 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1060 /// construct SubprogramDIE - Construct subprogram DIE.
1061 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1064 // Check for pre-existence.
1065 CompileUnit *TheCU = getCompileUnit(N);
1066 if (TheCU->getDIE(N))
1069 if (!SP.isDefinition())
1070 // This is a method declaration which will be handled while constructing
1074 DIE *SubprogramDie = createSubprogramDIE(SP);
1077 TheCU->insertDIE(N, SubprogramDie);
1079 // Add to context owner.
1080 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1082 // Expose as global.
1083 TheCU->addGlobal(SP.getName(), SubprogramDie);
1088 /// beginModule - Emit all Dwarf sections that should come prior to the
1089 /// content. Create global DIEs and emit initial debug info sections.
1090 /// This is inovked by the target AsmPrinter.
1091 void DwarfDebug::beginModule(Module *M) {
1092 if (DisableDebugInfoPrinting)
1095 // If module has named metadata anchors then use them, otherwise scan the module
1096 // using debug info finder to collect debug info.
1097 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1100 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1101 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1102 if (!GV_Nodes && !SP_Nodes)
1103 // If there are not any global variables or any functions then
1104 // there is not any debug info in this module.
1107 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1108 constructCompileUnit(CU_Nodes->getOperand(i));
1111 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1112 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1115 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1116 constructSubprogramDIE(SP_Nodes->getOperand(i));
1120 DebugInfoFinder DbgFinder;
1121 DbgFinder.processModule(*M);
1123 bool HasDebugInfo = false;
1124 // Scan all the compile-units to see if there are any marked as the main unit.
1125 // if not, we do not generate debug info.
1126 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1127 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1128 if (DICompileUnit(*I).isMain()) {
1129 HasDebugInfo = true;
1133 if (!HasDebugInfo) return;
1135 // Create all the compile unit DIEs.
1136 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1137 E = DbgFinder.compile_unit_end(); I != E; ++I)
1138 constructCompileUnit(*I);
1140 // Create DIEs for each global variable.
1141 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1142 E = DbgFinder.global_variable_end(); I != E; ++I)
1143 constructGlobalVariableDIE(*I);
1145 // Create DIEs for each subprogram.
1146 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1147 E = DbgFinder.subprogram_end(); I != E; ++I)
1148 constructSubprogramDIE(*I);
1151 // Tell MMI that we have debug info.
1152 MMI->setDebugInfoAvailability(true);
1154 // Emit initial sections.
1155 EmitSectionLabels();
1157 //getOrCreateTypeDIE
1158 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1159 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1160 DIType Ty(NMD->getOperand(i));
1161 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1164 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1165 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1166 DIType Ty(NMD->getOperand(i));
1167 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1170 // Prime section data.
1171 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1174 /// endModule - Emit all Dwarf sections that should come after the content.
1176 void DwarfDebug::endModule() {
1177 if (!FirstCU) return;
1178 const Module *M = MMI->getModule();
1179 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1180 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1181 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1182 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1183 DISubprogram SP(AllSPs->getOperand(SI));
1184 if (!SP.Verify()) continue;
1186 // Collect info for variables that were optimized out.
1187 if (!SP.isDefinition()) continue;
1188 StringRef FName = SP.getLinkageName();
1190 FName = SP.getName();
1191 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1193 unsigned E = NMD->getNumOperands();
1195 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1196 DeadFnScopeMap[SP] = Scope;
1197 for (unsigned I = 0; I != E; ++I) {
1198 DIVariable DV(NMD->getOperand(I));
1199 if (!DV.Verify()) continue;
1200 Scope->addVariable(new DbgVariable(DV));
1203 // Construct subprogram DIE and add variables DIEs.
1204 constructSubprogramDIE(SP);
1205 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1206 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1207 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1208 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1210 ScopeDIE->addChild(VariableDIE);
1215 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1216 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1217 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1219 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1222 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1223 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1224 DIE *SPDie = CI->first;
1225 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1227 DIE *NDie = getCompileUnit(N)->getDIE(N);
1228 if (!NDie) continue;
1229 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1230 dwarf::DW_FORM_ref4, NDie);
1233 // Standard sections final addresses.
1234 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1235 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1236 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1237 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1239 // End text sections.
1240 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1241 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1242 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1245 // Compute DIE offsets and sizes.
1246 computeSizeAndOffsets();
1248 // Emit all the DIEs into a debug info section
1251 // Corresponding abbreviations into a abbrev section.
1252 emitAbbreviations();
1254 // Emit info into a debug pubnames section.
1255 emitDebugPubNames();
1257 // Emit info into a debug pubtypes section.
1258 emitDebugPubTypes();
1260 // Emit info into a debug loc section.
1263 // Emit info into a debug aranges section.
1266 // Emit info into a debug ranges section.
1269 // Emit info into a debug macinfo section.
1272 // Emit inline info.
1273 emitDebugInlineInfo();
1275 // Emit info into a debug str section.
1279 DeleteContainerSeconds(DeadFnScopeMap);
1280 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1281 E = CUMap.end(); I != E; ++I)
1283 FirstCU = NULL; // Reset for the next Module, if any.
1286 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1287 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1288 DebugLoc ScopeLoc) {
1289 LLVMContext &Ctx = DV->getContext();
1291 // More then one inlined variable corresponds to one abstract variable.
1292 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1294 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1296 return AbsDbgVariable;
1299 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1303 AbsDbgVariable = new DbgVariable(Var);
1304 Scope->addVariable(AbsDbgVariable);
1305 AbstractVariables[Var] = AbsDbgVariable;
1306 return AbsDbgVariable;
1309 /// addCurrentFnArgument - If Var is an current function argument that add
1310 /// it in CurrentFnArguments list.
1311 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1312 DbgVariable *Var, DbgScope *Scope) {
1313 if (Scope != CurrentFnDbgScope)
1315 DIVariable DV = Var->getVariable();
1316 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1318 unsigned ArgNo = DV.getArgNumber();
1322 size_t Size = CurrentFnArguments.size();
1324 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1325 // llvm::Function argument size is not good indicator of how many
1326 // arguments does the function have at source level.
1328 CurrentFnArguments.resize(ArgNo * 2);
1329 CurrentFnArguments[ArgNo - 1] = Var;
1333 /// collectVariableInfoFromMMITable - Collect variable information from
1334 /// side table maintained by MMI.
1336 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1337 SmallPtrSet<const MDNode *, 16> &Processed) {
1338 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1339 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1340 VE = VMap.end(); VI != VE; ++VI) {
1341 const MDNode *Var = VI->first;
1343 Processed.insert(Var);
1345 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1347 DbgScope *Scope = findDbgScope(VP.second);
1349 // If variable scope is not found then skip this variable.
1353 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1354 DbgVariable *RegVar = new DbgVariable(DV);
1355 recordVariableFrameIndex(RegVar, VP.first);
1356 if (!addCurrentFnArgument(MF, RegVar, Scope))
1357 Scope->addVariable(RegVar);
1358 if (AbsDbgVariable) {
1359 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1360 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1365 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1366 /// DBG_VALUE instruction, is in a defined reg.
1367 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1368 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1369 return MI->getNumOperands() == 3 &&
1370 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1371 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1374 /// getDebugLocEntry - Get .debug_loc entry for the instraction range starting
1376 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1377 const MCSymbol *FLabel,
1378 const MCSymbol *SLabel,
1379 const MachineInstr *MI) {
1380 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1382 if (MI->getNumOperands() != 3) {
1383 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1384 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1386 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1387 MachineLocation MLoc;
1388 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1389 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1391 if (MI->getOperand(0).isImm())
1392 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1393 if (MI->getOperand(0).isFPImm())
1394 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1395 if (MI->getOperand(0).isCImm())
1396 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1398 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
1399 return DotDebugLocEntry();
1402 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1404 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1405 SmallPtrSet<const MDNode *, 16> &Processed) {
1407 /// collection info from MMI table.
1408 collectVariableInfoFromMMITable(MF, Processed);
1410 for (SmallVectorImpl<const MDNode*>::const_iterator
1411 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1413 const MDNode *Var = *UVI;
1414 if (Processed.count(Var))
1417 // History contains relevant DBG_VALUE instructions for Var and instructions
1419 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1420 if (History.empty())
1422 const MachineInstr *MInsn = History.front();
1425 DbgScope *Scope = NULL;
1426 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1427 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1428 Scope = CurrentFnDbgScope;
1430 if (DV.getVersion() <= LLVMDebugVersion9)
1431 Scope = findDbgScope(MInsn->getDebugLoc());
1433 if (MDNode *IA = DV.getInlinedAt())
1434 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
1436 Scope = DbgScopeMap.lookup(cast<MDNode>(DV->getOperand(1)));
1439 // If variable scope is not found then skip this variable.
1443 Processed.insert(DV);
1444 assert(MInsn->isDebugValue() && "History must begin with debug value");
1445 DbgVariable *RegVar = new DbgVariable(DV);
1446 if (!addCurrentFnArgument(MF, RegVar, Scope))
1447 Scope->addVariable(RegVar);
1448 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1449 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1450 VarToAbstractVarMap[RegVar] = AbsVar;
1453 // Simple ranges that are fully coalesced.
1454 if (History.size() <= 1 || (History.size() == 2 &&
1455 MInsn->isIdenticalTo(History.back()))) {
1456 DbgVariableToDbgInstMap[RegVar] = MInsn;
1460 // handle multiple DBG_VALUE instructions describing one variable.
1461 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1463 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1464 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1465 const MachineInstr *Begin = *HI;
1466 assert(Begin->isDebugValue() && "Invalid History entry");
1468 // Check if DBG_VALUE is truncating a range.
1469 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1470 && !Begin->getOperand(0).getReg())
1473 // Compute the range for a register location.
1474 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1475 const MCSymbol *SLabel = 0;
1478 // If Begin is the last instruction in History then its value is valid
1479 // until the end of the function.
1480 SLabel = FunctionEndSym;
1482 const MachineInstr *End = HI[1];
1483 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1484 << "\t" << *Begin << "\t" << *End << "\n");
1485 if (End->isDebugValue())
1486 SLabel = getLabelBeforeInsn(End);
1488 // End is a normal instruction clobbering the range.
1489 SLabel = getLabelAfterInsn(End);
1490 assert(SLabel && "Forgot label after clobber instruction");
1495 // The value is valid until the next DBG_VALUE or clobber.
1496 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1498 DotDebugLocEntries.push_back(DotDebugLocEntry());
1501 // Collect info for variables that were optimized out.
1502 const Function *F = MF->getFunction();
1503 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1504 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1505 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1506 if (!DV || !Processed.insert(DV))
1508 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1510 Scope->addVariable(new DbgVariable(DV));
1515 /// getLabelBeforeInsn - Return Label preceding the instruction.
1516 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1517 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1518 assert(Label && "Didn't insert label before instruction");
1522 /// getLabelAfterInsn - Return Label immediately following the instruction.
1523 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1524 return LabelsAfterInsn.lookup(MI);
1527 /// beginInstruction - Process beginning of an instruction.
1528 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1529 // Check if source location changes, but ignore DBG_VALUE locations.
1530 if (!MI->isDebugValue()) {
1531 DebugLoc DL = MI->getDebugLoc();
1532 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1533 unsigned Flags = DWARF2_FLAG_IS_STMT;
1535 if (DL == PrologEndLoc) {
1536 Flags |= DWARF2_FLAG_PROLOGUE_END;
1537 PrologEndLoc = DebugLoc();
1539 if (!DL.isUnknown()) {
1540 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1541 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1543 recordSourceLine(0, 0, 0, 0);
1547 // Insert labels where requested.
1548 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1549 LabelsBeforeInsn.find(MI);
1552 if (I == LabelsBeforeInsn.end())
1555 // Label already assigned.
1560 PrevLabel = MMI->getContext().CreateTempSymbol();
1561 Asm->OutStreamer.EmitLabel(PrevLabel);
1563 I->second = PrevLabel;
1566 /// endInstruction - Process end of an instruction.
1567 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1568 // Don't create a new label after DBG_VALUE instructions.
1569 // They don't generate code.
1570 if (!MI->isDebugValue())
1573 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1574 LabelsAfterInsn.find(MI);
1577 if (I == LabelsAfterInsn.end())
1580 // Label already assigned.
1584 // We need a label after this instruction.
1586 PrevLabel = MMI->getContext().CreateTempSymbol();
1587 Asm->OutStreamer.EmitLabel(PrevLabel);
1589 I->second = PrevLabel;
1592 /// getOrCreateRegularScope - Create regular DbgScope.
1593 DbgScope *DwarfDebug::getOrCreateRegularScope(MDNode *Scope) {
1594 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1597 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1598 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1599 if (DIDescriptor(Scope).isLexicalBlock()) {
1601 getOrCreateDbgScope(DebugLoc::getFromDILexicalBlock(Scope));
1602 WScope->setParent(Parent);
1603 Parent->addScope(WScope);
1604 } else if (DIDescriptor(Scope).isSubprogram()
1605 && DISubprogram(Scope).describes(Asm->MF->getFunction()))
1606 CurrentFnDbgScope = WScope;
1611 /// getOrCreateInlinedScope - Create inlined scope.
1612 DbgScope *DwarfDebug::getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt){
1613 DbgScope *InlinedScope = DbgScopeMap.lookup(InlinedAt);
1615 return InlinedScope;
1617 InlinedScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1618 DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt);
1619 InlinedDbgScopeMap[InlinedLoc] = InlinedScope;
1620 DbgScopeMap[InlinedAt] = InlinedScope;
1621 DbgScope *Parent = getOrCreateDbgScope(InlinedLoc);
1622 InlinedScope->setParent(Parent);
1623 Parent->addScope(InlinedScope);
1624 return InlinedScope;
1627 /// getOrCreateDbgScope - Create DbgScope for the scope.
1628 DbgScope *DwarfDebug::getOrCreateDbgScope(DebugLoc DL) {
1629 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1630 MDNode *Scope = NULL;
1631 MDNode *InlinedAt = NULL;
1632 DL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1634 return getOrCreateRegularScope(Scope);
1636 // Create an abstract scope for inlined function.
1637 getOrCreateAbstractScope(Scope);
1638 // Create an inlined scope for inlined function.
1639 return getOrCreateInlinedScope(Scope, InlinedAt);
1642 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1644 static void calculateDominanceGraph(DbgScope *Scope) {
1645 assert (Scope && "Unable to calculate scop edominance graph!");
1646 SmallVector<DbgScope *, 4> WorkStack;
1647 WorkStack.push_back(Scope);
1648 unsigned Counter = 0;
1649 while (!WorkStack.empty()) {
1650 DbgScope *WS = WorkStack.back();
1651 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1652 bool visitedChildren = false;
1653 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1654 SE = Children.end(); SI != SE; ++SI) {
1655 DbgScope *ChildScope = *SI;
1656 if (!ChildScope->getDFSOut()) {
1657 WorkStack.push_back(ChildScope);
1658 visitedChildren = true;
1659 ChildScope->setDFSIn(++Counter);
1662 dbgs() << "calculate dbgscope dom: In " << Counter << "\n";
1667 if (!visitedChildren) {
1668 WorkStack.pop_back();
1669 WS->setDFSOut(++Counter);
1672 dbgs() << "calculate dbgscope dom: In " << WS->getDFSIn()
1673 << " Out " << Counter << "\n";
1679 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1681 void printDbgScopeInfo(const MachineFunction *MF,
1682 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1685 LLVMContext &Ctx = MF->getFunction()->getContext();
1686 unsigned PrevDFSIn = 0;
1687 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1689 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1691 const MachineInstr *MInsn = II;
1692 MDNode *Scope = NULL;
1693 MDNode *InlinedAt = NULL;
1695 // Check if instruction has valid location information.
1696 DebugLoc MIDL = MInsn->getDebugLoc();
1697 if (!MIDL.isUnknown()) {
1698 MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1702 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1703 MI2ScopeMap.find(MInsn);
1704 if (DI != MI2ScopeMap.end()) {
1705 DbgScope *S = DI->second;
1706 dbgs() << S->getDFSIn();
1707 PrevDFSIn = S->getDFSIn();
1709 dbgs() << PrevDFSIn;
1711 dbgs() << " [ x" << PrevDFSIn;
1719 /// extractScopeInformation - Scan machine instructions in this function
1720 /// and collect DbgScopes. Return true, if at least one scope was found.
1721 bool DwarfDebug::extractScopeInformation() {
1722 // If scope information was extracted using .dbg intrinsics then there is not
1723 // any need to extract these information by scanning each instruction.
1724 if (!DbgScopeMap.empty())
1727 // Scan each instruction and create scopes. First build working set of scopes.
1728 SmallVector<DbgRange, 4> MIRanges;
1729 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1730 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1732 const MachineInstr *RangeBeginMI = NULL;
1733 const MachineInstr *PrevMI = NULL;
1735 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1737 const MachineInstr *MInsn = II;
1739 // Check if instruction has valid location information.
1740 const DebugLoc MIDL = MInsn->getDebugLoc();
1741 if (MIDL.isUnknown()) {
1746 // If scope has not changed then skip this instruction.
1747 if (MIDL == PrevDL) {
1752 // Ignore DBG_VALUE. It does not contribute any instruction in output.
1753 if (MInsn->isDebugValue())
1757 // If we have alread seen a beginning of a instruction range and
1758 // current instruction scope does not match scope of first instruction
1759 // in this range then create a new instruction range.
1760 DEBUG(dbgs() << "Creating new instruction range :\n");
1761 DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI);
1762 DEBUG(dbgs() << "End Range at " << *PrevMI);
1763 DEBUG(dbgs() << "Next Range starting at " << *MInsn);
1764 DEBUG(dbgs() << "------------------------\n");
1765 DbgRange R(RangeBeginMI, PrevMI);
1766 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1767 MIRanges.push_back(R);
1770 // This is a beginning of a new instruction range.
1771 RangeBeginMI = MInsn;
1773 // Reset previous markers.
1778 // Create last instruction range.
1779 if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) {
1780 DbgRange R(RangeBeginMI, PrevMI);
1781 MIRanges.push_back(R);
1782 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1786 if (!CurrentFnDbgScope)
1789 calculateDominanceGraph(CurrentFnDbgScope);
1791 printDbgScopeInfo(Asm->MF, MI2ScopeMap);
1793 // Find ranges of instructions covered by each DbgScope;
1794 DbgScope *PrevDbgScope = NULL;
1795 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1796 RE = MIRanges.end(); RI != RE; ++RI) {
1797 const DbgRange &R = *RI;
1798 DbgScope *S = MI2ScopeMap.lookup(R.first);
1799 assert (S && "Lost DbgScope for a machine instruction!");
1800 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1801 PrevDbgScope->closeInsnRange(S);
1802 S->openInsnRange(R.first);
1803 S->extendInsnRange(R.second);
1808 PrevDbgScope->closeInsnRange();
1810 identifyScopeMarkers();
1812 return !DbgScopeMap.empty();
1815 /// identifyScopeMarkers() -
1816 /// Each DbgScope has first instruction and last instruction to mark beginning
1817 /// and end of a scope respectively. Create an inverse map that list scopes
1818 /// starts (and ends) with an instruction. One instruction may start (or end)
1819 /// multiple scopes. Ignore scopes that are not reachable.
1820 void DwarfDebug::identifyScopeMarkers() {
1821 SmallVector<DbgScope *, 4> WorkList;
1822 WorkList.push_back(CurrentFnDbgScope);
1823 while (!WorkList.empty()) {
1824 DbgScope *S = WorkList.pop_back_val();
1826 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1827 if (!Children.empty())
1828 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1829 SE = Children.end(); SI != SE; ++SI)
1830 WorkList.push_back(*SI);
1832 if (S->isAbstractScope())
1835 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1838 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1839 RE = Ranges.end(); RI != RE; ++RI) {
1840 assert(RI->first && "DbgRange does not have first instruction!");
1841 assert(RI->second && "DbgRange does not have second instruction!");
1842 requestLabelBeforeInsn(RI->first);
1843 requestLabelAfterInsn(RI->second);
1848 /// getScopeNode - Get MDNode for DebugLoc's scope.
1849 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1850 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1851 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1852 return DL.getScope(Ctx);
1855 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1856 /// line number info for the function.
1857 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1858 const MDNode *Scope = getScopeNode(DL, Ctx);
1859 DISubprogram SP = getDISubprogram(Scope);
1861 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1865 /// beginFunction - Gather pre-function debug information. Assumes being
1866 /// emitted immediately after the function entry point.
1867 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1868 if (!MMI->hasDebugInfo()) return;
1869 if (!extractScopeInformation()) return;
1871 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1872 Asm->getFunctionNumber());
1873 // Assumes in correct section after the entry point.
1874 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1876 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1878 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1879 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1880 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1882 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1884 bool AtBlockEntry = true;
1885 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1887 const MachineInstr *MI = II;
1889 if (MI->isDebugValue()) {
1890 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1892 // Keep track of user variables.
1894 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1896 // Variable is in a register, we need to check for clobbers.
1897 if (isDbgValueInDefinedReg(MI))
1898 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1900 // Check the history of this variable.
1901 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1902 if (History.empty()) {
1903 UserVariables.push_back(Var);
1904 // The first mention of a function argument gets the FunctionBeginSym
1905 // label, so arguments are visible when breaking at function entry.
1907 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1908 DISubprogram(getDISubprogram(DV.getContext()))
1909 .describes(MF->getFunction()))
1910 LabelsBeforeInsn[MI] = FunctionBeginSym;
1912 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1913 const MachineInstr *Prev = History.back();
1914 if (Prev->isDebugValue()) {
1915 // Coalesce identical entries at the end of History.
1916 if (History.size() >= 2 &&
1917 Prev->isIdenticalTo(History[History.size() - 2])) {
1918 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1920 << "\t" << *History[History.size() - 2] << "\n");
1924 // Terminate old register assignments that don't reach MI;
1925 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1926 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1927 isDbgValueInDefinedReg(Prev)) {
1928 // Previous register assignment needs to terminate at the end of
1930 MachineBasicBlock::const_iterator LastMI =
1931 PrevMBB->getLastNonDebugInstr();
1932 if (LastMI == PrevMBB->end()) {
1933 // Drop DBG_VALUE for empty range.
1934 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1935 << "\t" << *Prev << "\n");
1939 // Terminate after LastMI.
1940 History.push_back(LastMI);
1945 History.push_back(MI);
1947 // Not a DBG_VALUE instruction.
1949 AtBlockEntry = false;
1951 // First known non DBG_VALUE location marks beginning of function
1953 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1954 PrologEndLoc = MI->getDebugLoc();
1956 // Check if the instruction clobbers any registers with debug vars.
1957 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1958 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1959 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1961 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1962 unsigned Reg = *AI; ++AI) {
1963 const MDNode *Var = LiveUserVar[Reg];
1966 // Reg is now clobbered.
1967 LiveUserVar[Reg] = 0;
1969 // Was MD last defined by a DBG_VALUE referring to Reg?
1970 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1971 if (HistI == DbgValues.end())
1973 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1974 if (History.empty())
1976 const MachineInstr *Prev = History.back();
1977 // Sanity-check: Register assignments are terminated at the end of
1979 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1981 // Is the variable still in Reg?
1982 if (!isDbgValueInDefinedReg(Prev) ||
1983 Prev->getOperand(0).getReg() != Reg)
1985 // Var is clobbered. Make sure the next instruction gets a label.
1986 History.push_back(MI);
1993 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1995 SmallVectorImpl<const MachineInstr*> &History = I->second;
1996 if (History.empty())
1999 // Make sure the final register assignments are terminated.
2000 const MachineInstr *Prev = History.back();
2001 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
2002 const MachineBasicBlock *PrevMBB = Prev->getParent();
2003 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
2004 if (LastMI == PrevMBB->end())
2005 // Drop DBG_VALUE for empty range.
2008 // Terminate after LastMI.
2009 History.push_back(LastMI);
2012 // Request labels for the full history.
2013 for (unsigned i = 0, e = History.size(); i != e; ++i) {
2014 const MachineInstr *MI = History[i];
2015 if (MI->isDebugValue())
2016 requestLabelBeforeInsn(MI);
2018 requestLabelAfterInsn(MI);
2022 PrevInstLoc = DebugLoc();
2023 PrevLabel = FunctionBeginSym;
2025 // Record beginning of function.
2026 if (!PrologEndLoc.isUnknown()) {
2027 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
2028 MF->getFunction()->getContext());
2029 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
2030 FnStartDL.getScope(MF->getFunction()->getContext()),
2031 DWARF2_FLAG_IS_STMT);
2035 /// endFunction - Gather and emit post-function debug information.
2037 void DwarfDebug::endFunction(const MachineFunction *MF) {
2038 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2040 if (CurrentFnDbgScope) {
2042 // Define end label for subprogram.
2043 FunctionEndSym = Asm->GetTempSymbol("func_end",
2044 Asm->getFunctionNumber());
2045 // Assumes in correct section after the entry point.
2046 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2048 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2049 collectVariableInfo(MF, ProcessedVars);
2051 // Construct abstract scopes.
2052 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2053 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2054 DISubprogram SP((*AI)->getScopeNode());
2056 // Collect info for variables that were optimized out.
2057 StringRef FName = SP.getLinkageName();
2059 FName = SP.getName();
2060 if (NamedMDNode *NMD =
2061 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2062 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2063 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2064 if (!DV || !ProcessedVars.insert(DV))
2066 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2068 Scope->addVariable(new DbgVariable(DV));
2072 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2073 constructScopeDIE(*AI);
2076 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2078 if (!DisableFramePointerElim(*MF))
2079 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2080 dwarf::DW_AT_APPLE_omit_frame_ptr,
2081 dwarf::DW_FORM_flag, 1);
2084 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2085 MMI->getFrameMoves()));
2089 CurrentFnDbgScope = NULL;
2090 DeleteContainerPointers(CurrentFnArguments);
2091 DbgVariableToFrameIndexMap.clear();
2092 VarToAbstractVarMap.clear();
2093 DbgVariableToDbgInstMap.clear();
2094 InlinedDbgScopeMap.clear();
2095 DeleteContainerSeconds(DbgScopeMap);
2096 UserVariables.clear();
2098 DeleteContainerSeconds(AbstractScopes);
2099 AbstractScopesList.clear();
2100 AbstractVariables.clear();
2101 LabelsBeforeInsn.clear();
2102 LabelsAfterInsn.clear();
2106 /// recordVariableFrameIndex - Record a variable's index.
2107 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2108 assert (V && "Invalid DbgVariable!");
2109 DbgVariableToFrameIndexMap[V] = Index;
2112 /// findVariableFrameIndex - Return true if frame index for the variable
2113 /// is found. Update FI to hold value of the index.
2114 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2115 assert (V && "Invalid DbgVariable!");
2116 DenseMap<const DbgVariable *, int>::iterator I =
2117 DbgVariableToFrameIndexMap.find(V);
2118 if (I == DbgVariableToFrameIndexMap.end())
2124 /// findDbgScope - Find DbgScope for the debug loc.
2125 DbgScope *DwarfDebug::findDbgScope(DebugLoc DL) {
2129 DbgScope *Scope = NULL;
2130 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2131 if (MDNode *IA = DL.getInlinedAt(Ctx))
2132 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
2134 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2139 /// recordSourceLine - Register a source line with debug info. Returns the
2140 /// unique label that was emitted and which provides correspondence to
2141 /// the source line list.
2142 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2148 DIDescriptor Scope(S);
2150 if (Scope.isCompileUnit()) {
2151 DICompileUnit CU(S);
2152 Fn = CU.getFilename();
2153 Dir = CU.getDirectory();
2154 } else if (Scope.isFile()) {
2156 Fn = F.getFilename();
2157 Dir = F.getDirectory();
2158 } else if (Scope.isSubprogram()) {
2160 Fn = SP.getFilename();
2161 Dir = SP.getDirectory();
2162 } else if (Scope.isLexicalBlock()) {
2163 DILexicalBlock DB(S);
2164 Fn = DB.getFilename();
2165 Dir = DB.getDirectory();
2167 assert(0 && "Unexpected scope info");
2169 Src = GetOrCreateSourceID(Fn, Dir);
2171 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2175 //===----------------------------------------------------------------------===//
2177 //===----------------------------------------------------------------------===//
2179 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2182 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2183 // Get the children.
2184 const std::vector<DIE *> &Children = Die->getChildren();
2186 // If not last sibling and has children then add sibling offset attribute.
2187 if (!Last && !Children.empty())
2188 Die->addSiblingOffset(DIEValueAllocator);
2190 // Record the abbreviation.
2191 assignAbbrevNumber(Die->getAbbrev());
2193 // Get the abbreviation for this DIE.
2194 unsigned AbbrevNumber = Die->getAbbrevNumber();
2195 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2198 Die->setOffset(Offset);
2200 // Start the size with the size of abbreviation code.
2201 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2203 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2204 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2206 // Size the DIE attribute values.
2207 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2208 // Size attribute value.
2209 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2211 // Size the DIE children if any.
2212 if (!Children.empty()) {
2213 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2214 "Children flag not set");
2216 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2217 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2219 // End of children marker.
2220 Offset += sizeof(int8_t);
2223 Die->setSize(Offset - Die->getOffset());
2227 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2229 void DwarfDebug::computeSizeAndOffsets() {
2230 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2231 E = CUMap.end(); I != E; ++I) {
2232 // Compute size of compile unit header.
2234 sizeof(int32_t) + // Length of Compilation Unit Info
2235 sizeof(int16_t) + // DWARF version number
2236 sizeof(int32_t) + // Offset Into Abbrev. Section
2237 sizeof(int8_t); // Pointer Size (in bytes)
2238 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2242 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2243 /// temporary label to it if SymbolStem is specified.
2244 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2245 const char *SymbolStem = 0) {
2246 Asm->OutStreamer.SwitchSection(Section);
2247 if (!SymbolStem) return 0;
2249 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2250 Asm->OutStreamer.EmitLabel(TmpSym);
2254 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2255 /// the start of each one.
2256 void DwarfDebug::EmitSectionLabels() {
2257 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2259 // Dwarf sections base addresses.
2260 DwarfInfoSectionSym =
2261 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2262 DwarfAbbrevSectionSym =
2263 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2264 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2266 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2267 EmitSectionSym(Asm, MacroInfo);
2269 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2270 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2271 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2272 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2273 DwarfStrSectionSym =
2274 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2275 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2278 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2279 "section_debug_loc");
2281 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2282 EmitSectionSym(Asm, TLOF.getDataSection());
2285 /// emitDIE - Recusively Emits a debug information entry.
2287 void DwarfDebug::emitDIE(DIE *Die) {
2288 // Get the abbreviation for this DIE.
2289 unsigned AbbrevNumber = Die->getAbbrevNumber();
2290 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2292 // Emit the code (index) for the abbreviation.
2293 if (Asm->isVerbose())
2294 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2295 Twine::utohexstr(Die->getOffset()) + ":0x" +
2296 Twine::utohexstr(Die->getSize()) + " " +
2297 dwarf::TagString(Abbrev->getTag()));
2298 Asm->EmitULEB128(AbbrevNumber);
2300 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2301 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2303 // Emit the DIE attribute values.
2304 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2305 unsigned Attr = AbbrevData[i].getAttribute();
2306 unsigned Form = AbbrevData[i].getForm();
2307 assert(Form && "Too many attributes for DIE (check abbreviation)");
2309 if (Asm->isVerbose())
2310 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2313 case dwarf::DW_AT_sibling:
2314 Asm->EmitInt32(Die->getSiblingOffset());
2316 case dwarf::DW_AT_abstract_origin: {
2317 DIEEntry *E = cast<DIEEntry>(Values[i]);
2318 DIE *Origin = E->getEntry();
2319 unsigned Addr = Origin->getOffset();
2320 Asm->EmitInt32(Addr);
2323 case dwarf::DW_AT_ranges: {
2324 // DW_AT_range Value encodes offset in debug_range section.
2325 DIEInteger *V = cast<DIEInteger>(Values[i]);
2327 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2328 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2332 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2334 DwarfDebugRangeSectionSym,
2339 case dwarf::DW_AT_location: {
2340 if (UseDotDebugLocEntry.count(Die) != 0) {
2341 DIELabel *L = cast<DIELabel>(Values[i]);
2342 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2344 Values[i]->EmitValue(Asm, Form);
2347 case dwarf::DW_AT_accessibility: {
2348 if (Asm->isVerbose()) {
2349 DIEInteger *V = cast<DIEInteger>(Values[i]);
2350 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2352 Values[i]->EmitValue(Asm, Form);
2356 // Emit an attribute using the defined form.
2357 Values[i]->EmitValue(Asm, Form);
2362 // Emit the DIE children if any.
2363 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2364 const std::vector<DIE *> &Children = Die->getChildren();
2366 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2367 emitDIE(Children[j]);
2369 if (Asm->isVerbose())
2370 Asm->OutStreamer.AddComment("End Of Children Mark");
2375 /// emitDebugInfo - Emit the debug info section.
2377 void DwarfDebug::emitDebugInfo() {
2378 // Start debug info section.
2379 Asm->OutStreamer.SwitchSection(
2380 Asm->getObjFileLowering().getDwarfInfoSection());
2381 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2382 E = CUMap.end(); I != E; ++I) {
2383 CompileUnit *TheCU = I->second;
2384 DIE *Die = TheCU->getCUDie();
2386 // Emit the compile units header.
2387 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2390 // Emit size of content not including length itself
2391 unsigned ContentSize = Die->getSize() +
2392 sizeof(int16_t) + // DWARF version number
2393 sizeof(int32_t) + // Offset Into Abbrev. Section
2394 sizeof(int8_t); // Pointer Size (in bytes)
2396 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2397 Asm->EmitInt32(ContentSize);
2398 Asm->OutStreamer.AddComment("DWARF version number");
2399 Asm->EmitInt16(dwarf::DWARF_VERSION);
2400 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2401 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2402 DwarfAbbrevSectionSym);
2403 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2404 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2407 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2411 /// emitAbbreviations - Emit the abbreviation section.
2413 void DwarfDebug::emitAbbreviations() const {
2414 // Check to see if it is worth the effort.
2415 if (!Abbreviations.empty()) {
2416 // Start the debug abbrev section.
2417 Asm->OutStreamer.SwitchSection(
2418 Asm->getObjFileLowering().getDwarfAbbrevSection());
2420 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2422 // For each abbrevation.
2423 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2424 // Get abbreviation data
2425 const DIEAbbrev *Abbrev = Abbreviations[i];
2427 // Emit the abbrevations code (base 1 index.)
2428 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2430 // Emit the abbreviations data.
2434 // Mark end of abbreviations.
2435 Asm->EmitULEB128(0, "EOM(3)");
2437 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2441 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2442 /// the line matrix.
2444 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2445 // Define last address of section.
2446 Asm->OutStreamer.AddComment("Extended Op");
2449 Asm->OutStreamer.AddComment("Op size");
2450 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2451 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2452 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2454 Asm->OutStreamer.AddComment("Section end label");
2456 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2457 Asm->getTargetData().getPointerSize(),
2460 // Mark end of matrix.
2461 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2467 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2469 void DwarfDebug::emitDebugPubNames() {
2470 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2471 E = CUMap.end(); I != E; ++I) {
2472 CompileUnit *TheCU = I->second;
2473 // Start the dwarf pubnames section.
2474 Asm->OutStreamer.SwitchSection(
2475 Asm->getObjFileLowering().getDwarfPubNamesSection());
2477 Asm->OutStreamer.AddComment("Length of Public Names Info");
2478 Asm->EmitLabelDifference(
2479 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2480 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2482 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2485 Asm->OutStreamer.AddComment("DWARF Version");
2486 Asm->EmitInt16(dwarf::DWARF_VERSION);
2488 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2489 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2490 DwarfInfoSectionSym);
2492 Asm->OutStreamer.AddComment("Compilation Unit Length");
2493 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2494 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2497 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2498 for (StringMap<DIE*>::const_iterator
2499 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2500 const char *Name = GI->getKeyData();
2501 DIE *Entity = GI->second;
2503 Asm->OutStreamer.AddComment("DIE offset");
2504 Asm->EmitInt32(Entity->getOffset());
2506 if (Asm->isVerbose())
2507 Asm->OutStreamer.AddComment("External Name");
2508 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2511 Asm->OutStreamer.AddComment("End Mark");
2513 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2518 void DwarfDebug::emitDebugPubTypes() {
2519 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2520 E = CUMap.end(); I != E; ++I) {
2521 CompileUnit *TheCU = I->second;
2522 // Start the dwarf pubnames section.
2523 Asm->OutStreamer.SwitchSection(
2524 Asm->getObjFileLowering().getDwarfPubTypesSection());
2525 Asm->OutStreamer.AddComment("Length of Public Types Info");
2526 Asm->EmitLabelDifference(
2527 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2528 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2530 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2533 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2534 Asm->EmitInt16(dwarf::DWARF_VERSION);
2536 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2537 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2538 DwarfInfoSectionSym);
2540 Asm->OutStreamer.AddComment("Compilation Unit Length");
2541 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2542 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2545 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2546 for (StringMap<DIE*>::const_iterator
2547 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2548 const char *Name = GI->getKeyData();
2549 DIE * Entity = GI->second;
2551 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2552 Asm->EmitInt32(Entity->getOffset());
2554 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2555 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2558 Asm->OutStreamer.AddComment("End Mark");
2560 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2565 /// emitDebugStr - Emit visible names into a debug str section.
2567 void DwarfDebug::emitDebugStr() {
2568 // Check to see if it is worth the effort.
2569 if (StringPool.empty()) return;
2571 // Start the dwarf str section.
2572 Asm->OutStreamer.SwitchSection(
2573 Asm->getObjFileLowering().getDwarfStrSection());
2575 // Get all of the string pool entries and put them in an array by their ID so
2576 // we can sort them.
2577 SmallVector<std::pair<unsigned,
2578 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2580 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2581 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2582 Entries.push_back(std::make_pair(I->second.second, &*I));
2584 array_pod_sort(Entries.begin(), Entries.end());
2586 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2587 // Emit a label for reference from debug information entries.
2588 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2590 // Emit the string itself.
2591 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2595 /// emitDebugLoc - Emit visible names into a debug loc section.
2597 void DwarfDebug::emitDebugLoc() {
2598 if (DotDebugLocEntries.empty())
2601 for (SmallVector<DotDebugLocEntry, 4>::iterator
2602 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2604 DotDebugLocEntry &Entry = *I;
2605 if (I + 1 != DotDebugLocEntries.end())
2609 // Start the dwarf loc section.
2610 Asm->OutStreamer.SwitchSection(
2611 Asm->getObjFileLowering().getDwarfLocSection());
2612 unsigned char Size = Asm->getTargetData().getPointerSize();
2613 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2615 for (SmallVector<DotDebugLocEntry, 4>::iterator
2616 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2617 I != E; ++I, ++index) {
2618 DotDebugLocEntry &Entry = *I;
2619 if (Entry.isMerged()) continue;
2620 if (Entry.isEmpty()) {
2621 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2622 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2623 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2625 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2626 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2627 DIVariable DV(Entry.Variable);
2628 Asm->OutStreamer.AddComment("Loc expr size");
2629 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2630 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2631 Asm->EmitLabelDifference(end, begin, 2);
2632 Asm->OutStreamer.EmitLabel(begin);
2633 if (Entry.isInt()) {
2634 DIBasicType BTy(DV.getType());
2636 (BTy.getEncoding() == dwarf::DW_ATE_signed
2637 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2638 Asm->OutStreamer.AddComment("DW_OP_consts");
2639 Asm->EmitInt8(dwarf::DW_OP_consts);
2640 Asm->EmitSLEB128(Entry.getInt());
2642 Asm->OutStreamer.AddComment("DW_OP_constu");
2643 Asm->EmitInt8(dwarf::DW_OP_constu);
2644 Asm->EmitULEB128(Entry.getInt());
2646 } else if (Entry.isLocation()) {
2647 if (!DV.hasComplexAddress())
2649 Asm->EmitDwarfRegOp(Entry.Loc);
2651 // Complex address entry.
2652 unsigned N = DV.getNumAddrElements();
2654 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2655 if (Entry.Loc.getOffset()) {
2657 Asm->EmitDwarfRegOp(Entry.Loc);
2658 Asm->OutStreamer.AddComment("DW_OP_deref");
2659 Asm->EmitInt8(dwarf::DW_OP_deref);
2660 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2661 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2662 Asm->EmitSLEB128(DV.getAddrElement(1));
2664 // If first address element is OpPlus then emit
2665 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2666 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2667 Asm->EmitDwarfRegOp(Loc);
2671 Asm->EmitDwarfRegOp(Entry.Loc);
2674 // Emit remaining complex address elements.
2675 for (; i < N; ++i) {
2676 uint64_t Element = DV.getAddrElement(i);
2677 if (Element == DIBuilder::OpPlus) {
2678 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2679 Asm->EmitULEB128(DV.getAddrElement(++i));
2680 } else if (Element == DIBuilder::OpDeref)
2681 Asm->EmitInt8(dwarf::DW_OP_deref);
2682 else llvm_unreachable("unknown Opcode found in complex address");
2686 // else ... ignore constant fp. There is not any good way to
2687 // to represent them here in dwarf.
2688 Asm->OutStreamer.EmitLabel(end);
2693 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2695 void DwarfDebug::EmitDebugARanges() {
2696 // Start the dwarf aranges section.
2697 Asm->OutStreamer.SwitchSection(
2698 Asm->getObjFileLowering().getDwarfARangesSection());
2701 /// emitDebugRanges - Emit visible names into a debug ranges section.
2703 void DwarfDebug::emitDebugRanges() {
2704 // Start the dwarf ranges section.
2705 Asm->OutStreamer.SwitchSection(
2706 Asm->getObjFileLowering().getDwarfRangesSection());
2707 unsigned char Size = Asm->getTargetData().getPointerSize();
2708 for (SmallVector<const MCSymbol *, 8>::iterator
2709 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2712 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2714 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2718 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2720 void DwarfDebug::emitDebugMacInfo() {
2721 if (const MCSection *LineInfo =
2722 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2723 // Start the dwarf macinfo section.
2724 Asm->OutStreamer.SwitchSection(LineInfo);
2728 /// emitDebugInlineInfo - Emit inline info using following format.
2730 /// 1. length of section
2731 /// 2. Dwarf version number
2732 /// 3. address size.
2734 /// Entries (one "entry" for each function that was inlined):
2736 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2737 /// otherwise offset into __debug_str for regular function name.
2738 /// 2. offset into __debug_str section for regular function name.
2739 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2740 /// instances for the function.
2742 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2743 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2744 /// __debug_info section, and the low_pc is the starting address for the
2745 /// inlining instance.
2746 void DwarfDebug::emitDebugInlineInfo() {
2747 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2753 Asm->OutStreamer.SwitchSection(
2754 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2756 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2757 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2758 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2760 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2762 Asm->OutStreamer.AddComment("Dwarf Version");
2763 Asm->EmitInt16(dwarf::DWARF_VERSION);
2764 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2765 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2767 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2768 E = InlinedSPNodes.end(); I != E; ++I) {
2770 const MDNode *Node = *I;
2771 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2772 = InlineInfo.find(Node);
2773 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2774 DISubprogram SP(Node);
2775 StringRef LName = SP.getLinkageName();
2776 StringRef Name = SP.getName();
2778 Asm->OutStreamer.AddComment("MIPS linkage name");
2779 if (LName.empty()) {
2780 Asm->OutStreamer.EmitBytes(Name, 0);
2781 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2783 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2784 DwarfStrSectionSym);
2786 Asm->OutStreamer.AddComment("Function name");
2787 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2788 Asm->EmitULEB128(Labels.size(), "Inline count");
2790 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2791 LE = Labels.end(); LI != LE; ++LI) {
2792 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2793 Asm->EmitInt32(LI->second->getOffset());
2795 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2796 Asm->OutStreamer.EmitSymbolValue(LI->first,
2797 Asm->getTargetData().getPointerSize(),0);
2801 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));