1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "DwarfCompileUnit.h"
18 #include "llvm/Constants.h"
19 #include "llvm/Module.h"
20 #include "llvm/Instructions.h"
21 #include "llvm/CodeGen/MachineFunction.h"
22 #include "llvm/CodeGen/MachineModuleInfo.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCSection.h"
25 #include "llvm/MC/MCStreamer.h"
26 #include "llvm/MC/MCSymbol.h"
27 #include "llvm/Target/Mangler.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Target/TargetFrameLowering.h"
30 #include "llvm/Target/TargetLoweringObjectFile.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetRegisterInfo.h"
33 #include "llvm/Target/TargetOptions.h"
34 #include "llvm/Analysis/DebugInfo.h"
35 #include "llvm/Analysis/DIBuilder.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/ADT/STLExtras.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/Debug.h"
41 #include "llvm/Support/ErrorHandling.h"
42 #include "llvm/Support/ValueHandle.h"
43 #include "llvm/Support/FormattedStream.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Support/Path.h"
48 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
49 cl::desc("Print DbgScope information for each machine instruction"));
51 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
53 cl::desc("Disable debug info printing"));
55 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
56 cl::desc("Make an absence of debug location information explicit."),
60 const char *DWARFGroupName = "DWARF Emission";
61 const char *DbgTimerName = "DWARF Debug Writer";
62 } // end anonymous namespace
64 //===----------------------------------------------------------------------===//
66 /// Configuration values for initial hash set sizes (log2).
68 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
72 DIType DbgVariable::getType() const {
73 DIType Ty = Var.getType();
74 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
76 if (Var.isBlockByrefVariable()) {
77 /* Byref variables, in Blocks, are declared by the programmer as
78 "SomeType VarName;", but the compiler creates a
79 __Block_byref_x_VarName struct, and gives the variable VarName
80 either the struct, or a pointer to the struct, as its type. This
81 is necessary for various behind-the-scenes things the compiler
82 needs to do with by-reference variables in blocks.
84 However, as far as the original *programmer* is concerned, the
85 variable should still have type 'SomeType', as originally declared.
87 The following function dives into the __Block_byref_x_VarName
88 struct to find the original type of the variable. This will be
89 passed back to the code generating the type for the Debug
90 Information Entry for the variable 'VarName'. 'VarName' will then
91 have the original type 'SomeType' in its debug information.
93 The original type 'SomeType' will be the type of the field named
94 'VarName' inside the __Block_byref_x_VarName struct.
96 NOTE: In order for this to not completely fail on the debugger
97 side, the Debug Information Entry for the variable VarName needs to
98 have a DW_AT_location that tells the debugger how to unwind through
99 the pointers and __Block_byref_x_VarName struct to find the actual
100 value of the variable. The function addBlockByrefType does this. */
102 unsigned tag = Ty.getTag();
104 if (tag == dwarf::DW_TAG_pointer_type) {
105 DIDerivedType DTy = DIDerivedType(Ty);
106 subType = DTy.getTypeDerivedFrom();
109 DICompositeType blockStruct = DICompositeType(subType);
110 DIArray Elements = blockStruct.getTypeArray();
112 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
113 DIDescriptor Element = Elements.getElement(i);
114 DIDerivedType DT = DIDerivedType(Element);
115 if (getName() == DT.getName())
116 return (DT.getTypeDerivedFrom());
123 //===----------------------------------------------------------------------===//
124 /// DbgRange - This is used to track range of instructions with identical
125 /// debug info scope.
127 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
129 //===----------------------------------------------------------------------===//
130 /// DbgScope - This class is used to track scope information.
133 DbgScope *Parent; // Parent to this scope.
134 DIDescriptor Desc; // Debug info descriptor for scope.
135 // Location at which this scope is inlined.
136 AssertingVH<const MDNode> InlinedAtLocation;
137 bool AbstractScope; // Abstract Scope
138 const MachineInstr *LastInsn; // Last instruction of this scope.
139 const MachineInstr *FirstInsn; // First instruction of this scope.
140 unsigned DFSIn, DFSOut;
141 // Scopes defined in scope. Contents not owned.
142 SmallVector<DbgScope *, 4> Scopes;
143 // Variables declared in scope. Contents owned.
144 SmallVector<DbgVariable *, 8> Variables;
145 SmallVector<DbgRange, 4> Ranges;
146 // Private state for dump()
147 mutable unsigned IndentLevel;
149 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
150 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
151 LastInsn(0), FirstInsn(0),
152 DFSIn(0), DFSOut(0), IndentLevel(0) {}
156 DbgScope *getParent() const { return Parent; }
157 void setParent(DbgScope *P) { Parent = P; }
158 DIDescriptor getDesc() const { return Desc; }
159 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
160 const MDNode *getScopeNode() const { return Desc; }
161 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
162 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
163 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
165 /// openInsnRange - This scope covers instruction range starting from MI.
166 void openInsnRange(const MachineInstr *MI) {
171 Parent->openInsnRange(MI);
174 /// extendInsnRange - Extend the current instruction range covered by
176 void extendInsnRange(const MachineInstr *MI) {
177 assert (FirstInsn && "MI Range is not open!");
180 Parent->extendInsnRange(MI);
183 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
184 /// until now. This is used when a new scope is encountered while walking
185 /// machine instructions.
186 void closeInsnRange(DbgScope *NewScope = NULL) {
187 assert (LastInsn && "Last insn missing!");
188 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
191 // If Parent dominates NewScope then do not close Parent's instruction
193 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
194 Parent->closeInsnRange(NewScope);
197 void setAbstractScope() { AbstractScope = true; }
198 bool isAbstractScope() const { return AbstractScope; }
200 // Depth First Search support to walk and manipulate DbgScope hierarchy.
201 unsigned getDFSOut() const { return DFSOut; }
202 void setDFSOut(unsigned O) { DFSOut = O; }
203 unsigned getDFSIn() const { return DFSIn; }
204 void setDFSIn(unsigned I) { DFSIn = I; }
205 bool dominates(const DbgScope *S) {
208 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
213 /// addScope - Add a scope to the scope.
215 void addScope(DbgScope *S) { Scopes.push_back(S); }
217 /// addVariable - Add a variable to the scope.
219 void addVariable(DbgVariable *V) { Variables.push_back(V); }
226 } // end llvm namespace
229 void DbgScope::dump() const {
230 raw_ostream &err = dbgs();
231 err.indent(IndentLevel);
232 err << "DFSIn: " << DFSIn << " DFSOut: " << DFSOut << "\n";
233 const MDNode *N = Desc;
236 err << "Abstract Scope\n";
240 err << "Children ...\n";
241 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
242 if (Scopes[i] != this)
249 DbgScope::~DbgScope() {
250 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
254 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
255 : Asm(A), MMI(Asm->MMI), FirstCU(0),
256 AbbreviationsSet(InitAbbreviationsSetSize),
257 CurrentFnDbgScope(0), PrevLabel(NULL) {
258 NextStringPoolNumber = 0;
260 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
261 DwarfStrSectionSym = TextSectionSym = 0;
262 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
263 FunctionBeginSym = FunctionEndSym = 0;
265 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
269 DwarfDebug::~DwarfDebug() {
272 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
273 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
274 if (Entry.first) return Entry.first;
276 Entry.second = NextStringPoolNumber++;
277 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
281 /// assignAbbrevNumber - Define a unique number for the abbreviation.
283 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
284 // Profile the node so that we can make it unique.
288 // Check the set for priors.
289 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
291 // If it's newly added.
292 if (InSet == &Abbrev) {
293 // Add to abbreviation list.
294 Abbreviations.push_back(&Abbrev);
296 // Assign the vector position + 1 as its number.
297 Abbrev.setNumber(Abbreviations.size());
299 // Assign existing abbreviation number.
300 Abbrev.setNumber(InSet->getNumber());
304 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
305 /// printer to not emit usual symbol prefix before the symbol name is used then
306 /// return linkage name after skipping this special LLVM prefix.
307 static StringRef getRealLinkageName(StringRef LinkageName) {
309 if (LinkageName.startswith(StringRef(&One, 1)))
310 return LinkageName.substr(1);
314 /// createSubprogramDIE - Create new DIE using SP.
315 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
316 CompileUnit *SPCU = getCompileUnit(SP);
317 DIE *SPDie = SPCU->getDIE(SP);
321 SPDie = new DIE(dwarf::DW_TAG_subprogram);
323 // DW_TAG_inlined_subroutine may refer to this DIE.
324 SPCU->insertDIE(SP, SPDie);
326 // Add to context owner.
327 SPCU->addToContextOwner(SPDie, SP.getContext());
329 // Add function template parameters.
330 SPCU->addTemplateParams(*SPDie, SP.getTemplateParams());
332 StringRef LinkageName = SP.getLinkageName();
333 if (!LinkageName.empty())
334 SPCU->addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
335 getRealLinkageName(LinkageName));
337 // If this DIE is going to refer declaration info using AT_specification
338 // then there is no need to add other attributes.
339 if (SP.getFunctionDeclaration().isSubprogram())
342 // Constructors and operators for anonymous aggregates do not have names.
343 if (!SP.getName().empty())
344 SPCU->addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
347 SPCU->addSourceLine(SPDie, SP);
349 if (SP.isPrototyped())
350 SPCU->addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
353 DICompositeType SPTy = SP.getType();
354 DIArray Args = SPTy.getTypeArray();
355 unsigned SPTag = SPTy.getTag();
357 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
358 SPCU->addType(SPDie, SPTy);
360 SPCU->addType(SPDie, DIType(Args.getElement(0)));
362 unsigned VK = SP.getVirtuality();
364 SPCU->addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
365 DIEBlock *Block = SPCU->getDIEBlock();
366 SPCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
367 SPCU->addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
368 SPCU->addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
369 ContainingTypeMap.insert(std::make_pair(SPDie,
370 SP.getContainingType()));
373 if (!SP.isDefinition()) {
374 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
376 // Add arguments. Do not add arguments for subprogram definition. They will
377 // be handled while processing variables.
378 DICompositeType SPTy = SP.getType();
379 DIArray Args = SPTy.getTypeArray();
380 unsigned SPTag = SPTy.getTag();
382 if (SPTag == dwarf::DW_TAG_subroutine_type)
383 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
384 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
385 DIType ATy = DIType(DIType(Args.getElement(i)));
386 SPCU->addType(Arg, ATy);
387 if (ATy.isArtificial())
388 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
389 SPDie->addChild(Arg);
393 if (SP.isArtificial())
394 SPCU->addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
396 if (!SP.isLocalToUnit())
397 SPCU->addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
399 if (SP.isOptimized())
400 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
402 if (unsigned isa = Asm->getISAEncoding()) {
403 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
409 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
410 assert(N && "Invalid Scope encoding!");
412 DbgScope *AScope = AbstractScopes.lookup(N);
416 DbgScope *Parent = NULL;
418 DIDescriptor Scope(N);
419 if (Scope.isLexicalBlock()) {
420 DILexicalBlock DB(N);
421 DIDescriptor ParentDesc = DB.getContext();
422 Parent = getOrCreateAbstractScope(ParentDesc);
425 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
428 Parent->addScope(AScope);
429 AScope->setAbstractScope();
430 AbstractScopes[N] = AScope;
431 if (DIDescriptor(N).isSubprogram())
432 AbstractScopesList.push_back(AScope);
436 /// isSubprogramContext - Return true if Context is either a subprogram
437 /// or another context nested inside a subprogram.
438 static bool isSubprogramContext(const MDNode *Context) {
441 DIDescriptor D(Context);
442 if (D.isSubprogram())
445 return isSubprogramContext(DIType(Context).getContext());
449 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
450 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
451 /// If there are global variables in this scope then create and insert
452 /// DIEs for these variables.
453 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
454 CompileUnit *SPCU = getCompileUnit(SPNode);
455 DIE *SPDie = SPCU->getDIE(SPNode);
457 assert(SPDie && "Unable to find subprogram DIE!");
458 DISubprogram SP(SPNode);
460 DISubprogram SPDecl = SP.getFunctionDeclaration();
461 if (SPDecl.isSubprogram())
462 // Refer function declaration directly.
463 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
464 createSubprogramDIE(SPDecl));
466 // There is not any need to generate specification DIE for a function
467 // defined at compile unit level. If a function is defined inside another
468 // function then gdb prefers the definition at top level and but does not
469 // expect specification DIE in parent function. So avoid creating
470 // specification DIE for a function defined inside a function.
471 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
472 !SP.getContext().isFile() &&
473 !isSubprogramContext(SP.getContext())) {
474 SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
477 DICompositeType SPTy = SP.getType();
478 DIArray Args = SPTy.getTypeArray();
479 unsigned SPTag = SPTy.getTag();
480 if (SPTag == dwarf::DW_TAG_subroutine_type)
481 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
482 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
483 DIType ATy = DIType(DIType(Args.getElement(i)));
484 SPCU->addType(Arg, ATy);
485 if (ATy.isArtificial())
486 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
487 SPDie->addChild(Arg);
489 DIE *SPDeclDie = SPDie;
490 SPDie = new DIE(dwarf::DW_TAG_subprogram);
491 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
496 // Pick up abstract subprogram DIE.
497 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
498 SPDie = new DIE(dwarf::DW_TAG_subprogram);
499 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
500 dwarf::DW_FORM_ref4, AbsSPDIE);
504 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
505 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
506 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
507 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
508 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
509 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
510 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
515 /// constructLexicalScope - Construct new DW_TAG_lexical_block
516 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
517 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
519 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
520 if (Scope->isAbstractScope())
523 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
527 CompileUnit *TheCU = getCompileUnit(Scope->getScopeNode());
528 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
529 if (Ranges.size() > 1) {
530 // .debug_range section has not been laid out yet. Emit offset in
531 // .debug_range as a uint, size 4, for now. emitDIE will handle
532 // DW_AT_ranges appropriately.
533 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
534 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
535 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
536 RE = Ranges.end(); RI != RE; ++RI) {
537 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
538 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
540 DebugRangeSymbols.push_back(NULL);
541 DebugRangeSymbols.push_back(NULL);
545 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
546 const MCSymbol *End = getLabelAfterInsn(RI->second);
548 if (End == 0) return 0;
550 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
551 assert(End->isDefined() && "Invalid end label for an inlined scope!");
553 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
554 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
559 /// constructInlinedScopeDIE - This scope represents inlined body of
560 /// a function. Construct DIE to represent this concrete inlined copy
562 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
564 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
565 assert (Ranges.empty() == false
566 && "DbgScope does not have instruction markers!");
568 if (!Scope->getScopeNode())
570 DIScope DS(Scope->getScopeNode());
571 DISubprogram InlinedSP = getDISubprogram(DS);
572 CompileUnit *TheCU = getCompileUnit(InlinedSP);
573 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
575 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
579 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
580 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
581 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
583 if (StartLabel == 0 || EndLabel == 0) {
584 assert (0 && "Unexpected Start and End labels for a inlined scope!");
587 assert(StartLabel->isDefined() &&
588 "Invalid starting label for an inlined scope!");
589 assert(EndLabel->isDefined() &&
590 "Invalid end label for an inlined scope!");
592 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
593 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
594 dwarf::DW_FORM_ref4, OriginDIE);
596 if (Ranges.size() > 1) {
597 // .debug_range section has not been laid out yet. Emit offset in
598 // .debug_range as a uint, size 4, for now. emitDIE will handle
599 // DW_AT_ranges appropriately.
600 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
601 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
602 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
603 RE = Ranges.end(); RI != RE; ++RI) {
604 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
605 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
607 DebugRangeSymbols.push_back(NULL);
608 DebugRangeSymbols.push_back(NULL);
610 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
611 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
614 InlinedSubprogramDIEs.insert(OriginDIE);
616 // Track the start label for this inlined function.
617 //.debug_inlined section specification does not clearly state how
618 // to emit inlined scope that is split into multiple instruction ranges.
619 // For now, use first instruction range and emit low_pc/high_pc pair and
620 // corresponding .debug_inlined section entry for this pair.
621 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
622 I = InlineInfo.find(InlinedSP);
624 if (I == InlineInfo.end()) {
625 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
627 InlinedSPNodes.push_back(InlinedSP);
629 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
631 DILocation DL(Scope->getInlinedAt());
632 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
633 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
638 /// isUnsignedDIType - Return true if type encoding is unsigned.
639 static bool isUnsignedDIType(DIType Ty) {
640 DIDerivedType DTy(Ty);
642 return isUnsignedDIType(DTy.getTypeDerivedFrom());
646 unsigned Encoding = BTy.getEncoding();
647 if (Encoding == dwarf::DW_ATE_unsigned ||
648 Encoding == dwarf::DW_ATE_unsigned_char)
654 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
655 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
656 StringRef Name = DV->getName();
660 // Translate tag to proper Dwarf tag. The result variable is dropped for
663 switch (DV->getTag()) {
664 case dwarf::DW_TAG_return_variable:
666 case dwarf::DW_TAG_arg_variable:
667 Tag = dwarf::DW_TAG_formal_parameter;
669 case dwarf::DW_TAG_auto_variable: // fall thru
671 Tag = dwarf::DW_TAG_variable;
675 // Define variable debug information entry.
676 DIE *VariableDie = new DIE(Tag);
677 CompileUnit *VariableCU = getCompileUnit(DV->getVariable());
679 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
680 V2AVI = VarToAbstractVarMap.find(DV);
681 if (V2AVI != VarToAbstractVarMap.end())
682 AbsDIE = V2AVI->second->getDIE();
685 VariableCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
686 dwarf::DW_FORM_ref4, AbsDIE);
688 VariableCU->addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
690 VariableCU->addSourceLine(VariableDie, DV->getVariable());
692 // Add variable type.
693 VariableCU->addType(VariableDie, DV->getType());
696 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
697 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
698 dwarf::DW_FORM_flag, 1);
699 else if (DIVariable(DV->getVariable()).isArtificial())
700 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
701 dwarf::DW_FORM_flag, 1);
703 if (Scope->isAbstractScope()) {
704 DV->setDIE(VariableDie);
708 // Add variable address.
710 unsigned Offset = DV->getDotDebugLocOffset();
712 VariableCU->addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
713 Asm->GetTempSymbol("debug_loc", Offset));
714 DV->setDIE(VariableDie);
715 UseDotDebugLocEntry.insert(VariableDie);
719 // Check if variable is described by a DBG_VALUE instruction.
720 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
721 DbgVariableToDbgInstMap.find(DV);
722 if (DVI != DbgVariableToDbgInstMap.end()) {
723 const MachineInstr *DVInsn = DVI->second;
724 bool updated = false;
725 if (DVInsn->getNumOperands() == 3) {
726 if (DVInsn->getOperand(0).isReg()) {
727 const MachineOperand RegOp = DVInsn->getOperand(0);
728 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
729 if (DVInsn->getOperand(1).isImm() &&
730 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
731 unsigned FrameReg = 0;
732 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
734 TFI->getFrameIndexReference(*Asm->MF,
735 DVInsn->getOperand(1).getImm(),
737 MachineLocation Location(FrameReg, Offset);
738 VariableCU->addVariableAddress(DV, VariableDie, Location);
740 } else if (RegOp.getReg())
741 VariableCU->addVariableAddress(DV, VariableDie,
742 MachineLocation(RegOp.getReg()));
745 else if (DVInsn->getOperand(0).isImm())
747 VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0),
749 else if (DVInsn->getOperand(0).isFPImm())
751 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
752 else if (DVInsn->getOperand(0).isCImm())
754 VariableCU->addConstantValue(VariableDie,
755 DVInsn->getOperand(0).getCImm(),
756 isUnsignedDIType(DV->getType()));
758 VariableCU->addVariableAddress(DV, VariableDie,
759 Asm->getDebugValueLocation(DVInsn));
763 // If variableDie is not updated then DBG_VALUE instruction does not
764 // have valid variable info.
768 DV->setDIE(VariableDie);
772 // .. else use frame index, if available.
774 if (findVariableFrameIndex(DV, &FI)) {
775 unsigned FrameReg = 0;
776 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
778 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
779 MachineLocation Location(FrameReg, Offset);
780 VariableCU->addVariableAddress(DV, VariableDie, Location);
783 DV->setDIE(VariableDie);
788 /// constructScopeDIE - Construct a DIE for this scope.
789 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
790 if (!Scope || !Scope->getScopeNode())
793 SmallVector <DIE *, 8> Children;
795 // Collect arguments for current function.
796 if (Scope == CurrentFnDbgScope)
797 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
798 if (DbgVariable *ArgDV = CurrentFnArguments[i])
799 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
800 Children.push_back(Arg);
802 // Collect lexical scope childrens first.
803 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
804 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
805 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
806 Children.push_back(Variable);
807 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
808 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
809 if (DIE *Nested = constructScopeDIE(Scopes[j]))
810 Children.push_back(Nested);
811 DIScope DS(Scope->getScopeNode());
812 DIE *ScopeDIE = NULL;
813 if (Scope->getInlinedAt())
814 ScopeDIE = constructInlinedScopeDIE(Scope);
815 else if (DS.isSubprogram()) {
816 ProcessedSPNodes.insert(DS);
817 if (Scope->isAbstractScope()) {
818 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
819 // Note down abstract DIE.
821 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
824 ScopeDIE = updateSubprogramScopeDIE(DS);
827 // There is no need to emit empty lexical block DIE.
828 if (Children.empty())
830 ScopeDIE = constructLexicalScopeDIE(Scope);
833 if (!ScopeDIE) return NULL;
836 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
837 E = Children.end(); I != E; ++I)
838 ScopeDIE->addChild(*I);
840 if (DS.isSubprogram())
841 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
846 /// GetOrCreateSourceID - Look up the source id with the given directory and
847 /// source file names. If none currently exists, create a new id and insert it
848 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
851 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
853 // If FE did not provide a file name, then assume stdin.
854 if (FileName.empty())
855 return GetOrCreateSourceID("<stdin>", StringRef());
857 // MCStream expects full path name as filename.
858 if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
859 SmallString<128> FullPathName = DirName;
860 sys::path::append(FullPathName, FileName);
861 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
862 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
865 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
866 if (Entry.getValue())
867 return Entry.getValue();
869 unsigned SrcId = SourceIdMap.size();
870 Entry.setValue(SrcId);
872 // Print out a .file directive to specify files for .loc directives.
873 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
878 /// constructCompileUnit - Create new CompileUnit for the given
879 /// metadata node with tag DW_TAG_compile_unit.
880 void DwarfDebug::constructCompileUnit(const MDNode *N) {
881 DICompileUnit DIUnit(N);
882 StringRef FN = DIUnit.getFilename();
883 StringRef Dir = DIUnit.getDirectory();
884 unsigned ID = GetOrCreateSourceID(FN, Dir);
886 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
887 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
888 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
889 DIUnit.getProducer());
890 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
891 DIUnit.getLanguage());
892 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
893 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
894 // simplifies debug range entries.
895 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
896 // DW_AT_stmt_list is a offset of line number information for this
897 // compile unit in debug_line section.
898 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
899 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
900 Asm->GetTempSymbol("section_line"));
902 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
905 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
906 if (DIUnit.isOptimized())
907 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
909 StringRef Flags = DIUnit.getFlags();
911 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
913 unsigned RVer = DIUnit.getRunTimeVersion();
915 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
916 dwarf::DW_FORM_data1, RVer);
920 CUMap.insert(std::make_pair(N, NewCU));
923 /// getCompileUnit - Get CompileUnit DIE.
924 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
925 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
927 const MDNode *CUNode = NULL;
928 if (D.isCompileUnit())
930 else if (D.isSubprogram())
931 CUNode = DISubprogram(N).getCompileUnit();
933 CUNode = DIType(N).getCompileUnit();
934 else if (D.isGlobalVariable())
935 CUNode = DIGlobalVariable(N).getCompileUnit();
936 else if (D.isVariable())
937 CUNode = DIVariable(N).getCompileUnit();
938 else if (D.isNameSpace())
939 CUNode = DINameSpace(N).getCompileUnit();
941 CUNode = DIFile(N).getCompileUnit();
945 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
946 = CUMap.find(CUNode);
947 if (I == CUMap.end())
952 // Return const expression if value is a GEP to access merged global
954 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
955 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
956 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
957 if (!CE || CE->getNumOperands() != 3 ||
958 CE->getOpcode() != Instruction::GetElementPtr ||
959 !isa<PointerType>(CE->getOperand(0)->getType()))
962 // First operand points to a global value.
963 if (!isa<GlobalValue>(CE->getOperand(0)))
966 // Second operand is zero.
967 const ConstantInt *CI = 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 // getMergedGlobalElementOffset - If CE is accessing a merged global
979 // then find byte offset of the element accessed by CE. This must be
980 // used only CE returned by getMergedGlobalExpr(). See above.
981 static uint64_t getMergedGlobalElementOffset(const TargetData &TD,
982 const ConstantExpr *CE) {
983 assert (getMergedGlobalExpr(CE) && "This is not a merged global!");
984 uint64_t e = cast<ConstantInt>(CE->getOperand(2))->getZExtValue();
985 if (e == 0) return 0;
988 const PointerType *PTy = dyn_cast<PointerType>(CE->getOperand(0)->getType());
989 const StructType *STy = dyn_cast<StructType>(PTy->getElementType());
990 for (uint64_t i = 0; i != e; ++i)
991 Offset += TD.getTypeAllocSize(STy->getElementType(i));
995 /// constructGlobalVariableDIE - Construct global variable DIE.
996 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
997 DIGlobalVariable GV(N);
999 // If debug information is malformed then ignore it.
1000 if (GV.Verify() == false)
1003 // Check for pre-existence.
1004 CompileUnit *TheCU = getCompileUnit(N);
1005 if (TheCU->getDIE(GV))
1008 DIType GTy = GV.getType();
1009 DIE *VariableDIE = new DIE(GV.getTag());
1011 bool isGlobalVariable = GV.getGlobal() != NULL;
1014 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1015 GV.getDisplayName());
1016 StringRef LinkageName = GV.getLinkageName();
1017 if (!LinkageName.empty() && isGlobalVariable)
1018 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1019 dwarf::DW_FORM_string,
1020 getRealLinkageName(LinkageName));
1022 TheCU->addType(VariableDIE, GTy);
1024 // Add scoping info.
1025 if (!GV.isLocalToUnit()) {
1026 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1027 // Expose as global.
1028 TheCU->addGlobal(GV.getName(), VariableDIE);
1030 // Add line number info.
1031 TheCU->addSourceLine(VariableDIE, GV);
1033 TheCU->insertDIE(N, VariableDIE);
1034 // Add to context owner.
1035 DIDescriptor GVContext = GV.getContext();
1036 TheCU->addToContextOwner(VariableDIE, GVContext);
1038 if (isGlobalVariable) {
1039 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1040 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1041 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1042 Asm->Mang->getSymbol(GV.getGlobal()));
1043 // Do not create specification DIE if context is either compile unit
1045 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1046 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1047 // Create specification DIE.
1048 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1049 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1050 dwarf::DW_FORM_ref4, VariableDIE);
1051 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1052 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1053 TheCU->addDie(VariableSpecDIE);
1055 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1057 } else if (const ConstantInt *CI =
1058 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1059 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1060 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1061 // GV is a merged global.
1062 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1063 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1064 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1065 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1066 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1067 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata,
1068 getMergedGlobalElementOffset(Asm->getTargetData(), CE));
1069 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1070 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1076 /// construct SubprogramDIE - Construct subprogram DIE.
1077 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1080 // Check for pre-existence.
1081 CompileUnit *TheCU = getCompileUnit(N);
1082 if (TheCU->getDIE(N))
1085 if (!SP.isDefinition())
1086 // This is a method declaration which will be handled while constructing
1090 DIE *SubprogramDie = createSubprogramDIE(SP);
1093 TheCU->insertDIE(N, SubprogramDie);
1095 // Add to context owner.
1096 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1098 // Expose as global.
1099 TheCU->addGlobal(SP.getName(), SubprogramDie);
1104 /// beginModule - Emit all Dwarf sections that should come prior to the
1105 /// content. Create global DIEs and emit initial debug info sections.
1106 /// This is invoked by the target AsmPrinter.
1107 void DwarfDebug::beginModule(Module *M) {
1108 if (DisableDebugInfoPrinting)
1111 // If module has named metadata anchors then use them, otherwise scan the
1112 // module using debug info finder to collect debug info.
1113 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1116 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1117 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1118 if (!GV_Nodes && !SP_Nodes)
1119 // If there are not any global variables or any functions then
1120 // there is not any debug info in this module.
1123 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1124 constructCompileUnit(CU_Nodes->getOperand(i));
1127 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1128 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1131 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1132 constructSubprogramDIE(SP_Nodes->getOperand(i));
1136 DebugInfoFinder DbgFinder;
1137 DbgFinder.processModule(*M);
1139 bool HasDebugInfo = false;
1140 // Scan all the compile-units to see if there are any marked as the main
1141 // unit. If not, we do not generate debug info.
1142 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1143 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1144 if (DICompileUnit(*I).isMain()) {
1145 HasDebugInfo = true;
1149 if (!HasDebugInfo) return;
1151 // Create all the compile unit DIEs.
1152 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1153 E = DbgFinder.compile_unit_end(); I != E; ++I)
1154 constructCompileUnit(*I);
1156 // Create DIEs for each global variable.
1157 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1158 E = DbgFinder.global_variable_end(); I != E; ++I)
1159 constructGlobalVariableDIE(*I);
1161 // Create DIEs for each subprogram.
1162 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1163 E = DbgFinder.subprogram_end(); I != E; ++I)
1164 constructSubprogramDIE(*I);
1167 // Tell MMI that we have debug info.
1168 MMI->setDebugInfoAvailability(true);
1170 // Emit initial sections.
1171 EmitSectionLabels();
1173 //getOrCreateTypeDIE
1174 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1175 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1176 DIType Ty(NMD->getOperand(i));
1177 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1180 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1181 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1182 DIType Ty(NMD->getOperand(i));
1183 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1186 // Prime section data.
1187 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1190 /// endModule - Emit all Dwarf sections that should come after the content.
1192 void DwarfDebug::endModule() {
1193 if (!FirstCU) return;
1194 const Module *M = MMI->getModule();
1195 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1196 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1197 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1198 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1199 DISubprogram SP(AllSPs->getOperand(SI));
1200 if (!SP.Verify()) continue;
1202 // Collect info for variables that were optimized out.
1203 if (!SP.isDefinition()) continue;
1204 StringRef FName = SP.getLinkageName();
1206 FName = SP.getName();
1207 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1209 unsigned E = NMD->getNumOperands();
1211 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1212 DeadFnScopeMap[SP] = Scope;
1213 for (unsigned I = 0; I != E; ++I) {
1214 DIVariable DV(NMD->getOperand(I));
1215 if (!DV.Verify()) continue;
1216 Scope->addVariable(new DbgVariable(DV));
1219 // Construct subprogram DIE and add variables DIEs.
1220 constructSubprogramDIE(SP);
1221 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1222 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1223 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1224 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1226 ScopeDIE->addChild(VariableDIE);
1231 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1232 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1233 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1235 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1238 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1239 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1240 DIE *SPDie = CI->first;
1241 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1243 DIE *NDie = getCompileUnit(N)->getDIE(N);
1244 if (!NDie) continue;
1245 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1246 dwarf::DW_FORM_ref4, NDie);
1249 // Standard sections final addresses.
1250 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1251 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1252 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1253 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1255 // End text sections.
1256 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1257 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1258 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1261 // Compute DIE offsets and sizes.
1262 computeSizeAndOffsets();
1264 // Emit all the DIEs into a debug info section
1267 // Corresponding abbreviations into a abbrev section.
1268 emitAbbreviations();
1270 // Emit info into a debug pubnames section.
1271 emitDebugPubNames();
1273 // Emit info into a debug pubtypes section.
1274 emitDebugPubTypes();
1276 // Emit info into a debug loc section.
1279 // Emit info into a debug aranges section.
1282 // Emit info into a debug ranges section.
1285 // Emit info into a debug macinfo section.
1288 // Emit inline info.
1289 emitDebugInlineInfo();
1291 // Emit info into a debug str section.
1295 DeleteContainerSeconds(DeadFnScopeMap);
1296 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1297 E = CUMap.end(); I != E; ++I)
1299 FirstCU = NULL; // Reset for the next Module, if any.
1302 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1303 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1304 DebugLoc ScopeLoc) {
1305 LLVMContext &Ctx = DV->getContext();
1307 // More then one inlined variable corresponds to one abstract variable.
1308 DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1310 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1312 return AbsDbgVariable;
1315 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1319 AbsDbgVariable = new DbgVariable(Var);
1320 Scope->addVariable(AbsDbgVariable);
1321 AbstractVariables[Var] = AbsDbgVariable;
1322 return AbsDbgVariable;
1325 /// addCurrentFnArgument - If Var is a current function argument then add
1326 /// it to CurrentFnArguments list.
1327 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1328 DbgVariable *Var, DbgScope *Scope) {
1329 if (Scope != CurrentFnDbgScope)
1331 DIVariable DV = Var->getVariable();
1332 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1334 unsigned ArgNo = DV.getArgNumber();
1338 size_t Size = CurrentFnArguments.size();
1340 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1341 // llvm::Function argument size is not good indicator of how many
1342 // arguments does the function have at source level.
1344 CurrentFnArguments.resize(ArgNo * 2);
1345 CurrentFnArguments[ArgNo - 1] = Var;
1349 /// collectVariableInfoFromMMITable - Collect variable information from
1350 /// side table maintained by MMI.
1352 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1353 SmallPtrSet<const MDNode *, 16> &Processed) {
1354 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1355 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1356 VE = VMap.end(); VI != VE; ++VI) {
1357 const MDNode *Var = VI->first;
1359 Processed.insert(Var);
1361 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1363 DbgScope *Scope = findDbgScope(VP.second);
1365 // If variable scope is not found then skip this variable.
1369 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1370 DbgVariable *RegVar = new DbgVariable(DV);
1371 recordVariableFrameIndex(RegVar, VP.first);
1372 if (!addCurrentFnArgument(MF, RegVar, Scope))
1373 Scope->addVariable(RegVar);
1374 if (AbsDbgVariable) {
1375 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1376 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1381 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1382 /// DBG_VALUE instruction, is in a defined reg.
1383 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1384 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1385 return MI->getNumOperands() == 3 &&
1386 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1387 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1390 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
1392 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1393 const MCSymbol *FLabel,
1394 const MCSymbol *SLabel,
1395 const MachineInstr *MI) {
1396 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1398 if (MI->getNumOperands() != 3) {
1399 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1400 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1402 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1403 MachineLocation MLoc;
1404 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1405 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1407 if (MI->getOperand(0).isImm())
1408 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1409 if (MI->getOperand(0).isFPImm())
1410 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1411 if (MI->getOperand(0).isCImm())
1412 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1414 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
1415 return DotDebugLocEntry();
1418 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1420 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1421 SmallPtrSet<const MDNode *, 16> &Processed) {
1423 /// collection info from MMI table.
1424 collectVariableInfoFromMMITable(MF, Processed);
1426 for (SmallVectorImpl<const MDNode*>::const_iterator
1427 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1429 const MDNode *Var = *UVI;
1430 if (Processed.count(Var))
1433 // History contains relevant DBG_VALUE instructions for Var and instructions
1435 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1436 if (History.empty())
1438 const MachineInstr *MInsn = History.front();
1441 DbgScope *Scope = NULL;
1442 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1443 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1444 Scope = CurrentFnDbgScope;
1446 if (DV.getVersion() <= LLVMDebugVersion9)
1447 Scope = findDbgScope(MInsn->getDebugLoc());
1449 if (MDNode *IA = DV.getInlinedAt())
1450 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
1452 Scope = DbgScopeMap.lookup(cast<MDNode>(DV->getOperand(1)));
1455 // If variable scope is not found then skip this variable.
1459 Processed.insert(DV);
1460 assert(MInsn->isDebugValue() && "History must begin with debug value");
1461 DbgVariable *RegVar = new DbgVariable(DV);
1462 if (!addCurrentFnArgument(MF, RegVar, Scope))
1463 Scope->addVariable(RegVar);
1464 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1465 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1466 VarToAbstractVarMap[RegVar] = AbsVar;
1469 // Simple ranges that are fully coalesced.
1470 if (History.size() <= 1 || (History.size() == 2 &&
1471 MInsn->isIdenticalTo(History.back()))) {
1472 DbgVariableToDbgInstMap[RegVar] = MInsn;
1476 // handle multiple DBG_VALUE instructions describing one variable.
1477 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1479 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1480 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1481 const MachineInstr *Begin = *HI;
1482 assert(Begin->isDebugValue() && "Invalid History entry");
1484 // Check if DBG_VALUE is truncating a range.
1485 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1486 && !Begin->getOperand(0).getReg())
1489 // Compute the range for a register location.
1490 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1491 const MCSymbol *SLabel = 0;
1494 // If Begin is the last instruction in History then its value is valid
1495 // until the end of the function.
1496 SLabel = FunctionEndSym;
1498 const MachineInstr *End = HI[1];
1499 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1500 << "\t" << *Begin << "\t" << *End << "\n");
1501 if (End->isDebugValue())
1502 SLabel = getLabelBeforeInsn(End);
1504 // End is a normal instruction clobbering the range.
1505 SLabel = getLabelAfterInsn(End);
1506 assert(SLabel && "Forgot label after clobber instruction");
1511 // The value is valid until the next DBG_VALUE or clobber.
1512 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1514 DotDebugLocEntries.push_back(DotDebugLocEntry());
1517 // Collect info for variables that were optimized out.
1518 const Function *F = MF->getFunction();
1519 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1520 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1521 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1522 if (!DV || !Processed.insert(DV))
1524 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1526 Scope->addVariable(new DbgVariable(DV));
1531 /// getLabelBeforeInsn - Return Label preceding the instruction.
1532 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1533 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1534 assert(Label && "Didn't insert label before instruction");
1538 /// getLabelAfterInsn - Return Label immediately following the instruction.
1539 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1540 return LabelsAfterInsn.lookup(MI);
1543 /// beginInstruction - Process beginning of an instruction.
1544 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1545 // Check if source location changes, but ignore DBG_VALUE locations.
1546 if (!MI->isDebugValue()) {
1547 DebugLoc DL = MI->getDebugLoc();
1548 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1549 unsigned Flags = DWARF2_FLAG_IS_STMT;
1551 if (DL == PrologEndLoc) {
1552 Flags |= DWARF2_FLAG_PROLOGUE_END;
1553 PrologEndLoc = DebugLoc();
1555 if (!DL.isUnknown()) {
1556 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1557 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1559 recordSourceLine(0, 0, 0, 0);
1563 // Insert labels where requested.
1564 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1565 LabelsBeforeInsn.find(MI);
1568 if (I == LabelsBeforeInsn.end())
1571 // Label already assigned.
1576 PrevLabel = MMI->getContext().CreateTempSymbol();
1577 Asm->OutStreamer.EmitLabel(PrevLabel);
1579 I->second = PrevLabel;
1582 /// endInstruction - Process end of an instruction.
1583 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1584 // Don't create a new label after DBG_VALUE instructions.
1585 // They don't generate code.
1586 if (!MI->isDebugValue())
1589 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1590 LabelsAfterInsn.find(MI);
1593 if (I == LabelsAfterInsn.end())
1596 // Label already assigned.
1600 // We need a label after this instruction.
1602 PrevLabel = MMI->getContext().CreateTempSymbol();
1603 Asm->OutStreamer.EmitLabel(PrevLabel);
1605 I->second = PrevLabel;
1608 /// getOrCreateRegularScope - Create regular DbgScope.
1609 DbgScope *DwarfDebug::getOrCreateRegularScope(MDNode *Scope) {
1610 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1613 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1614 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1615 if (DIDescriptor(Scope).isLexicalBlock()) {
1617 getOrCreateDbgScope(DebugLoc::getFromDILexicalBlock(Scope));
1618 WScope->setParent(Parent);
1619 Parent->addScope(WScope);
1620 } else if (DIDescriptor(Scope).isSubprogram()
1621 && DISubprogram(Scope).describes(Asm->MF->getFunction()))
1622 CurrentFnDbgScope = WScope;
1627 /// getOrCreateInlinedScope - Create inlined scope.
1628 DbgScope *DwarfDebug::getOrCreateInlinedScope(MDNode *Scope, MDNode *InlinedAt){
1629 DbgScope *InlinedScope = DbgScopeMap.lookup(InlinedAt);
1631 return InlinedScope;
1633 InlinedScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1634 DebugLoc InlinedLoc = DebugLoc::getFromDILocation(InlinedAt);
1635 InlinedDbgScopeMap[InlinedLoc] = InlinedScope;
1636 DbgScopeMap[InlinedAt] = InlinedScope;
1637 DbgScope *Parent = getOrCreateDbgScope(InlinedLoc);
1638 InlinedScope->setParent(Parent);
1639 Parent->addScope(InlinedScope);
1640 return InlinedScope;
1643 /// getOrCreateDbgScope - Create DbgScope for the scope.
1644 DbgScope *DwarfDebug::getOrCreateDbgScope(DebugLoc DL) {
1645 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1646 MDNode *Scope = NULL;
1647 MDNode *InlinedAt = NULL;
1648 DL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1650 return getOrCreateRegularScope(Scope);
1652 // Create an abstract scope for inlined function.
1653 getOrCreateAbstractScope(Scope);
1654 // Create an inlined scope for inlined function.
1655 return getOrCreateInlinedScope(Scope, InlinedAt);
1658 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1660 static void calculateDominanceGraph(DbgScope *Scope) {
1661 assert (Scope && "Unable to calculate scop edominance graph!");
1662 SmallVector<DbgScope *, 4> WorkStack;
1663 WorkStack.push_back(Scope);
1664 unsigned Counter = 0;
1665 while (!WorkStack.empty()) {
1666 DbgScope *WS = WorkStack.back();
1667 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1668 bool visitedChildren = false;
1669 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1670 SE = Children.end(); SI != SE; ++SI) {
1671 DbgScope *ChildScope = *SI;
1672 if (!ChildScope->getDFSOut()) {
1673 WorkStack.push_back(ChildScope);
1674 visitedChildren = true;
1675 ChildScope->setDFSIn(++Counter);
1678 dbgs() << "calculate dbgscope dom: In " << Counter << "\n";
1683 if (!visitedChildren) {
1684 WorkStack.pop_back();
1685 WS->setDFSOut(++Counter);
1688 dbgs() << "calculate dbgscope dom: In " << WS->getDFSIn()
1689 << " Out " << Counter << "\n";
1695 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1697 void printDbgScopeInfo(const MachineFunction *MF,
1698 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1701 LLVMContext &Ctx = MF->getFunction()->getContext();
1702 unsigned PrevDFSIn = 0;
1703 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1705 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1707 const MachineInstr *MInsn = II;
1708 MDNode *Scope = NULL;
1709 MDNode *InlinedAt = NULL;
1711 // Check if instruction has valid location information.
1712 DebugLoc MIDL = MInsn->getDebugLoc();
1713 if (!MIDL.isUnknown()) {
1714 MIDL.getScopeAndInlinedAt(Scope, InlinedAt, Ctx);
1718 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1719 MI2ScopeMap.find(MInsn);
1720 if (DI != MI2ScopeMap.end()) {
1721 DbgScope *S = DI->second;
1722 dbgs() << S->getDFSIn();
1723 PrevDFSIn = S->getDFSIn();
1725 dbgs() << PrevDFSIn;
1727 dbgs() << " [ x" << PrevDFSIn;
1735 /// extractScopeInformation - Scan machine instructions in this function
1736 /// and collect DbgScopes. Return true, if at least one scope was found.
1737 bool DwarfDebug::extractScopeInformation() {
1738 // If scope information was extracted using .dbg intrinsics then there is not
1739 // any need to extract these information by scanning each instruction.
1740 if (!DbgScopeMap.empty())
1743 // Scan each instruction and create scopes. First build working set of scopes.
1744 SmallVector<DbgRange, 4> MIRanges;
1745 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1746 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1748 const MachineInstr *RangeBeginMI = NULL;
1749 const MachineInstr *PrevMI = NULL;
1751 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1753 const MachineInstr *MInsn = II;
1755 // Check if instruction has valid location information.
1756 const DebugLoc MIDL = MInsn->getDebugLoc();
1757 if (MIDL.isUnknown()) {
1762 // If scope has not changed then skip this instruction.
1763 if (MIDL == PrevDL) {
1768 // Ignore DBG_VALUE. It does not contribute to any instruction in output.
1769 if (MInsn->isDebugValue())
1773 // If we have already seen a beginning of an instruction range and
1774 // current instruction scope does not match scope of first instruction
1775 // in this range then create a new instruction range.
1776 DEBUG(dbgs() << "Creating new instruction range :\n");
1777 DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI);
1778 DEBUG(dbgs() << "End Range at " << *PrevMI);
1779 DEBUG(dbgs() << "Next Range starting at " << *MInsn);
1780 DEBUG(dbgs() << "------------------------\n");
1781 DbgRange R(RangeBeginMI, PrevMI);
1782 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1783 MIRanges.push_back(R);
1786 // This is a beginning of a new instruction range.
1787 RangeBeginMI = MInsn;
1789 // Reset previous markers.
1794 // Create last instruction range.
1795 if (RangeBeginMI && PrevMI && !PrevDL.isUnknown()) {
1796 DbgRange R(RangeBeginMI, PrevMI);
1797 MIRanges.push_back(R);
1798 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevDL);
1802 if (!CurrentFnDbgScope)
1805 calculateDominanceGraph(CurrentFnDbgScope);
1807 printDbgScopeInfo(Asm->MF, MI2ScopeMap);
1809 // Find ranges of instructions covered by each DbgScope;
1810 DbgScope *PrevDbgScope = NULL;
1811 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1812 RE = MIRanges.end(); RI != RE; ++RI) {
1813 const DbgRange &R = *RI;
1814 DbgScope *S = MI2ScopeMap.lookup(R.first);
1815 assert (S && "Lost DbgScope for a machine instruction!");
1816 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1817 PrevDbgScope->closeInsnRange(S);
1818 S->openInsnRange(R.first);
1819 S->extendInsnRange(R.second);
1824 PrevDbgScope->closeInsnRange();
1826 identifyScopeMarkers();
1828 return !DbgScopeMap.empty();
1831 /// identifyScopeMarkers() -
1832 /// Each DbgScope has first instruction and last instruction to mark beginning
1833 /// and end of a scope respectively. Create an inverse map that list scopes
1834 /// starts (and ends) with an instruction. One instruction may start (or end)
1835 /// multiple scopes. Ignore scopes that are not reachable.
1836 void DwarfDebug::identifyScopeMarkers() {
1837 SmallVector<DbgScope *, 4> WorkList;
1838 WorkList.push_back(CurrentFnDbgScope);
1839 while (!WorkList.empty()) {
1840 DbgScope *S = WorkList.pop_back_val();
1842 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1843 if (!Children.empty())
1844 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1845 SE = Children.end(); SI != SE; ++SI)
1846 WorkList.push_back(*SI);
1848 if (S->isAbstractScope())
1851 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1854 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1855 RE = Ranges.end(); RI != RE; ++RI) {
1856 assert(RI->first && "DbgRange does not have first instruction!");
1857 assert(RI->second && "DbgRange does not have second instruction!");
1858 requestLabelBeforeInsn(RI->first);
1859 requestLabelAfterInsn(RI->second);
1864 /// getScopeNode - Get MDNode for DebugLoc's scope.
1865 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1866 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1867 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1868 return DL.getScope(Ctx);
1871 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1872 /// line number info for the function.
1873 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1874 const MDNode *Scope = getScopeNode(DL, Ctx);
1875 DISubprogram SP = getDISubprogram(Scope);
1877 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1881 /// beginFunction - Gather pre-function debug information. Assumes being
1882 /// emitted immediately after the function entry point.
1883 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1884 if (!MMI->hasDebugInfo()) return;
1885 if (!extractScopeInformation()) return;
1887 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1888 Asm->getFunctionNumber());
1889 // Assumes in correct section after the entry point.
1890 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1892 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1894 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1895 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1896 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1898 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1900 bool AtBlockEntry = true;
1901 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1903 const MachineInstr *MI = II;
1905 if (MI->isDebugValue()) {
1906 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1908 // Keep track of user variables.
1910 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1912 // Variable is in a register, we need to check for clobbers.
1913 if (isDbgValueInDefinedReg(MI))
1914 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1916 // Check the history of this variable.
1917 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1918 if (History.empty()) {
1919 UserVariables.push_back(Var);
1920 // The first mention of a function argument gets the FunctionBeginSym
1921 // label, so arguments are visible when breaking at function entry.
1923 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1924 DISubprogram(getDISubprogram(DV.getContext()))
1925 .describes(MF->getFunction()))
1926 LabelsBeforeInsn[MI] = FunctionBeginSym;
1928 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1929 const MachineInstr *Prev = History.back();
1930 if (Prev->isDebugValue()) {
1931 // Coalesce identical entries at the end of History.
1932 if (History.size() >= 2 &&
1933 Prev->isIdenticalTo(History[History.size() - 2])) {
1934 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1936 << "\t" << *History[History.size() - 2] << "\n");
1940 // Terminate old register assignments that don't reach MI;
1941 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1942 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1943 isDbgValueInDefinedReg(Prev)) {
1944 // Previous register assignment needs to terminate at the end of
1946 MachineBasicBlock::const_iterator LastMI =
1947 PrevMBB->getLastNonDebugInstr();
1948 if (LastMI == PrevMBB->end()) {
1949 // Drop DBG_VALUE for empty range.
1950 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1951 << "\t" << *Prev << "\n");
1955 // Terminate after LastMI.
1956 History.push_back(LastMI);
1961 History.push_back(MI);
1963 // Not a DBG_VALUE instruction.
1965 AtBlockEntry = false;
1967 // First known non DBG_VALUE location marks beginning of function
1969 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1970 PrologEndLoc = MI->getDebugLoc();
1972 // Check if the instruction clobbers any registers with debug vars.
1973 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1974 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1975 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1977 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1978 unsigned Reg = *AI; ++AI) {
1979 const MDNode *Var = LiveUserVar[Reg];
1982 // Reg is now clobbered.
1983 LiveUserVar[Reg] = 0;
1985 // Was MD last defined by a DBG_VALUE referring to Reg?
1986 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1987 if (HistI == DbgValues.end())
1989 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1990 if (History.empty())
1992 const MachineInstr *Prev = History.back();
1993 // Sanity-check: Register assignments are terminated at the end of
1995 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1997 // Is the variable still in Reg?
1998 if (!isDbgValueInDefinedReg(Prev) ||
1999 Prev->getOperand(0).getReg() != Reg)
2001 // Var is clobbered. Make sure the next instruction gets a label.
2002 History.push_back(MI);
2009 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
2011 SmallVectorImpl<const MachineInstr*> &History = I->second;
2012 if (History.empty())
2015 // Make sure the final register assignments are terminated.
2016 const MachineInstr *Prev = History.back();
2017 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
2018 const MachineBasicBlock *PrevMBB = Prev->getParent();
2019 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
2020 if (LastMI == PrevMBB->end())
2021 // Drop DBG_VALUE for empty range.
2024 // Terminate after LastMI.
2025 History.push_back(LastMI);
2028 // Request labels for the full history.
2029 for (unsigned i = 0, e = History.size(); i != e; ++i) {
2030 const MachineInstr *MI = History[i];
2031 if (MI->isDebugValue())
2032 requestLabelBeforeInsn(MI);
2034 requestLabelAfterInsn(MI);
2038 PrevInstLoc = DebugLoc();
2039 PrevLabel = FunctionBeginSym;
2041 // Record beginning of function.
2042 if (!PrologEndLoc.isUnknown()) {
2043 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
2044 MF->getFunction()->getContext());
2045 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
2046 FnStartDL.getScope(MF->getFunction()->getContext()),
2047 DWARF2_FLAG_IS_STMT);
2051 /// endFunction - Gather and emit post-function debug information.
2053 void DwarfDebug::endFunction(const MachineFunction *MF) {
2054 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2056 if (CurrentFnDbgScope) {
2058 // Define end label for subprogram.
2059 FunctionEndSym = Asm->GetTempSymbol("func_end",
2060 Asm->getFunctionNumber());
2061 // Assumes in correct section after the entry point.
2062 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2064 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2065 collectVariableInfo(MF, ProcessedVars);
2067 // Construct abstract scopes.
2068 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2069 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2070 DISubprogram SP((*AI)->getScopeNode());
2072 // Collect info for variables that were optimized out.
2073 StringRef FName = SP.getLinkageName();
2075 FName = SP.getName();
2076 if (NamedMDNode *NMD =
2077 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2078 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2079 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2080 if (!DV || !ProcessedVars.insert(DV))
2082 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2084 Scope->addVariable(new DbgVariable(DV));
2088 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2089 constructScopeDIE(*AI);
2092 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2094 if (!DisableFramePointerElim(*MF))
2095 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2096 dwarf::DW_AT_APPLE_omit_frame_ptr,
2097 dwarf::DW_FORM_flag, 1);
2100 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2101 MMI->getFrameMoves()));
2105 CurrentFnDbgScope = NULL;
2106 DeleteContainerPointers(CurrentFnArguments);
2107 DbgVariableToFrameIndexMap.clear();
2108 VarToAbstractVarMap.clear();
2109 DbgVariableToDbgInstMap.clear();
2110 InlinedDbgScopeMap.clear();
2111 DeleteContainerSeconds(DbgScopeMap);
2112 UserVariables.clear();
2114 DeleteContainerSeconds(AbstractScopes);
2115 AbstractScopesList.clear();
2116 AbstractVariables.clear();
2117 LabelsBeforeInsn.clear();
2118 LabelsAfterInsn.clear();
2122 /// recordVariableFrameIndex - Record a variable's index.
2123 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2124 assert (V && "Invalid DbgVariable!");
2125 DbgVariableToFrameIndexMap[V] = Index;
2128 /// findVariableFrameIndex - Return true if frame index for the variable
2129 /// is found. Update FI to hold value of the index.
2130 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2131 assert (V && "Invalid DbgVariable!");
2132 DenseMap<const DbgVariable *, int>::iterator I =
2133 DbgVariableToFrameIndexMap.find(V);
2134 if (I == DbgVariableToFrameIndexMap.end())
2140 /// findDbgScope - Find DbgScope for the debug loc.
2141 DbgScope *DwarfDebug::findDbgScope(DebugLoc DL) {
2145 DbgScope *Scope = NULL;
2146 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2147 if (MDNode *IA = DL.getInlinedAt(Ctx))
2148 Scope = InlinedDbgScopeMap.lookup(DebugLoc::getFromDILocation(IA));
2150 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2155 /// recordSourceLine - Register a source line with debug info. Returns the
2156 /// unique label that was emitted and which provides correspondence to
2157 /// the source line list.
2158 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2164 DIDescriptor Scope(S);
2166 if (Scope.isCompileUnit()) {
2167 DICompileUnit CU(S);
2168 Fn = CU.getFilename();
2169 Dir = CU.getDirectory();
2170 } else if (Scope.isFile()) {
2172 Fn = F.getFilename();
2173 Dir = F.getDirectory();
2174 } else if (Scope.isSubprogram()) {
2176 Fn = SP.getFilename();
2177 Dir = SP.getDirectory();
2178 } else if (Scope.isLexicalBlock()) {
2179 DILexicalBlock DB(S);
2180 Fn = DB.getFilename();
2181 Dir = DB.getDirectory();
2183 assert(0 && "Unexpected scope info");
2185 Src = GetOrCreateSourceID(Fn, Dir);
2187 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
2190 //===----------------------------------------------------------------------===//
2192 //===----------------------------------------------------------------------===//
2194 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2197 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2198 // Get the children.
2199 const std::vector<DIE *> &Children = Die->getChildren();
2201 // If not last sibling and has children then add sibling offset attribute.
2202 if (!Last && !Children.empty())
2203 Die->addSiblingOffset(DIEValueAllocator);
2205 // Record the abbreviation.
2206 assignAbbrevNumber(Die->getAbbrev());
2208 // Get the abbreviation for this DIE.
2209 unsigned AbbrevNumber = Die->getAbbrevNumber();
2210 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2213 Die->setOffset(Offset);
2215 // Start the size with the size of abbreviation code.
2216 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2218 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2219 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2221 // Size the DIE attribute values.
2222 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2223 // Size attribute value.
2224 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2226 // Size the DIE children if any.
2227 if (!Children.empty()) {
2228 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2229 "Children flag not set");
2231 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2232 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2234 // End of children marker.
2235 Offset += sizeof(int8_t);
2238 Die->setSize(Offset - Die->getOffset());
2242 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2244 void DwarfDebug::computeSizeAndOffsets() {
2245 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2246 E = CUMap.end(); I != E; ++I) {
2247 // Compute size of compile unit header.
2249 sizeof(int32_t) + // Length of Compilation Unit Info
2250 sizeof(int16_t) + // DWARF version number
2251 sizeof(int32_t) + // Offset Into Abbrev. Section
2252 sizeof(int8_t); // Pointer Size (in bytes)
2253 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2257 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2258 /// temporary label to it if SymbolStem is specified.
2259 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2260 const char *SymbolStem = 0) {
2261 Asm->OutStreamer.SwitchSection(Section);
2262 if (!SymbolStem) return 0;
2264 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2265 Asm->OutStreamer.EmitLabel(TmpSym);
2269 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2270 /// the start of each one.
2271 void DwarfDebug::EmitSectionLabels() {
2272 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2274 // Dwarf sections base addresses.
2275 DwarfInfoSectionSym =
2276 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2277 DwarfAbbrevSectionSym =
2278 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2279 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2281 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2282 EmitSectionSym(Asm, MacroInfo);
2284 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2285 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2286 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2287 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2288 DwarfStrSectionSym =
2289 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2290 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2293 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2294 "section_debug_loc");
2296 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2297 EmitSectionSym(Asm, TLOF.getDataSection());
2300 /// emitDIE - Recursively emits a debug information entry.
2302 void DwarfDebug::emitDIE(DIE *Die) {
2303 // Get the abbreviation for this DIE.
2304 unsigned AbbrevNumber = Die->getAbbrevNumber();
2305 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2307 // Emit the code (index) for the abbreviation.
2308 if (Asm->isVerbose())
2309 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2310 Twine::utohexstr(Die->getOffset()) + ":0x" +
2311 Twine::utohexstr(Die->getSize()) + " " +
2312 dwarf::TagString(Abbrev->getTag()));
2313 Asm->EmitULEB128(AbbrevNumber);
2315 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2316 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2318 // Emit the DIE attribute values.
2319 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2320 unsigned Attr = AbbrevData[i].getAttribute();
2321 unsigned Form = AbbrevData[i].getForm();
2322 assert(Form && "Too many attributes for DIE (check abbreviation)");
2324 if (Asm->isVerbose())
2325 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2328 case dwarf::DW_AT_sibling:
2329 Asm->EmitInt32(Die->getSiblingOffset());
2331 case dwarf::DW_AT_abstract_origin: {
2332 DIEEntry *E = cast<DIEEntry>(Values[i]);
2333 DIE *Origin = E->getEntry();
2334 unsigned Addr = Origin->getOffset();
2335 Asm->EmitInt32(Addr);
2338 case dwarf::DW_AT_ranges: {
2339 // DW_AT_range Value encodes offset in debug_range section.
2340 DIEInteger *V = cast<DIEInteger>(Values[i]);
2342 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2343 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2347 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2349 DwarfDebugRangeSectionSym,
2354 case dwarf::DW_AT_location: {
2355 if (UseDotDebugLocEntry.count(Die) != 0) {
2356 DIELabel *L = cast<DIELabel>(Values[i]);
2357 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2359 Values[i]->EmitValue(Asm, Form);
2362 case dwarf::DW_AT_accessibility: {
2363 if (Asm->isVerbose()) {
2364 DIEInteger *V = cast<DIEInteger>(Values[i]);
2365 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2367 Values[i]->EmitValue(Asm, Form);
2371 // Emit an attribute using the defined form.
2372 Values[i]->EmitValue(Asm, Form);
2377 // Emit the DIE children if any.
2378 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2379 const std::vector<DIE *> &Children = Die->getChildren();
2381 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2382 emitDIE(Children[j]);
2384 if (Asm->isVerbose())
2385 Asm->OutStreamer.AddComment("End Of Children Mark");
2390 /// emitDebugInfo - Emit the debug info section.
2392 void DwarfDebug::emitDebugInfo() {
2393 // Start debug info section.
2394 Asm->OutStreamer.SwitchSection(
2395 Asm->getObjFileLowering().getDwarfInfoSection());
2396 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2397 E = CUMap.end(); I != E; ++I) {
2398 CompileUnit *TheCU = I->second;
2399 DIE *Die = TheCU->getCUDie();
2401 // Emit the compile units header.
2402 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2405 // Emit size of content not including length itself
2406 unsigned ContentSize = Die->getSize() +
2407 sizeof(int16_t) + // DWARF version number
2408 sizeof(int32_t) + // Offset Into Abbrev. Section
2409 sizeof(int8_t); // Pointer Size (in bytes)
2411 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2412 Asm->EmitInt32(ContentSize);
2413 Asm->OutStreamer.AddComment("DWARF version number");
2414 Asm->EmitInt16(dwarf::DWARF_VERSION);
2415 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2416 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2417 DwarfAbbrevSectionSym);
2418 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2419 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2422 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2426 /// emitAbbreviations - Emit the abbreviation section.
2428 void DwarfDebug::emitAbbreviations() const {
2429 // Check to see if it is worth the effort.
2430 if (!Abbreviations.empty()) {
2431 // Start the debug abbrev section.
2432 Asm->OutStreamer.SwitchSection(
2433 Asm->getObjFileLowering().getDwarfAbbrevSection());
2435 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2437 // For each abbrevation.
2438 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2439 // Get abbreviation data
2440 const DIEAbbrev *Abbrev = Abbreviations[i];
2442 // Emit the abbrevations code (base 1 index.)
2443 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2445 // Emit the abbreviations data.
2449 // Mark end of abbreviations.
2450 Asm->EmitULEB128(0, "EOM(3)");
2452 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2456 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2457 /// the line matrix.
2459 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2460 // Define last address of section.
2461 Asm->OutStreamer.AddComment("Extended Op");
2464 Asm->OutStreamer.AddComment("Op size");
2465 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2466 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2467 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2469 Asm->OutStreamer.AddComment("Section end label");
2471 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2472 Asm->getTargetData().getPointerSize(),
2475 // Mark end of matrix.
2476 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2482 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2484 void DwarfDebug::emitDebugPubNames() {
2485 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2486 E = CUMap.end(); I != E; ++I) {
2487 CompileUnit *TheCU = I->second;
2488 // Start the dwarf pubnames section.
2489 Asm->OutStreamer.SwitchSection(
2490 Asm->getObjFileLowering().getDwarfPubNamesSection());
2492 Asm->OutStreamer.AddComment("Length of Public Names Info");
2493 Asm->EmitLabelDifference(
2494 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2495 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2497 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2500 Asm->OutStreamer.AddComment("DWARF Version");
2501 Asm->EmitInt16(dwarf::DWARF_VERSION);
2503 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2504 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2505 DwarfInfoSectionSym);
2507 Asm->OutStreamer.AddComment("Compilation Unit Length");
2508 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2509 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2512 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2513 for (StringMap<DIE*>::const_iterator
2514 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2515 const char *Name = GI->getKeyData();
2516 DIE *Entity = GI->second;
2518 Asm->OutStreamer.AddComment("DIE offset");
2519 Asm->EmitInt32(Entity->getOffset());
2521 if (Asm->isVerbose())
2522 Asm->OutStreamer.AddComment("External Name");
2523 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2526 Asm->OutStreamer.AddComment("End Mark");
2528 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2533 void DwarfDebug::emitDebugPubTypes() {
2534 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2535 E = CUMap.end(); I != E; ++I) {
2536 CompileUnit *TheCU = I->second;
2537 // Start the dwarf pubnames section.
2538 Asm->OutStreamer.SwitchSection(
2539 Asm->getObjFileLowering().getDwarfPubTypesSection());
2540 Asm->OutStreamer.AddComment("Length of Public Types Info");
2541 Asm->EmitLabelDifference(
2542 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2543 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2545 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2548 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2549 Asm->EmitInt16(dwarf::DWARF_VERSION);
2551 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2552 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2553 DwarfInfoSectionSym);
2555 Asm->OutStreamer.AddComment("Compilation Unit Length");
2556 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2557 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2560 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2561 for (StringMap<DIE*>::const_iterator
2562 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2563 const char *Name = GI->getKeyData();
2564 DIE *Entity = GI->second;
2566 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2567 Asm->EmitInt32(Entity->getOffset());
2569 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2570 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2573 Asm->OutStreamer.AddComment("End Mark");
2575 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2580 /// emitDebugStr - Emit visible names into a debug str section.
2582 void DwarfDebug::emitDebugStr() {
2583 // Check to see if it is worth the effort.
2584 if (StringPool.empty()) return;
2586 // Start the dwarf str section.
2587 Asm->OutStreamer.SwitchSection(
2588 Asm->getObjFileLowering().getDwarfStrSection());
2590 // Get all of the string pool entries and put them in an array by their ID so
2591 // we can sort them.
2592 SmallVector<std::pair<unsigned,
2593 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2595 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2596 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2597 Entries.push_back(std::make_pair(I->second.second, &*I));
2599 array_pod_sort(Entries.begin(), Entries.end());
2601 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2602 // Emit a label for reference from debug information entries.
2603 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2605 // Emit the string itself.
2606 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2610 /// emitDebugLoc - Emit visible names into a debug loc section.
2612 void DwarfDebug::emitDebugLoc() {
2613 if (DotDebugLocEntries.empty())
2616 for (SmallVector<DotDebugLocEntry, 4>::iterator
2617 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2619 DotDebugLocEntry &Entry = *I;
2620 if (I + 1 != DotDebugLocEntries.end())
2624 // Start the dwarf loc section.
2625 Asm->OutStreamer.SwitchSection(
2626 Asm->getObjFileLowering().getDwarfLocSection());
2627 unsigned char Size = Asm->getTargetData().getPointerSize();
2628 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2630 for (SmallVector<DotDebugLocEntry, 4>::iterator
2631 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2632 I != E; ++I, ++index) {
2633 DotDebugLocEntry &Entry = *I;
2634 if (Entry.isMerged()) continue;
2635 if (Entry.isEmpty()) {
2636 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2637 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2638 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2640 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2641 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2642 DIVariable DV(Entry.Variable);
2643 Asm->OutStreamer.AddComment("Loc expr size");
2644 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2645 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2646 Asm->EmitLabelDifference(end, begin, 2);
2647 Asm->OutStreamer.EmitLabel(begin);
2648 if (Entry.isInt()) {
2649 DIBasicType BTy(DV.getType());
2651 (BTy.getEncoding() == dwarf::DW_ATE_signed
2652 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2653 Asm->OutStreamer.AddComment("DW_OP_consts");
2654 Asm->EmitInt8(dwarf::DW_OP_consts);
2655 Asm->EmitSLEB128(Entry.getInt());
2657 Asm->OutStreamer.AddComment("DW_OP_constu");
2658 Asm->EmitInt8(dwarf::DW_OP_constu);
2659 Asm->EmitULEB128(Entry.getInt());
2661 } else if (Entry.isLocation()) {
2662 if (!DV.hasComplexAddress())
2664 Asm->EmitDwarfRegOp(Entry.Loc);
2666 // Complex address entry.
2667 unsigned N = DV.getNumAddrElements();
2669 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2670 if (Entry.Loc.getOffset()) {
2672 Asm->EmitDwarfRegOp(Entry.Loc);
2673 Asm->OutStreamer.AddComment("DW_OP_deref");
2674 Asm->EmitInt8(dwarf::DW_OP_deref);
2675 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2676 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2677 Asm->EmitSLEB128(DV.getAddrElement(1));
2679 // If first address element is OpPlus then emit
2680 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2681 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2682 Asm->EmitDwarfRegOp(Loc);
2686 Asm->EmitDwarfRegOp(Entry.Loc);
2689 // Emit remaining complex address elements.
2690 for (; i < N; ++i) {
2691 uint64_t Element = DV.getAddrElement(i);
2692 if (Element == DIBuilder::OpPlus) {
2693 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2694 Asm->EmitULEB128(DV.getAddrElement(++i));
2695 } else if (Element == DIBuilder::OpDeref)
2696 Asm->EmitInt8(dwarf::DW_OP_deref);
2697 else llvm_unreachable("unknown Opcode found in complex address");
2701 // else ... ignore constant fp. There is not any good way to
2702 // to represent them here in dwarf.
2703 Asm->OutStreamer.EmitLabel(end);
2708 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2710 void DwarfDebug::EmitDebugARanges() {
2711 // Start the dwarf aranges section.
2712 Asm->OutStreamer.SwitchSection(
2713 Asm->getObjFileLowering().getDwarfARangesSection());
2716 /// emitDebugRanges - Emit visible names into a debug ranges section.
2718 void DwarfDebug::emitDebugRanges() {
2719 // Start the dwarf ranges section.
2720 Asm->OutStreamer.SwitchSection(
2721 Asm->getObjFileLowering().getDwarfRangesSection());
2722 unsigned char Size = Asm->getTargetData().getPointerSize();
2723 for (SmallVector<const MCSymbol *, 8>::iterator
2724 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2727 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2729 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2733 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2735 void DwarfDebug::emitDebugMacInfo() {
2736 if (const MCSection *LineInfo =
2737 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2738 // Start the dwarf macinfo section.
2739 Asm->OutStreamer.SwitchSection(LineInfo);
2743 /// emitDebugInlineInfo - Emit inline info using following format.
2745 /// 1. length of section
2746 /// 2. Dwarf version number
2747 /// 3. address size.
2749 /// Entries (one "entry" for each function that was inlined):
2751 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2752 /// otherwise offset into __debug_str for regular function name.
2753 /// 2. offset into __debug_str section for regular function name.
2754 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2755 /// instances for the function.
2757 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2758 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2759 /// __debug_info section, and the low_pc is the starting address for the
2760 /// inlining instance.
2761 void DwarfDebug::emitDebugInlineInfo() {
2762 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2768 Asm->OutStreamer.SwitchSection(
2769 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2771 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2772 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2773 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2775 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2777 Asm->OutStreamer.AddComment("Dwarf Version");
2778 Asm->EmitInt16(dwarf::DWARF_VERSION);
2779 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2780 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2782 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2783 E = InlinedSPNodes.end(); I != E; ++I) {
2785 const MDNode *Node = *I;
2786 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2787 = InlineInfo.find(Node);
2788 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2789 DISubprogram SP(Node);
2790 StringRef LName = SP.getLinkageName();
2791 StringRef Name = SP.getName();
2793 Asm->OutStreamer.AddComment("MIPS linkage name");
2794 if (LName.empty()) {
2795 Asm->OutStreamer.EmitBytes(Name, 0);
2796 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2798 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2799 DwarfStrSectionSym);
2801 Asm->OutStreamer.AddComment("Function name");
2802 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2803 Asm->EmitULEB128(Labels.size(), "Inline count");
2805 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2806 LE = Labels.end(); LI != LE; ++LI) {
2807 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2808 Asm->EmitInt32(LI->second->getOffset());
2810 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2811 Asm->OutStreamer.EmitSymbolValue(LI->first,
2812 Asm->getTargetData().getPointerSize(),0);
2816 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));