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 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 /// getCompielUnit - 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 exprssion 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 =
967 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
968 if (!CI || !CI->isZero())
971 // Third operand is offset.
972 if (!isa<ConstantInt>(CE->getOperand(2)))
978 /// constructGlobalVariableDIE - Construct global variable DIE.
979 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
980 DIGlobalVariable GV(N);
982 // If debug information is malformed then ignore it.
983 if (GV.Verify() == false)
986 // Check for pre-existence.
987 CompileUnit *TheCU = getCompileUnit(N);
988 if (TheCU->getDIE(GV))
991 DIType GTy = GV.getType();
992 DIE *VariableDIE = new DIE(GV.getTag());
994 bool isGlobalVariable = GV.getGlobal() != NULL;
997 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
998 GV.getDisplayName());
999 StringRef LinkageName = GV.getLinkageName();
1000 if (!LinkageName.empty() && isGlobalVariable)
1001 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1002 dwarf::DW_FORM_string,
1003 getRealLinkageName(LinkageName));
1005 TheCU->addType(VariableDIE, GTy);
1007 // Add scoping info.
1008 if (!GV.isLocalToUnit()) {
1009 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1010 // Expose as global.
1011 TheCU->addGlobal(GV.getName(), VariableDIE);
1013 // Add line number info.
1014 TheCU->addSourceLine(VariableDIE, GV);
1016 TheCU->insertDIE(N, VariableDIE);
1017 // Add to context owner.
1018 DIDescriptor GVContext = GV.getContext();
1019 TheCU->addToContextOwner(VariableDIE, GVContext);
1021 if (isGlobalVariable) {
1022 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1023 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1024 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1025 Asm->Mang->getSymbol(GV.getGlobal()));
1026 // Do not create specification DIE if context is either compile unit
1028 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1029 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1030 // Create specification DIE.
1031 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1032 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1033 dwarf::DW_FORM_ref4, VariableDIE);
1034 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1035 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1036 TheCU->addDie(VariableSpecDIE);
1038 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1040 } else if (const ConstantInt *CI =
1041 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1042 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1043 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1044 // GV is a merged global.
1045 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1046 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1047 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1048 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1049 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1050 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1051 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1052 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1053 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1059 /// construct SubprogramDIE - Construct subprogram DIE.
1060 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1063 // Check for pre-existence.
1064 CompileUnit *TheCU = getCompileUnit(N);
1065 if (TheCU->getDIE(N))
1068 if (!SP.isDefinition())
1069 // This is a method declaration which will be handled while constructing
1073 DIE *SubprogramDie = createSubprogramDIE(SP);
1076 TheCU->insertDIE(N, SubprogramDie);
1078 // Add to context owner.
1079 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1081 // Expose as global.
1082 TheCU->addGlobal(SP.getName(), SubprogramDie);
1087 /// beginModule - Emit all Dwarf sections that should come prior to the
1088 /// content. Create global DIEs and emit initial debug info sections.
1089 /// This is inovked by the target AsmPrinter.
1090 void DwarfDebug::beginModule(Module *M) {
1091 if (DisableDebugInfoPrinting)
1094 // If module has named metadata anchors then use them, otherwise scan the module
1095 // using debug info finder to collect debug info.
1096 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1099 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1100 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1101 if (!GV_Nodes && !SP_Nodes)
1102 // If there are not any global variables or any functions then
1103 // there is not any debug info in this module.
1106 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1107 constructCompileUnit(CU_Nodes->getOperand(i));
1110 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1111 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1114 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1115 constructSubprogramDIE(SP_Nodes->getOperand(i));
1119 DebugInfoFinder DbgFinder;
1120 DbgFinder.processModule(*M);
1122 bool HasDebugInfo = false;
1123 // Scan all the compile-units to see if there are any marked as the main unit.
1124 // if not, we do not generate debug info.
1125 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1126 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1127 if (DICompileUnit(*I).isMain()) {
1128 HasDebugInfo = true;
1132 if (!HasDebugInfo) return;
1134 // Create all the compile unit DIEs.
1135 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1136 E = DbgFinder.compile_unit_end(); I != E; ++I)
1137 constructCompileUnit(*I);
1139 // Create DIEs for each global variable.
1140 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1141 E = DbgFinder.global_variable_end(); I != E; ++I)
1142 constructGlobalVariableDIE(*I);
1144 // Create DIEs for each subprogram.
1145 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1146 E = DbgFinder.subprogram_end(); I != E; ++I)
1147 constructSubprogramDIE(*I);
1150 // Tell MMI that we have debug info.
1151 MMI->setDebugInfoAvailability(true);
1153 // Emit initial sections.
1154 EmitSectionLabels();
1156 //getOrCreateTypeDIE
1157 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1158 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1159 DIType Ty(NMD->getOperand(i));
1160 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1163 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1164 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1165 DIType Ty(NMD->getOperand(i));
1166 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1169 // Prime section data.
1170 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1173 /// endModule - Emit all Dwarf sections that should come after the content.
1175 void DwarfDebug::endModule() {
1176 if (!FirstCU) return;
1177 const Module *M = MMI->getModule();
1178 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1179 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1180 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1181 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1182 DISubprogram SP(AllSPs->getOperand(SI));
1183 if (!SP.Verify()) continue;
1185 // Collect info for variables that were optimized out.
1186 if (!SP.isDefinition()) continue;
1187 StringRef FName = SP.getLinkageName();
1189 FName = SP.getName();
1190 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1192 unsigned E = NMD->getNumOperands();
1194 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1195 DeadFnScopeMap[SP] = Scope;
1196 for (unsigned I = 0; I != E; ++I) {
1197 DIVariable DV(NMD->getOperand(I));
1198 if (!DV.Verify()) continue;
1199 Scope->addVariable(new DbgVariable(DV));
1202 // Construct subprogram DIE and add variables DIEs.
1203 constructSubprogramDIE(SP);
1204 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1205 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1206 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1207 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1209 ScopeDIE->addChild(VariableDIE);
1214 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1215 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1216 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1218 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1221 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1222 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1223 DIE *SPDie = CI->first;
1224 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1226 DIE *NDie = getCompileUnit(N)->getDIE(N);
1227 if (!NDie) continue;
1228 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1229 dwarf::DW_FORM_ref4, NDie);
1232 // Standard sections final addresses.
1233 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1234 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1235 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1236 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1238 // End text sections.
1239 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1240 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1241 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1244 // Compute DIE offsets and sizes.
1245 computeSizeAndOffsets();
1247 // Emit all the DIEs into a debug info section
1250 // Corresponding abbreviations into a abbrev section.
1251 emitAbbreviations();
1253 // Emit info into a debug pubnames section.
1254 emitDebugPubNames();
1256 // Emit info into a debug pubtypes section.
1257 emitDebugPubTypes();
1259 // Emit info into a debug loc section.
1262 // Emit info into a debug aranges section.
1265 // Emit info into a debug ranges section.
1268 // Emit info into a debug macinfo section.
1271 // Emit inline info.
1272 emitDebugInlineInfo();
1274 // Emit info into a debug str section.
1278 DeleteContainerSeconds(DeadFnScopeMap);
1279 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1280 E = CUMap.end(); I != E; ++I)
1282 FirstCU = NULL; // Reset for the next Module, if any.
1285 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1286 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1287 DebugLoc ScopeLoc) {
1288 LLVMContext &Ctx = DV->getContext();
1290 // More then one inlined variable corresponds to one abstract variable.
1291 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1293 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1295 return AbsDbgVariable;
1298 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1302 AbsDbgVariable = new DbgVariable(Var);
1303 Scope->addVariable(AbsDbgVariable);
1304 AbstractVariables[Var] = AbsDbgVariable;
1305 return AbsDbgVariable;
1308 /// addCurrentFnArgument - If Var is an current function argument that add
1309 /// it in CurrentFnArguments list.
1310 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1311 DbgVariable *Var, DbgScope *Scope) {
1312 if (Scope != CurrentFnDbgScope)
1314 DIVariable DV = Var->getVariable();
1315 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1317 unsigned ArgNo = DV.getArgNumber();
1321 size_t Size = CurrentFnArguments.size();
1323 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1324 // llvm::Function argument size is not good indicator of how many
1325 // arguments does the function have at source level.
1327 CurrentFnArguments.resize(ArgNo * 2);
1328 CurrentFnArguments[ArgNo - 1] = Var;
1332 /// collectVariableInfoFromMMITable - Collect variable information from
1333 /// side table maintained by MMI.
1335 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1336 SmallPtrSet<const MDNode *, 16> &Processed) {
1337 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1338 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1339 VE = VMap.end(); VI != VE; ++VI) {
1340 const MDNode *Var = VI->first;
1342 Processed.insert(Var);
1344 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1346 DbgScope *Scope = findDbgScope(VP.second);
1348 // If variable scope is not found then skip this variable.
1352 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1353 DbgVariable *RegVar = new DbgVariable(DV);
1354 recordVariableFrameIndex(RegVar, VP.first);
1355 if (!addCurrentFnArgument(MF, RegVar, Scope))
1356 Scope->addVariable(RegVar);
1357 if (AbsDbgVariable) {
1358 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1359 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1364 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1365 /// DBG_VALUE instruction, is in a defined reg.
1366 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1367 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1368 return MI->getNumOperands() == 3 &&
1369 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1370 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1373 /// getDebugLocEntry - Get .debug_loc entry for the instraction range starting
1375 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1376 const MCSymbol *FLabel,
1377 const MCSymbol *SLabel,
1378 const MachineInstr *MI) {
1379 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1381 if (MI->getNumOperands() != 3) {
1382 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1383 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1385 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1386 MachineLocation MLoc;
1387 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1388 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1390 if (MI->getOperand(0).isImm())
1391 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1392 if (MI->getOperand(0).isFPImm())
1393 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1394 if (MI->getOperand(0).isCImm())
1395 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1397 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
1398 return DotDebugLocEntry();
1401 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1403 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1404 SmallPtrSet<const MDNode *, 16> &Processed) {
1406 /// collection info from MMI table.
1407 collectVariableInfoFromMMITable(MF, Processed);
1409 for (SmallVectorImpl<const MDNode*>::const_iterator
1410 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1412 const MDNode *Var = *UVI;
1413 if (Processed.count(Var))
1416 // History contains relevant DBG_VALUE instructions for Var and instructions
1418 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1419 if (History.empty())
1421 const MachineInstr *MInsn = History.front();
1424 DbgScope *Scope = NULL;
1425 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1426 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1427 Scope = CurrentFnDbgScope;
1429 if (DV.getVersion() <= LLVMDebugVersion9)
1430 Scope = findDbgScope(MInsn->getDebugLoc());
1432 if (MDNode *IA = DV.getInlinedAt())
1433 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
1435 Scope = DbgScopeMap.lookup(cast<MDNode>(DV->getOperand(1)));
1438 // If variable scope is not found then skip this variable.
1442 Processed.insert(DV);
1443 assert(MInsn->isDebugValue() && "History must begin with debug value");
1444 DbgVariable *RegVar = new DbgVariable(DV);
1445 if (!addCurrentFnArgument(MF, RegVar, Scope))
1446 Scope->addVariable(RegVar);
1447 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1448 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1449 VarToAbstractVarMap[RegVar] = AbsVar;
1452 // Simple ranges that are fully coalesced.
1453 if (History.size() <= 1 || (History.size() == 2 &&
1454 MInsn->isIdenticalTo(History.back()))) {
1455 DbgVariableToDbgInstMap[RegVar] = MInsn;
1459 // handle multiple DBG_VALUE instructions describing one variable.
1460 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1462 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1463 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1464 const MachineInstr *Begin = *HI;
1465 assert(Begin->isDebugValue() && "Invalid History entry");
1467 // Check if DBG_VALUE is truncating a range.
1468 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1469 && !Begin->getOperand(0).getReg())
1472 // Compute the range for a register location.
1473 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1474 const MCSymbol *SLabel = 0;
1477 // If Begin is the last instruction in History then its value is valid
1478 // until the end of the function.
1479 SLabel = FunctionEndSym;
1481 const MachineInstr *End = HI[1];
1482 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1483 << "\t" << *Begin << "\t" << *End << "\n");
1484 if (End->isDebugValue())
1485 SLabel = getLabelBeforeInsn(End);
1487 // End is a normal instruction clobbering the range.
1488 SLabel = getLabelAfterInsn(End);
1489 assert(SLabel && "Forgot label after clobber instruction");
1494 // The value is valid until the next DBG_VALUE or clobber.
1495 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1497 DotDebugLocEntries.push_back(DotDebugLocEntry());
1500 // Collect info for variables that were optimized out.
1501 const Function *F = MF->getFunction();
1502 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1503 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1504 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1505 if (!DV || !Processed.insert(DV))
1507 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1509 Scope->addVariable(new DbgVariable(DV));
1514 /// getLabelBeforeInsn - Return Label preceding the instruction.
1515 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1516 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1517 assert(Label && "Didn't insert label before instruction");
1521 /// getLabelAfterInsn - Return Label immediately following the instruction.
1522 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1523 return LabelsAfterInsn.lookup(MI);
1526 /// beginInstruction - Process beginning of an instruction.
1527 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1528 // Check if source location changes, but ignore DBG_VALUE locations.
1529 if (!MI->isDebugValue()) {
1530 DebugLoc DL = MI->getDebugLoc();
1531 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1532 unsigned Flags = DWARF2_FLAG_IS_STMT;
1534 if (DL == PrologEndLoc) {
1535 Flags |= DWARF2_FLAG_PROLOGUE_END;
1536 PrologEndLoc = DebugLoc();
1538 if (!DL.isUnknown()) {
1539 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1540 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1542 recordSourceLine(0, 0, 0, 0);
1546 // Insert labels where requested.
1547 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1548 LabelsBeforeInsn.find(MI);
1551 if (I == LabelsBeforeInsn.end())
1554 // Label already assigned.
1559 PrevLabel = MMI->getContext().CreateTempSymbol();
1560 Asm->OutStreamer.EmitLabel(PrevLabel);
1562 I->second = PrevLabel;
1565 /// endInstruction - Process end of an instruction.
1566 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1567 // Don't create a new label after DBG_VALUE instructions.
1568 // They don't generate code.
1569 if (!MI->isDebugValue())
1572 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1573 LabelsAfterInsn.find(MI);
1576 if (I == LabelsAfterInsn.end())
1579 // Label already assigned.
1583 // We need a label after this instruction.
1585 PrevLabel = MMI->getContext().CreateTempSymbol();
1586 Asm->OutStreamer.EmitLabel(PrevLabel);
1588 I->second = PrevLabel;
1591 /// getOrCreateRegularScope - Create regular DbgScope.
1592 DbgScope *DwarfDebug::getOrCreateRegularScope(MDNode *Scope) {
1593 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1596 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1597 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1598 if (DIDescriptor(Scope).isLexicalBlock()) {
1600 getOrCreateDbgScope(DebugLoc::getFromDILexicalBlock(Scope));
1601 WScope->setParent(Parent);
1602 Parent->addScope(WScope);
1603 } else if (DIDescriptor(Scope).isSubprogram()
1604 && DISubprogram(Scope).describes(Asm->MF->getFunction()))
1605 CurrentFnDbgScope = WScope;
1610 /// getOrCreateInlinedScope - Create inlined scope.
1611 DbgScope *DwarfDebug::getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt){
1612 DbgScope *InlinedScope = DbgScopeMap.lookup(InlinedAt);
1614 return InlinedScope;
1616 InlinedScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1617 DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt);
1618 InlinedDbgScopeMap[InlinedLoc] = InlinedScope;
1619 DbgScopeMap[InlinedAt] = InlinedScope;
1620 DbgScope *Parent = getOrCreateDbgScope(InlinedLoc);
1621 InlinedScope->setParent(Parent);
1622 Parent->addScope(InlinedScope);
1623 return InlinedScope;
1626 /// getOrCreateDbgScope - Create DbgScope for the scope.
1627 DbgScope *DwarfDebug::getOrCreateDbgScope(DebugLoc DL) {
1628 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1629 MDNode *Scope = NULL;
1630 MDNode *InlinedAt = NULL;
1631 DL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1633 return getOrCreateRegularScope(Scope);
1635 // Create an abstract scope for inlined function.
1636 getOrCreateAbstractScope(Scope);
1637 // Create an inlined scope for inlined function.
1638 return getOrCreateInlinedScope(Scope, InlinedAt);
1641 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1643 static void calculateDominanceGraph(DbgScope *Scope) {
1644 assert (Scope && "Unable to calculate scop edominance graph!");
1645 SmallVector<DbgScope *, 4> WorkStack;
1646 WorkStack.push_back(Scope);
1647 unsigned Counter = 0;
1648 while (!WorkStack.empty()) {
1649 DbgScope *WS = WorkStack.back();
1650 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1651 bool visitedChildren = false;
1652 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1653 SE = Children.end(); SI != SE; ++SI) {
1654 DbgScope *ChildScope = *SI;
1655 if (!ChildScope->getDFSOut()) {
1656 WorkStack.push_back(ChildScope);
1657 visitedChildren = true;
1658 ChildScope->setDFSIn(++Counter);
1661 dbgs() << "calculate dbgscope dom: In " << Counter << "\n";
1666 if (!visitedChildren) {
1667 WorkStack.pop_back();
1668 WS->setDFSOut(++Counter);
1671 dbgs() << "calculate dbgscope dom: In " << WS->getDFSIn()
1672 << " Out " << Counter << "\n";
1678 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1680 void printDbgScopeInfo(const MachineFunction *MF,
1681 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1684 LLVMContext &Ctx = MF->getFunction()->getContext();
1685 unsigned PrevDFSIn = 0;
1686 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1688 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1690 const MachineInstr *MInsn = II;
1691 MDNode *Scope = NULL;
1692 MDNode *InlinedAt = NULL;
1694 // Check if instruction has valid location information.
1695 DebugLoc MIDL = MInsn->getDebugLoc();
1696 if (!MIDL.isUnknown()) {
1697 MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1701 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1702 MI2ScopeMap.find(MInsn);
1703 if (DI != MI2ScopeMap.end()) {
1704 DbgScope *S = DI->second;
1705 dbgs() << S->getDFSIn();
1706 PrevDFSIn = S->getDFSIn();
1708 dbgs() << PrevDFSIn;
1710 dbgs() << " [ x" << PrevDFSIn;
1718 /// extractScopeInformation - Scan machine instructions in this function
1719 /// and collect DbgScopes. Return true, if at least one scope was found.
1720 bool DwarfDebug::extractScopeInformation() {
1721 // If scope information was extracted using .dbg intrinsics then there is not
1722 // any need to extract these information by scanning each instruction.
1723 if (!DbgScopeMap.empty())
1726 // Scan each instruction and create scopes. First build working set of scopes.
1727 SmallVector<DbgRange, 4> MIRanges;
1728 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1729 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1731 const MachineInstr *RangeBeginMI = NULL;
1732 const MachineInstr *PrevMI = NULL;
1734 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1736 const MachineInstr *MInsn = II;
1738 // Check if instruction has valid location information.
1739 const DebugLoc MIDL = MInsn->getDebugLoc();
1740 if (MIDL.isUnknown()) {
1745 // If scope has not changed then skip this instruction.
1746 if (MIDL == PrevDL) {
1751 // Ignore DBG_VALUE. It does not contribute any instruction in output.
1752 if (MInsn->isDebugValue())
1756 // If we have alread seen a beginning of a instruction range and
1757 // current instruction scope does not match scope of first instruction
1758 // in this range then create a new instruction range.
1759 DEBUG(dbgs() << "Creating new instruction range :\n");
1760 DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI);
1761 DEBUG(dbgs() << "End Range at " << *PrevMI);
1762 DEBUG(dbgs() << "Next Range starting at " << *MInsn);
1763 DEBUG(dbgs() << "------------------------\n");
1764 DbgRange R(RangeBeginMI, PrevMI);
1765 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1766 MIRanges.push_back(R);
1769 // This is a beginning of a new instruction range.
1770 RangeBeginMI = MInsn;
1772 // Reset previous markers.
1777 // Create last instruction range.
1778 if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) {
1779 DbgRange R(RangeBeginMI, PrevMI);
1780 MIRanges.push_back(R);
1781 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1785 if (!CurrentFnDbgScope)
1788 calculateDominanceGraph(CurrentFnDbgScope);
1790 printDbgScopeInfo(Asm->MF, MI2ScopeMap);
1792 // Find ranges of instructions covered by each DbgScope;
1793 DbgScope *PrevDbgScope = NULL;
1794 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1795 RE = MIRanges.end(); RI != RE; ++RI) {
1796 const DbgRange &R = *RI;
1797 DbgScope *S = MI2ScopeMap.lookup(R.first);
1798 assert (S && "Lost DbgScope for a machine instruction!");
1799 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1800 PrevDbgScope->closeInsnRange(S);
1801 S->openInsnRange(R.first);
1802 S->extendInsnRange(R.second);
1807 PrevDbgScope->closeInsnRange();
1809 identifyScopeMarkers();
1811 return !DbgScopeMap.empty();
1814 /// identifyScopeMarkers() -
1815 /// Each DbgScope has first instruction and last instruction to mark beginning
1816 /// and end of a scope respectively. Create an inverse map that list scopes
1817 /// starts (and ends) with an instruction. One instruction may start (or end)
1818 /// multiple scopes. Ignore scopes that are not reachable.
1819 void DwarfDebug::identifyScopeMarkers() {
1820 SmallVector<DbgScope *, 4> WorkList;
1821 WorkList.push_back(CurrentFnDbgScope);
1822 while (!WorkList.empty()) {
1823 DbgScope *S = WorkList.pop_back_val();
1825 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1826 if (!Children.empty())
1827 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1828 SE = Children.end(); SI != SE; ++SI)
1829 WorkList.push_back(*SI);
1831 if (S->isAbstractScope())
1834 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1837 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1838 RE = Ranges.end(); RI != RE; ++RI) {
1839 assert(RI->first && "DbgRange does not have first instruction!");
1840 assert(RI->second && "DbgRange does not have second instruction!");
1841 requestLabelBeforeInsn(RI->first);
1842 requestLabelAfterInsn(RI->second);
1847 /// getScopeNode - Get MDNode for DebugLoc's scope.
1848 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1849 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1850 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1851 return DL.getScope(Ctx);
1854 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1855 /// line number info for the function.
1856 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1857 const MDNode *Scope = getScopeNode(DL, Ctx);
1858 DISubprogram SP = getDISubprogram(Scope);
1860 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1864 /// beginFunction - Gather pre-function debug information. Assumes being
1865 /// emitted immediately after the function entry point.
1866 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1867 if (!MMI->hasDebugInfo()) return;
1868 if (!extractScopeInformation()) return;
1870 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1871 Asm->getFunctionNumber());
1872 // Assumes in correct section after the entry point.
1873 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1875 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1877 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1878 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1879 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1881 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1883 bool AtBlockEntry = true;
1884 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1886 const MachineInstr *MI = II;
1888 if (MI->isDebugValue()) {
1889 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1891 // Keep track of user variables.
1893 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1895 // Variable is in a register, we need to check for clobbers.
1896 if (isDbgValueInDefinedReg(MI))
1897 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1899 // Check the history of this variable.
1900 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1901 if (History.empty()) {
1902 UserVariables.push_back(Var);
1903 // The first mention of a function argument gets the FunctionBeginSym
1904 // label, so arguments are visible when breaking at function entry.
1906 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1907 DISubprogram(getDISubprogram(DV.getContext()))
1908 .describes(MF->getFunction()))
1909 LabelsBeforeInsn[MI] = FunctionBeginSym;
1911 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1912 const MachineInstr *Prev = History.back();
1913 if (Prev->isDebugValue()) {
1914 // Coalesce identical entries at the end of History.
1915 if (History.size() >= 2 &&
1916 Prev->isIdenticalTo(History[History.size() - 2])) {
1917 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1919 << "\t" << *History[History.size() - 2] << "\n");
1923 // Terminate old register assignments that don't reach MI;
1924 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1925 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1926 isDbgValueInDefinedReg(Prev)) {
1927 // Previous register assignment needs to terminate at the end of
1929 MachineBasicBlock::const_iterator LastMI =
1930 PrevMBB->getLastNonDebugInstr();
1931 if (LastMI == PrevMBB->end()) {
1932 // Drop DBG_VALUE for empty range.
1933 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1934 << "\t" << *Prev << "\n");
1938 // Terminate after LastMI.
1939 History.push_back(LastMI);
1944 History.push_back(MI);
1946 // Not a DBG_VALUE instruction.
1948 AtBlockEntry = false;
1950 // First known non DBG_VALUE location marks beginning of function
1952 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1953 PrologEndLoc = MI->getDebugLoc();
1955 // Check if the instruction clobbers any registers with debug vars.
1956 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1957 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1958 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1960 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1961 unsigned Reg = *AI; ++AI) {
1962 const MDNode *Var = LiveUserVar[Reg];
1965 // Reg is now clobbered.
1966 LiveUserVar[Reg] = 0;
1968 // Was MD last defined by a DBG_VALUE referring to Reg?
1969 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1970 if (HistI == DbgValues.end())
1972 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1973 if (History.empty())
1975 const MachineInstr *Prev = History.back();
1976 // Sanity-check: Register assignments are terminated at the end of
1978 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1980 // Is the variable still in Reg?
1981 if (!isDbgValueInDefinedReg(Prev) ||
1982 Prev->getOperand(0).getReg() != Reg)
1984 // Var is clobbered. Make sure the next instruction gets a label.
1985 History.push_back(MI);
1992 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1994 SmallVectorImpl<const MachineInstr*> &History = I->second;
1995 if (History.empty())
1998 // Make sure the final register assignments are terminated.
1999 const MachineInstr *Prev = History.back();
2000 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
2001 const MachineBasicBlock *PrevMBB = Prev->getParent();
2002 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
2003 if (LastMI == PrevMBB->end())
2004 // Drop DBG_VALUE for empty range.
2007 // Terminate after LastMI.
2008 History.push_back(LastMI);
2011 // Request labels for the full history.
2012 for (unsigned i = 0, e = History.size(); i != e; ++i) {
2013 const MachineInstr *MI = History[i];
2014 if (MI->isDebugValue())
2015 requestLabelBeforeInsn(MI);
2017 requestLabelAfterInsn(MI);
2021 PrevInstLoc = DebugLoc();
2022 PrevLabel = FunctionBeginSym;
2024 // Record beginning of function.
2025 if (!PrologEndLoc.isUnknown()) {
2026 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
2027 MF->getFunction()->getContext());
2028 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
2029 FnStartDL.getScope(MF->getFunction()->getContext()),
2030 DWARF2_FLAG_IS_STMT);
2034 /// endFunction - Gather and emit post-function debug information.
2036 void DwarfDebug::endFunction(const MachineFunction *MF) {
2037 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2039 if (CurrentFnDbgScope) {
2041 // Define end label for subprogram.
2042 FunctionEndSym = Asm->GetTempSymbol("func_end",
2043 Asm->getFunctionNumber());
2044 // Assumes in correct section after the entry point.
2045 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2047 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2048 collectVariableInfo(MF, ProcessedVars);
2050 // Construct abstract scopes.
2051 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2052 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2053 DISubprogram SP((*AI)->getScopeNode());
2055 // Collect info for variables that were optimized out.
2056 StringRef FName = SP.getLinkageName();
2058 FName = SP.getName();
2059 if (NamedMDNode *NMD =
2060 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2061 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2062 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2063 if (!DV || !ProcessedVars.insert(DV))
2065 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2067 Scope->addVariable(new DbgVariable(DV));
2071 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2072 constructScopeDIE(*AI);
2075 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2077 if (!DisableFramePointerElim(*MF))
2078 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2079 dwarf::DW_AT_APPLE_omit_frame_ptr,
2080 dwarf::DW_FORM_flag, 1);
2083 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2084 MMI->getFrameMoves()));
2088 CurrentFnDbgScope = NULL;
2089 DeleteContainerPointers(CurrentFnArguments);
2090 DbgVariableToFrameIndexMap.clear();
2091 VarToAbstractVarMap.clear();
2092 DbgVariableToDbgInstMap.clear();
2093 InlinedDbgScopeMap.clear();
2094 DeleteContainerSeconds(DbgScopeMap);
2095 UserVariables.clear();
2097 DeleteContainerSeconds(AbstractScopes);
2098 AbstractScopesList.clear();
2099 AbstractVariables.clear();
2100 LabelsBeforeInsn.clear();
2101 LabelsAfterInsn.clear();
2105 /// recordVariableFrameIndex - Record a variable's index.
2106 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2107 assert (V && "Invalid DbgVariable!");
2108 DbgVariableToFrameIndexMap[V] = Index;
2111 /// findVariableFrameIndex - Return true if frame index for the variable
2112 /// is found. Update FI to hold value of the index.
2113 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2114 assert (V && "Invalid DbgVariable!");
2115 DenseMap<const DbgVariable *, int>::iterator I =
2116 DbgVariableToFrameIndexMap.find(V);
2117 if (I == DbgVariableToFrameIndexMap.end())
2123 /// findDbgScope - Find DbgScope for the debug loc.
2124 DbgScope *DwarfDebug::findDbgScope(DebugLoc DL) {
2128 DbgScope *Scope = NULL;
2129 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2130 if (MDNode *IA = DL.getInlinedAt(Ctx))
2131 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
2133 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2138 /// recordSourceLine - Register a source line with debug info. Returns the
2139 /// unique label that was emitted and which provides correspondence to
2140 /// the source line list.
2141 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2147 DIDescriptor Scope(S);
2149 if (Scope.isCompileUnit()) {
2150 DICompileUnit CU(S);
2151 Fn = CU.getFilename();
2152 Dir = CU.getDirectory();
2153 } else if (Scope.isFile()) {
2155 Fn = F.getFilename();
2156 Dir = F.getDirectory();
2157 } else if (Scope.isSubprogram()) {
2159 Fn = SP.getFilename();
2160 Dir = SP.getDirectory();
2161 } else if (Scope.isLexicalBlock()) {
2162 DILexicalBlock DB(S);
2163 Fn = DB.getFilename();
2164 Dir = DB.getDirectory();
2166 assert(0 && "Unexpected scope info");
2168 Src = GetOrCreateSourceID(Fn, Dir);
2170 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2174 //===----------------------------------------------------------------------===//
2176 //===----------------------------------------------------------------------===//
2178 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2181 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2182 // Get the children.
2183 const std::vector<DIE *> &Children = Die->getChildren();
2185 // If not last sibling and has children then add sibling offset attribute.
2186 if (!Last && !Children.empty())
2187 Die->addSiblingOffset(DIEValueAllocator);
2189 // Record the abbreviation.
2190 assignAbbrevNumber(Die->getAbbrev());
2192 // Get the abbreviation for this DIE.
2193 unsigned AbbrevNumber = Die->getAbbrevNumber();
2194 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2197 Die->setOffset(Offset);
2199 // Start the size with the size of abbreviation code.
2200 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2202 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2203 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2205 // Size the DIE attribute values.
2206 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2207 // Size attribute value.
2208 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2210 // Size the DIE children if any.
2211 if (!Children.empty()) {
2212 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2213 "Children flag not set");
2215 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2216 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2218 // End of children marker.
2219 Offset += sizeof(int8_t);
2222 Die->setSize(Offset - Die->getOffset());
2226 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2228 void DwarfDebug::computeSizeAndOffsets() {
2229 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2230 E = CUMap.end(); I != E; ++I) {
2231 // Compute size of compile unit header.
2233 sizeof(int32_t) + // Length of Compilation Unit Info
2234 sizeof(int16_t) + // DWARF version number
2235 sizeof(int32_t) + // Offset Into Abbrev. Section
2236 sizeof(int8_t); // Pointer Size (in bytes)
2237 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2241 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2242 /// temporary label to it if SymbolStem is specified.
2243 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2244 const char *SymbolStem = 0) {
2245 Asm->OutStreamer.SwitchSection(Section);
2246 if (!SymbolStem) return 0;
2248 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2249 Asm->OutStreamer.EmitLabel(TmpSym);
2253 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2254 /// the start of each one.
2255 void DwarfDebug::EmitSectionLabels() {
2256 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2258 // Dwarf sections base addresses.
2259 DwarfInfoSectionSym =
2260 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2261 DwarfAbbrevSectionSym =
2262 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2263 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2265 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2266 EmitSectionSym(Asm, MacroInfo);
2268 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2269 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2270 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2271 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2272 DwarfStrSectionSym =
2273 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2274 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2277 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2278 "section_debug_loc");
2280 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2281 EmitSectionSym(Asm, TLOF.getDataSection());
2284 /// emitDIE - Recusively Emits a debug information entry.
2286 void DwarfDebug::emitDIE(DIE *Die) {
2287 // Get the abbreviation for this DIE.
2288 unsigned AbbrevNumber = Die->getAbbrevNumber();
2289 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2291 // Emit the code (index) for the abbreviation.
2292 if (Asm->isVerbose())
2293 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2294 Twine::utohexstr(Die->getOffset()) + ":0x" +
2295 Twine::utohexstr(Die->getSize()) + " " +
2296 dwarf::TagString(Abbrev->getTag()));
2297 Asm->EmitULEB128(AbbrevNumber);
2299 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2300 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2302 // Emit the DIE attribute values.
2303 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2304 unsigned Attr = AbbrevData[i].getAttribute();
2305 unsigned Form = AbbrevData[i].getForm();
2306 assert(Form && "Too many attributes for DIE (check abbreviation)");
2308 if (Asm->isVerbose())
2309 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2312 case dwarf::DW_AT_sibling:
2313 Asm->EmitInt32(Die->getSiblingOffset());
2315 case dwarf::DW_AT_abstract_origin: {
2316 DIEEntry *E = cast<DIEEntry>(Values[i]);
2317 DIE *Origin = E->getEntry();
2318 unsigned Addr = Origin->getOffset();
2319 Asm->EmitInt32(Addr);
2322 case dwarf::DW_AT_ranges: {
2323 // DW_AT_range Value encodes offset in debug_range section.
2324 DIEInteger *V = cast<DIEInteger>(Values[i]);
2326 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2327 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2331 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2333 DwarfDebugRangeSectionSym,
2338 case dwarf::DW_AT_location: {
2339 if (UseDotDebugLocEntry.count(Die) != 0) {
2340 DIELabel *L = cast<DIELabel>(Values[i]);
2341 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2343 Values[i]->EmitValue(Asm, Form);
2346 case dwarf::DW_AT_accessibility: {
2347 if (Asm->isVerbose()) {
2348 DIEInteger *V = cast<DIEInteger>(Values[i]);
2349 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2351 Values[i]->EmitValue(Asm, Form);
2355 // Emit an attribute using the defined form.
2356 Values[i]->EmitValue(Asm, Form);
2361 // Emit the DIE children if any.
2362 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2363 const std::vector<DIE *> &Children = Die->getChildren();
2365 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2366 emitDIE(Children[j]);
2368 if (Asm->isVerbose())
2369 Asm->OutStreamer.AddComment("End Of Children Mark");
2374 /// emitDebugInfo - Emit the debug info section.
2376 void DwarfDebug::emitDebugInfo() {
2377 // Start debug info section.
2378 Asm->OutStreamer.SwitchSection(
2379 Asm->getObjFileLowering().getDwarfInfoSection());
2380 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2381 E = CUMap.end(); I != E; ++I) {
2382 CompileUnit *TheCU = I->second;
2383 DIE *Die = TheCU->getCUDie();
2385 // Emit the compile units header.
2386 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2389 // Emit size of content not including length itself
2390 unsigned ContentSize = Die->getSize() +
2391 sizeof(int16_t) + // DWARF version number
2392 sizeof(int32_t) + // Offset Into Abbrev. Section
2393 sizeof(int8_t); // Pointer Size (in bytes)
2395 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2396 Asm->EmitInt32(ContentSize);
2397 Asm->OutStreamer.AddComment("DWARF version number");
2398 Asm->EmitInt16(dwarf::DWARF_VERSION);
2399 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2400 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2401 DwarfAbbrevSectionSym);
2402 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2403 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2406 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2410 /// emitAbbreviations - Emit the abbreviation section.
2412 void DwarfDebug::emitAbbreviations() const {
2413 // Check to see if it is worth the effort.
2414 if (!Abbreviations.empty()) {
2415 // Start the debug abbrev section.
2416 Asm->OutStreamer.SwitchSection(
2417 Asm->getObjFileLowering().getDwarfAbbrevSection());
2419 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2421 // For each abbrevation.
2422 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2423 // Get abbreviation data
2424 const DIEAbbrev *Abbrev = Abbreviations[i];
2426 // Emit the abbrevations code (base 1 index.)
2427 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2429 // Emit the abbreviations data.
2433 // Mark end of abbreviations.
2434 Asm->EmitULEB128(0, "EOM(3)");
2436 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2440 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2441 /// the line matrix.
2443 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2444 // Define last address of section.
2445 Asm->OutStreamer.AddComment("Extended Op");
2448 Asm->OutStreamer.AddComment("Op size");
2449 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2450 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2451 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2453 Asm->OutStreamer.AddComment("Section end label");
2455 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2456 Asm->getTargetData().getPointerSize(),
2459 // Mark end of matrix.
2460 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2466 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2468 void DwarfDebug::emitDebugPubNames() {
2469 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2470 E = CUMap.end(); I != E; ++I) {
2471 CompileUnit *TheCU = I->second;
2472 // Start the dwarf pubnames section.
2473 Asm->OutStreamer.SwitchSection(
2474 Asm->getObjFileLowering().getDwarfPubNamesSection());
2476 Asm->OutStreamer.AddComment("Length of Public Names Info");
2477 Asm->EmitLabelDifference(
2478 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2479 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2481 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2484 Asm->OutStreamer.AddComment("DWARF Version");
2485 Asm->EmitInt16(dwarf::DWARF_VERSION);
2487 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2488 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2489 DwarfInfoSectionSym);
2491 Asm->OutStreamer.AddComment("Compilation Unit Length");
2492 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2493 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2496 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2497 for (StringMap<DIE*>::const_iterator
2498 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2499 const char *Name = GI->getKeyData();
2500 DIE *Entity = GI->second;
2502 Asm->OutStreamer.AddComment("DIE offset");
2503 Asm->EmitInt32(Entity->getOffset());
2505 if (Asm->isVerbose())
2506 Asm->OutStreamer.AddComment("External Name");
2507 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2510 Asm->OutStreamer.AddComment("End Mark");
2512 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2517 void DwarfDebug::emitDebugPubTypes() {
2518 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2519 E = CUMap.end(); I != E; ++I) {
2520 CompileUnit *TheCU = I->second;
2521 // Start the dwarf pubnames section.
2522 Asm->OutStreamer.SwitchSection(
2523 Asm->getObjFileLowering().getDwarfPubTypesSection());
2524 Asm->OutStreamer.AddComment("Length of Public Types Info");
2525 Asm->EmitLabelDifference(
2526 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2527 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2529 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2532 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2533 Asm->EmitInt16(dwarf::DWARF_VERSION);
2535 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2536 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2537 DwarfInfoSectionSym);
2539 Asm->OutStreamer.AddComment("Compilation Unit Length");
2540 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2541 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2544 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2545 for (StringMap<DIE*>::const_iterator
2546 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2547 const char *Name = GI->getKeyData();
2548 DIE * Entity = GI->second;
2550 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2551 Asm->EmitInt32(Entity->getOffset());
2553 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2554 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2557 Asm->OutStreamer.AddComment("End Mark");
2559 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2564 /// emitDebugStr - Emit visible names into a debug str section.
2566 void DwarfDebug::emitDebugStr() {
2567 // Check to see if it is worth the effort.
2568 if (StringPool.empty()) return;
2570 // Start the dwarf str section.
2571 Asm->OutStreamer.SwitchSection(
2572 Asm->getObjFileLowering().getDwarfStrSection());
2574 // Get all of the string pool entries and put them in an array by their ID so
2575 // we can sort them.
2576 SmallVector<std::pair<unsigned,
2577 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2579 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2580 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2581 Entries.push_back(std::make_pair(I->second.second, &*I));
2583 array_pod_sort(Entries.begin(), Entries.end());
2585 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2586 // Emit a label for reference from debug information entries.
2587 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2589 // Emit the string itself.
2590 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2594 /// emitDebugLoc - Emit visible names into a debug loc section.
2596 void DwarfDebug::emitDebugLoc() {
2597 if (DotDebugLocEntries.empty())
2600 for (SmallVector<DotDebugLocEntry, 4>::iterator
2601 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2603 DotDebugLocEntry &Entry = *I;
2604 if (I + 1 != DotDebugLocEntries.end())
2608 // Start the dwarf loc section.
2609 Asm->OutStreamer.SwitchSection(
2610 Asm->getObjFileLowering().getDwarfLocSection());
2611 unsigned char Size = Asm->getTargetData().getPointerSize();
2612 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2614 for (SmallVector<DotDebugLocEntry, 4>::iterator
2615 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2616 I != E; ++I, ++index) {
2617 DotDebugLocEntry &Entry = *I;
2618 if (Entry.isMerged()) continue;
2619 if (Entry.isEmpty()) {
2620 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2621 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2622 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2624 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2625 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2626 DIVariable DV(Entry.Variable);
2627 Asm->OutStreamer.AddComment("Loc expr size");
2628 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2629 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2630 Asm->EmitLabelDifference(end, begin, 2);
2631 Asm->OutStreamer.EmitLabel(begin);
2632 if (Entry.isInt()) {
2633 DIBasicType BTy(DV.getType());
2635 (BTy.getEncoding() == dwarf::DW_ATE_signed
2636 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2637 Asm->OutStreamer.AddComment("DW_OP_consts");
2638 Asm->EmitInt8(dwarf::DW_OP_consts);
2639 Asm->EmitSLEB128(Entry.getInt());
2641 Asm->OutStreamer.AddComment("DW_OP_constu");
2642 Asm->EmitInt8(dwarf::DW_OP_constu);
2643 Asm->EmitULEB128(Entry.getInt());
2645 } else if (Entry.isLocation()) {
2646 if (!DV.hasComplexAddress())
2648 Asm->EmitDwarfRegOp(Entry.Loc);
2650 // Complex address entry.
2651 unsigned N = DV.getNumAddrElements();
2653 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2654 if (Entry.Loc.getOffset()) {
2656 Asm->EmitDwarfRegOp(Entry.Loc);
2657 Asm->OutStreamer.AddComment("DW_OP_deref");
2658 Asm->EmitInt8(dwarf::DW_OP_deref);
2659 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2660 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2661 Asm->EmitSLEB128(DV.getAddrElement(1));
2663 // If first address element is OpPlus then emit
2664 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2665 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2666 Asm->EmitDwarfRegOp(Loc);
2670 Asm->EmitDwarfRegOp(Entry.Loc);
2673 // Emit remaining complex address elements.
2674 for (; i < N; ++i) {
2675 uint64_t Element = DV.getAddrElement(i);
2676 if (Element == DIBuilder::OpPlus) {
2677 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2678 Asm->EmitULEB128(DV.getAddrElement(++i));
2679 } else if (Element == DIBuilder::OpDeref)
2680 Asm->EmitInt8(dwarf::DW_OP_deref);
2681 else llvm_unreachable("unknown Opcode found in complex address");
2685 // else ... ignore constant fp. There is not any good way to
2686 // to represent them here in dwarf.
2687 Asm->OutStreamer.EmitLabel(end);
2692 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2694 void DwarfDebug::EmitDebugARanges() {
2695 // Start the dwarf aranges section.
2696 Asm->OutStreamer.SwitchSection(
2697 Asm->getObjFileLowering().getDwarfARangesSection());
2700 /// emitDebugRanges - Emit visible names into a debug ranges section.
2702 void DwarfDebug::emitDebugRanges() {
2703 // Start the dwarf ranges section.
2704 Asm->OutStreamer.SwitchSection(
2705 Asm->getObjFileLowering().getDwarfRangesSection());
2706 unsigned char Size = Asm->getTargetData().getPointerSize();
2707 for (SmallVector<const MCSymbol *, 8>::iterator
2708 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2711 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2713 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2717 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2719 void DwarfDebug::emitDebugMacInfo() {
2720 if (const MCSection *LineInfo =
2721 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2722 // Start the dwarf macinfo section.
2723 Asm->OutStreamer.SwitchSection(LineInfo);
2727 /// emitDebugInlineInfo - Emit inline info using following format.
2729 /// 1. length of section
2730 /// 2. Dwarf version number
2731 /// 3. address size.
2733 /// Entries (one "entry" for each function that was inlined):
2735 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2736 /// otherwise offset into __debug_str for regular function name.
2737 /// 2. offset into __debug_str section for regular function name.
2738 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2739 /// instances for the function.
2741 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2742 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2743 /// __debug_info section, and the low_pc is the starting address for the
2744 /// inlining instance.
2745 void DwarfDebug::emitDebugInlineInfo() {
2746 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2752 Asm->OutStreamer.SwitchSection(
2753 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2755 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2756 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2757 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2759 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2761 Asm->OutStreamer.AddComment("Dwarf Version");
2762 Asm->EmitInt16(dwarf::DWARF_VERSION);
2763 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2764 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2766 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2767 E = InlinedSPNodes.end(); I != E; ++I) {
2769 const MDNode *Node = *I;
2770 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2771 = InlineInfo.find(Node);
2772 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2773 DISubprogram SP(Node);
2774 StringRef LName = SP.getLinkageName();
2775 StringRef Name = SP.getName();
2777 Asm->OutStreamer.AddComment("MIPS linkage name");
2778 if (LName.empty()) {
2779 Asm->OutStreamer.EmitBytes(Name, 0);
2780 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2782 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2783 DwarfStrSectionSym);
2785 Asm->OutStreamer.AddComment("Function name");
2786 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2787 Asm->EmitULEB128(Labels.size(), "Inline count");
2789 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2790 LE = Labels.end(); LI != LE; ++LI) {
2791 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2792 Asm->EmitInt32(LI->second->getOffset());
2794 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2795 Asm->OutStreamer.EmitSymbolValue(LI->first,
2796 Asm->getTargetData().getPointerSize(),0);
2800 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));