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 "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/Instructions.h"
20 #include "llvm/CodeGen/MachineFunction.h"
21 #include "llvm/CodeGen/MachineModuleInfo.h"
22 #include "llvm/MC/MCAsmInfo.h"
23 #include "llvm/MC/MCSection.h"
24 #include "llvm/MC/MCStreamer.h"
25 #include "llvm/MC/MCSymbol.h"
26 #include "llvm/Target/Mangler.h"
27 #include "llvm/Target/TargetData.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetLoweringObjectFile.h"
30 #include "llvm/Target/TargetMachine.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
32 #include "llvm/Target/TargetOptions.h"
33 #include "llvm/Analysis/DebugInfo.h"
34 #include "llvm/ADT/Statistic.h"
35 #include "llvm/ADT/STLExtras.h"
36 #include "llvm/ADT/StringExtras.h"
37 #include "llvm/Support/CommandLine.h"
38 #include "llvm/Support/Debug.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/ValueHandle.h"
41 #include "llvm/Support/FormattedStream.h"
42 #include "llvm/Support/Timer.h"
43 #include "llvm/Support/Path.h"
46 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
47 cl::desc("Print DbgScope information for each machine instruction"));
49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
51 cl::desc("Disable debug info printing"));
53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
54 cl::desc("Make an absense of debug location information explicit."),
58 STATISTIC(BlocksWithoutLineNo, "Number of blocks without any line number");
62 const char *DWARFGroupName = "DWARF Emission";
63 const char *DbgTimerName = "DWARF Debug Writer";
64 } // end anonymous namespace
66 //===----------------------------------------------------------------------===//
68 /// Configuration values for initial hash set sizes (log2).
70 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
74 //===----------------------------------------------------------------------===//
75 /// CompileUnit - This dwarf writer support class manages information associate
76 /// with a source file.
78 /// ID - File identifier for source.
82 /// Die - Compile unit debug information entry.
84 const OwningPtr<DIE> CUDie;
86 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
89 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
90 /// variables to debug information entries.
91 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
93 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
94 /// descriptors to debug information entries using a DIEEntry proxy.
95 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
97 /// Globals - A map of globally visible named entities for this unit.
99 StringMap<DIE*> Globals;
101 /// GlobalTypes - A map of globally visible types for this unit.
103 StringMap<DIE*> GlobalTypes;
106 CompileUnit(unsigned I, DIE *D)
107 : ID(I), CUDie(D), IndexTyDie(0) {}
110 unsigned getID() const { return ID; }
111 DIE* getCUDie() const { return CUDie.get(); }
112 const StringMap<DIE*> &getGlobals() const { return Globals; }
113 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
115 /// hasContent - Return true if this compile unit has something to write out.
117 bool hasContent() const { return !CUDie->getChildren().empty(); }
119 /// addGlobal - Add a new global entity to the compile unit.
121 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
123 /// addGlobalType - Add a new global type to the compile unit.
125 void addGlobalType(StringRef Name, DIE *Die) {
126 GlobalTypes[Name] = Die;
129 /// getDIE - Returns the debug information entry map slot for the
130 /// specified debug variable.
131 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
133 /// insertDIE - Insert DIE into the map.
134 void insertDIE(const MDNode *N, DIE *D) {
135 MDNodeToDieMap.insert(std::make_pair(N, D));
138 /// getDIEEntry - Returns the debug information entry for the speciefied
140 DIEEntry *getDIEEntry(const MDNode *N) {
141 DenseMap<const MDNode *, DIEEntry *>::iterator I =
142 MDNodeToDIEEntryMap.find(N);
143 if (I == MDNodeToDIEEntryMap.end())
148 /// insertDIEEntry - Insert debug information entry into the map.
149 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
150 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
153 /// addDie - Adds or interns the DIE to the compile unit.
155 void addDie(DIE *Buffer) {
156 this->CUDie->addChild(Buffer);
159 // getIndexTyDie - Get an anonymous type for index type.
160 DIE *getIndexTyDie() {
164 // setIndexTyDie - Set D as anonymous type for index which can be reused
166 void setIndexTyDie(DIE *D) {
172 //===----------------------------------------------------------------------===//
173 /// DbgVariable - This class is used to track local variable information.
176 DIVariable Var; // Variable Descriptor.
177 DIE *TheDIE; // Variable DIE.
178 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
180 // AbsVar may be NULL.
181 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
184 DIVariable getVariable() const { return Var; }
185 void setDIE(DIE *D) { TheDIE = D; }
186 DIE *getDIE() const { return TheDIE; }
187 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
188 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
189 StringRef getName() const { return Var.getName(); }
190 unsigned getTag() const { return Var.getTag(); }
191 bool variableHasComplexAddress() const {
192 assert(Var.Verify() && "Invalid complex DbgVariable!");
193 return Var.hasComplexAddress();
195 bool isBlockByrefVariable() const {
196 assert(Var.Verify() && "Invalid complex DbgVariable!");
197 return Var.isBlockByrefVariable();
199 unsigned getNumAddrElements() const {
200 assert(Var.Verify() && "Invalid complex DbgVariable!");
201 return Var.getNumAddrElements();
203 uint64_t getAddrElement(unsigned i) const {
204 return Var.getAddrElement(i);
206 DIType getType() const {
207 DIType Ty = Var.getType();
208 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
209 // addresses instead.
210 if (Var.isBlockByrefVariable()) {
211 /* Byref variables, in Blocks, are declared by the programmer as
212 "SomeType VarName;", but the compiler creates a
213 __Block_byref_x_VarName struct, and gives the variable VarName
214 either the struct, or a pointer to the struct, as its type. This
215 is necessary for various behind-the-scenes things the compiler
216 needs to do with by-reference variables in blocks.
218 However, as far as the original *programmer* is concerned, the
219 variable should still have type 'SomeType', as originally declared.
221 The following function dives into the __Block_byref_x_VarName
222 struct to find the original type of the variable. This will be
223 passed back to the code generating the type for the Debug
224 Information Entry for the variable 'VarName'. 'VarName' will then
225 have the original type 'SomeType' in its debug information.
227 The original type 'SomeType' will be the type of the field named
228 'VarName' inside the __Block_byref_x_VarName struct.
230 NOTE: In order for this to not completely fail on the debugger
231 side, the Debug Information Entry for the variable VarName needs to
232 have a DW_AT_location that tells the debugger how to unwind through
233 the pointers and __Block_byref_x_VarName struct to find the actual
234 value of the variable. The function addBlockByrefType does this. */
236 unsigned tag = Ty.getTag();
238 if (tag == dwarf::DW_TAG_pointer_type) {
239 DIDerivedType DTy = DIDerivedType(Ty);
240 subType = DTy.getTypeDerivedFrom();
243 DICompositeType blockStruct = DICompositeType(subType);
244 DIArray Elements = blockStruct.getTypeArray();
246 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
247 DIDescriptor Element = Elements.getElement(i);
248 DIDerivedType DT = DIDerivedType(Element);
249 if (getName() == DT.getName())
250 return (DT.getTypeDerivedFrom());
258 //===----------------------------------------------------------------------===//
259 /// DbgRange - This is used to track range of instructions with identical
260 /// debug info scope.
262 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
264 //===----------------------------------------------------------------------===//
265 /// DbgScope - This class is used to track scope information.
268 DbgScope *Parent; // Parent to this scope.
269 DIDescriptor Desc; // Debug info descriptor for scope.
270 // Location at which this scope is inlined.
271 AssertingVH<const MDNode> InlinedAtLocation;
272 bool AbstractScope; // Abstract Scope
273 const MachineInstr *LastInsn; // Last instruction of this scope.
274 const MachineInstr *FirstInsn; // First instruction of this scope.
275 unsigned DFSIn, DFSOut;
276 // Scopes defined in scope. Contents not owned.
277 SmallVector<DbgScope *, 4> Scopes;
278 // Variables declared in scope. Contents owned.
279 SmallVector<DbgVariable *, 8> Variables;
280 SmallVector<DbgRange, 4> Ranges;
281 // Private state for dump()
282 mutable unsigned IndentLevel;
284 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
285 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
286 LastInsn(0), FirstInsn(0),
287 DFSIn(0), DFSOut(0), IndentLevel(0) {}
291 DbgScope *getParent() const { return Parent; }
292 void setParent(DbgScope *P) { Parent = P; }
293 DIDescriptor getDesc() const { return Desc; }
294 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
295 const MDNode *getScopeNode() const { return Desc; }
296 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
297 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
298 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
300 /// openInsnRange - This scope covers instruction range starting from MI.
301 void openInsnRange(const MachineInstr *MI) {
306 Parent->openInsnRange(MI);
309 /// extendInsnRange - Extend the current instruction range covered by
311 void extendInsnRange(const MachineInstr *MI) {
312 assert (FirstInsn && "MI Range is not open!");
315 Parent->extendInsnRange(MI);
318 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
319 /// until now. This is used when a new scope is encountered while walking
320 /// machine instructions.
321 void closeInsnRange(DbgScope *NewScope = NULL) {
322 assert (LastInsn && "Last insn missing!");
323 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
326 // If Parent dominates NewScope then do not close Parent's instruction
328 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
329 Parent->closeInsnRange(NewScope);
332 void setAbstractScope() { AbstractScope = true; }
333 bool isAbstractScope() const { return AbstractScope; }
335 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
336 unsigned getDFSOut() const { return DFSOut; }
337 void setDFSOut(unsigned O) { DFSOut = O; }
338 unsigned getDFSIn() const { return DFSIn; }
339 void setDFSIn(unsigned I) { DFSIn = I; }
340 bool dominates(const DbgScope *S) {
343 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
348 /// addScope - Add a scope to the scope.
350 void addScope(DbgScope *S) { Scopes.push_back(S); }
352 /// addVariable - Add a variable to the scope.
354 void addVariable(DbgVariable *V) { Variables.push_back(V); }
361 } // end llvm namespace
364 void DbgScope::dump() const {
365 raw_ostream &err = dbgs();
366 err.indent(IndentLevel);
367 const MDNode *N = Desc;
370 err << "Abstract Scope\n";
374 err << "Children ...\n";
375 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
376 if (Scopes[i] != this)
383 DbgScope::~DbgScope() {
384 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
388 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
389 : Asm(A), MMI(Asm->MMI), FirstCU(0),
390 AbbreviationsSet(InitAbbreviationsSetSize),
391 CurrentFnDbgScope(0), PrevLabel(NULL) {
392 NextStringPoolNumber = 0;
394 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
395 DwarfStrSectionSym = TextSectionSym = 0;
396 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
397 FunctionBeginSym = FunctionEndSym = 0;
398 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
400 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
404 DwarfDebug::~DwarfDebug() {
405 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
406 DIEBlocks[j]->~DIEBlock();
409 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
410 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
411 if (Entry.first) return Entry.first;
413 Entry.second = NextStringPoolNumber++;
414 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
418 /// assignAbbrevNumber - Define a unique number for the abbreviation.
420 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
421 // Profile the node so that we can make it unique.
425 // Check the set for priors.
426 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
428 // If it's newly added.
429 if (InSet == &Abbrev) {
430 // Add to abbreviation list.
431 Abbreviations.push_back(&Abbrev);
433 // Assign the vector position + 1 as its number.
434 Abbrev.setNumber(Abbreviations.size());
436 // Assign existing abbreviation number.
437 Abbrev.setNumber(InSet->getNumber());
441 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
442 /// information entry.
443 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
444 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
448 /// addUInt - Add an unsigned integer attribute data and value.
450 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
451 unsigned Form, uint64_t Integer) {
452 if (!Form) Form = DIEInteger::BestForm(false, Integer);
453 DIEValue *Value = Integer == 1 ?
454 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
455 Die->addValue(Attribute, Form, Value);
458 /// addSInt - Add an signed integer attribute data and value.
460 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
461 unsigned Form, int64_t Integer) {
462 if (!Form) Form = DIEInteger::BestForm(true, Integer);
463 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
464 Die->addValue(Attribute, Form, Value);
467 /// addString - Add a string attribute data and value. DIEString only
468 /// keeps string reference.
469 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
471 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
472 Die->addValue(Attribute, Form, Value);
475 /// addLabel - Add a Dwarf label attribute data and value.
477 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
478 const MCSymbol *Label) {
479 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
480 Die->addValue(Attribute, Form, Value);
483 /// addDelta - Add a label delta attribute data and value.
485 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
486 const MCSymbol *Hi, const MCSymbol *Lo) {
487 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
488 Die->addValue(Attribute, Form, Value);
491 /// addDIEEntry - Add a DIE attribute data and value.
493 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
495 Die->addValue(Attribute, Form, createDIEEntry(Entry));
499 /// addBlock - Add block data.
501 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
503 Block->ComputeSize(Asm);
504 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
505 Die->addValue(Attribute, Block->BestForm(), Block);
508 /// addSourceLine - Add location information to specified debug information
510 void DwarfDebug::addSourceLine(DIE *Die, DIVariable V) {
515 unsigned Line = V.getLineNumber();
518 unsigned FileID = GetOrCreateSourceID(V.getContext().getFilename());
519 assert(FileID && "Invalid file id");
520 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
521 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
524 /// addSourceLine - Add location information to specified debug information
526 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
527 // Verify global variable.
531 unsigned Line = G.getLineNumber();
534 unsigned FileID = GetOrCreateSourceID(G.getContext().getFilename());
535 assert(FileID && "Invalid file id");
536 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
537 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
540 /// addSourceLine - Add location information to specified debug information
542 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
543 // Verify subprogram.
546 // If the line number is 0, don't add it.
547 if (SP.getLineNumber() == 0)
550 unsigned Line = SP.getLineNumber();
551 if (!SP.getContext().Verify())
553 unsigned FileID = GetOrCreateSourceID(SP.getFilename());
554 assert(FileID && "Invalid file id");
555 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
556 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
559 /// addSourceLine - Add location information to specified debug information
561 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
566 unsigned Line = Ty.getLineNumber();
567 if (Line == 0 || !Ty.getContext().Verify())
569 unsigned FileID = GetOrCreateSourceID(Ty.getFilename());
570 assert(FileID && "Invalid file id");
571 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
572 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
575 /// addSourceLine - Add location information to specified debug information
577 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
582 unsigned Line = NS.getLineNumber();
585 StringRef FN = NS.getFilename();
587 unsigned FileID = GetOrCreateSourceID(FN);
588 assert(FileID && "Invalid file id");
589 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
590 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
593 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based
594 /// on provided frame index.
595 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) {
596 MachineLocation Location;
598 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
599 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
600 Location.set(FrameReg, Offset);
602 if (DV->variableHasComplexAddress())
603 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
604 else if (DV->isBlockByrefVariable())
605 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
607 addAddress(Die, dwarf::DW_AT_location, Location);
610 /// addComplexAddress - Start with the address based on the location provided,
611 /// and generate the DWARF information necessary to find the actual variable
612 /// given the extra address information encoded in the DIVariable, starting from
613 /// the starting location. Add the DWARF information to the die.
615 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
617 const MachineLocation &Location) {
618 DIType Ty = DV->getType();
620 // Decode the original location, and use that as the start of the byref
621 // variable's location.
622 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
623 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
624 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
626 if (Location.isReg()) {
628 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
630 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
631 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
635 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
637 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
638 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
641 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
644 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
645 uint64_t Element = DV->getAddrElement(i);
647 if (Element == DIFactory::OpPlus) {
648 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
649 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
650 } else if (Element == DIFactory::OpDeref) {
651 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
652 } else llvm_unreachable("unknown DIFactory Opcode");
655 // Now attach the location information to the DIE.
656 addBlock(Die, Attribute, 0, Block);
659 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
660 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
661 gives the variable VarName either the struct, or a pointer to the struct, as
662 its type. This is necessary for various behind-the-scenes things the
663 compiler needs to do with by-reference variables in Blocks.
665 However, as far as the original *programmer* is concerned, the variable
666 should still have type 'SomeType', as originally declared.
668 The function getBlockByrefType dives into the __Block_byref_x_VarName
669 struct to find the original type of the variable, which is then assigned to
670 the variable's Debug Information Entry as its real type. So far, so good.
671 However now the debugger will expect the variable VarName to have the type
672 SomeType. So we need the location attribute for the variable to be an
673 expression that explains to the debugger how to navigate through the
674 pointers and struct to find the actual variable of type SomeType.
676 The following function does just that. We start by getting
677 the "normal" location for the variable. This will be the location
678 of either the struct __Block_byref_x_VarName or the pointer to the
679 struct __Block_byref_x_VarName.
681 The struct will look something like:
683 struct __Block_byref_x_VarName {
685 struct __Block_byref_x_VarName *forwarding;
686 ... <various other fields>
688 ... <maybe more fields>
691 If we are given the struct directly (as our starting point) we
692 need to tell the debugger to:
694 1). Add the offset of the forwarding field.
696 2). Follow that pointer to get the real __Block_byref_x_VarName
697 struct to use (the real one may have been copied onto the heap).
699 3). Add the offset for the field VarName, to find the actual variable.
701 If we started with a pointer to the struct, then we need to
702 dereference that pointer first, before the other steps.
703 Translating this into DWARF ops, we will need to append the following
704 to the current location description for the variable:
706 DW_OP_deref -- optional, if we start with a pointer
707 DW_OP_plus_uconst <forward_fld_offset>
709 DW_OP_plus_uconst <varName_fld_offset>
711 That is what this function does. */
713 /// addBlockByrefAddress - Start with the address based on the location
714 /// provided, and generate the DWARF information necessary to find the
715 /// actual Block variable (navigating the Block struct) based on the
716 /// starting location. Add the DWARF information to the die. For
717 /// more information, read large comment just above here.
719 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
721 const MachineLocation &Location) {
722 DIType Ty = DV->getType();
724 unsigned Tag = Ty.getTag();
725 bool isPointer = false;
727 StringRef varName = DV->getName();
729 if (Tag == dwarf::DW_TAG_pointer_type) {
730 DIDerivedType DTy = DIDerivedType(Ty);
731 TmpTy = DTy.getTypeDerivedFrom();
735 DICompositeType blockStruct = DICompositeType(TmpTy);
737 // Find the __forwarding field and the variable field in the __Block_byref
739 DIArray Fields = blockStruct.getTypeArray();
740 DIDescriptor varField = DIDescriptor();
741 DIDescriptor forwardingField = DIDescriptor();
743 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
744 DIDescriptor Element = Fields.getElement(i);
745 DIDerivedType DT = DIDerivedType(Element);
746 StringRef fieldName = DT.getName();
747 if (fieldName == "__forwarding")
748 forwardingField = Element;
749 else if (fieldName == varName)
753 // Get the offsets for the forwarding field and the variable field.
754 unsigned forwardingFieldOffset =
755 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
756 unsigned varFieldOffset =
757 DIDerivedType(varField).getOffsetInBits() >> 3;
759 // Decode the original location, and use that as the start of the byref
760 // variable's location.
761 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
762 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
763 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
765 if (Location.isReg()) {
767 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
770 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
774 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
776 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
777 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
780 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
783 // If we started with a pointer to the __Block_byref... struct, then
784 // the first thing we need to do is dereference the pointer (DW_OP_deref).
786 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
788 // Next add the offset for the '__forwarding' field:
789 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
790 // adding the offset if it's 0.
791 if (forwardingFieldOffset > 0) {
792 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
793 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
796 // Now dereference the __forwarding field to get to the real __Block_byref
797 // struct: DW_OP_deref.
798 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
800 // Now that we've got the real __Block_byref... struct, add the offset
801 // for the variable's field to get to the location of the actual variable:
802 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
803 if (varFieldOffset > 0) {
804 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
805 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
808 // Now attach the location information to the DIE.
809 addBlock(Die, Attribute, 0, Block);
812 /// addAddress - Add an address attribute to a die based on the location
814 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
815 const MachineLocation &Location) {
816 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
817 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
818 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
820 if (RI->getFrameRegister(*Asm->MF) == Location.getReg()
821 && Location.getOffset()) {
822 // If variable offset is based in frame register then use fbreg.
823 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
824 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
825 addBlock(Die, Attribute, 0, Block);
829 if (Location.isReg()) {
831 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
833 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
834 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
838 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
840 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
841 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
844 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
847 addBlock(Die, Attribute, 0, Block);
850 /// addRegisterAddress - Add register location entry in variable DIE.
851 bool DwarfDebug::addRegisterAddress(DIE *Die, const MachineOperand &MO) {
852 assert (MO.isReg() && "Invalid machine operand!");
855 MachineLocation Location;
856 Location.set(MO.getReg());
857 addAddress(Die, dwarf::DW_AT_location, Location);
861 /// addConstantValue - Add constant value entry in variable DIE.
862 bool DwarfDebug::addConstantValue(DIE *Die, const MachineOperand &MO) {
863 assert (MO.isImm() && "Invalid machine operand!");
864 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
865 unsigned Imm = MO.getImm();
866 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
867 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
871 /// addConstantFPValue - Add constant value entry in variable DIE.
872 bool DwarfDebug::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
873 assert (MO.isFPImm() && "Invalid machine operand!");
874 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
875 APFloat FPImm = MO.getFPImm()->getValueAPF();
877 // Get the raw data form of the floating point.
878 const APInt FltVal = FPImm.bitcastToAPInt();
879 const char *FltPtr = (const char*)FltVal.getRawData();
881 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
882 bool LittleEndian = Asm->getTargetData().isLittleEndian();
883 int Incr = (LittleEndian ? 1 : -1);
884 int Start = (LittleEndian ? 0 : NumBytes - 1);
885 int Stop = (LittleEndian ? NumBytes : -1);
887 // Output the constant to DWARF one byte at a time.
888 for (; Start != Stop; Start += Incr)
889 addUInt(Block, 0, dwarf::DW_FORM_data1,
890 (unsigned char)0xFF & FltPtr[Start]);
892 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
896 /// addConstantValue - Add constant value entry in variable DIE.
897 bool DwarfDebug::addConstantValue(DIE *Die, ConstantInt *CI,
899 if (CI->getBitWidth() <= 64) {
901 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
904 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
909 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
911 // Get the raw data form of the large APInt.
912 const APInt Val = CI->getValue();
913 const char *Ptr = (const char*)Val.getRawData();
915 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
916 bool LittleEndian = Asm->getTargetData().isLittleEndian();
917 int Incr = (LittleEndian ? 1 : -1);
918 int Start = (LittleEndian ? 0 : NumBytes - 1);
919 int Stop = (LittleEndian ? NumBytes : -1);
921 // Output the constant to DWARF one byte at a time.
922 for (; Start != Stop; Start += Incr)
923 addUInt(Block, 0, dwarf::DW_FORM_data1,
924 (unsigned char)0xFF & Ptr[Start]);
926 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
930 /// addToContextOwner - Add Die into the list of its context owner's children.
931 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
932 if (Context.isType()) {
933 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
934 ContextDIE->addChild(Die);
935 } else if (Context.isNameSpace()) {
936 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
937 ContextDIE->addChild(Die);
938 } else if (Context.isSubprogram()) {
939 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context));
940 ContextDIE->addChild(Die);
941 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
942 ContextDIE->addChild(Die);
944 getCompileUnit(Context)->addDie(Die);
947 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
949 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
950 CompileUnit *TypeCU = getCompileUnit(Ty);
951 DIE *TyDIE = TypeCU->getDIE(Ty);
956 TyDIE = new DIE(dwarf::DW_TAG_base_type);
957 TypeCU->insertDIE(Ty, TyDIE);
958 if (Ty.isBasicType())
959 constructTypeDIE(*TyDIE, DIBasicType(Ty));
960 else if (Ty.isCompositeType())
961 constructTypeDIE(*TyDIE, DICompositeType(Ty));
963 assert(Ty.isDerivedType() && "Unknown kind of DIType");
964 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
967 addToContextOwner(TyDIE, Ty.getContext());
971 /// addType - Add a new type attribute to the specified entity.
972 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
976 // Check for pre-existence.
977 CompileUnit *TypeCU = getCompileUnit(Ty);
978 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
979 // If it exists then use the existing value.
981 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
986 DIE *Buffer = getOrCreateTypeDIE(Ty);
989 Entry = createDIEEntry(Buffer);
990 TypeCU->insertDIEEntry(Ty, Entry);
992 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
995 /// constructTypeDIE - Construct basic type die from DIBasicType.
996 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
997 // Get core information.
998 StringRef Name = BTy.getName();
999 Buffer.setTag(dwarf::DW_TAG_base_type);
1000 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1003 // Add name if not anonymous or intermediate type.
1005 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1006 uint64_t Size = BTy.getSizeInBits() >> 3;
1007 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1010 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1011 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1012 // Get core information.
1013 StringRef Name = DTy.getName();
1014 uint64_t Size = DTy.getSizeInBits() >> 3;
1015 unsigned Tag = DTy.getTag();
1017 // FIXME - Workaround for templates.
1018 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
1022 // Map to main type, void will not have a type.
1023 DIType FromTy = DTy.getTypeDerivedFrom();
1024 addType(&Buffer, FromTy);
1026 // Add name if not anonymous or intermediate type.
1028 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1030 // Add size if non-zero (derived types might be zero-sized.)
1032 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1034 // Add source line info if available and TyDesc is not a forward declaration.
1035 if (!DTy.isForwardDecl())
1036 addSourceLine(&Buffer, DTy);
1039 /// constructTypeDIE - Construct type DIE from DICompositeType.
1040 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1041 // Get core information.
1042 StringRef Name = CTy.getName();
1044 uint64_t Size = CTy.getSizeInBits() >> 3;
1045 unsigned Tag = CTy.getTag();
1049 case dwarf::DW_TAG_vector_type:
1050 case dwarf::DW_TAG_array_type:
1051 constructArrayTypeDIE(Buffer, &CTy);
1053 case dwarf::DW_TAG_enumeration_type: {
1054 DIArray Elements = CTy.getTypeArray();
1056 // Add enumerators to enumeration type.
1057 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1058 DIE *ElemDie = NULL;
1059 DIDescriptor Enum(Elements.getElement(i));
1060 if (Enum.isEnumerator()) {
1061 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1062 Buffer.addChild(ElemDie);
1067 case dwarf::DW_TAG_subroutine_type: {
1069 DIArray Elements = CTy.getTypeArray();
1070 DIDescriptor RTy = Elements.getElement(0);
1071 addType(&Buffer, DIType(RTy));
1073 bool isPrototyped = true;
1075 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1076 DIDescriptor Ty = Elements.getElement(i);
1077 if (Ty.isUnspecifiedParameter()) {
1078 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1079 Buffer.addChild(Arg);
1080 isPrototyped = false;
1082 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1083 addType(Arg, DIType(Ty));
1084 Buffer.addChild(Arg);
1087 // Add prototype flag.
1089 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1092 case dwarf::DW_TAG_structure_type:
1093 case dwarf::DW_TAG_union_type:
1094 case dwarf::DW_TAG_class_type: {
1095 // Add elements to structure type.
1096 DIArray Elements = CTy.getTypeArray();
1098 // A forward struct declared type may not have elements available.
1099 unsigned N = Elements.getNumElements();
1103 // Add elements to structure type.
1104 for (unsigned i = 0; i < N; ++i) {
1105 DIDescriptor Element = Elements.getElement(i);
1106 DIE *ElemDie = NULL;
1107 if (Element.isSubprogram()) {
1108 DISubprogram SP(Element);
1109 ElemDie = createSubprogramDIE(DISubprogram(Element));
1110 if (SP.isProtected())
1111 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1112 dwarf::DW_ACCESS_protected);
1113 else if (SP.isPrivate())
1114 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1115 dwarf::DW_ACCESS_private);
1117 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1118 dwarf::DW_ACCESS_public);
1119 if (SP.isExplicit())
1120 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
1122 else if (Element.isVariable()) {
1123 DIVariable DV(Element);
1124 ElemDie = new DIE(dwarf::DW_TAG_variable);
1125 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1127 addType(ElemDie, DV.getType());
1128 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1129 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1130 addSourceLine(ElemDie, DV);
1131 } else if (Element.isDerivedType())
1132 ElemDie = createMemberDIE(DIDerivedType(Element));
1135 Buffer.addChild(ElemDie);
1138 if (CTy.isAppleBlockExtension())
1139 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1141 unsigned RLang = CTy.getRunTimeLang();
1143 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1144 dwarf::DW_FORM_data1, RLang);
1146 DICompositeType ContainingType = CTy.getContainingType();
1147 if (DIDescriptor(ContainingType).isCompositeType())
1148 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1149 getOrCreateTypeDIE(DIType(ContainingType)));
1151 DIDescriptor Context = CTy.getContext();
1152 addToContextOwner(&Buffer, Context);
1155 if (Tag == dwarf::DW_TAG_class_type) {
1156 DIArray TParams = CTy.getTemplateParams();
1157 unsigned N = TParams.getNumElements();
1158 // Add template parameters.
1159 for (unsigned i = 0; i < N; ++i) {
1160 DIDescriptor Element = TParams.getElement(i);
1161 if (Element.isTemplateTypeParameter())
1162 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
1163 DITemplateTypeParameter(Element)));
1164 else if (Element.isTemplateValueParameter())
1165 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
1166 DITemplateValueParameter(Element)));
1175 // Add name if not anonymous or intermediate type.
1177 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1179 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1180 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1182 // Add size if non-zero (derived types might be zero-sized.)
1184 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1186 // Add zero size if it is not a forward declaration.
1187 if (CTy.isForwardDecl())
1188 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1190 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1193 // Add source line info if available.
1194 if (!CTy.isForwardDecl())
1195 addSourceLine(&Buffer, CTy);
1199 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1200 /// for the given DITemplateTypeParameter.
1202 DwarfDebug::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1203 CompileUnit *TypeCU = getCompileUnit(TP);
1204 DIE *ParamDIE = TypeCU->getDIE(TP);
1208 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1209 addType(ParamDIE, TP.getType());
1210 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
1214 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1215 /// for the given DITemplateValueParameter.
1217 DwarfDebug::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
1218 CompileUnit *TVCU = getCompileUnit(TPV);
1219 DIE *ParamDIE = TVCU->getDIE(TPV);
1223 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
1224 addType(ParamDIE, TPV.getType());
1225 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
1226 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1231 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1232 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1233 int64_t L = SR.getLo();
1234 int64_t H = SR.getHi();
1235 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1237 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1239 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1240 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1242 Buffer.addChild(DW_Subrange);
1245 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1246 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1247 DICompositeType *CTy) {
1248 Buffer.setTag(dwarf::DW_TAG_array_type);
1249 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1250 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1252 // Emit derived type.
1253 addType(&Buffer, CTy->getTypeDerivedFrom());
1254 DIArray Elements = CTy->getTypeArray();
1256 // Get an anonymous type for index type.
1257 CompileUnit *TheCU = getCompileUnit(*CTy);
1258 DIE *IdxTy = TheCU->getIndexTyDie();
1260 // Construct an anonymous type for index type.
1261 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1262 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1263 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1264 dwarf::DW_ATE_signed);
1265 TheCU->addDie(IdxTy);
1266 TheCU->setIndexTyDie(IdxTy);
1269 // Add subranges to array type.
1270 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1271 DIDescriptor Element = Elements.getElement(i);
1272 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1273 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1277 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1278 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1279 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1280 StringRef Name = ETy.getName();
1281 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1282 int64_t Value = ETy.getEnumValue();
1283 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1287 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1288 /// printer to not emit usual symbol prefix before the symbol name is used then
1289 /// return linkage name after skipping this special LLVM prefix.
1290 static StringRef getRealLinkageName(StringRef LinkageName) {
1292 if (LinkageName.startswith(StringRef(&One, 1)))
1293 return LinkageName.substr(1);
1297 /// createMemberDIE - Create new member DIE.
1298 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1299 DIE *MemberDie = new DIE(DT.getTag());
1300 StringRef Name = DT.getName();
1302 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1304 addType(MemberDie, DT.getTypeDerivedFrom());
1306 addSourceLine(MemberDie, DT);
1308 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1309 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1311 uint64_t Size = DT.getSizeInBits();
1312 uint64_t FieldSize = DT.getOriginalTypeSize();
1314 if (Size != FieldSize) {
1316 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1317 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1319 uint64_t Offset = DT.getOffsetInBits();
1320 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1321 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1322 uint64_t FieldOffset = (HiMark - FieldSize);
1323 Offset -= FieldOffset;
1325 // Maybe we need to work from the other end.
1326 if (Asm->getTargetData().isLittleEndian())
1327 Offset = FieldSize - (Offset + Size);
1328 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1330 // Here WD_AT_data_member_location points to the anonymous
1331 // field that includes this bit field.
1332 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1335 // This is not a bitfield.
1336 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1338 if (DT.getTag() == dwarf::DW_TAG_inheritance
1339 && DT.isVirtual()) {
1341 // For C++, virtual base classes are not at fixed offset. Use following
1342 // expression to extract appropriate offset from vtable.
1343 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1345 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1346 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1347 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1348 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1349 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1350 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1351 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1352 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1354 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1357 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1359 if (DT.isProtected())
1360 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1361 dwarf::DW_ACCESS_protected);
1362 else if (DT.isPrivate())
1363 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1364 dwarf::DW_ACCESS_private);
1365 // Otherwise C++ member and base classes are considered public.
1366 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1367 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1368 dwarf::DW_ACCESS_public);
1370 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1371 dwarf::DW_VIRTUALITY_virtual);
1375 /// createSubprogramDIE - Create new DIE using SP.
1376 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
1377 CompileUnit *SPCU = getCompileUnit(SP);
1378 DIE *SPDie = SPCU->getDIE(SP);
1382 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1383 // Constructors and operators for anonymous aggregates do not have names.
1384 if (!SP.getName().empty())
1385 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1387 StringRef LinkageName = SP.getLinkageName();
1388 if (!LinkageName.empty())
1389 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1390 getRealLinkageName(LinkageName));
1392 addSourceLine(SPDie, SP);
1394 if (SP.isPrototyped())
1395 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1398 DICompositeType SPTy = SP.getType();
1399 DIArray Args = SPTy.getTypeArray();
1400 unsigned SPTag = SPTy.getTag();
1402 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1403 addType(SPDie, SPTy);
1405 addType(SPDie, DIType(Args.getElement(0)));
1407 unsigned VK = SP.getVirtuality();
1409 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1410 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1411 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1412 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1413 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1414 ContainingTypeMap.insert(std::make_pair(SPDie,
1415 SP.getContainingType()));
1418 if (!SP.isDefinition()) {
1419 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1421 // Add arguments. Do not add arguments for subprogram definition. They will
1422 // be handled while processing variables.
1423 DICompositeType SPTy = SP.getType();
1424 DIArray Args = SPTy.getTypeArray();
1425 unsigned SPTag = SPTy.getTag();
1427 if (SPTag == dwarf::DW_TAG_subroutine_type)
1428 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1429 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1430 DIType ATy = DIType(DIType(Args.getElement(i)));
1432 if (ATy.isArtificial())
1433 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1434 SPDie->addChild(Arg);
1438 if (SP.isArtificial())
1439 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1441 if (!SP.isLocalToUnit())
1442 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1444 if (SP.isOptimized())
1445 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1447 if (unsigned isa = Asm->getISAEncoding()) {
1448 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1451 // DW_TAG_inlined_subroutine may refer to this DIE.
1452 SPCU->insertDIE(SP, SPDie);
1454 // Add to context owner.
1455 addToContextOwner(SPDie, SP.getContext());
1460 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1461 assert(N && "Invalid Scope encoding!");
1463 DbgScope *AScope = AbstractScopes.lookup(N);
1467 DbgScope *Parent = NULL;
1469 DIDescriptor Scope(N);
1470 if (Scope.isLexicalBlock()) {
1471 DILexicalBlock DB(N);
1472 DIDescriptor ParentDesc = DB.getContext();
1473 Parent = getOrCreateAbstractScope(ParentDesc);
1476 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1479 Parent->addScope(AScope);
1480 AScope->setAbstractScope();
1481 AbstractScopes[N] = AScope;
1482 if (DIDescriptor(N).isSubprogram())
1483 AbstractScopesList.push_back(AScope);
1487 /// isSubprogramContext - Return true if Context is either a subprogram
1488 /// or another context nested inside a subprogram.
1489 static bool isSubprogramContext(const MDNode *Context) {
1492 DIDescriptor D(Context);
1493 if (D.isSubprogram())
1496 return isSubprogramContext(DIType(Context).getContext());
1500 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1501 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1502 /// If there are global variables in this scope then create and insert
1503 /// DIEs for these variables.
1504 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1505 CompileUnit *SPCU = getCompileUnit(SPNode);
1506 DIE *SPDie = SPCU->getDIE(SPNode);
1508 assert(SPDie && "Unable to find subprogram DIE!");
1509 DISubprogram SP(SPNode);
1511 // There is not any need to generate specification DIE for a function
1512 // defined at compile unit level. If a function is defined inside another
1513 // function then gdb prefers the definition at top level and but does not
1514 // expect specification DIE in parent function. So avoid creating
1515 // specification DIE for a function defined inside a function.
1516 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1517 !SP.getContext().isFile() &&
1518 !isSubprogramContext(SP.getContext())) {
1519 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1522 DICompositeType SPTy = SP.getType();
1523 DIArray Args = SPTy.getTypeArray();
1524 unsigned SPTag = SPTy.getTag();
1525 if (SPTag == dwarf::DW_TAG_subroutine_type)
1526 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1527 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1528 DIType ATy = DIType(DIType(Args.getElement(i)));
1530 if (ATy.isArtificial())
1531 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1532 SPDie->addChild(Arg);
1534 DIE *SPDeclDie = SPDie;
1535 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1536 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1538 SPCU->addDie(SPDie);
1541 // Pick up abstract subprogram DIE.
1542 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1543 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1544 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1545 dwarf::DW_FORM_ref4, AbsSPDIE);
1546 SPCU->addDie(SPDie);
1549 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1550 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1551 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1552 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1553 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1554 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1555 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1560 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1561 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1562 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1564 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1565 if (Scope->isAbstractScope())
1568 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1572 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1573 if (Ranges.size() > 1) {
1574 // .debug_range section has not been laid out yet. Emit offset in
1575 // .debug_range as a uint, size 4, for now. emitDIE will handle
1576 // DW_AT_ranges appropriately.
1577 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1578 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1579 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1580 RE = Ranges.end(); RI != RE; ++RI) {
1581 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1582 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1584 DebugRangeSymbols.push_back(NULL);
1585 DebugRangeSymbols.push_back(NULL);
1589 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1590 const MCSymbol *End = getLabelAfterInsn(RI->second);
1592 if (End == 0) return 0;
1594 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1595 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1597 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1598 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1603 /// constructInlinedScopeDIE - This scope represents inlined body of
1604 /// a function. Construct DIE to represent this concrete inlined copy
1605 /// of the function.
1606 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1608 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1609 assert (Ranges.empty() == false
1610 && "DbgScope does not have instruction markers!");
1612 // FIXME : .debug_inlined section specification does not clearly state how
1613 // to emit inlined scope that is split into multiple instruction ranges.
1614 // For now, use first instruction range and emit low_pc/high_pc pair and
1615 // corresponding .debug_inlined section entry for this pair.
1616 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1617 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1618 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1620 if (StartLabel == 0 || EndLabel == 0) {
1621 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1624 assert(StartLabel->isDefined() &&
1625 "Invalid starting label for an inlined scope!");
1626 assert(EndLabel->isDefined() &&
1627 "Invalid end label for an inlined scope!");
1629 if (!Scope->getScopeNode())
1631 DIScope DS(Scope->getScopeNode());
1632 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1634 DISubprogram InlinedSP = getDISubprogram(DS);
1635 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1636 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1637 assert(OriginDIE && "Unable to find Origin DIE!");
1638 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1639 dwarf::DW_FORM_ref4, OriginDIE);
1641 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1642 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1644 InlinedSubprogramDIEs.insert(OriginDIE);
1646 // Track the start label for this inlined function.
1647 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1648 I = InlineInfo.find(InlinedSP);
1650 if (I == InlineInfo.end()) {
1651 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1653 InlinedSPNodes.push_back(InlinedSP);
1655 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1657 DILocation DL(Scope->getInlinedAt());
1658 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1659 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1665 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1666 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1667 StringRef Name = DV->getName();
1671 // Translate tag to proper Dwarf tag. The result variable is dropped for
1674 switch (DV->getTag()) {
1675 case dwarf::DW_TAG_return_variable:
1677 case dwarf::DW_TAG_arg_variable:
1678 Tag = dwarf::DW_TAG_formal_parameter;
1680 case dwarf::DW_TAG_auto_variable: // fall thru
1682 Tag = dwarf::DW_TAG_variable;
1686 // Define variable debug information entry.
1687 DIE *VariableDie = new DIE(Tag);
1690 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1691 V2AVI = VarToAbstractVarMap.find(DV);
1692 if (V2AVI != VarToAbstractVarMap.end())
1693 AbsDIE = V2AVI->second->getDIE();
1696 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1697 dwarf::DW_FORM_ref4, AbsDIE);
1699 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1700 addSourceLine(VariableDie, DV->getVariable());
1702 // Add variable type.
1703 addType(VariableDie, DV->getType());
1706 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1707 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1708 else if (DIVariable(DV->getVariable()).isArtificial())
1709 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1711 if (Scope->isAbstractScope()) {
1712 DV->setDIE(VariableDie);
1716 // Add variable address.
1718 unsigned Offset = DV->getDotDebugLocOffset();
1719 if (Offset != ~0U) {
1720 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1721 Asm->GetTempSymbol("debug_loc", Offset));
1722 DV->setDIE(VariableDie);
1723 UseDotDebugLocEntry.insert(VariableDie);
1727 // Check if variable is described by a DBG_VALUE instruction.
1728 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1729 DbgVariableToDbgInstMap.find(DV);
1730 if (DVI != DbgVariableToDbgInstMap.end()) {
1731 const MachineInstr *DVInsn = DVI->second;
1732 bool updated = false;
1733 // FIXME : Handle getNumOperands != 3
1734 if (DVInsn->getNumOperands() == 3) {
1735 if (DVInsn->getOperand(0).isReg()) {
1736 const MachineOperand RegOp = DVInsn->getOperand(0);
1737 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1738 if (DVInsn->getOperand(1).isImm() &&
1739 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1740 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1743 updated = addRegisterAddress(VariableDie, RegOp);
1745 else if (DVInsn->getOperand(0).isImm())
1746 updated = addConstantValue(VariableDie, DVInsn->getOperand(0));
1747 else if (DVInsn->getOperand(0).isFPImm())
1749 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1751 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1752 if (Location.getReg()) {
1753 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1758 // If variableDie is not updated then DBG_VALUE instruction does not
1759 // have valid variable info.
1763 DV->setDIE(VariableDie);
1767 // .. else use frame index, if available.
1769 if (findVariableFrameIndex(DV, &FI))
1770 addVariableAddress(DV, VariableDie, FI);
1772 DV->setDIE(VariableDie);
1777 void DwarfDebug::addPubTypes(DISubprogram SP) {
1778 DICompositeType SPTy = SP.getType();
1779 unsigned SPTag = SPTy.getTag();
1780 if (SPTag != dwarf::DW_TAG_subroutine_type)
1783 DIArray Args = SPTy.getTypeArray();
1784 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1785 DIType ATy(Args.getElement(i));
1788 DICompositeType CATy = getDICompositeType(ATy);
1789 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1790 && !CATy.isForwardDecl()) {
1791 CompileUnit *TheCU = getCompileUnit(CATy);
1792 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1793 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1798 /// constructScopeDIE - Construct a DIE for this scope.
1799 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1800 if (!Scope || !Scope->getScopeNode())
1803 DIScope DS(Scope->getScopeNode());
1804 DIE *ScopeDIE = NULL;
1805 if (Scope->getInlinedAt())
1806 ScopeDIE = constructInlinedScopeDIE(Scope);
1807 else if (DS.isSubprogram()) {
1808 ProcessedSPNodes.insert(DS);
1809 if (Scope->isAbstractScope()) {
1810 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1811 // Note down abstract DIE.
1813 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1816 ScopeDIE = updateSubprogramScopeDIE(DS);
1819 ScopeDIE = constructLexicalScopeDIE(Scope);
1820 if (!ScopeDIE) return NULL;
1822 // Add variables to scope.
1823 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1824 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1825 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1827 ScopeDIE->addChild(VariableDIE);
1830 // Add nested scopes.
1831 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1832 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1833 // Define the Scope debug information entry.
1834 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1836 ScopeDIE->addChild(NestedDIE);
1839 if (DS.isSubprogram())
1840 addPubTypes(DISubprogram(DS));
1845 /// GetOrCreateSourceID - Look up the source id with the given directory and
1846 /// source file names. If none currently exists, create a new id and insert it
1847 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1850 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName){
1851 // If FE did not provide a file name, then assume stdin.
1852 if (FileName.empty())
1853 return GetOrCreateSourceID("<stdin>");
1855 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
1856 if (Entry.getValue())
1857 return Entry.getValue();
1859 unsigned SrcId = SourceIdMap.size();
1860 Entry.setValue(SrcId);
1862 // Print out a .file directive to specify files for .loc directives.
1863 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, FileName);
1868 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1869 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1870 CompileUnit *TheCU = getCompileUnit(NS);
1871 DIE *NDie = TheCU->getDIE(NS);
1874 NDie = new DIE(dwarf::DW_TAG_namespace);
1875 TheCU->insertDIE(NS, NDie);
1876 if (!NS.getName().empty())
1877 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1878 addSourceLine(NDie, NS);
1879 addToContextOwner(NDie, NS.getContext());
1883 /// constructCompileUnit - Create new CompileUnit for the given
1884 /// metadata node with tag DW_TAG_compile_unit.
1885 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1886 DICompileUnit DIUnit(N);
1887 StringRef FN = DIUnit.getFilename();
1888 StringRef Dir = DIUnit.getDirectory();
1889 unsigned ID = GetOrCreateSourceID(FN);
1891 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1892 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1893 DIUnit.getProducer());
1894 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1895 DIUnit.getLanguage());
1896 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1897 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1898 // simplifies debug range entries.
1899 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1900 // DW_AT_stmt_list is a offset of line number information for this
1901 // compile unit in debug_line section.
1902 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1903 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1904 Asm->GetTempSymbol("section_line"));
1906 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1909 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1910 if (DIUnit.isOptimized())
1911 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1913 StringRef Flags = DIUnit.getFlags();
1915 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1917 unsigned RVer = DIUnit.getRunTimeVersion();
1919 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1920 dwarf::DW_FORM_data1, RVer);
1922 CompileUnit *NewCU = new CompileUnit(ID, Die);
1925 CUMap.insert(std::make_pair(N, NewCU));
1928 /// getCompielUnit - Get CompileUnit DIE.
1929 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1930 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1932 const MDNode *CUNode = NULL;
1933 if (D.isCompileUnit())
1935 else if (D.isSubprogram())
1936 CUNode = DISubprogram(N).getCompileUnit();
1937 else if (D.isType())
1938 CUNode = DIType(N).getCompileUnit();
1939 else if (D.isGlobalVariable())
1940 CUNode = DIGlobalVariable(N).getCompileUnit();
1941 else if (D.isVariable())
1942 CUNode = DIVariable(N).getCompileUnit();
1943 else if (D.isNameSpace())
1944 CUNode = DINameSpace(N).getCompileUnit();
1945 else if (D.isFile())
1946 CUNode = DIFile(N).getCompileUnit();
1950 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1951 = CUMap.find(CUNode);
1952 if (I == CUMap.end())
1957 /// isUnsignedDIType - Return true if type encoding is unsigned.
1958 static bool isUnsignedDIType(DIType Ty) {
1959 DIDerivedType DTy(Ty);
1961 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1963 DIBasicType BTy(Ty);
1965 unsigned Encoding = BTy.getEncoding();
1966 if (Encoding == dwarf::DW_ATE_unsigned ||
1967 Encoding == dwarf::DW_ATE_unsigned_char)
1973 // Return const exprssion if value is a GEP to access merged global
1975 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1976 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1977 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1978 if (!CE || CE->getNumOperands() != 3 ||
1979 CE->getOpcode() != Instruction::GetElementPtr)
1982 // First operand points to a global value.
1983 if (!isa<GlobalValue>(CE->getOperand(0)))
1986 // Second operand is zero.
1987 const ConstantInt *CI =
1988 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1989 if (!CI || !CI->isZero())
1992 // Third operand is offset.
1993 if (!isa<ConstantInt>(CE->getOperand(2)))
1999 /// constructGlobalVariableDIE - Construct global variable DIE.
2000 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
2001 DIGlobalVariable GV(N);
2003 // If debug information is malformed then ignore it.
2004 if (GV.Verify() == false)
2007 // Check for pre-existence.
2008 CompileUnit *TheCU = getCompileUnit(N);
2009 if (TheCU->getDIE(GV))
2012 DIType GTy = GV.getType();
2013 DIE *VariableDIE = new DIE(GV.getTag());
2015 bool isGlobalVariable = GV.getGlobal() != NULL;
2018 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
2019 GV.getDisplayName());
2020 StringRef LinkageName = GV.getLinkageName();
2021 if (!LinkageName.empty() && isGlobalVariable)
2022 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
2023 getRealLinkageName(LinkageName));
2025 addType(VariableDIE, GTy);
2026 if (GTy.isCompositeType() && !GTy.getName().empty()
2027 && !GTy.isForwardDecl()) {
2028 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
2029 assert(Entry && "Missing global type!");
2030 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
2032 // Add scoping info.
2033 if (!GV.isLocalToUnit()) {
2034 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
2035 // Expose as global.
2036 TheCU->addGlobal(GV.getName(), VariableDIE);
2038 // Add line number info.
2039 addSourceLine(VariableDIE, GV);
2041 TheCU->insertDIE(N, VariableDIE);
2042 // Add to context owner.
2043 DIDescriptor GVContext = GV.getContext();
2044 addToContextOwner(VariableDIE, GVContext);
2046 if (isGlobalVariable) {
2047 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2048 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2049 addLabel(Block, 0, dwarf::DW_FORM_udata,
2050 Asm->Mang->getSymbol(GV.getGlobal()));
2051 // Do not create specification DIE if context is either compile unit
2053 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
2054 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
2055 // Create specification DIE.
2056 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
2057 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
2058 dwarf::DW_FORM_ref4, VariableDIE);
2059 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
2060 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
2061 TheCU->addDie(VariableSpecDIE);
2063 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2065 } else if (ConstantInt *CI =
2066 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
2067 addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
2068 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
2069 // GV is a merged global.
2070 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2071 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2072 addLabel(Block, 0, dwarf::DW_FORM_udata,
2073 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
2074 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
2075 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
2076 addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
2077 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
2078 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2084 /// construct SubprogramDIE - Construct subprogram DIE.
2085 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2088 // Check for pre-existence.
2089 CompileUnit *TheCU = getCompileUnit(N);
2090 if (TheCU->getDIE(N))
2093 if (!SP.isDefinition())
2094 // This is a method declaration which will be handled while constructing
2098 DIE *SubprogramDie = createSubprogramDIE(SP);
2101 TheCU->insertDIE(N, SubprogramDie);
2103 // Add to context owner.
2104 addToContextOwner(SubprogramDie, SP.getContext());
2106 // Expose as global.
2107 TheCU->addGlobal(SP.getName(), SubprogramDie);
2112 /// beginModule - Emit all Dwarf sections that should come prior to the
2113 /// content. Create global DIEs and emit initial debug info sections.
2114 /// This is inovked by the target AsmPrinter.
2115 void DwarfDebug::beginModule(Module *M) {
2116 if (DisableDebugInfoPrinting)
2119 DebugInfoFinder DbgFinder;
2120 DbgFinder.processModule(*M);
2122 bool HasDebugInfo = false;
2124 // Scan all the compile-units to see if there are any marked as the main unit.
2125 // if not, we do not generate debug info.
2126 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2127 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2128 if (DICompileUnit(*I).isMain()) {
2129 HasDebugInfo = true;
2134 if (!HasDebugInfo) return;
2136 // Tell MMI that we have debug info.
2137 MMI->setDebugInfoAvailability(true);
2139 // Emit initial sections.
2140 EmitSectionLabels();
2142 // Create all the compile unit DIEs.
2143 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2144 E = DbgFinder.compile_unit_end(); I != E; ++I)
2145 constructCompileUnit(*I);
2147 // Create DIEs for each subprogram.
2148 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2149 E = DbgFinder.subprogram_end(); I != E; ++I)
2150 constructSubprogramDIE(*I);
2152 // Create DIEs for each global variable.
2153 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2154 E = DbgFinder.global_variable_end(); I != E; ++I)
2155 constructGlobalVariableDIE(*I);
2157 //getOrCreateTypeDIE
2158 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2159 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2160 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2162 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2163 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2164 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2166 // Prime section data.
2167 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2170 /// endModule - Emit all Dwarf sections that should come after the content.
2172 void DwarfDebug::endModule() {
2173 if (!FirstCU) return;
2174 const Module *M = MMI->getModule();
2175 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2176 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2177 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2178 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2179 DISubprogram SP(AllSPs->getOperand(SI));
2180 if (!SP.Verify()) continue;
2182 // Collect info for variables that were optimized out.
2183 if (!SP.isDefinition()) continue;
2184 StringRef FName = SP.getLinkageName();
2186 FName = SP.getName();
2187 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
2189 unsigned E = NMD->getNumOperands();
2191 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2192 DeadFnScopeMap[SP] = Scope;
2193 for (unsigned I = 0; I != E; ++I) {
2194 DIVariable DV(NMD->getOperand(I));
2195 if (!DV.Verify()) continue;
2196 Scope->addVariable(new DbgVariable(DV));
2199 // Construct subprogram DIE and add variables DIEs.
2200 constructSubprogramDIE(SP);
2201 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2202 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2203 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2204 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2206 ScopeDIE->addChild(VariableDIE);
2211 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2212 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2213 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2215 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2218 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2219 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2220 DIE *SPDie = CI->first;
2221 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2223 DIE *NDie = getCompileUnit(N)->getDIE(N);
2224 if (!NDie) continue;
2225 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2228 // Standard sections final addresses.
2229 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2230 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2231 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2232 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2234 // End text sections.
2235 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2236 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2237 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2240 // Emit common frame information.
2241 emitCommonDebugFrame();
2243 // Emit function debug frame information
2244 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2245 E = DebugFrames.end(); I != E; ++I)
2246 emitFunctionDebugFrame(*I);
2248 // Compute DIE offsets and sizes.
2249 computeSizeAndOffsets();
2251 // Emit all the DIEs into a debug info section
2254 // Corresponding abbreviations into a abbrev section.
2255 emitAbbreviations();
2257 // Emit info into a debug pubnames section.
2258 emitDebugPubNames();
2260 // Emit info into a debug pubtypes section.
2261 emitDebugPubTypes();
2263 // Emit info into a debug loc section.
2266 // Emit info into a debug aranges section.
2269 // Emit info into a debug ranges section.
2272 // Emit info into a debug macinfo section.
2275 // Emit inline info.
2276 emitDebugInlineInfo();
2278 // Emit info into a debug str section.
2282 DeleteContainerSeconds(DeadFnScopeMap);
2283 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2284 E = CUMap.end(); I != E; ++I)
2286 FirstCU = NULL; // Reset for the next Module, if any.
2289 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2290 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2291 DebugLoc ScopeLoc) {
2293 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2295 return AbsDbgVariable;
2297 LLVMContext &Ctx = Var->getContext();
2298 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2302 AbsDbgVariable = new DbgVariable(Var);
2303 Scope->addVariable(AbsDbgVariable);
2304 AbstractVariables[Var] = AbsDbgVariable;
2305 return AbsDbgVariable;
2308 /// collectVariableInfoFromMMITable - Collect variable information from
2309 /// side table maintained by MMI.
2311 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2312 SmallPtrSet<const MDNode *, 16> &Processed) {
2313 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2314 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2315 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2316 VE = VMap.end(); VI != VE; ++VI) {
2317 const MDNode *Var = VI->first;
2319 Processed.insert(Var);
2321 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2323 DbgScope *Scope = 0;
2324 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2325 Scope = ConcreteScopes.lookup(IA);
2327 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2329 // If variable scope is not found then skip this variable.
2333 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2334 DbgVariable *RegVar = new DbgVariable(DV);
2335 recordVariableFrameIndex(RegVar, VP.first);
2336 Scope->addVariable(RegVar);
2337 if (AbsDbgVariable) {
2338 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2339 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2344 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2345 /// DBG_VALUE instruction, is in a defined reg.
2346 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2347 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2348 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2353 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2355 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2356 SmallPtrSet<const MDNode *, 16> &Processed) {
2358 /// collection info from MMI table.
2359 collectVariableInfoFromMMITable(MF, Processed);
2361 SmallVector<const MachineInstr *, 8> DbgValues;
2362 // Collect variable information from DBG_VALUE machine instructions;
2363 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2365 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2367 const MachineInstr *MInsn = II;
2368 if (!MInsn->isDebugValue())
2370 DbgValues.push_back(MInsn);
2373 // This is a collection of DBV_VALUE instructions describing same variable.
2374 SmallVector<const MachineInstr *, 4> MultipleValues;
2375 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2376 E = DbgValues.end(); I != E; ++I) {
2377 const MachineInstr *MInsn = *I;
2378 MultipleValues.clear();
2379 if (isDbgValueInDefinedReg(MInsn))
2380 MultipleValues.push_back(MInsn);
2381 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2382 if (Processed.count(DV) != 0)
2385 const MachineInstr *PrevMI = MInsn;
2386 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2387 ME = DbgValues.end(); MI != ME; ++MI) {
2389 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2391 !PrevMI->isIdenticalTo(*MI))
2392 MultipleValues.push_back(*MI);
2396 DbgScope *Scope = NULL;
2397 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2398 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2399 Scope = CurrentFnDbgScope;
2401 Scope = findDbgScope(MInsn);
2402 // If variable scope is not found then skip this variable.
2406 Processed.insert(DV);
2407 DbgVariable *RegVar = new DbgVariable(DV);
2408 Scope->addVariable(RegVar);
2409 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2410 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2411 VarToAbstractVarMap[RegVar] = AbsVar;
2413 if (MultipleValues.size() <= 1) {
2414 DbgVariableToDbgInstMap[RegVar] = MInsn;
2418 // handle multiple DBG_VALUE instructions describing one variable.
2419 if (DotDebugLocEntries.empty())
2420 RegVar->setDotDebugLocOffset(0);
2422 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2423 const MachineInstr *Begin = NULL;
2424 const MachineInstr *End = NULL;
2425 for (SmallVector<const MachineInstr *, 4>::iterator
2426 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2427 MVI != MVE; ++MVI) {
2433 MachineLocation MLoc;
2434 if (Begin->getNumOperands() == 3) {
2435 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2436 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2438 MLoc = Asm->getDebugValueLocation(Begin);
2440 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2441 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2443 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2446 if (MVI + 1 == MVE) {
2447 // If End is the last instruction then its value is valid
2448 // until the end of the funtion.
2449 MachineLocation EMLoc;
2450 if (End->getNumOperands() == 3) {
2451 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2452 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2454 EMLoc = Asm->getDebugValueLocation(End);
2457 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2460 DotDebugLocEntries.push_back(DotDebugLocEntry());
2463 // Collect info for variables that were optimized out.
2464 const Function *F = MF->getFunction();
2465 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
2466 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2467 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2468 if (!DV || !Processed.insert(DV))
2470 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2472 Scope->addVariable(new DbgVariable(DV));
2477 /// getLabelBeforeInsn - Return Label preceding the instruction.
2478 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2479 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2480 LabelsBeforeInsn.find(MI);
2481 if (I == LabelsBeforeInsn.end())
2482 // FunctionBeginSym always preceeds all the instruction in current function.
2483 return FunctionBeginSym;
2487 /// getLabelAfterInsn - Return Label immediately following the instruction.
2488 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2489 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2490 LabelsAfterInsn.find(MI);
2491 if (I == LabelsAfterInsn.end())
2496 /// beginInstruction - Process beginning of an instruction.
2497 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
2498 if (InsnNeedsLabel.count(MI) == 0) {
2499 LabelsBeforeInsn[MI] = PrevLabel;
2504 DebugLoc DL = MI->getDebugLoc();
2505 if (!DL.isUnknown()) {
2506 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2507 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2509 LabelsBeforeInsn[MI] = PrevLabel;
2513 // If location is unknown then use temp label for this DBG_VALUE
2515 if (MI->isDebugValue()) {
2516 PrevLabel = MMI->getContext().CreateTempSymbol();
2517 Asm->OutStreamer.EmitLabel(PrevLabel);
2518 LabelsBeforeInsn[MI] = PrevLabel;
2522 if (UnknownLocations) {
2523 PrevLabel = recordSourceLine(0, 0, 0);
2524 LabelsBeforeInsn[MI] = PrevLabel;
2528 assert (0 && "Instruction is not processed!");
2531 /// endInstruction - Process end of an instruction.
2532 void DwarfDebug::endInstruction(const MachineInstr *MI) {
2533 if (InsnsEndScopeSet.count(MI) != 0) {
2534 // Emit a label if this instruction ends a scope.
2535 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2536 Asm->OutStreamer.EmitLabel(Label);
2537 LabelsAfterInsn[MI] = Label;
2541 /// getOrCreateDbgScope - Create DbgScope for the scope.
2542 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2543 const MDNode *InlinedAt) {
2545 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2548 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2549 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2550 if (DIDescriptor(Scope).isLexicalBlock()) {
2552 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2553 WScope->setParent(Parent);
2554 Parent->addScope(WScope);
2557 if (!WScope->getParent()) {
2558 StringRef SPName = DISubprogram(Scope).getLinkageName();
2559 // We used to check only for a linkage name, but that fails
2560 // since we began omitting the linkage name for private
2561 // functions. The new way is to check for the name in metadata,
2562 // but that's not supported in old .ll test cases. Ergo, we
2564 if (SPName == Asm->MF->getFunction()->getName() ||
2565 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2566 CurrentFnDbgScope = WScope;
2572 getOrCreateAbstractScope(Scope);
2573 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2577 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2578 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2579 DILocation DL(InlinedAt);
2581 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2582 WScope->setParent(Parent);
2583 Parent->addScope(WScope);
2585 ConcreteScopes[InlinedAt] = WScope;
2590 /// hasValidLocation - Return true if debug location entry attached with
2591 /// machine instruction encodes valid location info.
2592 static bool hasValidLocation(LLVMContext &Ctx,
2593 const MachineInstr *MInsn,
2594 const MDNode *&Scope, const MDNode *&InlinedAt) {
2595 DebugLoc DL = MInsn->getDebugLoc();
2596 if (DL.isUnknown()) return false;
2598 const MDNode *S = DL.getScope(Ctx);
2600 // There is no need to create another DIE for compile unit. For all
2601 // other scopes, create one DbgScope now. This will be translated
2602 // into a scope DIE at the end.
2603 if (DIScope(S).isCompileUnit()) return false;
2606 InlinedAt = DL.getInlinedAt(Ctx);
2610 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2612 static void calculateDominanceGraph(DbgScope *Scope) {
2613 assert (Scope && "Unable to calculate scop edominance graph!");
2614 SmallVector<DbgScope *, 4> WorkStack;
2615 WorkStack.push_back(Scope);
2616 unsigned Counter = 0;
2617 while (!WorkStack.empty()) {
2618 DbgScope *WS = WorkStack.back();
2619 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2620 bool visitedChildren = false;
2621 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2622 SE = Children.end(); SI != SE; ++SI) {
2623 DbgScope *ChildScope = *SI;
2624 if (!ChildScope->getDFSOut()) {
2625 WorkStack.push_back(ChildScope);
2626 visitedChildren = true;
2627 ChildScope->setDFSIn(++Counter);
2631 if (!visitedChildren) {
2632 WorkStack.pop_back();
2633 WS->setDFSOut(++Counter);
2638 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2640 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2641 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2644 unsigned PrevDFSIn = 0;
2645 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2647 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2649 const MachineInstr *MInsn = II;
2650 const MDNode *Scope = NULL;
2651 const MDNode *InlinedAt = NULL;
2653 // Check if instruction has valid location information.
2654 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2658 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2659 MI2ScopeMap.find(MInsn);
2660 if (DI != MI2ScopeMap.end()) {
2661 DbgScope *S = DI->second;
2662 dbgs() << S->getDFSIn();
2663 PrevDFSIn = S->getDFSIn();
2665 dbgs() << PrevDFSIn;
2667 dbgs() << " [ x" << PrevDFSIn;
2675 /// extractScopeInformation - Scan machine instructions in this function
2676 /// and collect DbgScopes. Return true, if at least one scope was found.
2677 bool DwarfDebug::extractScopeInformation() {
2678 // If scope information was extracted using .dbg intrinsics then there is not
2679 // any need to extract these information by scanning each instruction.
2680 if (!DbgScopeMap.empty())
2683 // Scan each instruction and create scopes. First build working set of scopes.
2684 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2685 SmallVector<DbgRange, 4> MIRanges;
2686 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2687 const MDNode *PrevScope = NULL;
2688 const MDNode *PrevInlinedAt = NULL;
2689 const MachineInstr *RangeBeginMI = NULL;
2690 const MachineInstr *PrevMI = NULL;
2691 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2693 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2695 const MachineInstr *MInsn = II;
2696 const MDNode *Scope = NULL;
2697 const MDNode *InlinedAt = NULL;
2699 // Check if instruction has valid location information.
2700 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2705 // If scope has not changed then skip this instruction.
2706 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2712 // If we have alread seen a beginning of a instruction range and
2713 // current instruction scope does not match scope of first instruction
2714 // in this range then create a new instruction range.
2715 DbgRange R(RangeBeginMI, PrevMI);
2716 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2718 MIRanges.push_back(R);
2721 // This is a beginning of a new instruction range.
2722 RangeBeginMI = MInsn;
2724 // Reset previous markers.
2727 PrevInlinedAt = InlinedAt;
2731 // Create last instruction range.
2732 if (RangeBeginMI && PrevMI && PrevScope) {
2733 DbgRange R(RangeBeginMI, PrevMI);
2734 MIRanges.push_back(R);
2735 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2738 if (!CurrentFnDbgScope)
2741 calculateDominanceGraph(CurrentFnDbgScope);
2743 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2745 // Find ranges of instructions covered by each DbgScope;
2746 DbgScope *PrevDbgScope = NULL;
2747 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2748 RE = MIRanges.end(); RI != RE; ++RI) {
2749 const DbgRange &R = *RI;
2750 DbgScope *S = MI2ScopeMap.lookup(R.first);
2751 assert (S && "Lost DbgScope for a machine instruction!");
2752 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2753 PrevDbgScope->closeInsnRange(S);
2754 S->openInsnRange(R.first);
2755 S->extendInsnRange(R.second);
2760 PrevDbgScope->closeInsnRange();
2762 identifyScopeMarkers();
2764 return !DbgScopeMap.empty();
2767 /// identifyScopeMarkers() -
2768 /// Each DbgScope has first instruction and last instruction to mark beginning
2769 /// and end of a scope respectively. Create an inverse map that list scopes
2770 /// starts (and ends) with an instruction. One instruction may start (or end)
2771 /// multiple scopes. Ignore scopes that are not reachable.
2772 void DwarfDebug::identifyScopeMarkers() {
2773 SmallVector<DbgScope *, 4> WorkList;
2774 WorkList.push_back(CurrentFnDbgScope);
2775 while (!WorkList.empty()) {
2776 DbgScope *S = WorkList.pop_back_val();
2778 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2779 if (!Children.empty())
2780 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2781 SE = Children.end(); SI != SE; ++SI)
2782 WorkList.push_back(*SI);
2784 if (S->isAbstractScope())
2787 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2790 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2791 RE = Ranges.end(); RI != RE; ++RI) {
2792 assert(RI->first && "DbgRange does not have first instruction!");
2793 assert(RI->second && "DbgRange does not have second instruction!");
2794 InsnsEndScopeSet.insert(RI->second);
2799 /// FindFirstDebugLoc - Find the first debug location in the function. This
2800 /// is intended to be an approximation for the source position of the
2801 /// beginning of the function.
2802 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2803 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2805 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2806 MBBI != MBBE; ++MBBI) {
2807 DebugLoc DL = MBBI->getDebugLoc();
2808 if (!DL.isUnknown())
2815 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2816 /// line number information.
2817 static void CheckLineNumbers(const MachineFunction *MF) {
2818 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2820 bool FoundLineNo = false;
2821 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2823 const MachineInstr *MI = II;
2824 if (!MI->getDebugLoc().isUnknown()) {
2829 if (!FoundLineNo && I->size())
2830 ++BlocksWithoutLineNo;
2835 /// beginFunction - Gather pre-function debug information. Assumes being
2836 /// emitted immediately after the function entry point.
2837 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2838 if (!MMI->hasDebugInfo()) return;
2839 if (!extractScopeInformation()) return;
2842 CheckLineNumbers(MF);
2845 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2846 Asm->getFunctionNumber());
2847 // Assumes in correct section after the entry point.
2848 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2850 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2852 DebugLoc FDL = FindFirstDebugLoc(MF);
2853 if (FDL.isUnknown()) return;
2855 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2856 const MDNode *TheScope = 0;
2858 DISubprogram SP = getDISubprogram(Scope);
2861 Line = SP.getLineNumber();
2865 Line = FDL.getLine();
2870 recordSourceLine(Line, Col, TheScope);
2872 /// ProcessedArgs - Collection of arguments already processed.
2873 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2876 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2878 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2880 const MachineInstr *MI = II;
2881 DebugLoc DL = MI->getDebugLoc();
2882 if (MI->isDebugValue()) {
2883 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2884 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2885 if (!DV.Verify()) continue;
2886 // If DBG_VALUE is for a local variable then it needs a label.
2887 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2888 InsnNeedsLabel.insert(MI);
2889 // DBG_VALUE for inlined functions argument needs a label.
2890 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2891 describes(MF->getFunction()))
2892 InsnNeedsLabel.insert(MI);
2893 // DBG_VALUE indicating argument location change needs a label.
2894 else if (!ProcessedArgs.insert(DV))
2895 InsnNeedsLabel.insert(MI);
2897 // If location is unknown then instruction needs a location only if
2898 // UnknownLocations flag is set.
2899 if (DL.isUnknown()) {
2900 if (UnknownLocations && !PrevLoc.isUnknown())
2901 InsnNeedsLabel.insert(MI);
2902 } else if (DL != PrevLoc)
2903 // Otherwise, instruction needs a location only if it is new location.
2904 InsnNeedsLabel.insert(MI);
2907 if (!DL.isUnknown() || UnknownLocations)
2911 PrevLabel = FunctionBeginSym;
2914 /// endFunction - Gather and emit post-function debug information.
2916 void DwarfDebug::endFunction(const MachineFunction *MF) {
2917 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2919 if (CurrentFnDbgScope) {
2921 // Define end label for subprogram.
2922 FunctionEndSym = Asm->GetTempSymbol("func_end",
2923 Asm->getFunctionNumber());
2924 // Assumes in correct section after the entry point.
2925 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2927 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2928 collectVariableInfo(MF, ProcessedVars);
2930 // Construct abstract scopes.
2931 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2932 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2933 DISubprogram SP((*AI)->getScopeNode());
2935 // Collect info for variables that were optimized out.
2936 StringRef FName = SP.getLinkageName();
2938 FName = SP.getName();
2939 if (NamedMDNode *NMD =
2940 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
2941 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2942 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2943 if (!DV || !ProcessedVars.insert(DV))
2945 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2947 Scope->addVariable(new DbgVariable(DV));
2951 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2952 constructScopeDIE(*AI);
2955 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2957 if (!DisableFramePointerElim(*MF))
2958 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2959 dwarf::DW_FORM_flag, 1);
2962 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2963 MMI->getFrameMoves()));
2967 CurrentFnDbgScope = NULL;
2968 InsnNeedsLabel.clear();
2969 DbgVariableToFrameIndexMap.clear();
2970 VarToAbstractVarMap.clear();
2971 DbgVariableToDbgInstMap.clear();
2972 DeleteContainerSeconds(DbgScopeMap);
2973 InsnsEndScopeSet.clear();
2974 ConcreteScopes.clear();
2975 DeleteContainerSeconds(AbstractScopes);
2976 AbstractScopesList.clear();
2977 AbstractVariables.clear();
2978 LabelsBeforeInsn.clear();
2979 LabelsAfterInsn.clear();
2983 /// recordVariableFrameIndex - Record a variable's index.
2984 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2985 assert (V && "Invalid DbgVariable!");
2986 DbgVariableToFrameIndexMap[V] = Index;
2989 /// findVariableFrameIndex - Return true if frame index for the variable
2990 /// is found. Update FI to hold value of the index.
2991 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2992 assert (V && "Invalid DbgVariable!");
2993 DenseMap<const DbgVariable *, int>::iterator I =
2994 DbgVariableToFrameIndexMap.find(V);
2995 if (I == DbgVariableToFrameIndexMap.end())
3001 /// findDbgScope - Find DbgScope for the debug loc attached with an
3003 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
3004 DbgScope *Scope = NULL;
3006 MInsn->getParent()->getParent()->getFunction()->getContext();
3007 DebugLoc DL = MInsn->getDebugLoc();
3012 if (const MDNode *IA = DL.getInlinedAt(Ctx))
3013 Scope = ConcreteScopes.lookup(IA);
3015 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
3021 /// recordSourceLine - Register a source line with debug info. Returns the
3022 /// unique label that was emitted and which provides correspondence to
3023 /// the source line list.
3024 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
3030 DIDescriptor Scope(S);
3032 if (Scope.isCompileUnit()) {
3033 DICompileUnit CU(S);
3034 Fn = CU.getFilename();
3035 } else if (Scope.isFile()) {
3037 Fn = F.getFilename();
3038 } else if (Scope.isSubprogram()) {
3040 Fn = SP.getFilename();
3041 } else if (Scope.isLexicalBlock()) {
3042 DILexicalBlock DB(S);
3043 Fn = DB.getFilename();
3045 assert(0 && "Unexpected scope info");
3047 Src = GetOrCreateSourceID(Fn);
3050 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
3053 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
3054 Asm->OutStreamer.EmitLabel(Label);
3058 //===----------------------------------------------------------------------===//
3060 //===----------------------------------------------------------------------===//
3062 /// computeSizeAndOffset - Compute the size and offset of a DIE.
3065 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
3066 // Get the children.
3067 const std::vector<DIE *> &Children = Die->getChildren();
3069 // If not last sibling and has children then add sibling offset attribute.
3070 if (!Last && !Children.empty())
3071 Die->addSiblingOffset(DIEValueAllocator);
3073 // Record the abbreviation.
3074 assignAbbrevNumber(Die->getAbbrev());
3076 // Get the abbreviation for this DIE.
3077 unsigned AbbrevNumber = Die->getAbbrevNumber();
3078 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3081 Die->setOffset(Offset);
3083 // Start the size with the size of abbreviation code.
3084 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3086 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3087 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3089 // Size the DIE attribute values.
3090 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3091 // Size attribute value.
3092 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3094 // Size the DIE children if any.
3095 if (!Children.empty()) {
3096 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3097 "Children flag not set");
3099 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3100 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3102 // End of children marker.
3103 Offset += sizeof(int8_t);
3106 Die->setSize(Offset - Die->getOffset());
3110 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3112 void DwarfDebug::computeSizeAndOffsets() {
3113 unsigned PrevOffset = 0;
3114 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3115 E = CUMap.end(); I != E; ++I) {
3116 // Compute size of compile unit header.
3117 static unsigned Offset = PrevOffset +
3118 sizeof(int32_t) + // Length of Compilation Unit Info
3119 sizeof(int16_t) + // DWARF version number
3120 sizeof(int32_t) + // Offset Into Abbrev. Section
3121 sizeof(int8_t); // Pointer Size (in bytes)
3122 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3123 PrevOffset = Offset;
3127 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3128 /// temporary label to it if SymbolStem is specified.
3129 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3130 const char *SymbolStem = 0) {
3131 Asm->OutStreamer.SwitchSection(Section);
3132 if (!SymbolStem) return 0;
3134 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3135 Asm->OutStreamer.EmitLabel(TmpSym);
3139 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3140 /// the start of each one.
3141 void DwarfDebug::EmitSectionLabels() {
3142 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3144 // Dwarf sections base addresses.
3145 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3146 DwarfFrameSectionSym =
3147 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3150 DwarfInfoSectionSym =
3151 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3152 DwarfAbbrevSectionSym =
3153 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3154 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3156 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3157 EmitSectionSym(Asm, MacroInfo);
3159 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3160 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3161 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3162 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3163 DwarfStrSectionSym =
3164 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3165 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3168 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3169 "section_debug_loc");
3171 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3172 EmitSectionSym(Asm, TLOF.getDataSection());
3175 /// emitDIE - Recusively Emits a debug information entry.
3177 void DwarfDebug::emitDIE(DIE *Die) {
3178 // Get the abbreviation for this DIE.
3179 unsigned AbbrevNumber = Die->getAbbrevNumber();
3180 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3182 // Emit the code (index) for the abbreviation.
3183 if (Asm->isVerbose())
3184 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3185 Twine::utohexstr(Die->getOffset()) + ":0x" +
3186 Twine::utohexstr(Die->getSize()) + " " +
3187 dwarf::TagString(Abbrev->getTag()));
3188 Asm->EmitULEB128(AbbrevNumber);
3190 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3191 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3193 // Emit the DIE attribute values.
3194 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3195 unsigned Attr = AbbrevData[i].getAttribute();
3196 unsigned Form = AbbrevData[i].getForm();
3197 assert(Form && "Too many attributes for DIE (check abbreviation)");
3199 if (Asm->isVerbose())
3200 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3203 case dwarf::DW_AT_sibling:
3204 Asm->EmitInt32(Die->getSiblingOffset());
3206 case dwarf::DW_AT_abstract_origin: {
3207 DIEEntry *E = cast<DIEEntry>(Values[i]);
3208 DIE *Origin = E->getEntry();
3209 unsigned Addr = Origin->getOffset();
3210 Asm->EmitInt32(Addr);
3213 case dwarf::DW_AT_ranges: {
3214 // DW_AT_range Value encodes offset in debug_range section.
3215 DIEInteger *V = cast<DIEInteger>(Values[i]);
3217 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3218 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3222 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3224 DwarfDebugRangeSectionSym,
3229 case dwarf::DW_AT_location: {
3230 if (UseDotDebugLocEntry.count(Die) != 0) {
3231 DIELabel *L = cast<DIELabel>(Values[i]);
3232 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3234 Values[i]->EmitValue(Asm, Form);
3237 case dwarf::DW_AT_accessibility: {
3238 if (Asm->isVerbose()) {
3239 DIEInteger *V = cast<DIEInteger>(Values[i]);
3240 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3242 Values[i]->EmitValue(Asm, Form);
3246 // Emit an attribute using the defined form.
3247 Values[i]->EmitValue(Asm, Form);
3252 // Emit the DIE children if any.
3253 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3254 const std::vector<DIE *> &Children = Die->getChildren();
3256 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3257 emitDIE(Children[j]);
3259 if (Asm->isVerbose())
3260 Asm->OutStreamer.AddComment("End Of Children Mark");
3265 /// emitDebugInfo - Emit the debug info section.
3267 void DwarfDebug::emitDebugInfo() {
3268 // Start debug info section.
3269 Asm->OutStreamer.SwitchSection(
3270 Asm->getObjFileLowering().getDwarfInfoSection());
3271 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3272 E = CUMap.end(); I != E; ++I) {
3273 CompileUnit *TheCU = I->second;
3274 DIE *Die = TheCU->getCUDie();
3276 // Emit the compile units header.
3277 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3280 // Emit size of content not including length itself
3281 unsigned ContentSize = Die->getSize() +
3282 sizeof(int16_t) + // DWARF version number
3283 sizeof(int32_t) + // Offset Into Abbrev. Section
3284 sizeof(int8_t) + // Pointer Size (in bytes)
3285 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3287 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3288 Asm->EmitInt32(ContentSize);
3289 Asm->OutStreamer.AddComment("DWARF version number");
3290 Asm->EmitInt16(dwarf::DWARF_VERSION);
3291 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3292 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3293 DwarfAbbrevSectionSym);
3294 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3295 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3298 // FIXME - extra padding for gdb bug.
3299 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3304 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3308 /// emitAbbreviations - Emit the abbreviation section.
3310 void DwarfDebug::emitAbbreviations() const {
3311 // Check to see if it is worth the effort.
3312 if (!Abbreviations.empty()) {
3313 // Start the debug abbrev section.
3314 Asm->OutStreamer.SwitchSection(
3315 Asm->getObjFileLowering().getDwarfAbbrevSection());
3317 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3319 // For each abbrevation.
3320 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3321 // Get abbreviation data
3322 const DIEAbbrev *Abbrev = Abbreviations[i];
3324 // Emit the abbrevations code (base 1 index.)
3325 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3327 // Emit the abbreviations data.
3331 // Mark end of abbreviations.
3332 Asm->EmitULEB128(0, "EOM(3)");
3334 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3338 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3339 /// the line matrix.
3341 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3342 // Define last address of section.
3343 Asm->OutStreamer.AddComment("Extended Op");
3346 Asm->OutStreamer.AddComment("Op size");
3347 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3348 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3349 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3351 Asm->OutStreamer.AddComment("Section end label");
3353 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3354 Asm->getTargetData().getPointerSize(),
3357 // Mark end of matrix.
3358 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3364 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3366 void DwarfDebug::emitCommonDebugFrame() {
3367 if (!Asm->MAI->doesDwarfRequireFrameSection())
3370 int stackGrowth = Asm->getTargetData().getPointerSize();
3371 if (Asm->TM.getFrameLowering()->getStackGrowthDirection() ==
3372 TargetFrameLowering::StackGrowsDown)
3375 // Start the dwarf frame section.
3376 Asm->OutStreamer.SwitchSection(
3377 Asm->getObjFileLowering().getDwarfFrameSection());
3379 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3380 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3381 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3382 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3384 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3385 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3386 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3387 Asm->OutStreamer.AddComment("CIE Version");
3388 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3389 Asm->OutStreamer.AddComment("CIE Augmentation");
3390 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3391 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3392 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3393 Asm->OutStreamer.AddComment("CIE RA Column");
3394 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3395 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
3396 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3398 std::vector<MachineMove> Moves;
3399 TFI->getInitialFrameState(Moves);
3401 Asm->EmitFrameMoves(Moves, 0, false);
3403 Asm->EmitAlignment(2);
3404 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3407 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3410 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3411 if (!Asm->MAI->doesDwarfRequireFrameSection())
3414 // Start the dwarf frame section.
3415 Asm->OutStreamer.SwitchSection(
3416 Asm->getObjFileLowering().getDwarfFrameSection());
3418 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3419 MCSymbol *DebugFrameBegin =
3420 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3421 MCSymbol *DebugFrameEnd =
3422 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3423 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3425 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3427 Asm->OutStreamer.AddComment("FDE CIE offset");
3428 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3429 DwarfFrameSectionSym);
3431 Asm->OutStreamer.AddComment("FDE initial location");
3432 MCSymbol *FuncBeginSym =
3433 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3434 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3435 Asm->getTargetData().getPointerSize(),
3439 Asm->OutStreamer.AddComment("FDE address range");
3440 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3441 FuncBeginSym, Asm->getTargetData().getPointerSize());
3443 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3445 Asm->EmitAlignment(2);
3446 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3449 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3451 void DwarfDebug::emitDebugPubNames() {
3452 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3453 E = CUMap.end(); I != E; ++I) {
3454 CompileUnit *TheCU = I->second;
3455 // Start the dwarf pubnames section.
3456 Asm->OutStreamer.SwitchSection(
3457 Asm->getObjFileLowering().getDwarfPubNamesSection());
3459 Asm->OutStreamer.AddComment("Length of Public Names Info");
3460 Asm->EmitLabelDifference(
3461 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3462 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3464 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3467 Asm->OutStreamer.AddComment("DWARF Version");
3468 Asm->EmitInt16(dwarf::DWARF_VERSION);
3470 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3471 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3472 DwarfInfoSectionSym);
3474 Asm->OutStreamer.AddComment("Compilation Unit Length");
3475 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3476 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3479 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3480 for (StringMap<DIE*>::const_iterator
3481 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3482 const char *Name = GI->getKeyData();
3483 DIE *Entity = GI->second;
3485 Asm->OutStreamer.AddComment("DIE offset");
3486 Asm->EmitInt32(Entity->getOffset());
3488 if (Asm->isVerbose())
3489 Asm->OutStreamer.AddComment("External Name");
3490 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3493 Asm->OutStreamer.AddComment("End Mark");
3495 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3500 void DwarfDebug::emitDebugPubTypes() {
3501 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3502 E = CUMap.end(); I != E; ++I) {
3503 CompileUnit *TheCU = I->second;
3504 // Start the dwarf pubnames section.
3505 Asm->OutStreamer.SwitchSection(
3506 Asm->getObjFileLowering().getDwarfPubTypesSection());
3507 Asm->OutStreamer.AddComment("Length of Public Types Info");
3508 Asm->EmitLabelDifference(
3509 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3510 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3512 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3515 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3516 Asm->EmitInt16(dwarf::DWARF_VERSION);
3518 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3519 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3520 DwarfInfoSectionSym);
3522 Asm->OutStreamer.AddComment("Compilation Unit Length");
3523 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3524 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3527 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3528 for (StringMap<DIE*>::const_iterator
3529 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3530 const char *Name = GI->getKeyData();
3531 DIE * Entity = GI->second;
3533 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3534 Asm->EmitInt32(Entity->getOffset());
3536 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3537 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3540 Asm->OutStreamer.AddComment("End Mark");
3542 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3547 /// emitDebugStr - Emit visible names into a debug str section.
3549 void DwarfDebug::emitDebugStr() {
3550 // Check to see if it is worth the effort.
3551 if (StringPool.empty()) return;
3553 // Start the dwarf str section.
3554 Asm->OutStreamer.SwitchSection(
3555 Asm->getObjFileLowering().getDwarfStrSection());
3557 // Get all of the string pool entries and put them in an array by their ID so
3558 // we can sort them.
3559 SmallVector<std::pair<unsigned,
3560 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3562 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3563 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3564 Entries.push_back(std::make_pair(I->second.second, &*I));
3566 array_pod_sort(Entries.begin(), Entries.end());
3568 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3569 // Emit a label for reference from debug information entries.
3570 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3572 // Emit the string itself.
3573 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3577 /// emitDebugLoc - Emit visible names into a debug loc section.
3579 void DwarfDebug::emitDebugLoc() {
3580 if (DotDebugLocEntries.empty())
3583 // Start the dwarf loc section.
3584 Asm->OutStreamer.SwitchSection(
3585 Asm->getObjFileLowering().getDwarfLocSection());
3586 unsigned char Size = Asm->getTargetData().getPointerSize();
3587 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3589 for (SmallVector<DotDebugLocEntry, 4>::iterator
3590 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3591 I != E; ++I, ++index) {
3592 DotDebugLocEntry Entry = *I;
3593 if (Entry.isEmpty()) {
3594 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3595 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3596 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3598 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3599 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3600 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3601 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3602 if (int Offset = Entry.Loc.getOffset()) {
3603 // If the value is at a certain offset from frame register then
3605 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3606 Asm->OutStreamer.AddComment("Loc expr size");
3607 Asm->EmitInt16(1 + OffsetSize);
3608 Asm->OutStreamer.AddComment(
3609 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3610 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3611 Asm->OutStreamer.AddComment("Offset");
3612 Asm->EmitSLEB128(Offset);
3615 Asm->OutStreamer.AddComment("Loc expr size");
3617 Asm->OutStreamer.AddComment(
3618 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3619 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3621 Asm->OutStreamer.AddComment("Loc expr size");
3622 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3623 Asm->EmitInt8(dwarf::DW_OP_regx);
3624 Asm->EmitULEB128(Reg);
3631 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3633 void DwarfDebug::EmitDebugARanges() {
3634 // Start the dwarf aranges section.
3635 Asm->OutStreamer.SwitchSection(
3636 Asm->getObjFileLowering().getDwarfARangesSection());
3639 /// emitDebugRanges - Emit visible names into a debug ranges section.
3641 void DwarfDebug::emitDebugRanges() {
3642 // Start the dwarf ranges section.
3643 Asm->OutStreamer.SwitchSection(
3644 Asm->getObjFileLowering().getDwarfRangesSection());
3645 unsigned char Size = Asm->getTargetData().getPointerSize();
3646 for (SmallVector<const MCSymbol *, 8>::iterator
3647 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3650 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3652 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3656 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3658 void DwarfDebug::emitDebugMacInfo() {
3659 if (const MCSection *LineInfo =
3660 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3661 // Start the dwarf macinfo section.
3662 Asm->OutStreamer.SwitchSection(LineInfo);
3666 /// emitDebugInlineInfo - Emit inline info using following format.
3668 /// 1. length of section
3669 /// 2. Dwarf version number
3670 /// 3. address size.
3672 /// Entries (one "entry" for each function that was inlined):
3674 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3675 /// otherwise offset into __debug_str for regular function name.
3676 /// 2. offset into __debug_str section for regular function name.
3677 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3678 /// instances for the function.
3680 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3681 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3682 /// __debug_info section, and the low_pc is the starting address for the
3683 /// inlining instance.
3684 void DwarfDebug::emitDebugInlineInfo() {
3685 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3691 Asm->OutStreamer.SwitchSection(
3692 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3694 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3695 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3696 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3698 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3700 Asm->OutStreamer.AddComment("Dwarf Version");
3701 Asm->EmitInt16(dwarf::DWARF_VERSION);
3702 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3703 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3705 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3706 E = InlinedSPNodes.end(); I != E; ++I) {
3708 const MDNode *Node = *I;
3709 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3710 = InlineInfo.find(Node);
3711 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3712 DISubprogram SP(Node);
3713 StringRef LName = SP.getLinkageName();
3714 StringRef Name = SP.getName();
3716 Asm->OutStreamer.AddComment("MIPS linkage name");
3717 if (LName.empty()) {
3718 Asm->OutStreamer.EmitBytes(Name, 0);
3719 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3721 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3722 DwarfStrSectionSym);
3724 Asm->OutStreamer.AddComment("Function name");
3725 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3726 Asm->EmitULEB128(Labels.size(), "Inline count");
3728 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3729 LE = Labels.end(); LI != LE; ++LI) {
3730 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3731 Asm->EmitInt32(LI->second->getOffset());
3733 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3734 Asm->OutStreamer.EmitSymbolValue(LI->first,
3735 Asm->getTargetData().getPointerSize(),0);
3739 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));