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, const 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, const 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, const 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, const 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, const 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 /// createGlobalVariableDIE - Create new DIE using GV.
1190 DIE *DwarfDebug::createGlobalVariableDIE(const DIGlobalVariable &GV) {
1191 // If the global variable was optmized out then no need to create debug info
1193 if (!GV.Verify()) return NULL;
1194 if (GV.getDisplayName().empty()) return NULL;
1196 DIE *GVDie = new DIE(dwarf::DW_TAG_variable);
1197 addString(GVDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1198 GV.getDisplayName());
1200 StringRef LinkageName = GV.getLinkageName();
1201 if (!LinkageName.empty())
1202 addString(GVDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1203 getRealLinkageName(LinkageName));
1205 addType(GVDie, GV.getType());
1206 if (!GV.isLocalToUnit())
1207 addUInt(GVDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1208 addSourceLine(GVDie, GV);
1213 /// createMemberDIE - Create new member DIE.
1214 DIE *DwarfDebug::createMemberDIE(const DIDerivedType &DT) {
1215 DIE *MemberDie = new DIE(DT.getTag());
1216 StringRef Name = DT.getName();
1218 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1220 addType(MemberDie, DT.getTypeDerivedFrom());
1222 addSourceLine(MemberDie, DT);
1224 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1225 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1227 uint64_t Size = DT.getSizeInBits();
1228 uint64_t FieldSize = DT.getOriginalTypeSize();
1230 if (Size != FieldSize) {
1232 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1233 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1235 uint64_t Offset = DT.getOffsetInBits();
1236 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1237 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1238 uint64_t FieldOffset = (HiMark - FieldSize);
1239 Offset -= FieldOffset;
1241 // Maybe we need to work from the other end.
1242 if (Asm->getTargetData().isLittleEndian())
1243 Offset = FieldSize - (Offset + Size);
1244 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1246 // Here WD_AT_data_member_location points to the anonymous
1247 // field that includes this bit field.
1248 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1251 // This is not a bitfield.
1252 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1254 if (DT.getTag() == dwarf::DW_TAG_inheritance
1255 && DT.isVirtual()) {
1257 // For C++, virtual base classes are not at fixed offset. Use following
1258 // expression to extract appropriate offset from vtable.
1259 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1261 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1262 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1263 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1264 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1265 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1266 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1267 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1268 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1270 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1273 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1275 if (DT.isProtected())
1276 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1277 dwarf::DW_ACCESS_protected);
1278 else if (DT.isPrivate())
1279 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1280 dwarf::DW_ACCESS_private);
1281 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1282 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1283 dwarf::DW_ACCESS_public);
1285 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1286 dwarf::DW_VIRTUALITY_virtual);
1290 /// createSubprogramDIE - Create new DIE using SP.
1291 DIE *DwarfDebug::createSubprogramDIE(const DISubprogram &SP, bool MakeDecl) {
1292 CompileUnit *SPCU = getCompileUnit(SP);
1293 DIE *SPDie = SPCU->getDIE(SP);
1297 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1298 // Constructors and operators for anonymous aggregates do not have names.
1299 if (!SP.getName().empty())
1300 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1302 StringRef LinkageName = SP.getLinkageName();
1303 if (!LinkageName.empty())
1304 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1305 getRealLinkageName(LinkageName));
1307 addSourceLine(SPDie, SP);
1309 // Add prototyped tag, if C or ObjC.
1310 unsigned Lang = SP.getCompileUnit().getLanguage();
1311 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1312 Lang == dwarf::DW_LANG_ObjC)
1313 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1316 DICompositeType SPTy = SP.getType();
1317 DIArray Args = SPTy.getTypeArray();
1318 unsigned SPTag = SPTy.getTag();
1320 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1321 addType(SPDie, SPTy);
1323 addType(SPDie, DIType(Args.getElement(0)));
1325 unsigned VK = SP.getVirtuality();
1327 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1328 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1329 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1330 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1331 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1332 ContainingTypeMap.insert(std::make_pair(SPDie,
1333 SP.getContainingType()));
1336 if (MakeDecl || !SP.isDefinition()) {
1337 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1339 // Add arguments. Do not add arguments for subprogram definition. They will
1340 // be handled while processing variables.
1341 DICompositeType SPTy = SP.getType();
1342 DIArray Args = SPTy.getTypeArray();
1343 unsigned SPTag = SPTy.getTag();
1345 if (SPTag == dwarf::DW_TAG_subroutine_type)
1346 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1347 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1348 DIType ATy = DIType(DIType(Args.getElement(i)));
1350 if (ATy.isArtificial())
1351 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1352 SPDie->addChild(Arg);
1356 if (SP.isArtificial())
1357 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1359 if (!SP.isLocalToUnit())
1360 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1362 if (SP.isOptimized())
1363 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1365 if (unsigned isa = Asm->getISAEncoding()) {
1366 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1369 // DW_TAG_inlined_subroutine may refer to this DIE.
1370 SPCU->insertDIE(SP, SPDie);
1372 // Add to context owner.
1373 addToContextOwner(SPDie, SP.getContext());
1378 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1379 assert(N && "Invalid Scope encoding!");
1381 DbgScope *AScope = AbstractScopes.lookup(N);
1385 DbgScope *Parent = NULL;
1387 DIDescriptor Scope(N);
1388 if (Scope.isLexicalBlock()) {
1389 DILexicalBlock DB(N);
1390 DIDescriptor ParentDesc = DB.getContext();
1391 Parent = getOrCreateAbstractScope(ParentDesc);
1394 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1397 Parent->addScope(AScope);
1398 AScope->setAbstractScope();
1399 AbstractScopes[N] = AScope;
1400 if (DIDescriptor(N).isSubprogram())
1401 AbstractScopesList.push_back(AScope);
1405 /// isSubprogramContext - Return true if Context is either a subprogram
1406 /// or another context nested inside a subprogram.
1407 static bool isSubprogramContext(const MDNode *Context) {
1410 DIDescriptor D(Context);
1411 if (D.isSubprogram())
1414 return isSubprogramContext(DIType(Context).getContext());
1418 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1419 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1420 /// If there are global variables in this scope then create and insert
1421 /// DIEs for these variables.
1422 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1423 CompileUnit *SPCU = getCompileUnit(SPNode);
1424 DIE *SPDie = SPCU->getDIE(SPNode);
1426 assert(SPDie && "Unable to find subprogram DIE!");
1427 DISubprogram SP(SPNode);
1429 // There is not any need to generate specification DIE for a function
1430 // defined at compile unit level. If a function is defined inside another
1431 // function then gdb prefers the definition at top level and but does not
1432 // expect specification DIE in parent function. So avoid creating
1433 // specification DIE for a function defined inside a function.
1434 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1435 !SP.getContext().isFile() &&
1436 !isSubprogramContext(SP.getContext())) {
1437 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1440 DICompositeType SPTy = SP.getType();
1441 DIArray Args = SPTy.getTypeArray();
1442 unsigned SPTag = SPTy.getTag();
1443 if (SPTag == dwarf::DW_TAG_subroutine_type)
1444 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1445 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1446 DIType ATy = DIType(DIType(Args.getElement(i)));
1448 if (ATy.isArtificial())
1449 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1450 SPDie->addChild(Arg);
1452 DIE *SPDeclDie = SPDie;
1453 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1454 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1456 SPCU->addDie(SPDie);
1459 // Pick up abstract subprogram DIE.
1460 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1461 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1462 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1463 dwarf::DW_FORM_ref4, AbsSPDIE);
1464 SPCU->addDie(SPDie);
1467 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1468 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1469 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1470 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1471 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1472 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1473 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1478 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1479 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1480 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1482 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1483 if (Scope->isAbstractScope())
1486 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1490 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1491 if (Ranges.size() > 1) {
1492 // .debug_range section has not been laid out yet. Emit offset in
1493 // .debug_range as a uint, size 4, for now. emitDIE will handle
1494 // DW_AT_ranges appropriately.
1495 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1496 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1497 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1498 RE = Ranges.end(); RI != RE; ++RI) {
1499 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1500 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1502 DebugRangeSymbols.push_back(NULL);
1503 DebugRangeSymbols.push_back(NULL);
1507 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1508 const MCSymbol *End = getLabelAfterInsn(RI->second);
1510 if (End == 0) return 0;
1512 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1513 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1515 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1516 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1521 /// constructInlinedScopeDIE - This scope represents inlined body of
1522 /// a function. Construct DIE to represent this concrete inlined copy
1523 /// of the function.
1524 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1526 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1527 assert (Ranges.empty() == false
1528 && "DbgScope does not have instruction markers!");
1530 // FIXME : .debug_inlined section specification does not clearly state how
1531 // to emit inlined scope that is split into multiple instruction ranges.
1532 // For now, use first instruction range and emit low_pc/high_pc pair and
1533 // corresponding .debug_inlined section entry for this pair.
1534 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1535 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1536 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1538 if (StartLabel == 0 || EndLabel == 0) {
1539 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1542 assert(StartLabel->isDefined() &&
1543 "Invalid starting label for an inlined scope!");
1544 assert(EndLabel->isDefined() &&
1545 "Invalid end label for an inlined scope!");
1547 if (!Scope->getScopeNode())
1549 DIScope DS(Scope->getScopeNode());
1550 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1552 DISubprogram InlinedSP = getDISubprogram(DS);
1553 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1554 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1555 assert(OriginDIE && "Unable to find Origin DIE!");
1556 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1557 dwarf::DW_FORM_ref4, OriginDIE);
1559 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1560 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1562 InlinedSubprogramDIEs.insert(OriginDIE);
1564 // Track the start label for this inlined function.
1565 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1566 I = InlineInfo.find(InlinedSP);
1568 if (I == InlineInfo.end()) {
1569 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1571 InlinedSPNodes.push_back(InlinedSP);
1573 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1575 DILocation DL(Scope->getInlinedAt());
1576 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1577 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1583 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1584 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1585 StringRef Name = DV->getName();
1589 // Translate tag to proper Dwarf tag. The result variable is dropped for
1592 switch (DV->getTag()) {
1593 case dwarf::DW_TAG_return_variable:
1595 case dwarf::DW_TAG_arg_variable:
1596 Tag = dwarf::DW_TAG_formal_parameter;
1598 case dwarf::DW_TAG_auto_variable: // fall thru
1600 Tag = dwarf::DW_TAG_variable;
1604 // Define variable debug information entry.
1605 DIE *VariableDie = new DIE(Tag);
1608 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1609 V2AVI = VarToAbstractVarMap.find(DV);
1610 if (V2AVI != VarToAbstractVarMap.end())
1611 AbsDIE = V2AVI->second->getDIE();
1614 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1615 dwarf::DW_FORM_ref4, AbsDIE);
1617 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1618 addSourceLine(VariableDie, DV->getVariable());
1620 // Add variable type.
1621 addType(VariableDie, DV->getType());
1624 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1625 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1627 if (Scope->isAbstractScope()) {
1628 DV->setDIE(VariableDie);
1632 // Add variable address.
1634 unsigned Offset = DV->getDotDebugLocOffset();
1635 if (Offset != ~0U) {
1636 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1637 Asm->GetTempSymbol("debug_loc", Offset));
1638 DV->setDIE(VariableDie);
1639 UseDotDebugLocEntry.insert(VariableDie);
1643 // Check if variable is described by a DBG_VALUE instruction.
1644 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1645 DbgVariableToDbgInstMap.find(DV);
1646 if (DVI != DbgVariableToDbgInstMap.end()) {
1647 const MachineInstr *DVInsn = DVI->second;
1648 const MCSymbol *DVLabel = findVariableLabel(DV);
1649 bool updated = false;
1650 // FIXME : Handle getNumOperands != 3
1651 if (DVInsn->getNumOperands() == 3) {
1652 if (DVInsn->getOperand(0).isReg())
1654 addRegisterAddress(VariableDie, DVLabel, DVInsn->getOperand(0));
1655 else if (DVInsn->getOperand(0).isImm())
1656 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1657 else if (DVInsn->getOperand(0).isFPImm())
1659 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1661 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1662 if (Location.getReg()) {
1663 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1665 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1671 // If variableDie is not updated then DBG_VALUE instruction does not
1672 // have valid variable info.
1676 DV->setDIE(VariableDie);
1680 // .. else use frame index, if available.
1681 MachineLocation Location;
1683 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1685 if (findVariableFrameIndex(DV, &FI)) {
1686 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1687 Location.set(FrameReg, Offset);
1688 addVariableAddress(DV, VariableDie, dwarf::DW_AT_location, Location);
1690 DV->setDIE(VariableDie);
1695 void DwarfDebug::addPubTypes(DISubprogram SP) {
1696 DICompositeType SPTy = SP.getType();
1697 unsigned SPTag = SPTy.getTag();
1698 if (SPTag != dwarf::DW_TAG_subroutine_type)
1701 DIArray Args = SPTy.getTypeArray();
1702 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1703 DIType ATy(Args.getElement(i));
1706 DICompositeType CATy = getDICompositeType(ATy);
1707 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1708 && !CATy.isForwardDecl()) {
1709 CompileUnit *TheCU = getCompileUnit(CATy);
1710 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1711 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1716 /// constructScopeDIE - Construct a DIE for this scope.
1717 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1718 if (!Scope || !Scope->getScopeNode())
1721 DIScope DS(Scope->getScopeNode());
1722 DIE *ScopeDIE = NULL;
1723 if (Scope->getInlinedAt())
1724 ScopeDIE = constructInlinedScopeDIE(Scope);
1725 else if (DS.isSubprogram()) {
1726 ProcessedSPNodes.insert(DS);
1727 if (Scope->isAbstractScope()) {
1728 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1729 // Note down abstract DIE.
1731 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1734 ScopeDIE = updateSubprogramScopeDIE(DS);
1737 ScopeDIE = constructLexicalScopeDIE(Scope);
1738 if (!ScopeDIE) return NULL;
1740 // Add variables to scope.
1741 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1742 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1743 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1745 ScopeDIE->addChild(VariableDIE);
1748 // Add nested scopes.
1749 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1750 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1751 // Define the Scope debug information entry.
1752 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1754 ScopeDIE->addChild(NestedDIE);
1757 if (DS.isSubprogram())
1758 addPubTypes(DISubprogram(DS));
1763 /// GetOrCreateSourceID - Look up the source id with the given directory and
1764 /// source file names. If none currently exists, create a new id and insert it
1765 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1767 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1769 assert (DirName.empty() == false && "Invalid directory name!");
1771 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1772 if (DI != DirectoryIdMap.end()) {
1773 DId = DI->getValue();
1775 DId = DirectoryNames.size() + 1;
1776 DirectoryIdMap[DirName] = DId;
1777 DirectoryNames.push_back(DirName);
1781 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1782 if (FI != SourceFileIdMap.end()) {
1783 FId = FI->getValue();
1785 FId = SourceFileNames.size() + 1;
1786 SourceFileIdMap[FileName] = FId;
1787 SourceFileNames.push_back(FileName);
1790 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1791 SourceIdMap.find(std::make_pair(DId, FId));
1792 if (SI != SourceIdMap.end())
1795 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1796 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1797 SourceIds.push_back(std::make_pair(DId, FId));
1802 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1803 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1804 CompileUnit *TheCU = getCompileUnit(NS);
1805 DIE *NDie = TheCU->getDIE(NS);
1808 NDie = new DIE(dwarf::DW_TAG_namespace);
1809 TheCU->insertDIE(NS, NDie);
1810 if (!NS.getName().empty())
1811 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1812 addSourceLine(NDie, NS);
1813 addToContextOwner(NDie, NS.getContext());
1817 /// constructCompileUnit - Create new CompileUnit for the given
1818 /// metadata node with tag DW_TAG_compile_unit.
1819 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1820 DICompileUnit DIUnit(N);
1821 StringRef FN = DIUnit.getFilename();
1822 StringRef Dir = DIUnit.getDirectory();
1823 unsigned ID = GetOrCreateSourceID(Dir, FN);
1825 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1826 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1827 DIUnit.getProducer());
1828 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1829 DIUnit.getLanguage());
1830 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1831 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1832 // simplifies debug range entries.
1833 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1834 // DW_AT_stmt_list is a offset of line number information for this
1835 // compile unit in debug_line section. This offset is calculated
1836 // during endMoudle().
1837 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1840 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1841 if (DIUnit.isOptimized())
1842 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1844 StringRef Flags = DIUnit.getFlags();
1846 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1848 unsigned RVer = DIUnit.getRunTimeVersion();
1850 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1851 dwarf::DW_FORM_data1, RVer);
1853 CompileUnit *NewCU = new CompileUnit(ID, Die);
1856 CUMap.insert(std::make_pair(N, NewCU));
1859 /// getCompielUnit - Get CompileUnit DIE.
1860 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1861 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1863 const MDNode *CUNode = NULL;
1864 if (D.isCompileUnit())
1866 else if (D.isSubprogram())
1867 CUNode = DISubprogram(N).getCompileUnit();
1868 else if (D.isType())
1869 CUNode = DIType(N).getCompileUnit();
1870 else if (D.isGlobalVariable())
1871 CUNode = DIGlobalVariable(N).getCompileUnit();
1872 else if (D.isVariable())
1873 CUNode = DIVariable(N).getCompileUnit();
1874 else if (D.isNameSpace())
1875 CUNode = DINameSpace(N).getCompileUnit();
1876 else if (D.isFile())
1877 CUNode = DIFile(N).getCompileUnit();
1881 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1882 = CUMap.find(CUNode);
1883 if (I == CUMap.end())
1889 /// constructGlobalVariableDIE - Construct global variable DIE.
1890 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1891 DIGlobalVariable DI_GV(N);
1893 // If debug information is malformed then ignore it.
1894 if (DI_GV.Verify() == false)
1897 // Check for pre-existence.
1898 CompileUnit *TheCU = getCompileUnit(N);
1899 if (TheCU->getDIE(DI_GV))
1902 DIE *VariableDie = createGlobalVariableDIE(DI_GV);
1907 TheCU->insertDIE(N, VariableDie);
1909 // Add to context owner.
1910 DIDescriptor GVContext = DI_GV.getContext();
1911 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1912 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1913 addLabel(Block, 0, dwarf::DW_FORM_udata,
1914 Asm->Mang->getSymbol(DI_GV.getGlobal()));
1915 // Do not create specification DIE if context is either compile unit
1917 if (DI_GV.isDefinition() && !GVContext.isCompileUnit() &&
1918 !GVContext.isFile() &&
1919 !isSubprogramContext(GVContext)) {
1920 // Create specification DIE.
1921 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1922 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1923 dwarf::DW_FORM_ref4, VariableDie);
1924 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1925 addUInt(VariableDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1926 TheCU->addDie(VariableSpecDIE);
1928 addBlock(VariableDie, dwarf::DW_AT_location, 0, Block);
1930 addToContextOwner(VariableDie, GVContext);
1932 // Expose as global. FIXME - need to check external flag.
1933 TheCU->addGlobal(DI_GV.getName(), VariableDie);
1935 DIType GTy = DI_GV.getType();
1936 if (GTy.isCompositeType() && !GTy.getName().empty()
1937 && !GTy.isForwardDecl()) {
1938 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1939 assert(Entry && "Missing global type!");
1940 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1945 /// construct SubprogramDIE - Construct subprogram DIE.
1946 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1949 // Check for pre-existence.
1950 CompileUnit *TheCU = getCompileUnit(N);
1951 if (TheCU->getDIE(N))
1954 if (!SP.isDefinition())
1955 // This is a method declaration which will be handled while constructing
1959 DIE *SubprogramDie = createSubprogramDIE(SP);
1962 TheCU->insertDIE(N, SubprogramDie);
1964 // Add to context owner.
1965 addToContextOwner(SubprogramDie, SP.getContext());
1967 // Expose as global.
1968 TheCU->addGlobal(SP.getName(), SubprogramDie);
1973 /// beginModule - Emit all Dwarf sections that should come prior to the
1974 /// content. Create global DIEs and emit initial debug info sections.
1975 /// This is inovked by the target AsmPrinter.
1976 void DwarfDebug::beginModule(Module *M) {
1977 if (DisableDebugInfoPrinting)
1980 DebugInfoFinder DbgFinder;
1981 DbgFinder.processModule(*M);
1983 bool HasDebugInfo = false;
1985 // Scan all the compile-units to see if there are any marked as the main unit.
1986 // if not, we do not generate debug info.
1987 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
1988 E = DbgFinder.compile_unit_end(); I != E; ++I) {
1989 if (DICompileUnit(*I).isMain()) {
1990 HasDebugInfo = true;
1995 if (!HasDebugInfo) return;
1997 // Tell MMI that we have debug info.
1998 MMI->setDebugInfoAvailability(true);
2000 // Emit initial sections.
2001 EmitSectionLabels();
2003 // Create all the compile unit DIEs.
2004 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2005 E = DbgFinder.compile_unit_end(); I != E; ++I)
2006 constructCompileUnit(*I);
2008 // Create DIEs for each subprogram.
2009 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2010 E = DbgFinder.subprogram_end(); I != E; ++I)
2011 constructSubprogramDIE(*I);
2013 // Create DIEs for each global variable.
2014 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2015 E = DbgFinder.global_variable_end(); I != E; ++I)
2016 constructGlobalVariableDIE(*I);
2018 // Prime section data.
2019 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2021 // Print out .file directives to specify files for .loc directives. These are
2022 // printed out early so that they precede any .loc directives.
2023 if (Asm->MAI->hasDotLocAndDotFile()) {
2024 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2025 // Remember source id starts at 1.
2026 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2027 // FIXME: don't use sys::path for this! This should not depend on the
2029 sys::Path FullPath(getSourceDirectoryName(Id.first));
2031 FullPath.appendComponent(getSourceFileName(Id.second));
2032 assert(AppendOk && "Could not append filename to directory!");
2034 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2039 /// endModule - Emit all Dwarf sections that should come after the content.
2041 void DwarfDebug::endModule() {
2042 if (!FirstCU) return;
2043 const Module *M = MMI->getModule();
2044 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2045 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2046 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2047 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2048 DISubprogram SP(AllSPs->getOperand(SI));
2049 if (!SP.Verify()) continue;
2051 // Collect info for variables that were optimized out.
2052 if (!SP.isDefinition()) continue;
2053 StringRef FName = SP.getLinkageName();
2055 FName = SP.getName();
2057 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2059 unsigned E = NMD->getNumOperands();
2061 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2062 DeadFnScopeMap[SP] = Scope;
2063 for (unsigned I = 0; I != E; ++I) {
2064 DIVariable DV(NMD->getOperand(I));
2065 if (!DV.Verify()) continue;
2066 Scope->addVariable(new DbgVariable(DV));
2069 // Construct subprogram DIE and add variables DIEs.
2070 constructSubprogramDIE(SP);
2071 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2072 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2073 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2074 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2076 ScopeDIE->addChild(VariableDIE);
2081 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2082 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2083 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2085 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2088 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2089 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2090 DIE *SPDie = CI->first;
2091 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2093 DIE *NDie = getCompileUnit(N)->getDIE(N);
2094 if (!NDie) continue;
2095 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2098 // Standard sections final addresses.
2099 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2100 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2101 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2102 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2104 // End text sections.
2105 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2106 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2107 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2110 // Emit common frame information.
2111 emitCommonDebugFrame();
2113 // Emit function debug frame information
2114 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2115 E = DebugFrames.end(); I != E; ++I)
2116 emitFunctionDebugFrame(*I);
2118 // Compute DIE offsets and sizes.
2119 computeSizeAndOffsets();
2121 // Emit source line correspondence into a debug line section.
2124 // Emit all the DIEs into a debug info section
2127 // Corresponding abbreviations into a abbrev section.
2128 emitAbbreviations();
2130 // Emit info into a debug pubnames section.
2131 emitDebugPubNames();
2133 // Emit info into a debug pubtypes section.
2134 emitDebugPubTypes();
2136 // Emit info into a debug loc section.
2139 // Emit info into a debug aranges section.
2142 // Emit info into a debug ranges section.
2145 // Emit info into a debug macinfo section.
2148 // Emit inline info.
2149 emitDebugInlineInfo();
2151 // Emit info into a debug str section.
2155 DeleteContainerSeconds(DeadFnScopeMap);
2156 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2157 E = CUMap.end(); I != E; ++I)
2159 FirstCU = NULL; // Reset for the next Module, if any.
2162 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2163 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2164 DebugLoc ScopeLoc) {
2166 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2168 return AbsDbgVariable;
2170 LLVMContext &Ctx = Var->getContext();
2171 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2175 AbsDbgVariable = new DbgVariable(Var);
2176 Scope->addVariable(AbsDbgVariable);
2177 AbstractVariables[Var] = AbsDbgVariable;
2178 return AbsDbgVariable;
2181 /// collectVariableInfoFromMMITable - Collect variable information from
2182 /// side table maintained by MMI.
2184 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2185 SmallPtrSet<const MDNode *, 16> &Processed) {
2186 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2187 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2188 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2189 VE = VMap.end(); VI != VE; ++VI) {
2190 const MDNode *Var = VI->first;
2192 Processed.insert(Var);
2194 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2196 DbgScope *Scope = 0;
2197 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2198 Scope = ConcreteScopes.lookup(IA);
2200 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2202 // If variable scope is not found then skip this variable.
2206 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2207 DbgVariable *RegVar = new DbgVariable(DV);
2208 recordVariableFrameIndex(RegVar, VP.first);
2209 Scope->addVariable(RegVar);
2210 if (AbsDbgVariable) {
2211 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2212 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2217 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2218 /// DBG_VALUE instruction, is in undefined reg.
2219 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2220 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2221 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2226 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2227 /// DBG_VALUE instruction, is in a defined reg.
2228 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2229 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2230 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2235 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2237 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2238 SmallPtrSet<const MDNode *, 16> &Processed) {
2240 /// collection info from MMI table.
2241 collectVariableInfoFromMMITable(MF, Processed);
2243 SmallVector<const MachineInstr *, 8> DbgValues;
2244 // Collect variable information from DBG_VALUE machine instructions;
2245 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2247 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2249 const MachineInstr *MInsn = II;
2250 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2252 DbgValues.push_back(MInsn);
2255 // This is a collection of DBV_VALUE instructions describing same variable.
2256 SmallVector<const MachineInstr *, 4> MultipleValues;
2257 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2258 E = DbgValues.end(); I != E; ++I) {
2259 const MachineInstr *MInsn = *I;
2260 MultipleValues.clear();
2261 if (isDbgValueInDefinedReg(MInsn))
2262 MultipleValues.push_back(MInsn);
2263 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2264 if (Processed.count(DV) != 0)
2267 const MachineInstr *PrevMI = MInsn;
2268 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2269 ME = DbgValues.end(); MI != ME; ++MI) {
2271 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2272 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2273 !PrevMI->isIdenticalTo(*MI))
2274 MultipleValues.push_back(*MI);
2278 DbgScope *Scope = findDbgScope(MInsn);
2279 bool CurFnArg = false;
2280 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2281 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2283 if (!Scope && CurFnArg)
2284 Scope = CurrentFnDbgScope;
2285 // If variable scope is not found then skip this variable.
2289 Processed.insert(DV);
2290 DbgVariable *RegVar = new DbgVariable(DV);
2291 Scope->addVariable(RegVar);
2293 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2294 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2295 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2296 VarToAbstractVarMap[RegVar] = AbsVar;
2298 if (MultipleValues.size() <= 1) {
2299 DbgVariableToDbgInstMap[RegVar] = MInsn;
2303 // handle multiple DBG_VALUE instructions describing one variable.
2304 if (DotDebugLocEntries.empty())
2305 RegVar->setDotDebugLocOffset(0);
2307 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2308 const MachineInstr *Begin = NULL;
2309 const MachineInstr *End = NULL;
2310 for (SmallVector<const MachineInstr *, 4>::iterator
2311 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2312 MVI != MVE; ++MVI) {
2318 MachineLocation MLoc;
2319 if (Begin->getNumOperands() == 3) {
2320 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2321 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2323 MLoc = Asm->getDebugValueLocation(Begin);
2325 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2326 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2328 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2331 if (MVI + 1 == MVE) {
2332 // If End is the last instruction then its value is valid
2333 // until the end of the funtion.
2334 MachineLocation EMLoc;
2335 if (End->getNumOperands() == 3) {
2336 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2337 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2339 EMLoc = Asm->getDebugValueLocation(End);
2342 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2345 DotDebugLocEntries.push_back(DotDebugLocEntry());
2348 // Collect info for variables that were optimized out.
2349 const Function *F = MF->getFunction();
2350 const Module *M = F->getParent();
2351 if (NamedMDNode *NMD =
2352 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2353 getRealLinkageName(F->getName())))) {
2354 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2355 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2356 if (!DV || !Processed.insert(DV))
2358 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2360 Scope->addVariable(new DbgVariable(DV));
2365 /// getLabelBeforeInsn - Return Label preceding the instruction.
2366 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2367 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2368 LabelsBeforeInsn.find(MI);
2369 if (I == LabelsBeforeInsn.end())
2370 // FunctionBeginSym always preceeds all the instruction in current function.
2371 return FunctionBeginSym;
2375 /// getLabelAfterInsn - Return Label immediately following the instruction.
2376 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2377 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2378 LabelsAfterInsn.find(MI);
2379 if (I == LabelsAfterInsn.end())
2384 /// beginScope - Process beginning of a scope.
2385 void DwarfDebug::beginScope(const MachineInstr *MI) {
2386 if (InsnNeedsLabel.count(MI) == 0) {
2387 LabelsBeforeInsn[MI] = PrevLabel;
2392 DebugLoc DL = MI->getDebugLoc();
2393 if (!DL.isUnknown()) {
2394 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2395 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2397 LabelsBeforeInsn[MI] = PrevLabel;
2401 // If location is unknown then use temp label for this DBG_VALUE
2403 if (MI->isDebugValue()) {
2404 PrevLabel = MMI->getContext().CreateTempSymbol();
2405 Asm->OutStreamer.EmitLabel(PrevLabel);
2406 LabelsBeforeInsn[MI] = PrevLabel;
2410 if (UnknownLocations) {
2411 PrevLabel = recordSourceLine(0, 0, 0);
2412 LabelsBeforeInsn[MI] = PrevLabel;
2416 assert (0 && "Instruction is not processed!");
2419 /// endScope - Process end of a scope.
2420 void DwarfDebug::endScope(const MachineInstr *MI) {
2421 if (InsnsEndScopeSet.count(MI) != 0) {
2422 // Emit a label if this instruction ends a scope.
2423 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2424 Asm->OutStreamer.EmitLabel(Label);
2425 LabelsAfterInsn[MI] = Label;
2429 /// getOrCreateDbgScope - Create DbgScope for the scope.
2430 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2431 const MDNode *InlinedAt) {
2433 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2436 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2437 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2438 if (DIDescriptor(Scope).isLexicalBlock()) {
2440 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2441 WScope->setParent(Parent);
2442 Parent->addScope(WScope);
2445 if (!WScope->getParent()) {
2446 StringRef SPName = DISubprogram(Scope).getLinkageName();
2447 // We used to check only for a linkage name, but that fails
2448 // since we began omitting the linkage name for private
2449 // functions. The new way is to check for the name in metadata,
2450 // but that's not supported in old .ll test cases. Ergo, we
2452 if (SPName == Asm->MF->getFunction()->getName() ||
2453 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2454 CurrentFnDbgScope = WScope;
2460 getOrCreateAbstractScope(Scope);
2461 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2465 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2466 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2467 DILocation DL(InlinedAt);
2469 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2470 WScope->setParent(Parent);
2471 Parent->addScope(WScope);
2473 ConcreteScopes[InlinedAt] = WScope;
2478 /// hasValidLocation - Return true if debug location entry attached with
2479 /// machine instruction encodes valid location info.
2480 static bool hasValidLocation(LLVMContext &Ctx,
2481 const MachineInstr *MInsn,
2482 const MDNode *&Scope, const MDNode *&InlinedAt) {
2483 DebugLoc DL = MInsn->getDebugLoc();
2484 if (DL.isUnknown()) return false;
2486 const MDNode *S = DL.getScope(Ctx);
2488 // There is no need to create another DIE for compile unit. For all
2489 // other scopes, create one DbgScope now. This will be translated
2490 // into a scope DIE at the end.
2491 if (DIScope(S).isCompileUnit()) return false;
2494 InlinedAt = DL.getInlinedAt(Ctx);
2498 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2500 static void calculateDominanceGraph(DbgScope *Scope) {
2501 assert (Scope && "Unable to calculate scop edominance graph!");
2502 SmallVector<DbgScope *, 4> WorkStack;
2503 WorkStack.push_back(Scope);
2504 unsigned Counter = 0;
2505 while (!WorkStack.empty()) {
2506 DbgScope *WS = WorkStack.back();
2507 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2508 bool visitedChildren = false;
2509 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2510 SE = Children.end(); SI != SE; ++SI) {
2511 DbgScope *ChildScope = *SI;
2512 if (!ChildScope->getDFSOut()) {
2513 WorkStack.push_back(ChildScope);
2514 visitedChildren = true;
2515 ChildScope->setDFSIn(++Counter);
2519 if (!visitedChildren) {
2520 WorkStack.pop_back();
2521 WS->setDFSOut(++Counter);
2526 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2528 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2529 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2532 unsigned PrevDFSIn = 0;
2533 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2535 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2537 const MachineInstr *MInsn = II;
2538 const MDNode *Scope = NULL;
2539 const MDNode *InlinedAt = NULL;
2541 // Check if instruction has valid location information.
2542 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2546 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2547 MI2ScopeMap.find(MInsn);
2548 if (DI != MI2ScopeMap.end()) {
2549 DbgScope *S = DI->second;
2550 dbgs() << S->getDFSIn();
2551 PrevDFSIn = S->getDFSIn();
2553 dbgs() << PrevDFSIn;
2555 dbgs() << " [ x" << PrevDFSIn;
2563 /// extractScopeInformation - Scan machine instructions in this function
2564 /// and collect DbgScopes. Return true, if at least one scope was found.
2565 bool DwarfDebug::extractScopeInformation() {
2566 // If scope information was extracted using .dbg intrinsics then there is not
2567 // any need to extract these information by scanning each instruction.
2568 if (!DbgScopeMap.empty())
2571 // Scan each instruction and create scopes. First build working set of scopes.
2572 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2573 SmallVector<DbgRange, 4> MIRanges;
2574 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2575 const MDNode *PrevScope = NULL;
2576 const MDNode *PrevInlinedAt = NULL;
2577 const MachineInstr *RangeBeginMI = NULL;
2578 const MachineInstr *PrevMI = NULL;
2579 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2581 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2583 const MachineInstr *MInsn = II;
2584 const MDNode *Scope = NULL;
2585 const MDNode *InlinedAt = NULL;
2587 // Check if instruction has valid location information.
2588 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2593 // If scope has not changed then skip this instruction.
2594 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2600 // If we have alread seen a beginning of a instruction range and
2601 // current instruction scope does not match scope of first instruction
2602 // in this range then create a new instruction range.
2603 DbgRange R(RangeBeginMI, PrevMI);
2604 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2606 MIRanges.push_back(R);
2609 // This is a beginning of a new instruction range.
2610 RangeBeginMI = MInsn;
2612 // Reset previous markers.
2615 PrevInlinedAt = InlinedAt;
2619 // Create last instruction range.
2620 if (RangeBeginMI && PrevMI && PrevScope) {
2621 DbgRange R(RangeBeginMI, PrevMI);
2622 MIRanges.push_back(R);
2623 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2626 if (!CurrentFnDbgScope)
2629 calculateDominanceGraph(CurrentFnDbgScope);
2631 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2633 // Find ranges of instructions covered by each DbgScope;
2634 DbgScope *PrevDbgScope = NULL;
2635 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2636 RE = MIRanges.end(); RI != RE; ++RI) {
2637 const DbgRange &R = *RI;
2638 DbgScope *S = MI2ScopeMap.lookup(R.first);
2639 assert (S && "Lost DbgScope for a machine instruction!");
2640 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2641 PrevDbgScope->closeInsnRange(S);
2642 S->openInsnRange(R.first);
2643 S->extendInsnRange(R.second);
2648 PrevDbgScope->closeInsnRange();
2650 identifyScopeMarkers();
2652 return !DbgScopeMap.empty();
2655 /// identifyScopeMarkers() -
2656 /// Each DbgScope has first instruction and last instruction to mark beginning
2657 /// and end of a scope respectively. Create an inverse map that list scopes
2658 /// starts (and ends) with an instruction. One instruction may start (or end)
2659 /// multiple scopes. Ignore scopes that are not reachable.
2660 void DwarfDebug::identifyScopeMarkers() {
2661 SmallVector<DbgScope *, 4> WorkList;
2662 WorkList.push_back(CurrentFnDbgScope);
2663 while (!WorkList.empty()) {
2664 DbgScope *S = WorkList.pop_back_val();
2666 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2667 if (!Children.empty())
2668 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2669 SE = Children.end(); SI != SE; ++SI)
2670 WorkList.push_back(*SI);
2672 if (S->isAbstractScope())
2675 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2678 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2679 RE = Ranges.end(); RI != RE; ++RI) {
2680 assert(RI->first && "DbgRange does not have first instruction!");
2681 assert(RI->second && "DbgRange does not have second instruction!");
2682 InsnsEndScopeSet.insert(RI->second);
2687 /// FindFirstDebugLoc - Find the first debug location in the function. This
2688 /// is intended to be an approximation for the source position of the
2689 /// beginning of the function.
2690 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2691 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2693 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2694 MBBI != MBBE; ++MBBI) {
2695 DebugLoc DL = MBBI->getDebugLoc();
2696 if (!DL.isUnknown())
2702 /// beginFunction - Gather pre-function debug information. Assumes being
2703 /// emitted immediately after the function entry point.
2704 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2705 if (!MMI->hasDebugInfo()) return;
2706 if (!extractScopeInformation()) return;
2708 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2709 Asm->getFunctionNumber());
2710 // Assumes in correct section after the entry point.
2711 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2713 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2715 DebugLoc FDL = FindFirstDebugLoc(MF);
2716 if (FDL.isUnknown()) return;
2718 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2719 const MDNode *TheScope = 0;
2721 DISubprogram SP = getDISubprogram(Scope);
2724 Line = SP.getLineNumber();
2728 Line = FDL.getLine();
2733 recordSourceLine(Line, Col, TheScope);
2735 /// ProcessedArgs - Collection of arguments already processed.
2736 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2739 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2741 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2743 const MachineInstr *MI = II;
2744 DebugLoc DL = MI->getDebugLoc();
2745 if (MI->isDebugValue()) {
2746 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2747 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2748 if (!DV.Verify()) continue;
2749 // If DBG_VALUE is for a local variable then it needs a label.
2750 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2751 && isDbgValueInUndefinedReg(MI) == false)
2752 InsnNeedsLabel.insert(MI);
2753 // DBG_VALUE for inlined functions argument needs a label.
2754 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2755 describes(MF->getFunction()))
2756 InsnNeedsLabel.insert(MI);
2757 // DBG_VALUE indicating argument location change needs a label.
2758 else if (isDbgValueInUndefinedReg(MI) == false
2759 && !ProcessedArgs.insert(DV))
2760 InsnNeedsLabel.insert(MI);
2762 // If location is unknown then instruction needs a location only if
2763 // UnknownLocations flag is set.
2764 if (DL.isUnknown()) {
2765 if (UnknownLocations && !PrevLoc.isUnknown())
2766 InsnNeedsLabel.insert(MI);
2767 } else if (DL != PrevLoc)
2768 // Otherwise, instruction needs a location only if it is new location.
2769 InsnNeedsLabel.insert(MI);
2772 if (!DL.isUnknown() || UnknownLocations)
2776 PrevLabel = FunctionBeginSym;
2779 /// endFunction - Gather and emit post-function debug information.
2781 void DwarfDebug::endFunction(const MachineFunction *MF) {
2782 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2784 if (CurrentFnDbgScope) {
2786 // Define end label for subprogram.
2787 FunctionEndSym = Asm->GetTempSymbol("func_end",
2788 Asm->getFunctionNumber());
2789 // Assumes in correct section after the entry point.
2790 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2792 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2793 collectVariableInfo(MF, ProcessedVars);
2795 // Get function line info.
2796 if (!Lines.empty()) {
2797 // Get section line info.
2798 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2799 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2800 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2801 // Append the function info to section info.
2802 SectionLineInfos.insert(SectionLineInfos.end(),
2803 Lines.begin(), Lines.end());
2806 // Construct abstract scopes.
2807 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2808 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2809 DISubprogram SP((*AI)->getScopeNode());
2811 // Collect info for variables that were optimized out.
2812 StringRef FName = SP.getLinkageName();
2814 FName = SP.getName();
2815 const Module *M = MF->getFunction()->getParent();
2816 if (NamedMDNode *NMD =
2817 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2818 getRealLinkageName(FName)))) {
2819 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2820 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2821 if (!DV || !ProcessedVars.insert(DV))
2823 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2825 Scope->addVariable(new DbgVariable(DV));
2829 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2830 constructScopeDIE(*AI);
2833 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2835 if (!DisableFramePointerElim(*MF))
2836 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2837 dwarf::DW_FORM_flag, 1);
2840 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2841 MMI->getFrameMoves()));
2845 CurrentFnDbgScope = NULL;
2846 InsnNeedsLabel.clear();
2847 DbgVariableToFrameIndexMap.clear();
2848 VarToAbstractVarMap.clear();
2849 DbgVariableToDbgInstMap.clear();
2850 DbgVariableLabelsMap.clear();
2851 DeleteContainerSeconds(DbgScopeMap);
2852 InsnsEndScopeSet.clear();
2853 ConcreteScopes.clear();
2854 DeleteContainerSeconds(AbstractScopes);
2855 AbstractScopesList.clear();
2856 AbstractVariables.clear();
2857 LabelsBeforeInsn.clear();
2858 LabelsAfterInsn.clear();
2863 /// recordVariableFrameIndex - Record a variable's index.
2864 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2865 assert (V && "Invalid DbgVariable!");
2866 DbgVariableToFrameIndexMap[V] = Index;
2869 /// findVariableFrameIndex - Return true if frame index for the variable
2870 /// is found. Update FI to hold value of the index.
2871 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2872 assert (V && "Invalid DbgVariable!");
2873 DenseMap<const DbgVariable *, int>::iterator I =
2874 DbgVariableToFrameIndexMap.find(V);
2875 if (I == DbgVariableToFrameIndexMap.end())
2881 /// findVariableLabel - Find MCSymbol for the variable.
2882 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2883 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2884 = DbgVariableLabelsMap.find(V);
2885 if (I == DbgVariableLabelsMap.end())
2887 else return I->second;
2890 /// findDbgScope - Find DbgScope for the debug loc attached with an
2892 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2893 DbgScope *Scope = NULL;
2895 MInsn->getParent()->getParent()->getFunction()->getContext();
2896 DebugLoc DL = MInsn->getDebugLoc();
2901 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2902 Scope = ConcreteScopes.lookup(IA);
2904 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2910 /// recordSourceLine - Register a source line with debug info. Returns the
2911 /// unique label that was emitted and which provides correspondence to
2912 /// the source line list.
2913 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2920 DIDescriptor Scope(S);
2922 if (Scope.isCompileUnit()) {
2923 DICompileUnit CU(S);
2924 Dir = CU.getDirectory();
2925 Fn = CU.getFilename();
2926 } else if (Scope.isSubprogram()) {
2928 Dir = SP.getDirectory();
2929 Fn = SP.getFilename();
2930 } else if (Scope.isLexicalBlock()) {
2931 DILexicalBlock DB(S);
2932 Dir = DB.getDirectory();
2933 Fn = DB.getFilename();
2935 assert(0 && "Unexpected scope info");
2937 Src = GetOrCreateSourceID(Dir, Fn);
2940 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2941 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2943 Asm->OutStreamer.EmitLabel(Label);
2947 //===----------------------------------------------------------------------===//
2949 //===----------------------------------------------------------------------===//
2951 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2954 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2955 // Get the children.
2956 const std::vector<DIE *> &Children = Die->getChildren();
2958 // If not last sibling and has children then add sibling offset attribute.
2959 if (!Last && !Children.empty())
2960 Die->addSiblingOffset(DIEValueAllocator);
2962 // Record the abbreviation.
2963 assignAbbrevNumber(Die->getAbbrev());
2965 // Get the abbreviation for this DIE.
2966 unsigned AbbrevNumber = Die->getAbbrevNumber();
2967 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2970 Die->setOffset(Offset);
2972 // Start the size with the size of abbreviation code.
2973 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2975 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
2976 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
2978 // Size the DIE attribute values.
2979 for (unsigned i = 0, N = Values.size(); i < N; ++i)
2980 // Size attribute value.
2981 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
2983 // Size the DIE children if any.
2984 if (!Children.empty()) {
2985 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
2986 "Children flag not set");
2988 for (unsigned j = 0, M = Children.size(); j < M; ++j)
2989 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
2991 // End of children marker.
2992 Offset += sizeof(int8_t);
2995 Die->setSize(Offset - Die->getOffset());
2999 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3001 void DwarfDebug::computeSizeAndOffsets() {
3002 unsigned PrevOffset = 0;
3003 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3004 E = CUMap.end(); I != E; ++I) {
3005 // Compute size of compile unit header.
3006 static unsigned Offset = PrevOffset +
3007 sizeof(int32_t) + // Length of Compilation Unit Info
3008 sizeof(int16_t) + // DWARF version number
3009 sizeof(int32_t) + // Offset Into Abbrev. Section
3010 sizeof(int8_t); // Pointer Size (in bytes)
3011 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3012 PrevOffset = Offset;
3016 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3017 /// temporary label to it if SymbolStem is specified.
3018 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3019 const char *SymbolStem = 0) {
3020 Asm->OutStreamer.SwitchSection(Section);
3021 if (!SymbolStem) return 0;
3023 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3024 Asm->OutStreamer.EmitLabel(TmpSym);
3028 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3029 /// the start of each one.
3030 void DwarfDebug::EmitSectionLabels() {
3031 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3033 // Dwarf sections base addresses.
3034 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3035 DwarfFrameSectionSym =
3036 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3039 DwarfInfoSectionSym =
3040 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3041 DwarfAbbrevSectionSym =
3042 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3043 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3045 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3046 EmitSectionSym(Asm, MacroInfo);
3048 DwarfDebugLineSectionSym =
3049 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3050 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3051 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3052 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3053 DwarfStrSectionSym =
3054 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3055 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3058 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3059 "section_debug_loc");
3061 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3062 EmitSectionSym(Asm, TLOF.getDataSection());
3065 /// emitDIE - Recusively Emits a debug information entry.
3067 void DwarfDebug::emitDIE(DIE *Die) {
3068 // Get the abbreviation for this DIE.
3069 unsigned AbbrevNumber = Die->getAbbrevNumber();
3070 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3072 // Emit the code (index) for the abbreviation.
3073 if (Asm->isVerbose())
3074 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3075 Twine::utohexstr(Die->getOffset()) + ":0x" +
3076 Twine::utohexstr(Die->getSize()) + " " +
3077 dwarf::TagString(Abbrev->getTag()));
3078 Asm->EmitULEB128(AbbrevNumber);
3080 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3081 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3083 // Emit the DIE attribute values.
3084 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3085 unsigned Attr = AbbrevData[i].getAttribute();
3086 unsigned Form = AbbrevData[i].getForm();
3087 assert(Form && "Too many attributes for DIE (check abbreviation)");
3089 if (Asm->isVerbose())
3090 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3093 case dwarf::DW_AT_sibling:
3094 Asm->EmitInt32(Die->getSiblingOffset());
3096 case dwarf::DW_AT_abstract_origin: {
3097 DIEEntry *E = cast<DIEEntry>(Values[i]);
3098 DIE *Origin = E->getEntry();
3099 unsigned Addr = Origin->getOffset();
3100 Asm->EmitInt32(Addr);
3103 case dwarf::DW_AT_ranges: {
3104 // DW_AT_range Value encodes offset in debug_range section.
3105 DIEInteger *V = cast<DIEInteger>(Values[i]);
3106 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3108 DwarfDebugRangeSectionSym,
3112 case dwarf::DW_AT_stmt_list: {
3113 Asm->EmitLabelDifference(CurrentLineSectionSym,
3114 DwarfDebugLineSectionSym, 4);
3117 case dwarf::DW_AT_location: {
3118 if (UseDotDebugLocEntry.count(Die) != 0) {
3119 DIELabel *L = cast<DIELabel>(Values[i]);
3120 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3122 Values[i]->EmitValue(Asm, Form);
3126 // Emit an attribute using the defined form.
3127 Values[i]->EmitValue(Asm, Form);
3132 // Emit the DIE children if any.
3133 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3134 const std::vector<DIE *> &Children = Die->getChildren();
3136 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3137 emitDIE(Children[j]);
3139 if (Asm->isVerbose())
3140 Asm->OutStreamer.AddComment("End Of Children Mark");
3145 /// emitDebugInfo - Emit the debug info section.
3147 void DwarfDebug::emitDebugInfo() {
3148 // Start debug info section.
3149 Asm->OutStreamer.SwitchSection(
3150 Asm->getObjFileLowering().getDwarfInfoSection());
3151 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3152 E = CUMap.end(); I != E; ++I) {
3153 CompileUnit *TheCU = I->second;
3154 DIE *Die = TheCU->getCUDie();
3156 // Emit the compile units header.
3157 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3160 // Emit size of content not including length itself
3161 unsigned ContentSize = Die->getSize() +
3162 sizeof(int16_t) + // DWARF version number
3163 sizeof(int32_t) + // Offset Into Abbrev. Section
3164 sizeof(int8_t) + // Pointer Size (in bytes)
3165 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3167 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3168 Asm->EmitInt32(ContentSize);
3169 Asm->OutStreamer.AddComment("DWARF version number");
3170 Asm->EmitInt16(dwarf::DWARF_VERSION);
3171 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3172 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3173 DwarfAbbrevSectionSym);
3174 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3175 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3178 // FIXME - extra padding for gdb bug.
3179 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3184 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3188 /// emitAbbreviations - Emit the abbreviation section.
3190 void DwarfDebug::emitAbbreviations() const {
3191 // Check to see if it is worth the effort.
3192 if (!Abbreviations.empty()) {
3193 // Start the debug abbrev section.
3194 Asm->OutStreamer.SwitchSection(
3195 Asm->getObjFileLowering().getDwarfAbbrevSection());
3197 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3199 // For each abbrevation.
3200 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3201 // Get abbreviation data
3202 const DIEAbbrev *Abbrev = Abbreviations[i];
3204 // Emit the abbrevations code (base 1 index.)
3205 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3207 // Emit the abbreviations data.
3211 // Mark end of abbreviations.
3212 Asm->EmitULEB128(0, "EOM(3)");
3214 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3218 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3219 /// the line matrix.
3221 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3222 // Define last address of section.
3223 Asm->OutStreamer.AddComment("Extended Op");
3226 Asm->OutStreamer.AddComment("Op size");
3227 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3228 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3229 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3231 Asm->OutStreamer.AddComment("Section end label");
3233 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3234 Asm->getTargetData().getPointerSize(),
3237 // Mark end of matrix.
3238 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3244 /// emitDebugLines - Emit source line information.
3246 void DwarfDebug::emitDebugLines() {
3247 // If the target is using .loc/.file, the assembler will be emitting the
3248 // .debug_line table automatically.
3249 if (Asm->MAI->hasDotLocAndDotFile())
3252 // Minimum line delta, thus ranging from -10..(255-10).
3253 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3254 // Maximum line delta, thus ranging from -10..(255-10).
3255 const int MaxLineDelta = 255 + MinLineDelta;
3257 // Start the dwarf line section.
3258 Asm->OutStreamer.SwitchSection(
3259 Asm->getObjFileLowering().getDwarfLineSection());
3261 // Construct the section header.
3262 CurrentLineSectionSym = Asm->GetTempSymbol("section_line_begin");
3263 Asm->OutStreamer.EmitLabel(CurrentLineSectionSym);
3264 Asm->OutStreamer.AddComment("Length of Source Line Info");
3265 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3266 Asm->GetTempSymbol("line_begin"), 4);
3267 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3269 Asm->OutStreamer.AddComment("DWARF version number");
3270 Asm->EmitInt16(dwarf::DWARF_VERSION);
3272 Asm->OutStreamer.AddComment("Prolog Length");
3273 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3274 Asm->GetTempSymbol("line_prolog_begin"), 4);
3275 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3277 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3279 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3281 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3282 Asm->EmitInt8(MinLineDelta);
3283 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3284 Asm->EmitInt8(MaxLineDelta);
3285 Asm->OutStreamer.AddComment("Special Opcode Base");
3286 Asm->EmitInt8(-MinLineDelta);
3288 // Line number standard opcode encodings argument count
3289 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3291 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3293 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3295 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3297 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3299 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3301 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3303 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3305 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3308 // Emit directories.
3309 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3310 const std::string &Dir = getSourceDirectoryName(DI);
3311 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3312 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3315 Asm->OutStreamer.AddComment("End of directories");
3319 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3320 // Remember source id starts at 1.
3321 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3322 const std::string &FN = getSourceFileName(Id.second);
3323 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3324 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3326 Asm->EmitULEB128(Id.first, "Directory #");
3327 Asm->EmitULEB128(0, "Mod date");
3328 Asm->EmitULEB128(0, "File size");
3331 Asm->OutStreamer.AddComment("End of files");
3334 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3336 // A sequence for each text section.
3337 unsigned SecSrcLinesSize = SectionSourceLines.size();
3339 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3340 // Isolate current sections line info.
3341 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3343 // Dwarf assumes we start with first line of first source file.
3344 unsigned Source = 1;
3347 // Construct rows of the address, source, line, column matrix.
3348 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3349 const SrcLineInfo &LineInfo = LineInfos[i];
3350 MCSymbol *Label = LineInfo.getLabel();
3351 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3353 if (Asm->isVerbose()) {
3354 std::pair<unsigned, unsigned> SrcID =
3355 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3356 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3358 Twine(getSourceFileName(SrcID.second)) +
3359 ":" + Twine(LineInfo.getLine()));
3362 // Define the line address.
3363 Asm->OutStreamer.AddComment("Extended Op");
3365 Asm->OutStreamer.AddComment("Op size");
3366 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3368 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3369 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3371 Asm->OutStreamer.AddComment("Location label");
3372 Asm->OutStreamer.EmitSymbolValue(Label,
3373 Asm->getTargetData().getPointerSize(),
3376 // If change of source, then switch to the new source.
3377 if (Source != LineInfo.getSourceID()) {
3378 Source = LineInfo.getSourceID();
3379 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3380 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3381 Asm->EmitULEB128(Source, "New Source");
3384 // If change of line.
3385 if (Line != LineInfo.getLine()) {
3386 // Determine offset.
3387 int Offset = LineInfo.getLine() - Line;
3388 int Delta = Offset - MinLineDelta;
3391 Line = LineInfo.getLine();
3393 // If delta is small enough and in range...
3394 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3395 // ... then use fast opcode.
3396 Asm->OutStreamer.AddComment("Line Delta");
3397 Asm->EmitInt8(Delta - MinLineDelta);
3399 // ... otherwise use long hand.
3400 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3401 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3402 Asm->EmitSLEB128(Offset, "Line Offset");
3403 Asm->OutStreamer.AddComment("DW_LNS_copy");
3404 Asm->EmitInt8(dwarf::DW_LNS_copy);
3407 // Copy the previous row (different address or source)
3408 Asm->OutStreamer.AddComment("DW_LNS_copy");
3409 Asm->EmitInt8(dwarf::DW_LNS_copy);
3413 emitEndOfLineMatrix(j + 1);
3416 if (SecSrcLinesSize == 0)
3417 // Because we're emitting a debug_line section, we still need a line
3418 // table. The linker and friends expect it to exist. If there's nothing to
3419 // put into it, emit an empty table.
3420 emitEndOfLineMatrix(1);
3422 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3425 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3427 void DwarfDebug::emitCommonDebugFrame() {
3428 if (!Asm->MAI->doesDwarfRequireFrameSection())
3431 int stackGrowth = Asm->getTargetData().getPointerSize();
3432 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3433 TargetFrameInfo::StackGrowsDown)
3436 // Start the dwarf frame section.
3437 Asm->OutStreamer.SwitchSection(
3438 Asm->getObjFileLowering().getDwarfFrameSection());
3440 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3441 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3442 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3443 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3445 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3446 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3447 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3448 Asm->OutStreamer.AddComment("CIE Version");
3449 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3450 Asm->OutStreamer.AddComment("CIE Augmentation");
3451 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3452 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3453 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3454 Asm->OutStreamer.AddComment("CIE RA Column");
3455 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3456 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3458 std::vector<MachineMove> Moves;
3459 RI->getInitialFrameState(Moves);
3461 Asm->EmitFrameMoves(Moves, 0, false);
3463 Asm->EmitAlignment(2);
3464 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3467 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3470 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3471 if (!Asm->MAI->doesDwarfRequireFrameSection())
3474 // Start the dwarf frame section.
3475 Asm->OutStreamer.SwitchSection(
3476 Asm->getObjFileLowering().getDwarfFrameSection());
3478 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3479 MCSymbol *DebugFrameBegin =
3480 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3481 MCSymbol *DebugFrameEnd =
3482 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3483 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3485 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3487 Asm->OutStreamer.AddComment("FDE CIE offset");
3488 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3489 DwarfFrameSectionSym);
3491 Asm->OutStreamer.AddComment("FDE initial location");
3492 MCSymbol *FuncBeginSym =
3493 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3494 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3495 Asm->getTargetData().getPointerSize(),
3499 Asm->OutStreamer.AddComment("FDE address range");
3500 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3501 FuncBeginSym, Asm->getTargetData().getPointerSize());
3503 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3505 Asm->EmitAlignment(2);
3506 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3509 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3511 void DwarfDebug::emitDebugPubNames() {
3512 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3513 E = CUMap.end(); I != E; ++I) {
3514 CompileUnit *TheCU = I->second;
3515 // Start the dwarf pubnames section.
3516 Asm->OutStreamer.SwitchSection(
3517 Asm->getObjFileLowering().getDwarfPubNamesSection());
3519 Asm->OutStreamer.AddComment("Length of Public Names Info");
3520 Asm->EmitLabelDifference(
3521 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3522 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3524 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3527 Asm->OutStreamer.AddComment("DWARF Version");
3528 Asm->EmitInt16(dwarf::DWARF_VERSION);
3530 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3531 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3532 DwarfInfoSectionSym);
3534 Asm->OutStreamer.AddComment("Compilation Unit Length");
3535 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3536 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3539 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3540 for (StringMap<DIE*>::const_iterator
3541 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3542 const char *Name = GI->getKeyData();
3543 DIE *Entity = GI->second;
3545 Asm->OutStreamer.AddComment("DIE offset");
3546 Asm->EmitInt32(Entity->getOffset());
3548 if (Asm->isVerbose())
3549 Asm->OutStreamer.AddComment("External Name");
3550 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3553 Asm->OutStreamer.AddComment("End Mark");
3555 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3560 void DwarfDebug::emitDebugPubTypes() {
3561 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3562 E = CUMap.end(); I != E; ++I) {
3563 CompileUnit *TheCU = I->second;
3564 // Start the dwarf pubnames section.
3565 Asm->OutStreamer.SwitchSection(
3566 Asm->getObjFileLowering().getDwarfPubTypesSection());
3567 Asm->OutStreamer.AddComment("Length of Public Types Info");
3568 Asm->EmitLabelDifference(
3569 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3570 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3572 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3575 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3576 Asm->EmitInt16(dwarf::DWARF_VERSION);
3578 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3579 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3580 DwarfInfoSectionSym);
3582 Asm->OutStreamer.AddComment("Compilation Unit Length");
3583 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3584 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3587 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3588 for (StringMap<DIE*>::const_iterator
3589 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3590 const char *Name = GI->getKeyData();
3591 DIE * Entity = GI->second;
3593 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3594 Asm->EmitInt32(Entity->getOffset());
3596 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3597 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3600 Asm->OutStreamer.AddComment("End Mark");
3602 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3607 /// emitDebugStr - Emit visible names into a debug str section.
3609 void DwarfDebug::emitDebugStr() {
3610 // Check to see if it is worth the effort.
3611 if (StringPool.empty()) return;
3613 // Start the dwarf str section.
3614 Asm->OutStreamer.SwitchSection(
3615 Asm->getObjFileLowering().getDwarfStrSection());
3617 // Get all of the string pool entries and put them in an array by their ID so
3618 // we can sort them.
3619 SmallVector<std::pair<unsigned,
3620 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3622 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3623 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3624 Entries.push_back(std::make_pair(I->second.second, &*I));
3626 array_pod_sort(Entries.begin(), Entries.end());
3628 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3629 // Emit a label for reference from debug information entries.
3630 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3632 // Emit the string itself.
3633 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3637 /// emitDebugLoc - Emit visible names into a debug loc section.
3639 void DwarfDebug::emitDebugLoc() {
3640 if (DotDebugLocEntries.empty())
3643 // Start the dwarf loc section.
3644 Asm->OutStreamer.SwitchSection(
3645 Asm->getObjFileLowering().getDwarfLocSection());
3646 unsigned char Size = Asm->getTargetData().getPointerSize();
3647 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3649 for (SmallVector<DotDebugLocEntry, 4>::iterator
3650 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3651 I != E; ++I, ++index) {
3652 DotDebugLocEntry Entry = *I;
3653 if (Entry.isEmpty()) {
3654 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3655 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3656 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3658 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3659 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3660 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3661 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3662 if (int Offset = Entry.Loc.getOffset()) {
3663 // If the value is at a certain offset from frame register then
3665 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3666 Asm->OutStreamer.AddComment("Loc expr size");
3667 Asm->EmitInt16(1 + OffsetSize);
3668 Asm->OutStreamer.AddComment(
3669 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3670 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3671 Asm->OutStreamer.AddComment("Offset");
3672 Asm->EmitSLEB128(Offset);
3675 Asm->OutStreamer.AddComment("Loc expr size");
3677 Asm->OutStreamer.AddComment(
3678 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3679 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3681 Asm->OutStreamer.AddComment("Loc expr size");
3682 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3683 Asm->EmitInt8(dwarf::DW_OP_regx);
3684 Asm->EmitULEB128(Reg);
3691 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3693 void DwarfDebug::EmitDebugARanges() {
3694 // Start the dwarf aranges section.
3695 Asm->OutStreamer.SwitchSection(
3696 Asm->getObjFileLowering().getDwarfARangesSection());
3699 /// emitDebugRanges - Emit visible names into a debug ranges section.
3701 void DwarfDebug::emitDebugRanges() {
3702 // Start the dwarf ranges section.
3703 Asm->OutStreamer.SwitchSection(
3704 Asm->getObjFileLowering().getDwarfRangesSection());
3705 unsigned char Size = Asm->getTargetData().getPointerSize();
3706 for (SmallVector<const MCSymbol *, 8>::iterator
3707 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3710 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3712 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3716 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3718 void DwarfDebug::emitDebugMacInfo() {
3719 if (const MCSection *LineInfo =
3720 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3721 // Start the dwarf macinfo section.
3722 Asm->OutStreamer.SwitchSection(LineInfo);
3726 /// emitDebugInlineInfo - Emit inline info using following format.
3728 /// 1. length of section
3729 /// 2. Dwarf version number
3730 /// 3. address size.
3732 /// Entries (one "entry" for each function that was inlined):
3734 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3735 /// otherwise offset into __debug_str for regular function name.
3736 /// 2. offset into __debug_str section for regular function name.
3737 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3738 /// instances for the function.
3740 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3741 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3742 /// __debug_info section, and the low_pc is the starting address for the
3743 /// inlining instance.
3744 void DwarfDebug::emitDebugInlineInfo() {
3745 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3751 Asm->OutStreamer.SwitchSection(
3752 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3754 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3755 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3756 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3758 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3760 Asm->OutStreamer.AddComment("Dwarf Version");
3761 Asm->EmitInt16(dwarf::DWARF_VERSION);
3762 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3763 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3765 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3766 E = InlinedSPNodes.end(); I != E; ++I) {
3768 const MDNode *Node = *I;
3769 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3770 = InlineInfo.find(Node);
3771 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3772 DISubprogram SP(Node);
3773 StringRef LName = SP.getLinkageName();
3774 StringRef Name = SP.getName();
3776 Asm->OutStreamer.AddComment("MIPS linkage name");
3777 if (LName.empty()) {
3778 Asm->OutStreamer.EmitBytes(Name, 0);
3779 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3781 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3782 DwarfStrSectionSym);
3784 Asm->OutStreamer.AddComment("Function name");
3785 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3786 Asm->EmitULEB128(Labels.size(), "Inline count");
3788 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3789 LE = Labels.end(); LI != LE; ++LI) {
3790 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3791 Asm->EmitInt32(LI->second->getOffset());
3793 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3794 Asm->OutStreamer.EmitSymbolValue(LI->first,
3795 Asm->getTargetData().getPointerSize(),0);
3799 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));