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())
715 updated = VariableCU->addConstantValue(VariableDie,
716 DVInsn->getOperand(0));
717 else if (DVInsn->getOperand(0).isFPImm())
719 VariableCU->addConstantFPValue(VariableDie, DVInsn->getOperand(0));
721 VariableCU->addVariableAddress(DV, VariableDie,
722 Asm->getDebugValueLocation(DVInsn));
726 // If variableDie is not updated then DBG_VALUE instruction does not
727 // have valid variable info.
731 DV->setDIE(VariableDie);
735 // .. else use frame index, if available.
737 if (findVariableFrameIndex(DV, &FI)) {
738 unsigned FrameReg = 0;
739 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
741 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
742 MachineLocation Location(FrameReg, Offset);
743 VariableCU->addVariableAddress(DV, VariableDie, Location);
746 DV->setDIE(VariableDie);
751 /// constructScopeDIE - Construct a DIE for this scope.
752 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
753 if (!Scope || !Scope->getScopeNode())
756 SmallVector <DIE *, 8> Children;
758 // Collect arguments for current function.
759 if (Scope == CurrentFnDbgScope)
760 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
761 if (DbgVariable *ArgDV = CurrentFnArguments[i])
762 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
763 Children.push_back(Arg);
765 // Collect lexical scope childrens first.
766 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
767 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
768 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
769 Children.push_back(Variable);
770 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
771 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
772 if (DIE *Nested = constructScopeDIE(Scopes[j]))
773 Children.push_back(Nested);
774 DIScope DS(Scope->getScopeNode());
775 DIE *ScopeDIE = NULL;
776 if (Scope->getInlinedAt())
777 ScopeDIE = constructInlinedScopeDIE(Scope);
778 else if (DS.isSubprogram()) {
779 ProcessedSPNodes.insert(DS);
780 if (Scope->isAbstractScope()) {
781 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
782 // Note down abstract DIE.
784 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
787 ScopeDIE = updateSubprogramScopeDIE(DS);
790 // There is no need to emit empty lexical block DIE.
791 if (Children.empty())
793 ScopeDIE = constructLexicalScopeDIE(Scope);
796 if (!ScopeDIE) return NULL;
799 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
800 E = Children.end(); I != E; ++I)
801 ScopeDIE->addChild(*I);
803 if (DS.isSubprogram())
804 getCompileUnit(DS)->addPubTypes(DISubprogram(DS));
809 /// GetOrCreateSourceID - Look up the source id with the given directory and
810 /// source file names. If none currently exists, create a new id and insert it
811 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
814 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
816 // If FE did not provide a file name, then assume stdin.
817 if (FileName.empty())
818 return GetOrCreateSourceID("<stdin>", StringRef());
820 // MCStream expects full path name as filename.
821 if (!DirName.empty() && !FileName.startswith("/")) {
822 std::string FullPathName(DirName.data());
823 if (!DirName.endswith("/"))
825 FullPathName += FileName.data();
826 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
827 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
830 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
831 if (Entry.getValue())
832 return Entry.getValue();
834 unsigned SrcId = SourceIdMap.size();
835 Entry.setValue(SrcId);
837 // Print out a .file directive to specify files for .loc directives.
838 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
843 /// constructCompileUnit - Create new CompileUnit for the given
844 /// metadata node with tag DW_TAG_compile_unit.
845 void DwarfDebug::constructCompileUnit(const MDNode *N) {
846 DICompileUnit DIUnit(N);
847 StringRef FN = DIUnit.getFilename();
848 StringRef Dir = DIUnit.getDirectory();
849 unsigned ID = GetOrCreateSourceID(FN, Dir);
851 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
852 CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
853 NewCU->addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
854 DIUnit.getProducer());
855 NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
856 DIUnit.getLanguage());
857 NewCU->addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
858 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
859 // simplifies debug range entries.
860 NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
861 // DW_AT_stmt_list is a offset of line number information for this
862 // compile unit in debug_line section.
863 if(Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
864 NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
865 Asm->GetTempSymbol("section_line"));
867 NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
870 NewCU->addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
871 if (DIUnit.isOptimized())
872 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
874 StringRef Flags = DIUnit.getFlags();
876 NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
878 unsigned RVer = DIUnit.getRunTimeVersion();
880 NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
881 dwarf::DW_FORM_data1, RVer);
885 CUMap.insert(std::make_pair(N, NewCU));
888 /// getCompielUnit - Get CompileUnit DIE.
889 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
890 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
892 const MDNode *CUNode = NULL;
893 if (D.isCompileUnit())
895 else if (D.isSubprogram())
896 CUNode = DISubprogram(N).getCompileUnit();
898 CUNode = DIType(N).getCompileUnit();
899 else if (D.isGlobalVariable())
900 CUNode = DIGlobalVariable(N).getCompileUnit();
901 else if (D.isVariable())
902 CUNode = DIVariable(N).getCompileUnit();
903 else if (D.isNameSpace())
904 CUNode = DINameSpace(N).getCompileUnit();
906 CUNode = DIFile(N).getCompileUnit();
910 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
911 = CUMap.find(CUNode);
912 if (I == CUMap.end())
917 /// isUnsignedDIType - Return true if type encoding is unsigned.
918 static bool isUnsignedDIType(DIType Ty) {
919 DIDerivedType DTy(Ty);
921 return isUnsignedDIType(DTy.getTypeDerivedFrom());
925 unsigned Encoding = BTy.getEncoding();
926 if (Encoding == dwarf::DW_ATE_unsigned ||
927 Encoding == dwarf::DW_ATE_unsigned_char)
933 // Return const exprssion if value is a GEP to access merged global
935 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
936 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
937 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
938 if (!CE || CE->getNumOperands() != 3 ||
939 CE->getOpcode() != Instruction::GetElementPtr)
942 // First operand points to a global value.
943 if (!isa<GlobalValue>(CE->getOperand(0)))
946 // Second operand is zero.
947 const ConstantInt *CI =
948 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
949 if (!CI || !CI->isZero())
952 // Third operand is offset.
953 if (!isa<ConstantInt>(CE->getOperand(2)))
959 /// constructGlobalVariableDIE - Construct global variable DIE.
960 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
961 DIGlobalVariable GV(N);
963 // If debug information is malformed then ignore it.
964 if (GV.Verify() == false)
967 // Check for pre-existence.
968 CompileUnit *TheCU = getCompileUnit(N);
969 if (TheCU->getDIE(GV))
972 DIType GTy = GV.getType();
973 DIE *VariableDIE = new DIE(GV.getTag());
975 bool isGlobalVariable = GV.getGlobal() != NULL;
978 TheCU->addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
979 GV.getDisplayName());
980 StringRef LinkageName = GV.getLinkageName();
981 if (!LinkageName.empty() && isGlobalVariable)
982 TheCU->addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
983 dwarf::DW_FORM_string,
984 getRealLinkageName(LinkageName));
986 TheCU->addType(VariableDIE, GTy);
987 if (GTy.isCompositeType() && !GTy.getName().empty()
988 && !GTy.isForwardDecl()) {
989 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
990 assert(Entry && "Missing global type!");
991 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
994 if (!GV.isLocalToUnit()) {
995 TheCU->addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
997 TheCU->addGlobal(GV.getName(), VariableDIE);
999 // Add line number info.
1000 TheCU->addSourceLine(VariableDIE, GV);
1002 TheCU->insertDIE(N, VariableDIE);
1003 // Add to context owner.
1004 DIDescriptor GVContext = GV.getContext();
1005 TheCU->addToContextOwner(VariableDIE, GVContext);
1007 if (isGlobalVariable) {
1008 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1009 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1010 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1011 Asm->Mang->getSymbol(GV.getGlobal()));
1012 // Do not create specification DIE if context is either compile unit
1014 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1015 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1016 // Create specification DIE.
1017 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1018 TheCU->addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1019 dwarf::DW_FORM_ref4, VariableDIE);
1020 TheCU->addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1021 TheCU->addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1022 TheCU->addDie(VariableSpecDIE);
1024 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1026 } else if (ConstantInt *CI =
1027 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1028 TheCU->addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
1029 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1030 // GV is a merged global.
1031 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1032 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1033 TheCU->addLabel(Block, 0, dwarf::DW_FORM_udata,
1034 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
1035 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
1036 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1037 TheCU->addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
1038 TheCU->addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1039 TheCU->addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1045 /// construct SubprogramDIE - Construct subprogram DIE.
1046 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1049 // Check for pre-existence.
1050 CompileUnit *TheCU = getCompileUnit(N);
1051 if (TheCU->getDIE(N))
1054 if (!SP.isDefinition())
1055 // This is a method declaration which will be handled while constructing
1059 DIE *SubprogramDie = createSubprogramDIE(SP);
1062 TheCU->insertDIE(N, SubprogramDie);
1064 // Add to context owner.
1065 TheCU->addToContextOwner(SubprogramDie, SP.getContext());
1067 // Expose as global.
1068 TheCU->addGlobal(SP.getName(), SubprogramDie);
1073 /// beginModule - Emit all Dwarf sections that should come prior to the
1074 /// content. Create global DIEs and emit initial debug info sections.
1075 /// This is inovked by the target AsmPrinter.
1076 void DwarfDebug::beginModule(Module *M) {
1077 if (DisableDebugInfoPrinting)
1080 // If module has named metadata anchors then use them, otherwise scan the module
1081 // using debug info finder to collect debug info.
1082 NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
1085 NamedMDNode *GV_Nodes = M->getNamedMetadata("llvm.dbg.gv");
1086 NamedMDNode *SP_Nodes = M->getNamedMetadata("llvm.dbg.sp");
1087 if (!GV_Nodes && !SP_Nodes)
1088 // If there are not any global variables or any functions then
1089 // there is not any debug info in this module.
1092 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
1093 constructCompileUnit(CU_Nodes->getOperand(i));
1096 for (unsigned i = 0, e = GV_Nodes->getNumOperands(); i != e; ++i)
1097 constructGlobalVariableDIE(GV_Nodes->getOperand(i));
1100 for (unsigned i = 0, e = SP_Nodes->getNumOperands(); i != e; ++i)
1101 constructSubprogramDIE(SP_Nodes->getOperand(i));
1105 DebugInfoFinder DbgFinder;
1106 DbgFinder.processModule(*M);
1108 bool HasDebugInfo = false;
1109 // Scan all the compile-units to see if there are any marked as the main unit.
1110 // if not, we do not generate debug info.
1111 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1112 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1113 if (DICompileUnit(*I).isMain()) {
1114 HasDebugInfo = true;
1118 if (!HasDebugInfo) return;
1120 // Create all the compile unit DIEs.
1121 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1122 E = DbgFinder.compile_unit_end(); I != E; ++I)
1123 constructCompileUnit(*I);
1125 // Create DIEs for each global variable.
1126 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
1127 E = DbgFinder.global_variable_end(); I != E; ++I)
1128 constructGlobalVariableDIE(*I);
1130 // Create DIEs for each subprogram.
1131 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1132 E = DbgFinder.subprogram_end(); I != E; ++I)
1133 constructSubprogramDIE(*I);
1136 // Tell MMI that we have debug info.
1137 MMI->setDebugInfoAvailability(true);
1139 // Emit initial sections.
1140 EmitSectionLabels();
1142 //getOrCreateTypeDIE
1143 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
1144 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1145 DIType Ty(NMD->getOperand(i));
1146 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1149 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
1150 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1151 DIType Ty(NMD->getOperand(i));
1152 getCompileUnit(Ty)->getOrCreateTypeDIE(Ty);
1155 // Prime section data.
1156 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
1159 /// endModule - Emit all Dwarf sections that should come after the content.
1161 void DwarfDebug::endModule() {
1162 if (!FirstCU) return;
1163 const Module *M = MMI->getModule();
1164 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
1165 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
1166 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
1167 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
1168 DISubprogram SP(AllSPs->getOperand(SI));
1169 if (!SP.Verify()) continue;
1171 // Collect info for variables that were optimized out.
1172 if (!SP.isDefinition()) continue;
1173 StringRef FName = SP.getLinkageName();
1175 FName = SP.getName();
1176 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
1178 unsigned E = NMD->getNumOperands();
1180 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
1181 DeadFnScopeMap[SP] = Scope;
1182 for (unsigned I = 0; I != E; ++I) {
1183 DIVariable DV(NMD->getOperand(I));
1184 if (!DV.Verify()) continue;
1185 Scope->addVariable(new DbgVariable(DV));
1188 // Construct subprogram DIE and add variables DIEs.
1189 constructSubprogramDIE(SP);
1190 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
1191 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1192 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1193 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1195 ScopeDIE->addChild(VariableDIE);
1200 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1201 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
1202 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
1204 FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
1207 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1208 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1209 DIE *SPDie = CI->first;
1210 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
1212 DIE *NDie = getCompileUnit(N)->getDIE(N);
1213 if (!NDie) continue;
1214 getCompileUnit(N)->addDIEEntry(SPDie, dwarf::DW_AT_containing_type,
1215 dwarf::DW_FORM_ref4, NDie);
1218 // Standard sections final addresses.
1219 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1220 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1221 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1222 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1224 // End text sections.
1225 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
1226 Asm->OutStreamer.SwitchSection(SectionMap[i]);
1227 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
1230 // Compute DIE offsets and sizes.
1231 computeSizeAndOffsets();
1233 // Emit all the DIEs into a debug info section
1236 // Corresponding abbreviations into a abbrev section.
1237 emitAbbreviations();
1239 // Emit info into a debug pubnames section.
1240 emitDebugPubNames();
1242 // Emit info into a debug pubtypes section.
1243 emitDebugPubTypes();
1245 // Emit info into a debug loc section.
1248 // Emit info into a debug aranges section.
1251 // Emit info into a debug ranges section.
1254 // Emit info into a debug macinfo section.
1257 // Emit inline info.
1258 emitDebugInlineInfo();
1260 // Emit info into a debug str section.
1264 DeleteContainerSeconds(DeadFnScopeMap);
1265 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1266 E = CUMap.end(); I != E; ++I)
1268 FirstCU = NULL; // Reset for the next Module, if any.
1271 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
1272 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
1273 DebugLoc ScopeLoc) {
1275 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1277 return AbsDbgVariable;
1279 LLVMContext &Ctx = Var->getContext();
1280 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
1284 AbsDbgVariable = new DbgVariable(Var);
1285 Scope->addVariable(AbsDbgVariable);
1286 AbstractVariables[Var] = AbsDbgVariable;
1287 return AbsDbgVariable;
1290 /// addCurrentFnArgument - If Var is an current function argument that add
1291 /// it in CurrentFnArguments list.
1292 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1293 DbgVariable *Var, DbgScope *Scope) {
1294 if (Scope != CurrentFnDbgScope)
1296 DIVariable DV = Var->getVariable();
1297 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1299 unsigned ArgNo = DV.getArgNumber();
1303 size_t Size = CurrentFnArguments.size();
1305 CurrentFnArguments.resize(MF->getFunction()->arg_size());
1306 // llvm::Function argument size is not good indicator of how many
1307 // arguments does the function have at source level.
1309 CurrentFnArguments.resize(ArgNo * 2);
1310 CurrentFnArguments[ArgNo - 1] = Var;
1314 /// collectVariableInfoFromMMITable - Collect variable information from
1315 /// side table maintained by MMI.
1317 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
1318 SmallPtrSet<const MDNode *, 16> &Processed) {
1319 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1320 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1321 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1322 VE = VMap.end(); VI != VE; ++VI) {
1323 const MDNode *Var = VI->first;
1325 Processed.insert(Var);
1327 const std::pair<unsigned, DebugLoc> &VP = VI->second;
1329 DbgScope *Scope = 0;
1330 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
1331 Scope = ConcreteScopes.lookup(IA);
1333 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
1335 // If variable scope is not found then skip this variable.
1339 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1340 DbgVariable *RegVar = new DbgVariable(DV);
1341 recordVariableFrameIndex(RegVar, VP.first);
1342 if (!addCurrentFnArgument(MF, RegVar, Scope))
1343 Scope->addVariable(RegVar);
1344 if (AbsDbgVariable) {
1345 recordVariableFrameIndex(AbsDbgVariable, VP.first);
1346 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
1351 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1352 /// DBG_VALUE instruction, is in a defined reg.
1353 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1354 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1355 return MI->getNumOperands() == 3 &&
1356 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1357 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1360 /// collectVariableInfo - Populate DbgScope entries with variables' info.
1362 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1363 SmallPtrSet<const MDNode *, 16> &Processed) {
1365 /// collection info from MMI table.
1366 collectVariableInfoFromMMITable(MF, Processed);
1368 for (SmallVectorImpl<const MDNode*>::const_iterator
1369 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1371 const MDNode *Var = *UVI;
1372 if (Processed.count(Var))
1375 // History contains relevant DBG_VALUE instructions for Var and instructions
1377 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1378 if (History.empty())
1380 const MachineInstr *MInsn = History.front();
1383 DbgScope *Scope = NULL;
1384 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1385 DISubprogram(DV.getContext()).describes(MF->getFunction()))
1386 Scope = CurrentFnDbgScope;
1388 Scope = findDbgScope(MInsn);
1389 // If variable scope is not found then skip this variable.
1393 Processed.insert(DV);
1394 assert(MInsn->isDebugValue() && "History must begin with debug value");
1395 DbgVariable *RegVar = new DbgVariable(DV);
1396 if (!addCurrentFnArgument(MF, RegVar, Scope))
1397 Scope->addVariable(RegVar);
1398 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
1399 DbgVariableToDbgInstMap[AbsVar] = MInsn;
1400 VarToAbstractVarMap[RegVar] = AbsVar;
1403 // Simple ranges that are fully coalesced.
1404 if (History.size() <= 1 || (History.size() == 2 &&
1405 MInsn->isIdenticalTo(History.back()))) {
1406 DbgVariableToDbgInstMap[RegVar] = MInsn;
1410 // handle multiple DBG_VALUE instructions describing one variable.
1411 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1413 for (SmallVectorImpl<const MachineInstr*>::const_iterator
1414 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1415 const MachineInstr *Begin = *HI;
1416 assert(Begin->isDebugValue() && "Invalid History entry");
1417 MachineLocation MLoc;
1418 if (Begin->getNumOperands() == 3) {
1419 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
1420 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
1422 MLoc = Asm->getDebugValueLocation(Begin);
1424 // FIXME: emitDebugLoc only understands registers.
1428 // Compute the range for a register location.
1429 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1430 const MCSymbol *SLabel = 0;
1433 // If Begin is the last instruction in History then its value is valid
1434 // until the end of the function.
1435 SLabel = FunctionEndSym;
1437 const MachineInstr *End = HI[1];
1438 if (End->isDebugValue())
1439 SLabel = getLabelBeforeInsn(End);
1441 // End is a normal instruction clobbering the range.
1442 SLabel = getLabelAfterInsn(End);
1443 assert(SLabel && "Forgot label after clobber instruction");
1448 // The value is valid until the next DBG_VALUE or clobber.
1449 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc, Var));
1451 DotDebugLocEntries.push_back(DotDebugLocEntry());
1454 // Collect info for variables that were optimized out.
1455 const Function *F = MF->getFunction();
1456 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
1457 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1458 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1459 if (!DV || !Processed.insert(DV))
1461 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
1463 Scope->addVariable(new DbgVariable(DV));
1468 /// getLabelBeforeInsn - Return Label preceding the instruction.
1469 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1470 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1471 assert(Label && "Didn't insert label before instruction");
1475 /// getLabelAfterInsn - Return Label immediately following the instruction.
1476 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1477 return LabelsAfterInsn.lookup(MI);
1480 /// beginInstruction - Process beginning of an instruction.
1481 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1482 // Check if source location changes, but ignore DBG_VALUE locations.
1483 if (!MI->isDebugValue()) {
1484 DebugLoc DL = MI->getDebugLoc();
1485 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1486 unsigned Flags = DWARF2_FLAG_IS_STMT;
1488 if (DL == PrologEndLoc) {
1489 Flags |= DWARF2_FLAG_PROLOGUE_END;
1490 PrologEndLoc = DebugLoc();
1492 if (!DL.isUnknown()) {
1493 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1494 recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1496 recordSourceLine(0, 0, 0, 0);
1500 // Insert labels where requested.
1501 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1502 LabelsBeforeInsn.find(MI);
1505 if (I == LabelsBeforeInsn.end())
1508 // Label already assigned.
1513 PrevLabel = MMI->getContext().CreateTempSymbol();
1514 Asm->OutStreamer.EmitLabel(PrevLabel);
1516 I->second = PrevLabel;
1519 /// endInstruction - Process end of an instruction.
1520 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1521 // Don't create a new label after DBG_VALUE instructions.
1522 // They don't generate code.
1523 if (!MI->isDebugValue())
1526 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1527 LabelsAfterInsn.find(MI);
1530 if (I == LabelsAfterInsn.end())
1533 // Label already assigned.
1537 // We need a label after this instruction.
1539 PrevLabel = MMI->getContext().CreateTempSymbol();
1540 Asm->OutStreamer.EmitLabel(PrevLabel);
1542 I->second = PrevLabel;
1545 /// getOrCreateDbgScope - Create DbgScope for the scope.
1546 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
1547 const MDNode *InlinedAt) {
1549 DbgScope *WScope = DbgScopeMap.lookup(Scope);
1552 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
1553 DbgScopeMap.insert(std::make_pair(Scope, WScope));
1554 if (DIDescriptor(Scope).isLexicalBlock()) {
1556 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
1557 WScope->setParent(Parent);
1558 Parent->addScope(WScope);
1561 if (!WScope->getParent()) {
1562 StringRef SPName = DISubprogram(Scope).getLinkageName();
1563 // We used to check only for a linkage name, but that fails
1564 // since we began omitting the linkage name for private
1565 // functions. The new way is to check for the name in metadata,
1566 // but that's not supported in old .ll test cases. Ergo, we
1568 if (SPName == Asm->MF->getFunction()->getName() ||
1569 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
1570 CurrentFnDbgScope = WScope;
1576 getOrCreateAbstractScope(Scope);
1577 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
1581 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
1582 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
1583 DILocation DL(InlinedAt);
1585 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
1586 WScope->setParent(Parent);
1587 Parent->addScope(WScope);
1589 ConcreteScopes[InlinedAt] = WScope;
1594 /// hasValidLocation - Return true if debug location entry attached with
1595 /// machine instruction encodes valid location info.
1596 static bool hasValidLocation(LLVMContext &Ctx,
1597 const MachineInstr *MInsn,
1598 const MDNode *&Scope, const MDNode *&InlinedAt) {
1599 DebugLoc DL = MInsn->getDebugLoc();
1600 if (DL.isUnknown()) return false;
1602 const MDNode *S = DL.getScope(Ctx);
1604 // There is no need to create another DIE for compile unit. For all
1605 // other scopes, create one DbgScope now. This will be translated
1606 // into a scope DIE at the end.
1607 if (DIScope(S).isCompileUnit()) return false;
1610 InlinedAt = DL.getInlinedAt(Ctx);
1614 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
1616 static void calculateDominanceGraph(DbgScope *Scope) {
1617 assert (Scope && "Unable to calculate scop edominance graph!");
1618 SmallVector<DbgScope *, 4> WorkStack;
1619 WorkStack.push_back(Scope);
1620 unsigned Counter = 0;
1621 while (!WorkStack.empty()) {
1622 DbgScope *WS = WorkStack.back();
1623 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
1624 bool visitedChildren = false;
1625 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1626 SE = Children.end(); SI != SE; ++SI) {
1627 DbgScope *ChildScope = *SI;
1628 if (!ChildScope->getDFSOut()) {
1629 WorkStack.push_back(ChildScope);
1630 visitedChildren = true;
1631 ChildScope->setDFSIn(++Counter);
1635 if (!visitedChildren) {
1636 WorkStack.pop_back();
1637 WS->setDFSOut(++Counter);
1642 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
1644 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
1645 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
1648 unsigned PrevDFSIn = 0;
1649 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1651 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1653 const MachineInstr *MInsn = II;
1654 const MDNode *Scope = NULL;
1655 const MDNode *InlinedAt = NULL;
1657 // Check if instruction has valid location information.
1658 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1662 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
1663 MI2ScopeMap.find(MInsn);
1664 if (DI != MI2ScopeMap.end()) {
1665 DbgScope *S = DI->second;
1666 dbgs() << S->getDFSIn();
1667 PrevDFSIn = S->getDFSIn();
1669 dbgs() << PrevDFSIn;
1671 dbgs() << " [ x" << PrevDFSIn;
1679 /// extractScopeInformation - Scan machine instructions in this function
1680 /// and collect DbgScopes. Return true, if at least one scope was found.
1681 bool DwarfDebug::extractScopeInformation() {
1682 // If scope information was extracted using .dbg intrinsics then there is not
1683 // any need to extract these information by scanning each instruction.
1684 if (!DbgScopeMap.empty())
1687 // Scan each instruction and create scopes. First build working set of scopes.
1688 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
1689 SmallVector<DbgRange, 4> MIRanges;
1690 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
1691 const MDNode *PrevScope = NULL;
1692 const MDNode *PrevInlinedAt = NULL;
1693 const MachineInstr *RangeBeginMI = NULL;
1694 const MachineInstr *PrevMI = NULL;
1695 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
1697 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1699 const MachineInstr *MInsn = II;
1700 const MDNode *Scope = NULL;
1701 const MDNode *InlinedAt = NULL;
1703 // Check if instruction has valid location information.
1704 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
1709 // If scope has not changed then skip this instruction.
1710 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
1715 // Ignore DBG_VALUE. It does not contribute any instruction in output.
1716 if (MInsn->isDebugValue())
1720 // If we have alread seen a beginning of a instruction range and
1721 // current instruction scope does not match scope of first instruction
1722 // in this range then create a new instruction range.
1723 DbgRange R(RangeBeginMI, PrevMI);
1724 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
1726 MIRanges.push_back(R);
1729 // This is a beginning of a new instruction range.
1730 RangeBeginMI = MInsn;
1732 // Reset previous markers.
1735 PrevInlinedAt = InlinedAt;
1739 // Create last instruction range.
1740 if (RangeBeginMI && PrevMI && PrevScope) {
1741 DbgRange R(RangeBeginMI, PrevMI);
1742 MIRanges.push_back(R);
1743 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
1746 if (!CurrentFnDbgScope)
1749 calculateDominanceGraph(CurrentFnDbgScope);
1751 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
1753 // Find ranges of instructions covered by each DbgScope;
1754 DbgScope *PrevDbgScope = NULL;
1755 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
1756 RE = MIRanges.end(); RI != RE; ++RI) {
1757 const DbgRange &R = *RI;
1758 DbgScope *S = MI2ScopeMap.lookup(R.first);
1759 assert (S && "Lost DbgScope for a machine instruction!");
1760 if (PrevDbgScope && !PrevDbgScope->dominates(S))
1761 PrevDbgScope->closeInsnRange(S);
1762 S->openInsnRange(R.first);
1763 S->extendInsnRange(R.second);
1768 PrevDbgScope->closeInsnRange();
1770 identifyScopeMarkers();
1772 return !DbgScopeMap.empty();
1775 /// identifyScopeMarkers() -
1776 /// Each DbgScope has first instruction and last instruction to mark beginning
1777 /// and end of a scope respectively. Create an inverse map that list scopes
1778 /// starts (and ends) with an instruction. One instruction may start (or end)
1779 /// multiple scopes. Ignore scopes that are not reachable.
1780 void DwarfDebug::identifyScopeMarkers() {
1781 SmallVector<DbgScope *, 4> WorkList;
1782 WorkList.push_back(CurrentFnDbgScope);
1783 while (!WorkList.empty()) {
1784 DbgScope *S = WorkList.pop_back_val();
1786 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
1787 if (!Children.empty())
1788 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
1789 SE = Children.end(); SI != SE; ++SI)
1790 WorkList.push_back(*SI);
1792 if (S->isAbstractScope())
1795 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
1798 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1799 RE = Ranges.end(); RI != RE; ++RI) {
1800 assert(RI->first && "DbgRange does not have first instruction!");
1801 assert(RI->second && "DbgRange does not have second instruction!");
1802 requestLabelBeforeInsn(RI->first);
1803 requestLabelAfterInsn(RI->second);
1808 /// getScopeNode - Get MDNode for DebugLoc's scope.
1809 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1810 if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1811 return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1812 return DL.getScope(Ctx);
1815 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1816 /// line number info for the function.
1817 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1818 const MDNode *Scope = getScopeNode(DL, Ctx);
1819 DISubprogram SP = getDISubprogram(Scope);
1821 return DebugLoc::get(SP.getLineNumber(), 0, SP);
1825 /// beginFunction - Gather pre-function debug information. Assumes being
1826 /// emitted immediately after the function entry point.
1827 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1828 if (!MMI->hasDebugInfo()) return;
1829 if (!extractScopeInformation()) return;
1831 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1832 Asm->getFunctionNumber());
1833 // Assumes in correct section after the entry point.
1834 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1836 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1838 /// ProcessedArgs - Collection of arguments already processed.
1839 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
1840 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1841 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1842 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1844 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1846 bool AtBlockEntry = true;
1847 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1849 const MachineInstr *MI = II;
1851 if (MI->isDebugValue()) {
1852 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
1854 // Keep track of user variables.
1856 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1858 // Variable is in a register, we need to check for clobbers.
1859 if (isDbgValueInDefinedReg(MI))
1860 LiveUserVar[MI->getOperand(0).getReg()] = Var;
1862 // Check the history of this variable.
1863 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1864 if (History.empty()) {
1865 UserVariables.push_back(Var);
1866 // The first mention of a function argument gets the FunctionBeginSym
1867 // label, so arguments are visible when breaking at function entry.
1869 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1870 DISubprogram(getDISubprogram(DV.getContext()))
1871 .describes(MF->getFunction()))
1872 LabelsBeforeInsn[MI] = FunctionBeginSym;
1874 // We have seen this variable before. Try to coalesce DBG_VALUEs.
1875 const MachineInstr *Prev = History.back();
1876 if (Prev->isDebugValue()) {
1877 // Coalesce identical entries at the end of History.
1878 if (History.size() >= 2 &&
1879 Prev->isIdenticalTo(History[History.size() - 2]))
1882 // Terminate old register assignments that don't reach MI;
1883 MachineFunction::const_iterator PrevMBB = Prev->getParent();
1884 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1885 isDbgValueInDefinedReg(Prev)) {
1886 // Previous register assignment needs to terminate at the end of
1888 MachineBasicBlock::const_iterator LastMI =
1889 PrevMBB->getLastNonDebugInstr();
1890 if (LastMI == PrevMBB->end())
1891 // Drop DBG_VALUE for empty range.
1894 // Terminate after LastMI.
1895 History.push_back(LastMI);
1900 History.push_back(MI);
1902 // Not a DBG_VALUE instruction.
1904 AtBlockEntry = false;
1906 // First known non DBG_VALUE location marks beginning of function
1908 if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1909 PrologEndLoc = MI->getDebugLoc();
1911 // Check if the instruction clobbers any registers with debug vars.
1912 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1913 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1914 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1916 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1917 unsigned Reg = *AI; ++AI) {
1918 const MDNode *Var = LiveUserVar[Reg];
1921 // Reg is now clobbered.
1922 LiveUserVar[Reg] = 0;
1924 // Was MD last defined by a DBG_VALUE referring to Reg?
1925 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1926 if (HistI == DbgValues.end())
1928 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1929 if (History.empty())
1931 const MachineInstr *Prev = History.back();
1932 // Sanity-check: Register assignments are terminated at the end of
1934 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1936 // Is the variable still in Reg?
1937 if (!isDbgValueInDefinedReg(Prev) ||
1938 Prev->getOperand(0).getReg() != Reg)
1940 // Var is clobbered. Make sure the next instruction gets a label.
1941 History.push_back(MI);
1948 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1950 SmallVectorImpl<const MachineInstr*> &History = I->second;
1951 if (History.empty())
1954 // Make sure the final register assignments are terminated.
1955 const MachineInstr *Prev = History.back();
1956 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1957 const MachineBasicBlock *PrevMBB = Prev->getParent();
1958 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
1959 if (LastMI == PrevMBB->end())
1960 // Drop DBG_VALUE for empty range.
1963 // Terminate after LastMI.
1964 History.push_back(LastMI);
1967 // Request labels for the full history.
1968 for (unsigned i = 0, e = History.size(); i != e; ++i) {
1969 const MachineInstr *MI = History[i];
1970 if (MI->isDebugValue())
1971 requestLabelBeforeInsn(MI);
1973 requestLabelAfterInsn(MI);
1977 PrevInstLoc = DebugLoc();
1978 PrevLabel = FunctionBeginSym;
1980 // Record beginning of function.
1981 if (!PrologEndLoc.isUnknown()) {
1982 DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1983 MF->getFunction()->getContext());
1984 recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1985 FnStartDL.getScope(MF->getFunction()->getContext()),
1986 DWARF2_FLAG_IS_STMT);
1990 /// endFunction - Gather and emit post-function debug information.
1992 void DwarfDebug::endFunction(const MachineFunction *MF) {
1993 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
1995 if (CurrentFnDbgScope) {
1997 // Define end label for subprogram.
1998 FunctionEndSym = Asm->GetTempSymbol("func_end",
1999 Asm->getFunctionNumber());
2000 // Assumes in correct section after the entry point.
2001 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2003 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2004 collectVariableInfo(MF, ProcessedVars);
2006 // Construct abstract scopes.
2007 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2008 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2009 DISubprogram SP((*AI)->getScopeNode());
2011 // Collect info for variables that were optimized out.
2012 StringRef FName = SP.getLinkageName();
2014 FName = SP.getName();
2015 if (NamedMDNode *NMD =
2016 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2017 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2018 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2019 if (!DV || !ProcessedVars.insert(DV))
2021 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2023 Scope->addVariable(new DbgVariable(DV));
2027 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2028 constructScopeDIE(*AI);
2031 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2033 if (!DisableFramePointerElim(*MF))
2034 getCompileUnit(CurrentFnDbgScope->getScopeNode())->addUInt(CurFnDIE,
2035 dwarf::DW_AT_APPLE_omit_frame_ptr,
2036 dwarf::DW_FORM_flag, 1);
2039 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2040 MMI->getFrameMoves()));
2044 CurrentFnDbgScope = NULL;
2045 DeleteContainerPointers(CurrentFnArguments);
2046 DbgVariableToFrameIndexMap.clear();
2047 VarToAbstractVarMap.clear();
2048 DbgVariableToDbgInstMap.clear();
2049 DeleteContainerSeconds(DbgScopeMap);
2050 UserVariables.clear();
2052 ConcreteScopes.clear();
2053 DeleteContainerSeconds(AbstractScopes);
2054 AbstractScopesList.clear();
2055 AbstractVariables.clear();
2056 LabelsBeforeInsn.clear();
2057 LabelsAfterInsn.clear();
2061 /// recordVariableFrameIndex - Record a variable's index.
2062 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2063 assert (V && "Invalid DbgVariable!");
2064 DbgVariableToFrameIndexMap[V] = Index;
2067 /// findVariableFrameIndex - Return true if frame index for the variable
2068 /// is found. Update FI to hold value of the index.
2069 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2070 assert (V && "Invalid DbgVariable!");
2071 DenseMap<const DbgVariable *, int>::iterator I =
2072 DbgVariableToFrameIndexMap.find(V);
2073 if (I == DbgVariableToFrameIndexMap.end())
2079 /// findDbgScope - Find DbgScope for the debug loc attached with an
2081 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2082 DbgScope *Scope = NULL;
2084 MInsn->getParent()->getParent()->getFunction()->getContext();
2085 DebugLoc DL = MInsn->getDebugLoc();
2090 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2091 Scope = ConcreteScopes.lookup(IA);
2093 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2099 /// recordSourceLine - Register a source line with debug info. Returns the
2100 /// unique label that was emitted and which provides correspondence to
2101 /// the source line list.
2102 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
2108 DIDescriptor Scope(S);
2110 if (Scope.isCompileUnit()) {
2111 DICompileUnit CU(S);
2112 Fn = CU.getFilename();
2113 Dir = CU.getDirectory();
2114 } else if (Scope.isFile()) {
2116 Fn = F.getFilename();
2117 Dir = F.getDirectory();
2118 } else if (Scope.isSubprogram()) {
2120 Fn = SP.getFilename();
2121 Dir = SP.getDirectory();
2122 } else if (Scope.isLexicalBlock()) {
2123 DILexicalBlock DB(S);
2124 Fn = DB.getFilename();
2125 Dir = DB.getDirectory();
2127 assert(0 && "Unexpected scope info");
2129 Src = GetOrCreateSourceID(Fn, Dir);
2131 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags,
2135 //===----------------------------------------------------------------------===//
2137 //===----------------------------------------------------------------------===//
2139 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2142 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2143 // Get the children.
2144 const std::vector<DIE *> &Children = Die->getChildren();
2146 // If not last sibling and has children then add sibling offset attribute.
2147 if (!Last && !Children.empty())
2148 Die->addSiblingOffset(DIEValueAllocator);
2150 // Record the abbreviation.
2151 assignAbbrevNumber(Die->getAbbrev());
2153 // Get the abbreviation for this DIE.
2154 unsigned AbbrevNumber = Die->getAbbrevNumber();
2155 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2158 Die->setOffset(Offset);
2160 // Start the size with the size of abbreviation code.
2161 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2163 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2164 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2166 // Size the DIE attribute values.
2167 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2168 // Size attribute value.
2169 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2171 // Size the DIE children if any.
2172 if (!Children.empty()) {
2173 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2174 "Children flag not set");
2176 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2177 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2179 // End of children marker.
2180 Offset += sizeof(int8_t);
2183 Die->setSize(Offset - Die->getOffset());
2187 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2189 void DwarfDebug::computeSizeAndOffsets() {
2190 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2191 E = CUMap.end(); I != E; ++I) {
2192 // Compute size of compile unit header.
2194 sizeof(int32_t) + // Length of Compilation Unit Info
2195 sizeof(int16_t) + // DWARF version number
2196 sizeof(int32_t) + // Offset Into Abbrev. Section
2197 sizeof(int8_t); // Pointer Size (in bytes)
2198 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2202 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
2203 /// temporary label to it if SymbolStem is specified.
2204 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
2205 const char *SymbolStem = 0) {
2206 Asm->OutStreamer.SwitchSection(Section);
2207 if (!SymbolStem) return 0;
2209 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
2210 Asm->OutStreamer.EmitLabel(TmpSym);
2214 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
2215 /// the start of each one.
2216 void DwarfDebug::EmitSectionLabels() {
2217 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
2219 // Dwarf sections base addresses.
2220 DwarfInfoSectionSym =
2221 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
2222 DwarfAbbrevSectionSym =
2223 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
2224 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
2226 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
2227 EmitSectionSym(Asm, MacroInfo);
2229 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2230 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
2231 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2232 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2233 DwarfStrSectionSym =
2234 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
2235 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2238 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
2239 "section_debug_loc");
2241 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2242 EmitSectionSym(Asm, TLOF.getDataSection());
2245 /// emitDIE - Recusively Emits a debug information entry.
2247 void DwarfDebug::emitDIE(DIE *Die) {
2248 // Get the abbreviation for this DIE.
2249 unsigned AbbrevNumber = Die->getAbbrevNumber();
2250 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2252 // Emit the code (index) for the abbreviation.
2253 if (Asm->isVerbose())
2254 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2255 Twine::utohexstr(Die->getOffset()) + ":0x" +
2256 Twine::utohexstr(Die->getSize()) + " " +
2257 dwarf::TagString(Abbrev->getTag()));
2258 Asm->EmitULEB128(AbbrevNumber);
2260 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2261 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2263 // Emit the DIE attribute values.
2264 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2265 unsigned Attr = AbbrevData[i].getAttribute();
2266 unsigned Form = AbbrevData[i].getForm();
2267 assert(Form && "Too many attributes for DIE (check abbreviation)");
2269 if (Asm->isVerbose())
2270 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2273 case dwarf::DW_AT_sibling:
2274 Asm->EmitInt32(Die->getSiblingOffset());
2276 case dwarf::DW_AT_abstract_origin: {
2277 DIEEntry *E = cast<DIEEntry>(Values[i]);
2278 DIE *Origin = E->getEntry();
2279 unsigned Addr = Origin->getOffset();
2280 Asm->EmitInt32(Addr);
2283 case dwarf::DW_AT_ranges: {
2284 // DW_AT_range Value encodes offset in debug_range section.
2285 DIEInteger *V = cast<DIEInteger>(Values[i]);
2287 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
2288 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2292 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2294 DwarfDebugRangeSectionSym,
2299 case dwarf::DW_AT_location: {
2300 if (UseDotDebugLocEntry.count(Die) != 0) {
2301 DIELabel *L = cast<DIELabel>(Values[i]);
2302 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2304 Values[i]->EmitValue(Asm, Form);
2307 case dwarf::DW_AT_accessibility: {
2308 if (Asm->isVerbose()) {
2309 DIEInteger *V = cast<DIEInteger>(Values[i]);
2310 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2312 Values[i]->EmitValue(Asm, Form);
2316 // Emit an attribute using the defined form.
2317 Values[i]->EmitValue(Asm, Form);
2322 // Emit the DIE children if any.
2323 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2324 const std::vector<DIE *> &Children = Die->getChildren();
2326 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2327 emitDIE(Children[j]);
2329 if (Asm->isVerbose())
2330 Asm->OutStreamer.AddComment("End Of Children Mark");
2335 /// emitDebugInfo - Emit the debug info section.
2337 void DwarfDebug::emitDebugInfo() {
2338 // Start debug info section.
2339 Asm->OutStreamer.SwitchSection(
2340 Asm->getObjFileLowering().getDwarfInfoSection());
2341 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2342 E = CUMap.end(); I != E; ++I) {
2343 CompileUnit *TheCU = I->second;
2344 DIE *Die = TheCU->getCUDie();
2346 // Emit the compile units header.
2347 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
2350 // Emit size of content not including length itself
2351 unsigned ContentSize = Die->getSize() +
2352 sizeof(int16_t) + // DWARF version number
2353 sizeof(int32_t) + // Offset Into Abbrev. Section
2354 sizeof(int8_t); // Pointer Size (in bytes)
2356 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2357 Asm->EmitInt32(ContentSize);
2358 Asm->OutStreamer.AddComment("DWARF version number");
2359 Asm->EmitInt16(dwarf::DWARF_VERSION);
2360 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2361 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
2362 DwarfAbbrevSectionSym);
2363 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2364 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2367 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
2371 /// emitAbbreviations - Emit the abbreviation section.
2373 void DwarfDebug::emitAbbreviations() const {
2374 // Check to see if it is worth the effort.
2375 if (!Abbreviations.empty()) {
2376 // Start the debug abbrev section.
2377 Asm->OutStreamer.SwitchSection(
2378 Asm->getObjFileLowering().getDwarfAbbrevSection());
2380 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
2382 // For each abbrevation.
2383 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
2384 // Get abbreviation data
2385 const DIEAbbrev *Abbrev = Abbreviations[i];
2387 // Emit the abbrevations code (base 1 index.)
2388 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2390 // Emit the abbreviations data.
2394 // Mark end of abbreviations.
2395 Asm->EmitULEB128(0, "EOM(3)");
2397 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
2401 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
2402 /// the line matrix.
2404 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2405 // Define last address of section.
2406 Asm->OutStreamer.AddComment("Extended Op");
2409 Asm->OutStreamer.AddComment("Op size");
2410 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
2411 Asm->OutStreamer.AddComment("DW_LNE_set_address");
2412 Asm->EmitInt8(dwarf::DW_LNE_set_address);
2414 Asm->OutStreamer.AddComment("Section end label");
2416 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2417 Asm->getTargetData().getPointerSize(),
2420 // Mark end of matrix.
2421 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2427 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2429 void DwarfDebug::emitDebugPubNames() {
2430 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2431 E = CUMap.end(); I != E; ++I) {
2432 CompileUnit *TheCU = I->second;
2433 // Start the dwarf pubnames section.
2434 Asm->OutStreamer.SwitchSection(
2435 Asm->getObjFileLowering().getDwarfPubNamesSection());
2437 Asm->OutStreamer.AddComment("Length of Public Names Info");
2438 Asm->EmitLabelDifference(
2439 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
2440 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
2442 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
2445 Asm->OutStreamer.AddComment("DWARF Version");
2446 Asm->EmitInt16(dwarf::DWARF_VERSION);
2448 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2449 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2450 DwarfInfoSectionSym);
2452 Asm->OutStreamer.AddComment("Compilation Unit Length");
2453 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2454 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2457 const StringMap<DIE*> &Globals = TheCU->getGlobals();
2458 for (StringMap<DIE*>::const_iterator
2459 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2460 const char *Name = GI->getKeyData();
2461 DIE *Entity = GI->second;
2463 Asm->OutStreamer.AddComment("DIE offset");
2464 Asm->EmitInt32(Entity->getOffset());
2466 if (Asm->isVerbose())
2467 Asm->OutStreamer.AddComment("External Name");
2468 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2471 Asm->OutStreamer.AddComment("End Mark");
2473 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
2478 void DwarfDebug::emitDebugPubTypes() {
2479 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2480 E = CUMap.end(); I != E; ++I) {
2481 CompileUnit *TheCU = I->second;
2482 // Start the dwarf pubnames section.
2483 Asm->OutStreamer.SwitchSection(
2484 Asm->getObjFileLowering().getDwarfPubTypesSection());
2485 Asm->OutStreamer.AddComment("Length of Public Types Info");
2486 Asm->EmitLabelDifference(
2487 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2488 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2490 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2493 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2494 Asm->EmitInt16(dwarf::DWARF_VERSION);
2496 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2497 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2498 DwarfInfoSectionSym);
2500 Asm->OutStreamer.AddComment("Compilation Unit Length");
2501 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2502 Asm->GetTempSymbol("info_begin", TheCU->getID()),
2505 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2506 for (StringMap<DIE*>::const_iterator
2507 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2508 const char *Name = GI->getKeyData();
2509 DIE * Entity = GI->second;
2511 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2512 Asm->EmitInt32(Entity->getOffset());
2514 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2515 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2518 Asm->OutStreamer.AddComment("End Mark");
2520 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2525 /// emitDebugStr - Emit visible names into a debug str section.
2527 void DwarfDebug::emitDebugStr() {
2528 // Check to see if it is worth the effort.
2529 if (StringPool.empty()) return;
2531 // Start the dwarf str section.
2532 Asm->OutStreamer.SwitchSection(
2533 Asm->getObjFileLowering().getDwarfStrSection());
2535 // Get all of the string pool entries and put them in an array by their ID so
2536 // we can sort them.
2537 SmallVector<std::pair<unsigned,
2538 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2540 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2541 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2542 Entries.push_back(std::make_pair(I->second.second, &*I));
2544 array_pod_sort(Entries.begin(), Entries.end());
2546 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2547 // Emit a label for reference from debug information entries.
2548 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2550 // Emit the string itself.
2551 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
2555 /// emitDebugLoc - Emit visible names into a debug loc section.
2557 void DwarfDebug::emitDebugLoc() {
2558 if (DotDebugLocEntries.empty())
2561 for (SmallVector<DotDebugLocEntry, 4>::iterator
2562 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2564 DotDebugLocEntry &Entry = *I;
2565 if (I + 1 != DotDebugLocEntries.end())
2569 // Start the dwarf loc section.
2570 Asm->OutStreamer.SwitchSection(
2571 Asm->getObjFileLowering().getDwarfLocSection());
2572 unsigned char Size = Asm->getTargetData().getPointerSize();
2573 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2575 for (SmallVector<DotDebugLocEntry, 4>::iterator
2576 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2577 I != E; ++I, ++index) {
2578 DotDebugLocEntry &Entry = *I;
2579 if (Entry.isMerged()) continue;
2580 if (Entry.isEmpty()) {
2581 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2582 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2583 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2585 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2586 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2587 DIVariable DV(Entry.Variable);
2588 if (DV.hasComplexAddress()) {
2589 unsigned N = DV.getNumAddrElements();
2591 Asm->OutStreamer.AddComment("Loc expr size");
2592 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2593 // If first address element is OpPlus then emit
2594 // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2595 MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2596 Asm->EmitInt16(Asm->getDwarfRegOpSize(Loc) + N - 2);
2597 Asm->EmitDwarfRegOp(Loc);
2598 // Asm->EmitULEB128(DV.getAddrElement(1));
2601 Asm->EmitInt16(Asm->getDwarfRegOpSize(Entry.Loc) + N);
2602 Asm->EmitDwarfRegOp(Entry.Loc);
2605 // Emit remaining complex address elements.
2606 for (; i < N; ++i) {
2607 uint64_t Element = DV.getAddrElement(i);
2608 if (Element == DIBuilder::OpPlus) {
2609 Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2610 Asm->EmitULEB128(DV.getAddrElement(++i));
2611 } else if (Element == DIBuilder::OpDeref)
2612 Asm->EmitInt8(dwarf::DW_OP_deref);
2613 else llvm_unreachable("unknown Opcode found in complex address");
2616 Asm->OutStreamer.AddComment("Loc expr size");
2617 Asm->EmitInt16(Asm->getDwarfRegOpSize(Entry.Loc));
2618 Asm->EmitDwarfRegOp(Entry.Loc);
2624 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2626 void DwarfDebug::EmitDebugARanges() {
2627 // Start the dwarf aranges section.
2628 Asm->OutStreamer.SwitchSection(
2629 Asm->getObjFileLowering().getDwarfARangesSection());
2632 /// emitDebugRanges - Emit visible names into a debug ranges section.
2634 void DwarfDebug::emitDebugRanges() {
2635 // Start the dwarf ranges section.
2636 Asm->OutStreamer.SwitchSection(
2637 Asm->getObjFileLowering().getDwarfRangesSection());
2638 unsigned char Size = Asm->getTargetData().getPointerSize();
2639 for (SmallVector<const MCSymbol *, 8>::iterator
2640 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2643 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2645 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2649 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2651 void DwarfDebug::emitDebugMacInfo() {
2652 if (const MCSection *LineInfo =
2653 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2654 // Start the dwarf macinfo section.
2655 Asm->OutStreamer.SwitchSection(LineInfo);
2659 /// emitDebugInlineInfo - Emit inline info using following format.
2661 /// 1. length of section
2662 /// 2. Dwarf version number
2663 /// 3. address size.
2665 /// Entries (one "entry" for each function that was inlined):
2667 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2668 /// otherwise offset into __debug_str for regular function name.
2669 /// 2. offset into __debug_str section for regular function name.
2670 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2671 /// instances for the function.
2673 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2674 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2675 /// __debug_info section, and the low_pc is the starting address for the
2676 /// inlining instance.
2677 void DwarfDebug::emitDebugInlineInfo() {
2678 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2684 Asm->OutStreamer.SwitchSection(
2685 Asm->getObjFileLowering().getDwarfDebugInlineSection());
2687 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2688 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2689 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2691 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2693 Asm->OutStreamer.AddComment("Dwarf Version");
2694 Asm->EmitInt16(dwarf::DWARF_VERSION);
2695 Asm->OutStreamer.AddComment("Address Size (in bytes)");
2696 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2698 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2699 E = InlinedSPNodes.end(); I != E; ++I) {
2701 const MDNode *Node = *I;
2702 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2703 = InlineInfo.find(Node);
2704 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2705 DISubprogram SP(Node);
2706 StringRef LName = SP.getLinkageName();
2707 StringRef Name = SP.getName();
2709 Asm->OutStreamer.AddComment("MIPS linkage name");
2710 if (LName.empty()) {
2711 Asm->OutStreamer.EmitBytes(Name, 0);
2712 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2714 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2715 DwarfStrSectionSym);
2717 Asm->OutStreamer.AddComment("Function name");
2718 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2719 Asm->EmitULEB128(Labels.size(), "Inline count");
2721 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2722 LE = Labels.end(); LI != LE; ++LI) {
2723 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2724 Asm->EmitInt32(LI->second->getOffset());
2726 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2727 Asm->OutStreamer.EmitSymbolValue(LI->first,
2728 Asm->getTargetData().getPointerSize(),0);
2732 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));