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());
622 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
623 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
624 StringRef Name = DV->getName();
628 // Translate tag to proper Dwarf tag. The result variable is dropped for
631 switch (DV->getTag()) {
632 case dwarf::DW_TAG_return_variable:
634 case dwarf::DW_TAG_arg_variable:
635 Tag = dwarf::DW_TAG_formal_parameter;
637 case dwarf::DW_TAG_auto_variable: // fall thru
639 Tag = dwarf::DW_TAG_variable;
643 // Define variable debug information entry.
644 DIE *VariableDie = new DIE(Tag);
645 CompileUnit *VariableCU = getCompileUnit(DV->getVariable());
647 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
648 V2AVI = VarToAbstractVarMap.find(DV);
649 if (V2AVI != VarToAbstractVarMap.end())
650 AbsDIE = V2AVI->second->getDIE();
653 VariableCU->addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
654 dwarf::DW_FORM_ref4, AbsDIE);
656 VariableCU->addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
658 VariableCU->addSourceLine(VariableDie, DV->getVariable());
660 // Add variable type.
661 VariableCU->addType(VariableDie, DV->getType());
664 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
665 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
666 dwarf::DW_FORM_flag, 1);
667 else if (DIVariable(DV->getVariable()).isArtificial())
668 VariableCU->addUInt(VariableDie, dwarf::DW_AT_artificial,
669 dwarf::DW_FORM_flag, 1);
671 if (Scope->isAbstractScope()) {
672 DV->setDIE(VariableDie);
676 // Add variable address.
678 unsigned Offset = DV->getDotDebugLocOffset();
680 VariableCU->addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
681 Asm->GetTempSymbol("debug_loc", Offset));
682 DV->setDIE(VariableDie);
683 UseDotDebugLocEntry.insert(VariableDie);
687 // Check if variable is described by a DBG_VALUE instruction.
688 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
689 DbgVariableToDbgInstMap.find(DV);
690 if (DVI != DbgVariableToDbgInstMap.end()) {
691 const MachineInstr *DVInsn = DVI->second;
692 bool updated = false;
693 // FIXME : Handle getNumOperands != 3
694 if (DVInsn->getNumOperands() == 3) {
695 if (DVInsn->getOperand(0).isReg()) {
696 const MachineOperand RegOp = DVInsn->getOperand(0);
697 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
698 if (DVInsn->getOperand(1).isImm() &&
699 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
700 unsigned FrameReg = 0;
701 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
703 TFI->getFrameIndexReference(*Asm->MF,
704 DVInsn->getOperand(1).getImm(),
706 MachineLocation Location(FrameReg, Offset);
707 VariableCU->addVariableAddress(DV, VariableDie, Location);
709 } else if (RegOp.getReg())
710 VariableCU->addVariableAddress(DV, VariableDie,
711 MachineLocation(RegOp.getReg()));
714 else if (DVInsn->getOperand(0).isImm())
716 VariableCU->addConstantValue(VariableDie, DVInsn->getOperand(0),
718 else if (DVInsn->getOperand(0).isFPImm())
720 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
722 VariableCU->addVariableAddress(DV, VariableDie,
723 Asm->getDebugValueLocation(DVInsn));
727 // If variableDie is not updated then DBG_VALUE instruction does not
728 // have valid variable info.
732 DV->setDIE(VariableDie);
736 // .. else use frame index, if available.
738 if (findVariableFrameIndex(DV, &FI)) {
739 unsigned FrameReg = 0;
740 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
742 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
743 MachineLocation Location(FrameReg, Offset);
744 VariableCU->addVariableAddress(DV, VariableDie, Location);
747 DV->setDIE(VariableDie);
752 /// constructScopeDIE - Construct a DIE for this scope.
753 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
754 if (!Scope || !Scope->getScopeNode())
757 SmallVector <DIE *, 8> Children;
759 // Collect arguments for current function.
760 if (Scope == CurrentFnDbgScope)
761 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
762 if (DbgVariable *ArgDV = CurrentFnArguments[i])
763 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
764 Children.push_back(Arg);
766 // Collect lexical scope childrens first.
767 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
768 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
769 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
770 Children.push_back(Variable);
771 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
772 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
773 if (DIE *Nested = constructScopeDIE(Scopes[j]))
774 Children.push_back(Nested);
775 DIScope DS(Scope->getScopeNode());
776 DIE *ScopeDIE = NULL;
777 if (Scope->getInlinedAt())
778 ScopeDIE = constructInlinedScopeDIE(Scope);
779 else if (DS.isSubprogram()) {
780 ProcessedSPNodes.insert(DS);
781 if (Scope->isAbstractScope()) {
782 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
783 // Note down abstract DIE.
785 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
788 ScopeDIE = updateSubprogramScopeDIE(DS);
791 // There is no need to emit empty lexical block DIE.
792 if (Children.empty())
794 ScopeDIE = constructLexicalScopeDIE(Scope);
797 if (!ScopeDIE) return NULL;
800 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
801 E = Children.end(); I != E; ++I)
802 ScopeDIE->addChild(*I);
804 if (DS.isSubprogram())
805 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
810 /// GetOrCreateSourceID - Look up the source id with the given directory and
811 /// source file names. If none currently exists, create a new id and insert it
812 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
815 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
817 // If FE did not provide a file name, then assume stdin.
818 if (FileName.empty())
819 return GetOrCreateSourceID("<stdin>", StringRef());
821 // MCStream expects full path name as filename.
822 if (!DirName.empty() && !sys::path::is_absolute(FileName)) {
823 SmallString<128> FullPathName = DirName;
824 sys::path::append(FullPathName, FileName);
825 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
826 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
829 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
830 if (Entry.getValue())
831 return Entry.getValue();
833 unsigned SrcId = SourceIdMap.size();
834 Entry.setValue(SrcId);
836 // Print out a .file directive to specify files for .loc directives.
837 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
842 /// constructCompileUnit - Create new CompileUnit for the given
843 /// metadata node with tag DW_TAG_compile_unit.
844 void DwarfDebug::constructCompileUnit(const MDNode *N) {
845 DICompileUnit DIUnit(N);
846 StringRef FN = DIUnit.getFilename();
847 StringRef Dir = DIUnit.getDirectory();
848 unsigned ID = GetOrCreateSourceID(FN, Dir);
850 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
851 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
852 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
853 DIUnit.getProducer());
854 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
855 DIUnit.getLanguage());
856 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
857 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
858 // simplifies debug range entries.
859 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
860 // DW_AT_stmt_list is a offset of line number information for this
861 // compile unit in debug_line section.
862 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
863 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
864 Asm->GetTempSymbol("section_line"));
866 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
869 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
870 if (DIUnit.isOptimized())
871 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
873 StringRef Flags = DIUnit.getFlags();
875 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
877 unsigned RVer = DIUnit.getRunTimeVersion();
879 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
880 dwarf::DW_FORM_data1, RVer);
884 CUMap.insert(std::make_pair(N, NewCU));
887 /// getCompielUnit - Get CompileUnit DIE.
888 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
889 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
891 const MDNode *CUNode = NULL;
892 if (D.isCompileUnit())
894 else if (D.isSubprogram())
895 CUNode = DISubprogram(N).getCompileUnit();
897 CUNode = DIType(N).getCompileUnit();
898 else if (D.isGlobalVariable())
899 CUNode = DIGlobalVariable(N).getCompileUnit();
900 else if (D.isVariable())
901 CUNode = DIVariable(N).getCompileUnit();
902 else if (D.isNameSpace())
903 CUNode = DINameSpace(N).getCompileUnit();
905 CUNode = DIFile(N).getCompileUnit();
909 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
910 = CUMap.find(CUNode);
911 if (I == CUMap.end())
916 /// isUnsignedDIType - Return true if type encoding is unsigned.
917 static bool isUnsignedDIType(DIType Ty) {
918 DIDerivedType DTy(Ty);
920 return isUnsignedDIType(DTy.getTypeDerivedFrom());
924 unsigned Encoding = BTy.getEncoding();
925 if (Encoding == dwarf::DW_ATE_unsigned ||
926 Encoding == dwarf::DW_ATE_unsigned_char)
932 // Return const exprssion if value is a GEP to access merged global
934 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
935 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
936 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
937 if (!CE || CE->getNumOperands() != 3 ||
938 CE->getOpcode() != Instruction::GetElementPtr)
941 // First operand points to a global value.
942 if (!isa<GlobalValue>(CE->getOperand(0)))
945 // Second operand is zero.
946 const ConstantInt *CI =
947 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
948 if (!CI || !CI->isZero())
951 // Third operand is offset.
952 if (!isa<ConstantInt>(CE->getOperand(2)))
958 /// constructGlobalVariableDIE - Construct global variable DIE.
959 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
960 DIGlobalVariable GV(N);
962 // If debug information is malformed then ignore it.
963 if (GV.Verify() == false)
966 // Check for pre-existence.
967 CompileUnit *TheCU = getCompileUnit(N);
968 if (TheCU->getDIE(GV))
971 DIType GTy = GV.getType();
972 DIE *VariableDIE = new DIE(GV.getTag());
974 bool isGlobalVariable = GV.getGlobal() != NULL;
977 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
978 GV.getDisplayName());
979 StringRef LinkageName = GV.getLinkageName();
980 if (!LinkageName.empty() && isGlobalVariable)
981 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
982 dwarf::DW_FORM_string,
983 getRealLinkageName(LinkageName));
985 TheCU->addType(VariableDIE, GTy);
988 if (!GV.isLocalToUnit()) {
989 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
991 TheCU->addGlobal(GV.getName(), VariableDIE);
993 // Add line number info.
994 TheCU->addSourceLine(VariableDIE, GV);
996 TheCU->insertDIE(N, VariableDIE);
997 // Add to context owner.
998 DIDescriptor GVContext = GV.getContext();
999 TheCU->addToContextOwner(VariableDIE, GVContext);
1001 if (isGlobalVariable) {
1002 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1003 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1004 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1005 Asm->Mang->getSymbol(GV.getGlobal()));
1006 // Do not create specification DIE if context is either compile unit
1008 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1009 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1010 // Create specification DIE.
1011 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1012 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1013 dwarf::DW_FORM_ref4, VariableDIE);
1014 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1015 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1016 TheCU->addDie(VariableSpecDIE);
1018 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1020 } else if (ConstantInt *CI =
1021 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1022 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1023 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1024 // GV is a merged global.
1025 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1026 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1027 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1028 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1029 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1030 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1031 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1032 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1033 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1039 /// construct SubprogramDIE - Construct subprogram DIE.
1040 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1043 // Check for pre-existence.
1044 CompileUnit *TheCU = getCompileUnit(N);
1045 if (TheCU->getDIE(N))
1048 if (!SP.isDefinition())
1049 // This is a method declaration which will be handled while constructing
1053 DIE *SubprogramDie = createSubprogramDIE(SP);
1056 TheCU->insertDIE(N, SubprogramDie);
1058 // Add to context owner.
1059 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1061 // Expose as global.
1062 TheCU->addGlobal(SP.getName(), SubprogramDie);
1067 /// beginModule - Emit all Dwarf sections that should come prior to the
1068 /// content. Create global DIEs and emit initial debug info sections.
1069 /// This is inovked by the target AsmPrinter.
1070 void DwarfDebug::beginModule(Module *M) {
1071 if (DisableDebugInfoPrinting)
1074 // If module has named metadata anchors then use them, otherwise scan the module
1075 // using debug info finder to collect debug info.
1076 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1079 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1080 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1081 if (!GV_Nodes && !SP_Nodes)
1082 // If there are not any global variables or any functions then
1083 // there is not any debug info in this module.
1086 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1087 constructCompileUnit(CU_Nodes->getOperand(i));
1090 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1091 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1094 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1095 constructSubprogramDIE(SP_Nodes->getOperand(i));
1099 DebugInfoFinder DbgFinder;
1100 DbgFinder.processModule(*M);
1102 bool HasDebugInfo = false;
1103 // Scan all the compile-units to see if there are any marked as the main unit.
1104 // if not, we do not generate debug info.
1105 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1106 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1107 if (DICompileUnit(*I).isMain()) {
1108 HasDebugInfo = true;
1112 if (!HasDebugInfo) return;
1114 // Create all the compile unit DIEs.
1115 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1116 E = DbgFinder.compile_unit_end(); I != E; ++I)
1117 constructCompileUnit(*I);
1119 // Create DIEs for each global variable.
1120 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1121 E = DbgFinder.global_variable_end(); I != E; ++I)
1122 constructGlobalVariableDIE(*I);
1124 // Create DIEs for each subprogram.
1125 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1126 E = DbgFinder.subprogram_end(); I != E; ++I)
1127 constructSubprogramDIE(*I);
1130 // Tell MMI that we have debug info.
1131 MMI->setDebugInfoAvailability(true);
1133 // Emit initial sections.
1134 EmitSectionLabels();
1136 //getOrCreateTypeDIE
1137 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1138 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1139 DIType Ty(NMD->getOperand(i));
1140 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1143 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1144 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1145 DIType Ty(NMD->getOperand(i));
1146 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1149 // Prime section data.
1150 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1153 /// endModule - Emit all Dwarf sections that should come after the content.
1155 void DwarfDebug::endModule() {
1156 if (!FirstCU) return;
1157 const Module *M = MMI->getModule();
1158 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1159 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1160 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1161 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1162 DISubprogram SP(AllSPs->getOperand(SI));
1163 if (!SP.Verify()) continue;
1165 // Collect info for variables that were optimized out.
1166 if (!SP.isDefinition()) continue;
1167 StringRef FName = SP.getLinkageName();
1169 FName = SP.getName();
1170 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1172 unsigned E = NMD->getNumOperands();
1174 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1175 DeadFnScopeMap[SP] = Scope;
1176 for (unsigned I = 0; I != E; ++I) {
1177 DIVariable DV(NMD->getOperand(I));
1178 if (!DV.Verify()) continue;
1179 Scope->addVariable(new DbgVariable(DV));
1182 // Construct subprogram DIE and add variables DIEs.
1183 constructSubprogramDIE(SP);
1184 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1185 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1186 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1187 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1189 ScopeDIE->addChild(VariableDIE);
1194 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1195 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1196 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1198 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1201 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1202 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1203 DIE *SPDie = CI->first;
1204 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1206 DIE *NDie = getCompileUnit(N)->getDIE(N);
1207 if (!NDie) continue;
1208 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1209 dwarf::DW_FORM_ref4, NDie);
1212 // Standard sections final addresses.
1213 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1214 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1215 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1216 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1218 // End text sections.
1219 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1220 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1221 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1224 // Compute DIE offsets and sizes.
1225 computeSizeAndOffsets();
1227 // Emit all the DIEs into a debug info section
1230 // Corresponding abbreviations into a abbrev section.
1231 emitAbbreviations();
1233 // Emit info into a debug pubnames section.
1234 emitDebugPubNames();
1236 // Emit info into a debug pubtypes section.
1237 emitDebugPubTypes();
1239 // Emit info into a debug loc section.
1242 // Emit info into a debug aranges section.
1245 // Emit info into a debug ranges section.
1248 // Emit info into a debug macinfo section.
1251 // Emit inline info.
1252 emitDebugInlineInfo();
1254 // Emit info into a debug str section.
1258 DeleteContainerSeconds(DeadFnScopeMap);
1259 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1260 E = CUMap.end(); I != E; ++I)
1262 FirstCU = NULL; // Reset for the next Module, if any.
1265 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1266 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1267 DebugLoc ScopeLoc) {
1269 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1271 return AbsDbgVariable;
1273 LLVMContext &Ctx = Var->getContext();
1274 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1278 AbsDbgVariable = new DbgVariable(Var);
1279 Scope->addVariable(AbsDbgVariable);
1280 AbstractVariables[Var] = AbsDbgVariable;
1281 return AbsDbgVariable;
1284 /// addCurrentFnArgument - If Var is an current function argument that add
1285 /// it in CurrentFnArguments list.
1286 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1287 DbgVariable *Var, DbgScope *Scope) {
1288 if (Scope != CurrentFnDbgScope)
1290 DIVariable DV = Var->getVariable();
1291 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1293 unsigned ArgNo = DV.getArgNumber();
1297 size_t Size = CurrentFnArguments.size();
1299 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1300 // llvm::Function argument size is not good indicator of how many
1301 // arguments does the function have at source level.
1303 CurrentFnArguments.resize(ArgNo * 2);
1304 CurrentFnArguments[ArgNo - 1] = Var;
1308 /// collectVariableInfoFromMMITable - Collect variable information from
1309 /// side table maintained by MMI.
1311 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1312 SmallPtrSet<const MDNode *, 16> &Processed) {
1313 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1314 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1315 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1316 VE = VMap.end(); VI != VE; ++VI) {
1317 const MDNode *Var = VI->first;
1319 Processed.insert(Var);
1321 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1323 DbgScope *Scope = 0;
1324 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
1325 Scope = ConcreteScopes.lookup(IA);
1327 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
1329 // If variable scope is not found then skip this variable.
1333 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1334 DbgVariable *RegVar = new DbgVariable(DV);
1335 recordVariableFrameIndex(RegVar, VP.first);
1336 if (!addCurrentFnArgument(MF, RegVar, Scope))
1337 Scope->addVariable(RegVar);
1338 if (AbsDbgVariable) {
1339 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1340 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1345 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1346 /// DBG_VALUE instruction, is in a defined reg.
1347 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1348 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1349 return MI->getNumOperands() == 3 &&
1350 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1351 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1354 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1356 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1357 SmallPtrSet<const MDNode *, 16> &Processed) {
1359 /// collection info from MMI table.
1360 collectVariableInfoFromMMITable(MF, Processed);
1362 for (SmallVectorImpl<const MDNode*>::const_iterator
1363 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1365 const MDNode *Var = *UVI;
1366 if (Processed.count(Var))
1369 // History contains relevant DBG_VALUE instructions for Var and instructions
1371 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1372 if (History.empty())
1374 const MachineInstr *MInsn = History.front();
1377 DbgScope *Scope = NULL;
1378 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1379 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1380 Scope = CurrentFnDbgScope;
1382 Scope = findDbgScope(MInsn);
1383 // If variable scope is not found then skip this variable.
1387 Processed.insert(DV);
1388 assert(MInsn->isDebugValue() && "History must begin with debug value");
1389 DbgVariable *RegVar = new DbgVariable(DV);
1390 if (!addCurrentFnArgument(MF, RegVar, Scope))
1391 Scope->addVariable(RegVar);
1392 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1393 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1394 VarToAbstractVarMap[RegVar] = AbsVar;
1397 // Simple ranges that are fully coalesced.
1398 if (History.size() <= 1 || (History.size() == 2 &&
1399 MInsn->isIdenticalTo(History.back()))) {
1400 DbgVariableToDbgInstMap[RegVar] = MInsn;
1404 // handle multiple DBG_VALUE instructions describing one variable.
1405 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1407 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1408 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1409 const MachineInstr *Begin = *HI;
1410 assert(Begin->isDebugValue() && "Invalid History entry");
1412 // Check if DBG_VALUE is truncating a range.
1413 if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1414 && !Begin->getOperand(0).getReg())
1417 // Compute the range for a register location.
1418 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1419 const MCSymbol *SLabel = 0;
1422 // If Begin is the last instruction in History then its value is valid
1423 // until the end of the function.
1424 SLabel = FunctionEndSym;
1426 const MachineInstr *End = HI[1];
1427 if (End->isDebugValue())
1428 SLabel = getLabelBeforeInsn(End);
1430 // End is a normal instruction clobbering the range.
1431 SLabel = getLabelAfterInsn(End);
1432 assert(SLabel && "Forgot label after clobber instruction");
1437 // The value is valid until the next DBG_VALUE or clobber.
1438 MachineLocation MLoc;
1439 if (Begin->getNumOperands() == 3) {
1440 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm()) {
1441 MLoc.set(Begin->getOperand(0).getReg(),
1442 Begin->getOperand(1).getImm());
1444 push_back(DotDebugLocEntry(FLabel, SLabel, MLoc, Var));
1446 // FIXME: Handle isFPImm also.
1447 else if (Begin->getOperand(0).isImm()) {
1449 push_back(DotDebugLocEntry(FLabel, SLabel,
1450 Begin->getOperand(0).getImm()));
1453 MLoc = Asm->getDebugValueLocation(Begin);
1455 push_back(DotDebugLocEntry(FLabel, SLabel, MLoc, Var));
1458 DotDebugLocEntries.push_back(DotDebugLocEntry());
1461 // Collect info for variables that were optimized out.
1462 const Function *F = MF->getFunction();
1463 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1464 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1465 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1466 if (!DV || !Processed.insert(DV))
1468 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1470 Scope->addVariable(new DbgVariable(DV));
1475 /// getLabelBeforeInsn - Return Label preceding the instruction.
1476 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1477 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1478 assert(Label && "Didn't insert label before instruction");
1482 /// getLabelAfterInsn - Return Label immediately following the instruction.
1483 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1484 return LabelsAfterInsn.lookup(MI);
1487 /// beginInstruction - Process beginning of an instruction.
1488 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1489 // Check if source location changes, but ignore DBG_VALUE locations.
1490 if (!MI->isDebugValue()) {
1491 DebugLoc DL = MI->getDebugLoc();
1492 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1493 unsigned Flags = DWARF2_FLAG_IS_STMT;
1495 if (DL == PrologEndLoc) {
1496 Flags |= DWARF2_FLAG_PROLOGUE_END;
1497 PrologEndLoc = DebugLoc();
1499 if (!DL.isUnknown()) {
1500 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1501 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1503 recordSourceLine(0, 0, 0, 0);
1507 // Insert labels where requested.
1508 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1509 LabelsBeforeInsn.find(MI);
1512 if (I == LabelsBeforeInsn.end())
1515 // Label already assigned.
1520 PrevLabel = MMI->getContext().CreateTempSymbol();
1521 Asm->OutStreamer.EmitLabel(PrevLabel);
1523 I->second = PrevLabel;
1526 /// endInstruction - Process end of an instruction.
1527 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1528 // Don't create a new label after DBG_VALUE instructions.
1529 // They don't generate code.
1530 if (!MI->isDebugValue())
1533 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1534 LabelsAfterInsn.find(MI);
1537 if (I == LabelsAfterInsn.end())
1540 // Label already assigned.
1544 // We need a label after this instruction.
1546 PrevLabel = MMI->getContext().CreateTempSymbol();
1547 Asm->OutStreamer.EmitLabel(PrevLabel);
1549 I->second = PrevLabel;
1552 /// getOrCreateDbgScope - Create DbgScope for the scope.
1553 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
1554 const MDNode *InlinedAt) {
1556 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1559 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1560 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1561 if (DIDescriptor(Scope).isLexicalBlock()) {
1563 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
1564 WScope->setParent(Parent);
1565 Parent->addScope(WScope);
1568 if (!WScope->getParent()) {
1569 StringRef SPName = DISubprogram(Scope).getLinkageName();
1570 // We used to check only for a linkage name, but that fails
1571 // since we began omitting the linkage name for private
1572 // functions. The new way is to check for the name in metadata,
1573 // but that's not supported in old .ll test cases. Ergo, we
1575 if (SPName == Asm->MF->getFunction()->getName() ||
1576 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
1577 CurrentFnDbgScope = WScope;
1583 getOrCreateAbstractScope(Scope);
1584 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1588 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1589 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1590 DILocation DL(InlinedAt);
1592 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
1593 WScope->setParent(Parent);
1594 Parent->addScope(WScope);
1596 ConcreteScopes[InlinedAt] = WScope;
1601 /// hasValidLocation - Return true if debug location entry attached with
1602 /// machine instruction encodes valid location info.
1603 static bool hasValidLocation(LLVMContext &Ctx,
1604 const MachineInstr *MInsn,
1605 const MDNode *&Scope, const MDNode *&InlinedAt) {
1606 DebugLoc DL = MInsn->getDebugLoc();
1607 if (DL.isUnknown()) return false;
1609 const MDNode *S = DL.getScope(Ctx);
1611 // There is no need to create another DIE for compile unit. For all
1612 // other scopes, create one DbgScope now. This will be translated
1613 // into a scope DIE at the end.
1614 if (DIScope(S).isCompileUnit()) return false;
1617 InlinedAt = DL.getInlinedAt(Ctx);
1621 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1623 static void calculateDominanceGraph(DbgScope *Scope) {
1624 assert (Scope && "Unable to calculate scop edominance graph!");
1625 SmallVector<DbgScope *, 4> WorkStack;
1626 WorkStack.push_back(Scope);
1627 unsigned Counter = 0;
1628 while (!WorkStack.empty()) {
1629 DbgScope *WS = WorkStack.back();
1630 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1631 bool visitedChildren = false;
1632 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1633 SE = Children.end(); SI != SE; ++SI) {
1634 DbgScope *ChildScope = *SI;
1635 if (!ChildScope->getDFSOut()) {
1636 WorkStack.push_back(ChildScope);
1637 visitedChildren = true;
1638 ChildScope->setDFSIn(++Counter);
1642 if (!visitedChildren) {
1643 WorkStack.pop_back();
1644 WS->setDFSOut(++Counter);
1649 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1651 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1652 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1655 unsigned PrevDFSIn = 0;
1656 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1658 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1660 const MachineInstr *MInsn = II;
1661 const MDNode *Scope = NULL;
1662 const MDNode *InlinedAt = NULL;
1664 // Check if instruction has valid location information.
1665 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1669 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1670 MI2ScopeMap.find(MInsn);
1671 if (DI != MI2ScopeMap.end()) {
1672 DbgScope *S = DI->second;
1673 dbgs() << S->getDFSIn();
1674 PrevDFSIn = S->getDFSIn();
1676 dbgs() << PrevDFSIn;
1678 dbgs() << " [ x" << PrevDFSIn;
1686 /// extractScopeInformation - Scan machine instructions in this function
1687 /// and collect DbgScopes. Return true, if at least one scope was found.
1688 bool DwarfDebug::extractScopeInformation() {
1689 // If scope information was extracted using .dbg intrinsics then there is not
1690 // any need to extract these information by scanning each instruction.
1691 if (!DbgScopeMap.empty())
1694 // Scan each instruction and create scopes. First build working set of scopes.
1695 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1696 SmallVector<DbgRange, 4> MIRanges;
1697 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1698 const MDNode *PrevScope = NULL;
1699 const MDNode *PrevInlinedAt = NULL;
1700 const MachineInstr *RangeBeginMI = NULL;
1701 const MachineInstr *PrevMI = NULL;
1702 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1704 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1706 const MachineInstr *MInsn = II;
1707 const MDNode *Scope = NULL;
1708 const MDNode *InlinedAt = NULL;
1710 // Check if instruction has valid location information.
1711 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1716 // If scope has not changed then skip this instruction.
1717 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
1722 // Ignore DBG_VALUE. It does not contribute any instruction in output.
1723 if (MInsn->isDebugValue())
1727 // If we have alread seen a beginning of a instruction range and
1728 // current instruction scope does not match scope of first instruction
1729 // in this range then create a new instruction range.
1730 DbgRange R(RangeBeginMI, PrevMI);
1731 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
1733 MIRanges.push_back(R);
1736 // This is a beginning of a new instruction range.
1737 RangeBeginMI = MInsn;
1739 // Reset previous markers.
1742 PrevInlinedAt = InlinedAt;
1746 // Create last instruction range.
1747 if (RangeBeginMI && PrevMI && PrevScope) {
1748 DbgRange R(RangeBeginMI, PrevMI);
1749 MIRanges.push_back(R);
1750 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
1753 if (!CurrentFnDbgScope)
1756 calculateDominanceGraph(CurrentFnDbgScope);
1758 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1760 // Find ranges of instructions covered by each DbgScope;
1761 DbgScope *PrevDbgScope = NULL;
1762 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1763 RE = MIRanges.end(); RI != RE; ++RI) {
1764 const DbgRange &R = *RI;
1765 DbgScope *S = MI2ScopeMap.lookup(R.first);
1766 assert (S && "Lost DbgScope for a machine instruction!");
1767 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1768 PrevDbgScope->closeInsnRange(S);
1769 S->openInsnRange(R.first);
1770 S->extendInsnRange(R.second);
1775 PrevDbgScope->closeInsnRange();
1777 identifyScopeMarkers();
1779 return !DbgScopeMap.empty();
1782 /// identifyScopeMarkers() -
1783 /// Each DbgScope has first instruction and last instruction to mark beginning
1784 /// and end of a scope respectively. Create an inverse map that list scopes
1785 /// starts (and ends) with an instruction. One instruction may start (or end)
1786 /// multiple scopes. Ignore scopes that are not reachable.
1787 void DwarfDebug::identifyScopeMarkers() {
1788 SmallVector<DbgScope *, 4> WorkList;
1789 WorkList.push_back(CurrentFnDbgScope);
1790 while (!WorkList.empty()) {
1791 DbgScope *S = WorkList.pop_back_val();
1793 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1794 if (!Children.empty())
1795 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1796 SE = Children.end(); SI != SE; ++SI)
1797 WorkList.push_back(*SI);
1799 if (S->isAbstractScope())
1802 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1805 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1806 RE = Ranges.end(); RI != RE; ++RI) {
1807 assert(RI->first && "DbgRange does not have first instruction!");
1808 assert(RI->second && "DbgRange does not have second instruction!");
1809 requestLabelBeforeInsn(RI->first);
1810 requestLabelAfterInsn(RI->second);
1815 /// getScopeNode - Get MDNode for DebugLoc's scope.
1816 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1817 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1818 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1819 return DL.getScope(Ctx);
1822 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1823 /// line number info for the function.
1824 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1825 const MDNode *Scope = getScopeNode(DL, Ctx);
1826 DISubprogram SP = getDISubprogram(Scope);
1828 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1832 /// beginFunction - Gather pre-function debug information. Assumes being
1833 /// emitted immediately after the function entry point.
1834 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1835 if (!MMI->hasDebugInfo()) return;
1836 if (!extractScopeInformation()) return;
1838 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1839 Asm->getFunctionNumber());
1840 // Assumes in correct section after the entry point.
1841 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1843 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1845 /// ProcessedArgs - Collection of arguments already processed.
1846 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
1847 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1848 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1849 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1851 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1853 bool AtBlockEntry = true;
1854 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1856 const MachineInstr *MI = II;
1858 if (MI->isDebugValue()) {
1859 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1861 // Keep track of user variables.
1863 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1865 // Variable is in a register, we need to check for clobbers.
1866 if (isDbgValueInDefinedReg(MI))
1867 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1869 // Check the history of this variable.
1870 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1871 if (History.empty()) {
1872 UserVariables.push_back(Var);
1873 // The first mention of a function argument gets the FunctionBeginSym
1874 // label, so arguments are visible when breaking at function entry.
1876 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1877 DISubprogram(getDISubprogram(DV.getContext()))
1878 .describes(MF->getFunction()))
1879 LabelsBeforeInsn[MI] = FunctionBeginSym;
1881 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1882 const MachineInstr *Prev = History.back();
1883 if (Prev->isDebugValue()) {
1884 // Coalesce identical entries at the end of History.
1885 if (History.size() >= 2 &&
1886 Prev->isIdenticalTo(History[History.size() - 2]))
1889 // Terminate old register assignments that don't reach MI;
1890 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1891 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1892 isDbgValueInDefinedReg(Prev)) {
1893 // Previous register assignment needs to terminate at the end of
1895 MachineBasicBlock::const_iterator LastMI =
1896 PrevMBB->getLastNonDebugInstr();
1897 if (LastMI == PrevMBB->end())
1898 // Drop DBG_VALUE for empty range.
1901 // Terminate after LastMI.
1902 History.push_back(LastMI);
1907 History.push_back(MI);
1909 // Not a DBG_VALUE instruction.
1911 AtBlockEntry = false;
1913 // First known non DBG_VALUE location marks beginning of function
1915 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1916 PrologEndLoc = MI->getDebugLoc();
1918 // Check if the instruction clobbers any registers with debug vars.
1919 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1920 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1921 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1923 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1924 unsigned Reg = *AI; ++AI) {
1925 const MDNode *Var = LiveUserVar[Reg];
1928 // Reg is now clobbered.
1929 LiveUserVar[Reg] = 0;
1931 // Was MD last defined by a DBG_VALUE referring to Reg?
1932 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1933 if (HistI == DbgValues.end())
1935 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1936 if (History.empty())
1938 const MachineInstr *Prev = History.back();
1939 // Sanity-check: Register assignments are terminated at the end of
1941 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1943 // Is the variable still in Reg?
1944 if (!isDbgValueInDefinedReg(Prev) ||
1945 Prev->getOperand(0).getReg() != Reg)
1947 // Var is clobbered. Make sure the next instruction gets a label.
1948 History.push_back(MI);
1955 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1957 SmallVectorImpl<const MachineInstr*> &History = I->second;
1958 if (History.empty())
1961 // Make sure the final register assignments are terminated.
1962 const MachineInstr *Prev = History.back();
1963 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1964 const MachineBasicBlock *PrevMBB = Prev->getParent();
1965 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1966 if (LastMI == PrevMBB->end())
1967 // Drop DBG_VALUE for empty range.
1970 // Terminate after LastMI.
1971 History.push_back(LastMI);
1974 // Request labels for the full history.
1975 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1976 const MachineInstr *MI = History[i];
1977 if (MI->isDebugValue())
1978 requestLabelBeforeInsn(MI);
1980 requestLabelAfterInsn(MI);
1984 PrevInstLoc = DebugLoc();
1985 PrevLabel = FunctionBeginSym;
1987 // Record beginning of function.
1988 if (!PrologEndLoc.isUnknown()) {
1989 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1990 MF->getFunction()->getContext());
1991 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1992 FnStartDL.getScope(MF->getFunction()->getContext()),
1993 DWARF2_FLAG_IS_STMT);
1997 /// endFunction - Gather and emit post-function debug information.
1999 void DwarfDebug::endFunction(const MachineFunction *MF) {
2000 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2002 if (CurrentFnDbgScope) {
2004 // Define end label for subprogram.
2005 FunctionEndSym = Asm->GetTempSymbol("func_end",
2006 Asm->getFunctionNumber());
2007 // Assumes in correct section after the entry point.
2008 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2010 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2011 collectVariableInfo(MF, ProcessedVars);
2013 // Construct abstract scopes.
2014 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2015 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2016 DISubprogram SP((*AI)->getScopeNode());
2018 // Collect info for variables that were optimized out.
2019 StringRef FName = SP.getLinkageName();
2021 FName = SP.getName();
2022 if (NamedMDNode *NMD =
2023 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2024 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2025 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2026 if (!DV || !ProcessedVars.insert(DV))
2028 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2030 Scope->addVariable(new DbgVariable(DV));
2034 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2035 constructScopeDIE(*AI);
2038 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2040 if (!DisableFramePointerElim(*MF))
2041 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2042 dwarf::DW_AT_APPLE_omit_frame_ptr,
2043 dwarf::DW_FORM_flag, 1);
2046 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2047 MMI->getFrameMoves()));
2051 CurrentFnDbgScope = NULL;
2052 DeleteContainerPointers(CurrentFnArguments);
2053 DbgVariableToFrameIndexMap.clear();
2054 VarToAbstractVarMap.clear();
2055 DbgVariableToDbgInstMap.clear();
2056 DeleteContainerSeconds(DbgScopeMap);
2057 UserVariables.clear();
2059 ConcreteScopes.clear();
2060 DeleteContainerSeconds(AbstractScopes);
2061 AbstractScopesList.clear();
2062 AbstractVariables.clear();
2063 LabelsBeforeInsn.clear();
2064 LabelsAfterInsn.clear();
2068 /// recordVariableFrameIndex - Record a variable's index.
2069 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2070 assert (V && "Invalid DbgVariable!");
2071 DbgVariableToFrameIndexMap[V] = Index;
2074 /// findVariableFrameIndex - Return true if frame index for the variable
2075 /// is found. Update FI to hold value of the index.
2076 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2077 assert (V && "Invalid DbgVariable!");
2078 DenseMap<const DbgVariable *, int>::iterator I =
2079 DbgVariableToFrameIndexMap.find(V);
2080 if (I == DbgVariableToFrameIndexMap.end())
2086 /// findDbgScope - Find DbgScope for the debug loc attached with an
2088 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2089 DbgScope *Scope = NULL;
2091 MInsn->getParent()->getParent()->getFunction()->getContext();
2092 DebugLoc DL = MInsn->getDebugLoc();
2097 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2098 Scope = ConcreteScopes.lookup(IA);
2100 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2106 /// recordSourceLine - Register a source line with debug info. Returns the
2107 /// unique label that was emitted and which provides correspondence to
2108 /// the source line list.
2109 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2115 DIDescriptor Scope(S);
2117 if (Scope.isCompileUnit()) {
2118 DICompileUnit CU(S);
2119 Fn = CU.getFilename();
2120 Dir = CU.getDirectory();
2121 } else if (Scope.isFile()) {
2123 Fn = F.getFilename();
2124 Dir = F.getDirectory();
2125 } else if (Scope.isSubprogram()) {
2127 Fn = SP.getFilename();
2128 Dir = SP.getDirectory();
2129 } else if (Scope.isLexicalBlock()) {
2130 DILexicalBlock DB(S);
2131 Fn = DB.getFilename();
2132 Dir = DB.getDirectory();
2134 assert(0 && "Unexpected scope info");
2136 Src = GetOrCreateSourceID(Fn, Dir);
2138 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2142 //===----------------------------------------------------------------------===//
2144 //===----------------------------------------------------------------------===//
2146 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2149 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2150 // Get the children.
2151 const std::vector<DIE *> &Children = Die->getChildren();
2153 // If not last sibling and has children then add sibling offset attribute.
2154 if (!Last && !Children.empty())
2155 Die->addSiblingOffset(DIEValueAllocator);
2157 // Record the abbreviation.
2158 assignAbbrevNumber(Die->getAbbrev());
2160 // Get the abbreviation for this DIE.
2161 unsigned AbbrevNumber = Die->getAbbrevNumber();
2162 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2165 Die->setOffset(Offset);
2167 // Start the size with the size of abbreviation code.
2168 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2170 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2171 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2173 // Size the DIE attribute values.
2174 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2175 // Size attribute value.
2176 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2178 // Size the DIE children if any.
2179 if (!Children.empty()) {
2180 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2181 "Children flag not set");
2183 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2184 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2186 // End of children marker.
2187 Offset += sizeof(int8_t);
2190 Die->setSize(Offset - Die->getOffset());
2194 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2196 void DwarfDebug::computeSizeAndOffsets() {
2197 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2198 E = CUMap.end(); I != E; ++I) {
2199 // Compute size of compile unit header.
2201 sizeof(int32_t) + // Length of Compilation Unit Info
2202 sizeof(int16_t) + // DWARF version number
2203 sizeof(int32_t) + // Offset Into Abbrev. Section
2204 sizeof(int8_t); // Pointer Size (in bytes)
2205 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2209 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2210 /// temporary label to it if SymbolStem is specified.
2211 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2212 const char *SymbolStem = 0) {
2213 Asm->OutStreamer.SwitchSection(Section);
2214 if (!SymbolStem) return 0;
2216 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2217 Asm->OutStreamer.EmitLabel(TmpSym);
2221 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2222 /// the start of each one.
2223 void DwarfDebug::EmitSectionLabels() {
2224 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2226 // Dwarf sections base addresses.
2227 DwarfInfoSectionSym =
2228 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2229 DwarfAbbrevSectionSym =
2230 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2231 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2233 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2234 EmitSectionSym(Asm, MacroInfo);
2236 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2237 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2238 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2239 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2240 DwarfStrSectionSym =
2241 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2242 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2245 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2246 "section_debug_loc");
2248 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2249 EmitSectionSym(Asm, TLOF.getDataSection());
2252 /// emitDIE - Recusively Emits a debug information entry.
2254 void DwarfDebug::emitDIE(DIE *Die) {
2255 // Get the abbreviation for this DIE.
2256 unsigned AbbrevNumber = Die->getAbbrevNumber();
2257 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2259 // Emit the code (index) for the abbreviation.
2260 if (Asm->isVerbose())
2261 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2262 Twine::utohexstr(Die->getOffset()) + ":0x" +
2263 Twine::utohexstr(Die->getSize()) + " " +
2264 dwarf::TagString(Abbrev->getTag()));
2265 Asm->EmitULEB128(AbbrevNumber);
2267 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2268 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2270 // Emit the DIE attribute values.
2271 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2272 unsigned Attr = AbbrevData[i].getAttribute();
2273 unsigned Form = AbbrevData[i].getForm();
2274 assert(Form && "Too many attributes for DIE (check abbreviation)");
2276 if (Asm->isVerbose())
2277 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2280 case dwarf::DW_AT_sibling:
2281 Asm->EmitInt32(Die->getSiblingOffset());
2283 case dwarf::DW_AT_abstract_origin: {
2284 DIEEntry *E = cast<DIEEntry>(Values[i]);
2285 DIE *Origin = E->getEntry();
2286 unsigned Addr = Origin->getOffset();
2287 Asm->EmitInt32(Addr);
2290 case dwarf::DW_AT_ranges: {
2291 // DW_AT_range Value encodes offset in debug_range section.
2292 DIEInteger *V = cast<DIEInteger>(Values[i]);
2294 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2295 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2299 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2301 DwarfDebugRangeSectionSym,
2306 case dwarf::DW_AT_location: {
2307 if (UseDotDebugLocEntry.count(Die) != 0) {
2308 DIELabel *L = cast<DIELabel>(Values[i]);
2309 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2311 Values[i]->EmitValue(Asm, Form);
2314 case dwarf::DW_AT_accessibility: {
2315 if (Asm->isVerbose()) {
2316 DIEInteger *V = cast<DIEInteger>(Values[i]);
2317 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2319 Values[i]->EmitValue(Asm, Form);
2323 // Emit an attribute using the defined form.
2324 Values[i]->EmitValue(Asm, Form);
2329 // Emit the DIE children if any.
2330 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2331 const std::vector<DIE *> &Children = Die->getChildren();
2333 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2334 emitDIE(Children[j]);
2336 if (Asm->isVerbose())
2337 Asm->OutStreamer.AddComment("End Of Children Mark");
2342 /// emitDebugInfo - Emit the debug info section.
2344 void DwarfDebug::emitDebugInfo() {
2345 // Start debug info section.
2346 Asm->OutStreamer.SwitchSection(
2347 Asm->getObjFileLowering().getDwarfInfoSection());
2348 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2349 E = CUMap.end(); I != E; ++I) {
2350 CompileUnit *TheCU = I->second;
2351 DIE *Die = TheCU->getCUDie();
2353 // Emit the compile units header.
2354 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2357 // Emit size of content not including length itself
2358 unsigned ContentSize = Die->getSize() +
2359 sizeof(int16_t) + // DWARF version number
2360 sizeof(int32_t) + // Offset Into Abbrev. Section
2361 sizeof(int8_t); // Pointer Size (in bytes)
2363 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2364 Asm->EmitInt32(ContentSize);
2365 Asm->OutStreamer.AddComment("DWARF version number");
2366 Asm->EmitInt16(dwarf::DWARF_VERSION);
2367 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2368 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2369 DwarfAbbrevSectionSym);
2370 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2371 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2374 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2378 /// emitAbbreviations - Emit the abbreviation section.
2380 void DwarfDebug::emitAbbreviations() const {
2381 // Check to see if it is worth the effort.
2382 if (!Abbreviations.empty()) {
2383 // Start the debug abbrev section.
2384 Asm->OutStreamer.SwitchSection(
2385 Asm->getObjFileLowering().getDwarfAbbrevSection());
2387 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2389 // For each abbrevation.
2390 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2391 // Get abbreviation data
2392 const DIEAbbrev *Abbrev = Abbreviations[i];
2394 // Emit the abbrevations code (base 1 index.)
2395 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2397 // Emit the abbreviations data.
2401 // Mark end of abbreviations.
2402 Asm->EmitULEB128(0, "EOM(3)");
2404 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2408 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2409 /// the line matrix.
2411 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2412 // Define last address of section.
2413 Asm->OutStreamer.AddComment("Extended Op");
2416 Asm->OutStreamer.AddComment("Op size");
2417 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2418 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2419 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2421 Asm->OutStreamer.AddComment("Section end label");
2423 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2424 Asm->getTargetData().getPointerSize(),
2427 // Mark end of matrix.
2428 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2434 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2436 void DwarfDebug::emitDebugPubNames() {
2437 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2438 E = CUMap.end(); I != E; ++I) {
2439 CompileUnit *TheCU = I->second;
2440 // Start the dwarf pubnames section.
2441 Asm->OutStreamer.SwitchSection(
2442 Asm->getObjFileLowering().getDwarfPubNamesSection());
2444 Asm->OutStreamer.AddComment("Length of Public Names Info");
2445 Asm->EmitLabelDifference(
2446 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2447 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2449 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2452 Asm->OutStreamer.AddComment("DWARF Version");
2453 Asm->EmitInt16(dwarf::DWARF_VERSION);
2455 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2456 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2457 DwarfInfoSectionSym);
2459 Asm->OutStreamer.AddComment("Compilation Unit Length");
2460 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2461 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2464 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2465 for (StringMap<DIE*>::const_iterator
2466 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2467 const char *Name = GI->getKeyData();
2468 DIE *Entity = GI->second;
2470 Asm->OutStreamer.AddComment("DIE offset");
2471 Asm->EmitInt32(Entity->getOffset());
2473 if (Asm->isVerbose())
2474 Asm->OutStreamer.AddComment("External Name");
2475 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2478 Asm->OutStreamer.AddComment("End Mark");
2480 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2485 void DwarfDebug::emitDebugPubTypes() {
2486 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2487 E = CUMap.end(); I != E; ++I) {
2488 CompileUnit *TheCU = I->second;
2489 // Start the dwarf pubnames section.
2490 Asm->OutStreamer.SwitchSection(
2491 Asm->getObjFileLowering().getDwarfPubTypesSection());
2492 Asm->OutStreamer.AddComment("Length of Public Types Info");
2493 Asm->EmitLabelDifference(
2494 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2495 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2497 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2500 if (Asm->isVerbose()) 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->getGlobalTypes();
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 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2519 Asm->EmitInt32(Entity->getOffset());
2521 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2522 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2525 Asm->OutStreamer.AddComment("End Mark");
2527 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2532 /// emitDebugStr - Emit visible names into a debug str section.
2534 void DwarfDebug::emitDebugStr() {
2535 // Check to see if it is worth the effort.
2536 if (StringPool.empty()) return;
2538 // Start the dwarf str section.
2539 Asm->OutStreamer.SwitchSection(
2540 Asm->getObjFileLowering().getDwarfStrSection());
2542 // Get all of the string pool entries and put them in an array by their ID so
2543 // we can sort them.
2544 SmallVector<std::pair<unsigned,
2545 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2547 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2548 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2549 Entries.push_back(std::make_pair(I->second.second, &*I));
2551 array_pod_sort(Entries.begin(), Entries.end());
2553 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2554 // Emit a label for reference from debug information entries.
2555 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2557 // Emit the string itself.
2558 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2562 /// emitDebugLoc - Emit visible names into a debug loc section.
2564 void DwarfDebug::emitDebugLoc() {
2565 if (DotDebugLocEntries.empty())
2568 for (SmallVector<DotDebugLocEntry, 4>::iterator
2569 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2571 DotDebugLocEntry &Entry = *I;
2572 if (I + 1 != DotDebugLocEntries.end())
2576 // Start the dwarf loc section.
2577 Asm->OutStreamer.SwitchSection(
2578 Asm->getObjFileLowering().getDwarfLocSection());
2579 unsigned char Size = Asm->getTargetData().getPointerSize();
2580 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2582 for (SmallVector<DotDebugLocEntry, 4>::iterator
2583 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2584 I != E; ++I, ++index) {
2585 DotDebugLocEntry &Entry = *I;
2586 if (Entry.isMerged()) continue;
2587 if (Entry.isEmpty()) {
2588 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2589 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2590 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2592 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2593 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2594 DIVariable DV(Entry.Variable);
2595 Asm->OutStreamer.AddComment("Loc expr size");
2596 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2597 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2598 Asm->EmitLabelDifference(end, begin, 2);
2599 Asm->OutStreamer.EmitLabel(begin);
2600 if (Entry.isConstant()) {
2601 DIBasicType BTy(DV.getType());
2603 (BTy.getEncoding() == dwarf::DW_ATE_signed
2604 || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2605 Asm->OutStreamer.AddComment("DW_OP_consts");
2606 Asm->EmitInt8(dwarf::DW_OP_consts);
2607 Asm->EmitSLEB128(Entry.getConstant());
2609 Asm->OutStreamer.AddComment("DW_OP_constu");
2610 Asm->EmitInt8(dwarf::DW_OP_constu);
2611 Asm->EmitULEB128(Entry.getConstant());
2613 } else if (DV.hasComplexAddress()) {
2614 unsigned N = DV.getNumAddrElements();
2616 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2617 if (Entry.Loc.getOffset()) {
2619 Asm->EmitDwarfRegOp(Entry.Loc);
2620 Asm->OutStreamer.AddComment("DW_OP_deref");
2621 Asm->EmitInt8(dwarf::DW_OP_deref);
2622 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2623 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2624 Asm->EmitSLEB128(DV.getAddrElement(1));
2626 // If first address element is OpPlus then emit
2627 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2628 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2629 Asm->EmitDwarfRegOp(Loc);
2633 Asm->EmitDwarfRegOp(Entry.Loc);
2636 // Emit remaining complex address elements.
2637 for (; i < N; ++i) {
2638 uint64_t Element = DV.getAddrElement(i);
2639 if (Element == DIBuilder::OpPlus) {
2640 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2641 Asm->EmitULEB128(DV.getAddrElement(++i));
2642 } else if (Element == DIBuilder::OpDeref)
2643 Asm->EmitInt8(dwarf::DW_OP_deref);
2644 else llvm_unreachable("unknown Opcode found in complex address");
2648 Asm->EmitDwarfRegOp(Entry.Loc);
2650 Asm->OutStreamer.EmitLabel(end);
2655 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2657 void DwarfDebug::EmitDebugARanges() {
2658 // Start the dwarf aranges section.
2659 Asm->OutStreamer.SwitchSection(
2660 Asm->getObjFileLowering().getDwarfARangesSection());
2663 /// emitDebugRanges - Emit visible names into a debug ranges section.
2665 void DwarfDebug::emitDebugRanges() {
2666 // Start the dwarf ranges section.
2667 Asm->OutStreamer.SwitchSection(
2668 Asm->getObjFileLowering().getDwarfRangesSection());
2669 unsigned char Size = Asm->getTargetData().getPointerSize();
2670 for (SmallVector<const MCSymbol *, 8>::iterator
2671 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2674 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2676 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2680 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2682 void DwarfDebug::emitDebugMacInfo() {
2683 if (const MCSection *LineInfo =
2684 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2685 // Start the dwarf macinfo section.
2686 Asm->OutStreamer.SwitchSection(LineInfo);
2690 /// emitDebugInlineInfo - Emit inline info using following format.
2692 /// 1. length of section
2693 /// 2. Dwarf version number
2694 /// 3. address size.
2696 /// Entries (one "entry" for each function that was inlined):
2698 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2699 /// otherwise offset into __debug_str for regular function name.
2700 /// 2. offset into __debug_str section for regular function name.
2701 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2702 /// instances for the function.
2704 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2705 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2706 /// __debug_info section, and the low_pc is the starting address for the
2707 /// inlining instance.
2708 void DwarfDebug::emitDebugInlineInfo() {
2709 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2715 Asm->OutStreamer.SwitchSection(
2716 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2718 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2719 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2720 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2722 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2724 Asm->OutStreamer.AddComment("Dwarf Version");
2725 Asm->EmitInt16(dwarf::DWARF_VERSION);
2726 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2727 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2729 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2730 E = InlinedSPNodes.end(); I != E; ++I) {
2732 const MDNode *Node = *I;
2733 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2734 = InlineInfo.find(Node);
2735 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2736 DISubprogram SP(Node);
2737 StringRef LName = SP.getLinkageName();
2738 StringRef Name = SP.getName();
2740 Asm->OutStreamer.AddComment("MIPS linkage name");
2741 if (LName.empty()) {
2742 Asm->OutStreamer.EmitBytes(Name, 0);
2743 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2745 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2746 DwarfStrSectionSym);
2748 Asm->OutStreamer.AddComment("Function name");
2749 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2750 Asm->EmitULEB128(Labels.size(), "Inline count");
2752 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2753 LE = Labels.end(); LI != LE; ++LI) {
2754 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2755 Asm->EmitInt32(LI->second->getOffset());
2757 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2758 Asm->OutStreamer.EmitSymbolValue(LI->first,
2759 Asm->getTargetData().getPointerSize(),0);
2763 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));