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 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1819 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1820 Asm->GetTempSymbol("section_line"));
1822 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1825 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1826 if (DIUnit.isOptimized())
1827 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1829 StringRef Flags = DIUnit.getFlags();
1831 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1833 unsigned RVer = DIUnit.getRunTimeVersion();
1835 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1836 dwarf::DW_FORM_data1, RVer);
1838 CompileUnit *NewCU = new CompileUnit(ID, Die);
1841 CUMap.insert(std::make_pair(N, NewCU));
1844 /// getCompielUnit - Get CompileUnit DIE.
1845 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1846 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1848 const MDNode *CUNode = NULL;
1849 if (D.isCompileUnit())
1851 else if (D.isSubprogram())
1852 CUNode = DISubprogram(N).getCompileUnit();
1853 else if (D.isType())
1854 CUNode = DIType(N).getCompileUnit();
1855 else if (D.isGlobalVariable())
1856 CUNode = DIGlobalVariable(N).getCompileUnit();
1857 else if (D.isVariable())
1858 CUNode = DIVariable(N).getCompileUnit();
1859 else if (D.isNameSpace())
1860 CUNode = DINameSpace(N).getCompileUnit();
1861 else if (D.isFile())
1862 CUNode = DIFile(N).getCompileUnit();
1866 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1867 = CUMap.find(CUNode);
1868 if (I == CUMap.end())
1873 /// isUnsignedDIType - Return true if type encoding is unsigned.
1874 static bool isUnsignedDIType(DIType Ty) {
1875 DIDerivedType DTy(Ty);
1877 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1879 DIBasicType BTy(Ty);
1881 unsigned Encoding = BTy.getEncoding();
1882 if (Encoding == dwarf::DW_ATE_unsigned ||
1883 Encoding == dwarf::DW_ATE_unsigned_char)
1889 /// constructGlobalVariableDIE - Construct global variable DIE.
1890 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1891 DIGlobalVariable GV(N);
1893 // If debug information is malformed then ignore it.
1894 if (GV.Verify() == false)
1897 // Check for pre-existence.
1898 CompileUnit *TheCU = getCompileUnit(N);
1899 if (TheCU->getDIE(GV))
1902 DIType GTy = GV.getType();
1903 DIE *VariableDIE = new DIE(GV.getTag());
1905 bool isGlobalVariable = GV.getGlobal() != NULL;
1908 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1909 GV.getDisplayName());
1910 StringRef LinkageName = GV.getLinkageName();
1911 if (!LinkageName.empty() && isGlobalVariable)
1912 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1913 getRealLinkageName(LinkageName));
1915 addType(VariableDIE, GTy);
1916 if (GTy.isCompositeType() && !GTy.getName().empty()
1917 && !GTy.isForwardDecl()) {
1918 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1919 assert(Entry && "Missing global type!");
1920 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1922 // Add scoping info.
1923 if (!GV.isLocalToUnit()) {
1924 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1925 // Expose as global.
1926 TheCU->addGlobal(GV.getName(), VariableDIE);
1928 // Add line number info.
1929 addSourceLine(VariableDIE, GV);
1931 TheCU->insertDIE(N, VariableDIE);
1932 // Add to context owner.
1933 DIDescriptor GVContext = GV.getContext();
1934 addToContextOwner(VariableDIE, GVContext);
1936 if (isGlobalVariable) {
1937 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1938 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1939 addLabel(Block, 0, dwarf::DW_FORM_udata,
1940 Asm->Mang->getSymbol(GV.getGlobal()));
1941 // Do not create specification DIE if context is either compile unit
1943 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1944 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1945 // Create specification DIE.
1946 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1947 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1948 dwarf::DW_FORM_ref4, VariableDIE);
1949 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1950 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1951 TheCU->addDie(VariableSpecDIE);
1953 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1955 } else if (Constant *C = GV.getConstant()) {
1956 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
1957 if (isUnsignedDIType(GTy))
1958 addUInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1959 CI->getZExtValue());
1961 addSInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1962 CI->getSExtValue());
1968 /// construct SubprogramDIE - Construct subprogram DIE.
1969 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1972 // Check for pre-existence.
1973 CompileUnit *TheCU = getCompileUnit(N);
1974 if (TheCU->getDIE(N))
1977 if (!SP.isDefinition())
1978 // This is a method declaration which will be handled while constructing
1982 DIE *SubprogramDie = createSubprogramDIE(SP);
1985 TheCU->insertDIE(N, SubprogramDie);
1987 // Add to context owner.
1988 addToContextOwner(SubprogramDie, SP.getContext());
1990 // Expose as global.
1991 TheCU->addGlobal(SP.getName(), SubprogramDie);
1996 /// beginModule - Emit all Dwarf sections that should come prior to the
1997 /// content. Create global DIEs and emit initial debug info sections.
1998 /// This is inovked by the target AsmPrinter.
1999 void DwarfDebug::beginModule(Module *M) {
2000 if (DisableDebugInfoPrinting)
2003 DebugInfoFinder DbgFinder;
2004 DbgFinder.processModule(*M);
2006 bool HasDebugInfo = false;
2008 // Scan all the compile-units to see if there are any marked as the main unit.
2009 // if not, we do not generate debug info.
2010 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2011 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2012 if (DICompileUnit(*I).isMain()) {
2013 HasDebugInfo = true;
2018 if (!HasDebugInfo) return;
2020 // Tell MMI that we have debug info.
2021 MMI->setDebugInfoAvailability(true);
2023 // Emit initial sections.
2024 EmitSectionLabels();
2026 // Create all the compile unit DIEs.
2027 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2028 E = DbgFinder.compile_unit_end(); I != E; ++I)
2029 constructCompileUnit(*I);
2031 // Create DIEs for each subprogram.
2032 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2033 E = DbgFinder.subprogram_end(); I != E; ++I)
2034 constructSubprogramDIE(*I);
2036 // Create DIEs for each global variable.
2037 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2038 E = DbgFinder.global_variable_end(); I != E; ++I)
2039 constructGlobalVariableDIE(*I);
2041 //getOrCreateTypeDIE
2042 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2043 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2044 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2046 // Prime section data.
2047 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2049 // Print out .file directives to specify files for .loc directives. These are
2050 // printed out early so that they precede any .loc directives.
2051 if (Asm->MAI->hasDotLocAndDotFile()) {
2052 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2053 // Remember source id starts at 1.
2054 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2055 // FIXME: don't use sys::path for this! This should not depend on the
2057 sys::Path FullPath(getSourceDirectoryName(Id.first));
2059 FullPath.appendComponent(getSourceFileName(Id.second));
2060 assert(AppendOk && "Could not append filename to directory!");
2062 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2067 /// endModule - Emit all Dwarf sections that should come after the content.
2069 void DwarfDebug::endModule() {
2070 if (!FirstCU) return;
2071 const Module *M = MMI->getModule();
2072 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2073 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2074 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2075 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2076 DISubprogram SP(AllSPs->getOperand(SI));
2077 if (!SP.Verify()) continue;
2079 // Collect info for variables that were optimized out.
2080 if (!SP.isDefinition()) continue;
2081 StringRef FName = SP.getLinkageName();
2083 FName = SP.getName();
2085 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2087 unsigned E = NMD->getNumOperands();
2089 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2090 DeadFnScopeMap[SP] = Scope;
2091 for (unsigned I = 0; I != E; ++I) {
2092 DIVariable DV(NMD->getOperand(I));
2093 if (!DV.Verify()) continue;
2094 Scope->addVariable(new DbgVariable(DV));
2097 // Construct subprogram DIE and add variables DIEs.
2098 constructSubprogramDIE(SP);
2099 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2100 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2101 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2102 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2104 ScopeDIE->addChild(VariableDIE);
2109 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2110 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2111 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2113 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2116 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2117 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2118 DIE *SPDie = CI->first;
2119 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2121 DIE *NDie = getCompileUnit(N)->getDIE(N);
2122 if (!NDie) continue;
2123 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2126 // Standard sections final addresses.
2127 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2128 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2129 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2130 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2132 // End text sections.
2133 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2134 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2135 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2138 // Emit common frame information.
2139 emitCommonDebugFrame();
2141 // Emit function debug frame information
2142 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2143 E = DebugFrames.end(); I != E; ++I)
2144 emitFunctionDebugFrame(*I);
2146 // Compute DIE offsets and sizes.
2147 computeSizeAndOffsets();
2149 // Emit all the DIEs into a debug info section
2152 // Corresponding abbreviations into a abbrev section.
2153 emitAbbreviations();
2155 // Emit source line correspondence into a debug line section.
2158 // Emit info into a debug pubnames section.
2159 emitDebugPubNames();
2161 // Emit info into a debug pubtypes section.
2162 emitDebugPubTypes();
2164 // Emit info into a debug loc section.
2167 // Emit info into a debug aranges section.
2170 // Emit info into a debug ranges section.
2173 // Emit info into a debug macinfo section.
2176 // Emit inline info.
2177 emitDebugInlineInfo();
2179 // Emit info into a debug str section.
2183 DeleteContainerSeconds(DeadFnScopeMap);
2184 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2185 E = CUMap.end(); I != E; ++I)
2187 FirstCU = NULL; // Reset for the next Module, if any.
2190 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2191 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2192 DebugLoc ScopeLoc) {
2194 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2196 return AbsDbgVariable;
2198 LLVMContext &Ctx = Var->getContext();
2199 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2203 AbsDbgVariable = new DbgVariable(Var);
2204 Scope->addVariable(AbsDbgVariable);
2205 AbstractVariables[Var] = AbsDbgVariable;
2206 return AbsDbgVariable;
2209 /// collectVariableInfoFromMMITable - Collect variable information from
2210 /// side table maintained by MMI.
2212 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2213 SmallPtrSet<const MDNode *, 16> &Processed) {
2214 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2215 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2216 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2217 VE = VMap.end(); VI != VE; ++VI) {
2218 const MDNode *Var = VI->first;
2220 Processed.insert(Var);
2222 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2224 DbgScope *Scope = 0;
2225 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2226 Scope = ConcreteScopes.lookup(IA);
2228 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2230 // If variable scope is not found then skip this variable.
2234 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2235 DbgVariable *RegVar = new DbgVariable(DV);
2236 recordVariableFrameIndex(RegVar, VP.first);
2237 Scope->addVariable(RegVar);
2238 if (AbsDbgVariable) {
2239 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2240 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2245 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2246 /// DBG_VALUE instruction, is in undefined reg.
2247 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2248 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2249 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2254 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2255 /// DBG_VALUE instruction, is in a defined reg.
2256 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2257 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2258 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2263 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2265 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2266 SmallPtrSet<const MDNode *, 16> &Processed) {
2268 /// collection info from MMI table.
2269 collectVariableInfoFromMMITable(MF, Processed);
2271 SmallVector<const MachineInstr *, 8> DbgValues;
2272 // Collect variable information from DBG_VALUE machine instructions;
2273 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2275 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2277 const MachineInstr *MInsn = II;
2278 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2280 DbgValues.push_back(MInsn);
2283 // This is a collection of DBV_VALUE instructions describing same variable.
2284 SmallVector<const MachineInstr *, 4> MultipleValues;
2285 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2286 E = DbgValues.end(); I != E; ++I) {
2287 const MachineInstr *MInsn = *I;
2288 MultipleValues.clear();
2289 if (isDbgValueInDefinedReg(MInsn))
2290 MultipleValues.push_back(MInsn);
2291 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2292 if (Processed.count(DV) != 0)
2295 const MachineInstr *PrevMI = MInsn;
2296 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2297 ME = DbgValues.end(); MI != ME; ++MI) {
2299 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2300 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2301 !PrevMI->isIdenticalTo(*MI))
2302 MultipleValues.push_back(*MI);
2306 DbgScope *Scope = findDbgScope(MInsn);
2307 bool CurFnArg = false;
2308 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2309 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2311 if (!Scope && CurFnArg)
2312 Scope = CurrentFnDbgScope;
2313 // If variable scope is not found then skip this variable.
2317 Processed.insert(DV);
2318 DbgVariable *RegVar = new DbgVariable(DV);
2319 Scope->addVariable(RegVar);
2321 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2322 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2323 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2324 VarToAbstractVarMap[RegVar] = AbsVar;
2326 if (MultipleValues.size() <= 1) {
2327 DbgVariableToDbgInstMap[RegVar] = MInsn;
2331 // handle multiple DBG_VALUE instructions describing one variable.
2332 if (DotDebugLocEntries.empty())
2333 RegVar->setDotDebugLocOffset(0);
2335 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2336 const MachineInstr *Begin = NULL;
2337 const MachineInstr *End = NULL;
2338 for (SmallVector<const MachineInstr *, 4>::iterator
2339 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2340 MVI != MVE; ++MVI) {
2346 MachineLocation MLoc;
2347 if (Begin->getNumOperands() == 3) {
2348 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2349 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2351 MLoc = Asm->getDebugValueLocation(Begin);
2353 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2354 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2356 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2359 if (MVI + 1 == MVE) {
2360 // If End is the last instruction then its value is valid
2361 // until the end of the funtion.
2362 MachineLocation EMLoc;
2363 if (End->getNumOperands() == 3) {
2364 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2365 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2367 EMLoc = Asm->getDebugValueLocation(End);
2370 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2373 DotDebugLocEntries.push_back(DotDebugLocEntry());
2376 // Collect info for variables that were optimized out.
2377 const Function *F = MF->getFunction();
2378 const Module *M = F->getParent();
2379 if (NamedMDNode *NMD =
2380 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2381 getRealLinkageName(F->getName())))) {
2382 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2383 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2384 if (!DV || !Processed.insert(DV))
2386 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2388 Scope->addVariable(new DbgVariable(DV));
2393 /// getLabelBeforeInsn - Return Label preceding the instruction.
2394 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2395 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2396 LabelsBeforeInsn.find(MI);
2397 if (I == LabelsBeforeInsn.end())
2398 // FunctionBeginSym always preceeds all the instruction in current function.
2399 return FunctionBeginSym;
2403 /// getLabelAfterInsn - Return Label immediately following the instruction.
2404 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2405 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2406 LabelsAfterInsn.find(MI);
2407 if (I == LabelsAfterInsn.end())
2412 /// beginScope - Process beginning of a scope.
2413 void DwarfDebug::beginScope(const MachineInstr *MI) {
2414 if (InsnNeedsLabel.count(MI) == 0) {
2415 LabelsBeforeInsn[MI] = PrevLabel;
2420 DebugLoc DL = MI->getDebugLoc();
2421 if (!DL.isUnknown()) {
2422 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2423 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2425 LabelsBeforeInsn[MI] = PrevLabel;
2429 // If location is unknown then use temp label for this DBG_VALUE
2431 if (MI->isDebugValue()) {
2432 PrevLabel = MMI->getContext().CreateTempSymbol();
2433 Asm->OutStreamer.EmitLabel(PrevLabel);
2434 LabelsBeforeInsn[MI] = PrevLabel;
2438 if (UnknownLocations) {
2439 PrevLabel = recordSourceLine(0, 0, 0);
2440 LabelsBeforeInsn[MI] = PrevLabel;
2444 assert (0 && "Instruction is not processed!");
2447 /// endScope - Process end of a scope.
2448 void DwarfDebug::endScope(const MachineInstr *MI) {
2449 if (InsnsEndScopeSet.count(MI) != 0) {
2450 // Emit a label if this instruction ends a scope.
2451 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2452 Asm->OutStreamer.EmitLabel(Label);
2453 LabelsAfterInsn[MI] = Label;
2457 /// getOrCreateDbgScope - Create DbgScope for the scope.
2458 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2459 const MDNode *InlinedAt) {
2461 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2464 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2465 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2466 if (DIDescriptor(Scope).isLexicalBlock()) {
2468 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2469 WScope->setParent(Parent);
2470 Parent->addScope(WScope);
2473 if (!WScope->getParent()) {
2474 StringRef SPName = DISubprogram(Scope).getLinkageName();
2475 // We used to check only for a linkage name, but that fails
2476 // since we began omitting the linkage name for private
2477 // functions. The new way is to check for the name in metadata,
2478 // but that's not supported in old .ll test cases. Ergo, we
2480 if (SPName == Asm->MF->getFunction()->getName() ||
2481 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2482 CurrentFnDbgScope = WScope;
2488 getOrCreateAbstractScope(Scope);
2489 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2493 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2494 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2495 DILocation DL(InlinedAt);
2497 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2498 WScope->setParent(Parent);
2499 Parent->addScope(WScope);
2501 ConcreteScopes[InlinedAt] = WScope;
2506 /// hasValidLocation - Return true if debug location entry attached with
2507 /// machine instruction encodes valid location info.
2508 static bool hasValidLocation(LLVMContext &Ctx,
2509 const MachineInstr *MInsn,
2510 const MDNode *&Scope, const MDNode *&InlinedAt) {
2511 DebugLoc DL = MInsn->getDebugLoc();
2512 if (DL.isUnknown()) return false;
2514 const MDNode *S = DL.getScope(Ctx);
2516 // There is no need to create another DIE for compile unit. For all
2517 // other scopes, create one DbgScope now. This will be translated
2518 // into a scope DIE at the end.
2519 if (DIScope(S).isCompileUnit()) return false;
2522 InlinedAt = DL.getInlinedAt(Ctx);
2526 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2528 static void calculateDominanceGraph(DbgScope *Scope) {
2529 assert (Scope && "Unable to calculate scop edominance graph!");
2530 SmallVector<DbgScope *, 4> WorkStack;
2531 WorkStack.push_back(Scope);
2532 unsigned Counter = 0;
2533 while (!WorkStack.empty()) {
2534 DbgScope *WS = WorkStack.back();
2535 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2536 bool visitedChildren = false;
2537 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2538 SE = Children.end(); SI != SE; ++SI) {
2539 DbgScope *ChildScope = *SI;
2540 if (!ChildScope->getDFSOut()) {
2541 WorkStack.push_back(ChildScope);
2542 visitedChildren = true;
2543 ChildScope->setDFSIn(++Counter);
2547 if (!visitedChildren) {
2548 WorkStack.pop_back();
2549 WS->setDFSOut(++Counter);
2554 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2556 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2557 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2560 unsigned PrevDFSIn = 0;
2561 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2563 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2565 const MachineInstr *MInsn = II;
2566 const MDNode *Scope = NULL;
2567 const MDNode *InlinedAt = NULL;
2569 // Check if instruction has valid location information.
2570 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2574 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2575 MI2ScopeMap.find(MInsn);
2576 if (DI != MI2ScopeMap.end()) {
2577 DbgScope *S = DI->second;
2578 dbgs() << S->getDFSIn();
2579 PrevDFSIn = S->getDFSIn();
2581 dbgs() << PrevDFSIn;
2583 dbgs() << " [ x" << PrevDFSIn;
2591 /// extractScopeInformation - Scan machine instructions in this function
2592 /// and collect DbgScopes. Return true, if at least one scope was found.
2593 bool DwarfDebug::extractScopeInformation() {
2594 // If scope information was extracted using .dbg intrinsics then there is not
2595 // any need to extract these information by scanning each instruction.
2596 if (!DbgScopeMap.empty())
2599 // Scan each instruction and create scopes. First build working set of scopes.
2600 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2601 SmallVector<DbgRange, 4> MIRanges;
2602 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2603 const MDNode *PrevScope = NULL;
2604 const MDNode *PrevInlinedAt = NULL;
2605 const MachineInstr *RangeBeginMI = NULL;
2606 const MachineInstr *PrevMI = NULL;
2607 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2609 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2611 const MachineInstr *MInsn = II;
2612 const MDNode *Scope = NULL;
2613 const MDNode *InlinedAt = NULL;
2615 // Check if instruction has valid location information.
2616 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2621 // If scope has not changed then skip this instruction.
2622 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2628 // If we have alread seen a beginning of a instruction range and
2629 // current instruction scope does not match scope of first instruction
2630 // in this range then create a new instruction range.
2631 DbgRange R(RangeBeginMI, PrevMI);
2632 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2634 MIRanges.push_back(R);
2637 // This is a beginning of a new instruction range.
2638 RangeBeginMI = MInsn;
2640 // Reset previous markers.
2643 PrevInlinedAt = InlinedAt;
2647 // Create last instruction range.
2648 if (RangeBeginMI && PrevMI && PrevScope) {
2649 DbgRange R(RangeBeginMI, PrevMI);
2650 MIRanges.push_back(R);
2651 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2654 if (!CurrentFnDbgScope)
2657 calculateDominanceGraph(CurrentFnDbgScope);
2659 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2661 // Find ranges of instructions covered by each DbgScope;
2662 DbgScope *PrevDbgScope = NULL;
2663 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2664 RE = MIRanges.end(); RI != RE; ++RI) {
2665 const DbgRange &R = *RI;
2666 DbgScope *S = MI2ScopeMap.lookup(R.first);
2667 assert (S && "Lost DbgScope for a machine instruction!");
2668 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2669 PrevDbgScope->closeInsnRange(S);
2670 S->openInsnRange(R.first);
2671 S->extendInsnRange(R.second);
2676 PrevDbgScope->closeInsnRange();
2678 identifyScopeMarkers();
2680 return !DbgScopeMap.empty();
2683 /// identifyScopeMarkers() -
2684 /// Each DbgScope has first instruction and last instruction to mark beginning
2685 /// and end of a scope respectively. Create an inverse map that list scopes
2686 /// starts (and ends) with an instruction. One instruction may start (or end)
2687 /// multiple scopes. Ignore scopes that are not reachable.
2688 void DwarfDebug::identifyScopeMarkers() {
2689 SmallVector<DbgScope *, 4> WorkList;
2690 WorkList.push_back(CurrentFnDbgScope);
2691 while (!WorkList.empty()) {
2692 DbgScope *S = WorkList.pop_back_val();
2694 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2695 if (!Children.empty())
2696 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2697 SE = Children.end(); SI != SE; ++SI)
2698 WorkList.push_back(*SI);
2700 if (S->isAbstractScope())
2703 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2706 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2707 RE = Ranges.end(); RI != RE; ++RI) {
2708 assert(RI->first && "DbgRange does not have first instruction!");
2709 assert(RI->second && "DbgRange does not have second instruction!");
2710 InsnsEndScopeSet.insert(RI->second);
2715 /// FindFirstDebugLoc - Find the first debug location in the function. This
2716 /// is intended to be an approximation for the source position of the
2717 /// beginning of the function.
2718 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2719 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2721 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2722 MBBI != MBBE; ++MBBI) {
2723 DebugLoc DL = MBBI->getDebugLoc();
2724 if (!DL.isUnknown())
2730 /// beginFunction - Gather pre-function debug information. Assumes being
2731 /// emitted immediately after the function entry point.
2732 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2733 if (!MMI->hasDebugInfo()) return;
2734 if (!extractScopeInformation()) return;
2736 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2737 Asm->getFunctionNumber());
2738 // Assumes in correct section after the entry point.
2739 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2741 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2743 DebugLoc FDL = FindFirstDebugLoc(MF);
2744 if (FDL.isUnknown()) return;
2746 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2747 const MDNode *TheScope = 0;
2749 DISubprogram SP = getDISubprogram(Scope);
2752 Line = SP.getLineNumber();
2756 Line = FDL.getLine();
2761 recordSourceLine(Line, Col, TheScope);
2763 /// ProcessedArgs - Collection of arguments already processed.
2764 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2767 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2769 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2771 const MachineInstr *MI = II;
2772 DebugLoc DL = MI->getDebugLoc();
2773 if (MI->isDebugValue()) {
2774 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2775 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2776 if (!DV.Verify()) continue;
2777 // If DBG_VALUE is for a local variable then it needs a label.
2778 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2779 && isDbgValueInUndefinedReg(MI) == false)
2780 InsnNeedsLabel.insert(MI);
2781 // DBG_VALUE for inlined functions argument needs a label.
2782 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2783 describes(MF->getFunction()))
2784 InsnNeedsLabel.insert(MI);
2785 // DBG_VALUE indicating argument location change needs a label.
2786 else if (isDbgValueInUndefinedReg(MI) == false
2787 && !ProcessedArgs.insert(DV))
2788 InsnNeedsLabel.insert(MI);
2790 // If location is unknown then instruction needs a location only if
2791 // UnknownLocations flag is set.
2792 if (DL.isUnknown()) {
2793 if (UnknownLocations && !PrevLoc.isUnknown())
2794 InsnNeedsLabel.insert(MI);
2795 } else if (DL != PrevLoc)
2796 // Otherwise, instruction needs a location only if it is new location.
2797 InsnNeedsLabel.insert(MI);
2800 if (!DL.isUnknown() || UnknownLocations)
2804 PrevLabel = FunctionBeginSym;
2807 /// endFunction - Gather and emit post-function debug information.
2809 void DwarfDebug::endFunction(const MachineFunction *MF) {
2810 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2812 if (CurrentFnDbgScope) {
2814 // Define end label for subprogram.
2815 FunctionEndSym = Asm->GetTempSymbol("func_end",
2816 Asm->getFunctionNumber());
2817 // Assumes in correct section after the entry point.
2818 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2820 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2821 collectVariableInfo(MF, ProcessedVars);
2823 // Get function line info.
2824 if (!Lines.empty()) {
2825 // Get section line info.
2826 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2827 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2828 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2829 // Append the function info to section info.
2830 SectionLineInfos.insert(SectionLineInfos.end(),
2831 Lines.begin(), Lines.end());
2834 // Construct abstract scopes.
2835 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2836 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2837 DISubprogram SP((*AI)->getScopeNode());
2839 // Collect info for variables that were optimized out.
2840 StringRef FName = SP.getLinkageName();
2842 FName = SP.getName();
2843 const Module *M = MF->getFunction()->getParent();
2844 if (NamedMDNode *NMD =
2845 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2846 getRealLinkageName(FName)))) {
2847 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2848 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2849 if (!DV || !ProcessedVars.insert(DV))
2851 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2853 Scope->addVariable(new DbgVariable(DV));
2857 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2858 constructScopeDIE(*AI);
2861 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2863 if (!DisableFramePointerElim(*MF))
2864 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2865 dwarf::DW_FORM_flag, 1);
2868 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2869 MMI->getFrameMoves()));
2873 CurrentFnDbgScope = NULL;
2874 InsnNeedsLabel.clear();
2875 DbgVariableToFrameIndexMap.clear();
2876 VarToAbstractVarMap.clear();
2877 DbgVariableToDbgInstMap.clear();
2878 DbgVariableLabelsMap.clear();
2879 DeleteContainerSeconds(DbgScopeMap);
2880 InsnsEndScopeSet.clear();
2881 ConcreteScopes.clear();
2882 DeleteContainerSeconds(AbstractScopes);
2883 AbstractScopesList.clear();
2884 AbstractVariables.clear();
2885 LabelsBeforeInsn.clear();
2886 LabelsAfterInsn.clear();
2891 /// recordVariableFrameIndex - Record a variable's index.
2892 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2893 assert (V && "Invalid DbgVariable!");
2894 DbgVariableToFrameIndexMap[V] = Index;
2897 /// findVariableFrameIndex - Return true if frame index for the variable
2898 /// is found. Update FI to hold value of the index.
2899 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2900 assert (V && "Invalid DbgVariable!");
2901 DenseMap<const DbgVariable *, int>::iterator I =
2902 DbgVariableToFrameIndexMap.find(V);
2903 if (I == DbgVariableToFrameIndexMap.end())
2909 /// findVariableLabel - Find MCSymbol for the variable.
2910 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2911 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2912 = DbgVariableLabelsMap.find(V);
2913 if (I == DbgVariableLabelsMap.end())
2915 else return I->second;
2918 /// findDbgScope - Find DbgScope for the debug loc attached with an
2920 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2921 DbgScope *Scope = NULL;
2923 MInsn->getParent()->getParent()->getFunction()->getContext();
2924 DebugLoc DL = MInsn->getDebugLoc();
2929 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2930 Scope = ConcreteScopes.lookup(IA);
2932 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2938 /// recordSourceLine - Register a source line with debug info. Returns the
2939 /// unique label that was emitted and which provides correspondence to
2940 /// the source line list.
2941 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2948 DIDescriptor Scope(S);
2950 if (Scope.isCompileUnit()) {
2951 DICompileUnit CU(S);
2952 Dir = CU.getDirectory();
2953 Fn = CU.getFilename();
2954 } else if (Scope.isSubprogram()) {
2956 Dir = SP.getDirectory();
2957 Fn = SP.getFilename();
2958 } else if (Scope.isLexicalBlock()) {
2959 DILexicalBlock DB(S);
2960 Dir = DB.getDirectory();
2961 Fn = DB.getFilename();
2963 assert(0 && "Unexpected scope info");
2965 Src = GetOrCreateSourceID(Dir, Fn);
2968 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2969 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2971 Asm->OutStreamer.EmitLabel(Label);
2975 //===----------------------------------------------------------------------===//
2977 //===----------------------------------------------------------------------===//
2979 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2982 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2983 // Get the children.
2984 const std::vector<DIE *> &Children = Die->getChildren();
2986 // If not last sibling and has children then add sibling offset attribute.
2987 if (!Last && !Children.empty())
2988 Die->addSiblingOffset(DIEValueAllocator);
2990 // Record the abbreviation.
2991 assignAbbrevNumber(Die->getAbbrev());
2993 // Get the abbreviation for this DIE.
2994 unsigned AbbrevNumber = Die->getAbbrevNumber();
2995 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
2998 Die->setOffset(Offset);
3000 // Start the size with the size of abbreviation code.
3001 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3003 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3004 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3006 // Size the DIE attribute values.
3007 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3008 // Size attribute value.
3009 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3011 // Size the DIE children if any.
3012 if (!Children.empty()) {
3013 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3014 "Children flag not set");
3016 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3017 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3019 // End of children marker.
3020 Offset += sizeof(int8_t);
3023 Die->setSize(Offset - Die->getOffset());
3027 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3029 void DwarfDebug::computeSizeAndOffsets() {
3030 unsigned PrevOffset = 0;
3031 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3032 E = CUMap.end(); I != E; ++I) {
3033 // Compute size of compile unit header.
3034 static unsigned Offset = PrevOffset +
3035 sizeof(int32_t) + // Length of Compilation Unit Info
3036 sizeof(int16_t) + // DWARF version number
3037 sizeof(int32_t) + // Offset Into Abbrev. Section
3038 sizeof(int8_t); // Pointer Size (in bytes)
3039 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3040 PrevOffset = Offset;
3044 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3045 /// temporary label to it if SymbolStem is specified.
3046 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3047 const char *SymbolStem = 0) {
3048 Asm->OutStreamer.SwitchSection(Section);
3049 if (!SymbolStem) return 0;
3051 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3052 Asm->OutStreamer.EmitLabel(TmpSym);
3056 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3057 /// the start of each one.
3058 void DwarfDebug::EmitSectionLabels() {
3059 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3061 // Dwarf sections base addresses.
3062 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3063 DwarfFrameSectionSym =
3064 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3067 DwarfInfoSectionSym =
3068 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3069 DwarfAbbrevSectionSym =
3070 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3071 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3073 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3074 EmitSectionSym(Asm, MacroInfo);
3076 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3077 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3078 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3079 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3080 DwarfStrSectionSym =
3081 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3082 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3085 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3086 "section_debug_loc");
3088 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3089 EmitSectionSym(Asm, TLOF.getDataSection());
3092 /// emitDIE - Recusively Emits a debug information entry.
3094 void DwarfDebug::emitDIE(DIE *Die) {
3095 // Get the abbreviation for this DIE.
3096 unsigned AbbrevNumber = Die->getAbbrevNumber();
3097 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3099 // Emit the code (index) for the abbreviation.
3100 if (Asm->isVerbose())
3101 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3102 Twine::utohexstr(Die->getOffset()) + ":0x" +
3103 Twine::utohexstr(Die->getSize()) + " " +
3104 dwarf::TagString(Abbrev->getTag()));
3105 Asm->EmitULEB128(AbbrevNumber);
3107 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3108 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3110 // Emit the DIE attribute values.
3111 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3112 unsigned Attr = AbbrevData[i].getAttribute();
3113 unsigned Form = AbbrevData[i].getForm();
3114 assert(Form && "Too many attributes for DIE (check abbreviation)");
3116 if (Asm->isVerbose())
3117 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3120 case dwarf::DW_AT_sibling:
3121 Asm->EmitInt32(Die->getSiblingOffset());
3123 case dwarf::DW_AT_abstract_origin: {
3124 DIEEntry *E = cast<DIEEntry>(Values[i]);
3125 DIE *Origin = E->getEntry();
3126 unsigned Addr = Origin->getOffset();
3127 Asm->EmitInt32(Addr);
3130 case dwarf::DW_AT_ranges: {
3131 // DW_AT_range Value encodes offset in debug_range section.
3132 DIEInteger *V = cast<DIEInteger>(Values[i]);
3133 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3135 DwarfDebugRangeSectionSym,
3139 case dwarf::DW_AT_location: {
3140 if (UseDotDebugLocEntry.count(Die) != 0) {
3141 DIELabel *L = cast<DIELabel>(Values[i]);
3142 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3144 Values[i]->EmitValue(Asm, Form);
3148 // Emit an attribute using the defined form.
3149 Values[i]->EmitValue(Asm, Form);
3154 // Emit the DIE children if any.
3155 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3156 const std::vector<DIE *> &Children = Die->getChildren();
3158 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3159 emitDIE(Children[j]);
3161 if (Asm->isVerbose())
3162 Asm->OutStreamer.AddComment("End Of Children Mark");
3167 /// emitDebugInfo - Emit the debug info section.
3169 void DwarfDebug::emitDebugInfo() {
3170 // Start debug info section.
3171 Asm->OutStreamer.SwitchSection(
3172 Asm->getObjFileLowering().getDwarfInfoSection());
3173 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3174 E = CUMap.end(); I != E; ++I) {
3175 CompileUnit *TheCU = I->second;
3176 DIE *Die = TheCU->getCUDie();
3178 // Emit the compile units header.
3179 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3182 // Emit size of content not including length itself
3183 unsigned ContentSize = Die->getSize() +
3184 sizeof(int16_t) + // DWARF version number
3185 sizeof(int32_t) + // Offset Into Abbrev. Section
3186 sizeof(int8_t) + // Pointer Size (in bytes)
3187 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3189 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3190 Asm->EmitInt32(ContentSize);
3191 Asm->OutStreamer.AddComment("DWARF version number");
3192 Asm->EmitInt16(dwarf::DWARF_VERSION);
3193 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3194 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3195 DwarfAbbrevSectionSym);
3196 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3197 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3200 // FIXME - extra padding for gdb bug.
3201 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3206 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3210 /// emitAbbreviations - Emit the abbreviation section.
3212 void DwarfDebug::emitAbbreviations() const {
3213 // Check to see if it is worth the effort.
3214 if (!Abbreviations.empty()) {
3215 // Start the debug abbrev section.
3216 Asm->OutStreamer.SwitchSection(
3217 Asm->getObjFileLowering().getDwarfAbbrevSection());
3219 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3221 // For each abbrevation.
3222 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3223 // Get abbreviation data
3224 const DIEAbbrev *Abbrev = Abbreviations[i];
3226 // Emit the abbrevations code (base 1 index.)
3227 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3229 // Emit the abbreviations data.
3233 // Mark end of abbreviations.
3234 Asm->EmitULEB128(0, "EOM(3)");
3236 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3240 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3241 /// the line matrix.
3243 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3244 // Define last address of section.
3245 Asm->OutStreamer.AddComment("Extended Op");
3248 Asm->OutStreamer.AddComment("Op size");
3249 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3250 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3251 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3253 Asm->OutStreamer.AddComment("Section end label");
3255 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3256 Asm->getTargetData().getPointerSize(),
3259 // Mark end of matrix.
3260 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3266 /// emitDebugLines - Emit source line information.
3268 void DwarfDebug::emitDebugLines() {
3269 // If the target is using .loc/.file, the assembler will be emitting the
3270 // .debug_line table automatically.
3271 if (Asm->MAI->hasDotLocAndDotFile())
3274 // Minimum line delta, thus ranging from -10..(255-10).
3275 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3276 // Maximum line delta, thus ranging from -10..(255-10).
3277 const int MaxLineDelta = 255 + MinLineDelta;
3279 // Start the dwarf line section.
3280 Asm->OutStreamer.SwitchSection(
3281 Asm->getObjFileLowering().getDwarfLineSection());
3283 // Construct the section header.
3284 Asm->OutStreamer.AddComment("Length of Source Line Info");
3285 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3286 Asm->GetTempSymbol("line_begin"), 4);
3287 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3289 Asm->OutStreamer.AddComment("DWARF version number");
3290 Asm->EmitInt16(dwarf::DWARF_VERSION);
3292 Asm->OutStreamer.AddComment("Prolog Length");
3293 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3294 Asm->GetTempSymbol("line_prolog_begin"), 4);
3295 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3297 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3299 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3301 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3302 Asm->EmitInt8(MinLineDelta);
3303 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3304 Asm->EmitInt8(MaxLineDelta);
3305 Asm->OutStreamer.AddComment("Special Opcode Base");
3306 Asm->EmitInt8(-MinLineDelta);
3308 // Line number standard opcode encodings argument count
3309 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3311 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3313 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3315 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3317 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3319 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3321 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3323 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3325 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3328 // Emit directories.
3329 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3330 const std::string &Dir = getSourceDirectoryName(DI);
3331 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3332 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3335 Asm->OutStreamer.AddComment("End of directories");
3339 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3340 // Remember source id starts at 1.
3341 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3342 const std::string &FN = getSourceFileName(Id.second);
3343 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3344 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3346 Asm->EmitULEB128(Id.first, "Directory #");
3347 Asm->EmitULEB128(0, "Mod date");
3348 Asm->EmitULEB128(0, "File size");
3351 Asm->OutStreamer.AddComment("End of files");
3354 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3356 // A sequence for each text section.
3357 unsigned SecSrcLinesSize = SectionSourceLines.size();
3359 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3360 // Isolate current sections line info.
3361 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3363 // Dwarf assumes we start with first line of first source file.
3364 unsigned Source = 1;
3367 // Construct rows of the address, source, line, column matrix.
3368 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3369 const SrcLineInfo &LineInfo = LineInfos[i];
3370 MCSymbol *Label = LineInfo.getLabel();
3371 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3373 if (Asm->isVerbose()) {
3374 std::pair<unsigned, unsigned> SrcID =
3375 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3376 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3378 Twine(getSourceFileName(SrcID.second)) +
3379 ":" + Twine(LineInfo.getLine()));
3382 // Define the line address.
3383 Asm->OutStreamer.AddComment("Extended Op");
3385 Asm->OutStreamer.AddComment("Op size");
3386 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3388 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3389 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3391 Asm->OutStreamer.AddComment("Location label");
3392 Asm->OutStreamer.EmitSymbolValue(Label,
3393 Asm->getTargetData().getPointerSize(),
3396 // If change of source, then switch to the new source.
3397 if (Source != LineInfo.getSourceID()) {
3398 Source = LineInfo.getSourceID();
3399 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3400 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3401 Asm->EmitULEB128(Source, "New Source");
3404 // If change of line.
3405 if (Line != LineInfo.getLine()) {
3406 // Determine offset.
3407 int Offset = LineInfo.getLine() - Line;
3408 int Delta = Offset - MinLineDelta;
3411 Line = LineInfo.getLine();
3413 // If delta is small enough and in range...
3414 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3415 // ... then use fast opcode.
3416 Asm->OutStreamer.AddComment("Line Delta");
3417 Asm->EmitInt8(Delta - MinLineDelta);
3419 // ... otherwise use long hand.
3420 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3421 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3422 Asm->EmitSLEB128(Offset, "Line Offset");
3423 Asm->OutStreamer.AddComment("DW_LNS_copy");
3424 Asm->EmitInt8(dwarf::DW_LNS_copy);
3427 // Copy the previous row (different address or source)
3428 Asm->OutStreamer.AddComment("DW_LNS_copy");
3429 Asm->EmitInt8(dwarf::DW_LNS_copy);
3433 emitEndOfLineMatrix(j + 1);
3436 if (SecSrcLinesSize == 0)
3437 // Because we're emitting a debug_line section, we still need a line
3438 // table. The linker and friends expect it to exist. If there's nothing to
3439 // put into it, emit an empty table.
3440 emitEndOfLineMatrix(1);
3442 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3445 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3447 void DwarfDebug::emitCommonDebugFrame() {
3448 if (!Asm->MAI->doesDwarfRequireFrameSection())
3451 int stackGrowth = Asm->getTargetData().getPointerSize();
3452 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3453 TargetFrameInfo::StackGrowsDown)
3456 // Start the dwarf frame section.
3457 Asm->OutStreamer.SwitchSection(
3458 Asm->getObjFileLowering().getDwarfFrameSection());
3460 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3461 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3462 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3463 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3465 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3466 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3467 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3468 Asm->OutStreamer.AddComment("CIE Version");
3469 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3470 Asm->OutStreamer.AddComment("CIE Augmentation");
3471 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3472 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3473 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3474 Asm->OutStreamer.AddComment("CIE RA Column");
3475 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3476 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3478 std::vector<MachineMove> Moves;
3479 RI->getInitialFrameState(Moves);
3481 Asm->EmitFrameMoves(Moves, 0, false);
3483 Asm->EmitAlignment(2);
3484 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3487 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3490 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3491 if (!Asm->MAI->doesDwarfRequireFrameSection())
3494 // Start the dwarf frame section.
3495 Asm->OutStreamer.SwitchSection(
3496 Asm->getObjFileLowering().getDwarfFrameSection());
3498 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3499 MCSymbol *DebugFrameBegin =
3500 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3501 MCSymbol *DebugFrameEnd =
3502 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3503 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3505 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3507 Asm->OutStreamer.AddComment("FDE CIE offset");
3508 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3509 DwarfFrameSectionSym);
3511 Asm->OutStreamer.AddComment("FDE initial location");
3512 MCSymbol *FuncBeginSym =
3513 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3514 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3515 Asm->getTargetData().getPointerSize(),
3519 Asm->OutStreamer.AddComment("FDE address range");
3520 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3521 FuncBeginSym, Asm->getTargetData().getPointerSize());
3523 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3525 Asm->EmitAlignment(2);
3526 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3529 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3531 void DwarfDebug::emitDebugPubNames() {
3532 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3533 E = CUMap.end(); I != E; ++I) {
3534 CompileUnit *TheCU = I->second;
3535 // Start the dwarf pubnames section.
3536 Asm->OutStreamer.SwitchSection(
3537 Asm->getObjFileLowering().getDwarfPubNamesSection());
3539 Asm->OutStreamer.AddComment("Length of Public Names Info");
3540 Asm->EmitLabelDifference(
3541 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3542 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3544 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3547 Asm->OutStreamer.AddComment("DWARF Version");
3548 Asm->EmitInt16(dwarf::DWARF_VERSION);
3550 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3551 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3552 DwarfInfoSectionSym);
3554 Asm->OutStreamer.AddComment("Compilation Unit Length");
3555 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3556 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3559 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3560 for (StringMap<DIE*>::const_iterator
3561 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3562 const char *Name = GI->getKeyData();
3563 DIE *Entity = GI->second;
3565 Asm->OutStreamer.AddComment("DIE offset");
3566 Asm->EmitInt32(Entity->getOffset());
3568 if (Asm->isVerbose())
3569 Asm->OutStreamer.AddComment("External Name");
3570 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3573 Asm->OutStreamer.AddComment("End Mark");
3575 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3580 void DwarfDebug::emitDebugPubTypes() {
3581 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3582 E = CUMap.end(); I != E; ++I) {
3583 CompileUnit *TheCU = I->second;
3584 // Start the dwarf pubnames section.
3585 Asm->OutStreamer.SwitchSection(
3586 Asm->getObjFileLowering().getDwarfPubTypesSection());
3587 Asm->OutStreamer.AddComment("Length of Public Types Info");
3588 Asm->EmitLabelDifference(
3589 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3590 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3592 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3595 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3596 Asm->EmitInt16(dwarf::DWARF_VERSION);
3598 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3599 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3600 DwarfInfoSectionSym);
3602 Asm->OutStreamer.AddComment("Compilation Unit Length");
3603 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3604 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3607 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3608 for (StringMap<DIE*>::const_iterator
3609 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3610 const char *Name = GI->getKeyData();
3611 DIE * Entity = GI->second;
3613 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3614 Asm->EmitInt32(Entity->getOffset());
3616 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3617 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3620 Asm->OutStreamer.AddComment("End Mark");
3622 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3627 /// emitDebugStr - Emit visible names into a debug str section.
3629 void DwarfDebug::emitDebugStr() {
3630 // Check to see if it is worth the effort.
3631 if (StringPool.empty()) return;
3633 // Start the dwarf str section.
3634 Asm->OutStreamer.SwitchSection(
3635 Asm->getObjFileLowering().getDwarfStrSection());
3637 // Get all of the string pool entries and put them in an array by their ID so
3638 // we can sort them.
3639 SmallVector<std::pair<unsigned,
3640 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3642 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3643 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3644 Entries.push_back(std::make_pair(I->second.second, &*I));
3646 array_pod_sort(Entries.begin(), Entries.end());
3648 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3649 // Emit a label for reference from debug information entries.
3650 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3652 // Emit the string itself.
3653 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3657 /// emitDebugLoc - Emit visible names into a debug loc section.
3659 void DwarfDebug::emitDebugLoc() {
3660 if (DotDebugLocEntries.empty())
3663 // Start the dwarf loc section.
3664 Asm->OutStreamer.SwitchSection(
3665 Asm->getObjFileLowering().getDwarfLocSection());
3666 unsigned char Size = Asm->getTargetData().getPointerSize();
3667 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3669 for (SmallVector<DotDebugLocEntry, 4>::iterator
3670 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3671 I != E; ++I, ++index) {
3672 DotDebugLocEntry Entry = *I;
3673 if (Entry.isEmpty()) {
3674 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3675 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3676 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3678 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3679 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3680 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3681 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3682 if (int Offset = Entry.Loc.getOffset()) {
3683 // If the value is at a certain offset from frame register then
3685 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3686 Asm->OutStreamer.AddComment("Loc expr size");
3687 Asm->EmitInt16(1 + OffsetSize);
3688 Asm->OutStreamer.AddComment(
3689 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3690 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3691 Asm->OutStreamer.AddComment("Offset");
3692 Asm->EmitSLEB128(Offset);
3695 Asm->OutStreamer.AddComment("Loc expr size");
3697 Asm->OutStreamer.AddComment(
3698 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3699 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3701 Asm->OutStreamer.AddComment("Loc expr size");
3702 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3703 Asm->EmitInt8(dwarf::DW_OP_regx);
3704 Asm->EmitULEB128(Reg);
3711 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3713 void DwarfDebug::EmitDebugARanges() {
3714 // Start the dwarf aranges section.
3715 Asm->OutStreamer.SwitchSection(
3716 Asm->getObjFileLowering().getDwarfARangesSection());
3719 /// emitDebugRanges - Emit visible names into a debug ranges section.
3721 void DwarfDebug::emitDebugRanges() {
3722 // Start the dwarf ranges section.
3723 Asm->OutStreamer.SwitchSection(
3724 Asm->getObjFileLowering().getDwarfRangesSection());
3725 unsigned char Size = Asm->getTargetData().getPointerSize();
3726 for (SmallVector<const MCSymbol *, 8>::iterator
3727 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3730 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3732 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3736 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3738 void DwarfDebug::emitDebugMacInfo() {
3739 if (const MCSection *LineInfo =
3740 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3741 // Start the dwarf macinfo section.
3742 Asm->OutStreamer.SwitchSection(LineInfo);
3746 /// emitDebugInlineInfo - Emit inline info using following format.
3748 /// 1. length of section
3749 /// 2. Dwarf version number
3750 /// 3. address size.
3752 /// Entries (one "entry" for each function that was inlined):
3754 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3755 /// otherwise offset into __debug_str for regular function name.
3756 /// 2. offset into __debug_str section for regular function name.
3757 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3758 /// instances for the function.
3760 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3761 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3762 /// __debug_info section, and the low_pc is the starting address for the
3763 /// inlining instance.
3764 void DwarfDebug::emitDebugInlineInfo() {
3765 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3771 Asm->OutStreamer.SwitchSection(
3772 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3774 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3775 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3776 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3778 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3780 Asm->OutStreamer.AddComment("Dwarf Version");
3781 Asm->EmitInt16(dwarf::DWARF_VERSION);
3782 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3783 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3785 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3786 E = InlinedSPNodes.end(); I != E; ++I) {
3788 const MDNode *Node = *I;
3789 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3790 = InlineInfo.find(Node);
3791 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3792 DISubprogram SP(Node);
3793 StringRef LName = SP.getLinkageName();
3794 StringRef Name = SP.getName();
3796 Asm->OutStreamer.AddComment("MIPS linkage name");
3797 if (LName.empty()) {
3798 Asm->OutStreamer.EmitBytes(Name, 0);
3799 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3801 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3802 DwarfStrSectionSym);
3804 Asm->OutStreamer.AddComment("Function name");
3805 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3806 Asm->EmitULEB128(Labels.size(), "Inline count");
3808 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3809 LE = Labels.end(); LI != LE; ++LI) {
3810 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3811 Asm->EmitInt32(LI->second->getOffset());
3813 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3814 Asm->OutStreamer.EmitSymbolValue(LI->first,
3815 Asm->getTargetData().getPointerSize(),0);
3819 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));