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() && !FileName.startswith("/")) {
823 std::string FullPathName(DirName.data());
824 if (!DirName.endswith("/"))
826 FullPathName += FileName.data();
827 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
828 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
831 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
832 if (Entry.getValue())
833 return Entry.getValue();
835 unsigned SrcId = SourceIdMap.size();
836 Entry.setValue(SrcId);
838 // Print out a .file directive to specify files for .loc directives.
839 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
844 /// constructCompileUnit - Create new CompileUnit for the given
845 /// metadata node with tag DW_TAG_compile_unit.
846 void DwarfDebug::constructCompileUnit(const MDNode *N) {
847 DICompileUnit DIUnit(N);
848 StringRef FN = DIUnit.getFilename();
849 StringRef Dir = DIUnit.getDirectory();
850 unsigned ID = GetOrCreateSourceID(FN, Dir);
852 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
853 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
854 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
855 DIUnit.getProducer());
856 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
857 DIUnit.getLanguage());
858 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
859 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
860 // simplifies debug range entries.
861 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
862 // DW_AT_stmt_list is a offset of line number information for this
863 // compile unit in debug_line section.
864 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
865 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
866 Asm->GetTempSymbol("section_line"));
868 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
871 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
872 if (DIUnit.isOptimized())
873 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
875 StringRef Flags = DIUnit.getFlags();
877 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
879 unsigned RVer = DIUnit.getRunTimeVersion();
881 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
882 dwarf::DW_FORM_data1, RVer);
886 CUMap.insert(std::make_pair(N, NewCU));
889 /// getCompielUnit - Get CompileUnit DIE.
890 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
891 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
893 const MDNode *CUNode = NULL;
894 if (D.isCompileUnit())
896 else if (D.isSubprogram())
897 CUNode = DISubprogram(N).getCompileUnit();
899 CUNode = DIType(N).getCompileUnit();
900 else if (D.isGlobalVariable())
901 CUNode = DIGlobalVariable(N).getCompileUnit();
902 else if (D.isVariable())
903 CUNode = DIVariable(N).getCompileUnit();
904 else if (D.isNameSpace())
905 CUNode = DINameSpace(N).getCompileUnit();
907 CUNode = DIFile(N).getCompileUnit();
911 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
912 = CUMap.find(CUNode);
913 if (I == CUMap.end())
918 /// isUnsignedDIType - Return true if type encoding is unsigned.
919 static bool isUnsignedDIType(DIType Ty) {
920 DIDerivedType DTy(Ty);
922 return isUnsignedDIType(DTy.getTypeDerivedFrom());
926 unsigned Encoding = BTy.getEncoding();
927 if (Encoding == dwarf::DW_ATE_unsigned ||
928 Encoding == dwarf::DW_ATE_unsigned_char)
934 // Return const exprssion if value is a GEP to access merged global
936 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
937 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
938 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
939 if (!CE || CE->getNumOperands() != 3 ||
940 CE->getOpcode() != Instruction::GetElementPtr)
943 // First operand points to a global value.
944 if (!isa<GlobalValue>(CE->getOperand(0)))
947 // Second operand is zero.
948 const ConstantInt *CI =
949 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
950 if (!CI || !CI->isZero())
953 // Third operand is offset.
954 if (!isa<ConstantInt>(CE->getOperand(2)))
960 /// constructGlobalVariableDIE - Construct global variable DIE.
961 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
962 DIGlobalVariable GV(N);
964 // If debug information is malformed then ignore it.
965 if (GV.Verify() == false)
968 // Check for pre-existence.
969 CompileUnit *TheCU = getCompileUnit(N);
970 if (TheCU->getDIE(GV))
973 DIType GTy = GV.getType();
974 DIE *VariableDIE = new DIE(GV.getTag());
976 bool isGlobalVariable = GV.getGlobal() != NULL;
979 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
980 GV.getDisplayName());
981 StringRef LinkageName = GV.getLinkageName();
982 if (!LinkageName.empty() && isGlobalVariable)
983 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
984 dwarf::DW_FORM_string,
985 getRealLinkageName(LinkageName));
987 TheCU->addType(VariableDIE, GTy);
990 if (!GV.isLocalToUnit()) {
991 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
993 TheCU->addGlobal(GV.getName(), VariableDIE);
995 // Add line number info.
996 TheCU->addSourceLine(VariableDIE, GV);
998 TheCU->insertDIE(N, VariableDIE);
999 // Add to context owner.
1000 DIDescriptor GVContext = GV.getContext();
1001 TheCU->addToContextOwner(VariableDIE, GVContext);
1003 if (isGlobalVariable) {
1004 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1005 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1006 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1007 Asm->Mang->getSymbol(GV.getGlobal()));
1008 // Do not create specification DIE if context is either compile unit
1010 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1011 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1012 // Create specification DIE.
1013 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1014 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1015 dwarf::DW_FORM_ref4, VariableDIE);
1016 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1017 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1018 TheCU->addDie(VariableSpecDIE);
1020 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1022 } else if (ConstantInt *CI =
1023 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1024 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1025 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1026 // GV is a merged global.
1027 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1028 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1029 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1030 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1031 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1032 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1033 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1034 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1035 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1041 /// construct SubprogramDIE - Construct subprogram DIE.
1042 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1045 // Check for pre-existence.
1046 CompileUnit *TheCU = getCompileUnit(N);
1047 if (TheCU->getDIE(N))
1050 if (!SP.isDefinition())
1051 // This is a method declaration which will be handled while constructing
1055 DIE *SubprogramDie = createSubprogramDIE(SP);
1058 TheCU->insertDIE(N, SubprogramDie);
1060 // Add to context owner.
1061 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1063 // Expose as global.
1064 TheCU->addGlobal(SP.getName(), SubprogramDie);
1069 /// beginModule - Emit all Dwarf sections that should come prior to the
1070 /// content. Create global DIEs and emit initial debug info sections.
1071 /// This is inovked by the target AsmPrinter.
1072 void DwarfDebug::beginModule(Module *M) {
1073 if (DisableDebugInfoPrinting)
1076 // If module has named metadata anchors then use them, otherwise scan the module
1077 // using debug info finder to collect debug info.
1078 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1081 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1082 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1083 if (!GV_Nodes && !SP_Nodes)
1084 // If there are not any global variables or any functions then
1085 // there is not any debug info in this module.
1088 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1089 constructCompileUnit(CU_Nodes->getOperand(i));
1092 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1093 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1096 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1097 constructSubprogramDIE(SP_Nodes->getOperand(i));
1101 DebugInfoFinder DbgFinder;
1102 DbgFinder.processModule(*M);
1104 bool HasDebugInfo = false;
1105 // Scan all the compile-units to see if there are any marked as the main unit.
1106 // if not, we do not generate debug info.
1107 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1108 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1109 if (DICompileUnit(*I).isMain()) {
1110 HasDebugInfo = true;
1114 if (!HasDebugInfo) return;
1116 // Create all the compile unit DIEs.
1117 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1118 E = DbgFinder.compile_unit_end(); I != E; ++I)
1119 constructCompileUnit(*I);
1121 // Create DIEs for each global variable.
1122 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1123 E = DbgFinder.global_variable_end(); I != E; ++I)
1124 constructGlobalVariableDIE(*I);
1126 // Create DIEs for each subprogram.
1127 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1128 E = DbgFinder.subprogram_end(); I != E; ++I)
1129 constructSubprogramDIE(*I);
1132 // Tell MMI that we have debug info.
1133 MMI->setDebugInfoAvailability(true);
1135 // Emit initial sections.
1136 EmitSectionLabels();
1138 //getOrCreateTypeDIE
1139 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1140 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1141 DIType Ty(NMD->getOperand(i));
1142 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1145 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1146 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1147 DIType Ty(NMD->getOperand(i));
1148 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1151 // Prime section data.
1152 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1155 /// endModule - Emit all Dwarf sections that should come after the content.
1157 void DwarfDebug::endModule() {
1158 if (!FirstCU) return;
1159 const Module *M = MMI->getModule();
1160 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1161 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1162 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1163 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1164 DISubprogram SP(AllSPs->getOperand(SI));
1165 if (!SP.Verify()) continue;
1167 // Collect info for variables that were optimized out.
1168 if (!SP.isDefinition()) continue;
1169 StringRef FName = SP.getLinkageName();
1171 FName = SP.getName();
1172 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1174 unsigned E = NMD->getNumOperands();
1176 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1177 DeadFnScopeMap[SP] = Scope;
1178 for (unsigned I = 0; I != E; ++I) {
1179 DIVariable DV(NMD->getOperand(I));
1180 if (!DV.Verify()) continue;
1181 Scope->addVariable(new DbgVariable(DV));
1184 // Construct subprogram DIE and add variables DIEs.
1185 constructSubprogramDIE(SP);
1186 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1187 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1188 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1189 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1191 ScopeDIE->addChild(VariableDIE);
1196 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1197 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1198 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1200 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1203 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1204 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1205 DIE *SPDie = CI->first;
1206 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1208 DIE *NDie = getCompileUnit(N)->getDIE(N);
1209 if (!NDie) continue;
1210 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1211 dwarf::DW_FORM_ref4, NDie);
1214 // Standard sections final addresses.
1215 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1216 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1217 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1218 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1220 // End text sections.
1221 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1222 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1223 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1226 // Compute DIE offsets and sizes.
1227 computeSizeAndOffsets();
1229 // Emit all the DIEs into a debug info section
1232 // Corresponding abbreviations into a abbrev section.
1233 emitAbbreviations();
1235 // Emit info into a debug pubnames section.
1236 emitDebugPubNames();
1238 // Emit info into a debug pubtypes section.
1239 emitDebugPubTypes();
1241 // Emit info into a debug loc section.
1244 // Emit info into a debug aranges section.
1247 // Emit info into a debug ranges section.
1250 // Emit info into a debug macinfo section.
1253 // Emit inline info.
1254 emitDebugInlineInfo();
1256 // Emit info into a debug str section.
1260 DeleteContainerSeconds(DeadFnScopeMap);
1261 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1262 E = CUMap.end(); I != E; ++I)
1264 FirstCU = NULL; // Reset for the next Module, if any.
1267 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1268 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1269 DebugLoc ScopeLoc) {
1271 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1273 return AbsDbgVariable;
1275 LLVMContext &Ctx = Var->getContext();
1276 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1280 AbsDbgVariable = new DbgVariable(Var);
1281 Scope->addVariable(AbsDbgVariable);
1282 AbstractVariables[Var] = AbsDbgVariable;
1283 return AbsDbgVariable;
1286 /// addCurrentFnArgument - If Var is an current function argument that add
1287 /// it in CurrentFnArguments list.
1288 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1289 DbgVariable *Var, DbgScope *Scope) {
1290 if (Scope != CurrentFnDbgScope)
1292 DIVariable DV = Var->getVariable();
1293 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1295 unsigned ArgNo = DV.getArgNumber();
1299 size_t Size = CurrentFnArguments.size();
1301 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1302 // llvm::Function argument size is not good indicator of how many
1303 // arguments does the function have at source level.
1305 CurrentFnArguments.resize(ArgNo * 2);
1306 CurrentFnArguments[ArgNo - 1] = Var;
1310 /// collectVariableInfoFromMMITable - Collect variable information from
1311 /// side table maintained by MMI.
1313 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1314 SmallPtrSet<const MDNode *, 16> &Processed) {
1315 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1316 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1317 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1318 VE = VMap.end(); VI != VE; ++VI) {
1319 const MDNode *Var = VI->first;
1321 Processed.insert(Var);
1323 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1325 DbgScope *Scope = 0;
1326 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
1327 Scope = ConcreteScopes.lookup(IA);
1329 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
1331 // If variable scope is not found then skip this variable.
1335 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1336 DbgVariable *RegVar = new DbgVariable(DV);
1337 recordVariableFrameIndex(RegVar, VP.first);
1338 if (!addCurrentFnArgument(MF, RegVar, Scope))
1339 Scope->addVariable(RegVar);
1340 if (AbsDbgVariable) {
1341 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1342 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1347 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1348 /// DBG_VALUE instruction, is in a defined reg.
1349 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1350 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1351 return MI->getNumOperands() == 3 &&
1352 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1353 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1356 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1358 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1359 SmallPtrSet<const MDNode *, 16> &Processed) {
1361 /// collection info from MMI table.
1362 collectVariableInfoFromMMITable(MF, Processed);
1364 for (SmallVectorImpl<const MDNode*>::const_iterator
1365 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1367 const MDNode *Var = *UVI;
1368 if (Processed.count(Var))
1371 // History contains relevant DBG_VALUE instructions for Var and instructions
1373 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1374 if (History.empty())
1376 const MachineInstr *MInsn = History.front();
1379 DbgScope *Scope = NULL;
1380 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1381 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1382 Scope = CurrentFnDbgScope;
1384 Scope = findDbgScope(MInsn);
1385 // If variable scope is not found then skip this variable.
1389 Processed.insert(DV);
1390 assert(MInsn->isDebugValue() && "History must begin with debug value");
1391 DbgVariable *RegVar = new DbgVariable(DV);
1392 if (!addCurrentFnArgument(MF, RegVar, Scope))
1393 Scope->addVariable(RegVar);
1394 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1395 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1396 VarToAbstractVarMap[RegVar] = AbsVar;
1399 // Simple ranges that are fully coalesced.
1400 if (History.size() <= 1 || (History.size() == 2 &&
1401 MInsn->isIdenticalTo(History.back()))) {
1402 DbgVariableToDbgInstMap[RegVar] = MInsn;
1406 // handle multiple DBG_VALUE instructions describing one variable.
1407 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1409 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1410 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1411 const MachineInstr *Begin = *HI;
1412 assert(Begin->isDebugValue() && "Invalid History entry");
1413 MachineLocation MLoc;
1414 if (Begin->getNumOperands() == 3) {
1415 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
1416 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
1418 MLoc = Asm->getDebugValueLocation(Begin);
1420 // FIXME: emitDebugLoc only understands registers.
1424 // Compute the range for a register location.
1425 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1426 const MCSymbol *SLabel = 0;
1429 // If Begin is the last instruction in History then its value is valid
1430 // until the end of the function.
1431 SLabel = FunctionEndSym;
1433 const MachineInstr *End = HI[1];
1434 if (End->isDebugValue())
1435 SLabel = getLabelBeforeInsn(End);
1437 // End is a normal instruction clobbering the range.
1438 SLabel = getLabelAfterInsn(End);
1439 assert(SLabel && "Forgot label after clobber instruction");
1444 // The value is valid until the next DBG_VALUE or clobber.
1445 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc, Var));
1447 DotDebugLocEntries.push_back(DotDebugLocEntry());
1450 // Collect info for variables that were optimized out.
1451 const Function *F = MF->getFunction();
1452 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1453 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1454 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1455 if (!DV || !Processed.insert(DV))
1457 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1459 Scope->addVariable(new DbgVariable(DV));
1464 /// getLabelBeforeInsn - Return Label preceding the instruction.
1465 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1466 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1467 assert(Label && "Didn't insert label before instruction");
1471 /// getLabelAfterInsn - Return Label immediately following the instruction.
1472 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1473 return LabelsAfterInsn.lookup(MI);
1476 /// beginInstruction - Process beginning of an instruction.
1477 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1478 // Check if source location changes, but ignore DBG_VALUE locations.
1479 if (!MI->isDebugValue()) {
1480 DebugLoc DL = MI->getDebugLoc();
1481 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1482 unsigned Flags = DWARF2_FLAG_IS_STMT;
1484 if (DL == PrologEndLoc) {
1485 Flags |= DWARF2_FLAG_PROLOGUE_END;
1486 PrologEndLoc = DebugLoc();
1488 if (!DL.isUnknown()) {
1489 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1490 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1492 recordSourceLine(0, 0, 0, 0);
1496 // Insert labels where requested.
1497 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1498 LabelsBeforeInsn.find(MI);
1501 if (I == LabelsBeforeInsn.end())
1504 // Label already assigned.
1509 PrevLabel = MMI->getContext().CreateTempSymbol();
1510 Asm->OutStreamer.EmitLabel(PrevLabel);
1512 I->second = PrevLabel;
1515 /// endInstruction - Process end of an instruction.
1516 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1517 // Don't create a new label after DBG_VALUE instructions.
1518 // They don't generate code.
1519 if (!MI->isDebugValue())
1522 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1523 LabelsAfterInsn.find(MI);
1526 if (I == LabelsAfterInsn.end())
1529 // Label already assigned.
1533 // We need a label after this instruction.
1535 PrevLabel = MMI->getContext().CreateTempSymbol();
1536 Asm->OutStreamer.EmitLabel(PrevLabel);
1538 I->second = PrevLabel;
1541 /// getOrCreateDbgScope - Create DbgScope for the scope.
1542 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
1543 const MDNode *InlinedAt) {
1545 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1548 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1549 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1550 if (DIDescriptor(Scope).isLexicalBlock()) {
1552 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
1553 WScope->setParent(Parent);
1554 Parent->addScope(WScope);
1557 if (!WScope->getParent()) {
1558 StringRef SPName = DISubprogram(Scope).getLinkageName();
1559 // We used to check only for a linkage name, but that fails
1560 // since we began omitting the linkage name for private
1561 // functions. The new way is to check for the name in metadata,
1562 // but that's not supported in old .ll test cases. Ergo, we
1564 if (SPName == Asm->MF->getFunction()->getName() ||
1565 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
1566 CurrentFnDbgScope = WScope;
1572 getOrCreateAbstractScope(Scope);
1573 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1577 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1578 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1579 DILocation DL(InlinedAt);
1581 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
1582 WScope->setParent(Parent);
1583 Parent->addScope(WScope);
1585 ConcreteScopes[InlinedAt] = WScope;
1590 /// hasValidLocation - Return true if debug location entry attached with
1591 /// machine instruction encodes valid location info.
1592 static bool hasValidLocation(LLVMContext &Ctx,
1593 const MachineInstr *MInsn,
1594 const MDNode *&Scope, const MDNode *&InlinedAt) {
1595 DebugLoc DL = MInsn->getDebugLoc();
1596 if (DL.isUnknown()) return false;
1598 const MDNode *S = DL.getScope(Ctx);
1600 // There is no need to create another DIE for compile unit. For all
1601 // other scopes, create one DbgScope now. This will be translated
1602 // into a scope DIE at the end.
1603 if (DIScope(S).isCompileUnit()) return false;
1606 InlinedAt = DL.getInlinedAt(Ctx);
1610 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1612 static void calculateDominanceGraph(DbgScope *Scope) {
1613 assert (Scope && "Unable to calculate scop edominance graph!");
1614 SmallVector<DbgScope *, 4> WorkStack;
1615 WorkStack.push_back(Scope);
1616 unsigned Counter = 0;
1617 while (!WorkStack.empty()) {
1618 DbgScope *WS = WorkStack.back();
1619 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1620 bool visitedChildren = false;
1621 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1622 SE = Children.end(); SI != SE; ++SI) {
1623 DbgScope *ChildScope = *SI;
1624 if (!ChildScope->getDFSOut()) {
1625 WorkStack.push_back(ChildScope);
1626 visitedChildren = true;
1627 ChildScope->setDFSIn(++Counter);
1631 if (!visitedChildren) {
1632 WorkStack.pop_back();
1633 WS->setDFSOut(++Counter);
1638 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1640 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1641 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1644 unsigned PrevDFSIn = 0;
1645 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1647 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1649 const MachineInstr *MInsn = II;
1650 const MDNode *Scope = NULL;
1651 const MDNode *InlinedAt = NULL;
1653 // Check if instruction has valid location information.
1654 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1658 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1659 MI2ScopeMap.find(MInsn);
1660 if (DI != MI2ScopeMap.end()) {
1661 DbgScope *S = DI->second;
1662 dbgs() << S->getDFSIn();
1663 PrevDFSIn = S->getDFSIn();
1665 dbgs() << PrevDFSIn;
1667 dbgs() << " [ x" << PrevDFSIn;
1675 /// extractScopeInformation - Scan machine instructions in this function
1676 /// and collect DbgScopes. Return true, if at least one scope was found.
1677 bool DwarfDebug::extractScopeInformation() {
1678 // If scope information was extracted using .dbg intrinsics then there is not
1679 // any need to extract these information by scanning each instruction.
1680 if (!DbgScopeMap.empty())
1683 // Scan each instruction and create scopes. First build working set of scopes.
1684 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1685 SmallVector<DbgRange, 4> MIRanges;
1686 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1687 const MDNode *PrevScope = NULL;
1688 const MDNode *PrevInlinedAt = NULL;
1689 const MachineInstr *RangeBeginMI = NULL;
1690 const MachineInstr *PrevMI = NULL;
1691 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1693 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1695 const MachineInstr *MInsn = II;
1696 const MDNode *Scope = NULL;
1697 const MDNode *InlinedAt = NULL;
1699 // Check if instruction has valid location information.
1700 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1705 // If scope has not changed then skip this instruction.
1706 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
1711 // Ignore DBG_VALUE. It does not contribute any instruction in output.
1712 if (MInsn->isDebugValue())
1716 // If we have alread seen a beginning of a instruction range and
1717 // current instruction scope does not match scope of first instruction
1718 // in this range then create a new instruction range.
1719 DbgRange R(RangeBeginMI, PrevMI);
1720 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
1722 MIRanges.push_back(R);
1725 // This is a beginning of a new instruction range.
1726 RangeBeginMI = MInsn;
1728 // Reset previous markers.
1731 PrevInlinedAt = InlinedAt;
1735 // Create last instruction range.
1736 if (RangeBeginMI && PrevMI && PrevScope) {
1737 DbgRange R(RangeBeginMI, PrevMI);
1738 MIRanges.push_back(R);
1739 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
1742 if (!CurrentFnDbgScope)
1745 calculateDominanceGraph(CurrentFnDbgScope);
1747 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1749 // Find ranges of instructions covered by each DbgScope;
1750 DbgScope *PrevDbgScope = NULL;
1751 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1752 RE = MIRanges.end(); RI != RE; ++RI) {
1753 const DbgRange &R = *RI;
1754 DbgScope *S = MI2ScopeMap.lookup(R.first);
1755 assert (S && "Lost DbgScope for a machine instruction!");
1756 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1757 PrevDbgScope->closeInsnRange(S);
1758 S->openInsnRange(R.first);
1759 S->extendInsnRange(R.second);
1764 PrevDbgScope->closeInsnRange();
1766 identifyScopeMarkers();
1768 return !DbgScopeMap.empty();
1771 /// identifyScopeMarkers() -
1772 /// Each DbgScope has first instruction and last instruction to mark beginning
1773 /// and end of a scope respectively. Create an inverse map that list scopes
1774 /// starts (and ends) with an instruction. One instruction may start (or end)
1775 /// multiple scopes. Ignore scopes that are not reachable.
1776 void DwarfDebug::identifyScopeMarkers() {
1777 SmallVector<DbgScope *, 4> WorkList;
1778 WorkList.push_back(CurrentFnDbgScope);
1779 while (!WorkList.empty()) {
1780 DbgScope *S = WorkList.pop_back_val();
1782 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1783 if (!Children.empty())
1784 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1785 SE = Children.end(); SI != SE; ++SI)
1786 WorkList.push_back(*SI);
1788 if (S->isAbstractScope())
1791 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1794 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1795 RE = Ranges.end(); RI != RE; ++RI) {
1796 assert(RI->first && "DbgRange does not have first instruction!");
1797 assert(RI->second && "DbgRange does not have second instruction!");
1798 requestLabelBeforeInsn(RI->first);
1799 requestLabelAfterInsn(RI->second);
1804 /// getScopeNode - Get MDNode for DebugLoc's scope.
1805 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1806 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1807 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1808 return DL.getScope(Ctx);
1811 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1812 /// line number info for the function.
1813 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1814 const MDNode *Scope = getScopeNode(DL, Ctx);
1815 DISubprogram SP = getDISubprogram(Scope);
1817 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1821 /// beginFunction - Gather pre-function debug information. Assumes being
1822 /// emitted immediately after the function entry point.
1823 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1824 if (!MMI->hasDebugInfo()) return;
1825 if (!extractScopeInformation()) return;
1827 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1828 Asm->getFunctionNumber());
1829 // Assumes in correct section after the entry point.
1830 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1832 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1834 /// ProcessedArgs - Collection of arguments already processed.
1835 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
1836 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1837 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1838 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1840 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1842 bool AtBlockEntry = true;
1843 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1845 const MachineInstr *MI = II;
1847 if (MI->isDebugValue()) {
1848 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1850 // Keep track of user variables.
1852 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1854 // Variable is in a register, we need to check for clobbers.
1855 if (isDbgValueInDefinedReg(MI))
1856 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1858 // Check the history of this variable.
1859 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1860 if (History.empty()) {
1861 UserVariables.push_back(Var);
1862 // The first mention of a function argument gets the FunctionBeginSym
1863 // label, so arguments are visible when breaking at function entry.
1865 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1866 DISubprogram(getDISubprogram(DV.getContext()))
1867 .describes(MF->getFunction()))
1868 LabelsBeforeInsn[MI] = FunctionBeginSym;
1870 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1871 const MachineInstr *Prev = History.back();
1872 if (Prev->isDebugValue()) {
1873 // Coalesce identical entries at the end of History.
1874 if (History.size() >= 2 &&
1875 Prev->isIdenticalTo(History[History.size() - 2]))
1878 // Terminate old register assignments that don't reach MI;
1879 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1880 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1881 isDbgValueInDefinedReg(Prev)) {
1882 // Previous register assignment needs to terminate at the end of
1884 MachineBasicBlock::const_iterator LastMI =
1885 PrevMBB->getLastNonDebugInstr();
1886 if (LastMI == PrevMBB->end())
1887 // Drop DBG_VALUE for empty range.
1890 // Terminate after LastMI.
1891 History.push_back(LastMI);
1896 History.push_back(MI);
1898 // Not a DBG_VALUE instruction.
1900 AtBlockEntry = false;
1902 // First known non DBG_VALUE location marks beginning of function
1904 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1905 PrologEndLoc = MI->getDebugLoc();
1907 // Check if the instruction clobbers any registers with debug vars.
1908 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1909 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1910 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1912 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1913 unsigned Reg = *AI; ++AI) {
1914 const MDNode *Var = LiveUserVar[Reg];
1917 // Reg is now clobbered.
1918 LiveUserVar[Reg] = 0;
1920 // Was MD last defined by a DBG_VALUE referring to Reg?
1921 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1922 if (HistI == DbgValues.end())
1924 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1925 if (History.empty())
1927 const MachineInstr *Prev = History.back();
1928 // Sanity-check: Register assignments are terminated at the end of
1930 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1932 // Is the variable still in Reg?
1933 if (!isDbgValueInDefinedReg(Prev) ||
1934 Prev->getOperand(0).getReg() != Reg)
1936 // Var is clobbered. Make sure the next instruction gets a label.
1937 History.push_back(MI);
1944 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1946 SmallVectorImpl<const MachineInstr*> &History = I->second;
1947 if (History.empty())
1950 // Make sure the final register assignments are terminated.
1951 const MachineInstr *Prev = History.back();
1952 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1953 const MachineBasicBlock *PrevMBB = Prev->getParent();
1954 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1955 if (LastMI == PrevMBB->end())
1956 // Drop DBG_VALUE for empty range.
1959 // Terminate after LastMI.
1960 History.push_back(LastMI);
1963 // Request labels for the full history.
1964 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1965 const MachineInstr *MI = History[i];
1966 if (MI->isDebugValue())
1967 requestLabelBeforeInsn(MI);
1969 requestLabelAfterInsn(MI);
1973 PrevInstLoc = DebugLoc();
1974 PrevLabel = FunctionBeginSym;
1976 // Record beginning of function.
1977 if (!PrologEndLoc.isUnknown()) {
1978 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1979 MF->getFunction()->getContext());
1980 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1981 FnStartDL.getScope(MF->getFunction()->getContext()),
1982 DWARF2_FLAG_IS_STMT);
1986 /// endFunction - Gather and emit post-function debug information.
1988 void DwarfDebug::endFunction(const MachineFunction *MF) {
1989 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
1991 if (CurrentFnDbgScope) {
1993 // Define end label for subprogram.
1994 FunctionEndSym = Asm->GetTempSymbol("func_end",
1995 Asm->getFunctionNumber());
1996 // Assumes in correct section after the entry point.
1997 Asm->OutStreamer.EmitLabel(FunctionEndSym);
1999 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2000 collectVariableInfo(MF, ProcessedVars);
2002 // Construct abstract scopes.
2003 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2004 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2005 DISubprogram SP((*AI)->getScopeNode());
2007 // Collect info for variables that were optimized out.
2008 StringRef FName = SP.getLinkageName();
2010 FName = SP.getName();
2011 if (NamedMDNode *NMD =
2012 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2013 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2014 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2015 if (!DV || !ProcessedVars.insert(DV))
2017 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2019 Scope->addVariable(new DbgVariable(DV));
2023 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2024 constructScopeDIE(*AI);
2027 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2029 if (!DisableFramePointerElim(*MF))
2030 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2031 dwarf::DW_AT_APPLE_omit_frame_ptr,
2032 dwarf::DW_FORM_flag, 1);
2035 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2036 MMI->getFrameMoves()));
2040 CurrentFnDbgScope = NULL;
2041 DeleteContainerPointers(CurrentFnArguments);
2042 DbgVariableToFrameIndexMap.clear();
2043 VarToAbstractVarMap.clear();
2044 DbgVariableToDbgInstMap.clear();
2045 DeleteContainerSeconds(DbgScopeMap);
2046 UserVariables.clear();
2048 ConcreteScopes.clear();
2049 DeleteContainerSeconds(AbstractScopes);
2050 AbstractScopesList.clear();
2051 AbstractVariables.clear();
2052 LabelsBeforeInsn.clear();
2053 LabelsAfterInsn.clear();
2057 /// recordVariableFrameIndex - Record a variable's index.
2058 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2059 assert (V && "Invalid DbgVariable!");
2060 DbgVariableToFrameIndexMap[V] = Index;
2063 /// findVariableFrameIndex - Return true if frame index for the variable
2064 /// is found. Update FI to hold value of the index.
2065 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2066 assert (V && "Invalid DbgVariable!");
2067 DenseMap<const DbgVariable *, int>::iterator I =
2068 DbgVariableToFrameIndexMap.find(V);
2069 if (I == DbgVariableToFrameIndexMap.end())
2075 /// findDbgScope - Find DbgScope for the debug loc attached with an
2077 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2078 DbgScope *Scope = NULL;
2080 MInsn->getParent()->getParent()->getFunction()->getContext();
2081 DebugLoc DL = MInsn->getDebugLoc();
2086 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2087 Scope = ConcreteScopes.lookup(IA);
2089 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2095 /// recordSourceLine - Register a source line with debug info. Returns the
2096 /// unique label that was emitted and which provides correspondence to
2097 /// the source line list.
2098 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2104 DIDescriptor Scope(S);
2106 if (Scope.isCompileUnit()) {
2107 DICompileUnit CU(S);
2108 Fn = CU.getFilename();
2109 Dir = CU.getDirectory();
2110 } else if (Scope.isFile()) {
2112 Fn = F.getFilename();
2113 Dir = F.getDirectory();
2114 } else if (Scope.isSubprogram()) {
2116 Fn = SP.getFilename();
2117 Dir = SP.getDirectory();
2118 } else if (Scope.isLexicalBlock()) {
2119 DILexicalBlock DB(S);
2120 Fn = DB.getFilename();
2121 Dir = DB.getDirectory();
2123 assert(0 && "Unexpected scope info");
2125 Src = GetOrCreateSourceID(Fn, Dir);
2127 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2131 //===----------------------------------------------------------------------===//
2133 //===----------------------------------------------------------------------===//
2135 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2138 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2139 // Get the children.
2140 const std::vector<DIE *> &Children = Die->getChildren();
2142 // If not last sibling and has children then add sibling offset attribute.
2143 if (!Last && !Children.empty())
2144 Die->addSiblingOffset(DIEValueAllocator);
2146 // Record the abbreviation.
2147 assignAbbrevNumber(Die->getAbbrev());
2149 // Get the abbreviation for this DIE.
2150 unsigned AbbrevNumber = Die->getAbbrevNumber();
2151 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2154 Die->setOffset(Offset);
2156 // Start the size with the size of abbreviation code.
2157 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2159 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2160 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2162 // Size the DIE attribute values.
2163 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2164 // Size attribute value.
2165 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2167 // Size the DIE children if any.
2168 if (!Children.empty()) {
2169 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2170 "Children flag not set");
2172 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2173 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2175 // End of children marker.
2176 Offset += sizeof(int8_t);
2179 Die->setSize(Offset - Die->getOffset());
2183 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2185 void DwarfDebug::computeSizeAndOffsets() {
2186 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2187 E = CUMap.end(); I != E; ++I) {
2188 // Compute size of compile unit header.
2190 sizeof(int32_t) + // Length of Compilation Unit Info
2191 sizeof(int16_t) + // DWARF version number
2192 sizeof(int32_t) + // Offset Into Abbrev. Section
2193 sizeof(int8_t); // Pointer Size (in bytes)
2194 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2198 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2199 /// temporary label to it if SymbolStem is specified.
2200 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2201 const char *SymbolStem = 0) {
2202 Asm->OutStreamer.SwitchSection(Section);
2203 if (!SymbolStem) return 0;
2205 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2206 Asm->OutStreamer.EmitLabel(TmpSym);
2210 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2211 /// the start of each one.
2212 void DwarfDebug::EmitSectionLabels() {
2213 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2215 // Dwarf sections base addresses.
2216 DwarfInfoSectionSym =
2217 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2218 DwarfAbbrevSectionSym =
2219 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2220 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2222 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2223 EmitSectionSym(Asm, MacroInfo);
2225 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2226 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2227 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2228 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2229 DwarfStrSectionSym =
2230 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2231 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2234 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2235 "section_debug_loc");
2237 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2238 EmitSectionSym(Asm, TLOF.getDataSection());
2241 /// emitDIE - Recusively Emits a debug information entry.
2243 void DwarfDebug::emitDIE(DIE *Die) {
2244 // Get the abbreviation for this DIE.
2245 unsigned AbbrevNumber = Die->getAbbrevNumber();
2246 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2248 // Emit the code (index) for the abbreviation.
2249 if (Asm->isVerbose())
2250 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2251 Twine::utohexstr(Die->getOffset()) + ":0x" +
2252 Twine::utohexstr(Die->getSize()) + " " +
2253 dwarf::TagString(Abbrev->getTag()));
2254 Asm->EmitULEB128(AbbrevNumber);
2256 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2257 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2259 // Emit the DIE attribute values.
2260 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2261 unsigned Attr = AbbrevData[i].getAttribute();
2262 unsigned Form = AbbrevData[i].getForm();
2263 assert(Form && "Too many attributes for DIE (check abbreviation)");
2265 if (Asm->isVerbose())
2266 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2269 case dwarf::DW_AT_sibling:
2270 Asm->EmitInt32(Die->getSiblingOffset());
2272 case dwarf::DW_AT_abstract_origin: {
2273 DIEEntry *E = cast<DIEEntry>(Values[i]);
2274 DIE *Origin = E->getEntry();
2275 unsigned Addr = Origin->getOffset();
2276 Asm->EmitInt32(Addr);
2279 case dwarf::DW_AT_ranges: {
2280 // DW_AT_range Value encodes offset in debug_range section.
2281 DIEInteger *V = cast<DIEInteger>(Values[i]);
2283 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2284 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2288 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2290 DwarfDebugRangeSectionSym,
2295 case dwarf::DW_AT_location: {
2296 if (UseDotDebugLocEntry.count(Die) != 0) {
2297 DIELabel *L = cast<DIELabel>(Values[i]);
2298 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2300 Values[i]->EmitValue(Asm, Form);
2303 case dwarf::DW_AT_accessibility: {
2304 if (Asm->isVerbose()) {
2305 DIEInteger *V = cast<DIEInteger>(Values[i]);
2306 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2308 Values[i]->EmitValue(Asm, Form);
2312 // Emit an attribute using the defined form.
2313 Values[i]->EmitValue(Asm, Form);
2318 // Emit the DIE children if any.
2319 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2320 const std::vector<DIE *> &Children = Die->getChildren();
2322 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2323 emitDIE(Children[j]);
2325 if (Asm->isVerbose())
2326 Asm->OutStreamer.AddComment("End Of Children Mark");
2331 /// emitDebugInfo - Emit the debug info section.
2333 void DwarfDebug::emitDebugInfo() {
2334 // Start debug info section.
2335 Asm->OutStreamer.SwitchSection(
2336 Asm->getObjFileLowering().getDwarfInfoSection());
2337 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2338 E = CUMap.end(); I != E; ++I) {
2339 CompileUnit *TheCU = I->second;
2340 DIE *Die = TheCU->getCUDie();
2342 // Emit the compile units header.
2343 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2346 // Emit size of content not including length itself
2347 unsigned ContentSize = Die->getSize() +
2348 sizeof(int16_t) + // DWARF version number
2349 sizeof(int32_t) + // Offset Into Abbrev. Section
2350 sizeof(int8_t); // Pointer Size (in bytes)
2352 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2353 Asm->EmitInt32(ContentSize);
2354 Asm->OutStreamer.AddComment("DWARF version number");
2355 Asm->EmitInt16(dwarf::DWARF_VERSION);
2356 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2357 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2358 DwarfAbbrevSectionSym);
2359 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2360 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2363 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2367 /// emitAbbreviations - Emit the abbreviation section.
2369 void DwarfDebug::emitAbbreviations() const {
2370 // Check to see if it is worth the effort.
2371 if (!Abbreviations.empty()) {
2372 // Start the debug abbrev section.
2373 Asm->OutStreamer.SwitchSection(
2374 Asm->getObjFileLowering().getDwarfAbbrevSection());
2376 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2378 // For each abbrevation.
2379 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2380 // Get abbreviation data
2381 const DIEAbbrev *Abbrev = Abbreviations[i];
2383 // Emit the abbrevations code (base 1 index.)
2384 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2386 // Emit the abbreviations data.
2390 // Mark end of abbreviations.
2391 Asm->EmitULEB128(0, "EOM(3)");
2393 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2397 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2398 /// the line matrix.
2400 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2401 // Define last address of section.
2402 Asm->OutStreamer.AddComment("Extended Op");
2405 Asm->OutStreamer.AddComment("Op size");
2406 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2407 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2408 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2410 Asm->OutStreamer.AddComment("Section end label");
2412 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2413 Asm->getTargetData().getPointerSize(),
2416 // Mark end of matrix.
2417 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2423 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2425 void DwarfDebug::emitDebugPubNames() {
2426 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2427 E = CUMap.end(); I != E; ++I) {
2428 CompileUnit *TheCU = I->second;
2429 // Start the dwarf pubnames section.
2430 Asm->OutStreamer.SwitchSection(
2431 Asm->getObjFileLowering().getDwarfPubNamesSection());
2433 Asm->OutStreamer.AddComment("Length of Public Names Info");
2434 Asm->EmitLabelDifference(
2435 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2436 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2438 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2441 Asm->OutStreamer.AddComment("DWARF Version");
2442 Asm->EmitInt16(dwarf::DWARF_VERSION);
2444 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2445 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2446 DwarfInfoSectionSym);
2448 Asm->OutStreamer.AddComment("Compilation Unit Length");
2449 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2450 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2453 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2454 for (StringMap<DIE*>::const_iterator
2455 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2456 const char *Name = GI->getKeyData();
2457 DIE *Entity = GI->second;
2459 Asm->OutStreamer.AddComment("DIE offset");
2460 Asm->EmitInt32(Entity->getOffset());
2462 if (Asm->isVerbose())
2463 Asm->OutStreamer.AddComment("External Name");
2464 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2467 Asm->OutStreamer.AddComment("End Mark");
2469 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2474 void DwarfDebug::emitDebugPubTypes() {
2475 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2476 E = CUMap.end(); I != E; ++I) {
2477 CompileUnit *TheCU = I->second;
2478 // Start the dwarf pubnames section.
2479 Asm->OutStreamer.SwitchSection(
2480 Asm->getObjFileLowering().getDwarfPubTypesSection());
2481 Asm->OutStreamer.AddComment("Length of Public Types Info");
2482 Asm->EmitLabelDifference(
2483 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2484 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2486 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2489 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2490 Asm->EmitInt16(dwarf::DWARF_VERSION);
2492 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2493 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2494 DwarfInfoSectionSym);
2496 Asm->OutStreamer.AddComment("Compilation Unit Length");
2497 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2498 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2501 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2502 for (StringMap<DIE*>::const_iterator
2503 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2504 const char *Name = GI->getKeyData();
2505 DIE * Entity = GI->second;
2507 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2508 Asm->EmitInt32(Entity->getOffset());
2510 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2511 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2514 Asm->OutStreamer.AddComment("End Mark");
2516 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2521 /// emitDebugStr - Emit visible names into a debug str section.
2523 void DwarfDebug::emitDebugStr() {
2524 // Check to see if it is worth the effort.
2525 if (StringPool.empty()) return;
2527 // Start the dwarf str section.
2528 Asm->OutStreamer.SwitchSection(
2529 Asm->getObjFileLowering().getDwarfStrSection());
2531 // Get all of the string pool entries and put them in an array by their ID so
2532 // we can sort them.
2533 SmallVector<std::pair<unsigned,
2534 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2536 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2537 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2538 Entries.push_back(std::make_pair(I->second.second, &*I));
2540 array_pod_sort(Entries.begin(), Entries.end());
2542 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2543 // Emit a label for reference from debug information entries.
2544 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2546 // Emit the string itself.
2547 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2551 /// emitDebugLoc - Emit visible names into a debug loc section.
2553 void DwarfDebug::emitDebugLoc() {
2554 if (DotDebugLocEntries.empty())
2557 for (SmallVector<DotDebugLocEntry, 4>::iterator
2558 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2560 DotDebugLocEntry &Entry = *I;
2561 if (I + 1 != DotDebugLocEntries.end())
2565 // Start the dwarf loc section.
2566 Asm->OutStreamer.SwitchSection(
2567 Asm->getObjFileLowering().getDwarfLocSection());
2568 unsigned char Size = Asm->getTargetData().getPointerSize();
2569 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2571 for (SmallVector<DotDebugLocEntry, 4>::iterator
2572 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2573 I != E; ++I, ++index) {
2574 DotDebugLocEntry &Entry = *I;
2575 if (Entry.isMerged()) continue;
2576 if (Entry.isEmpty()) {
2577 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2578 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2579 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2581 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2582 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2583 DIVariable DV(Entry.Variable);
2584 Asm->OutStreamer.AddComment("Loc expr size");
2585 MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2586 MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2587 Asm->EmitLabelDifference(end, begin, 2);
2588 Asm->OutStreamer.EmitLabel(begin);
2589 if (DV.hasComplexAddress()) {
2590 unsigned N = DV.getNumAddrElements();
2592 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2593 if (Entry.Loc.getOffset()) {
2595 Asm->EmitDwarfRegOp(Entry.Loc);
2596 Asm->OutStreamer.AddComment("DW_OP_deref");
2597 Asm->EmitInt8(dwarf::DW_OP_deref);
2598 Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2599 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2600 Asm->EmitSLEB128(DV.getAddrElement(1));
2602 // If first address element is OpPlus then emit
2603 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2604 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2605 Asm->EmitDwarfRegOp(Loc);
2609 Asm->EmitDwarfRegOp(Entry.Loc);
2612 // Emit remaining complex address elements.
2613 for (; i < N; ++i) {
2614 uint64_t Element = DV.getAddrElement(i);
2615 if (Element == DIBuilder::OpPlus) {
2616 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2617 Asm->EmitULEB128(DV.getAddrElement(++i));
2618 } else if (Element == DIBuilder::OpDeref)
2619 Asm->EmitInt8(dwarf::DW_OP_deref);
2620 else llvm_unreachable("unknown Opcode found in complex address");
2623 Asm->EmitDwarfRegOp(Entry.Loc);
2625 Asm->OutStreamer.EmitLabel(end);
2630 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2632 void DwarfDebug::EmitDebugARanges() {
2633 // Start the dwarf aranges section.
2634 Asm->OutStreamer.SwitchSection(
2635 Asm->getObjFileLowering().getDwarfARangesSection());
2638 /// emitDebugRanges - Emit visible names into a debug ranges section.
2640 void DwarfDebug::emitDebugRanges() {
2641 // Start the dwarf ranges section.
2642 Asm->OutStreamer.SwitchSection(
2643 Asm->getObjFileLowering().getDwarfRangesSection());
2644 unsigned char Size = Asm->getTargetData().getPointerSize();
2645 for (SmallVector<const MCSymbol *, 8>::iterator
2646 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2649 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2651 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2655 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2657 void DwarfDebug::emitDebugMacInfo() {
2658 if (const MCSection *LineInfo =
2659 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2660 // Start the dwarf macinfo section.
2661 Asm->OutStreamer.SwitchSection(LineInfo);
2665 /// emitDebugInlineInfo - Emit inline info using following format.
2667 /// 1. length of section
2668 /// 2. Dwarf version number
2669 /// 3. address size.
2671 /// Entries (one "entry" for each function that was inlined):
2673 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2674 /// otherwise offset into __debug_str for regular function name.
2675 /// 2. offset into __debug_str section for regular function name.
2676 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2677 /// instances for the function.
2679 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2680 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2681 /// __debug_info section, and the low_pc is the starting address for the
2682 /// inlining instance.
2683 void DwarfDebug::emitDebugInlineInfo() {
2684 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2690 Asm->OutStreamer.SwitchSection(
2691 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2693 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2694 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2695 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2697 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2699 Asm->OutStreamer.AddComment("Dwarf Version");
2700 Asm->EmitInt16(dwarf::DWARF_VERSION);
2701 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2702 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2704 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2705 E = InlinedSPNodes.end(); I != E; ++I) {
2707 const MDNode *Node = *I;
2708 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2709 = InlineInfo.find(Node);
2710 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2711 DISubprogram SP(Node);
2712 StringRef LName = SP.getLinkageName();
2713 StringRef Name = SP.getName();
2715 Asm->OutStreamer.AddComment("MIPS linkage name");
2716 if (LName.empty()) {
2717 Asm->OutStreamer.EmitBytes(Name, 0);
2718 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2720 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2721 DwarfStrSectionSym);
2723 Asm->OutStreamer.AddComment("Function name");
2724 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2725 Asm->EmitULEB128(Labels.size(), "Inline count");
2727 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2728 LE = Labels.end(); LI != LE; ++LI) {
2729 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2730 Asm->EmitInt32(LI->second->getOffset());
2732 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2733 Asm->OutStreamer.EmitSymbolValue(LI->first,
2734 Asm->getTargetData().getPointerSize(),0);
2738 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));