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/CodeGen/MachineFunction.h"
20 #include "llvm/CodeGen/MachineModuleInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCStreamer.h"
24 #include "llvm/MC/MCSymbol.h"
25 #include "llvm/Target/Mangler.h"
26 #include "llvm/Target/TargetData.h"
27 #include "llvm/Target/TargetFrameInfo.h"
28 #include "llvm/Target/TargetLoweringObjectFile.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetRegisterInfo.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Analysis/DebugInfo.h"
33 #include "llvm/ADT/STLExtras.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/ValueHandle.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/Timer.h"
41 #include "llvm/System/Path.h"
44 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
45 cl::desc("Print DbgScope information for each machine instruction"));
47 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
49 cl::desc("Disable debug info printing"));
51 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
52 cl::desc("Make an absense of debug location information explicit."),
56 const char *DWARFGroupName = "DWARF Emission";
57 const char *DbgTimerName = "DWARF Debug Writer";
58 } // end anonymous namespace
60 //===----------------------------------------------------------------------===//
62 /// Configuration values for initial hash set sizes (log2).
64 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
68 //===----------------------------------------------------------------------===//
69 /// CompileUnit - This dwarf writer support class manages information associate
70 /// with a source file.
72 /// ID - File identifier for source.
76 /// Die - Compile unit debug information entry.
78 const OwningPtr<DIE> CUDie;
80 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
83 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
84 /// variables to debug information entries.
85 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
87 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
88 /// descriptors to debug information entries using a DIEEntry proxy.
89 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
91 /// Globals - A map of globally visible named entities for this unit.
93 StringMap<DIE*> Globals;
95 /// GlobalTypes - A map of globally visible types for this unit.
97 StringMap<DIE*> GlobalTypes;
100 CompileUnit(unsigned I, DIE *D)
101 : ID(I), CUDie(D), IndexTyDie(0) {}
104 unsigned getID() const { return ID; }
105 DIE* getCUDie() const { return CUDie.get(); }
106 const StringMap<DIE*> &getGlobals() const { return Globals; }
107 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
109 /// hasContent - Return true if this compile unit has something to write out.
111 bool hasContent() const { return !CUDie->getChildren().empty(); }
113 /// addGlobal - Add a new global entity to the compile unit.
115 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
117 /// addGlobalType - Add a new global type to the compile unit.
119 void addGlobalType(StringRef Name, DIE *Die) {
120 GlobalTypes[Name] = Die;
123 /// getDIE - Returns the debug information entry map slot for the
124 /// specified debug variable.
125 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
127 /// insertDIE - Insert DIE into the map.
128 void insertDIE(const MDNode *N, DIE *D) {
129 MDNodeToDieMap.insert(std::make_pair(N, D));
132 /// getDIEEntry - Returns the debug information entry for the speciefied
134 DIEEntry *getDIEEntry(const MDNode *N) {
135 DenseMap<const MDNode *, DIEEntry *>::iterator I =
136 MDNodeToDIEEntryMap.find(N);
137 if (I == MDNodeToDIEEntryMap.end())
142 /// insertDIEEntry - Insert debug information entry into the map.
143 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
144 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
147 /// addDie - Adds or interns the DIE to the compile unit.
149 void addDie(DIE *Buffer) {
150 this->CUDie->addChild(Buffer);
153 // getIndexTyDie - Get an anonymous type for index type.
154 DIE *getIndexTyDie() {
158 // setIndexTyDie - Set D as anonymous type for index which can be reused
160 void setIndexTyDie(DIE *D) {
166 //===----------------------------------------------------------------------===//
167 /// DbgVariable - This class is used to track local variable information.
170 DIVariable Var; // Variable Descriptor.
171 DIE *TheDIE; // Variable DIE.
172 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
174 // AbsVar may be NULL.
175 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
178 DIVariable getVariable() const { return Var; }
179 void setDIE(DIE *D) { TheDIE = D; }
180 DIE *getDIE() const { return TheDIE; }
181 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
182 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
183 StringRef getName() const { return Var.getName(); }
184 unsigned getTag() const { return Var.getTag(); }
185 bool variableHasComplexAddress() const {
186 assert(Var.Verify() && "Invalid complex DbgVariable!");
187 return Var.hasComplexAddress();
189 bool isBlockByrefVariable() const {
190 assert(Var.Verify() && "Invalid complex DbgVariable!");
191 return Var.isBlockByrefVariable();
193 unsigned getNumAddrElements() const {
194 assert(Var.Verify() && "Invalid complex DbgVariable!");
195 return Var.getNumAddrElements();
197 uint64_t getAddrElement(unsigned i) const {
198 return Var.getAddrElement(i);
200 DIType getType() const {
201 DIType Ty = Var.getType();
202 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
203 // addresses instead.
204 if (Var.isBlockByrefVariable()) {
205 /* Byref variables, in Blocks, are declared by the programmer as
206 "SomeType VarName;", but the compiler creates a
207 __Block_byref_x_VarName struct, and gives the variable VarName
208 either the struct, or a pointer to the struct, as its type. This
209 is necessary for various behind-the-scenes things the compiler
210 needs to do with by-reference variables in blocks.
212 However, as far as the original *programmer* is concerned, the
213 variable should still have type 'SomeType', as originally declared.
215 The following function dives into the __Block_byref_x_VarName
216 struct to find the original type of the variable. This will be
217 passed back to the code generating the type for the Debug
218 Information Entry for the variable 'VarName'. 'VarName' will then
219 have the original type 'SomeType' in its debug information.
221 The original type 'SomeType' will be the type of the field named
222 'VarName' inside the __Block_byref_x_VarName struct.
224 NOTE: In order for this to not completely fail on the debugger
225 side, the Debug Information Entry for the variable VarName needs to
226 have a DW_AT_location that tells the debugger how to unwind through
227 the pointers and __Block_byref_x_VarName struct to find the actual
228 value of the variable. The function addBlockByrefType does this. */
230 unsigned tag = Ty.getTag();
232 if (tag == dwarf::DW_TAG_pointer_type) {
233 DIDerivedType DTy = DIDerivedType(Ty);
234 subType = DTy.getTypeDerivedFrom();
237 DICompositeType blockStruct = DICompositeType(subType);
238 DIArray Elements = blockStruct.getTypeArray();
240 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
241 DIDescriptor Element = Elements.getElement(i);
242 DIDerivedType DT = DIDerivedType(Element);
243 if (getName() == DT.getName())
244 return (DT.getTypeDerivedFrom());
252 //===----------------------------------------------------------------------===//
253 /// DbgRange - This is used to track range of instructions with identical
254 /// debug info scope.
256 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
258 //===----------------------------------------------------------------------===//
259 /// DbgScope - This class is used to track scope information.
262 DbgScope *Parent; // Parent to this scope.
263 DIDescriptor Desc; // Debug info descriptor for scope.
264 // Location at which this scope is inlined.
265 AssertingVH<const MDNode> InlinedAtLocation;
266 bool AbstractScope; // Abstract Scope
267 const MachineInstr *LastInsn; // Last instruction of this scope.
268 const MachineInstr *FirstInsn; // First instruction of this scope.
269 unsigned DFSIn, DFSOut;
270 // Scopes defined in scope. Contents not owned.
271 SmallVector<DbgScope *, 4> Scopes;
272 // Variables declared in scope. Contents owned.
273 SmallVector<DbgVariable *, 8> Variables;
274 SmallVector<DbgRange, 4> Ranges;
275 // Private state for dump()
276 mutable unsigned IndentLevel;
278 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
279 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
280 LastInsn(0), FirstInsn(0),
281 DFSIn(0), DFSOut(0), IndentLevel(0) {}
285 DbgScope *getParent() const { return Parent; }
286 void setParent(DbgScope *P) { Parent = P; }
287 DIDescriptor getDesc() const { return Desc; }
288 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
289 const MDNode *getScopeNode() const { return Desc; }
290 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
291 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
292 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
294 /// openInsnRange - This scope covers instruction range starting from MI.
295 void openInsnRange(const MachineInstr *MI) {
300 Parent->openInsnRange(MI);
303 /// extendInsnRange - Extend the current instruction range covered by
305 void extendInsnRange(const MachineInstr *MI) {
306 assert (FirstInsn && "MI Range is not open!");
309 Parent->extendInsnRange(MI);
312 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
313 /// until now. This is used when a new scope is encountered while walking
314 /// machine instructions.
315 void closeInsnRange(DbgScope *NewScope = NULL) {
316 assert (LastInsn && "Last insn missing!");
317 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
320 // If Parent dominates NewScope then do not close Parent's instruction
322 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
323 Parent->closeInsnRange(NewScope);
326 void setAbstractScope() { AbstractScope = true; }
327 bool isAbstractScope() const { return AbstractScope; }
329 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
330 unsigned getDFSOut() const { return DFSOut; }
331 void setDFSOut(unsigned O) { DFSOut = O; }
332 unsigned getDFSIn() const { return DFSIn; }
333 void setDFSIn(unsigned I) { DFSIn = I; }
334 bool dominates(const DbgScope *S) {
337 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
342 /// addScope - Add a scope to the scope.
344 void addScope(DbgScope *S) { Scopes.push_back(S); }
346 /// addVariable - Add a variable to the scope.
348 void addVariable(DbgVariable *V) { Variables.push_back(V); }
355 } // end llvm namespace
358 void DbgScope::dump() const {
359 raw_ostream &err = dbgs();
360 err.indent(IndentLevel);
361 const MDNode *N = Desc;
364 err << "Abstract Scope\n";
368 err << "Children ...\n";
369 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
370 if (Scopes[i] != this)
377 DbgScope::~DbgScope() {
378 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
382 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
383 : Asm(A), MMI(Asm->MMI), FirstCU(0),
384 AbbreviationsSet(InitAbbreviationsSetSize),
385 CurrentFnDbgScope(0), PrevLabel(NULL) {
386 NextStringPoolNumber = 0;
388 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
389 DwarfStrSectionSym = TextSectionSym = 0;
390 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
391 DwarfDebugLineSectionSym = CurrentLineSectionSym = 0;
392 FunctionBeginSym = FunctionEndSym = 0;
393 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
395 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
399 DwarfDebug::~DwarfDebug() {
400 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
401 DIEBlocks[j]->~DIEBlock();
404 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
405 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
406 if (Entry.first) return Entry.first;
408 Entry.second = NextStringPoolNumber++;
409 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
413 /// assignAbbrevNumber - Define a unique number for the abbreviation.
415 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
416 // Profile the node so that we can make it unique.
420 // Check the set for priors.
421 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
423 // If it's newly added.
424 if (InSet == &Abbrev) {
425 // Add to abbreviation list.
426 Abbreviations.push_back(&Abbrev);
428 // Assign the vector position + 1 as its number.
429 Abbrev.setNumber(Abbreviations.size());
431 // Assign existing abbreviation number.
432 Abbrev.setNumber(InSet->getNumber());
436 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
437 /// information entry.
438 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
439 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
443 /// addUInt - Add an unsigned integer attribute data and value.
445 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
446 unsigned Form, uint64_t Integer) {
447 if (!Form) Form = DIEInteger::BestForm(false, Integer);
448 DIEValue *Value = Integer == 1 ?
449 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
450 Die->addValue(Attribute, Form, Value);
453 /// addSInt - Add an signed integer attribute data and value.
455 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
456 unsigned Form, int64_t Integer) {
457 if (!Form) Form = DIEInteger::BestForm(true, Integer);
458 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
459 Die->addValue(Attribute, Form, Value);
462 /// addString - Add a string attribute data and value. DIEString only
463 /// keeps string reference.
464 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
466 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
467 Die->addValue(Attribute, Form, Value);
470 /// addLabel - Add a Dwarf label attribute data and value.
472 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
473 const MCSymbol *Label) {
474 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
475 Die->addValue(Attribute, Form, Value);
478 /// addDelta - Add a label delta attribute data and value.
480 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
481 const MCSymbol *Hi, const MCSymbol *Lo) {
482 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
483 Die->addValue(Attribute, Form, Value);
486 /// addDIEEntry - Add a DIE attribute data and value.
488 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
490 Die->addValue(Attribute, Form, createDIEEntry(Entry));
494 /// addBlock - Add block data.
496 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
498 Block->ComputeSize(Asm);
499 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
500 Die->addValue(Attribute, Block->BestForm(), Block);
503 /// addSourceLine - Add location information to specified debug information
505 void DwarfDebug::addSourceLine(DIE *Die, DIVariable V) {
510 unsigned Line = V.getLineNumber();
511 unsigned FileID = GetOrCreateSourceID(V.getContext().getDirectory(),
512 V.getContext().getFilename());
513 assert(FileID && "Invalid file id");
514 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
515 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
518 /// addSourceLine - Add location information to specified debug information
520 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
521 // Verify global variable.
525 unsigned Line = G.getLineNumber();
526 unsigned FileID = GetOrCreateSourceID(G.getContext().getDirectory(),
527 G.getContext().getFilename());
528 assert(FileID && "Invalid file id");
529 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
530 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
533 /// addSourceLine - Add location information to specified debug information
535 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
536 // Verify subprogram.
539 // If the line number is 0, don't add it.
540 if (SP.getLineNumber() == 0)
543 unsigned Line = SP.getLineNumber();
544 if (!SP.getContext().Verify())
546 unsigned FileID = GetOrCreateSourceID(SP.getDirectory(),
548 assert(FileID && "Invalid file id");
549 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
550 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
553 /// addSourceLine - Add location information to specified debug information
555 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
560 unsigned Line = Ty.getLineNumber();
561 if (!Ty.getContext().Verify())
563 unsigned FileID = GetOrCreateSourceID(Ty.getContext().getDirectory(),
564 Ty.getContext().getFilename());
565 assert(FileID && "Invalid file id");
566 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
567 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
570 /// addSourceLine - Add location information to specified debug information
572 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
577 unsigned Line = NS.getLineNumber();
578 StringRef FN = NS.getFilename();
579 StringRef Dir = NS.getDirectory();
581 unsigned FileID = GetOrCreateSourceID(Dir, FN);
582 assert(FileID && "Invalid file id");
583 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
584 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
587 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable.
588 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die,
590 const MachineLocation &Location) {
591 if (DV->variableHasComplexAddress())
592 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
593 else if (DV->isBlockByrefVariable())
594 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
596 addAddress(Die, dwarf::DW_AT_location, Location);
599 /// addComplexAddress - Start with the address based on the location provided,
600 /// and generate the DWARF information necessary to find the actual variable
601 /// given the extra address information encoded in the DIVariable, starting from
602 /// the starting location. Add the DWARF information to the die.
604 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
606 const MachineLocation &Location) {
607 DIType Ty = DV->getType();
609 // Decode the original location, and use that as the start of the byref
610 // variable's location.
611 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
612 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
613 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
615 if (Location.isReg()) {
617 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
619 Reg = Reg - dwarf::DW_OP_reg0;
620 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
621 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
625 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
627 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
628 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
631 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
634 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
635 uint64_t Element = DV->getAddrElement(i);
637 if (Element == DIFactory::OpPlus) {
638 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
639 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
640 } else if (Element == DIFactory::OpDeref) {
641 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
642 } else llvm_unreachable("unknown DIFactory Opcode");
645 // Now attach the location information to the DIE.
646 addBlock(Die, Attribute, 0, Block);
649 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
650 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
651 gives the variable VarName either the struct, or a pointer to the struct, as
652 its type. This is necessary for various behind-the-scenes things the
653 compiler needs to do with by-reference variables in Blocks.
655 However, as far as the original *programmer* is concerned, the variable
656 should still have type 'SomeType', as originally declared.
658 The function getBlockByrefType dives into the __Block_byref_x_VarName
659 struct to find the original type of the variable, which is then assigned to
660 the variable's Debug Information Entry as its real type. So far, so good.
661 However now the debugger will expect the variable VarName to have the type
662 SomeType. So we need the location attribute for the variable to be an
663 expression that explains to the debugger how to navigate through the
664 pointers and struct to find the actual variable of type SomeType.
666 The following function does just that. We start by getting
667 the "normal" location for the variable. This will be the location
668 of either the struct __Block_byref_x_VarName or the pointer to the
669 struct __Block_byref_x_VarName.
671 The struct will look something like:
673 struct __Block_byref_x_VarName {
675 struct __Block_byref_x_VarName *forwarding;
676 ... <various other fields>
678 ... <maybe more fields>
681 If we are given the struct directly (as our starting point) we
682 need to tell the debugger to:
684 1). Add the offset of the forwarding field.
686 2). Follow that pointer to get the real __Block_byref_x_VarName
687 struct to use (the real one may have been copied onto the heap).
689 3). Add the offset for the field VarName, to find the actual variable.
691 If we started with a pointer to the struct, then we need to
692 dereference that pointer first, before the other steps.
693 Translating this into DWARF ops, we will need to append the following
694 to the current location description for the variable:
696 DW_OP_deref -- optional, if we start with a pointer
697 DW_OP_plus_uconst <forward_fld_offset>
699 DW_OP_plus_uconst <varName_fld_offset>
701 That is what this function does. */
703 /// addBlockByrefAddress - Start with the address based on the location
704 /// provided, and generate the DWARF information necessary to find the
705 /// actual Block variable (navigating the Block struct) based on the
706 /// starting location. Add the DWARF information to the die. For
707 /// more information, read large comment just above here.
709 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
711 const MachineLocation &Location) {
712 DIType Ty = DV->getType();
714 unsigned Tag = Ty.getTag();
715 bool isPointer = false;
717 StringRef varName = DV->getName();
719 if (Tag == dwarf::DW_TAG_pointer_type) {
720 DIDerivedType DTy = DIDerivedType(Ty);
721 TmpTy = DTy.getTypeDerivedFrom();
725 DICompositeType blockStruct = DICompositeType(TmpTy);
727 // Find the __forwarding field and the variable field in the __Block_byref
729 DIArray Fields = blockStruct.getTypeArray();
730 DIDescriptor varField = DIDescriptor();
731 DIDescriptor forwardingField = DIDescriptor();
733 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
734 DIDescriptor Element = Fields.getElement(i);
735 DIDerivedType DT = DIDerivedType(Element);
736 StringRef fieldName = DT.getName();
737 if (fieldName == "__forwarding")
738 forwardingField = Element;
739 else if (fieldName == varName)
743 // Get the offsets for the forwarding field and the variable field.
744 unsigned forwardingFieldOffset =
745 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
746 unsigned varFieldOffset =
747 DIDerivedType(varField).getOffsetInBits() >> 3;
749 // Decode the original location, and use that as the start of the byref
750 // variable's location.
751 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
752 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
753 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
755 if (Location.isReg()) {
757 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
759 Reg = Reg - dwarf::DW_OP_reg0;
760 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
761 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
767 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
768 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
771 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
774 // If we started with a pointer to the __Block_byref... struct, then
775 // the first thing we need to do is dereference the pointer (DW_OP_deref).
777 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
779 // Next add the offset for the '__forwarding' field:
780 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
781 // adding the offset if it's 0.
782 if (forwardingFieldOffset > 0) {
783 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
784 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
787 // Now dereference the __forwarding field to get to the real __Block_byref
788 // struct: DW_OP_deref.
789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
791 // Now that we've got the real __Block_byref... struct, add the offset
792 // for the variable's field to get to the location of the actual variable:
793 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
794 if (varFieldOffset > 0) {
795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
799 // Now attach the location information to the DIE.
800 addBlock(Die, Attribute, 0, Block);
803 /// addAddress - Add an address attribute to a die based on the location
805 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
806 const MachineLocation &Location) {
807 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
808 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
809 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
811 if (Location.isReg()) {
813 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
815 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
816 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
820 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
822 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
823 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
826 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
829 addBlock(Die, Attribute, 0, Block);
832 /// addRegisterAddress - Add register location entry in variable DIE.
833 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
834 const MachineOperand &MO) {
835 assert (MO.isReg() && "Invalid machine operand!");
838 MachineLocation Location;
839 Location.set(MO.getReg());
840 addAddress(Die, dwarf::DW_AT_location, Location);
842 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
846 /// addConstantValue - Add constant value entry in variable DIE.
847 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
848 const MachineOperand &MO) {
849 assert (MO.isImm() && "Invalid machine operand!");
850 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
851 unsigned Imm = MO.getImm();
852 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
853 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
855 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
859 /// addConstantFPValue - Add constant value entry in variable DIE.
860 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
861 const MachineOperand &MO) {
862 assert (MO.isFPImm() && "Invalid machine operand!");
863 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
864 APFloat FPImm = MO.getFPImm()->getValueAPF();
866 // Get the raw data form of the floating point.
867 const APInt FltVal = FPImm.bitcastToAPInt();
868 const char *FltPtr = (const char*)FltVal.getRawData();
870 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
871 bool LittleEndian = Asm->getTargetData().isLittleEndian();
872 int Incr = (LittleEndian ? 1 : -1);
873 int Start = (LittleEndian ? 0 : NumBytes - 1);
874 int Stop = (LittleEndian ? NumBytes : -1);
876 // Output the constant to DWARF one byte at a time.
877 for (; Start != Stop; Start += Incr)
878 addUInt(Block, 0, dwarf::DW_FORM_data1,
879 (unsigned char)0xFF & FltPtr[Start]);
881 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
883 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
888 /// addToContextOwner - Add Die into the list of its context owner's children.
889 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
890 if (Context.isType()) {
891 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
892 ContextDIE->addChild(Die);
893 } else if (Context.isNameSpace()) {
894 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
895 ContextDIE->addChild(Die);
896 } else if (Context.isSubprogram()) {
897 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
899 ContextDIE->addChild(Die);
900 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
901 ContextDIE->addChild(Die);
903 getCompileUnit(Context)->addDie(Die);
906 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
908 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
909 CompileUnit *TypeCU = getCompileUnit(Ty);
910 DIE *TyDIE = TypeCU->getDIE(Ty);
915 TyDIE = new DIE(dwarf::DW_TAG_base_type);
916 TypeCU->insertDIE(Ty, TyDIE);
917 if (Ty.isBasicType())
918 constructTypeDIE(*TyDIE, DIBasicType(Ty));
919 else if (Ty.isCompositeType())
920 constructTypeDIE(*TyDIE, DICompositeType(Ty));
922 assert(Ty.isDerivedType() && "Unknown kind of DIType");
923 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
926 addToContextOwner(TyDIE, Ty.getContext());
930 /// addType - Add a new type attribute to the specified entity.
931 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
935 // Check for pre-existence.
936 CompileUnit *TypeCU = getCompileUnit(Ty);
937 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
938 // If it exists then use the existing value.
940 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
945 DIE *Buffer = getOrCreateTypeDIE(Ty);
948 Entry = createDIEEntry(Buffer);
949 TypeCU->insertDIEEntry(Ty, Entry);
951 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
954 /// constructTypeDIE - Construct basic type die from DIBasicType.
955 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
956 // Get core information.
957 StringRef Name = BTy.getName();
958 Buffer.setTag(dwarf::DW_TAG_base_type);
959 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
962 // Add name if not anonymous or intermediate type.
964 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
965 uint64_t Size = BTy.getSizeInBits() >> 3;
966 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
969 /// constructTypeDIE - Construct derived type die from DIDerivedType.
970 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
971 // Get core information.
972 StringRef Name = DTy.getName();
973 uint64_t Size = DTy.getSizeInBits() >> 3;
974 unsigned Tag = DTy.getTag();
976 // FIXME - Workaround for templates.
977 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
981 // Map to main type, void will not have a type.
982 DIType FromTy = DTy.getTypeDerivedFrom();
983 addType(&Buffer, FromTy);
985 // Add name if not anonymous or intermediate type.
987 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
989 // Add size if non-zero (derived types might be zero-sized.)
991 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
993 // Add source line info if available and TyDesc is not a forward declaration.
994 if (!DTy.isForwardDecl())
995 addSourceLine(&Buffer, DTy);
998 /// constructTypeDIE - Construct type DIE from DICompositeType.
999 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1000 // Get core information.
1001 StringRef Name = CTy.getName();
1003 uint64_t Size = CTy.getSizeInBits() >> 3;
1004 unsigned Tag = CTy.getTag();
1008 case dwarf::DW_TAG_vector_type:
1009 case dwarf::DW_TAG_array_type:
1010 constructArrayTypeDIE(Buffer, &CTy);
1012 case dwarf::DW_TAG_enumeration_type: {
1013 DIArray Elements = CTy.getTypeArray();
1015 // Add enumerators to enumeration type.
1016 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1017 DIE *ElemDie = NULL;
1018 DIDescriptor Enum(Elements.getElement(i));
1019 if (Enum.isEnumerator()) {
1020 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1021 Buffer.addChild(ElemDie);
1026 case dwarf::DW_TAG_subroutine_type: {
1028 DIArray Elements = CTy.getTypeArray();
1029 DIDescriptor RTy = Elements.getElement(0);
1030 addType(&Buffer, DIType(RTy));
1032 // Add prototype flag.
1033 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1036 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1037 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1038 DIDescriptor Ty = Elements.getElement(i);
1039 addType(Arg, DIType(Ty));
1040 Buffer.addChild(Arg);
1044 case dwarf::DW_TAG_structure_type:
1045 case dwarf::DW_TAG_union_type:
1046 case dwarf::DW_TAG_class_type: {
1047 // Add elements to structure type.
1048 DIArray Elements = CTy.getTypeArray();
1050 // A forward struct declared type may not have elements available.
1051 unsigned N = Elements.getNumElements();
1055 // Add elements to structure type.
1056 for (unsigned i = 0; i < N; ++i) {
1057 DIDescriptor Element = Elements.getElement(i);
1058 DIE *ElemDie = NULL;
1059 if (Element.isSubprogram())
1060 ElemDie = createSubprogramDIE(DISubprogram(Element));
1061 else if (Element.isVariable()) {
1062 DIVariable DV(Element);
1063 ElemDie = new DIE(dwarf::DW_TAG_variable);
1064 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1066 addType(ElemDie, DV.getType());
1067 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1068 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1069 addSourceLine(ElemDie, DV);
1070 } else if (Element.isDerivedType())
1071 ElemDie = createMemberDIE(DIDerivedType(Element));
1074 Buffer.addChild(ElemDie);
1077 if (CTy.isAppleBlockExtension())
1078 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1080 unsigned RLang = CTy.getRunTimeLang();
1082 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1083 dwarf::DW_FORM_data1, RLang);
1085 DICompositeType ContainingType = CTy.getContainingType();
1086 if (DIDescriptor(ContainingType).isCompositeType())
1087 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1088 getOrCreateTypeDIE(DIType(ContainingType)));
1090 DIDescriptor Context = CTy.getContext();
1091 addToContextOwner(&Buffer, Context);
1099 // Add name if not anonymous or intermediate type.
1101 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1103 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1104 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1106 // Add size if non-zero (derived types might be zero-sized.)
1108 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1110 // Add zero size if it is not a forward declaration.
1111 if (CTy.isForwardDecl())
1112 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1114 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1117 // Add source line info if available.
1118 if (!CTy.isForwardDecl())
1119 addSourceLine(&Buffer, CTy);
1123 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1124 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1125 int64_t L = SR.getLo();
1126 int64_t H = SR.getHi();
1127 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1129 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1131 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1132 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1134 Buffer.addChild(DW_Subrange);
1137 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1138 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1139 DICompositeType *CTy) {
1140 Buffer.setTag(dwarf::DW_TAG_array_type);
1141 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1142 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1144 // Emit derived type.
1145 addType(&Buffer, CTy->getTypeDerivedFrom());
1146 DIArray Elements = CTy->getTypeArray();
1148 // Get an anonymous type for index type.
1149 CompileUnit *TheCU = getCompileUnit(*CTy);
1150 DIE *IdxTy = TheCU->getIndexTyDie();
1152 // Construct an anonymous type for index type.
1153 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1154 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1155 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1156 dwarf::DW_ATE_signed);
1157 TheCU->addDie(IdxTy);
1158 TheCU->setIndexTyDie(IdxTy);
1161 // Add subranges to array type.
1162 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1163 DIDescriptor Element = Elements.getElement(i);
1164 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1165 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1169 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1170 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1171 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1172 StringRef Name = ETy.getName();
1173 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1174 int64_t Value = ETy.getEnumValue();
1175 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1179 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1180 /// printer to not emit usual symbol prefix before the symbol name is used then
1181 /// return linkage name after skipping this special LLVM prefix.
1182 static StringRef getRealLinkageName(StringRef LinkageName) {
1184 if (LinkageName.startswith(StringRef(&One, 1)))
1185 return LinkageName.substr(1);
1189 /// createMemberDIE - Create new member DIE.
1190 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1191 DIE *MemberDie = new DIE(DT.getTag());
1192 StringRef Name = DT.getName();
1194 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1196 addType(MemberDie, DT.getTypeDerivedFrom());
1198 addSourceLine(MemberDie, DT);
1200 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1201 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1203 uint64_t Size = DT.getSizeInBits();
1204 uint64_t FieldSize = DT.getOriginalTypeSize();
1206 if (Size != FieldSize) {
1208 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1209 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1211 uint64_t Offset = DT.getOffsetInBits();
1212 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1213 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1214 uint64_t FieldOffset = (HiMark - FieldSize);
1215 Offset -= FieldOffset;
1217 // Maybe we need to work from the other end.
1218 if (Asm->getTargetData().isLittleEndian())
1219 Offset = FieldSize - (Offset + Size);
1220 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1222 // Here WD_AT_data_member_location points to the anonymous
1223 // field that includes this bit field.
1224 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1227 // This is not a bitfield.
1228 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1230 if (DT.getTag() == dwarf::DW_TAG_inheritance
1231 && DT.isVirtual()) {
1233 // For C++, virtual base classes are not at fixed offset. Use following
1234 // expression to extract appropriate offset from vtable.
1235 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1237 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1238 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1239 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1240 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1241 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1242 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1243 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1244 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1246 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1249 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1251 if (DT.isProtected())
1252 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1253 dwarf::DW_ACCESS_protected);
1254 else if (DT.isPrivate())
1255 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1256 dwarf::DW_ACCESS_private);
1257 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1258 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1259 dwarf::DW_ACCESS_public);
1261 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1262 dwarf::DW_VIRTUALITY_virtual);
1266 /// createSubprogramDIE - Create new DIE using SP.
1267 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP, bool MakeDecl) {
1268 CompileUnit *SPCU = getCompileUnit(SP);
1269 DIE *SPDie = SPCU->getDIE(SP);
1273 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1274 // Constructors and operators for anonymous aggregates do not have names.
1275 if (!SP.getName().empty())
1276 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1278 StringRef LinkageName = SP.getLinkageName();
1279 if (!LinkageName.empty())
1280 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1281 getRealLinkageName(LinkageName));
1283 addSourceLine(SPDie, SP);
1285 // Add prototyped tag, if C or ObjC.
1286 unsigned Lang = SP.getCompileUnit().getLanguage();
1287 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1288 Lang == dwarf::DW_LANG_ObjC)
1289 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1292 DICompositeType SPTy = SP.getType();
1293 DIArray Args = SPTy.getTypeArray();
1294 unsigned SPTag = SPTy.getTag();
1296 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1297 addType(SPDie, SPTy);
1299 addType(SPDie, DIType(Args.getElement(0)));
1301 unsigned VK = SP.getVirtuality();
1303 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1304 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1305 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1306 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1307 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1308 ContainingTypeMap.insert(std::make_pair(SPDie,
1309 SP.getContainingType()));
1312 if (MakeDecl || !SP.isDefinition()) {
1313 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1315 // Add arguments. Do not add arguments for subprogram definition. They will
1316 // be handled while processing variables.
1317 DICompositeType SPTy = SP.getType();
1318 DIArray Args = SPTy.getTypeArray();
1319 unsigned SPTag = SPTy.getTag();
1321 if (SPTag == dwarf::DW_TAG_subroutine_type)
1322 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1323 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1324 DIType ATy = DIType(DIType(Args.getElement(i)));
1326 if (ATy.isArtificial())
1327 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1328 SPDie->addChild(Arg);
1332 if (SP.isArtificial())
1333 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1335 if (!SP.isLocalToUnit())
1336 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1338 if (SP.isOptimized())
1339 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1341 if (unsigned isa = Asm->getISAEncoding()) {
1342 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1345 // DW_TAG_inlined_subroutine may refer to this DIE.
1346 SPCU->insertDIE(SP, SPDie);
1348 // Add to context owner.
1349 addToContextOwner(SPDie, SP.getContext());
1354 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1355 assert(N && "Invalid Scope encoding!");
1357 DbgScope *AScope = AbstractScopes.lookup(N);
1361 DbgScope *Parent = NULL;
1363 DIDescriptor Scope(N);
1364 if (Scope.isLexicalBlock()) {
1365 DILexicalBlock DB(N);
1366 DIDescriptor ParentDesc = DB.getContext();
1367 Parent = getOrCreateAbstractScope(ParentDesc);
1370 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1373 Parent->addScope(AScope);
1374 AScope->setAbstractScope();
1375 AbstractScopes[N] = AScope;
1376 if (DIDescriptor(N).isSubprogram())
1377 AbstractScopesList.push_back(AScope);
1381 /// isSubprogramContext - Return true if Context is either a subprogram
1382 /// or another context nested inside a subprogram.
1383 static bool isSubprogramContext(const MDNode *Context) {
1386 DIDescriptor D(Context);
1387 if (D.isSubprogram())
1390 return isSubprogramContext(DIType(Context).getContext());
1394 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1395 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1396 /// If there are global variables in this scope then create and insert
1397 /// DIEs for these variables.
1398 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1399 CompileUnit *SPCU = getCompileUnit(SPNode);
1400 DIE *SPDie = SPCU->getDIE(SPNode);
1402 assert(SPDie && "Unable to find subprogram DIE!");
1403 DISubprogram SP(SPNode);
1405 // There is not any need to generate specification DIE for a function
1406 // defined at compile unit level. If a function is defined inside another
1407 // function then gdb prefers the definition at top level and but does not
1408 // expect specification DIE in parent function. So avoid creating
1409 // specification DIE for a function defined inside a function.
1410 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1411 !SP.getContext().isFile() &&
1412 !isSubprogramContext(SP.getContext())) {
1413 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1416 DICompositeType SPTy = SP.getType();
1417 DIArray Args = SPTy.getTypeArray();
1418 unsigned SPTag = SPTy.getTag();
1419 if (SPTag == dwarf::DW_TAG_subroutine_type)
1420 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1421 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1422 DIType ATy = DIType(DIType(Args.getElement(i)));
1424 if (ATy.isArtificial())
1425 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1426 SPDie->addChild(Arg);
1428 DIE *SPDeclDie = SPDie;
1429 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1430 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1432 SPCU->addDie(SPDie);
1435 // Pick up abstract subprogram DIE.
1436 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1437 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1438 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1439 dwarf::DW_FORM_ref4, AbsSPDIE);
1440 SPCU->addDie(SPDie);
1443 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1444 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1445 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1446 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1447 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1448 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1449 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1454 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1455 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1456 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1458 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1459 if (Scope->isAbstractScope())
1462 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1466 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1467 if (Ranges.size() > 1) {
1468 // .debug_range section has not been laid out yet. Emit offset in
1469 // .debug_range as a uint, size 4, for now. emitDIE will handle
1470 // DW_AT_ranges appropriately.
1471 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1472 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1473 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1474 RE = Ranges.end(); RI != RE; ++RI) {
1475 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1476 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1478 DebugRangeSymbols.push_back(NULL);
1479 DebugRangeSymbols.push_back(NULL);
1483 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1484 const MCSymbol *End = getLabelAfterInsn(RI->second);
1486 if (End == 0) return 0;
1488 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1489 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1491 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1492 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1497 /// constructInlinedScopeDIE - This scope represents inlined body of
1498 /// a function. Construct DIE to represent this concrete inlined copy
1499 /// of the function.
1500 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1502 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1503 assert (Ranges.empty() == false
1504 && "DbgScope does not have instruction markers!");
1506 // FIXME : .debug_inlined section specification does not clearly state how
1507 // to emit inlined scope that is split into multiple instruction ranges.
1508 // For now, use first instruction range and emit low_pc/high_pc pair and
1509 // corresponding .debug_inlined section entry for this pair.
1510 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1511 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1512 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1514 if (StartLabel == 0 || EndLabel == 0) {
1515 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1518 assert(StartLabel->isDefined() &&
1519 "Invalid starting label for an inlined scope!");
1520 assert(EndLabel->isDefined() &&
1521 "Invalid end label for an inlined scope!");
1523 if (!Scope->getScopeNode())
1525 DIScope DS(Scope->getScopeNode());
1526 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1528 DISubprogram InlinedSP = getDISubprogram(DS);
1529 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1530 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1531 assert(OriginDIE && "Unable to find Origin DIE!");
1532 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1533 dwarf::DW_FORM_ref4, OriginDIE);
1535 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1536 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1538 InlinedSubprogramDIEs.insert(OriginDIE);
1540 // Track the start label for this inlined function.
1541 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1542 I = InlineInfo.find(InlinedSP);
1544 if (I == InlineInfo.end()) {
1545 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1547 InlinedSPNodes.push_back(InlinedSP);
1549 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1551 DILocation DL(Scope->getInlinedAt());
1552 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1553 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1559 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1560 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1561 StringRef Name = DV->getName();
1565 // Translate tag to proper Dwarf tag. The result variable is dropped for
1568 switch (DV->getTag()) {
1569 case dwarf::DW_TAG_return_variable:
1571 case dwarf::DW_TAG_arg_variable:
1572 Tag = dwarf::DW_TAG_formal_parameter;
1574 case dwarf::DW_TAG_auto_variable: // fall thru
1576 Tag = dwarf::DW_TAG_variable;
1580 // Define variable debug information entry.
1581 DIE *VariableDie = new DIE(Tag);
1584 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1585 V2AVI = VarToAbstractVarMap.find(DV);
1586 if (V2AVI != VarToAbstractVarMap.end())
1587 AbsDIE = V2AVI->second->getDIE();
1590 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1591 dwarf::DW_FORM_ref4, AbsDIE);
1593 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1594 addSourceLine(VariableDie, DV->getVariable());
1596 // Add variable type.
1597 addType(VariableDie, DV->getType());
1600 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1601 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1603 if (Scope->isAbstractScope()) {
1604 DV->setDIE(VariableDie);
1608 // Add variable address.
1610 unsigned Offset = DV->getDotDebugLocOffset();
1611 if (Offset != ~0U) {
1612 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1613 Asm->GetTempSymbol("debug_loc", Offset));
1614 DV->setDIE(VariableDie);
1615 UseDotDebugLocEntry.insert(VariableDie);
1619 // Check if variable is described by a DBG_VALUE instruction.
1620 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1621 DbgVariableToDbgInstMap.find(DV);
1622 if (DVI != DbgVariableToDbgInstMap.end()) {
1623 const MachineInstr *DVInsn = DVI->second;
1624 const MCSymbol *DVLabel = findVariableLabel(DV);
1625 bool updated = false;
1626 // FIXME : Handle getNumOperands != 3
1627 if (DVInsn->getNumOperands() == 3) {
1628 if (DVInsn->getOperand(0).isReg())
1630 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1631 else if (DVInsn->getOperand(0).isImm())
1632 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1633 else if (DVInsn->getOperand(0).isFPImm())
1635 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1637 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1638 if (Location.getReg()) {
1639 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1641 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1647 // If variableDie is not updated then DBG_VALUE instruction does not
1648 // have valid variable info.
1652 DV->setDIE(VariableDie);
1656 // .. else use frame index, if available.
1657 MachineLocation Location;
1659 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1661 if (findVariableFrameIndex(DV, &FI)) {
1662 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1663 Location.set(FrameReg, Offset);
1664 addVariableAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1666 DV->setDIE(VariableDie);
1671 void DwarfDebug::addPubTypes(DISubprogram SP) {
1672 DICompositeType SPTy = SP.getType();
1673 unsigned SPTag = SPTy.getTag();
1674 if (SPTag != dwarf::DW_TAG_subroutine_type)
1677 DIArray Args = SPTy.getTypeArray();
1678 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1679 DIType ATy(Args.getElement(i));
1682 DICompositeType CATy = getDICompositeType(ATy);
1683 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1684 && !CATy.isForwardDecl()) {
1685 CompileUnit *TheCU = getCompileUnit(CATy);
1686 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1687 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1692 /// constructScopeDIE - Construct a DIE for this scope.
1693 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1694 if (!Scope || !Scope->getScopeNode())
1697 DIScope DS(Scope->getScopeNode());
1698 DIE *ScopeDIE = NULL;
1699 if (Scope->getInlinedAt())
1700 ScopeDIE = constructInlinedScopeDIE(Scope);
1701 else if (DS.isSubprogram()) {
1702 ProcessedSPNodes.insert(DS);
1703 if (Scope->isAbstractScope()) {
1704 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1705 // Note down abstract DIE.
1707 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1710 ScopeDIE = updateSubprogramScopeDIE(DS);
1713 ScopeDIE = constructLexicalScopeDIE(Scope);
1714 if (!ScopeDIE) return NULL;
1716 // Add variables to scope.
1717 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1718 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1719 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1721 ScopeDIE->addChild(VariableDIE);
1724 // Add nested scopes.
1725 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1726 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1727 // Define the Scope debug information entry.
1728 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1730 ScopeDIE->addChild(NestedDIE);
1733 if (DS.isSubprogram())
1734 addPubTypes(DISubprogram(DS));
1739 /// GetOrCreateSourceID - Look up the source id with the given directory and
1740 /// source file names. If none currently exists, create a new id and insert it
1741 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1743 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1745 assert (DirName.empty() == false && "Invalid directory name!");
1747 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1748 if (DI != DirectoryIdMap.end()) {
1749 DId = DI->getValue();
1751 DId = DirectoryNames.size() + 1;
1752 DirectoryIdMap[DirName] = DId;
1753 DirectoryNames.push_back(DirName);
1757 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1758 if (FI != SourceFileIdMap.end()) {
1759 FId = FI->getValue();
1761 FId = SourceFileNames.size() + 1;
1762 SourceFileIdMap[FileName] = FId;
1763 SourceFileNames.push_back(FileName);
1766 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1767 SourceIdMap.find(std::make_pair(DId, FId));
1768 if (SI != SourceIdMap.end())
1771 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1772 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1773 SourceIds.push_back(std::make_pair(DId, FId));
1778 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1779 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1780 CompileUnit *TheCU = getCompileUnit(NS);
1781 DIE *NDie = TheCU->getDIE(NS);
1784 NDie = new DIE(dwarf::DW_TAG_namespace);
1785 TheCU->insertDIE(NS, NDie);
1786 if (!NS.getName().empty())
1787 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1788 addSourceLine(NDie, NS);
1789 addToContextOwner(NDie, NS.getContext());
1793 /// constructCompileUnit - Create new CompileUnit for the given
1794 /// metadata node with tag DW_TAG_compile_unit.
1795 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1796 DICompileUnit DIUnit(N);
1797 StringRef FN = DIUnit.getFilename();
1798 StringRef Dir = DIUnit.getDirectory();
1799 unsigned ID = GetOrCreateSourceID(Dir, FN);
1801 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1802 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1803 DIUnit.getProducer());
1804 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1805 DIUnit.getLanguage());
1806 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1807 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1808 // simplifies debug range entries.
1809 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1810 // DW_AT_stmt_list is a offset of line number information for this
1811 // compile unit in debug_line section. This offset is calculated
1812 // during endMoudle().
1813 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1816 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1817 if (DIUnit.isOptimized())
1818 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1820 StringRef Flags = DIUnit.getFlags();
1822 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1824 unsigned RVer = DIUnit.getRunTimeVersion();
1826 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1827 dwarf::DW_FORM_data1, RVer);
1829 CompileUnit *NewCU = new CompileUnit(ID, Die);
1832 CUMap.insert(std::make_pair(N, NewCU));
1835 /// getCompielUnit - Get CompileUnit DIE.
1836 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1837 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1839 const MDNode *CUNode = NULL;
1840 if (D.isCompileUnit())
1842 else if (D.isSubprogram())
1843 CUNode = DISubprogram(N).getCompileUnit();
1844 else if (D.isType())
1845 CUNode = DIType(N).getCompileUnit();
1846 else if (D.isGlobalVariable())
1847 CUNode = DIGlobalVariable(N).getCompileUnit();
1848 else if (D.isVariable())
1849 CUNode = DIVariable(N).getCompileUnit();
1850 else if (D.isNameSpace())
1851 CUNode = DINameSpace(N).getCompileUnit();
1852 else if (D.isFile())
1853 CUNode = DIFile(N).getCompileUnit();
1857 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1858 = CUMap.find(CUNode);
1859 if (I == CUMap.end())
1865 /// constructGlobalVariableDIE - Construct global variable DIE.
1866 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1867 DIGlobalVariable GV(N);
1869 // If debug information is malformed then ignore it.
1870 if (GV.Verify() == false)
1873 // Check for pre-existence.
1874 CompileUnit *TheCU = getCompileUnit(N);
1875 if (TheCU->getDIE(GV))
1878 DIType GTy = GV.getType();
1879 DIE *VariableDIE = new DIE(dwarf::DW_TAG_variable);
1882 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1883 GV.getDisplayName());
1884 StringRef LinkageName = GV.getLinkageName();
1885 if (!LinkageName.empty())
1886 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1887 getRealLinkageName(LinkageName));
1889 addType(VariableDIE, GTy);
1890 if (GTy.isCompositeType() && !GTy.getName().empty()
1891 && !GTy.isForwardDecl()) {
1892 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1893 assert(Entry && "Missing global type!");
1894 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1896 // Add scoping info.
1897 if (!GV.isLocalToUnit()) {
1898 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1899 // Expose as global.
1900 TheCU->addGlobal(GV.getName(), VariableDIE);
1902 // Add line number info.
1903 addSourceLine(VariableDIE, GV);
1905 TheCU->insertDIE(N, VariableDIE);
1906 // Add to context owner.
1907 DIDescriptor GVContext = GV.getContext();
1908 addToContextOwner(VariableDIE, GVContext);
1910 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1911 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1912 addLabel(Block, 0, dwarf::DW_FORM_udata,
1913 Asm->Mang->getSymbol(GV.getGlobal()));
1914 // Do not create specification DIE if context is either compile unit
1916 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1917 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1918 // Create specification DIE.
1919 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1920 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1921 dwarf::DW_FORM_ref4, VariableDIE);
1922 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1923 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1924 TheCU->addDie(VariableSpecDIE);
1926 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1932 /// construct SubprogramDIE - Construct subprogram DIE.
1933 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1936 // Check for pre-existence.
1937 CompileUnit *TheCU = getCompileUnit(N);
1938 if (TheCU->getDIE(N))
1941 if (!SP.isDefinition())
1942 // This is a method declaration which will be handled while constructing
1946 DIE *SubprogramDie = createSubprogramDIE(SP);
1949 TheCU->insertDIE(N, SubprogramDie);
1951 // Add to context owner.
1952 addToContextOwner(SubprogramDie, SP.getContext());
1954 // Expose as global.
1955 TheCU->addGlobal(SP.getName(), SubprogramDie);
1960 /// beginModule - Emit all Dwarf sections that should come prior to the
1961 /// content. Create global DIEs and emit initial debug info sections.
1962 /// This is inovked by the target AsmPrinter.
1963 void DwarfDebug::beginModule(Module *M) {
1964 if (DisableDebugInfoPrinting)
1967 DebugInfoFinder DbgFinder;
1968 DbgFinder.processModule(*M);
1970 bool HasDebugInfo = false;
1972 // Scan all the compile-units to see if there are any marked as the main unit.
1973 // if not, we do not generate debug info.
1974 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1975 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1976 if (DICompileUnit(*I).isMain()) {
1977 HasDebugInfo = true;
1982 if (!HasDebugInfo) return;
1984 // Tell MMI that we have debug info.
1985 MMI->setDebugInfoAvailability(true);
1987 // Emit initial sections.
1988 EmitSectionLabels();
1990 // Create all the compile unit DIEs.
1991 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1992 E = DbgFinder.compile_unit_end(); I != E; ++I)
1993 constructCompileUnit(*I);
1995 // Create DIEs for each subprogram.
1996 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
1997 E = DbgFinder.subprogram_end(); I != E; ++I)
1998 constructSubprogramDIE(*I);
2000 // Create DIEs for each global variable.
2001 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2002 E = DbgFinder.global_variable_end(); I != E; ++I)
2003 constructGlobalVariableDIE(*I);
2005 // Prime section data.
2006 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2008 // Print out .file directives to specify files for .loc directives. These are
2009 // printed out early so that they precede any .loc directives.
2010 if (Asm->MAI->hasDotLocAndDotFile()) {
2011 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2012 // Remember source id starts at 1.
2013 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2014 // FIXME: don't use sys::path for this! This should not depend on the
2016 sys::Path FullPath(getSourceDirectoryName(Id.first));
2018 FullPath.appendComponent(getSourceFileName(Id.second));
2019 assert(AppendOk && "Could not append filename to directory!");
2021 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2026 /// endModule - Emit all Dwarf sections that should come after the content.
2028 void DwarfDebug::endModule() {
2029 if (!FirstCU) return;
2030 const Module *M = MMI->getModule();
2031 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2032 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2033 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2034 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2035 DISubprogram SP(AllSPs->getOperand(SI));
2036 if (!SP.Verify()) continue;
2038 // Collect info for variables that were optimized out.
2039 if (!SP.isDefinition()) continue;
2040 StringRef FName = SP.getLinkageName();
2042 FName = SP.getName();
2044 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2046 unsigned E = NMD->getNumOperands();
2048 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2049 DeadFnScopeMap[SP] = Scope;
2050 for (unsigned I = 0; I != E; ++I) {
2051 DIVariable DV(NMD->getOperand(I));
2052 if (!DV.Verify()) continue;
2053 Scope->addVariable(new DbgVariable(DV));
2056 // Construct subprogram DIE and add variables DIEs.
2057 constructSubprogramDIE(SP);
2058 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2059 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2060 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2061 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2063 ScopeDIE->addChild(VariableDIE);
2068 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2069 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2070 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2072 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2075 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2076 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2077 DIE *SPDie = CI->first;
2078 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2080 DIE *NDie = getCompileUnit(N)->getDIE(N);
2081 if (!NDie) continue;
2082 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2085 // Standard sections final addresses.
2086 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2087 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2088 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2089 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2091 // End text sections.
2092 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2093 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2094 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2097 // Emit common frame information.
2098 emitCommonDebugFrame();
2100 // Emit function debug frame information
2101 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2102 E = DebugFrames.end(); I != E; ++I)
2103 emitFunctionDebugFrame(*I);
2105 // Compute DIE offsets and sizes.
2106 computeSizeAndOffsets();
2108 // Emit source line correspondence into a debug line section.
2111 // Emit all the DIEs into a debug info section
2114 // Corresponding abbreviations into a abbrev section.
2115 emitAbbreviations();
2117 // Emit info into a debug pubnames section.
2118 emitDebugPubNames();
2120 // Emit info into a debug pubtypes section.
2121 emitDebugPubTypes();
2123 // Emit info into a debug loc section.
2126 // Emit info into a debug aranges section.
2129 // Emit info into a debug ranges section.
2132 // Emit info into a debug macinfo section.
2135 // Emit inline info.
2136 emitDebugInlineInfo();
2138 // Emit info into a debug str section.
2142 DeleteContainerSeconds(DeadFnScopeMap);
2143 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2144 E = CUMap.end(); I != E; ++I)
2146 FirstCU = NULL; // Reset for the next Module, if any.
2149 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2150 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2151 DebugLoc ScopeLoc) {
2153 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2155 return AbsDbgVariable;
2157 LLVMContext &Ctx = Var->getContext();
2158 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2162 AbsDbgVariable = new DbgVariable(Var);
2163 Scope->addVariable(AbsDbgVariable);
2164 AbstractVariables[Var] = AbsDbgVariable;
2165 return AbsDbgVariable;
2168 /// collectVariableInfoFromMMITable - Collect variable information from
2169 /// side table maintained by MMI.
2171 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2172 SmallPtrSet<const MDNode *, 16> &Processed) {
2173 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2174 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2175 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2176 VE = VMap.end(); VI != VE; ++VI) {
2177 const MDNode *Var = VI->first;
2179 Processed.insert(Var);
2181 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2183 DbgScope *Scope = 0;
2184 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2185 Scope = ConcreteScopes.lookup(IA);
2187 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2189 // If variable scope is not found then skip this variable.
2193 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2194 DbgVariable *RegVar = new DbgVariable(DV);
2195 recordVariableFrameIndex(RegVar, VP.first);
2196 Scope->addVariable(RegVar);
2197 if (AbsDbgVariable) {
2198 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2199 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2204 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2205 /// DBG_VALUE instruction, is in undefined reg.
2206 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2207 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2208 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2213 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2214 /// DBG_VALUE instruction, is in a defined reg.
2215 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2216 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2217 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2222 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2224 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2225 SmallPtrSet<const MDNode *, 16> &Processed) {
2227 /// collection info from MMI table.
2228 collectVariableInfoFromMMITable(MF, Processed);
2230 SmallVector<const MachineInstr *, 8> DbgValues;
2231 // Collect variable information from DBG_VALUE machine instructions;
2232 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2234 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2236 const MachineInstr *MInsn = II;
2237 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2239 DbgValues.push_back(MInsn);
2242 // This is a collection of DBV_VALUE instructions describing same variable.
2243 SmallVector<const MachineInstr *, 4> MultipleValues;
2244 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2245 E = DbgValues.end(); I != E; ++I) {
2246 const MachineInstr *MInsn = *I;
2247 MultipleValues.clear();
2248 if (isDbgValueInDefinedReg(MInsn))
2249 MultipleValues.push_back(MInsn);
2250 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2251 if (Processed.count(DV) != 0)
2254 const MachineInstr *PrevMI = MInsn;
2255 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2256 ME = DbgValues.end(); MI != ME; ++MI) {
2258 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2259 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2260 !PrevMI->isIdenticalTo(*MI))
2261 MultipleValues.push_back(*MI);
2265 DbgScope *Scope = findDbgScope(MInsn);
2266 bool CurFnArg = false;
2267 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2268 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2270 if (!Scope && CurFnArg)
2271 Scope = CurrentFnDbgScope;
2272 // If variable scope is not found then skip this variable.
2276 Processed.insert(DV);
2277 DbgVariable *RegVar = new DbgVariable(DV);
2278 Scope->addVariable(RegVar);
2280 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2281 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2282 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2283 VarToAbstractVarMap[RegVar] = AbsVar;
2285 if (MultipleValues.size() <= 1) {
2286 DbgVariableToDbgInstMap[RegVar] = MInsn;
2290 // handle multiple DBG_VALUE instructions describing one variable.
2291 if (DotDebugLocEntries.empty())
2292 RegVar->setDotDebugLocOffset(0);
2294 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2295 const MachineInstr *Begin = NULL;
2296 const MachineInstr *End = NULL;
2297 for (SmallVector<const MachineInstr *, 4>::iterator
2298 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2299 MVI != MVE; ++MVI) {
2305 MachineLocation MLoc;
2306 if (Begin->getNumOperands() == 3) {
2307 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2308 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2310 MLoc = Asm->getDebugValueLocation(Begin);
2312 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2313 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2315 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2318 if (MVI + 1 == MVE) {
2319 // If End is the last instruction then its value is valid
2320 // until the end of the funtion.
2321 MachineLocation EMLoc;
2322 if (End->getNumOperands() == 3) {
2323 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2324 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2326 EMLoc = Asm->getDebugValueLocation(End);
2329 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2332 DotDebugLocEntries.push_back(DotDebugLocEntry());
2335 // Collect info for variables that were optimized out.
2336 const Function *F = MF->getFunction();
2337 const Module *M = F->getParent();
2338 if (NamedMDNode *NMD =
2339 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2340 getRealLinkageName(F->getName())))) {
2341 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2342 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2343 if (!DV || !Processed.insert(DV))
2345 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2347 Scope->addVariable(new DbgVariable(DV));
2352 /// getLabelBeforeInsn - Return Label preceding the instruction.
2353 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2354 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2355 LabelsBeforeInsn.find(MI);
2356 if (I == LabelsBeforeInsn.end())
2357 // FunctionBeginSym always preceeds all the instruction in current function.
2358 return FunctionBeginSym;
2362 /// getLabelAfterInsn - Return Label immediately following the instruction.
2363 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2364 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2365 LabelsAfterInsn.find(MI);
2366 if (I == LabelsAfterInsn.end())
2371 /// beginScope - Process beginning of a scope.
2372 void DwarfDebug::beginScope(const MachineInstr *MI) {
2373 if (InsnNeedsLabel.count(MI) == 0) {
2374 LabelsBeforeInsn[MI] = PrevLabel;
2379 DebugLoc DL = MI->getDebugLoc();
2380 if (!DL.isUnknown()) {
2381 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2382 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2384 LabelsBeforeInsn[MI] = PrevLabel;
2388 // If location is unknown then use temp label for this DBG_VALUE
2390 if (MI->isDebugValue()) {
2391 PrevLabel = MMI->getContext().CreateTempSymbol();
2392 Asm->OutStreamer.EmitLabel(PrevLabel);
2393 LabelsBeforeInsn[MI] = PrevLabel;
2397 if (UnknownLocations) {
2398 PrevLabel = recordSourceLine(0, 0, 0);
2399 LabelsBeforeInsn[MI] = PrevLabel;
2403 assert (0 && "Instruction is not processed!");
2406 /// endScope - Process end of a scope.
2407 void DwarfDebug::endScope(const MachineInstr *MI) {
2408 if (InsnsEndScopeSet.count(MI) != 0) {
2409 // Emit a label if this instruction ends a scope.
2410 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2411 Asm->OutStreamer.EmitLabel(Label);
2412 LabelsAfterInsn[MI] = Label;
2416 /// getOrCreateDbgScope - Create DbgScope for the scope.
2417 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2418 const MDNode *InlinedAt) {
2420 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2423 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2424 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2425 if (DIDescriptor(Scope).isLexicalBlock()) {
2427 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2428 WScope->setParent(Parent);
2429 Parent->addScope(WScope);
2432 if (!WScope->getParent()) {
2433 StringRef SPName = DISubprogram(Scope).getLinkageName();
2434 // We used to check only for a linkage name, but that fails
2435 // since we began omitting the linkage name for private
2436 // functions. The new way is to check for the name in metadata,
2437 // but that's not supported in old .ll test cases. Ergo, we
2439 if (SPName == Asm->MF->getFunction()->getName() ||
2440 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2441 CurrentFnDbgScope = WScope;
2447 getOrCreateAbstractScope(Scope);
2448 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2452 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2453 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2454 DILocation DL(InlinedAt);
2456 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2457 WScope->setParent(Parent);
2458 Parent->addScope(WScope);
2460 ConcreteScopes[InlinedAt] = WScope;
2465 /// hasValidLocation - Return true if debug location entry attached with
2466 /// machine instruction encodes valid location info.
2467 static bool hasValidLocation(LLVMContext &Ctx,
2468 const MachineInstr *MInsn,
2469 const MDNode *&Scope, const MDNode *&InlinedAt) {
2470 DebugLoc DL = MInsn->getDebugLoc();
2471 if (DL.isUnknown()) return false;
2473 const MDNode *S = DL.getScope(Ctx);
2475 // There is no need to create another DIE for compile unit. For all
2476 // other scopes, create one DbgScope now. This will be translated
2477 // into a scope DIE at the end.
2478 if (DIScope(S).isCompileUnit()) return false;
2481 InlinedAt = DL.getInlinedAt(Ctx);
2485 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2487 static void calculateDominanceGraph(DbgScope *Scope) {
2488 assert (Scope && "Unable to calculate scop edominance graph!");
2489 SmallVector<DbgScope *, 4> WorkStack;
2490 WorkStack.push_back(Scope);
2491 unsigned Counter = 0;
2492 while (!WorkStack.empty()) {
2493 DbgScope *WS = WorkStack.back();
2494 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2495 bool visitedChildren = false;
2496 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2497 SE = Children.end(); SI != SE; ++SI) {
2498 DbgScope *ChildScope = *SI;
2499 if (!ChildScope->getDFSOut()) {
2500 WorkStack.push_back(ChildScope);
2501 visitedChildren = true;
2502 ChildScope->setDFSIn(++Counter);
2506 if (!visitedChildren) {
2507 WorkStack.pop_back();
2508 WS->setDFSOut(++Counter);
2513 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2515 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2516 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2519 unsigned PrevDFSIn = 0;
2520 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2522 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2524 const MachineInstr *MInsn = II;
2525 const MDNode *Scope = NULL;
2526 const MDNode *InlinedAt = NULL;
2528 // Check if instruction has valid location information.
2529 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2533 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2534 MI2ScopeMap.find(MInsn);
2535 if (DI != MI2ScopeMap.end()) {
2536 DbgScope *S = DI->second;
2537 dbgs() << S->getDFSIn();
2538 PrevDFSIn = S->getDFSIn();
2540 dbgs() << PrevDFSIn;
2542 dbgs() << " [ x" << PrevDFSIn;
2550 /// extractScopeInformation - Scan machine instructions in this function
2551 /// and collect DbgScopes. Return true, if at least one scope was found.
2552 bool DwarfDebug::extractScopeInformation() {
2553 // If scope information was extracted using .dbg intrinsics then there is not
2554 // any need to extract these information by scanning each instruction.
2555 if (!DbgScopeMap.empty())
2558 // Scan each instruction and create scopes. First build working set of scopes.
2559 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2560 SmallVector<DbgRange, 4> MIRanges;
2561 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2562 const MDNode *PrevScope = NULL;
2563 const MDNode *PrevInlinedAt = NULL;
2564 const MachineInstr *RangeBeginMI = NULL;
2565 const MachineInstr *PrevMI = NULL;
2566 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2568 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2570 const MachineInstr *MInsn = II;
2571 const MDNode *Scope = NULL;
2572 const MDNode *InlinedAt = NULL;
2574 // Check if instruction has valid location information.
2575 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2580 // If scope has not changed then skip this instruction.
2581 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2587 // If we have alread seen a beginning of a instruction range and
2588 // current instruction scope does not match scope of first instruction
2589 // in this range then create a new instruction range.
2590 DbgRange R(RangeBeginMI, PrevMI);
2591 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2593 MIRanges.push_back(R);
2596 // This is a beginning of a new instruction range.
2597 RangeBeginMI = MInsn;
2599 // Reset previous markers.
2602 PrevInlinedAt = InlinedAt;
2606 // Create last instruction range.
2607 if (RangeBeginMI && PrevMI && PrevScope) {
2608 DbgRange R(RangeBeginMI, PrevMI);
2609 MIRanges.push_back(R);
2610 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2613 if (!CurrentFnDbgScope)
2616 calculateDominanceGraph(CurrentFnDbgScope);
2618 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2620 // Find ranges of instructions covered by each DbgScope;
2621 DbgScope *PrevDbgScope = NULL;
2622 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2623 RE = MIRanges.end(); RI != RE; ++RI) {
2624 const DbgRange &R = *RI;
2625 DbgScope *S = MI2ScopeMap.lookup(R.first);
2626 assert (S && "Lost DbgScope for a machine instruction!");
2627 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2628 PrevDbgScope->closeInsnRange(S);
2629 S->openInsnRange(R.first);
2630 S->extendInsnRange(R.second);
2635 PrevDbgScope->closeInsnRange();
2637 identifyScopeMarkers();
2639 return !DbgScopeMap.empty();
2642 /// identifyScopeMarkers() -
2643 /// Each DbgScope has first instruction and last instruction to mark beginning
2644 /// and end of a scope respectively. Create an inverse map that list scopes
2645 /// starts (and ends) with an instruction. One instruction may start (or end)
2646 /// multiple scopes. Ignore scopes that are not reachable.
2647 void DwarfDebug::identifyScopeMarkers() {
2648 SmallVector<DbgScope *, 4> WorkList;
2649 WorkList.push_back(CurrentFnDbgScope);
2650 while (!WorkList.empty()) {
2651 DbgScope *S = WorkList.pop_back_val();
2653 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2654 if (!Children.empty())
2655 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2656 SE = Children.end(); SI != SE; ++SI)
2657 WorkList.push_back(*SI);
2659 if (S->isAbstractScope())
2662 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2665 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2666 RE = Ranges.end(); RI != RE; ++RI) {
2667 assert(RI->first && "DbgRange does not have first instruction!");
2668 assert(RI->second && "DbgRange does not have second instruction!");
2669 InsnsEndScopeSet.insert(RI->second);
2674 /// FindFirstDebugLoc - Find the first debug location in the function. This
2675 /// is intended to be an approximation for the source position of the
2676 /// beginning of the function.
2677 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2678 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2680 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2681 MBBI != MBBE; ++MBBI) {
2682 DebugLoc DL = MBBI->getDebugLoc();
2683 if (!DL.isUnknown())
2689 /// beginFunction - Gather pre-function debug information. Assumes being
2690 /// emitted immediately after the function entry point.
2691 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2692 if (!MMI->hasDebugInfo()) return;
2693 if (!extractScopeInformation()) return;
2695 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2696 Asm->getFunctionNumber());
2697 // Assumes in correct section after the entry point.
2698 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2700 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2702 DebugLoc FDL = FindFirstDebugLoc(MF);
2703 if (FDL.isUnknown()) return;
2705 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2706 const MDNode *TheScope = 0;
2708 DISubprogram SP = getDISubprogram(Scope);
2711 Line = SP.getLineNumber();
2715 Line = FDL.getLine();
2720 recordSourceLine(Line, Col, TheScope);
2722 /// ProcessedArgs - Collection of arguments already processed.
2723 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2726 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2728 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2730 const MachineInstr *MI = II;
2731 DebugLoc DL = MI->getDebugLoc();
2732 if (MI->isDebugValue()) {
2733 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2734 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2735 if (!DV.Verify()) continue;
2736 // If DBG_VALUE is for a local variable then it needs a label.
2737 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2738 && isDbgValueInUndefinedReg(MI) == false)
2739 InsnNeedsLabel.insert(MI);
2740 // DBG_VALUE for inlined functions argument needs a label.
2741 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2742 describes(MF->getFunction()))
2743 InsnNeedsLabel.insert(MI);
2744 // DBG_VALUE indicating argument location change needs a label.
2745 else if (isDbgValueInUndefinedReg(MI) == false
2746 && !ProcessedArgs.insert(DV))
2747 InsnNeedsLabel.insert(MI);
2749 // If location is unknown then instruction needs a location only if
2750 // UnknownLocations flag is set.
2751 if (DL.isUnknown()) {
2752 if (UnknownLocations && !PrevLoc.isUnknown())
2753 InsnNeedsLabel.insert(MI);
2754 } else if (DL != PrevLoc)
2755 // Otherwise, instruction needs a location only if it is new location.
2756 InsnNeedsLabel.insert(MI);
2759 if (!DL.isUnknown() || UnknownLocations)
2763 PrevLabel = FunctionBeginSym;
2766 /// endFunction - Gather and emit post-function debug information.
2768 void DwarfDebug::endFunction(const MachineFunction *MF) {
2769 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2771 if (CurrentFnDbgScope) {
2773 // Define end label for subprogram.
2774 FunctionEndSym = Asm->GetTempSymbol("func_end",
2775 Asm->getFunctionNumber());
2776 // Assumes in correct section after the entry point.
2777 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2779 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2780 collectVariableInfo(MF, ProcessedVars);
2782 // Get function line info.
2783 if (!Lines.empty()) {
2784 // Get section line info.
2785 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2786 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2787 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2788 // Append the function info to section info.
2789 SectionLineInfos.insert(SectionLineInfos.end(),
2790 Lines.begin(), Lines.end());
2793 // Construct abstract scopes.
2794 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2795 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2796 DISubprogram SP((*AI)->getScopeNode());
2798 // Collect info for variables that were optimized out.
2799 StringRef FName = SP.getLinkageName();
2801 FName = SP.getName();
2802 const Module *M = MF->getFunction()->getParent();
2803 if (NamedMDNode *NMD =
2804 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2805 getRealLinkageName(FName)))) {
2806 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2807 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2808 if (!DV || !ProcessedVars.insert(DV))
2810 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2812 Scope->addVariable(new DbgVariable(DV));
2816 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2817 constructScopeDIE(*AI);
2820 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2822 if (!DisableFramePointerElim(*MF))
2823 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2824 dwarf::DW_FORM_flag, 1);
2827 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2828 MMI->getFrameMoves()));
2832 CurrentFnDbgScope = NULL;
2833 InsnNeedsLabel.clear();
2834 DbgVariableToFrameIndexMap.clear();
2835 VarToAbstractVarMap.clear();
2836 DbgVariableToDbgInstMap.clear();
2837 DbgVariableLabelsMap.clear();
2838 DeleteContainerSeconds(DbgScopeMap);
2839 InsnsEndScopeSet.clear();
2840 ConcreteScopes.clear();
2841 DeleteContainerSeconds(AbstractScopes);
2842 AbstractScopesList.clear();
2843 AbstractVariables.clear();
2844 LabelsBeforeInsn.clear();
2845 LabelsAfterInsn.clear();
2850 /// recordVariableFrameIndex - Record a variable's index.
2851 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2852 assert (V && "Invalid DbgVariable!");
2853 DbgVariableToFrameIndexMap[V] = Index;
2856 /// findVariableFrameIndex - Return true if frame index for the variable
2857 /// is found. Update FI to hold value of the index.
2858 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2859 assert (V && "Invalid DbgVariable!");
2860 DenseMap<const DbgVariable *, int>::iterator I =
2861 DbgVariableToFrameIndexMap.find(V);
2862 if (I == DbgVariableToFrameIndexMap.end())
2868 /// findVariableLabel - Find MCSymbol for the variable.
2869 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2870 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2871 = DbgVariableLabelsMap.find(V);
2872 if (I == DbgVariableLabelsMap.end())
2874 else return I->second;
2877 /// findDbgScope - Find DbgScope for the debug loc attached with an
2879 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2880 DbgScope *Scope = NULL;
2882 MInsn->getParent()->getParent()->getFunction()->getContext();
2883 DebugLoc DL = MInsn->getDebugLoc();
2888 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2889 Scope = ConcreteScopes.lookup(IA);
2891 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2897 /// recordSourceLine - Register a source line with debug info. Returns the
2898 /// unique label that was emitted and which provides correspondence to
2899 /// the source line list.
2900 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2907 DIDescriptor Scope(S);
2909 if (Scope.isCompileUnit()) {
2910 DICompileUnit CU(S);
2911 Dir = CU.getDirectory();
2912 Fn = CU.getFilename();
2913 } else if (Scope.isSubprogram()) {
2915 Dir = SP.getDirectory();
2916 Fn = SP.getFilename();
2917 } else if (Scope.isLexicalBlock()) {
2918 DILexicalBlock DB(S);
2919 Dir = DB.getDirectory();
2920 Fn = DB.getFilename();
2922 assert(0 && "Unexpected scope info");
2924 Src = GetOrCreateSourceID(Dir, Fn);
2927 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2928 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2930 Asm->OutStreamer.EmitLabel(Label);
2934 //===----------------------------------------------------------------------===//
2936 //===----------------------------------------------------------------------===//
2938 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2941 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2942 // Get the children.
2943 const std::vector<DIE *> &Children = Die->getChildren();
2945 // If not last sibling and has children then add sibling offset attribute.
2946 if (!Last && !Children.empty())
2947 Die->addSiblingOffset(DIEValueAllocator);
2949 // Record the abbreviation.
2950 assignAbbrevNumber(Die->getAbbrev());
2952 // Get the abbreviation for this DIE.
2953 unsigned AbbrevNumber = Die->getAbbrevNumber();
2954 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2957 Die->setOffset(Offset);
2959 // Start the size with the size of abbreviation code.
2960 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2962 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2963 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2965 // Size the DIE attribute values.
2966 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2967 // Size attribute value.
2968 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2970 // Size the DIE children if any.
2971 if (!Children.empty()) {
2972 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2973 "Children flag not set");
2975 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2976 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2978 // End of children marker.
2979 Offset += sizeof(int8_t);
2982 Die->setSize(Offset - Die->getOffset());
2986 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
2988 void DwarfDebug::computeSizeAndOffsets() {
2989 unsigned PrevOffset = 0;
2990 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2991 E = CUMap.end(); I != E; ++I) {
2992 // Compute size of compile unit header.
2993 static unsigned Offset = PrevOffset +
2994 sizeof(int32_t) + // Length of Compilation Unit Info
2995 sizeof(int16_t) + // DWARF version number
2996 sizeof(int32_t) + // Offset Into Abbrev. Section
2997 sizeof(int8_t); // Pointer Size (in bytes)
2998 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
2999 PrevOffset = Offset;
3003 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3004 /// temporary label to it if SymbolStem is specified.
3005 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3006 const char *SymbolStem = 0) {
3007 Asm->OutStreamer.SwitchSection(Section);
3008 if (!SymbolStem) return 0;
3010 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3011 Asm->OutStreamer.EmitLabel(TmpSym);
3015 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3016 /// the start of each one.
3017 void DwarfDebug::EmitSectionLabels() {
3018 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3020 // Dwarf sections base addresses.
3021 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3022 DwarfFrameSectionSym =
3023 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3026 DwarfInfoSectionSym =
3027 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3028 DwarfAbbrevSectionSym =
3029 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3030 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3032 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3033 EmitSectionSym(Asm, MacroInfo);
3035 DwarfDebugLineSectionSym =
3036 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3037 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3038 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3039 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3040 DwarfStrSectionSym =
3041 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3042 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3045 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3046 "section_debug_loc");
3048 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3049 EmitSectionSym(Asm, TLOF.getDataSection());
3052 /// emitDIE - Recusively Emits a debug information entry.
3054 void DwarfDebug::emitDIE(DIE *Die) {
3055 // Get the abbreviation for this DIE.
3056 unsigned AbbrevNumber = Die->getAbbrevNumber();
3057 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3059 // Emit the code (index) for the abbreviation.
3060 if (Asm->isVerbose())
3061 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3062 Twine::utohexstr(Die->getOffset()) + ":0x" +
3063 Twine::utohexstr(Die->getSize()) + " " +
3064 dwarf::TagString(Abbrev->getTag()));
3065 Asm->EmitULEB128(AbbrevNumber);
3067 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3068 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3070 // Emit the DIE attribute values.
3071 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3072 unsigned Attr = AbbrevData[i].getAttribute();
3073 unsigned Form = AbbrevData[i].getForm();
3074 assert(Form && "Too many attributes for DIE (check abbreviation)");
3076 if (Asm->isVerbose())
3077 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3080 case dwarf::DW_AT_sibling:
3081 Asm->EmitInt32(Die->getSiblingOffset());
3083 case dwarf::DW_AT_abstract_origin: {
3084 DIEEntry *E = cast<DIEEntry>(Values[i]);
3085 DIE *Origin = E->getEntry();
3086 unsigned Addr = Origin->getOffset();
3087 Asm->EmitInt32(Addr);
3090 case dwarf::DW_AT_ranges: {
3091 // DW_AT_range Value encodes offset in debug_range section.
3092 DIEInteger *V = cast<DIEInteger>(Values[i]);
3093 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3095 DwarfDebugRangeSectionSym,
3099 case dwarf::DW_AT_stmt_list: {
3100 Asm->EmitLabelDifference(CurrentLineSectionSym,
3101 DwarfDebugLineSectionSym, 4);
3104 case dwarf::DW_AT_location: {
3105 if (UseDotDebugLocEntry.count(Die) != 0) {
3106 DIELabel *L = cast<DIELabel>(Values[i]);
3107 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3109 Values[i]->EmitValue(Asm, Form);
3113 // Emit an attribute using the defined form.
3114 Values[i]->EmitValue(Asm, Form);
3119 // Emit the DIE children if any.
3120 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3121 const std::vector<DIE *> &Children = Die->getChildren();
3123 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3124 emitDIE(Children[j]);
3126 if (Asm->isVerbose())
3127 Asm->OutStreamer.AddComment("End Of Children Mark");
3132 /// emitDebugInfo - Emit the debug info section.
3134 void DwarfDebug::emitDebugInfo() {
3135 // Start debug info section.
3136 Asm->OutStreamer.SwitchSection(
3137 Asm->getObjFileLowering().getDwarfInfoSection());
3138 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3139 E = CUMap.end(); I != E; ++I) {
3140 CompileUnit *TheCU = I->second;
3141 DIE *Die = TheCU->getCUDie();
3143 // Emit the compile units header.
3144 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3147 // Emit size of content not including length itself
3148 unsigned ContentSize = Die->getSize() +
3149 sizeof(int16_t) + // DWARF version number
3150 sizeof(int32_t) + // Offset Into Abbrev. Section
3151 sizeof(int8_t) + // Pointer Size (in bytes)
3152 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3154 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3155 Asm->EmitInt32(ContentSize);
3156 Asm->OutStreamer.AddComment("DWARF version number");
3157 Asm->EmitInt16(dwarf::DWARF_VERSION);
3158 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3159 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3160 DwarfAbbrevSectionSym);
3161 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3162 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3165 // FIXME - extra padding for gdb bug.
3166 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3171 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3175 /// emitAbbreviations - Emit the abbreviation section.
3177 void DwarfDebug::emitAbbreviations() const {
3178 // Check to see if it is worth the effort.
3179 if (!Abbreviations.empty()) {
3180 // Start the debug abbrev section.
3181 Asm->OutStreamer.SwitchSection(
3182 Asm->getObjFileLowering().getDwarfAbbrevSection());
3184 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3186 // For each abbrevation.
3187 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3188 // Get abbreviation data
3189 const DIEAbbrev *Abbrev = Abbreviations[i];
3191 // Emit the abbrevations code (base 1 index.)
3192 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3194 // Emit the abbreviations data.
3198 // Mark end of abbreviations.
3199 Asm->EmitULEB128(0, "EOM(3)");
3201 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3205 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3206 /// the line matrix.
3208 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3209 // Define last address of section.
3210 Asm->OutStreamer.AddComment("Extended Op");
3213 Asm->OutStreamer.AddComment("Op size");
3214 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3215 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3216 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3218 Asm->OutStreamer.AddComment("Section end label");
3220 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3221 Asm->getTargetData().getPointerSize(),
3224 // Mark end of matrix.
3225 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3231 /// emitDebugLines - Emit source line information.
3233 void DwarfDebug::emitDebugLines() {
3234 // If the target is using .loc/.file, the assembler will be emitting the
3235 // .debug_line table automatically.
3236 if (Asm->MAI->hasDotLocAndDotFile())
3239 // Minimum line delta, thus ranging from -10..(255-10).
3240 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3241 // Maximum line delta, thus ranging from -10..(255-10).
3242 const int MaxLineDelta = 255 + MinLineDelta;
3244 // Start the dwarf line section.
3245 Asm->OutStreamer.SwitchSection(
3246 Asm->getObjFileLowering().getDwarfLineSection());
3248 // Construct the section header.
3249 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3250 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3251 Asm->OutStreamer.AddComment("Length of Source Line Info");
3252 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3253 Asm->GetTempSymbol("line_begin"), 4);
3254 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3256 Asm->OutStreamer.AddComment("DWARF version number");
3257 Asm->EmitInt16(dwarf::DWARF_VERSION);
3259 Asm->OutStreamer.AddComment("Prolog Length");
3260 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3261 Asm->GetTempSymbol("line_prolog_begin"), 4);
3262 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3264 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3266 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3268 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3269 Asm->EmitInt8(MinLineDelta);
3270 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3271 Asm->EmitInt8(MaxLineDelta);
3272 Asm->OutStreamer.AddComment("Special Opcode Base");
3273 Asm->EmitInt8(-MinLineDelta);
3275 // Line number standard opcode encodings argument count
3276 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3278 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3280 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3282 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3284 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3286 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3288 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3290 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3292 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3295 // Emit directories.
3296 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3297 const std::string &Dir = getSourceDirectoryName(DI);
3298 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3299 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3302 Asm->OutStreamer.AddComment("End of directories");
3306 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3307 // Remember source id starts at 1.
3308 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3309 const std::string &FN = getSourceFileName(Id.second);
3310 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3311 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3313 Asm->EmitULEB128(Id.first, "Directory #");
3314 Asm->EmitULEB128(0, "Mod date");
3315 Asm->EmitULEB128(0, "File size");
3318 Asm->OutStreamer.AddComment("End of files");
3321 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3323 // A sequence for each text section.
3324 unsigned SecSrcLinesSize = SectionSourceLines.size();
3326 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3327 // Isolate current sections line info.
3328 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3330 // Dwarf assumes we start with first line of first source file.
3331 unsigned Source = 1;
3334 // Construct rows of the address, source, line, column matrix.
3335 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3336 const SrcLineInfo &LineInfo = LineInfos[i];
3337 MCSymbol *Label = LineInfo.getLabel();
3338 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3340 if (Asm->isVerbose()) {
3341 std::pair<unsigned, unsigned> SrcID =
3342 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3343 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3345 Twine(getSourceFileName(SrcID.second)) +
3346 ":" + Twine(LineInfo.getLine()));
3349 // Define the line address.
3350 Asm->OutStreamer.AddComment("Extended Op");
3352 Asm->OutStreamer.AddComment("Op size");
3353 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3355 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3356 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3358 Asm->OutStreamer.AddComment("Location label");
3359 Asm->OutStreamer.EmitSymbolValue(Label,
3360 Asm->getTargetData().getPointerSize(),
3363 // If change of source, then switch to the new source.
3364 if (Source != LineInfo.getSourceID()) {
3365 Source = LineInfo.getSourceID();
3366 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3367 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3368 Asm->EmitULEB128(Source, "New Source");
3371 // If change of line.
3372 if (Line != LineInfo.getLine()) {
3373 // Determine offset.
3374 int Offset = LineInfo.getLine() - Line;
3375 int Delta = Offset - MinLineDelta;
3378 Line = LineInfo.getLine();
3380 // If delta is small enough and in range...
3381 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3382 // ... then use fast opcode.
3383 Asm->OutStreamer.AddComment("Line Delta");
3384 Asm->EmitInt8(Delta - MinLineDelta);
3386 // ... otherwise use long hand.
3387 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3388 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3389 Asm->EmitSLEB128(Offset, "Line Offset");
3390 Asm->OutStreamer.AddComment("DW_LNS_copy");
3391 Asm->EmitInt8(dwarf::DW_LNS_copy);
3394 // Copy the previous row (different address or source)
3395 Asm->OutStreamer.AddComment("DW_LNS_copy");
3396 Asm->EmitInt8(dwarf::DW_LNS_copy);
3400 emitEndOfLineMatrix(j + 1);
3403 if (SecSrcLinesSize == 0)
3404 // Because we're emitting a debug_line section, we still need a line
3405 // table. The linker and friends expect it to exist. If there's nothing to
3406 // put into it, emit an empty table.
3407 emitEndOfLineMatrix(1);
3409 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3412 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3414 void DwarfDebug::emitCommonDebugFrame() {
3415 if (!Asm->MAI->doesDwarfRequireFrameSection())
3418 int stackGrowth = Asm->getTargetData().getPointerSize();
3419 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3420 TargetFrameInfo::StackGrowsDown)
3423 // Start the dwarf frame section.
3424 Asm->OutStreamer.SwitchSection(
3425 Asm->getObjFileLowering().getDwarfFrameSection());
3427 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3428 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3429 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3430 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3432 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3433 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3434 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3435 Asm->OutStreamer.AddComment("CIE Version");
3436 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3437 Asm->OutStreamer.AddComment("CIE Augmentation");
3438 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3439 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3440 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3441 Asm->OutStreamer.AddComment("CIE RA Column");
3442 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3443 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3445 std::vector<MachineMove> Moves;
3446 RI->getInitialFrameState(Moves);
3448 Asm->EmitFrameMoves(Moves, 0, false);
3450 Asm->EmitAlignment(2);
3451 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3454 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3457 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3458 if (!Asm->MAI->doesDwarfRequireFrameSection())
3461 // Start the dwarf frame section.
3462 Asm->OutStreamer.SwitchSection(
3463 Asm->getObjFileLowering().getDwarfFrameSection());
3465 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3466 MCSymbol *DebugFrameBegin =
3467 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3468 MCSymbol *DebugFrameEnd =
3469 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3470 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3472 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3474 Asm->OutStreamer.AddComment("FDE CIE offset");
3475 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3476 DwarfFrameSectionSym);
3478 Asm->OutStreamer.AddComment("FDE initial location");
3479 MCSymbol *FuncBeginSym =
3480 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3481 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3482 Asm->getTargetData().getPointerSize(),
3486 Asm->OutStreamer.AddComment("FDE address range");
3487 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3488 FuncBeginSym, Asm->getTargetData().getPointerSize());
3490 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3492 Asm->EmitAlignment(2);
3493 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3496 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3498 void DwarfDebug::emitDebugPubNames() {
3499 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3500 E = CUMap.end(); I != E; ++I) {
3501 CompileUnit *TheCU = I->second;
3502 // Start the dwarf pubnames section.
3503 Asm->OutStreamer.SwitchSection(
3504 Asm->getObjFileLowering().getDwarfPubNamesSection());
3506 Asm->OutStreamer.AddComment("Length of Public Names Info");
3507 Asm->EmitLabelDifference(
3508 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3509 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3511 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3514 Asm->OutStreamer.AddComment("DWARF Version");
3515 Asm->EmitInt16(dwarf::DWARF_VERSION);
3517 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3518 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3519 DwarfInfoSectionSym);
3521 Asm->OutStreamer.AddComment("Compilation Unit Length");
3522 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3523 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3526 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3527 for (StringMap<DIE*>::const_iterator
3528 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3529 const char *Name = GI->getKeyData();
3530 DIE *Entity = GI->second;
3532 Asm->OutStreamer.AddComment("DIE offset");
3533 Asm->EmitInt32(Entity->getOffset());
3535 if (Asm->isVerbose())
3536 Asm->OutStreamer.AddComment("External Name");
3537 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3540 Asm->OutStreamer.AddComment("End Mark");
3542 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3547 void DwarfDebug::emitDebugPubTypes() {
3548 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3549 E = CUMap.end(); I != E; ++I) {
3550 CompileUnit *TheCU = I->second;
3551 // Start the dwarf pubnames section.
3552 Asm->OutStreamer.SwitchSection(
3553 Asm->getObjFileLowering().getDwarfPubTypesSection());
3554 Asm->OutStreamer.AddComment("Length of Public Types Info");
3555 Asm->EmitLabelDifference(
3556 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3557 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3559 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3562 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3563 Asm->EmitInt16(dwarf::DWARF_VERSION);
3565 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3566 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3567 DwarfInfoSectionSym);
3569 Asm->OutStreamer.AddComment("Compilation Unit Length");
3570 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3571 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3574 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3575 for (StringMap<DIE*>::const_iterator
3576 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3577 const char *Name = GI->getKeyData();
3578 DIE * Entity = GI->second;
3580 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3581 Asm->EmitInt32(Entity->getOffset());
3583 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3584 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3587 Asm->OutStreamer.AddComment("End Mark");
3589 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3594 /// emitDebugStr - Emit visible names into a debug str section.
3596 void DwarfDebug::emitDebugStr() {
3597 // Check to see if it is worth the effort.
3598 if (StringPool.empty()) return;
3600 // Start the dwarf str section.
3601 Asm->OutStreamer.SwitchSection(
3602 Asm->getObjFileLowering().getDwarfStrSection());
3604 // Get all of the string pool entries and put them in an array by their ID so
3605 // we can sort them.
3606 SmallVector<std::pair<unsigned,
3607 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3609 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3610 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3611 Entries.push_back(std::make_pair(I->second.second, &*I));
3613 array_pod_sort(Entries.begin(), Entries.end());
3615 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3616 // Emit a label for reference from debug information entries.
3617 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3619 // Emit the string itself.
3620 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3624 /// emitDebugLoc - Emit visible names into a debug loc section.
3626 void DwarfDebug::emitDebugLoc() {
3627 if (DotDebugLocEntries.empty())
3630 // Start the dwarf loc section.
3631 Asm->OutStreamer.SwitchSection(
3632 Asm->getObjFileLowering().getDwarfLocSection());
3633 unsigned char Size = Asm->getTargetData().getPointerSize();
3634 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3636 for (SmallVector<DotDebugLocEntry, 4>::iterator
3637 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3638 I != E; ++I, ++index) {
3639 DotDebugLocEntry Entry = *I;
3640 if (Entry.isEmpty()) {
3641 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3642 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3643 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3645 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3646 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3647 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3648 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3649 if (int Offset = Entry.Loc.getOffset()) {
3650 // If the value is at a certain offset from frame register then
3652 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3653 Asm->OutStreamer.AddComment("Loc expr size");
3654 Asm->EmitInt16(1 + OffsetSize);
3655 Asm->OutStreamer.AddComment(
3656 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3657 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3658 Asm->OutStreamer.AddComment("Offset");
3659 Asm->EmitSLEB128(Offset);
3662 Asm->OutStreamer.AddComment("Loc expr size");
3664 Asm->OutStreamer.AddComment(
3665 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3666 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3668 Asm->OutStreamer.AddComment("Loc expr size");
3669 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3670 Asm->EmitInt8(dwarf::DW_OP_regx);
3671 Asm->EmitULEB128(Reg);
3678 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3680 void DwarfDebug::EmitDebugARanges() {
3681 // Start the dwarf aranges section.
3682 Asm->OutStreamer.SwitchSection(
3683 Asm->getObjFileLowering().getDwarfARangesSection());
3686 /// emitDebugRanges - Emit visible names into a debug ranges section.
3688 void DwarfDebug::emitDebugRanges() {
3689 // Start the dwarf ranges section.
3690 Asm->OutStreamer.SwitchSection(
3691 Asm->getObjFileLowering().getDwarfRangesSection());
3692 unsigned char Size = Asm->getTargetData().getPointerSize();
3693 for (SmallVector<const MCSymbol *, 8>::iterator
3694 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3697 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3699 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3703 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3705 void DwarfDebug::emitDebugMacInfo() {
3706 if (const MCSection *LineInfo =
3707 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3708 // Start the dwarf macinfo section.
3709 Asm->OutStreamer.SwitchSection(LineInfo);
3713 /// emitDebugInlineInfo - Emit inline info using following format.
3715 /// 1. length of section
3716 /// 2. Dwarf version number
3717 /// 3. address size.
3719 /// Entries (one "entry" for each function that was inlined):
3721 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3722 /// otherwise offset into __debug_str for regular function name.
3723 /// 2. offset into __debug_str section for regular function name.
3724 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3725 /// instances for the function.
3727 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3728 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3729 /// __debug_info section, and the low_pc is the starting address for the
3730 /// inlining instance.
3731 void DwarfDebug::emitDebugInlineInfo() {
3732 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3738 Asm->OutStreamer.SwitchSection(
3739 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3741 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3742 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3743 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3745 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3747 Asm->OutStreamer.AddComment("Dwarf Version");
3748 Asm->EmitInt16(dwarf::DWARF_VERSION);
3749 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3750 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3752 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3753 E = InlinedSPNodes.end(); I != E; ++I) {
3755 const MDNode *Node = *I;
3756 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3757 = InlineInfo.find(Node);
3758 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3759 DISubprogram SP(Node);
3760 StringRef LName = SP.getLinkageName();
3761 StringRef Name = SP.getName();
3763 Asm->OutStreamer.AddComment("MIPS linkage name");
3764 if (LName.empty()) {
3765 Asm->OutStreamer.EmitBytes(Name, 0);
3766 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3768 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3769 DwarfStrSectionSym);
3771 Asm->OutStreamer.AddComment("Function name");
3772 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3773 Asm->EmitULEB128(Labels.size(), "Inline count");
3775 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3776 LE = Labels.end(); LI != LE; ++LI) {
3777 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3778 Asm->EmitInt32(LI->second->getOffset());
3780 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3781 Asm->OutStreamer.EmitSymbolValue(LI->first,
3782 Asm->getTargetData().getPointerSize(),0);
3786 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));