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 const MDNode *N = Desc;
235 err << "Abstract Scope\n";
239 err << "Children ...\n";
240 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
241 if (Scopes[i] != this)
248 DbgScope::~DbgScope() {
249 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
253 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
254 : Asm(A), MMI(Asm->MMI), FirstCU(0),
255 AbbreviationsSet(InitAbbreviationsSetSize),
256 CurrentFnDbgScope(0), PrevLabel(NULL) {
257 NextStringPoolNumber = 0;
259 DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
260 DwarfStrSectionSym = TextSectionSym = 0;
261 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
262 FunctionBeginSym = FunctionEndSym = 0;
264 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
268 DwarfDebug::~DwarfDebug() {
271 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
272 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
273 if (Entry.first) return Entry.first;
275 Entry.second = NextStringPoolNumber++;
276 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
280 /// assignAbbrevNumber - Define a unique number for the abbreviation.
282 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
283 // Profile the node so that we can make it unique.
287 // Check the set for priors.
288 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
290 // If it's newly added.
291 if (InSet == &Abbrev) {
292 // Add to abbreviation list.
293 Abbreviations.push_back(&Abbrev);
295 // Assign the vector position + 1 as its number.
296 Abbrev.setNumber(Abbreviations.size());
298 // Assign existing abbreviation number.
299 Abbrev.setNumber(InSet->getNumber());
303 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
304 /// printer to not emit usual symbol prefix before the symbol name is used then
305 /// return linkage name after skipping this special LLVM prefix.
306 static StringRef getRealLinkageName(StringRef LinkageName) {
308 if (LinkageName.startswith(StringRef(&One, 1)))
309 return LinkageName.substr(1);
313 /// createSubprogramDIE - Create new DIE using SP.
314 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
315 CompileUnit *SPCU = getCompileUnit(SP);
316 DIE *SPDie = SPCU->getDIE(SP);
320 SPDie = new DIE(dwarf::DW_TAG_subprogram);
322 // DW_TAG_inlined_subroutine may refer to this DIE.
323 SPCU->insertDIE(SP, SPDie);
325 // Add to context owner.
326 SPCU->addToContextOwner(SPDie, SP.getContext());
328 // Add function template parameters.
329 SPCU->addTemplateParams(*SPDie, SP.getTemplateParams());
331 StringRef LinkageName = SP.getLinkageName();
332 if (!LinkageName.empty())
333 SPCU->addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
334 getRealLinkageName(LinkageName));
336 // If this DIE is going to refer declaration info using AT_specification
337 // then there is no need to add other attributes.
338 if (SP.getFunctionDeclaration().isSubprogram())
341 // Constructors and operators for anonymous aggregates do not have names.
342 if (!SP.getName().empty())
343 SPCU->addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
346 SPCU->addSourceLine(SPDie, SP);
348 if (SP.isPrototyped())
349 SPCU->addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
352 DICompositeType SPTy = SP.getType();
353 DIArray Args = SPTy.getTypeArray();
354 unsigned SPTag = SPTy.getTag();
356 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
357 SPCU->addType(SPDie, SPTy);
359 SPCU->addType(SPDie, DIType(Args.getElement(0)));
361 unsigned VK = SP.getVirtuality();
363 SPCU->addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
364 DIEBlock *Block = SPCU->getDIEBlock();
365 SPCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
366 SPCU->addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
367 SPCU->addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
368 ContainingTypeMap.insert(std::make_pair(SPDie,
369 SP.getContainingType()));
372 if (!SP.isDefinition()) {
373 SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
375 // Add arguments. Do not add arguments for subprogram definition. They will
376 // be handled while processing variables.
377 DICompositeType SPTy = SP.getType();
378 DIArray Args = SPTy.getTypeArray();
379 unsigned SPTag = SPTy.getTag();
381 if (SPTag == dwarf::DW_TAG_subroutine_type)
382 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
383 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
384 DIType ATy = DIType(DIType(Args.getElement(i)));
385 SPCU->addType(Arg, ATy);
386 if (ATy.isArtificial())
387 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
388 SPDie->addChild(Arg);
392 if (SP.isArtificial())
393 SPCU->addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
395 if (!SP.isLocalToUnit())
396 SPCU->addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
398 if (SP.isOptimized())
399 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
401 if (unsigned isa = Asm->getISAEncoding()) {
402 SPCU->addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
408 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
409 assert(N && "Invalid Scope encoding!");
411 DbgScope *AScope = AbstractScopes.lookup(N);
415 DbgScope *Parent = NULL;
417 DIDescriptor Scope(N);
418 if (Scope.isLexicalBlock()) {
419 DILexicalBlock DB(N);
420 DIDescriptor ParentDesc = DB.getContext();
421 Parent = getOrCreateAbstractScope(ParentDesc);
424 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
427 Parent->addScope(AScope);
428 AScope->setAbstractScope();
429 AbstractScopes[N] = AScope;
430 if (DIDescriptor(N).isSubprogram())
431 AbstractScopesList.push_back(AScope);
435 /// isSubprogramContext - Return true if Context is either a subprogram
436 /// or another context nested inside a subprogram.
437 static bool isSubprogramContext(const MDNode *Context) {
440 DIDescriptor D(Context);
441 if (D.isSubprogram())
444 return isSubprogramContext(DIType(Context).getContext());
448 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
449 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
450 /// If there are global variables in this scope then create and insert
451 /// DIEs for these variables.
452 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
453 CompileUnit *SPCU = getCompileUnit(SPNode);
454 DIE *SPDie = SPCU->getDIE(SPNode);
456 assert(SPDie && "Unable to find subprogram DIE!");
457 DISubprogram SP(SPNode);
459 DISubprogram SPDecl = SP.getFunctionDeclaration();
460 if (SPDecl.isSubprogram())
461 // Refer function declaration directly.
462 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
463 createSubprogramDIE(SPDecl));
465 // There is not any need to generate specification DIE for a function
466 // defined at compile unit level. If a function is defined inside another
467 // function then gdb prefers the definition at top level and but does not
468 // expect specification DIE in parent function. So avoid creating
469 // specification DIE for a function defined inside a function.
470 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
471 !SP.getContext().isFile() &&
472 !isSubprogramContext(SP.getContext())) {
473 SPCU-> addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
476 DICompositeType SPTy = SP.getType();
477 DIArray Args = SPTy.getTypeArray();
478 unsigned SPTag = SPTy.getTag();
479 if (SPTag == dwarf::DW_TAG_subroutine_type)
480 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
481 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
482 DIType ATy = DIType(DIType(Args.getElement(i)));
483 SPCU->addType(Arg, ATy);
484 if (ATy.isArtificial())
485 SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
486 SPDie->addChild(Arg);
488 DIE *SPDeclDie = SPDie;
489 SPDie = new DIE(dwarf::DW_TAG_subprogram);
490 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
495 // Pick up abstract subprogram DIE.
496 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
497 SPDie = new DIE(dwarf::DW_TAG_subprogram);
498 SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
499 dwarf::DW_FORM_ref4, AbsSPDIE);
503 SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
504 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
505 SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
506 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
507 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
508 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
509 SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
514 /// constructLexicalScope - Construct new DW_TAG_lexical_block
515 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
516 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
518 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
519 if (Scope->isAbstractScope())
522 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
526 CompileUnit *TheCU = getCompileUnit(Scope->getScopeNode());
527 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
528 if (Ranges.size() > 1) {
529 // .debug_range section has not been laid out yet. Emit offset in
530 // .debug_range as a uint, size 4, for now. emitDIE will handle
531 // DW_AT_ranges appropriately.
532 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
533 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
534 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
535 RE = Ranges.end(); RI != RE; ++RI) {
536 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
537 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
539 DebugRangeSymbols.push_back(NULL);
540 DebugRangeSymbols.push_back(NULL);
544 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
545 const MCSymbol *End = getLabelAfterInsn(RI->second);
547 if (End == 0) return 0;
549 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
550 assert(End->isDefined() && "Invalid end label for an inlined scope!");
552 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
553 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
558 /// constructInlinedScopeDIE - This scope represents inlined body of
559 /// a function. Construct DIE to represent this concrete inlined copy
561 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
563 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
564 assert (Ranges.empty() == false
565 && "DbgScope does not have instruction markers!");
567 // FIXME : .debug_inlined section specification does not clearly state how
568 // to emit inlined scope that is split into multiple instruction ranges.
569 // For now, use first instruction range and emit low_pc/high_pc pair and
570 // corresponding .debug_inlined section entry for this pair.
571 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
572 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
573 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
575 if (StartLabel == 0 || EndLabel == 0) {
576 assert (0 && "Unexpected Start and End labels for a inlined scope!");
579 assert(StartLabel->isDefined() &&
580 "Invalid starting label for an inlined scope!");
581 assert(EndLabel->isDefined() &&
582 "Invalid end label for an inlined scope!");
584 if (!Scope->getScopeNode())
586 DIScope DS(Scope->getScopeNode());
587 DISubprogram InlinedSP = getDISubprogram(DS);
588 CompileUnit *TheCU = getCompileUnit(InlinedSP);
589 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
591 DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
594 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
595 TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
596 dwarf::DW_FORM_ref4, OriginDIE);
598 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
599 TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
601 InlinedSubprogramDIEs.insert(OriginDIE);
603 // Track the start label for this inlined function.
604 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
605 I = InlineInfo.find(InlinedSP);
607 if (I == InlineInfo.end()) {
608 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
610 InlinedSPNodes.push_back(InlinedSP);
612 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
614 DILocation DL(Scope->getInlinedAt());
615 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
616 TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
621 /// isUnsignedDIType - Return true if type encoding is unsigned.
622 static bool isUnsignedDIType(DIType Ty) {
623 DIDerivedType DTy(Ty);
625 return isUnsignedDIType(DTy.getTypeDerivedFrom());
629 unsigned Encoding = BTy.getEncoding();
630 if (Encoding == dwarf::DW_ATE_unsigned ||
631 Encoding == dwarf::DW_ATE_unsigned_char)
637 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
638 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
639 StringRef Name = DV->getName();
643 // Translate tag to proper Dwarf tag. The result variable is dropped for
646 switch (DV->getTag()) {
647 case dwarf::DW_TAG_return_variable:
649 case dwarf::DW_TAG_arg_variable:
650 Tag = dwarf::DW_TAG_formal_parameter;
652 case dwarf::DW_TAG_auto_variable: // fall thru
654 Tag = dwarf::DW_TAG_variable;
658 // Define variable debug information entry.
659 DIE *VariableDie = new DIE(Tag);
660 CompileUnit *VariableCU = getCompileUnit(DV->getVariable());
662 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
663 V2AVI = VarToAbstractVarMap.find(DV);
664 if (V2AVI != VarToAbstractVarMap.end())
665 AbsDIE = V2AVI->second->getDIE();
668 VariableCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
669 dwarf::DW_FORM_ref4, AbsDIE);
671 VariableCU->addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
673 VariableCU->addSourceLine(VariableDie, DV->getVariable());
675 // Add variable type.
676 VariableCU->addType(VariableDie, DV->getType());
679 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
680 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
681 dwarf::DW_FORM_flag, 1);
682 else if (DIVariable(DV->getVariable()).isArtificial())
683 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
684 dwarf::DW_FORM_flag, 1);
686 if (Scope->isAbstractScope()) {
687 DV->setDIE(VariableDie);
691 // Add variable address.
693 unsigned Offset = DV->getDotDebugLocOffset();
695 VariableCU->addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
696 Asm->GetTempSymbol("debug_loc", Offset));
697 DV->setDIE(VariableDie);
698 UseDotDebugLocEntry.insert(VariableDie);
702 // Check if variable is described by a DBG_VALUE instruction.
703 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
704 DbgVariableToDbgInstMap.find(DV);
705 if (DVI != DbgVariableToDbgInstMap.end()) {
706 const MachineInstr *DVInsn = DVI->second;
707 bool updated = false;
708 // FIXME : Handle getNumOperands != 3
709 if (DVInsn->getNumOperands() == 3) {
710 if (DVInsn->getOperand(0).isReg()) {
711 const MachineOperand RegOp = DVInsn->getOperand(0);
712 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
713 if (DVInsn->getOperand(1).isImm() &&
714 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
715 unsigned FrameReg = 0;
716 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
718 TFI->getFrameIndexReference(*Asm->MF,
719 DVInsn->getOperand(1).getImm(),
721 MachineLocation Location(FrameReg, Offset);
722 VariableCU->addVariableAddress(DV, VariableDie, Location);
724 } else if (RegOp.getReg())
725 VariableCU->addVariableAddress(DV, VariableDie,
726 MachineLocation(RegOp.getReg()));
729 else if (DVInsn->getOperand(0).isImm())
731 VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0),
733 else if (DVInsn->getOperand(0).isFPImm())
735 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
736 else if (DVInsn->getOperand(0).isCImm())
738 VariableCU->addConstantValue(VariableDie,
739 DVInsn->getOperand(0).getCImm(),
740 isUnsignedDIType(DV->getType()));
742 VariableCU->addVariableAddress(DV, VariableDie,
743 Asm->getDebugValueLocation(DVInsn));
747 // If variableDie is not updated then DBG_VALUE instruction does not
748 // have valid variable info.
752 DV->setDIE(VariableDie);
756 // .. else use frame index, if available.
758 if (findVariableFrameIndex(DV, &FI)) {
759 unsigned FrameReg = 0;
760 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
762 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
763 MachineLocation Location(FrameReg, Offset);
764 VariableCU->addVariableAddress(DV, VariableDie, Location);
767 DV->setDIE(VariableDie);
772 /// constructScopeDIE - Construct a DIE for this scope.
773 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
774 if (!Scope || !Scope->getScopeNode())
777 SmallVector <DIE *, 8> Children;
779 // Collect arguments for current function.
780 if (Scope == CurrentFnDbgScope)
781 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
782 if (DbgVariable *ArgDV = CurrentFnArguments[i])
783 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
784 Children.push_back(Arg);
786 // Collect lexical scope childrens first.
787 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
788 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
789 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
790 Children.push_back(Variable);
791 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
792 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
793 if (DIE *Nested = constructScopeDIE(Scopes[j]))
794 Children.push_back(Nested);
795 DIScope DS(Scope->getScopeNode());
796 DIE *ScopeDIE = NULL;
797 if (Scope->getInlinedAt())
798 ScopeDIE = constructInlinedScopeDIE(Scope);
799 else if (DS.isSubprogram()) {
800 ProcessedSPNodes.insert(DS);
801 if (Scope->isAbstractScope()) {
802 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
803 // Note down abstract DIE.
805 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
808 ScopeDIE = updateSubprogramScopeDIE(DS);
811 // There is no need to emit empty lexical block DIE.
812 if (Children.empty())
814 ScopeDIE = constructLexicalScopeDIE(Scope);
817 if (!ScopeDIE) return NULL;
820 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
821 E = Children.end(); I != E; ++I)
822 ScopeDIE->addChild(*I);
824 if (DS.isSubprogram())
825 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
830 /// GetOrCreateSourceID - Look up the source id with the given directory and
831 /// source file names. If none currently exists, create a new id and insert it
832 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
835 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
837 // If FE did not provide a file name, then assume stdin.
838 if (FileName.empty())
839 return GetOrCreateSourceID("<stdin>", StringRef());
841 // MCStream expects full path name as filename.
842 if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
843 SmallString<128> FullPathName = DirName;
844 sys::path::append(FullPathName, FileName);
845 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
846 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
849 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
850 if (Entry.getValue())
851 return Entry.getValue();
853 unsigned SrcId = SourceIdMap.size();
854 Entry.setValue(SrcId);
856 // Print out a .file directive to specify files for .loc directives.
857 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
862 /// constructCompileUnit - Create new CompileUnit for the given
863 /// metadata node with tag DW_TAG_compile_unit.
864 void DwarfDebug::constructCompileUnit(const MDNode *N) {
865 DICompileUnit DIUnit(N);
866 StringRef FN = DIUnit.getFilename();
867 StringRef Dir = DIUnit.getDirectory();
868 unsigned ID = GetOrCreateSourceID(FN, Dir);
870 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
871 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
872 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
873 DIUnit.getProducer());
874 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
875 DIUnit.getLanguage());
876 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
877 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
878 // simplifies debug range entries.
879 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
880 // DW_AT_stmt_list is a offset of line number information for this
881 // compile unit in debug_line section.
882 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
883 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
884 Asm->GetTempSymbol("section_line"));
886 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
889 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
890 if (DIUnit.isOptimized())
891 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
893 StringRef Flags = DIUnit.getFlags();
895 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
897 unsigned RVer = DIUnit.getRunTimeVersion();
899 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
900 dwarf::DW_FORM_data1, RVer);
904 CUMap.insert(std::make_pair(N, NewCU));
907 /// getCompielUnit - Get CompileUnit DIE.
908 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
909 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
911 const MDNode *CUNode = NULL;
912 if (D.isCompileUnit())
914 else if (D.isSubprogram())
915 CUNode = DISubprogram(N).getCompileUnit();
917 CUNode = DIType(N).getCompileUnit();
918 else if (D.isGlobalVariable())
919 CUNode = DIGlobalVariable(N).getCompileUnit();
920 else if (D.isVariable())
921 CUNode = DIVariable(N).getCompileUnit();
922 else if (D.isNameSpace())
923 CUNode = DINameSpace(N).getCompileUnit();
925 CUNode = DIFile(N).getCompileUnit();
929 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
930 = CUMap.find(CUNode);
931 if (I == CUMap.end())
936 // Return const exprssion if value is a GEP to access merged global
938 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
939 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
940 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
941 if (!CE || CE->getNumOperands() != 3 ||
942 CE->getOpcode() != Instruction::GetElementPtr)
945 // First operand points to a global value.
946 if (!isa<GlobalValue>(CE->getOperand(0)))
949 // Second operand is zero.
950 const ConstantInt *CI =
951 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
952 if (!CI || !CI->isZero())
955 // Third operand is offset.
956 if (!isa<ConstantInt>(CE->getOperand(2)))
962 /// constructGlobalVariableDIE - Construct global variable DIE.
963 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
964 DIGlobalVariable GV(N);
966 // If debug information is malformed then ignore it.
967 if (GV.Verify() == false)
970 // Check for pre-existence.
971 CompileUnit *TheCU = getCompileUnit(N);
972 if (TheCU->getDIE(GV))
975 DIType GTy = GV.getType();
976 DIE *VariableDIE = new DIE(GV.getTag());
978 bool isGlobalVariable = GV.getGlobal() != NULL;
981 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
982 GV.getDisplayName());
983 StringRef LinkageName = GV.getLinkageName();
984 if (!LinkageName.empty() && isGlobalVariable)
985 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
986 dwarf::DW_FORM_string,
987 getRealLinkageName(LinkageName));
989 TheCU->addType(VariableDIE, GTy);
992 if (!GV.isLocalToUnit()) {
993 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
995 TheCU->addGlobal(GV.getName(), VariableDIE);
997 // Add line number info.
998 TheCU->addSourceLine(VariableDIE, GV);
1000 TheCU->insertDIE(N, VariableDIE);
1001 // Add to context owner.
1002 DIDescriptor GVContext = GV.getContext();
1003 TheCU->addToContextOwner(VariableDIE, GVContext);
1005 if (isGlobalVariable) {
1006 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1007 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1008 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1009 Asm->Mang->getSymbol(GV.getGlobal()));
1010 // Do not create specification DIE if context is either compile unit
1012 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1013 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1014 // Create specification DIE.
1015 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1016 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1017 dwarf::DW_FORM_ref4, VariableDIE);
1018 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1019 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1020 TheCU->addDie(VariableSpecDIE);
1022 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1024 } else if (const ConstantInt *CI =
1025 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1026 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1027 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1028 // GV is a merged global.
1029 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1030 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1031 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1032 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1033 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1034 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1035 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1036 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1037 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1043 /// construct SubprogramDIE - Construct subprogram DIE.
1044 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1047 // Check for pre-existence.
1048 CompileUnit *TheCU = getCompileUnit(N);
1049 if (TheCU->getDIE(N))
1052 if (!SP.isDefinition())
1053 // This is a method declaration which will be handled while constructing
1057 DIE *SubprogramDie = createSubprogramDIE(SP);
1060 TheCU->insertDIE(N, SubprogramDie);
1062 // Add to context owner.
1063 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1065 // Expose as global.
1066 TheCU->addGlobal(SP.getName(), SubprogramDie);
1071 /// beginModule - Emit all Dwarf sections that should come prior to the
1072 /// content. Create global DIEs and emit initial debug info sections.
1073 /// This is inovked by the target AsmPrinter.
1074 void DwarfDebug::beginModule(Module *M) {
1075 if (DisableDebugInfoPrinting)
1078 // If module has named metadata anchors then use them, otherwise scan the module
1079 // using debug info finder to collect debug info.
1080 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1083 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1084 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1085 if (!GV_Nodes && !SP_Nodes)
1086 // If there are not any global variables or any functions then
1087 // there is not any debug info in this module.
1090 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1091 constructCompileUnit(CU_Nodes->getOperand(i));
1094 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1095 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1098 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1099 constructSubprogramDIE(SP_Nodes->getOperand(i));
1103 DebugInfoFinder DbgFinder;
1104 DbgFinder.processModule(*M);
1106 bool HasDebugInfo = false;
1107 // Scan all the compile-units to see if there are any marked as the main unit.
1108 // if not, we do not generate debug info.
1109 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1110 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1111 if (DICompileUnit(*I).isMain()) {
1112 HasDebugInfo = true;
1116 if (!HasDebugInfo) return;
1118 // Create all the compile unit DIEs.
1119 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1120 E = DbgFinder.compile_unit_end(); I != E; ++I)
1121 constructCompileUnit(*I);
1123 // Create DIEs for each global variable.
1124 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1125 E = DbgFinder.global_variable_end(); I != E; ++I)
1126 constructGlobalVariableDIE(*I);
1128 // Create DIEs for each subprogram.
1129 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1130 E = DbgFinder.subprogram_end(); I != E; ++I)
1131 constructSubprogramDIE(*I);
1134 // Tell MMI that we have debug info.
1135 MMI->setDebugInfoAvailability(true);
1137 // Emit initial sections.
1138 EmitSectionLabels();
1140 //getOrCreateTypeDIE
1141 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1142 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1143 DIType Ty(NMD->getOperand(i));
1144 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1147 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1148 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1149 DIType Ty(NMD->getOperand(i));
1150 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1153 // Prime section data.
1154 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1157 /// endModule - Emit all Dwarf sections that should come after the content.
1159 void DwarfDebug::endModule() {
1160 if (!FirstCU) return;
1161 const Module *M = MMI->getModule();
1162 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1163 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1164 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1165 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1166 DISubprogram SP(AllSPs->getOperand(SI));
1167 if (!SP.Verify()) continue;
1169 // Collect info for variables that were optimized out.
1170 if (!SP.isDefinition()) continue;
1171 StringRef FName = SP.getLinkageName();
1173 FName = SP.getName();
1174 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1176 unsigned E = NMD->getNumOperands();
1178 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1179 DeadFnScopeMap[SP] = Scope;
1180 for (unsigned I = 0; I != E; ++I) {
1181 DIVariable DV(NMD->getOperand(I));
1182 if (!DV.Verify()) continue;
1183 Scope->addVariable(new DbgVariable(DV));
1186 // Construct subprogram DIE and add variables DIEs.
1187 constructSubprogramDIE(SP);
1188 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1189 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1190 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1191 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1193 ScopeDIE->addChild(VariableDIE);
1198 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1199 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1200 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1202 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1205 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1206 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1207 DIE *SPDie = CI->first;
1208 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1210 DIE *NDie = getCompileUnit(N)->getDIE(N);
1211 if (!NDie) continue;
1212 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1213 dwarf::DW_FORM_ref4, NDie);
1216 // Standard sections final addresses.
1217 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1218 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1219 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1220 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1222 // End text sections.
1223 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1224 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1225 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1228 // Compute DIE offsets and sizes.
1229 computeSizeAndOffsets();
1231 // Emit all the DIEs into a debug info section
1234 // Corresponding abbreviations into a abbrev section.
1235 emitAbbreviations();
1237 // Emit info into a debug pubnames section.
1238 emitDebugPubNames();
1240 // Emit info into a debug pubtypes section.
1241 emitDebugPubTypes();
1243 // Emit info into a debug loc section.
1246 // Emit info into a debug aranges section.
1249 // Emit info into a debug ranges section.
1252 // Emit info into a debug macinfo section.
1255 // Emit inline info.
1256 emitDebugInlineInfo();
1258 // Emit info into a debug str section.
1262 DeleteContainerSeconds(DeadFnScopeMap);
1263 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1264 E = CUMap.end(); I != E; ++I)
1266 FirstCU = NULL; // Reset for the next Module, if any.
1269 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1270 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1271 DebugLoc ScopeLoc) {
1273 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1275 return AbsDbgVariable;
1277 LLVMContext &Ctx = Var->getContext();
1278 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1282 AbsDbgVariable = new DbgVariable(Var);
1283 Scope->addVariable(AbsDbgVariable);
1284 AbstractVariables[Var] = AbsDbgVariable;
1285 return AbsDbgVariable;
1288 /// addCurrentFnArgument - If Var is an current function argument that add
1289 /// it in CurrentFnArguments list.
1290 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1291 DbgVariable *Var, DbgScope *Scope) {
1292 if (Scope != CurrentFnDbgScope)
1294 DIVariable DV = Var->getVariable();
1295 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1297 unsigned ArgNo = DV.getArgNumber();
1301 size_t Size = CurrentFnArguments.size();
1303 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1304 // llvm::Function argument size is not good indicator of how many
1305 // arguments does the function have at source level.
1307 CurrentFnArguments.resize(ArgNo * 2);
1308 CurrentFnArguments[ArgNo - 1] = Var;
1312 /// collectVariableInfoFromMMITable - Collect variable information from
1313 /// side table maintained by MMI.
1315 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1316 SmallPtrSet<const MDNode *, 16> &Processed) {
1317 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1318 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1319 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1320 VE = VMap.end(); VI != VE; ++VI) {
1321 const MDNode *Var = VI->first;
1323 Processed.insert(Var);
1325 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1327 DbgScope *Scope = 0;
1328 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
1329 Scope = ConcreteScopes.lookup(IA);
1331 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
1333 // If variable scope is not found then skip this variable.
1337 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1338 DbgVariable *RegVar = new DbgVariable(DV);
1339 recordVariableFrameIndex(RegVar, VP.first);
1340 if (!addCurrentFnArgument(MF, RegVar, Scope))
1341 Scope->addVariable(RegVar);
1342 if (AbsDbgVariable) {
1343 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1344 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1349 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1350 /// DBG_VALUE instruction, is in a defined reg.
1351 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1352 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1353 return MI->getNumOperands() == 3 &&
1354 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1355 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1358 /// getDebugLocEntry - Get .debug_loc entry for the instraction range starting
1360 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1361 const MCSymbol *FLabel,
1362 const MCSymbol *SLabel,
1363 const MachineInstr *MI) {
1364 const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1366 if (MI->getNumOperands() != 3) {
1367 MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1368 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1370 if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1371 MachineLocation MLoc;
1372 MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1373 return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1375 if (MI->getOperand(0).isImm())
1376 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1377 if (MI->getOperand(0).isFPImm())
1378 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1379 if (MI->getOperand(0).isCImm())
1380 return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1382 assert (0 && "Unexpected 3 operand DBG_VALUE instruction!");
1383 return DotDebugLocEntry();
1386 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1388 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1389 SmallPtrSet<const MDNode *, 16> &Processed) {
1391 /// collection info from MMI table.
1392 collectVariableInfoFromMMITable(MF, Processed);
1394 for (SmallVectorImpl<const MDNode*>::const_iterator
1395 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1397 const MDNode *Var = *UVI;
1398 if (Processed.count(Var))
1401 // History contains relevant DBG_VALUE instructions for Var and instructions
1403 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1404 if (History.empty())
1406 const MachineInstr *MInsn = History.front();
1409 DbgScope *Scope = NULL;
1410 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1411 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1412 Scope = CurrentFnDbgScope;
1414 Scope = findDbgScope(MInsn);
1415 // If variable scope is not found then skip this variable.
1419 Processed.insert(DV);
1420 assert(MInsn->isDebugValue() && "History must begin with debug value");
1421 DbgVariable *RegVar = new DbgVariable(DV);
1422 if (!addCurrentFnArgument(MF, RegVar, Scope))
1423 Scope->addVariable(RegVar);
1424 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1425 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1426 VarToAbstractVarMap[RegVar] = AbsVar;
1429 // Simple ranges that are fully coalesced.
1430 if (History.size() <= 1 || (History.size() == 2 &&
1431 MInsn->isIdenticalTo(History.back()))) {
1432 DbgVariableToDbgInstMap[RegVar] = MInsn;
1436 // handle multiple DBG_VALUE instructions describing one variable.
1437 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1439 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1440 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1441 const MachineInstr *Begin = *HI;
1442 assert(Begin->isDebugValue() && "Invalid History entry");
1444 // Check if DBG_VALUE is truncating a range.
1445 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1446 && !Begin->getOperand(0).getReg())
1449 // Compute the range for a register location.
1450 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1451 const MCSymbol *SLabel = 0;
1454 // If Begin is the last instruction in History then its value is valid
1455 // until the end of the function.
1456 SLabel = FunctionEndSym;
1458 const MachineInstr *End = HI[1];
1459 DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1460 << "\t" << *Begin << "\t" << *End << "\n");
1461 if (End->isDebugValue())
1462 SLabel = getLabelBeforeInsn(End);
1464 // End is a normal instruction clobbering the range.
1465 SLabel = getLabelAfterInsn(End);
1466 assert(SLabel && "Forgot label after clobber instruction");
1471 // The value is valid until the next DBG_VALUE or clobber.
1472 DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1474 DotDebugLocEntries.push_back(DotDebugLocEntry());
1477 // Collect info for variables that were optimized out.
1478 const Function *F = MF->getFunction();
1479 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1480 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1481 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1482 if (!DV || !Processed.insert(DV))
1484 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1486 Scope->addVariable(new DbgVariable(DV));
1491 /// getLabelBeforeInsn - Return Label preceding the instruction.
1492 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1493 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1494 assert(Label && "Didn't insert label before instruction");
1498 /// getLabelAfterInsn - Return Label immediately following the instruction.
1499 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1500 return LabelsAfterInsn.lookup(MI);
1503 /// beginInstruction - Process beginning of an instruction.
1504 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1505 // Check if source location changes, but ignore DBG_VALUE locations.
1506 if (!MI->isDebugValue()) {
1507 DebugLoc DL = MI->getDebugLoc();
1508 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1509 unsigned Flags = DWARF2_FLAG_IS_STMT;
1511 if (DL == PrologEndLoc) {
1512 Flags |= DWARF2_FLAG_PROLOGUE_END;
1513 PrologEndLoc = DebugLoc();
1515 if (!DL.isUnknown()) {
1516 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1517 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1519 recordSourceLine(0, 0, 0, 0);
1523 // Insert labels where requested.
1524 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1525 LabelsBeforeInsn.find(MI);
1528 if (I == LabelsBeforeInsn.end())
1531 // Label already assigned.
1536 PrevLabel = MMI->getContext().CreateTempSymbol();
1537 Asm->OutStreamer.EmitLabel(PrevLabel);
1539 I->second = PrevLabel;
1542 /// endInstruction - Process end of an instruction.
1543 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1544 // Don't create a new label after DBG_VALUE instructions.
1545 // They don't generate code.
1546 if (!MI->isDebugValue())
1549 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1550 LabelsAfterInsn.find(MI);
1553 if (I == LabelsAfterInsn.end())
1556 // Label already assigned.
1560 // We need a label after this instruction.
1562 PrevLabel = MMI->getContext().CreateTempSymbol();
1563 Asm->OutStreamer.EmitLabel(PrevLabel);
1565 I->second = PrevLabel;
1568 /// getOrCreateDbgScope - Create DbgScope for the scope.
1569 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
1570 const MDNode *InlinedAt) {
1572 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1575 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1576 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1577 if (DIDescriptor(Scope).isLexicalBlock()) {
1579 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
1580 WScope->setParent(Parent);
1581 Parent->addScope(WScope);
1584 if (!WScope->getParent()) {
1585 StringRef SPName = DISubprogram(Scope).getLinkageName();
1586 // We used to check only for a linkage name, but that fails
1587 // since we began omitting the linkage name for private
1588 // functions. The new way is to check for the name in metadata,
1589 // but that's not supported in old .ll test cases. Ergo, we
1591 if (SPName == Asm->MF->getFunction()->getName() ||
1592 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
1593 CurrentFnDbgScope = WScope;
1599 getOrCreateAbstractScope(Scope);
1600 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1604 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1605 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1606 DILocation DL(InlinedAt);
1608 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
1609 WScope->setParent(Parent);
1610 Parent->addScope(WScope);
1612 ConcreteScopes[InlinedAt] = WScope;
1617 /// hasValidLocation - Return true if debug location entry attached with
1618 /// machine instruction encodes valid location info.
1619 static bool hasValidLocation(LLVMContext &Ctx,
1620 const MachineInstr *MInsn,
1621 const MDNode *&Scope, const MDNode *&InlinedAt) {
1622 DebugLoc DL = MInsn->getDebugLoc();
1623 if (DL.isUnknown()) return false;
1625 const MDNode *S = DL.getScope(Ctx);
1627 // There is no need to create another DIE for compile unit. For all
1628 // other scopes, create one DbgScope now. This will be translated
1629 // into a scope DIE at the end.
1630 if (DIScope(S).isCompileUnit()) return false;
1633 InlinedAt = DL.getInlinedAt(Ctx);
1637 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1639 static void calculateDominanceGraph(DbgScope *Scope) {
1640 assert (Scope && "Unable to calculate scop edominance graph!");
1641 SmallVector<DbgScope *, 4> WorkStack;
1642 WorkStack.push_back(Scope);
1643 unsigned Counter = 0;
1644 while (!WorkStack.empty()) {
1645 DbgScope *WS = WorkStack.back();
1646 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1647 bool visitedChildren = false;
1648 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1649 SE = Children.end(); SI != SE; ++SI) {
1650 DbgScope *ChildScope = *SI;
1651 if (!ChildScope->getDFSOut()) {
1652 WorkStack.push_back(ChildScope);
1653 visitedChildren = true;
1654 ChildScope->setDFSIn(++Counter);
1658 if (!visitedChildren) {
1659 WorkStack.pop_back();
1660 WS->setDFSOut(++Counter);
1665 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1667 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1668 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1671 unsigned PrevDFSIn = 0;
1672 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1674 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1676 const MachineInstr *MInsn = II;
1677 const MDNode *Scope = NULL;
1678 const MDNode *InlinedAt = NULL;
1680 // Check if instruction has valid location information.
1681 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1685 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1686 MI2ScopeMap.find(MInsn);
1687 if (DI != MI2ScopeMap.end()) {
1688 DbgScope *S = DI->second;
1689 dbgs() << S->getDFSIn();
1690 PrevDFSIn = S->getDFSIn();
1692 dbgs() << PrevDFSIn;
1694 dbgs() << " [ x" << PrevDFSIn;
1702 /// extractScopeInformation - Scan machine instructions in this function
1703 /// and collect DbgScopes. Return true, if at least one scope was found.
1704 bool DwarfDebug::extractScopeInformation() {
1705 // If scope information was extracted using .dbg intrinsics then there is not
1706 // any need to extract these information by scanning each instruction.
1707 if (!DbgScopeMap.empty())
1710 // Scan each instruction and create scopes. First build working set of scopes.
1711 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1712 SmallVector<DbgRange, 4> MIRanges;
1713 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1714 const MDNode *PrevScope = NULL;
1715 const MDNode *PrevInlinedAt = NULL;
1716 const MachineInstr *RangeBeginMI = NULL;
1717 const MachineInstr *PrevMI = NULL;
1718 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1720 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1722 const MachineInstr *MInsn = II;
1723 const MDNode *Scope = NULL;
1724 const MDNode *InlinedAt = NULL;
1726 // Check if instruction has valid location information.
1727 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1732 // If scope has not changed then skip this instruction.
1733 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
1738 // Ignore DBG_VALUE. It does not contribute any instruction in output.
1739 if (MInsn->isDebugValue())
1743 // If we have alread seen a beginning of a instruction range and
1744 // current instruction scope does not match scope of first instruction
1745 // in this range then create a new instruction range.
1746 DEBUG(dbgs() << "Creating new instruction range :\n");
1747 DEBUG(dbgs() << "Begin Range at " << *RangeBeginMI);
1748 DEBUG(dbgs() << "End Range at " << *PrevMI);
1749 DEBUG(dbgs() << "Next Range starting at " << *MInsn);
1750 DEBUG(dbgs() << "------------------------\n");
1751 DbgRange R(RangeBeginMI, PrevMI);
1752 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
1754 MIRanges.push_back(R);
1757 // This is a beginning of a new instruction range.
1758 RangeBeginMI = MInsn;
1760 // Reset previous markers.
1763 PrevInlinedAt = InlinedAt;
1767 // Create last instruction range.
1768 if (RangeBeginMI && PrevMI && PrevScope) {
1769 DbgRange R(RangeBeginMI, PrevMI);
1770 MIRanges.push_back(R);
1771 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
1774 if (!CurrentFnDbgScope)
1777 calculateDominanceGraph(CurrentFnDbgScope);
1779 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1781 // Find ranges of instructions covered by each DbgScope;
1782 DbgScope *PrevDbgScope = NULL;
1783 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1784 RE = MIRanges.end(); RI != RE; ++RI) {
1785 const DbgRange &R = *RI;
1786 DbgScope *S = MI2ScopeMap.lookup(R.first);
1787 assert (S && "Lost DbgScope for a machine instruction!");
1788 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1789 PrevDbgScope->closeInsnRange(S);
1790 S->openInsnRange(R.first);
1791 S->extendInsnRange(R.second);
1796 PrevDbgScope->closeInsnRange();
1798 identifyScopeMarkers();
1800 return !DbgScopeMap.empty();
1803 /// identifyScopeMarkers() -
1804 /// Each DbgScope has first instruction and last instruction to mark beginning
1805 /// and end of a scope respectively. Create an inverse map that list scopes
1806 /// starts (and ends) with an instruction. One instruction may start (or end)
1807 /// multiple scopes. Ignore scopes that are not reachable.
1808 void DwarfDebug::identifyScopeMarkers() {
1809 SmallVector<DbgScope *, 4> WorkList;
1810 WorkList.push_back(CurrentFnDbgScope);
1811 while (!WorkList.empty()) {
1812 DbgScope *S = WorkList.pop_back_val();
1814 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1815 if (!Children.empty())
1816 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1817 SE = Children.end(); SI != SE; ++SI)
1818 WorkList.push_back(*SI);
1820 if (S->isAbstractScope())
1823 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1826 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1827 RE = Ranges.end(); RI != RE; ++RI) {
1828 assert(RI->first && "DbgRange does not have first instruction!");
1829 assert(RI->second && "DbgRange does not have second instruction!");
1830 requestLabelBeforeInsn(RI->first);
1831 requestLabelAfterInsn(RI->second);
1836 /// getScopeNode - Get MDNode for DebugLoc's scope.
1837 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1838 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1839 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1840 return DL.getScope(Ctx);
1843 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1844 /// line number info for the function.
1845 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1846 const MDNode *Scope = getScopeNode(DL, Ctx);
1847 DISubprogram SP = getDISubprogram(Scope);
1849 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1853 /// beginFunction - Gather pre-function debug information. Assumes being
1854 /// emitted immediately after the function entry point.
1855 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1856 if (!MMI->hasDebugInfo()) return;
1857 if (!extractScopeInformation()) return;
1859 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1860 Asm->getFunctionNumber());
1861 // Assumes in correct section after the entry point.
1862 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1864 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1866 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1867 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1868 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1870 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1872 bool AtBlockEntry = true;
1873 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1875 const MachineInstr *MI = II;
1877 if (MI->isDebugValue()) {
1878 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1880 // Keep track of user variables.
1882 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1884 // Variable is in a register, we need to check for clobbers.
1885 if (isDbgValueInDefinedReg(MI))
1886 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1888 // Check the history of this variable.
1889 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1890 if (History.empty()) {
1891 UserVariables.push_back(Var);
1892 // The first mention of a function argument gets the FunctionBeginSym
1893 // label, so arguments are visible when breaking at function entry.
1895 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1896 DISubprogram(getDISubprogram(DV.getContext()))
1897 .describes(MF->getFunction()))
1898 LabelsBeforeInsn[MI] = FunctionBeginSym;
1900 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1901 const MachineInstr *Prev = History.back();
1902 if (Prev->isDebugValue()) {
1903 // Coalesce identical entries at the end of History.
1904 if (History.size() >= 2 &&
1905 Prev->isIdenticalTo(History[History.size() - 2])) {
1906 DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1908 << "\t" << *History[History.size() - 2] << "\n");
1912 // Terminate old register assignments that don't reach MI;
1913 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1914 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1915 isDbgValueInDefinedReg(Prev)) {
1916 // Previous register assignment needs to terminate at the end of
1918 MachineBasicBlock::const_iterator LastMI =
1919 PrevMBB->getLastNonDebugInstr();
1920 if (LastMI == PrevMBB->end()) {
1921 // Drop DBG_VALUE for empty range.
1922 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1923 << "\t" << *Prev << "\n");
1927 // Terminate after LastMI.
1928 History.push_back(LastMI);
1933 History.push_back(MI);
1935 // Not a DBG_VALUE instruction.
1937 AtBlockEntry = false;
1939 // First known non DBG_VALUE location marks beginning of function
1941 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1942 PrologEndLoc = MI->getDebugLoc();
1944 // Check if the instruction clobbers any registers with debug vars.
1945 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1946 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1947 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1949 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1950 unsigned Reg = *AI; ++AI) {
1951 const MDNode *Var = LiveUserVar[Reg];
1954 // Reg is now clobbered.
1955 LiveUserVar[Reg] = 0;
1957 // Was MD last defined by a DBG_VALUE referring to Reg?
1958 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1959 if (HistI == DbgValues.end())
1961 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1962 if (History.empty())
1964 const MachineInstr *Prev = History.back();
1965 // Sanity-check: Register assignments are terminated at the end of
1967 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1969 // Is the variable still in Reg?
1970 if (!isDbgValueInDefinedReg(Prev) ||
1971 Prev->getOperand(0).getReg() != Reg)
1973 // Var is clobbered. Make sure the next instruction gets a label.
1974 History.push_back(MI);
1981 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1983 SmallVectorImpl<const MachineInstr*> &History = I->second;
1984 if (History.empty())
1987 // Make sure the final register assignments are terminated.
1988 const MachineInstr *Prev = History.back();
1989 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1990 const MachineBasicBlock *PrevMBB = Prev->getParent();
1991 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1992 if (LastMI == PrevMBB->end())
1993 // Drop DBG_VALUE for empty range.
1996 // Terminate after LastMI.
1997 History.push_back(LastMI);
2000 // Request labels for the full history.
2001 for (unsigned i = 0, e = History.size(); i != e; ++i) {
2002 const MachineInstr *MI = History[i];
2003 if (MI->isDebugValue())
2004 requestLabelBeforeInsn(MI);
2006 requestLabelAfterInsn(MI);
2010 PrevInstLoc = DebugLoc();
2011 PrevLabel = FunctionBeginSym;
2013 // Record beginning of function.
2014 if (!PrologEndLoc.isUnknown()) {
2015 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
2016 MF->getFunction()->getContext());
2017 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
2018 FnStartDL.getScope(MF->getFunction()->getContext()),
2019 DWARF2_FLAG_IS_STMT);
2023 /// endFunction - Gather and emit post-function debug information.
2025 void DwarfDebug::endFunction(const MachineFunction *MF) {
2026 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2028 if (CurrentFnDbgScope) {
2030 // Define end label for subprogram.
2031 FunctionEndSym = Asm->GetTempSymbol("func_end",
2032 Asm->getFunctionNumber());
2033 // Assumes in correct section after the entry point.
2034 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2036 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2037 collectVariableInfo(MF, ProcessedVars);
2039 // Construct abstract scopes.
2040 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2041 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2042 DISubprogram SP((*AI)->getScopeNode());
2044 // Collect info for variables that were optimized out.
2045 StringRef FName = SP.getLinkageName();
2047 FName = SP.getName();
2048 if (NamedMDNode *NMD =
2049 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2050 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2051 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2052 if (!DV || !ProcessedVars.insert(DV))
2054 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2056 Scope->addVariable(new DbgVariable(DV));
2060 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2061 constructScopeDIE(*AI);
2064 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2066 if (!DisableFramePointerElim(*MF))
2067 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2068 dwarf::DW_AT_APPLE_omit_frame_ptr,
2069 dwarf::DW_FORM_flag, 1);
2072 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2073 MMI->getFrameMoves()));
2077 CurrentFnDbgScope = NULL;
2078 DeleteContainerPointers(CurrentFnArguments);
2079 DbgVariableToFrameIndexMap.clear();
2080 VarToAbstractVarMap.clear();
2081 DbgVariableToDbgInstMap.clear();
2082 DeleteContainerSeconds(DbgScopeMap);
2083 UserVariables.clear();
2085 ConcreteScopes.clear();
2086 DeleteContainerSeconds(AbstractScopes);
2087 AbstractScopesList.clear();
2088 AbstractVariables.clear();
2089 LabelsBeforeInsn.clear();
2090 LabelsAfterInsn.clear();
2094 /// recordVariableFrameIndex - Record a variable's index.
2095 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2096 assert (V && "Invalid DbgVariable!");
2097 DbgVariableToFrameIndexMap[V] = Index;
2100 /// findVariableFrameIndex - Return true if frame index for the variable
2101 /// is found. Update FI to hold value of the index.
2102 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2103 assert (V && "Invalid DbgVariable!");
2104 DenseMap<const DbgVariable *, int>::iterator I =
2105 DbgVariableToFrameIndexMap.find(V);
2106 if (I == DbgVariableToFrameIndexMap.end())
2112 /// findDbgScope - Find DbgScope for the debug loc attached with an
2114 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2115 DbgScope *Scope = NULL;
2117 MInsn->getParent()->getParent()->getFunction()->getContext();
2118 DebugLoc DL = MInsn->getDebugLoc();
2123 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2124 Scope = ConcreteScopes.lookup(IA);
2126 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2132 /// recordSourceLine - Register a source line with debug info. Returns the
2133 /// unique label that was emitted and which provides correspondence to
2134 /// the source line list.
2135 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2141 DIDescriptor Scope(S);
2143 if (Scope.isCompileUnit()) {
2144 DICompileUnit CU(S);
2145 Fn = CU.getFilename();
2146 Dir = CU.getDirectory();
2147 } else if (Scope.isFile()) {
2149 Fn = F.getFilename();
2150 Dir = F.getDirectory();
2151 } else if (Scope.isSubprogram()) {
2153 Fn = SP.getFilename();
2154 Dir = SP.getDirectory();
2155 } else if (Scope.isLexicalBlock()) {
2156 DILexicalBlock DB(S);
2157 Fn = DB.getFilename();
2158 Dir = DB.getDirectory();
2160 assert(0 && "Unexpected scope info");
2162 Src = GetOrCreateSourceID(Fn, Dir);
2164 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2168 //===----------------------------------------------------------------------===//
2170 //===----------------------------------------------------------------------===//
2172 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2175 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2176 // Get the children.
2177 const std::vector<DIE *> &Children = Die->getChildren();
2179 // If not last sibling and has children then add sibling offset attribute.
2180 if (!Last && !Children.empty())
2181 Die->addSiblingOffset(DIEValueAllocator);
2183 // Record the abbreviation.
2184 assignAbbrevNumber(Die->getAbbrev());
2186 // Get the abbreviation for this DIE.
2187 unsigned AbbrevNumber = Die->getAbbrevNumber();
2188 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2191 Die->setOffset(Offset);
2193 // Start the size with the size of abbreviation code.
2194 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2196 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2197 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2199 // Size the DIE attribute values.
2200 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2201 // Size attribute value.
2202 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2204 // Size the DIE children if any.
2205 if (!Children.empty()) {
2206 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2207 "Children flag not set");
2209 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2210 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2212 // End of children marker.
2213 Offset += sizeof(int8_t);
2216 Die->setSize(Offset - Die->getOffset());
2220 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2222 void DwarfDebug::computeSizeAndOffsets() {
2223 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2224 E = CUMap.end(); I != E; ++I) {
2225 // Compute size of compile unit header.
2227 sizeof(int32_t) + // Length of Compilation Unit Info
2228 sizeof(int16_t) + // DWARF version number
2229 sizeof(int32_t) + // Offset Into Abbrev. Section
2230 sizeof(int8_t); // Pointer Size (in bytes)
2231 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2235 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2236 /// temporary label to it if SymbolStem is specified.
2237 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2238 const char *SymbolStem = 0) {
2239 Asm->OutStreamer.SwitchSection(Section);
2240 if (!SymbolStem) return 0;
2242 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2243 Asm->OutStreamer.EmitLabel(TmpSym);
2247 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2248 /// the start of each one.
2249 void DwarfDebug::EmitSectionLabels() {
2250 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2252 // Dwarf sections base addresses.
2253 DwarfInfoSectionSym =
2254 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2255 DwarfAbbrevSectionSym =
2256 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2257 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2259 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2260 EmitSectionSym(Asm, MacroInfo);
2262 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2263 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2264 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2265 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2266 DwarfStrSectionSym =
2267 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2268 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2271 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2272 "section_debug_loc");
2274 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2275 EmitSectionSym(Asm, TLOF.getDataSection());
2278 /// emitDIE - Recusively Emits a debug information entry.
2280 void DwarfDebug::emitDIE(DIE *Die) {
2281 // Get the abbreviation for this DIE.
2282 unsigned AbbrevNumber = Die->getAbbrevNumber();
2283 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2285 // Emit the code (index) for the abbreviation.
2286 if (Asm->isVerbose())
2287 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2288 Twine::utohexstr(Die->getOffset()) + ":0x" +
2289 Twine::utohexstr(Die->getSize()) + " " +
2290 dwarf::TagString(Abbrev->getTag()));
2291 Asm->EmitULEB128(AbbrevNumber);
2293 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2294 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2296 // Emit the DIE attribute values.
2297 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2298 unsigned Attr = AbbrevData[i].getAttribute();
2299 unsigned Form = AbbrevData[i].getForm();
2300 assert(Form && "Too many attributes for DIE (check abbreviation)");
2302 if (Asm->isVerbose())
2303 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2306 case dwarf::DW_AT_sibling:
2307 Asm->EmitInt32(Die->getSiblingOffset());
2309 case dwarf::DW_AT_abstract_origin: {
2310 DIEEntry *E = cast<DIEEntry>(Values[i]);
2311 DIE *Origin = E->getEntry();
2312 unsigned Addr = Origin->getOffset();
2313 Asm->EmitInt32(Addr);
2316 case dwarf::DW_AT_ranges: {
2317 // DW_AT_range Value encodes offset in debug_range section.
2318 DIEInteger *V = cast<DIEInteger>(Values[i]);
2320 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2321 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2325 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2327 DwarfDebugRangeSectionSym,
2332 case dwarf::DW_AT_location: {
2333 if (UseDotDebugLocEntry.count(Die) != 0) {
2334 DIELabel *L = cast<DIELabel>(Values[i]);
2335 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2337 Values[i]->EmitValue(Asm, Form);
2340 case dwarf::DW_AT_accessibility: {
2341 if (Asm->isVerbose()) {
2342 DIEInteger *V = cast<DIEInteger>(Values[i]);
2343 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2345 Values[i]->EmitValue(Asm, Form);
2349 // Emit an attribute using the defined form.
2350 Values[i]->EmitValue(Asm, Form);
2355 // Emit the DIE children if any.
2356 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2357 const std::vector<DIE *> &Children = Die->getChildren();
2359 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2360 emitDIE(Children[j]);
2362 if (Asm->isVerbose())
2363 Asm->OutStreamer.AddComment("End Of Children Mark");
2368 /// emitDebugInfo - Emit the debug info section.
2370 void DwarfDebug::emitDebugInfo() {
2371 // Start debug info section.
2372 Asm->OutStreamer.SwitchSection(
2373 Asm->getObjFileLowering().getDwarfInfoSection());
2374 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2375 E = CUMap.end(); I != E; ++I) {
2376 CompileUnit *TheCU = I->second;
2377 DIE *Die = TheCU->getCUDie();
2379 // Emit the compile units header.
2380 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2383 // Emit size of content not including length itself
2384 unsigned ContentSize = Die->getSize() +
2385 sizeof(int16_t) + // DWARF version number
2386 sizeof(int32_t) + // Offset Into Abbrev. Section
2387 sizeof(int8_t); // Pointer Size (in bytes)
2389 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2390 Asm->EmitInt32(ContentSize);
2391 Asm->OutStreamer.AddComment("DWARF version number");
2392 Asm->EmitInt16(dwarf::DWARF_VERSION);
2393 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2394 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2395 DwarfAbbrevSectionSym);
2396 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2397 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2400 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2404 /// emitAbbreviations - Emit the abbreviation section.
2406 void DwarfDebug::emitAbbreviations() const {
2407 // Check to see if it is worth the effort.
2408 if (!Abbreviations.empty()) {
2409 // Start the debug abbrev section.
2410 Asm->OutStreamer.SwitchSection(
2411 Asm->getObjFileLowering().getDwarfAbbrevSection());
2413 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2415 // For each abbrevation.
2416 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2417 // Get abbreviation data
2418 const DIEAbbrev *Abbrev = Abbreviations[i];
2420 // Emit the abbrevations code (base 1 index.)
2421 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2423 // Emit the abbreviations data.
2427 // Mark end of abbreviations.
2428 Asm->EmitULEB128(0, "EOM(3)");
2430 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2434 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2435 /// the line matrix.
2437 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2438 // Define last address of section.
2439 Asm->OutStreamer.AddComment("Extended Op");
2442 Asm->OutStreamer.AddComment("Op size");
2443 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2444 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2445 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2447 Asm->OutStreamer.AddComment("Section end label");
2449 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2450 Asm->getTargetData().getPointerSize(),
2453 // Mark end of matrix.
2454 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2460 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2462 void DwarfDebug::emitDebugPubNames() {
2463 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2464 E = CUMap.end(); I != E; ++I) {
2465 CompileUnit *TheCU = I->second;
2466 // Start the dwarf pubnames section.
2467 Asm->OutStreamer.SwitchSection(
2468 Asm->getObjFileLowering().getDwarfPubNamesSection());
2470 Asm->OutStreamer.AddComment("Length of Public Names Info");
2471 Asm->EmitLabelDifference(
2472 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2473 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2475 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2478 Asm->OutStreamer.AddComment("DWARF Version");
2479 Asm->EmitInt16(dwarf::DWARF_VERSION);
2481 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2482 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2483 DwarfInfoSectionSym);
2485 Asm->OutStreamer.AddComment("Compilation Unit Length");
2486 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2487 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2490 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2491 for (StringMap<DIE*>::const_iterator
2492 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2493 const char *Name = GI->getKeyData();
2494 DIE *Entity = GI->second;
2496 Asm->OutStreamer.AddComment("DIE offset");
2497 Asm->EmitInt32(Entity->getOffset());
2499 if (Asm->isVerbose())
2500 Asm->OutStreamer.AddComment("External Name");
2501 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2504 Asm->OutStreamer.AddComment("End Mark");
2506 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2511 void DwarfDebug::emitDebugPubTypes() {
2512 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2513 E = CUMap.end(); I != E; ++I) {
2514 CompileUnit *TheCU = I->second;
2515 // Start the dwarf pubnames section.
2516 Asm->OutStreamer.SwitchSection(
2517 Asm->getObjFileLowering().getDwarfPubTypesSection());
2518 Asm->OutStreamer.AddComment("Length of Public Types Info");
2519 Asm->EmitLabelDifference(
2520 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2521 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2523 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2526 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2527 Asm->EmitInt16(dwarf::DWARF_VERSION);
2529 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2530 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2531 DwarfInfoSectionSym);
2533 Asm->OutStreamer.AddComment("Compilation Unit Length");
2534 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2535 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2538 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2539 for (StringMap<DIE*>::const_iterator
2540 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2541 const char *Name = GI->getKeyData();
2542 DIE * Entity = GI->second;
2544 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2545 Asm->EmitInt32(Entity->getOffset());
2547 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2548 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2551 Asm->OutStreamer.AddComment("End Mark");
2553 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2558 /// emitDebugStr - Emit visible names into a debug str section.
2560 void DwarfDebug::emitDebugStr() {
2561 // Check to see if it is worth the effort.
2562 if (StringPool.empty()) return;
2564 // Start the dwarf str section.
2565 Asm->OutStreamer.SwitchSection(
2566 Asm->getObjFileLowering().getDwarfStrSection());
2568 // Get all of the string pool entries and put them in an array by their ID so
2569 // we can sort them.
2570 SmallVector<std::pair<unsigned,
2571 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2573 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2574 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2575 Entries.push_back(std::make_pair(I->second.second, &*I));
2577 array_pod_sort(Entries.begin(), Entries.end());
2579 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2580 // Emit a label for reference from debug information entries.
2581 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2583 // Emit the string itself.
2584 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2588 /// emitDebugLoc - Emit visible names into a debug loc section.
2590 void DwarfDebug::emitDebugLoc() {
2591 if (DotDebugLocEntries.empty())
2594 for (SmallVector<DotDebugLocEntry, 4>::iterator
2595 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2597 DotDebugLocEntry &Entry = *I;
2598 if (I + 1 != DotDebugLocEntries.end())
2602 // Start the dwarf loc section.
2603 Asm->OutStreamer.SwitchSection(
2604 Asm->getObjFileLowering().getDwarfLocSection());
2605 unsigned char Size = Asm->getTargetData().getPointerSize();
2606 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2608 for (SmallVector<DotDebugLocEntry, 4>::iterator
2609 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2610 I != E; ++I, ++index) {
2611 DotDebugLocEntry &Entry = *I;
2612 if (Entry.isMerged()) continue;
2613 if (Entry.isEmpty()) {
2614 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2615 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2616 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2618 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2619 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2620 DIVariable DV(Entry.Variable);
2621 Asm->OutStreamer.AddComment("Loc expr size");
2622 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2623 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2624 Asm->EmitLabelDifference(end, begin, 2);
2625 Asm->OutStreamer.EmitLabel(begin);
2626 if (Entry.isInt()) {
2627 DIBasicType BTy(DV.getType());
2629 (BTy.getEncoding() == dwarf::DW_ATE_signed
2630 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2631 Asm->OutStreamer.AddComment("DW_OP_consts");
2632 Asm->EmitInt8(dwarf::DW_OP_consts);
2633 Asm->EmitSLEB128(Entry.getInt());
2635 Asm->OutStreamer.AddComment("DW_OP_constu");
2636 Asm->EmitInt8(dwarf::DW_OP_constu);
2637 Asm->EmitULEB128(Entry.getInt());
2639 } else if (Entry.isLocation()) {
2640 if (!DV.hasComplexAddress())
2642 Asm->EmitDwarfRegOp(Entry.Loc);
2644 // Complex address entry.
2645 unsigned N = DV.getNumAddrElements();
2647 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2648 if (Entry.Loc.getOffset()) {
2650 Asm->EmitDwarfRegOp(Entry.Loc);
2651 Asm->OutStreamer.AddComment("DW_OP_deref");
2652 Asm->EmitInt8(dwarf::DW_OP_deref);
2653 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2654 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2655 Asm->EmitSLEB128(DV.getAddrElement(1));
2657 // If first address element is OpPlus then emit
2658 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2659 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2660 Asm->EmitDwarfRegOp(Loc);
2664 Asm->EmitDwarfRegOp(Entry.Loc);
2667 // Emit remaining complex address elements.
2668 for (; i < N; ++i) {
2669 uint64_t Element = DV.getAddrElement(i);
2670 if (Element == DIBuilder::OpPlus) {
2671 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2672 Asm->EmitULEB128(DV.getAddrElement(++i));
2673 } else if (Element == DIBuilder::OpDeref)
2674 Asm->EmitInt8(dwarf::DW_OP_deref);
2675 else llvm_unreachable("unknown Opcode found in complex address");
2679 // else ... ignore constant fp. There is not any good way to
2680 // to represent them here in dwarf.
2681 Asm->OutStreamer.EmitLabel(end);
2686 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2688 void DwarfDebug::EmitDebugARanges() {
2689 // Start the dwarf aranges section.
2690 Asm->OutStreamer.SwitchSection(
2691 Asm->getObjFileLowering().getDwarfARangesSection());
2694 /// emitDebugRanges - Emit visible names into a debug ranges section.
2696 void DwarfDebug::emitDebugRanges() {
2697 // Start the dwarf ranges section.
2698 Asm->OutStreamer.SwitchSection(
2699 Asm->getObjFileLowering().getDwarfRangesSection());
2700 unsigned char Size = Asm->getTargetData().getPointerSize();
2701 for (SmallVector<const MCSymbol *, 8>::iterator
2702 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2705 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2707 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2711 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2713 void DwarfDebug::emitDebugMacInfo() {
2714 if (const MCSection *LineInfo =
2715 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2716 // Start the dwarf macinfo section.
2717 Asm->OutStreamer.SwitchSection(LineInfo);
2721 /// emitDebugInlineInfo - Emit inline info using following format.
2723 /// 1. length of section
2724 /// 2. Dwarf version number
2725 /// 3. address size.
2727 /// Entries (one "entry" for each function that was inlined):
2729 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2730 /// otherwise offset into __debug_str for regular function name.
2731 /// 2. offset into __debug_str section for regular function name.
2732 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2733 /// instances for the function.
2735 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2736 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2737 /// __debug_info section, and the low_pc is the starting address for the
2738 /// inlining instance.
2739 void DwarfDebug::emitDebugInlineInfo() {
2740 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2746 Asm->OutStreamer.SwitchSection(
2747 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2749 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2750 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2751 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2753 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2755 Asm->OutStreamer.AddComment("Dwarf Version");
2756 Asm->EmitInt16(dwarf::DWARF_VERSION);
2757 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2758 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2760 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2761 E = InlinedSPNodes.end(); I != E; ++I) {
2763 const MDNode *Node = *I;
2764 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2765 = InlineInfo.find(Node);
2766 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2767 DISubprogram SP(Node);
2768 StringRef LName = SP.getLinkageName();
2769 StringRef Name = SP.getName();
2771 Asm->OutStreamer.AddComment("MIPS linkage name");
2772 if (LName.empty()) {
2773 Asm->OutStreamer.EmitBytes(Name, 0);
2774 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2776 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2777 DwarfStrSectionSym);
2779 Asm->OutStreamer.AddComment("Function name");
2780 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2781 Asm->EmitULEB128(Labels.size(), "Inline count");
2783 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2784 LE = Labels.end(); LI != LE; ++LI) {
2785 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2786 Asm->EmitInt32(LI->second->getOffset());
2788 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2789 Asm->OutStreamer.EmitSymbolValue(LI->first,
2790 Asm->getTargetData().getPointerSize(),0);
2794 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));