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 FunctionBeginSym = FunctionEndSym = 0;
392 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
394 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
398 DwarfDebug::~DwarfDebug() {
399 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
400 DIEBlocks[j]->~DIEBlock();
403 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
404 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
405 if (Entry.first) return Entry.first;
407 Entry.second = NextStringPoolNumber++;
408 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
412 /// assignAbbrevNumber - Define a unique number for the abbreviation.
414 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
415 // Profile the node so that we can make it unique.
419 // Check the set for priors.
420 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
422 // If it's newly added.
423 if (InSet == &Abbrev) {
424 // Add to abbreviation list.
425 Abbreviations.push_back(&Abbrev);
427 // Assign the vector position + 1 as its number.
428 Abbrev.setNumber(Abbreviations.size());
430 // Assign existing abbreviation number.
431 Abbrev.setNumber(InSet->getNumber());
435 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
436 /// information entry.
437 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
438 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
442 /// addUInt - Add an unsigned integer attribute data and value.
444 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
445 unsigned Form, uint64_t Integer) {
446 if (!Form) Form = DIEInteger::BestForm(false, Integer);
447 DIEValue *Value = Integer == 1 ?
448 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
449 Die->addValue(Attribute, Form, Value);
452 /// addSInt - Add an signed integer attribute data and value.
454 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
455 unsigned Form, int64_t Integer) {
456 if (!Form) Form = DIEInteger::BestForm(true, Integer);
457 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
458 Die->addValue(Attribute, Form, Value);
461 /// addString - Add a string attribute data and value. DIEString only
462 /// keeps string reference.
463 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
465 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
466 Die->addValue(Attribute, Form, Value);
469 /// addLabel - Add a Dwarf label attribute data and value.
471 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
472 const MCSymbol *Label) {
473 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
474 Die->addValue(Attribute, Form, Value);
477 /// addDelta - Add a label delta attribute data and value.
479 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
480 const MCSymbol *Hi, const MCSymbol *Lo) {
481 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
482 Die->addValue(Attribute, Form, Value);
485 /// addDIEEntry - Add a DIE attribute data and value.
487 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
489 Die->addValue(Attribute, Form, createDIEEntry(Entry));
493 /// addBlock - Add block data.
495 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
497 Block->ComputeSize(Asm);
498 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
499 Die->addValue(Attribute, Block->BestForm(), Block);
502 /// addSourceLine - Add location information to specified debug information
504 void DwarfDebug::addSourceLine(DIE *Die, DIVariable V) {
509 unsigned Line = V.getLineNumber();
510 unsigned FileID = GetOrCreateSourceID(V.getContext().getDirectory(),
511 V.getContext().getFilename());
512 assert(FileID && "Invalid file id");
513 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
514 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
517 /// addSourceLine - Add location information to specified debug information
519 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
520 // Verify global variable.
524 unsigned Line = G.getLineNumber();
525 unsigned FileID = GetOrCreateSourceID(G.getContext().getDirectory(),
526 G.getContext().getFilename());
527 assert(FileID && "Invalid file id");
528 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
529 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
532 /// addSourceLine - Add location information to specified debug information
534 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
535 // Verify subprogram.
538 // If the line number is 0, don't add it.
539 if (SP.getLineNumber() == 0)
542 unsigned Line = SP.getLineNumber();
543 if (!SP.getContext().Verify())
545 unsigned FileID = GetOrCreateSourceID(SP.getDirectory(),
547 assert(FileID && "Invalid file id");
548 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
549 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
552 /// addSourceLine - Add location information to specified debug information
554 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
559 unsigned Line = Ty.getLineNumber();
560 if (!Ty.getContext().Verify())
562 unsigned FileID = GetOrCreateSourceID(Ty.getContext().getDirectory(),
563 Ty.getContext().getFilename());
564 assert(FileID && "Invalid file id");
565 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
566 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
569 /// addSourceLine - Add location information to specified debug information
571 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
576 unsigned Line = NS.getLineNumber();
577 StringRef FN = NS.getFilename();
578 StringRef Dir = NS.getDirectory();
580 unsigned FileID = GetOrCreateSourceID(Dir, FN);
581 assert(FileID && "Invalid file id");
582 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
583 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
586 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based
587 /// on provided frame index.
588 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) {
589 MachineLocation Location;
591 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
592 int Offset = RI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
593 Location.set(FrameReg, Offset);
595 if (DV->variableHasComplexAddress())
596 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
597 else if (DV->isBlockByrefVariable())
598 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
600 addAddress(Die, dwarf::DW_AT_location, Location);
603 /// addComplexAddress - Start with the address based on the location provided,
604 /// and generate the DWARF information necessary to find the actual variable
605 /// given the extra address information encoded in the DIVariable, starting from
606 /// the starting location. Add the DWARF information to the die.
608 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
610 const MachineLocation &Location) {
611 DIType Ty = DV->getType();
613 // Decode the original location, and use that as the start of the byref
614 // variable's location.
615 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
616 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
617 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
619 if (Location.isReg()) {
621 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
623 Reg = Reg - dwarf::DW_OP_reg0;
624 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
625 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
629 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
631 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
632 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
635 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
638 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
639 uint64_t Element = DV->getAddrElement(i);
641 if (Element == DIFactory::OpPlus) {
642 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
643 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
644 } else if (Element == DIFactory::OpDeref) {
645 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
646 } else llvm_unreachable("unknown DIFactory Opcode");
649 // Now attach the location information to the DIE.
650 addBlock(Die, Attribute, 0, Block);
653 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
654 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
655 gives the variable VarName either the struct, or a pointer to the struct, as
656 its type. This is necessary for various behind-the-scenes things the
657 compiler needs to do with by-reference variables in Blocks.
659 However, as far as the original *programmer* is concerned, the variable
660 should still have type 'SomeType', as originally declared.
662 The function getBlockByrefType dives into the __Block_byref_x_VarName
663 struct to find the original type of the variable, which is then assigned to
664 the variable's Debug Information Entry as its real type. So far, so good.
665 However now the debugger will expect the variable VarName to have the type
666 SomeType. So we need the location attribute for the variable to be an
667 expression that explains to the debugger how to navigate through the
668 pointers and struct to find the actual variable of type SomeType.
670 The following function does just that. We start by getting
671 the "normal" location for the variable. This will be the location
672 of either the struct __Block_byref_x_VarName or the pointer to the
673 struct __Block_byref_x_VarName.
675 The struct will look something like:
677 struct __Block_byref_x_VarName {
679 struct __Block_byref_x_VarName *forwarding;
680 ... <various other fields>
682 ... <maybe more fields>
685 If we are given the struct directly (as our starting point) we
686 need to tell the debugger to:
688 1). Add the offset of the forwarding field.
690 2). Follow that pointer to get the real __Block_byref_x_VarName
691 struct to use (the real one may have been copied onto the heap).
693 3). Add the offset for the field VarName, to find the actual variable.
695 If we started with a pointer to the struct, then we need to
696 dereference that pointer first, before the other steps.
697 Translating this into DWARF ops, we will need to append the following
698 to the current location description for the variable:
700 DW_OP_deref -- optional, if we start with a pointer
701 DW_OP_plus_uconst <forward_fld_offset>
703 DW_OP_plus_uconst <varName_fld_offset>
705 That is what this function does. */
707 /// addBlockByrefAddress - Start with the address based on the location
708 /// provided, and generate the DWARF information necessary to find the
709 /// actual Block variable (navigating the Block struct) based on the
710 /// starting location. Add the DWARF information to the die. For
711 /// more information, read large comment just above here.
713 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
715 const MachineLocation &Location) {
716 DIType Ty = DV->getType();
718 unsigned Tag = Ty.getTag();
719 bool isPointer = false;
721 StringRef varName = DV->getName();
723 if (Tag == dwarf::DW_TAG_pointer_type) {
724 DIDerivedType DTy = DIDerivedType(Ty);
725 TmpTy = DTy.getTypeDerivedFrom();
729 DICompositeType blockStruct = DICompositeType(TmpTy);
731 // Find the __forwarding field and the variable field in the __Block_byref
733 DIArray Fields = blockStruct.getTypeArray();
734 DIDescriptor varField = DIDescriptor();
735 DIDescriptor forwardingField = DIDescriptor();
737 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
738 DIDescriptor Element = Fields.getElement(i);
739 DIDerivedType DT = DIDerivedType(Element);
740 StringRef fieldName = DT.getName();
741 if (fieldName == "__forwarding")
742 forwardingField = Element;
743 else if (fieldName == varName)
747 // Get the offsets for the forwarding field and the variable field.
748 unsigned forwardingFieldOffset =
749 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
750 unsigned varFieldOffset =
751 DIDerivedType(varField).getOffsetInBits() >> 3;
753 // Decode the original location, and use that as the start of the byref
754 // variable's location.
755 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
756 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
757 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
759 if (Location.isReg()) {
761 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
763 Reg = Reg - dwarf::DW_OP_reg0;
764 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
765 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
769 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
771 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
772 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
775 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
778 // If we started with a pointer to the __Block_byref... struct, then
779 // the first thing we need to do is dereference the pointer (DW_OP_deref).
781 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
783 // Next add the offset for the '__forwarding' field:
784 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
785 // adding the offset if it's 0.
786 if (forwardingFieldOffset > 0) {
787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
788 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
791 // Now dereference the __forwarding field to get to the real __Block_byref
792 // struct: DW_OP_deref.
793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
795 // Now that we've got the real __Block_byref... struct, add the offset
796 // for the variable's field to get to the location of the actual variable:
797 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
798 if (varFieldOffset > 0) {
799 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
800 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
803 // Now attach the location information to the DIE.
804 addBlock(Die, Attribute, 0, Block);
807 /// addAddress - Add an address attribute to a die based on the location
809 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
810 const MachineLocation &Location) {
811 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
812 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
813 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
815 if (Location.isReg()) {
817 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
819 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
820 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
824 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
826 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
827 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
830 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
833 addBlock(Die, Attribute, 0, Block);
836 /// addRegisterAddress - Add register location entry in variable DIE.
837 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
838 const MachineOperand &MO) {
839 assert (MO.isReg() && "Invalid machine operand!");
842 MachineLocation Location;
843 Location.set(MO.getReg());
844 addAddress(Die, dwarf::DW_AT_location, Location);
846 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
850 /// addConstantValue - Add constant value entry in variable DIE.
851 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
852 const MachineOperand &MO) {
853 assert (MO.isImm() && "Invalid machine operand!");
854 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
855 unsigned Imm = MO.getImm();
856 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
857 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
859 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
863 /// addConstantFPValue - Add constant value entry in variable DIE.
864 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
865 const MachineOperand &MO) {
866 assert (MO.isFPImm() && "Invalid machine operand!");
867 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
868 APFloat FPImm = MO.getFPImm()->getValueAPF();
870 // Get the raw data form of the floating point.
871 const APInt FltVal = FPImm.bitcastToAPInt();
872 const char *FltPtr = (const char*)FltVal.getRawData();
874 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
875 bool LittleEndian = Asm->getTargetData().isLittleEndian();
876 int Incr = (LittleEndian ? 1 : -1);
877 int Start = (LittleEndian ? 0 : NumBytes - 1);
878 int Stop = (LittleEndian ? NumBytes : -1);
880 // Output the constant to DWARF one byte at a time.
881 for (; Start != Stop; Start += Incr)
882 addUInt(Block, 0, dwarf::DW_FORM_data1,
883 (unsigned char)0xFF & FltPtr[Start]);
885 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
887 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
892 /// addToContextOwner - Add Die into the list of its context owner's children.
893 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
894 if (Context.isType()) {
895 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
896 ContextDIE->addChild(Die);
897 } else if (Context.isNameSpace()) {
898 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
899 ContextDIE->addChild(Die);
900 } else if (Context.isSubprogram()) {
901 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
903 ContextDIE->addChild(Die);
904 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
905 ContextDIE->addChild(Die);
907 getCompileUnit(Context)->addDie(Die);
910 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
912 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
913 CompileUnit *TypeCU = getCompileUnit(Ty);
914 DIE *TyDIE = TypeCU->getDIE(Ty);
919 TyDIE = new DIE(dwarf::DW_TAG_base_type);
920 TypeCU->insertDIE(Ty, TyDIE);
921 if (Ty.isBasicType())
922 constructTypeDIE(*TyDIE, DIBasicType(Ty));
923 else if (Ty.isCompositeType())
924 constructTypeDIE(*TyDIE, DICompositeType(Ty));
926 assert(Ty.isDerivedType() && "Unknown kind of DIType");
927 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
930 addToContextOwner(TyDIE, Ty.getContext());
934 /// addType - Add a new type attribute to the specified entity.
935 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
939 // Check for pre-existence.
940 CompileUnit *TypeCU = getCompileUnit(Ty);
941 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
942 // If it exists then use the existing value.
944 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
949 DIE *Buffer = getOrCreateTypeDIE(Ty);
952 Entry = createDIEEntry(Buffer);
953 TypeCU->insertDIEEntry(Ty, Entry);
955 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
958 /// constructTypeDIE - Construct basic type die from DIBasicType.
959 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
960 // Get core information.
961 StringRef Name = BTy.getName();
962 Buffer.setTag(dwarf::DW_TAG_base_type);
963 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
966 // Add name if not anonymous or intermediate type.
968 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
969 uint64_t Size = BTy.getSizeInBits() >> 3;
970 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
973 /// constructTypeDIE - Construct derived type die from DIDerivedType.
974 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
975 // Get core information.
976 StringRef Name = DTy.getName();
977 uint64_t Size = DTy.getSizeInBits() >> 3;
978 unsigned Tag = DTy.getTag();
980 // FIXME - Workaround for templates.
981 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
985 // Map to main type, void will not have a type.
986 DIType FromTy = DTy.getTypeDerivedFrom();
987 addType(&Buffer, FromTy);
989 // Add name if not anonymous or intermediate type.
991 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
993 // Add size if non-zero (derived types might be zero-sized.)
995 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
997 // Add source line info if available and TyDesc is not a forward declaration.
998 if (!DTy.isForwardDecl())
999 addSourceLine(&Buffer, DTy);
1002 /// constructTypeDIE - Construct type DIE from DICompositeType.
1003 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1004 // Get core information.
1005 StringRef Name = CTy.getName();
1007 uint64_t Size = CTy.getSizeInBits() >> 3;
1008 unsigned Tag = CTy.getTag();
1012 case dwarf::DW_TAG_vector_type:
1013 case dwarf::DW_TAG_array_type:
1014 constructArrayTypeDIE(Buffer, &CTy);
1016 case dwarf::DW_TAG_enumeration_type: {
1017 DIArray Elements = CTy.getTypeArray();
1019 // Add enumerators to enumeration type.
1020 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1021 DIE *ElemDie = NULL;
1022 DIDescriptor Enum(Elements.getElement(i));
1023 if (Enum.isEnumerator()) {
1024 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1025 Buffer.addChild(ElemDie);
1030 case dwarf::DW_TAG_subroutine_type: {
1032 DIArray Elements = CTy.getTypeArray();
1033 DIDescriptor RTy = Elements.getElement(0);
1034 addType(&Buffer, DIType(RTy));
1036 // Add prototype flag.
1037 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1040 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1041 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1042 DIDescriptor Ty = Elements.getElement(i);
1043 addType(Arg, DIType(Ty));
1044 Buffer.addChild(Arg);
1048 case dwarf::DW_TAG_structure_type:
1049 case dwarf::DW_TAG_union_type:
1050 case dwarf::DW_TAG_class_type: {
1051 // Add elements to structure type.
1052 DIArray Elements = CTy.getTypeArray();
1054 // A forward struct declared type may not have elements available.
1055 unsigned N = Elements.getNumElements();
1059 // Add elements to structure type.
1060 for (unsigned i = 0; i < N; ++i) {
1061 DIDescriptor Element = Elements.getElement(i);
1062 DIE *ElemDie = NULL;
1063 if (Element.isSubprogram())
1064 ElemDie = createSubprogramDIE(DISubprogram(Element));
1065 else if (Element.isVariable()) {
1066 DIVariable DV(Element);
1067 ElemDie = new DIE(dwarf::DW_TAG_variable);
1068 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1070 addType(ElemDie, DV.getType());
1071 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1072 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1073 addSourceLine(ElemDie, DV);
1074 } else if (Element.isDerivedType())
1075 ElemDie = createMemberDIE(DIDerivedType(Element));
1078 Buffer.addChild(ElemDie);
1081 if (CTy.isAppleBlockExtension())
1082 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1084 unsigned RLang = CTy.getRunTimeLang();
1086 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1087 dwarf::DW_FORM_data1, RLang);
1089 DICompositeType ContainingType = CTy.getContainingType();
1090 if (DIDescriptor(ContainingType).isCompositeType())
1091 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1092 getOrCreateTypeDIE(DIType(ContainingType)));
1094 DIDescriptor Context = CTy.getContext();
1095 addToContextOwner(&Buffer, Context);
1103 // Add name if not anonymous or intermediate type.
1105 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1107 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1108 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1110 // Add size if non-zero (derived types might be zero-sized.)
1112 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1114 // Add zero size if it is not a forward declaration.
1115 if (CTy.isForwardDecl())
1116 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1118 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1121 // Add source line info if available.
1122 if (!CTy.isForwardDecl())
1123 addSourceLine(&Buffer, CTy);
1127 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1128 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1129 int64_t L = SR.getLo();
1130 int64_t H = SR.getHi();
1131 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1133 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1135 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1136 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1138 Buffer.addChild(DW_Subrange);
1141 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1142 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1143 DICompositeType *CTy) {
1144 Buffer.setTag(dwarf::DW_TAG_array_type);
1145 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1146 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1148 // Emit derived type.
1149 addType(&Buffer, CTy->getTypeDerivedFrom());
1150 DIArray Elements = CTy->getTypeArray();
1152 // Get an anonymous type for index type.
1153 CompileUnit *TheCU = getCompileUnit(*CTy);
1154 DIE *IdxTy = TheCU->getIndexTyDie();
1156 // Construct an anonymous type for index type.
1157 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1158 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1159 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1160 dwarf::DW_ATE_signed);
1161 TheCU->addDie(IdxTy);
1162 TheCU->setIndexTyDie(IdxTy);
1165 // Add subranges to array type.
1166 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1167 DIDescriptor Element = Elements.getElement(i);
1168 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1169 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1173 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1174 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1175 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1176 StringRef Name = ETy.getName();
1177 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1178 int64_t Value = ETy.getEnumValue();
1179 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1183 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1184 /// printer to not emit usual symbol prefix before the symbol name is used then
1185 /// return linkage name after skipping this special LLVM prefix.
1186 static StringRef getRealLinkageName(StringRef LinkageName) {
1188 if (LinkageName.startswith(StringRef(&One, 1)))
1189 return LinkageName.substr(1);
1193 /// createMemberDIE - Create new member DIE.
1194 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1195 DIE *MemberDie = new DIE(DT.getTag());
1196 StringRef Name = DT.getName();
1198 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1200 addType(MemberDie, DT.getTypeDerivedFrom());
1202 addSourceLine(MemberDie, DT);
1204 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1205 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1207 uint64_t Size = DT.getSizeInBits();
1208 uint64_t FieldSize = DT.getOriginalTypeSize();
1210 if (Size != FieldSize) {
1212 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1213 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1215 uint64_t Offset = DT.getOffsetInBits();
1216 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1217 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1218 uint64_t FieldOffset = (HiMark - FieldSize);
1219 Offset -= FieldOffset;
1221 // Maybe we need to work from the other end.
1222 if (Asm->getTargetData().isLittleEndian())
1223 Offset = FieldSize - (Offset + Size);
1224 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1226 // Here WD_AT_data_member_location points to the anonymous
1227 // field that includes this bit field.
1228 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1231 // This is not a bitfield.
1232 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1234 if (DT.getTag() == dwarf::DW_TAG_inheritance
1235 && DT.isVirtual()) {
1237 // For C++, virtual base classes are not at fixed offset. Use following
1238 // expression to extract appropriate offset from vtable.
1239 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1241 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1242 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1243 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1244 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1245 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1246 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1247 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1248 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1250 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1253 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1255 if (DT.isProtected())
1256 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1257 dwarf::DW_ACCESS_protected);
1258 else if (DT.isPrivate())
1259 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1260 dwarf::DW_ACCESS_private);
1261 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1262 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1263 dwarf::DW_ACCESS_public);
1265 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1266 dwarf::DW_VIRTUALITY_virtual);
1270 /// createSubprogramDIE - Create new DIE using SP.
1271 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP, bool MakeDecl) {
1272 CompileUnit *SPCU = getCompileUnit(SP);
1273 DIE *SPDie = SPCU->getDIE(SP);
1277 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1278 // Constructors and operators for anonymous aggregates do not have names.
1279 if (!SP.getName().empty())
1280 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1282 StringRef LinkageName = SP.getLinkageName();
1283 if (!LinkageName.empty())
1284 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1285 getRealLinkageName(LinkageName));
1287 addSourceLine(SPDie, SP);
1289 // Add prototyped tag, if C or ObjC.
1290 unsigned Lang = SP.getCompileUnit().getLanguage();
1291 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1292 Lang == dwarf::DW_LANG_ObjC)
1293 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1296 DICompositeType SPTy = SP.getType();
1297 DIArray Args = SPTy.getTypeArray();
1298 unsigned SPTag = SPTy.getTag();
1300 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1301 addType(SPDie, SPTy);
1303 addType(SPDie, DIType(Args.getElement(0)));
1305 unsigned VK = SP.getVirtuality();
1307 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1308 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1309 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1310 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1311 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1312 ContainingTypeMap.insert(std::make_pair(SPDie,
1313 SP.getContainingType()));
1316 if (MakeDecl || !SP.isDefinition()) {
1317 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1319 // Add arguments. Do not add arguments for subprogram definition. They will
1320 // be handled while processing variables.
1321 DICompositeType SPTy = SP.getType();
1322 DIArray Args = SPTy.getTypeArray();
1323 unsigned SPTag = SPTy.getTag();
1325 if (SPTag == dwarf::DW_TAG_subroutine_type)
1326 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1327 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1328 DIType ATy = DIType(DIType(Args.getElement(i)));
1330 if (ATy.isArtificial())
1331 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1332 SPDie->addChild(Arg);
1336 if (SP.isArtificial())
1337 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1339 if (!SP.isLocalToUnit())
1340 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1342 if (SP.isOptimized())
1343 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1345 if (unsigned isa = Asm->getISAEncoding()) {
1346 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1349 // DW_TAG_inlined_subroutine may refer to this DIE.
1350 SPCU->insertDIE(SP, SPDie);
1352 // Add to context owner.
1353 addToContextOwner(SPDie, SP.getContext());
1358 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1359 assert(N && "Invalid Scope encoding!");
1361 DbgScope *AScope = AbstractScopes.lookup(N);
1365 DbgScope *Parent = NULL;
1367 DIDescriptor Scope(N);
1368 if (Scope.isLexicalBlock()) {
1369 DILexicalBlock DB(N);
1370 DIDescriptor ParentDesc = DB.getContext();
1371 Parent = getOrCreateAbstractScope(ParentDesc);
1374 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1377 Parent->addScope(AScope);
1378 AScope->setAbstractScope();
1379 AbstractScopes[N] = AScope;
1380 if (DIDescriptor(N).isSubprogram())
1381 AbstractScopesList.push_back(AScope);
1385 /// isSubprogramContext - Return true if Context is either a subprogram
1386 /// or another context nested inside a subprogram.
1387 static bool isSubprogramContext(const MDNode *Context) {
1390 DIDescriptor D(Context);
1391 if (D.isSubprogram())
1394 return isSubprogramContext(DIType(Context).getContext());
1398 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1399 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1400 /// If there are global variables in this scope then create and insert
1401 /// DIEs for these variables.
1402 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1403 CompileUnit *SPCU = getCompileUnit(SPNode);
1404 DIE *SPDie = SPCU->getDIE(SPNode);
1406 assert(SPDie && "Unable to find subprogram DIE!");
1407 DISubprogram SP(SPNode);
1409 // There is not any need to generate specification DIE for a function
1410 // defined at compile unit level. If a function is defined inside another
1411 // function then gdb prefers the definition at top level and but does not
1412 // expect specification DIE in parent function. So avoid creating
1413 // specification DIE for a function defined inside a function.
1414 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1415 !SP.getContext().isFile() &&
1416 !isSubprogramContext(SP.getContext())) {
1417 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1420 DICompositeType SPTy = SP.getType();
1421 DIArray Args = SPTy.getTypeArray();
1422 unsigned SPTag = SPTy.getTag();
1423 if (SPTag == dwarf::DW_TAG_subroutine_type)
1424 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1425 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1426 DIType ATy = DIType(DIType(Args.getElement(i)));
1428 if (ATy.isArtificial())
1429 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1430 SPDie->addChild(Arg);
1432 DIE *SPDeclDie = SPDie;
1433 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1434 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1436 SPCU->addDie(SPDie);
1439 // Pick up abstract subprogram DIE.
1440 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1441 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1442 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1443 dwarf::DW_FORM_ref4, AbsSPDIE);
1444 SPCU->addDie(SPDie);
1447 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1448 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1449 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1450 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1451 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1452 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1453 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1458 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1459 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1460 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1462 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1463 if (Scope->isAbstractScope())
1466 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1470 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1471 if (Ranges.size() > 1) {
1472 // .debug_range section has not been laid out yet. Emit offset in
1473 // .debug_range as a uint, size 4, for now. emitDIE will handle
1474 // DW_AT_ranges appropriately.
1475 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1476 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1477 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1478 RE = Ranges.end(); RI != RE; ++RI) {
1479 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1480 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1482 DebugRangeSymbols.push_back(NULL);
1483 DebugRangeSymbols.push_back(NULL);
1487 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1488 const MCSymbol *End = getLabelAfterInsn(RI->second);
1490 if (End == 0) return 0;
1492 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1493 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1495 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1496 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1501 /// constructInlinedScopeDIE - This scope represents inlined body of
1502 /// a function. Construct DIE to represent this concrete inlined copy
1503 /// of the function.
1504 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1506 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1507 assert (Ranges.empty() == false
1508 && "DbgScope does not have instruction markers!");
1510 // FIXME : .debug_inlined section specification does not clearly state how
1511 // to emit inlined scope that is split into multiple instruction ranges.
1512 // For now, use first instruction range and emit low_pc/high_pc pair and
1513 // corresponding .debug_inlined section entry for this pair.
1514 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1515 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1516 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1518 if (StartLabel == 0 || EndLabel == 0) {
1519 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1522 assert(StartLabel->isDefined() &&
1523 "Invalid starting label for an inlined scope!");
1524 assert(EndLabel->isDefined() &&
1525 "Invalid end label for an inlined scope!");
1527 if (!Scope->getScopeNode())
1529 DIScope DS(Scope->getScopeNode());
1530 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1532 DISubprogram InlinedSP = getDISubprogram(DS);
1533 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1534 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1535 assert(OriginDIE && "Unable to find Origin DIE!");
1536 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1537 dwarf::DW_FORM_ref4, OriginDIE);
1539 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1540 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1542 InlinedSubprogramDIEs.insert(OriginDIE);
1544 // Track the start label for this inlined function.
1545 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1546 I = InlineInfo.find(InlinedSP);
1548 if (I == InlineInfo.end()) {
1549 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1551 InlinedSPNodes.push_back(InlinedSP);
1553 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1555 DILocation DL(Scope->getInlinedAt());
1556 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1557 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1563 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1564 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1565 StringRef Name = DV->getName();
1569 // Translate tag to proper Dwarf tag. The result variable is dropped for
1572 switch (DV->getTag()) {
1573 case dwarf::DW_TAG_return_variable:
1575 case dwarf::DW_TAG_arg_variable:
1576 Tag = dwarf::DW_TAG_formal_parameter;
1578 case dwarf::DW_TAG_auto_variable: // fall thru
1580 Tag = dwarf::DW_TAG_variable;
1584 // Define variable debug information entry.
1585 DIE *VariableDie = new DIE(Tag);
1588 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1589 V2AVI = VarToAbstractVarMap.find(DV);
1590 if (V2AVI != VarToAbstractVarMap.end())
1591 AbsDIE = V2AVI->second->getDIE();
1594 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1595 dwarf::DW_FORM_ref4, AbsDIE);
1597 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1598 addSourceLine(VariableDie, DV->getVariable());
1600 // Add variable type.
1601 addType(VariableDie, DV->getType());
1604 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1605 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1607 if (Scope->isAbstractScope()) {
1608 DV->setDIE(VariableDie);
1612 // Add variable address.
1614 unsigned Offset = DV->getDotDebugLocOffset();
1615 if (Offset != ~0U) {
1616 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1617 Asm->GetTempSymbol("debug_loc", Offset));
1618 DV->setDIE(VariableDie);
1619 UseDotDebugLocEntry.insert(VariableDie);
1623 // Check if variable is described by a DBG_VALUE instruction.
1624 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1625 DbgVariableToDbgInstMap.find(DV);
1626 if (DVI != DbgVariableToDbgInstMap.end()) {
1627 const MachineInstr *DVInsn = DVI->second;
1628 const MCSymbol *DVLabel = findVariableLabel(DV);
1629 bool updated = false;
1630 // FIXME : Handle getNumOperands != 3
1631 if (DVInsn->getNumOperands() == 3) {
1632 if (DVInsn->getOperand(0).isReg()) {
1633 const MachineOperand RegOp = DVInsn->getOperand(0);
1634 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1635 if (DVInsn->getOperand(1).isImm() &&
1636 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1637 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1640 updated = addRegisterAddress(VariableDie, DVLabel, RegOp);
1642 else if (DVInsn->getOperand(0).isImm())
1643 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1644 else if (DVInsn->getOperand(0).isFPImm())
1646 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1648 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1649 if (Location.getReg()) {
1650 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1652 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1658 // If variableDie is not updated then DBG_VALUE instruction does not
1659 // have valid variable info.
1663 DV->setDIE(VariableDie);
1667 // .. else use frame index, if available.
1669 if (findVariableFrameIndex(DV, &FI))
1670 addVariableAddress(DV, VariableDie, FI);
1672 DV->setDIE(VariableDie);
1677 void DwarfDebug::addPubTypes(DISubprogram SP) {
1678 DICompositeType SPTy = SP.getType();
1679 unsigned SPTag = SPTy.getTag();
1680 if (SPTag != dwarf::DW_TAG_subroutine_type)
1683 DIArray Args = SPTy.getTypeArray();
1684 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1685 DIType ATy(Args.getElement(i));
1688 DICompositeType CATy = getDICompositeType(ATy);
1689 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1690 && !CATy.isForwardDecl()) {
1691 CompileUnit *TheCU = getCompileUnit(CATy);
1692 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1693 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1698 /// constructScopeDIE - Construct a DIE for this scope.
1699 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1700 if (!Scope || !Scope->getScopeNode())
1703 DIScope DS(Scope->getScopeNode());
1704 DIE *ScopeDIE = NULL;
1705 if (Scope->getInlinedAt())
1706 ScopeDIE = constructInlinedScopeDIE(Scope);
1707 else if (DS.isSubprogram()) {
1708 ProcessedSPNodes.insert(DS);
1709 if (Scope->isAbstractScope()) {
1710 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1711 // Note down abstract DIE.
1713 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1716 ScopeDIE = updateSubprogramScopeDIE(DS);
1719 ScopeDIE = constructLexicalScopeDIE(Scope);
1720 if (!ScopeDIE) return NULL;
1722 // Add variables to scope.
1723 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1724 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1725 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1727 ScopeDIE->addChild(VariableDIE);
1730 // Add nested scopes.
1731 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1732 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1733 // Define the Scope debug information entry.
1734 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1736 ScopeDIE->addChild(NestedDIE);
1739 if (DS.isSubprogram())
1740 addPubTypes(DISubprogram(DS));
1745 /// GetOrCreateSourceID - Look up the source id with the given directory and
1746 /// source file names. If none currently exists, create a new id and insert it
1747 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1749 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1751 assert (DirName.empty() == false && "Invalid directory name!");
1753 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1754 if (DI != DirectoryIdMap.end()) {
1755 DId = DI->getValue();
1757 DId = DirectoryNames.size() + 1;
1758 DirectoryIdMap[DirName] = DId;
1759 DirectoryNames.push_back(DirName);
1763 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1764 if (FI != SourceFileIdMap.end()) {
1765 FId = FI->getValue();
1767 FId = SourceFileNames.size() + 1;
1768 SourceFileIdMap[FileName] = FId;
1769 SourceFileNames.push_back(FileName);
1772 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1773 SourceIdMap.find(std::make_pair(DId, FId));
1774 if (SI != SourceIdMap.end())
1777 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1778 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1779 SourceIds.push_back(std::make_pair(DId, FId));
1784 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1785 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1786 CompileUnit *TheCU = getCompileUnit(NS);
1787 DIE *NDie = TheCU->getDIE(NS);
1790 NDie = new DIE(dwarf::DW_TAG_namespace);
1791 TheCU->insertDIE(NS, NDie);
1792 if (!NS.getName().empty())
1793 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1794 addSourceLine(NDie, NS);
1795 addToContextOwner(NDie, NS.getContext());
1799 /// constructCompileUnit - Create new CompileUnit for the given
1800 /// metadata node with tag DW_TAG_compile_unit.
1801 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1802 DICompileUnit DIUnit(N);
1803 StringRef FN = DIUnit.getFilename();
1804 StringRef Dir = DIUnit.getDirectory();
1805 unsigned ID = GetOrCreateSourceID(Dir, FN);
1807 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1808 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1809 DIUnit.getProducer());
1810 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1811 DIUnit.getLanguage());
1812 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1813 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1814 // simplifies debug range entries.
1815 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1816 // DW_AT_stmt_list is a offset of line number information for this
1817 // compile unit in debug_line section.
1818 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1821 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1822 if (DIUnit.isOptimized())
1823 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1825 StringRef Flags = DIUnit.getFlags();
1827 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1829 unsigned RVer = DIUnit.getRunTimeVersion();
1831 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1832 dwarf::DW_FORM_data1, RVer);
1834 CompileUnit *NewCU = new CompileUnit(ID, Die);
1837 CUMap.insert(std::make_pair(N, NewCU));
1840 /// getCompielUnit - Get CompileUnit DIE.
1841 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1842 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1844 const MDNode *CUNode = NULL;
1845 if (D.isCompileUnit())
1847 else if (D.isSubprogram())
1848 CUNode = DISubprogram(N).getCompileUnit();
1849 else if (D.isType())
1850 CUNode = DIType(N).getCompileUnit();
1851 else if (D.isGlobalVariable())
1852 CUNode = DIGlobalVariable(N).getCompileUnit();
1853 else if (D.isVariable())
1854 CUNode = DIVariable(N).getCompileUnit();
1855 else if (D.isNameSpace())
1856 CUNode = DINameSpace(N).getCompileUnit();
1857 else if (D.isFile())
1858 CUNode = DIFile(N).getCompileUnit();
1862 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1863 = CUMap.find(CUNode);
1864 if (I == CUMap.end())
1869 /// isUnsignedDIType - Return true if type encoding is unsigned.
1870 static bool isUnsignedDIType(DIType Ty) {
1871 DIDerivedType DTy(Ty);
1873 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1875 DIBasicType BTy(Ty);
1877 unsigned Encoding = BTy.getEncoding();
1878 if (Encoding == dwarf::DW_ATE_unsigned ||
1879 Encoding == dwarf::DW_ATE_unsigned_char)
1885 /// constructGlobalVariableDIE - Construct global variable DIE.
1886 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1887 DIGlobalVariable GV(N);
1889 // If debug information is malformed then ignore it.
1890 if (GV.Verify() == false)
1893 // Check for pre-existence.
1894 CompileUnit *TheCU = getCompileUnit(N);
1895 if (TheCU->getDIE(GV))
1898 DIType GTy = GV.getType();
1899 DIE *VariableDIE = new DIE(GV.getTag());
1901 bool isGlobalVariable = GV.getGlobal() != NULL;
1904 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1905 GV.getDisplayName());
1906 StringRef LinkageName = GV.getLinkageName();
1907 if (!LinkageName.empty() && isGlobalVariable)
1908 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1909 getRealLinkageName(LinkageName));
1911 addType(VariableDIE, GTy);
1912 if (GTy.isCompositeType() && !GTy.getName().empty()
1913 && !GTy.isForwardDecl()) {
1914 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1915 assert(Entry && "Missing global type!");
1916 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1918 // Add scoping info.
1919 if (!GV.isLocalToUnit()) {
1920 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1921 // Expose as global.
1922 TheCU->addGlobal(GV.getName(), VariableDIE);
1924 // Add line number info.
1925 addSourceLine(VariableDIE, GV);
1927 TheCU->insertDIE(N, VariableDIE);
1928 // Add to context owner.
1929 DIDescriptor GVContext = GV.getContext();
1930 addToContextOwner(VariableDIE, GVContext);
1932 if (isGlobalVariable) {
1933 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1934 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1935 addLabel(Block, 0, dwarf::DW_FORM_udata,
1936 Asm->Mang->getSymbol(GV.getGlobal()));
1937 // Do not create specification DIE if context is either compile unit
1939 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1940 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1941 // Create specification DIE.
1942 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1943 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1944 dwarf::DW_FORM_ref4, VariableDIE);
1945 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1946 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1947 TheCU->addDie(VariableSpecDIE);
1949 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1951 } else if (Constant *C = GV.getConstant()) {
1952 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
1953 if (isUnsignedDIType(GTy))
1954 addUInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1955 CI->getZExtValue());
1957 addSInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1958 CI->getSExtValue());
1964 /// construct SubprogramDIE - Construct subprogram DIE.
1965 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1968 // Check for pre-existence.
1969 CompileUnit *TheCU = getCompileUnit(N);
1970 if (TheCU->getDIE(N))
1973 if (!SP.isDefinition())
1974 // This is a method declaration which will be handled while constructing
1978 DIE *SubprogramDie = createSubprogramDIE(SP);
1981 TheCU->insertDIE(N, SubprogramDie);
1983 // Add to context owner.
1984 addToContextOwner(SubprogramDie, SP.getContext());
1986 // Expose as global.
1987 TheCU->addGlobal(SP.getName(), SubprogramDie);
1992 /// beginModule - Emit all Dwarf sections that should come prior to the
1993 /// content. Create global DIEs and emit initial debug info sections.
1994 /// This is inovked by the target AsmPrinter.
1995 void DwarfDebug::beginModule(Module *M) {
1996 if (DisableDebugInfoPrinting)
1999 DebugInfoFinder DbgFinder;
2000 DbgFinder.processModule(*M);
2002 bool HasDebugInfo = false;
2004 // Scan all the compile-units to see if there are any marked as the main unit.
2005 // if not, we do not generate debug info.
2006 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2007 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2008 if (DICompileUnit(*I).isMain()) {
2009 HasDebugInfo = true;
2014 if (!HasDebugInfo) return;
2016 // Tell MMI that we have debug info.
2017 MMI->setDebugInfoAvailability(true);
2019 // Emit initial sections.
2020 EmitSectionLabels();
2022 // Create all the compile unit DIEs.
2023 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2024 E = DbgFinder.compile_unit_end(); I != E; ++I)
2025 constructCompileUnit(*I);
2027 // Create DIEs for each subprogram.
2028 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2029 E = DbgFinder.subprogram_end(); I != E; ++I)
2030 constructSubprogramDIE(*I);
2032 // Create DIEs for each global variable.
2033 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2034 E = DbgFinder.global_variable_end(); I != E; ++I)
2035 constructGlobalVariableDIE(*I);
2037 //getOrCreateTypeDIE
2038 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2039 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2040 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2042 // Prime section data.
2043 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2045 // Print out .file directives to specify files for .loc directives. These are
2046 // printed out early so that they precede any .loc directives.
2047 if (Asm->MAI->hasDotLocAndDotFile()) {
2048 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2049 // Remember source id starts at 1.
2050 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2051 // FIXME: don't use sys::path for this! This should not depend on the
2053 sys::Path FullPath(getSourceDirectoryName(Id.first));
2055 FullPath.appendComponent(getSourceFileName(Id.second));
2056 assert(AppendOk && "Could not append filename to directory!");
2058 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2063 /// endModule - Emit all Dwarf sections that should come after the content.
2065 void DwarfDebug::endModule() {
2066 if (!FirstCU) return;
2067 const Module *M = MMI->getModule();
2068 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2069 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2070 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2071 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2072 DISubprogram SP(AllSPs->getOperand(SI));
2073 if (!SP.Verify()) continue;
2075 // Collect info for variables that were optimized out.
2076 if (!SP.isDefinition()) continue;
2077 StringRef FName = SP.getLinkageName();
2079 FName = SP.getName();
2081 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2083 unsigned E = NMD->getNumOperands();
2085 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2086 DeadFnScopeMap[SP] = Scope;
2087 for (unsigned I = 0; I != E; ++I) {
2088 DIVariable DV(NMD->getOperand(I));
2089 if (!DV.Verify()) continue;
2090 Scope->addVariable(new DbgVariable(DV));
2093 // Construct subprogram DIE and add variables DIEs.
2094 constructSubprogramDIE(SP);
2095 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2096 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2097 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2098 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2100 ScopeDIE->addChild(VariableDIE);
2105 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2106 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2107 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2109 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2112 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2113 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2114 DIE *SPDie = CI->first;
2115 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2117 DIE *NDie = getCompileUnit(N)->getDIE(N);
2118 if (!NDie) continue;
2119 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2122 // Standard sections final addresses.
2123 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2124 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2125 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2126 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2128 // End text sections.
2129 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2130 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2131 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2134 // Emit common frame information.
2135 emitCommonDebugFrame();
2137 // Emit function debug frame information
2138 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2139 E = DebugFrames.end(); I != E; ++I)
2140 emitFunctionDebugFrame(*I);
2142 // Compute DIE offsets and sizes.
2143 computeSizeAndOffsets();
2145 // Emit all the DIEs into a debug info section
2148 // Corresponding abbreviations into a abbrev section.
2149 emitAbbreviations();
2151 // Emit source line correspondence into a debug line section.
2154 // Emit info into a debug pubnames section.
2155 emitDebugPubNames();
2157 // Emit info into a debug pubtypes section.
2158 emitDebugPubTypes();
2160 // Emit info into a debug loc section.
2163 // Emit info into a debug aranges section.
2166 // Emit info into a debug ranges section.
2169 // Emit info into a debug macinfo section.
2172 // Emit inline info.
2173 emitDebugInlineInfo();
2175 // Emit info into a debug str section.
2179 DeleteContainerSeconds(DeadFnScopeMap);
2180 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2181 E = CUMap.end(); I != E; ++I)
2183 FirstCU = NULL; // Reset for the next Module, if any.
2186 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2187 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2188 DebugLoc ScopeLoc) {
2190 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2192 return AbsDbgVariable;
2194 LLVMContext &Ctx = Var->getContext();
2195 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2199 AbsDbgVariable = new DbgVariable(Var);
2200 Scope->addVariable(AbsDbgVariable);
2201 AbstractVariables[Var] = AbsDbgVariable;
2202 return AbsDbgVariable;
2205 /// collectVariableInfoFromMMITable - Collect variable information from
2206 /// side table maintained by MMI.
2208 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2209 SmallPtrSet<const MDNode *, 16> &Processed) {
2210 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2211 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2212 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2213 VE = VMap.end(); VI != VE; ++VI) {
2214 const MDNode *Var = VI->first;
2216 Processed.insert(Var);
2218 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2220 DbgScope *Scope = 0;
2221 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2222 Scope = ConcreteScopes.lookup(IA);
2224 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2226 // If variable scope is not found then skip this variable.
2230 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2231 DbgVariable *RegVar = new DbgVariable(DV);
2232 recordVariableFrameIndex(RegVar, VP.first);
2233 Scope->addVariable(RegVar);
2234 if (AbsDbgVariable) {
2235 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2236 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2241 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2242 /// DBG_VALUE instruction, is in undefined reg.
2243 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2244 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2245 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2250 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2251 /// DBG_VALUE instruction, is in a defined reg.
2252 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2253 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2254 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2259 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2261 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2262 SmallPtrSet<const MDNode *, 16> &Processed) {
2264 /// collection info from MMI table.
2265 collectVariableInfoFromMMITable(MF, Processed);
2267 SmallVector<const MachineInstr *, 8> DbgValues;
2268 // Collect variable information from DBG_VALUE machine instructions;
2269 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2271 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2273 const MachineInstr *MInsn = II;
2274 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2276 DbgValues.push_back(MInsn);
2279 // This is a collection of DBV_VALUE instructions describing same variable.
2280 SmallVector<const MachineInstr *, 4> MultipleValues;
2281 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2282 E = DbgValues.end(); I != E; ++I) {
2283 const MachineInstr *MInsn = *I;
2284 MultipleValues.clear();
2285 if (isDbgValueInDefinedReg(MInsn))
2286 MultipleValues.push_back(MInsn);
2287 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2288 if (Processed.count(DV) != 0)
2291 const MachineInstr *PrevMI = MInsn;
2292 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2293 ME = DbgValues.end(); MI != ME; ++MI) {
2295 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2296 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2297 !PrevMI->isIdenticalTo(*MI))
2298 MultipleValues.push_back(*MI);
2302 DbgScope *Scope = findDbgScope(MInsn);
2303 bool CurFnArg = false;
2304 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2305 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2307 if (!Scope && CurFnArg)
2308 Scope = CurrentFnDbgScope;
2309 // If variable scope is not found then skip this variable.
2313 Processed.insert(DV);
2314 DbgVariable *RegVar = new DbgVariable(DV);
2315 Scope->addVariable(RegVar);
2317 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2318 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2319 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2320 VarToAbstractVarMap[RegVar] = AbsVar;
2322 if (MultipleValues.size() <= 1) {
2323 DbgVariableToDbgInstMap[RegVar] = MInsn;
2327 // handle multiple DBG_VALUE instructions describing one variable.
2328 if (DotDebugLocEntries.empty())
2329 RegVar->setDotDebugLocOffset(0);
2331 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2332 const MachineInstr *Begin = NULL;
2333 const MachineInstr *End = NULL;
2334 for (SmallVector<const MachineInstr *, 4>::iterator
2335 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2336 MVI != MVE; ++MVI) {
2342 MachineLocation MLoc;
2343 if (Begin->getNumOperands() == 3) {
2344 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2345 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2347 MLoc = Asm->getDebugValueLocation(Begin);
2349 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2350 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2352 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2355 if (MVI + 1 == MVE) {
2356 // If End is the last instruction then its value is valid
2357 // until the end of the funtion.
2358 MachineLocation EMLoc;
2359 if (End->getNumOperands() == 3) {
2360 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2361 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2363 EMLoc = Asm->getDebugValueLocation(End);
2366 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2369 DotDebugLocEntries.push_back(DotDebugLocEntry());
2372 // Collect info for variables that were optimized out.
2373 const Function *F = MF->getFunction();
2374 const Module *M = F->getParent();
2375 if (NamedMDNode *NMD =
2376 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2377 getRealLinkageName(F->getName())))) {
2378 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2379 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2380 if (!DV || !Processed.insert(DV))
2382 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2384 Scope->addVariable(new DbgVariable(DV));
2389 /// getLabelBeforeInsn - Return Label preceding the instruction.
2390 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2391 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2392 LabelsBeforeInsn.find(MI);
2393 if (I == LabelsBeforeInsn.end())
2394 // FunctionBeginSym always preceeds all the instruction in current function.
2395 return FunctionBeginSym;
2399 /// getLabelAfterInsn - Return Label immediately following the instruction.
2400 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2401 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2402 LabelsAfterInsn.find(MI);
2403 if (I == LabelsAfterInsn.end())
2408 /// beginScope - Process beginning of a scope.
2409 void DwarfDebug::beginScope(const MachineInstr *MI) {
2410 if (InsnNeedsLabel.count(MI) == 0) {
2411 LabelsBeforeInsn[MI] = PrevLabel;
2416 DebugLoc DL = MI->getDebugLoc();
2417 if (!DL.isUnknown()) {
2418 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2419 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2421 LabelsBeforeInsn[MI] = PrevLabel;
2425 // If location is unknown then use temp label for this DBG_VALUE
2427 if (MI->isDebugValue()) {
2428 PrevLabel = MMI->getContext().CreateTempSymbol();
2429 Asm->OutStreamer.EmitLabel(PrevLabel);
2430 LabelsBeforeInsn[MI] = PrevLabel;
2434 if (UnknownLocations) {
2435 PrevLabel = recordSourceLine(0, 0, 0);
2436 LabelsBeforeInsn[MI] = PrevLabel;
2440 assert (0 && "Instruction is not processed!");
2443 /// endScope - Process end of a scope.
2444 void DwarfDebug::endScope(const MachineInstr *MI) {
2445 if (InsnsEndScopeSet.count(MI) != 0) {
2446 // Emit a label if this instruction ends a scope.
2447 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2448 Asm->OutStreamer.EmitLabel(Label);
2449 LabelsAfterInsn[MI] = Label;
2453 /// getOrCreateDbgScope - Create DbgScope for the scope.
2454 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2455 const MDNode *InlinedAt) {
2457 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2460 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2461 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2462 if (DIDescriptor(Scope).isLexicalBlock()) {
2464 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2465 WScope->setParent(Parent);
2466 Parent->addScope(WScope);
2469 if (!WScope->getParent()) {
2470 StringRef SPName = DISubprogram(Scope).getLinkageName();
2471 // We used to check only for a linkage name, but that fails
2472 // since we began omitting the linkage name for private
2473 // functions. The new way is to check for the name in metadata,
2474 // but that's not supported in old .ll test cases. Ergo, we
2476 if (SPName == Asm->MF->getFunction()->getName() ||
2477 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2478 CurrentFnDbgScope = WScope;
2484 getOrCreateAbstractScope(Scope);
2485 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2489 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2490 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2491 DILocation DL(InlinedAt);
2493 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2494 WScope->setParent(Parent);
2495 Parent->addScope(WScope);
2497 ConcreteScopes[InlinedAt] = WScope;
2502 /// hasValidLocation - Return true if debug location entry attached with
2503 /// machine instruction encodes valid location info.
2504 static bool hasValidLocation(LLVMContext &Ctx,
2505 const MachineInstr *MInsn,
2506 const MDNode *&Scope, const MDNode *&InlinedAt) {
2507 DebugLoc DL = MInsn->getDebugLoc();
2508 if (DL.isUnknown()) return false;
2510 const MDNode *S = DL.getScope(Ctx);
2512 // There is no need to create another DIE for compile unit. For all
2513 // other scopes, create one DbgScope now. This will be translated
2514 // into a scope DIE at the end.
2515 if (DIScope(S).isCompileUnit()) return false;
2518 InlinedAt = DL.getInlinedAt(Ctx);
2522 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2524 static void calculateDominanceGraph(DbgScope *Scope) {
2525 assert (Scope && "Unable to calculate scop edominance graph!");
2526 SmallVector<DbgScope *, 4> WorkStack;
2527 WorkStack.push_back(Scope);
2528 unsigned Counter = 0;
2529 while (!WorkStack.empty()) {
2530 DbgScope *WS = WorkStack.back();
2531 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2532 bool visitedChildren = false;
2533 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2534 SE = Children.end(); SI != SE; ++SI) {
2535 DbgScope *ChildScope = *SI;
2536 if (!ChildScope->getDFSOut()) {
2537 WorkStack.push_back(ChildScope);
2538 visitedChildren = true;
2539 ChildScope->setDFSIn(++Counter);
2543 if (!visitedChildren) {
2544 WorkStack.pop_back();
2545 WS->setDFSOut(++Counter);
2550 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2552 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2553 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2556 unsigned PrevDFSIn = 0;
2557 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2559 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2561 const MachineInstr *MInsn = II;
2562 const MDNode *Scope = NULL;
2563 const MDNode *InlinedAt = NULL;
2565 // Check if instruction has valid location information.
2566 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2570 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2571 MI2ScopeMap.find(MInsn);
2572 if (DI != MI2ScopeMap.end()) {
2573 DbgScope *S = DI->second;
2574 dbgs() << S->getDFSIn();
2575 PrevDFSIn = S->getDFSIn();
2577 dbgs() << PrevDFSIn;
2579 dbgs() << " [ x" << PrevDFSIn;
2587 /// extractScopeInformation - Scan machine instructions in this function
2588 /// and collect DbgScopes. Return true, if at least one scope was found.
2589 bool DwarfDebug::extractScopeInformation() {
2590 // If scope information was extracted using .dbg intrinsics then there is not
2591 // any need to extract these information by scanning each instruction.
2592 if (!DbgScopeMap.empty())
2595 // Scan each instruction and create scopes. First build working set of scopes.
2596 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2597 SmallVector<DbgRange, 4> MIRanges;
2598 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2599 const MDNode *PrevScope = NULL;
2600 const MDNode *PrevInlinedAt = NULL;
2601 const MachineInstr *RangeBeginMI = NULL;
2602 const MachineInstr *PrevMI = NULL;
2603 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2605 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2607 const MachineInstr *MInsn = II;
2608 const MDNode *Scope = NULL;
2609 const MDNode *InlinedAt = NULL;
2611 // Check if instruction has valid location information.
2612 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2617 // If scope has not changed then skip this instruction.
2618 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2624 // If we have alread seen a beginning of a instruction range and
2625 // current instruction scope does not match scope of first instruction
2626 // in this range then create a new instruction range.
2627 DbgRange R(RangeBeginMI, PrevMI);
2628 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2630 MIRanges.push_back(R);
2633 // This is a beginning of a new instruction range.
2634 RangeBeginMI = MInsn;
2636 // Reset previous markers.
2639 PrevInlinedAt = InlinedAt;
2643 // Create last instruction range.
2644 if (RangeBeginMI && PrevMI && PrevScope) {
2645 DbgRange R(RangeBeginMI, PrevMI);
2646 MIRanges.push_back(R);
2647 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2650 if (!CurrentFnDbgScope)
2653 calculateDominanceGraph(CurrentFnDbgScope);
2655 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2657 // Find ranges of instructions covered by each DbgScope;
2658 DbgScope *PrevDbgScope = NULL;
2659 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2660 RE = MIRanges.end(); RI != RE; ++RI) {
2661 const DbgRange &R = *RI;
2662 DbgScope *S = MI2ScopeMap.lookup(R.first);
2663 assert (S && "Lost DbgScope for a machine instruction!");
2664 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2665 PrevDbgScope->closeInsnRange(S);
2666 S->openInsnRange(R.first);
2667 S->extendInsnRange(R.second);
2672 PrevDbgScope->closeInsnRange();
2674 identifyScopeMarkers();
2676 return !DbgScopeMap.empty();
2679 /// identifyScopeMarkers() -
2680 /// Each DbgScope has first instruction and last instruction to mark beginning
2681 /// and end of a scope respectively. Create an inverse map that list scopes
2682 /// starts (and ends) with an instruction. One instruction may start (or end)
2683 /// multiple scopes. Ignore scopes that are not reachable.
2684 void DwarfDebug::identifyScopeMarkers() {
2685 SmallVector<DbgScope *, 4> WorkList;
2686 WorkList.push_back(CurrentFnDbgScope);
2687 while (!WorkList.empty()) {
2688 DbgScope *S = WorkList.pop_back_val();
2690 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2691 if (!Children.empty())
2692 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2693 SE = Children.end(); SI != SE; ++SI)
2694 WorkList.push_back(*SI);
2696 if (S->isAbstractScope())
2699 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2702 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2703 RE = Ranges.end(); RI != RE; ++RI) {
2704 assert(RI->first && "DbgRange does not have first instruction!");
2705 assert(RI->second && "DbgRange does not have second instruction!");
2706 InsnsEndScopeSet.insert(RI->second);
2711 /// FindFirstDebugLoc - Find the first debug location in the function. This
2712 /// is intended to be an approximation for the source position of the
2713 /// beginning of the function.
2714 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2715 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2717 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2718 MBBI != MBBE; ++MBBI) {
2719 DebugLoc DL = MBBI->getDebugLoc();
2720 if (!DL.isUnknown())
2726 /// beginFunction - Gather pre-function debug information. Assumes being
2727 /// emitted immediately after the function entry point.
2728 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2729 if (!MMI->hasDebugInfo()) return;
2730 if (!extractScopeInformation()) return;
2732 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2733 Asm->getFunctionNumber());
2734 // Assumes in correct section after the entry point.
2735 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2737 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2739 DebugLoc FDL = FindFirstDebugLoc(MF);
2740 if (FDL.isUnknown()) return;
2742 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2743 const MDNode *TheScope = 0;
2745 DISubprogram SP = getDISubprogram(Scope);
2748 Line = SP.getLineNumber();
2752 Line = FDL.getLine();
2757 recordSourceLine(Line, Col, TheScope);
2759 /// ProcessedArgs - Collection of arguments already processed.
2760 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2763 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2765 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2767 const MachineInstr *MI = II;
2768 DebugLoc DL = MI->getDebugLoc();
2769 if (MI->isDebugValue()) {
2770 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2771 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2772 if (!DV.Verify()) continue;
2773 // If DBG_VALUE is for a local variable then it needs a label.
2774 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2775 && isDbgValueInUndefinedReg(MI) == false)
2776 InsnNeedsLabel.insert(MI);
2777 // DBG_VALUE for inlined functions argument needs a label.
2778 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2779 describes(MF->getFunction()))
2780 InsnNeedsLabel.insert(MI);
2781 // DBG_VALUE indicating argument location change needs a label.
2782 else if (isDbgValueInUndefinedReg(MI) == false
2783 && !ProcessedArgs.insert(DV))
2784 InsnNeedsLabel.insert(MI);
2786 // If location is unknown then instruction needs a location only if
2787 // UnknownLocations flag is set.
2788 if (DL.isUnknown()) {
2789 if (UnknownLocations && !PrevLoc.isUnknown())
2790 InsnNeedsLabel.insert(MI);
2791 } else if (DL != PrevLoc)
2792 // Otherwise, instruction needs a location only if it is new location.
2793 InsnNeedsLabel.insert(MI);
2796 if (!DL.isUnknown() || UnknownLocations)
2800 PrevLabel = FunctionBeginSym;
2803 /// endFunction - Gather and emit post-function debug information.
2805 void DwarfDebug::endFunction(const MachineFunction *MF) {
2806 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2808 if (CurrentFnDbgScope) {
2810 // Define end label for subprogram.
2811 FunctionEndSym = Asm->GetTempSymbol("func_end",
2812 Asm->getFunctionNumber());
2813 // Assumes in correct section after the entry point.
2814 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2816 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2817 collectVariableInfo(MF, ProcessedVars);
2819 // Get function line info.
2820 if (!Lines.empty()) {
2821 // Get section line info.
2822 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2823 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2824 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2825 // Append the function info to section info.
2826 SectionLineInfos.insert(SectionLineInfos.end(),
2827 Lines.begin(), Lines.end());
2830 // Construct abstract scopes.
2831 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2832 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2833 DISubprogram SP((*AI)->getScopeNode());
2835 // Collect info for variables that were optimized out.
2836 StringRef FName = SP.getLinkageName();
2838 FName = SP.getName();
2839 const Module *M = MF->getFunction()->getParent();
2840 if (NamedMDNode *NMD =
2841 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2842 getRealLinkageName(FName)))) {
2843 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2844 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2845 if (!DV || !ProcessedVars.insert(DV))
2847 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2849 Scope->addVariable(new DbgVariable(DV));
2853 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2854 constructScopeDIE(*AI);
2857 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2859 if (!DisableFramePointerElim(*MF))
2860 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2861 dwarf::DW_FORM_flag, 1);
2864 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2865 MMI->getFrameMoves()));
2869 CurrentFnDbgScope = NULL;
2870 InsnNeedsLabel.clear();
2871 DbgVariableToFrameIndexMap.clear();
2872 VarToAbstractVarMap.clear();
2873 DbgVariableToDbgInstMap.clear();
2874 DbgVariableLabelsMap.clear();
2875 DeleteContainerSeconds(DbgScopeMap);
2876 InsnsEndScopeSet.clear();
2877 ConcreteScopes.clear();
2878 DeleteContainerSeconds(AbstractScopes);
2879 AbstractScopesList.clear();
2880 AbstractVariables.clear();
2881 LabelsBeforeInsn.clear();
2882 LabelsAfterInsn.clear();
2887 /// recordVariableFrameIndex - Record a variable's index.
2888 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2889 assert (V && "Invalid DbgVariable!");
2890 DbgVariableToFrameIndexMap[V] = Index;
2893 /// findVariableFrameIndex - Return true if frame index for the variable
2894 /// is found. Update FI to hold value of the index.
2895 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2896 assert (V && "Invalid DbgVariable!");
2897 DenseMap<const DbgVariable *, int>::iterator I =
2898 DbgVariableToFrameIndexMap.find(V);
2899 if (I == DbgVariableToFrameIndexMap.end())
2905 /// findVariableLabel - Find MCSymbol for the variable.
2906 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2907 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2908 = DbgVariableLabelsMap.find(V);
2909 if (I == DbgVariableLabelsMap.end())
2911 else return I->second;
2914 /// findDbgScope - Find DbgScope for the debug loc attached with an
2916 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2917 DbgScope *Scope = NULL;
2919 MInsn->getParent()->getParent()->getFunction()->getContext();
2920 DebugLoc DL = MInsn->getDebugLoc();
2925 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2926 Scope = ConcreteScopes.lookup(IA);
2928 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2934 /// recordSourceLine - Register a source line with debug info. Returns the
2935 /// unique label that was emitted and which provides correspondence to
2936 /// the source line list.
2937 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2944 DIDescriptor Scope(S);
2946 if (Scope.isCompileUnit()) {
2947 DICompileUnit CU(S);
2948 Dir = CU.getDirectory();
2949 Fn = CU.getFilename();
2950 } else if (Scope.isSubprogram()) {
2952 Dir = SP.getDirectory();
2953 Fn = SP.getFilename();
2954 } else if (Scope.isLexicalBlock()) {
2955 DILexicalBlock DB(S);
2956 Dir = DB.getDirectory();
2957 Fn = DB.getFilename();
2959 assert(0 && "Unexpected scope info");
2961 Src = GetOrCreateSourceID(Dir, Fn);
2964 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2965 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2967 Asm->OutStreamer.EmitLabel(Label);
2971 //===----------------------------------------------------------------------===//
2973 //===----------------------------------------------------------------------===//
2975 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2978 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2979 // Get the children.
2980 const std::vector<DIE *> &Children = Die->getChildren();
2982 // If not last sibling and has children then add sibling offset attribute.
2983 if (!Last && !Children.empty())
2984 Die->addSiblingOffset(DIEValueAllocator);
2986 // Record the abbreviation.
2987 assignAbbrevNumber(Die->getAbbrev());
2989 // Get the abbreviation for this DIE.
2990 unsigned AbbrevNumber = Die->getAbbrevNumber();
2991 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2994 Die->setOffset(Offset);
2996 // Start the size with the size of abbreviation code.
2997 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
2999 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3000 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3002 // Size the DIE attribute values.
3003 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3004 // Size attribute value.
3005 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3007 // Size the DIE children if any.
3008 if (!Children.empty()) {
3009 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3010 "Children flag not set");
3012 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3013 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3015 // End of children marker.
3016 Offset += sizeof(int8_t);
3019 Die->setSize(Offset - Die->getOffset());
3023 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3025 void DwarfDebug::computeSizeAndOffsets() {
3026 unsigned PrevOffset = 0;
3027 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3028 E = CUMap.end(); I != E; ++I) {
3029 // Compute size of compile unit header.
3030 static unsigned Offset = PrevOffset +
3031 sizeof(int32_t) + // Length of Compilation Unit Info
3032 sizeof(int16_t) + // DWARF version number
3033 sizeof(int32_t) + // Offset Into Abbrev. Section
3034 sizeof(int8_t); // Pointer Size (in bytes)
3035 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3036 PrevOffset = Offset;
3040 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3041 /// temporary label to it if SymbolStem is specified.
3042 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3043 const char *SymbolStem = 0) {
3044 Asm->OutStreamer.SwitchSection(Section);
3045 if (!SymbolStem) return 0;
3047 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3048 Asm->OutStreamer.EmitLabel(TmpSym);
3052 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3053 /// the start of each one.
3054 void DwarfDebug::EmitSectionLabels() {
3055 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3057 // Dwarf sections base addresses.
3058 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3059 DwarfFrameSectionSym =
3060 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3063 DwarfInfoSectionSym =
3064 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3065 DwarfAbbrevSectionSym =
3066 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3067 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3069 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3070 EmitSectionSym(Asm, MacroInfo);
3072 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3073 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3074 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3075 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3076 DwarfStrSectionSym =
3077 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3078 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3081 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3082 "section_debug_loc");
3084 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3085 EmitSectionSym(Asm, TLOF.getDataSection());
3088 /// emitDIE - Recusively Emits a debug information entry.
3090 void DwarfDebug::emitDIE(DIE *Die) {
3091 // Get the abbreviation for this DIE.
3092 unsigned AbbrevNumber = Die->getAbbrevNumber();
3093 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3095 // Emit the code (index) for the abbreviation.
3096 if (Asm->isVerbose())
3097 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3098 Twine::utohexstr(Die->getOffset()) + ":0x" +
3099 Twine::utohexstr(Die->getSize()) + " " +
3100 dwarf::TagString(Abbrev->getTag()));
3101 Asm->EmitULEB128(AbbrevNumber);
3103 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3104 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3106 // Emit the DIE attribute values.
3107 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3108 unsigned Attr = AbbrevData[i].getAttribute();
3109 unsigned Form = AbbrevData[i].getForm();
3110 assert(Form && "Too many attributes for DIE (check abbreviation)");
3112 if (Asm->isVerbose())
3113 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3116 case dwarf::DW_AT_sibling:
3117 Asm->EmitInt32(Die->getSiblingOffset());
3119 case dwarf::DW_AT_abstract_origin: {
3120 DIEEntry *E = cast<DIEEntry>(Values[i]);
3121 DIE *Origin = E->getEntry();
3122 unsigned Addr = Origin->getOffset();
3123 Asm->EmitInt32(Addr);
3126 case dwarf::DW_AT_ranges: {
3127 // DW_AT_range Value encodes offset in debug_range section.
3128 DIEInteger *V = cast<DIEInteger>(Values[i]);
3129 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3131 DwarfDebugRangeSectionSym,
3135 case dwarf::DW_AT_location: {
3136 if (UseDotDebugLocEntry.count(Die) != 0) {
3137 DIELabel *L = cast<DIELabel>(Values[i]);
3138 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3140 Values[i]->EmitValue(Asm, Form);
3144 // Emit an attribute using the defined form.
3145 Values[i]->EmitValue(Asm, Form);
3150 // Emit the DIE children if any.
3151 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3152 const std::vector<DIE *> &Children = Die->getChildren();
3154 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3155 emitDIE(Children[j]);
3157 if (Asm->isVerbose())
3158 Asm->OutStreamer.AddComment("End Of Children Mark");
3163 /// emitDebugInfo - Emit the debug info section.
3165 void DwarfDebug::emitDebugInfo() {
3166 // Start debug info section.
3167 Asm->OutStreamer.SwitchSection(
3168 Asm->getObjFileLowering().getDwarfInfoSection());
3169 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3170 E = CUMap.end(); I != E; ++I) {
3171 CompileUnit *TheCU = I->second;
3172 DIE *Die = TheCU->getCUDie();
3174 // Emit the compile units header.
3175 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3178 // Emit size of content not including length itself
3179 unsigned ContentSize = Die->getSize() +
3180 sizeof(int16_t) + // DWARF version number
3181 sizeof(int32_t) + // Offset Into Abbrev. Section
3182 sizeof(int8_t) + // Pointer Size (in bytes)
3183 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3185 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3186 Asm->EmitInt32(ContentSize);
3187 Asm->OutStreamer.AddComment("DWARF version number");
3188 Asm->EmitInt16(dwarf::DWARF_VERSION);
3189 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3190 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3191 DwarfAbbrevSectionSym);
3192 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3193 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3196 // FIXME - extra padding for gdb bug.
3197 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3202 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3206 /// emitAbbreviations - Emit the abbreviation section.
3208 void DwarfDebug::emitAbbreviations() const {
3209 // Check to see if it is worth the effort.
3210 if (!Abbreviations.empty()) {
3211 // Start the debug abbrev section.
3212 Asm->OutStreamer.SwitchSection(
3213 Asm->getObjFileLowering().getDwarfAbbrevSection());
3215 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3217 // For each abbrevation.
3218 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3219 // Get abbreviation data
3220 const DIEAbbrev *Abbrev = Abbreviations[i];
3222 // Emit the abbrevations code (base 1 index.)
3223 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3225 // Emit the abbreviations data.
3229 // Mark end of abbreviations.
3230 Asm->EmitULEB128(0, "EOM(3)");
3232 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3236 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3237 /// the line matrix.
3239 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3240 // Define last address of section.
3241 Asm->OutStreamer.AddComment("Extended Op");
3244 Asm->OutStreamer.AddComment("Op size");
3245 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3246 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3247 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3249 Asm->OutStreamer.AddComment("Section end label");
3251 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3252 Asm->getTargetData().getPointerSize(),
3255 // Mark end of matrix.
3256 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3262 /// emitDebugLines - Emit source line information.
3264 void DwarfDebug::emitDebugLines() {
3265 // If the target is using .loc/.file, the assembler will be emitting the
3266 // .debug_line table automatically.
3267 if (Asm->MAI->hasDotLocAndDotFile())
3270 // Minimum line delta, thus ranging from -10..(255-10).
3271 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3272 // Maximum line delta, thus ranging from -10..(255-10).
3273 const int MaxLineDelta = 255 + MinLineDelta;
3275 // Start the dwarf line section.
3276 Asm->OutStreamer.SwitchSection(
3277 Asm->getObjFileLowering().getDwarfLineSection());
3279 // Construct the section header.
3280 Asm->OutStreamer.AddComment("Length of Source Line Info");
3281 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3282 Asm->GetTempSymbol("line_begin"), 4);
3283 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3285 Asm->OutStreamer.AddComment("DWARF version number");
3286 Asm->EmitInt16(dwarf::DWARF_VERSION);
3288 Asm->OutStreamer.AddComment("Prolog Length");
3289 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3290 Asm->GetTempSymbol("line_prolog_begin"), 4);
3291 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3293 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3295 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3297 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3298 Asm->EmitInt8(MinLineDelta);
3299 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3300 Asm->EmitInt8(MaxLineDelta);
3301 Asm->OutStreamer.AddComment("Special Opcode Base");
3302 Asm->EmitInt8(-MinLineDelta);
3304 // Line number standard opcode encodings argument count
3305 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3307 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3309 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3311 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3313 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3315 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3317 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3319 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3321 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3324 // Emit directories.
3325 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3326 const std::string &Dir = getSourceDirectoryName(DI);
3327 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3328 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3331 Asm->OutStreamer.AddComment("End of directories");
3335 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3336 // Remember source id starts at 1.
3337 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3338 const std::string &FN = getSourceFileName(Id.second);
3339 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3340 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3342 Asm->EmitULEB128(Id.first, "Directory #");
3343 Asm->EmitULEB128(0, "Mod date");
3344 Asm->EmitULEB128(0, "File size");
3347 Asm->OutStreamer.AddComment("End of files");
3350 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3352 // A sequence for each text section.
3353 unsigned SecSrcLinesSize = SectionSourceLines.size();
3355 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3356 // Isolate current sections line info.
3357 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3359 // Dwarf assumes we start with first line of first source file.
3360 unsigned Source = 1;
3363 // Construct rows of the address, source, line, column matrix.
3364 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3365 const SrcLineInfo &LineInfo = LineInfos[i];
3366 MCSymbol *Label = LineInfo.getLabel();
3367 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3369 if (Asm->isVerbose()) {
3370 std::pair<unsigned, unsigned> SrcID =
3371 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3372 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3374 Twine(getSourceFileName(SrcID.second)) +
3375 ":" + Twine(LineInfo.getLine()));
3378 // Define the line address.
3379 Asm->OutStreamer.AddComment("Extended Op");
3381 Asm->OutStreamer.AddComment("Op size");
3382 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3384 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3385 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3387 Asm->OutStreamer.AddComment("Location label");
3388 Asm->OutStreamer.EmitSymbolValue(Label,
3389 Asm->getTargetData().getPointerSize(),
3392 // If change of source, then switch to the new source.
3393 if (Source != LineInfo.getSourceID()) {
3394 Source = LineInfo.getSourceID();
3395 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3396 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3397 Asm->EmitULEB128(Source, "New Source");
3400 // If change of line.
3401 if (Line != LineInfo.getLine()) {
3402 // Determine offset.
3403 int Offset = LineInfo.getLine() - Line;
3404 int Delta = Offset - MinLineDelta;
3407 Line = LineInfo.getLine();
3409 // If delta is small enough and in range...
3410 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3411 // ... then use fast opcode.
3412 Asm->OutStreamer.AddComment("Line Delta");
3413 Asm->EmitInt8(Delta - MinLineDelta);
3415 // ... otherwise use long hand.
3416 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3417 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3418 Asm->EmitSLEB128(Offset, "Line Offset");
3419 Asm->OutStreamer.AddComment("DW_LNS_copy");
3420 Asm->EmitInt8(dwarf::DW_LNS_copy);
3423 // Copy the previous row (different address or source)
3424 Asm->OutStreamer.AddComment("DW_LNS_copy");
3425 Asm->EmitInt8(dwarf::DW_LNS_copy);
3429 emitEndOfLineMatrix(j + 1);
3432 if (SecSrcLinesSize == 0)
3433 // Because we're emitting a debug_line section, we still need a line
3434 // table. The linker and friends expect it to exist. If there's nothing to
3435 // put into it, emit an empty table.
3436 emitEndOfLineMatrix(1);
3438 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3441 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3443 void DwarfDebug::emitCommonDebugFrame() {
3444 if (!Asm->MAI->doesDwarfRequireFrameSection())
3447 int stackGrowth = Asm->getTargetData().getPointerSize();
3448 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3449 TargetFrameInfo::StackGrowsDown)
3452 // Start the dwarf frame section.
3453 Asm->OutStreamer.SwitchSection(
3454 Asm->getObjFileLowering().getDwarfFrameSection());
3456 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3457 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3458 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3459 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3461 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3462 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3463 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3464 Asm->OutStreamer.AddComment("CIE Version");
3465 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3466 Asm->OutStreamer.AddComment("CIE Augmentation");
3467 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3468 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3469 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3470 Asm->OutStreamer.AddComment("CIE RA Column");
3471 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3472 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3474 std::vector<MachineMove> Moves;
3475 RI->getInitialFrameState(Moves);
3477 Asm->EmitFrameMoves(Moves, 0, false);
3479 Asm->EmitAlignment(2);
3480 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3483 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3486 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3487 if (!Asm->MAI->doesDwarfRequireFrameSection())
3490 // Start the dwarf frame section.
3491 Asm->OutStreamer.SwitchSection(
3492 Asm->getObjFileLowering().getDwarfFrameSection());
3494 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3495 MCSymbol *DebugFrameBegin =
3496 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3497 MCSymbol *DebugFrameEnd =
3498 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3499 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3501 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3503 Asm->OutStreamer.AddComment("FDE CIE offset");
3504 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3505 DwarfFrameSectionSym);
3507 Asm->OutStreamer.AddComment("FDE initial location");
3508 MCSymbol *FuncBeginSym =
3509 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3510 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3511 Asm->getTargetData().getPointerSize(),
3515 Asm->OutStreamer.AddComment("FDE address range");
3516 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3517 FuncBeginSym, Asm->getTargetData().getPointerSize());
3519 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3521 Asm->EmitAlignment(2);
3522 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3525 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3527 void DwarfDebug::emitDebugPubNames() {
3528 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3529 E = CUMap.end(); I != E; ++I) {
3530 CompileUnit *TheCU = I->second;
3531 // Start the dwarf pubnames section.
3532 Asm->OutStreamer.SwitchSection(
3533 Asm->getObjFileLowering().getDwarfPubNamesSection());
3535 Asm->OutStreamer.AddComment("Length of Public Names Info");
3536 Asm->EmitLabelDifference(
3537 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3538 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3540 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3543 Asm->OutStreamer.AddComment("DWARF Version");
3544 Asm->EmitInt16(dwarf::DWARF_VERSION);
3546 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3547 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3548 DwarfInfoSectionSym);
3550 Asm->OutStreamer.AddComment("Compilation Unit Length");
3551 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3552 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3555 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3556 for (StringMap<DIE*>::const_iterator
3557 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3558 const char *Name = GI->getKeyData();
3559 DIE *Entity = GI->second;
3561 Asm->OutStreamer.AddComment("DIE offset");
3562 Asm->EmitInt32(Entity->getOffset());
3564 if (Asm->isVerbose())
3565 Asm->OutStreamer.AddComment("External Name");
3566 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3569 Asm->OutStreamer.AddComment("End Mark");
3571 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3576 void DwarfDebug::emitDebugPubTypes() {
3577 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3578 E = CUMap.end(); I != E; ++I) {
3579 CompileUnit *TheCU = I->second;
3580 // Start the dwarf pubnames section.
3581 Asm->OutStreamer.SwitchSection(
3582 Asm->getObjFileLowering().getDwarfPubTypesSection());
3583 Asm->OutStreamer.AddComment("Length of Public Types Info");
3584 Asm->EmitLabelDifference(
3585 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3586 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3588 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3591 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3592 Asm->EmitInt16(dwarf::DWARF_VERSION);
3594 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3595 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3596 DwarfInfoSectionSym);
3598 Asm->OutStreamer.AddComment("Compilation Unit Length");
3599 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3600 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3603 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3604 for (StringMap<DIE*>::const_iterator
3605 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3606 const char *Name = GI->getKeyData();
3607 DIE * Entity = GI->second;
3609 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3610 Asm->EmitInt32(Entity->getOffset());
3612 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3613 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3616 Asm->OutStreamer.AddComment("End Mark");
3618 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3623 /// emitDebugStr - Emit visible names into a debug str section.
3625 void DwarfDebug::emitDebugStr() {
3626 // Check to see if it is worth the effort.
3627 if (StringPool.empty()) return;
3629 // Start the dwarf str section.
3630 Asm->OutStreamer.SwitchSection(
3631 Asm->getObjFileLowering().getDwarfStrSection());
3633 // Get all of the string pool entries and put them in an array by their ID so
3634 // we can sort them.
3635 SmallVector<std::pair<unsigned,
3636 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3638 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3639 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3640 Entries.push_back(std::make_pair(I->second.second, &*I));
3642 array_pod_sort(Entries.begin(), Entries.end());
3644 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3645 // Emit a label for reference from debug information entries.
3646 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3648 // Emit the string itself.
3649 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3653 /// emitDebugLoc - Emit visible names into a debug loc section.
3655 void DwarfDebug::emitDebugLoc() {
3656 if (DotDebugLocEntries.empty())
3659 // Start the dwarf loc section.
3660 Asm->OutStreamer.SwitchSection(
3661 Asm->getObjFileLowering().getDwarfLocSection());
3662 unsigned char Size = Asm->getTargetData().getPointerSize();
3663 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3665 for (SmallVector<DotDebugLocEntry, 4>::iterator
3666 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3667 I != E; ++I, ++index) {
3668 DotDebugLocEntry Entry = *I;
3669 if (Entry.isEmpty()) {
3670 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3671 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3672 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3674 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3675 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3676 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3677 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3678 if (int Offset = Entry.Loc.getOffset()) {
3679 // If the value is at a certain offset from frame register then
3681 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3682 Asm->OutStreamer.AddComment("Loc expr size");
3683 Asm->EmitInt16(1 + OffsetSize);
3684 Asm->OutStreamer.AddComment(
3685 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3686 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3687 Asm->OutStreamer.AddComment("Offset");
3688 Asm->EmitSLEB128(Offset);
3691 Asm->OutStreamer.AddComment("Loc expr size");
3693 Asm->OutStreamer.AddComment(
3694 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3695 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3697 Asm->OutStreamer.AddComment("Loc expr size");
3698 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3699 Asm->EmitInt8(dwarf::DW_OP_regx);
3700 Asm->EmitULEB128(Reg);
3707 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3709 void DwarfDebug::EmitDebugARanges() {
3710 // Start the dwarf aranges section.
3711 Asm->OutStreamer.SwitchSection(
3712 Asm->getObjFileLowering().getDwarfARangesSection());
3715 /// emitDebugRanges - Emit visible names into a debug ranges section.
3717 void DwarfDebug::emitDebugRanges() {
3718 // Start the dwarf ranges section.
3719 Asm->OutStreamer.SwitchSection(
3720 Asm->getObjFileLowering().getDwarfRangesSection());
3721 unsigned char Size = Asm->getTargetData().getPointerSize();
3722 for (SmallVector<const MCSymbol *, 8>::iterator
3723 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3726 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3728 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3732 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3734 void DwarfDebug::emitDebugMacInfo() {
3735 if (const MCSection *LineInfo =
3736 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3737 // Start the dwarf macinfo section.
3738 Asm->OutStreamer.SwitchSection(LineInfo);
3742 /// emitDebugInlineInfo - Emit inline info using following format.
3744 /// 1. length of section
3745 /// 2. Dwarf version number
3746 /// 3. address size.
3748 /// Entries (one "entry" for each function that was inlined):
3750 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3751 /// otherwise offset into __debug_str for regular function name.
3752 /// 2. offset into __debug_str section for regular function name.
3753 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3754 /// instances for the function.
3756 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3757 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3758 /// __debug_info section, and the low_pc is the starting address for the
3759 /// inlining instance.
3760 void DwarfDebug::emitDebugInlineInfo() {
3761 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3767 Asm->OutStreamer.SwitchSection(
3768 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3770 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3771 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3772 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3774 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3776 Asm->OutStreamer.AddComment("Dwarf Version");
3777 Asm->EmitInt16(dwarf::DWARF_VERSION);
3778 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3779 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3781 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3782 E = InlinedSPNodes.end(); I != E; ++I) {
3784 const MDNode *Node = *I;
3785 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3786 = InlineInfo.find(Node);
3787 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3788 DISubprogram SP(Node);
3789 StringRef LName = SP.getLinkageName();
3790 StringRef Name = SP.getName();
3792 Asm->OutStreamer.AddComment("MIPS linkage name");
3793 if (LName.empty()) {
3794 Asm->OutStreamer.EmitBytes(Name, 0);
3795 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3797 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3798 DwarfStrSectionSym);
3800 Asm->OutStreamer.AddComment("Function name");
3801 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3802 Asm->EmitULEB128(Labels.size(), "Inline count");
3804 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3805 LE = Labels.end(); LI != LE; ++LI) {
3806 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3807 Asm->EmitInt32(LI->second->getOffset());
3809 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3810 Asm->OutStreamer.EmitSymbolValue(LI->first,
3811 Asm->getTargetData().getPointerSize(),0);
3815 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));