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();
814 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
816 if (TRI->getFrameRegister(*Asm->MF) == Location.getReg()
817 && Location.getOffset()) {
818 // If variable offset is based in frame register then use fbreg.
819 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
820 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
821 addBlock(Die, Attribute, 0, Block);
825 if (Location.isReg()) {
827 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
829 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
830 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
834 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
836 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
837 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
840 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
843 addBlock(Die, Attribute, 0, Block);
846 /// addRegisterAddress - Add register location entry in variable DIE.
847 bool DwarfDebug::addRegisterAddress(DIE *Die, const MCSymbol *VS,
848 const MachineOperand &MO) {
849 assert (MO.isReg() && "Invalid machine operand!");
852 MachineLocation Location;
853 Location.set(MO.getReg());
854 addAddress(Die, dwarf::DW_AT_location, Location);
856 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
860 /// addConstantValue - Add constant value entry in variable DIE.
861 bool DwarfDebug::addConstantValue(DIE *Die, const MCSymbol *VS,
862 const MachineOperand &MO) {
863 assert (MO.isImm() && "Invalid machine operand!");
864 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
865 unsigned Imm = MO.getImm();
866 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
867 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
869 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
873 /// addConstantFPValue - Add constant value entry in variable DIE.
874 bool DwarfDebug::addConstantFPValue(DIE *Die, const MCSymbol *VS,
875 const MachineOperand &MO) {
876 assert (MO.isFPImm() && "Invalid machine operand!");
877 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
878 APFloat FPImm = MO.getFPImm()->getValueAPF();
880 // Get the raw data form of the floating point.
881 const APInt FltVal = FPImm.bitcastToAPInt();
882 const char *FltPtr = (const char*)FltVal.getRawData();
884 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
885 bool LittleEndian = Asm->getTargetData().isLittleEndian();
886 int Incr = (LittleEndian ? 1 : -1);
887 int Start = (LittleEndian ? 0 : NumBytes - 1);
888 int Stop = (LittleEndian ? NumBytes : -1);
890 // Output the constant to DWARF one byte at a time.
891 for (; Start != Stop; Start += Incr)
892 addUInt(Block, 0, dwarf::DW_FORM_data1,
893 (unsigned char)0xFF & FltPtr[Start]);
895 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
897 addLabel(Die, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr, VS);
902 /// addToContextOwner - Add Die into the list of its context owner's children.
903 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
904 if (Context.isType()) {
905 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
906 ContextDIE->addChild(Die);
907 } else if (Context.isNameSpace()) {
908 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
909 ContextDIE->addChild(Die);
910 } else if (Context.isSubprogram()) {
911 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context),
913 ContextDIE->addChild(Die);
914 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
915 ContextDIE->addChild(Die);
917 getCompileUnit(Context)->addDie(Die);
920 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
922 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
923 CompileUnit *TypeCU = getCompileUnit(Ty);
924 DIE *TyDIE = TypeCU->getDIE(Ty);
929 TyDIE = new DIE(dwarf::DW_TAG_base_type);
930 TypeCU->insertDIE(Ty, TyDIE);
931 if (Ty.isBasicType())
932 constructTypeDIE(*TyDIE, DIBasicType(Ty));
933 else if (Ty.isCompositeType())
934 constructTypeDIE(*TyDIE, DICompositeType(Ty));
936 assert(Ty.isDerivedType() && "Unknown kind of DIType");
937 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
940 addToContextOwner(TyDIE, Ty.getContext());
944 /// addType - Add a new type attribute to the specified entity.
945 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
949 // Check for pre-existence.
950 CompileUnit *TypeCU = getCompileUnit(Ty);
951 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
952 // If it exists then use the existing value.
954 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
959 DIE *Buffer = getOrCreateTypeDIE(Ty);
962 Entry = createDIEEntry(Buffer);
963 TypeCU->insertDIEEntry(Ty, Entry);
965 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
968 /// constructTypeDIE - Construct basic type die from DIBasicType.
969 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
970 // Get core information.
971 StringRef Name = BTy.getName();
972 Buffer.setTag(dwarf::DW_TAG_base_type);
973 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
976 // Add name if not anonymous or intermediate type.
978 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
979 uint64_t Size = BTy.getSizeInBits() >> 3;
980 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
983 /// constructTypeDIE - Construct derived type die from DIDerivedType.
984 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
985 // Get core information.
986 StringRef Name = DTy.getName();
987 uint64_t Size = DTy.getSizeInBits() >> 3;
988 unsigned Tag = DTy.getTag();
990 // FIXME - Workaround for templates.
991 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
995 // Map to main type, void will not have a type.
996 DIType FromTy = DTy.getTypeDerivedFrom();
997 addType(&Buffer, FromTy);
999 // Add name if not anonymous or intermediate type.
1001 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1003 // Add size if non-zero (derived types might be zero-sized.)
1005 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1007 // Add source line info if available and TyDesc is not a forward declaration.
1008 if (!DTy.isForwardDecl())
1009 addSourceLine(&Buffer, DTy);
1012 /// constructTypeDIE - Construct type DIE from DICompositeType.
1013 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1014 // Get core information.
1015 StringRef Name = CTy.getName();
1017 uint64_t Size = CTy.getSizeInBits() >> 3;
1018 unsigned Tag = CTy.getTag();
1022 case dwarf::DW_TAG_vector_type:
1023 case dwarf::DW_TAG_array_type:
1024 constructArrayTypeDIE(Buffer, &CTy);
1026 case dwarf::DW_TAG_enumeration_type: {
1027 DIArray Elements = CTy.getTypeArray();
1029 // Add enumerators to enumeration type.
1030 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1031 DIE *ElemDie = NULL;
1032 DIDescriptor Enum(Elements.getElement(i));
1033 if (Enum.isEnumerator()) {
1034 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1035 Buffer.addChild(ElemDie);
1040 case dwarf::DW_TAG_subroutine_type: {
1042 DIArray Elements = CTy.getTypeArray();
1043 DIDescriptor RTy = Elements.getElement(0);
1044 addType(&Buffer, DIType(RTy));
1046 // Add prototype flag.
1047 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1050 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1051 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1052 DIDescriptor Ty = Elements.getElement(i);
1053 addType(Arg, DIType(Ty));
1054 Buffer.addChild(Arg);
1058 case dwarf::DW_TAG_structure_type:
1059 case dwarf::DW_TAG_union_type:
1060 case dwarf::DW_TAG_class_type: {
1061 // Add elements to structure type.
1062 DIArray Elements = CTy.getTypeArray();
1064 // A forward struct declared type may not have elements available.
1065 unsigned N = Elements.getNumElements();
1069 // Add elements to structure type.
1070 for (unsigned i = 0; i < N; ++i) {
1071 DIDescriptor Element = Elements.getElement(i);
1072 DIE *ElemDie = NULL;
1073 if (Element.isSubprogram())
1074 ElemDie = createSubprogramDIE(DISubprogram(Element));
1075 else if (Element.isVariable()) {
1076 DIVariable DV(Element);
1077 ElemDie = new DIE(dwarf::DW_TAG_variable);
1078 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1080 addType(ElemDie, DV.getType());
1081 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1082 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1083 addSourceLine(ElemDie, DV);
1084 } else if (Element.isDerivedType())
1085 ElemDie = createMemberDIE(DIDerivedType(Element));
1088 Buffer.addChild(ElemDie);
1091 if (CTy.isAppleBlockExtension())
1092 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1094 unsigned RLang = CTy.getRunTimeLang();
1096 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1097 dwarf::DW_FORM_data1, RLang);
1099 DICompositeType ContainingType = CTy.getContainingType();
1100 if (DIDescriptor(ContainingType).isCompositeType())
1101 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1102 getOrCreateTypeDIE(DIType(ContainingType)));
1104 DIDescriptor Context = CTy.getContext();
1105 addToContextOwner(&Buffer, Context);
1113 // Add name if not anonymous or intermediate type.
1115 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1117 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1118 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1120 // Add size if non-zero (derived types might be zero-sized.)
1122 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1124 // Add zero size if it is not a forward declaration.
1125 if (CTy.isForwardDecl())
1126 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1128 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1131 // Add source line info if available.
1132 if (!CTy.isForwardDecl())
1133 addSourceLine(&Buffer, CTy);
1137 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1138 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1139 int64_t L = SR.getLo();
1140 int64_t H = SR.getHi();
1141 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1143 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1145 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1146 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1148 Buffer.addChild(DW_Subrange);
1151 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1152 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1153 DICompositeType *CTy) {
1154 Buffer.setTag(dwarf::DW_TAG_array_type);
1155 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1156 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1158 // Emit derived type.
1159 addType(&Buffer, CTy->getTypeDerivedFrom());
1160 DIArray Elements = CTy->getTypeArray();
1162 // Get an anonymous type for index type.
1163 CompileUnit *TheCU = getCompileUnit(*CTy);
1164 DIE *IdxTy = TheCU->getIndexTyDie();
1166 // Construct an anonymous type for index type.
1167 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1168 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1169 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1170 dwarf::DW_ATE_signed);
1171 TheCU->addDie(IdxTy);
1172 TheCU->setIndexTyDie(IdxTy);
1175 // Add subranges to array type.
1176 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1177 DIDescriptor Element = Elements.getElement(i);
1178 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1179 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1183 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1184 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1185 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1186 StringRef Name = ETy.getName();
1187 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1188 int64_t Value = ETy.getEnumValue();
1189 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1193 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1194 /// printer to not emit usual symbol prefix before the symbol name is used then
1195 /// return linkage name after skipping this special LLVM prefix.
1196 static StringRef getRealLinkageName(StringRef LinkageName) {
1198 if (LinkageName.startswith(StringRef(&One, 1)))
1199 return LinkageName.substr(1);
1203 /// createMemberDIE - Create new member DIE.
1204 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1205 DIE *MemberDie = new DIE(DT.getTag());
1206 StringRef Name = DT.getName();
1208 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1210 addType(MemberDie, DT.getTypeDerivedFrom());
1212 addSourceLine(MemberDie, DT);
1214 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1215 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1217 uint64_t Size = DT.getSizeInBits();
1218 uint64_t FieldSize = DT.getOriginalTypeSize();
1220 if (Size != FieldSize) {
1222 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1223 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1225 uint64_t Offset = DT.getOffsetInBits();
1226 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1227 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1228 uint64_t FieldOffset = (HiMark - FieldSize);
1229 Offset -= FieldOffset;
1231 // Maybe we need to work from the other end.
1232 if (Asm->getTargetData().isLittleEndian())
1233 Offset = FieldSize - (Offset + Size);
1234 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1236 // Here WD_AT_data_member_location points to the anonymous
1237 // field that includes this bit field.
1238 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1241 // This is not a bitfield.
1242 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1244 if (DT.getTag() == dwarf::DW_TAG_inheritance
1245 && DT.isVirtual()) {
1247 // For C++, virtual base classes are not at fixed offset. Use following
1248 // expression to extract appropriate offset from vtable.
1249 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1251 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1252 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1253 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1254 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1255 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1256 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1257 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1258 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1260 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1263 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1265 if (DT.isProtected())
1266 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1267 dwarf::DW_ACCESS_protected);
1268 else if (DT.isPrivate())
1269 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1270 dwarf::DW_ACCESS_private);
1271 else if (DT.getTag() == dwarf::DW_TAG_inheritance)
1272 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1273 dwarf::DW_ACCESS_public);
1275 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1276 dwarf::DW_VIRTUALITY_virtual);
1280 /// createSubprogramDIE - Create new DIE using SP.
1281 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP, bool MakeDecl) {
1282 CompileUnit *SPCU = getCompileUnit(SP);
1283 DIE *SPDie = SPCU->getDIE(SP);
1287 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1288 // Constructors and operators for anonymous aggregates do not have names.
1289 if (!SP.getName().empty())
1290 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1292 StringRef LinkageName = SP.getLinkageName();
1293 if (!LinkageName.empty())
1294 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1295 getRealLinkageName(LinkageName));
1297 addSourceLine(SPDie, SP);
1299 // Add prototyped tag, if C or ObjC.
1300 unsigned Lang = SP.getCompileUnit().getLanguage();
1301 if (Lang == dwarf::DW_LANG_C99 || Lang == dwarf::DW_LANG_C89 ||
1302 Lang == dwarf::DW_LANG_ObjC)
1303 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1306 DICompositeType SPTy = SP.getType();
1307 DIArray Args = SPTy.getTypeArray();
1308 unsigned SPTag = SPTy.getTag();
1310 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1311 addType(SPDie, SPTy);
1313 addType(SPDie, DIType(Args.getElement(0)));
1315 unsigned VK = SP.getVirtuality();
1317 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1318 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1319 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1320 addUInt(Block, 0, dwarf::DW_FORM_data1, SP.getVirtualIndex());
1321 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1322 ContainingTypeMap.insert(std::make_pair(SPDie,
1323 SP.getContainingType()));
1326 if (MakeDecl || !SP.isDefinition()) {
1327 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1329 // Add arguments. Do not add arguments for subprogram definition. They will
1330 // be handled while processing variables.
1331 DICompositeType SPTy = SP.getType();
1332 DIArray Args = SPTy.getTypeArray();
1333 unsigned SPTag = SPTy.getTag();
1335 if (SPTag == dwarf::DW_TAG_subroutine_type)
1336 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1337 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1338 DIType ATy = DIType(DIType(Args.getElement(i)));
1340 if (ATy.isArtificial())
1341 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1342 SPDie->addChild(Arg);
1346 if (SP.isArtificial())
1347 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1349 if (!SP.isLocalToUnit())
1350 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1352 if (SP.isOptimized())
1353 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1355 if (unsigned isa = Asm->getISAEncoding()) {
1356 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1359 // DW_TAG_inlined_subroutine may refer to this DIE.
1360 SPCU->insertDIE(SP, SPDie);
1362 // Add to context owner.
1363 addToContextOwner(SPDie, SP.getContext());
1368 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1369 assert(N && "Invalid Scope encoding!");
1371 DbgScope *AScope = AbstractScopes.lookup(N);
1375 DbgScope *Parent = NULL;
1377 DIDescriptor Scope(N);
1378 if (Scope.isLexicalBlock()) {
1379 DILexicalBlock DB(N);
1380 DIDescriptor ParentDesc = DB.getContext();
1381 Parent = getOrCreateAbstractScope(ParentDesc);
1384 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1387 Parent->addScope(AScope);
1388 AScope->setAbstractScope();
1389 AbstractScopes[N] = AScope;
1390 if (DIDescriptor(N).isSubprogram())
1391 AbstractScopesList.push_back(AScope);
1395 /// isSubprogramContext - Return true if Context is either a subprogram
1396 /// or another context nested inside a subprogram.
1397 static bool isSubprogramContext(const MDNode *Context) {
1400 DIDescriptor D(Context);
1401 if (D.isSubprogram())
1404 return isSubprogramContext(DIType(Context).getContext());
1408 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1409 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1410 /// If there are global variables in this scope then create and insert
1411 /// DIEs for these variables.
1412 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1413 CompileUnit *SPCU = getCompileUnit(SPNode);
1414 DIE *SPDie = SPCU->getDIE(SPNode);
1416 assert(SPDie && "Unable to find subprogram DIE!");
1417 DISubprogram SP(SPNode);
1419 // There is not any need to generate specification DIE for a function
1420 // defined at compile unit level. If a function is defined inside another
1421 // function then gdb prefers the definition at top level and but does not
1422 // expect specification DIE in parent function. So avoid creating
1423 // specification DIE for a function defined inside a function.
1424 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1425 !SP.getContext().isFile() &&
1426 !isSubprogramContext(SP.getContext())) {
1427 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1430 DICompositeType SPTy = SP.getType();
1431 DIArray Args = SPTy.getTypeArray();
1432 unsigned SPTag = SPTy.getTag();
1433 if (SPTag == dwarf::DW_TAG_subroutine_type)
1434 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1435 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1436 DIType ATy = DIType(DIType(Args.getElement(i)));
1438 if (ATy.isArtificial())
1439 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1440 SPDie->addChild(Arg);
1442 DIE *SPDeclDie = SPDie;
1443 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1444 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1446 SPCU->addDie(SPDie);
1449 // Pick up abstract subprogram DIE.
1450 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1451 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1452 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1453 dwarf::DW_FORM_ref4, AbsSPDIE);
1454 SPCU->addDie(SPDie);
1457 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1458 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1459 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1460 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1461 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1462 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1463 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1468 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1469 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1470 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1472 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1473 if (Scope->isAbstractScope())
1476 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1480 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1481 if (Ranges.size() > 1) {
1482 // .debug_range section has not been laid out yet. Emit offset in
1483 // .debug_range as a uint, size 4, for now. emitDIE will handle
1484 // DW_AT_ranges appropriately.
1485 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1486 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1487 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1488 RE = Ranges.end(); RI != RE; ++RI) {
1489 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1490 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1492 DebugRangeSymbols.push_back(NULL);
1493 DebugRangeSymbols.push_back(NULL);
1497 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1498 const MCSymbol *End = getLabelAfterInsn(RI->second);
1500 if (End == 0) return 0;
1502 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1503 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1505 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1506 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1511 /// constructInlinedScopeDIE - This scope represents inlined body of
1512 /// a function. Construct DIE to represent this concrete inlined copy
1513 /// of the function.
1514 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1516 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1517 assert (Ranges.empty() == false
1518 && "DbgScope does not have instruction markers!");
1520 // FIXME : .debug_inlined section specification does not clearly state how
1521 // to emit inlined scope that is split into multiple instruction ranges.
1522 // For now, use first instruction range and emit low_pc/high_pc pair and
1523 // corresponding .debug_inlined section entry for this pair.
1524 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1525 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1526 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1528 if (StartLabel == 0 || EndLabel == 0) {
1529 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1532 assert(StartLabel->isDefined() &&
1533 "Invalid starting label for an inlined scope!");
1534 assert(EndLabel->isDefined() &&
1535 "Invalid end label for an inlined scope!");
1537 if (!Scope->getScopeNode())
1539 DIScope DS(Scope->getScopeNode());
1540 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1542 DISubprogram InlinedSP = getDISubprogram(DS);
1543 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1544 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1545 assert(OriginDIE && "Unable to find Origin DIE!");
1546 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1547 dwarf::DW_FORM_ref4, OriginDIE);
1549 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1550 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1552 InlinedSubprogramDIEs.insert(OriginDIE);
1554 // Track the start label for this inlined function.
1555 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1556 I = InlineInfo.find(InlinedSP);
1558 if (I == InlineInfo.end()) {
1559 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1561 InlinedSPNodes.push_back(InlinedSP);
1563 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1565 DILocation DL(Scope->getInlinedAt());
1566 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1567 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1573 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1574 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1575 StringRef Name = DV->getName();
1579 // Translate tag to proper Dwarf tag. The result variable is dropped for
1582 switch (DV->getTag()) {
1583 case dwarf::DW_TAG_return_variable:
1585 case dwarf::DW_TAG_arg_variable:
1586 Tag = dwarf::DW_TAG_formal_parameter;
1588 case dwarf::DW_TAG_auto_variable: // fall thru
1590 Tag = dwarf::DW_TAG_variable;
1594 // Define variable debug information entry.
1595 DIE *VariableDie = new DIE(Tag);
1598 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1599 V2AVI = VarToAbstractVarMap.find(DV);
1600 if (V2AVI != VarToAbstractVarMap.end())
1601 AbsDIE = V2AVI->second->getDIE();
1604 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1605 dwarf::DW_FORM_ref4, AbsDIE);
1607 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1608 addSourceLine(VariableDie, DV->getVariable());
1610 // Add variable type.
1611 addType(VariableDie, DV->getType());
1614 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1615 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1617 if (Scope->isAbstractScope()) {
1618 DV->setDIE(VariableDie);
1622 // Add variable address.
1624 unsigned Offset = DV->getDotDebugLocOffset();
1625 if (Offset != ~0U) {
1626 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1627 Asm->GetTempSymbol("debug_loc", Offset));
1628 DV->setDIE(VariableDie);
1629 UseDotDebugLocEntry.insert(VariableDie);
1633 // Check if variable is described by a DBG_VALUE instruction.
1634 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1635 DbgVariableToDbgInstMap.find(DV);
1636 if (DVI != DbgVariableToDbgInstMap.end()) {
1637 const MachineInstr *DVInsn = DVI->second;
1638 const MCSymbol *DVLabel = findVariableLabel(DV);
1639 bool updated = false;
1640 // FIXME : Handle getNumOperands != 3
1641 if (DVInsn->getNumOperands() == 3) {
1642 if (DVInsn->getOperand(0).isReg()) {
1643 const MachineOperand RegOp = DVInsn->getOperand(0);
1644 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1645 if (DVInsn->getOperand(1).isImm() &&
1646 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1647 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1650 updated = addRegisterAddress(VariableDie, DVLabel, RegOp);
1652 else if (DVInsn->getOperand(0).isImm())
1653 updated = addConstantValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1654 else if (DVInsn->getOperand(0).isFPImm())
1656 addConstantFPValue(VariableDie, DVLabel, DVInsn->getOperand(0));
1658 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1659 if (Location.getReg()) {
1660 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1662 addLabel(VariableDie, dwarf::DW_AT_start_scope, dwarf::DW_FORM_addr,
1668 // If variableDie is not updated then DBG_VALUE instruction does not
1669 // have valid variable info.
1673 DV->setDIE(VariableDie);
1677 // .. else use frame index, if available.
1679 if (findVariableFrameIndex(DV, &FI))
1680 addVariableAddress(DV, VariableDie, FI);
1682 DV->setDIE(VariableDie);
1687 void DwarfDebug::addPubTypes(DISubprogram SP) {
1688 DICompositeType SPTy = SP.getType();
1689 unsigned SPTag = SPTy.getTag();
1690 if (SPTag != dwarf::DW_TAG_subroutine_type)
1693 DIArray Args = SPTy.getTypeArray();
1694 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1695 DIType ATy(Args.getElement(i));
1698 DICompositeType CATy = getDICompositeType(ATy);
1699 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1700 && !CATy.isForwardDecl()) {
1701 CompileUnit *TheCU = getCompileUnit(CATy);
1702 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1703 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1708 /// constructScopeDIE - Construct a DIE for this scope.
1709 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1710 if (!Scope || !Scope->getScopeNode())
1713 DIScope DS(Scope->getScopeNode());
1714 DIE *ScopeDIE = NULL;
1715 if (Scope->getInlinedAt())
1716 ScopeDIE = constructInlinedScopeDIE(Scope);
1717 else if (DS.isSubprogram()) {
1718 ProcessedSPNodes.insert(DS);
1719 if (Scope->isAbstractScope()) {
1720 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1721 // Note down abstract DIE.
1723 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1726 ScopeDIE = updateSubprogramScopeDIE(DS);
1729 ScopeDIE = constructLexicalScopeDIE(Scope);
1730 if (!ScopeDIE) return NULL;
1732 // Add variables to scope.
1733 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1734 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
1735 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
1737 ScopeDIE->addChild(VariableDIE);
1740 // Add nested scopes.
1741 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1742 for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
1743 // Define the Scope debug information entry.
1744 DIE *NestedDIE = constructScopeDIE(Scopes[j]);
1746 ScopeDIE->addChild(NestedDIE);
1749 if (DS.isSubprogram())
1750 addPubTypes(DISubprogram(DS));
1755 /// GetOrCreateSourceID - Look up the source id with the given directory and
1756 /// source file names. If none currently exists, create a new id and insert it
1757 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1759 unsigned DwarfDebug::GetOrCreateSourceID(StringRef DirName, StringRef FileName){
1761 assert (DirName.empty() == false && "Invalid directory name!");
1763 // If FE did not provide a file name, then assume stdin.
1764 if (FileName.empty())
1765 return GetOrCreateSourceID(DirName, "<stdin>");
1767 StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
1768 if (DI != DirectoryIdMap.end()) {
1769 DId = DI->getValue();
1771 DId = DirectoryNames.size() + 1;
1772 DirectoryIdMap[DirName] = DId;
1773 DirectoryNames.push_back(DirName);
1777 StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
1778 if (FI != SourceFileIdMap.end()) {
1779 FId = FI->getValue();
1781 FId = SourceFileNames.size() + 1;
1782 SourceFileIdMap[FileName] = FId;
1783 SourceFileNames.push_back(FileName);
1786 DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
1787 SourceIdMap.find(std::make_pair(DId, FId));
1788 if (SI != SourceIdMap.end())
1791 unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
1792 SourceIdMap[std::make_pair(DId, FId)] = SrcId;
1793 SourceIds.push_back(std::make_pair(DId, FId));
1798 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1799 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1800 CompileUnit *TheCU = getCompileUnit(NS);
1801 DIE *NDie = TheCU->getDIE(NS);
1804 NDie = new DIE(dwarf::DW_TAG_namespace);
1805 TheCU->insertDIE(NS, NDie);
1806 if (!NS.getName().empty())
1807 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1808 addSourceLine(NDie, NS);
1809 addToContextOwner(NDie, NS.getContext());
1813 /// constructCompileUnit - Create new CompileUnit for the given
1814 /// metadata node with tag DW_TAG_compile_unit.
1815 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1816 DICompileUnit DIUnit(N);
1817 StringRef FN = DIUnit.getFilename();
1818 StringRef Dir = DIUnit.getDirectory();
1819 unsigned ID = GetOrCreateSourceID(Dir, FN);
1821 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1822 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1823 DIUnit.getProducer());
1824 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data1,
1825 DIUnit.getLanguage());
1826 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1827 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1828 // simplifies debug range entries.
1829 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1830 // DW_AT_stmt_list is a offset of line number information for this
1831 // compile unit in debug_line section.
1832 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1833 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1834 Asm->GetTempSymbol("section_line"));
1836 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1839 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1840 if (DIUnit.isOptimized())
1841 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1843 StringRef Flags = DIUnit.getFlags();
1845 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1847 unsigned RVer = DIUnit.getRunTimeVersion();
1849 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1850 dwarf::DW_FORM_data1, RVer);
1852 CompileUnit *NewCU = new CompileUnit(ID, Die);
1855 CUMap.insert(std::make_pair(N, NewCU));
1858 /// getCompielUnit - Get CompileUnit DIE.
1859 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1860 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1862 const MDNode *CUNode = NULL;
1863 if (D.isCompileUnit())
1865 else if (D.isSubprogram())
1866 CUNode = DISubprogram(N).getCompileUnit();
1867 else if (D.isType())
1868 CUNode = DIType(N).getCompileUnit();
1869 else if (D.isGlobalVariable())
1870 CUNode = DIGlobalVariable(N).getCompileUnit();
1871 else if (D.isVariable())
1872 CUNode = DIVariable(N).getCompileUnit();
1873 else if (D.isNameSpace())
1874 CUNode = DINameSpace(N).getCompileUnit();
1875 else if (D.isFile())
1876 CUNode = DIFile(N).getCompileUnit();
1880 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1881 = CUMap.find(CUNode);
1882 if (I == CUMap.end())
1887 /// isUnsignedDIType - Return true if type encoding is unsigned.
1888 static bool isUnsignedDIType(DIType Ty) {
1889 DIDerivedType DTy(Ty);
1891 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1893 DIBasicType BTy(Ty);
1895 unsigned Encoding = BTy.getEncoding();
1896 if (Encoding == dwarf::DW_ATE_unsigned ||
1897 Encoding == dwarf::DW_ATE_unsigned_char)
1903 /// constructGlobalVariableDIE - Construct global variable DIE.
1904 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
1905 DIGlobalVariable GV(N);
1907 // If debug information is malformed then ignore it.
1908 if (GV.Verify() == false)
1911 // Check for pre-existence.
1912 CompileUnit *TheCU = getCompileUnit(N);
1913 if (TheCU->getDIE(GV))
1916 DIType GTy = GV.getType();
1917 DIE *VariableDIE = new DIE(GV.getTag());
1919 bool isGlobalVariable = GV.getGlobal() != NULL;
1922 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1923 GV.getDisplayName());
1924 StringRef LinkageName = GV.getLinkageName();
1925 if (!LinkageName.empty() && isGlobalVariable)
1926 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1927 getRealLinkageName(LinkageName));
1929 addType(VariableDIE, GTy);
1930 if (GTy.isCompositeType() && !GTy.getName().empty()
1931 && !GTy.isForwardDecl()) {
1932 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
1933 assert(Entry && "Missing global type!");
1934 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
1936 // Add scoping info.
1937 if (!GV.isLocalToUnit()) {
1938 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1939 // Expose as global.
1940 TheCU->addGlobal(GV.getName(), VariableDIE);
1942 // Add line number info.
1943 addSourceLine(VariableDIE, GV);
1945 TheCU->insertDIE(N, VariableDIE);
1946 // Add to context owner.
1947 DIDescriptor GVContext = GV.getContext();
1948 addToContextOwner(VariableDIE, GVContext);
1950 if (isGlobalVariable) {
1951 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1952 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1953 addLabel(Block, 0, dwarf::DW_FORM_udata,
1954 Asm->Mang->getSymbol(GV.getGlobal()));
1955 // Do not create specification DIE if context is either compile unit
1957 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
1958 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1959 // Create specification DIE.
1960 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1961 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1962 dwarf::DW_FORM_ref4, VariableDIE);
1963 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1964 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1965 TheCU->addDie(VariableSpecDIE);
1967 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1969 } else if (Constant *C = GV.getConstant()) {
1970 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
1971 if (isUnsignedDIType(GTy))
1972 addUInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1973 CI->getZExtValue());
1975 addSInt(VariableDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1976 CI->getSExtValue());
1982 /// construct SubprogramDIE - Construct subprogram DIE.
1983 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
1986 // Check for pre-existence.
1987 CompileUnit *TheCU = getCompileUnit(N);
1988 if (TheCU->getDIE(N))
1991 if (!SP.isDefinition())
1992 // This is a method declaration which will be handled while constructing
1996 DIE *SubprogramDie = createSubprogramDIE(SP);
1999 TheCU->insertDIE(N, SubprogramDie);
2001 // Add to context owner.
2002 addToContextOwner(SubprogramDie, SP.getContext());
2004 // Expose as global.
2005 TheCU->addGlobal(SP.getName(), SubprogramDie);
2010 /// beginModule - Emit all Dwarf sections that should come prior to the
2011 /// content. Create global DIEs and emit initial debug info sections.
2012 /// This is inovked by the target AsmPrinter.
2013 void DwarfDebug::beginModule(Module *M) {
2014 if (DisableDebugInfoPrinting)
2017 DebugInfoFinder DbgFinder;
2018 DbgFinder.processModule(*M);
2020 bool HasDebugInfo = false;
2022 // Scan all the compile-units to see if there are any marked as the main unit.
2023 // if not, we do not generate debug info.
2024 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2025 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2026 if (DICompileUnit(*I).isMain()) {
2027 HasDebugInfo = true;
2032 if (!HasDebugInfo) return;
2034 // Tell MMI that we have debug info.
2035 MMI->setDebugInfoAvailability(true);
2037 // Emit initial sections.
2038 EmitSectionLabels();
2040 // Create all the compile unit DIEs.
2041 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2042 E = DbgFinder.compile_unit_end(); I != E; ++I)
2043 constructCompileUnit(*I);
2045 // Create DIEs for each subprogram.
2046 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2047 E = DbgFinder.subprogram_end(); I != E; ++I)
2048 constructSubprogramDIE(*I);
2050 // Create DIEs for each global variable.
2051 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2052 E = DbgFinder.global_variable_end(); I != E; ++I)
2053 constructGlobalVariableDIE(*I);
2055 //getOrCreateTypeDIE
2056 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2057 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2058 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2060 // Prime section data.
2061 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2063 // Print out .file directives to specify files for .loc directives. These are
2064 // printed out early so that they precede any .loc directives.
2065 if (Asm->MAI->hasDotLocAndDotFile()) {
2066 for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
2067 // Remember source id starts at 1.
2068 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
2069 // FIXME: don't use sys::path for this! This should not depend on the
2071 sys::Path FullPath(getSourceDirectoryName(Id.first));
2073 FullPath.appendComponent(getSourceFileName(Id.second));
2074 assert(AppendOk && "Could not append filename to directory!");
2076 Asm->OutStreamer.EmitDwarfFileDirective(i, FullPath.str());
2081 /// endModule - Emit all Dwarf sections that should come after the content.
2083 void DwarfDebug::endModule() {
2084 if (!FirstCU) return;
2085 const Module *M = MMI->getModule();
2086 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2087 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2088 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2089 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2090 DISubprogram SP(AllSPs->getOperand(SI));
2091 if (!SP.Verify()) continue;
2093 // Collect info for variables that were optimized out.
2094 if (!SP.isDefinition()) continue;
2095 StringRef FName = SP.getLinkageName();
2097 FName = SP.getName();
2099 M->getNamedMetadata(Twine("llvm.dbg.lv.", getRealLinkageName(FName)));
2101 unsigned E = NMD->getNumOperands();
2103 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2104 DeadFnScopeMap[SP] = Scope;
2105 for (unsigned I = 0; I != E; ++I) {
2106 DIVariable DV(NMD->getOperand(I));
2107 if (!DV.Verify()) continue;
2108 Scope->addVariable(new DbgVariable(DV));
2111 // Construct subprogram DIE and add variables DIEs.
2112 constructSubprogramDIE(SP);
2113 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2114 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2115 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2116 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2118 ScopeDIE->addChild(VariableDIE);
2123 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2124 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2125 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2127 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2130 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2131 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2132 DIE *SPDie = CI->first;
2133 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2135 DIE *NDie = getCompileUnit(N)->getDIE(N);
2136 if (!NDie) continue;
2137 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2140 // Standard sections final addresses.
2141 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2142 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2143 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2144 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2146 // End text sections.
2147 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2148 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2149 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2152 // Emit common frame information.
2153 emitCommonDebugFrame();
2155 // Emit function debug frame information
2156 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2157 E = DebugFrames.end(); I != E; ++I)
2158 emitFunctionDebugFrame(*I);
2160 // Compute DIE offsets and sizes.
2161 computeSizeAndOffsets();
2163 // Emit all the DIEs into a debug info section
2166 // Corresponding abbreviations into a abbrev section.
2167 emitAbbreviations();
2169 // Emit source line correspondence into a debug line section.
2172 // Emit info into a debug pubnames section.
2173 emitDebugPubNames();
2175 // Emit info into a debug pubtypes section.
2176 emitDebugPubTypes();
2178 // Emit info into a debug loc section.
2181 // Emit info into a debug aranges section.
2184 // Emit info into a debug ranges section.
2187 // Emit info into a debug macinfo section.
2190 // Emit inline info.
2191 emitDebugInlineInfo();
2193 // Emit info into a debug str section.
2197 DeleteContainerSeconds(DeadFnScopeMap);
2198 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2199 E = CUMap.end(); I != E; ++I)
2201 FirstCU = NULL; // Reset for the next Module, if any.
2204 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2205 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2206 DebugLoc ScopeLoc) {
2208 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2210 return AbsDbgVariable;
2212 LLVMContext &Ctx = Var->getContext();
2213 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2217 AbsDbgVariable = new DbgVariable(Var);
2218 Scope->addVariable(AbsDbgVariable);
2219 AbstractVariables[Var] = AbsDbgVariable;
2220 return AbsDbgVariable;
2223 /// collectVariableInfoFromMMITable - Collect variable information from
2224 /// side table maintained by MMI.
2226 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2227 SmallPtrSet<const MDNode *, 16> &Processed) {
2228 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2229 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2230 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2231 VE = VMap.end(); VI != VE; ++VI) {
2232 const MDNode *Var = VI->first;
2234 Processed.insert(Var);
2236 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2238 DbgScope *Scope = 0;
2239 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2240 Scope = ConcreteScopes.lookup(IA);
2242 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2244 // If variable scope is not found then skip this variable.
2248 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2249 DbgVariable *RegVar = new DbgVariable(DV);
2250 recordVariableFrameIndex(RegVar, VP.first);
2251 Scope->addVariable(RegVar);
2252 if (AbsDbgVariable) {
2253 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2254 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2259 /// isDbgValueInUndefinedReg - Return true if debug value, encoded by
2260 /// DBG_VALUE instruction, is in undefined reg.
2261 static bool isDbgValueInUndefinedReg(const MachineInstr *MI) {
2262 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2263 if (MI->getOperand(0).isReg() && !MI->getOperand(0).getReg())
2268 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2269 /// DBG_VALUE instruction, is in a defined reg.
2270 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2271 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2272 if (MI->getOperand(0).isReg() && MI->getOperand(0).getReg())
2277 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2279 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2280 SmallPtrSet<const MDNode *, 16> &Processed) {
2282 /// collection info from MMI table.
2283 collectVariableInfoFromMMITable(MF, Processed);
2285 SmallVector<const MachineInstr *, 8> DbgValues;
2286 // Collect variable information from DBG_VALUE machine instructions;
2287 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2289 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2291 const MachineInstr *MInsn = II;
2292 if (!MInsn->isDebugValue() || isDbgValueInUndefinedReg(MInsn))
2294 DbgValues.push_back(MInsn);
2297 // This is a collection of DBV_VALUE instructions describing same variable.
2298 SmallVector<const MachineInstr *, 4> MultipleValues;
2299 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2300 E = DbgValues.end(); I != E; ++I) {
2301 const MachineInstr *MInsn = *I;
2302 MultipleValues.clear();
2303 if (isDbgValueInDefinedReg(MInsn))
2304 MultipleValues.push_back(MInsn);
2305 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2306 if (Processed.count(DV) != 0)
2309 const MachineInstr *PrevMI = MInsn;
2310 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2311 ME = DbgValues.end(); MI != ME; ++MI) {
2313 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2314 if (Var == DV && isDbgValueInDefinedReg(*MI) &&
2315 !PrevMI->isIdenticalTo(*MI))
2316 MultipleValues.push_back(*MI);
2320 DbgScope *Scope = findDbgScope(MInsn);
2321 bool CurFnArg = false;
2322 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2323 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2325 if (!Scope && CurFnArg)
2326 Scope = CurrentFnDbgScope;
2327 // If variable scope is not found then skip this variable.
2331 Processed.insert(DV);
2332 DbgVariable *RegVar = new DbgVariable(DV);
2333 Scope->addVariable(RegVar);
2335 DbgVariableLabelsMap[RegVar] = getLabelBeforeInsn(MInsn);
2336 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2337 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2338 VarToAbstractVarMap[RegVar] = AbsVar;
2340 if (MultipleValues.size() <= 1) {
2341 DbgVariableToDbgInstMap[RegVar] = MInsn;
2345 // handle multiple DBG_VALUE instructions describing one variable.
2346 if (DotDebugLocEntries.empty())
2347 RegVar->setDotDebugLocOffset(0);
2349 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2350 const MachineInstr *Begin = NULL;
2351 const MachineInstr *End = NULL;
2352 for (SmallVector<const MachineInstr *, 4>::iterator
2353 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2354 MVI != MVE; ++MVI) {
2360 MachineLocation MLoc;
2361 if (Begin->getNumOperands() == 3) {
2362 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2363 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2365 MLoc = Asm->getDebugValueLocation(Begin);
2367 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2368 const MCSymbol *SLabel = getLabelBeforeInsn(End);
2370 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2373 if (MVI + 1 == MVE) {
2374 // If End is the last instruction then its value is valid
2375 // until the end of the funtion.
2376 MachineLocation EMLoc;
2377 if (End->getNumOperands() == 3) {
2378 if (End->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2379 EMLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2381 EMLoc = Asm->getDebugValueLocation(End);
2384 push_back(DotDebugLocEntry(SLabel, FunctionEndSym, EMLoc));
2387 DotDebugLocEntries.push_back(DotDebugLocEntry());
2390 // Collect info for variables that were optimized out.
2391 const Function *F = MF->getFunction();
2392 const Module *M = F->getParent();
2393 if (NamedMDNode *NMD =
2394 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2395 getRealLinkageName(F->getName())))) {
2396 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2397 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2398 if (!DV || !Processed.insert(DV))
2400 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2402 Scope->addVariable(new DbgVariable(DV));
2407 /// getLabelBeforeInsn - Return Label preceding the instruction.
2408 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2409 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2410 LabelsBeforeInsn.find(MI);
2411 if (I == LabelsBeforeInsn.end())
2412 // FunctionBeginSym always preceeds all the instruction in current function.
2413 return FunctionBeginSym;
2417 /// getLabelAfterInsn - Return Label immediately following the instruction.
2418 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2419 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2420 LabelsAfterInsn.find(MI);
2421 if (I == LabelsAfterInsn.end())
2426 /// beginScope - Process beginning of a scope.
2427 void DwarfDebug::beginScope(const MachineInstr *MI) {
2428 if (InsnNeedsLabel.count(MI) == 0) {
2429 LabelsBeforeInsn[MI] = PrevLabel;
2434 DebugLoc DL = MI->getDebugLoc();
2435 if (!DL.isUnknown()) {
2436 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2437 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2439 LabelsBeforeInsn[MI] = PrevLabel;
2443 // If location is unknown then use temp label for this DBG_VALUE
2445 if (MI->isDebugValue()) {
2446 PrevLabel = MMI->getContext().CreateTempSymbol();
2447 Asm->OutStreamer.EmitLabel(PrevLabel);
2448 LabelsBeforeInsn[MI] = PrevLabel;
2452 if (UnknownLocations) {
2453 PrevLabel = recordSourceLine(0, 0, 0);
2454 LabelsBeforeInsn[MI] = PrevLabel;
2458 assert (0 && "Instruction is not processed!");
2461 /// endScope - Process end of a scope.
2462 void DwarfDebug::endScope(const MachineInstr *MI) {
2463 if (InsnsEndScopeSet.count(MI) != 0) {
2464 // Emit a label if this instruction ends a scope.
2465 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2466 Asm->OutStreamer.EmitLabel(Label);
2467 LabelsAfterInsn[MI] = Label;
2471 /// getOrCreateDbgScope - Create DbgScope for the scope.
2472 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2473 const MDNode *InlinedAt) {
2475 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2478 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2479 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2480 if (DIDescriptor(Scope).isLexicalBlock()) {
2482 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2483 WScope->setParent(Parent);
2484 Parent->addScope(WScope);
2487 if (!WScope->getParent()) {
2488 StringRef SPName = DISubprogram(Scope).getLinkageName();
2489 // We used to check only for a linkage name, but that fails
2490 // since we began omitting the linkage name for private
2491 // functions. The new way is to check for the name in metadata,
2492 // but that's not supported in old .ll test cases. Ergo, we
2494 if (SPName == Asm->MF->getFunction()->getName() ||
2495 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2496 CurrentFnDbgScope = WScope;
2502 getOrCreateAbstractScope(Scope);
2503 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2507 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2508 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2509 DILocation DL(InlinedAt);
2511 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2512 WScope->setParent(Parent);
2513 Parent->addScope(WScope);
2515 ConcreteScopes[InlinedAt] = WScope;
2520 /// hasValidLocation - Return true if debug location entry attached with
2521 /// machine instruction encodes valid location info.
2522 static bool hasValidLocation(LLVMContext &Ctx,
2523 const MachineInstr *MInsn,
2524 const MDNode *&Scope, const MDNode *&InlinedAt) {
2525 DebugLoc DL = MInsn->getDebugLoc();
2526 if (DL.isUnknown()) return false;
2528 const MDNode *S = DL.getScope(Ctx);
2530 // There is no need to create another DIE for compile unit. For all
2531 // other scopes, create one DbgScope now. This will be translated
2532 // into a scope DIE at the end.
2533 if (DIScope(S).isCompileUnit()) return false;
2536 InlinedAt = DL.getInlinedAt(Ctx);
2540 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2542 static void calculateDominanceGraph(DbgScope *Scope) {
2543 assert (Scope && "Unable to calculate scop edominance graph!");
2544 SmallVector<DbgScope *, 4> WorkStack;
2545 WorkStack.push_back(Scope);
2546 unsigned Counter = 0;
2547 while (!WorkStack.empty()) {
2548 DbgScope *WS = WorkStack.back();
2549 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2550 bool visitedChildren = false;
2551 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2552 SE = Children.end(); SI != SE; ++SI) {
2553 DbgScope *ChildScope = *SI;
2554 if (!ChildScope->getDFSOut()) {
2555 WorkStack.push_back(ChildScope);
2556 visitedChildren = true;
2557 ChildScope->setDFSIn(++Counter);
2561 if (!visitedChildren) {
2562 WorkStack.pop_back();
2563 WS->setDFSOut(++Counter);
2568 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2570 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2571 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2574 unsigned PrevDFSIn = 0;
2575 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2577 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2579 const MachineInstr *MInsn = II;
2580 const MDNode *Scope = NULL;
2581 const MDNode *InlinedAt = NULL;
2583 // Check if instruction has valid location information.
2584 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2588 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2589 MI2ScopeMap.find(MInsn);
2590 if (DI != MI2ScopeMap.end()) {
2591 DbgScope *S = DI->second;
2592 dbgs() << S->getDFSIn();
2593 PrevDFSIn = S->getDFSIn();
2595 dbgs() << PrevDFSIn;
2597 dbgs() << " [ x" << PrevDFSIn;
2605 /// extractScopeInformation - Scan machine instructions in this function
2606 /// and collect DbgScopes. Return true, if at least one scope was found.
2607 bool DwarfDebug::extractScopeInformation() {
2608 // If scope information was extracted using .dbg intrinsics then there is not
2609 // any need to extract these information by scanning each instruction.
2610 if (!DbgScopeMap.empty())
2613 // Scan each instruction and create scopes. First build working set of scopes.
2614 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2615 SmallVector<DbgRange, 4> MIRanges;
2616 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2617 const MDNode *PrevScope = NULL;
2618 const MDNode *PrevInlinedAt = NULL;
2619 const MachineInstr *RangeBeginMI = NULL;
2620 const MachineInstr *PrevMI = NULL;
2621 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2623 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2625 const MachineInstr *MInsn = II;
2626 const MDNode *Scope = NULL;
2627 const MDNode *InlinedAt = NULL;
2629 // Check if instruction has valid location information.
2630 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2635 // If scope has not changed then skip this instruction.
2636 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2642 // If we have alread seen a beginning of a instruction range and
2643 // current instruction scope does not match scope of first instruction
2644 // in this range then create a new instruction range.
2645 DbgRange R(RangeBeginMI, PrevMI);
2646 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2648 MIRanges.push_back(R);
2651 // This is a beginning of a new instruction range.
2652 RangeBeginMI = MInsn;
2654 // Reset previous markers.
2657 PrevInlinedAt = InlinedAt;
2661 // Create last instruction range.
2662 if (RangeBeginMI && PrevMI && PrevScope) {
2663 DbgRange R(RangeBeginMI, PrevMI);
2664 MIRanges.push_back(R);
2665 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2668 if (!CurrentFnDbgScope)
2671 calculateDominanceGraph(CurrentFnDbgScope);
2673 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2675 // Find ranges of instructions covered by each DbgScope;
2676 DbgScope *PrevDbgScope = NULL;
2677 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2678 RE = MIRanges.end(); RI != RE; ++RI) {
2679 const DbgRange &R = *RI;
2680 DbgScope *S = MI2ScopeMap.lookup(R.first);
2681 assert (S && "Lost DbgScope for a machine instruction!");
2682 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2683 PrevDbgScope->closeInsnRange(S);
2684 S->openInsnRange(R.first);
2685 S->extendInsnRange(R.second);
2690 PrevDbgScope->closeInsnRange();
2692 identifyScopeMarkers();
2694 return !DbgScopeMap.empty();
2697 /// identifyScopeMarkers() -
2698 /// Each DbgScope has first instruction and last instruction to mark beginning
2699 /// and end of a scope respectively. Create an inverse map that list scopes
2700 /// starts (and ends) with an instruction. One instruction may start (or end)
2701 /// multiple scopes. Ignore scopes that are not reachable.
2702 void DwarfDebug::identifyScopeMarkers() {
2703 SmallVector<DbgScope *, 4> WorkList;
2704 WorkList.push_back(CurrentFnDbgScope);
2705 while (!WorkList.empty()) {
2706 DbgScope *S = WorkList.pop_back_val();
2708 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2709 if (!Children.empty())
2710 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2711 SE = Children.end(); SI != SE; ++SI)
2712 WorkList.push_back(*SI);
2714 if (S->isAbstractScope())
2717 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2720 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2721 RE = Ranges.end(); RI != RE; ++RI) {
2722 assert(RI->first && "DbgRange does not have first instruction!");
2723 assert(RI->second && "DbgRange does not have second instruction!");
2724 InsnsEndScopeSet.insert(RI->second);
2729 /// FindFirstDebugLoc - Find the first debug location in the function. This
2730 /// is intended to be an approximation for the source position of the
2731 /// beginning of the function.
2732 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2733 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2735 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2736 MBBI != MBBE; ++MBBI) {
2737 DebugLoc DL = MBBI->getDebugLoc();
2738 if (!DL.isUnknown())
2744 /// beginFunction - Gather pre-function debug information. Assumes being
2745 /// emitted immediately after the function entry point.
2746 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2747 if (!MMI->hasDebugInfo()) return;
2748 if (!extractScopeInformation()) return;
2750 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2751 Asm->getFunctionNumber());
2752 // Assumes in correct section after the entry point.
2753 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2755 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2757 DebugLoc FDL = FindFirstDebugLoc(MF);
2758 if (FDL.isUnknown()) return;
2760 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2761 const MDNode *TheScope = 0;
2763 DISubprogram SP = getDISubprogram(Scope);
2766 Line = SP.getLineNumber();
2770 Line = FDL.getLine();
2775 recordSourceLine(Line, Col, TheScope);
2777 /// ProcessedArgs - Collection of arguments already processed.
2778 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2781 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2783 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2785 const MachineInstr *MI = II;
2786 DebugLoc DL = MI->getDebugLoc();
2787 if (MI->isDebugValue()) {
2788 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2789 DIVariable DV(MI->getOperand(MI->getNumOperands() - 1).getMetadata());
2790 if (!DV.Verify()) continue;
2791 // If DBG_VALUE is for a local variable then it needs a label.
2792 if (DV.getTag() != dwarf::DW_TAG_arg_variable
2793 && isDbgValueInUndefinedReg(MI) == false)
2794 InsnNeedsLabel.insert(MI);
2795 // DBG_VALUE for inlined functions argument needs a label.
2796 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2797 describes(MF->getFunction()))
2798 InsnNeedsLabel.insert(MI);
2799 // DBG_VALUE indicating argument location change needs a label.
2800 else if (isDbgValueInUndefinedReg(MI) == false
2801 && !ProcessedArgs.insert(DV))
2802 InsnNeedsLabel.insert(MI);
2804 // If location is unknown then instruction needs a location only if
2805 // UnknownLocations flag is set.
2806 if (DL.isUnknown()) {
2807 if (UnknownLocations && !PrevLoc.isUnknown())
2808 InsnNeedsLabel.insert(MI);
2809 } else if (DL != PrevLoc)
2810 // Otherwise, instruction needs a location only if it is new location.
2811 InsnNeedsLabel.insert(MI);
2814 if (!DL.isUnknown() || UnknownLocations)
2818 PrevLabel = FunctionBeginSym;
2821 /// endFunction - Gather and emit post-function debug information.
2823 void DwarfDebug::endFunction(const MachineFunction *MF) {
2824 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2826 if (CurrentFnDbgScope) {
2828 // Define end label for subprogram.
2829 FunctionEndSym = Asm->GetTempSymbol("func_end",
2830 Asm->getFunctionNumber());
2831 // Assumes in correct section after the entry point.
2832 Asm->OutStreamer.EmitLabel(FunctionEndSym);
2834 SmallPtrSet<const MDNode *, 16> ProcessedVars;
2835 collectVariableInfo(MF, ProcessedVars);
2837 // Get function line info.
2838 if (!Lines.empty()) {
2839 // Get section line info.
2840 unsigned ID = SectionMap.insert(Asm->getCurrentSection());
2841 if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
2842 std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
2843 // Append the function info to section info.
2844 SectionLineInfos.insert(SectionLineInfos.end(),
2845 Lines.begin(), Lines.end());
2848 // Construct abstract scopes.
2849 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
2850 AE = AbstractScopesList.end(); AI != AE; ++AI) {
2851 DISubprogram SP((*AI)->getScopeNode());
2853 // Collect info for variables that were optimized out.
2854 StringRef FName = SP.getLinkageName();
2856 FName = SP.getName();
2857 const Module *M = MF->getFunction()->getParent();
2858 if (NamedMDNode *NMD =
2859 M->getNamedMetadata(Twine("llvm.dbg.lv.",
2860 getRealLinkageName(FName)))) {
2861 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2862 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2863 if (!DV || !ProcessedVars.insert(DV))
2865 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
2867 Scope->addVariable(new DbgVariable(DV));
2871 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
2872 constructScopeDIE(*AI);
2875 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
2877 if (!DisableFramePointerElim(*MF))
2878 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
2879 dwarf::DW_FORM_flag, 1);
2882 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
2883 MMI->getFrameMoves()));
2887 CurrentFnDbgScope = NULL;
2888 InsnNeedsLabel.clear();
2889 DbgVariableToFrameIndexMap.clear();
2890 VarToAbstractVarMap.clear();
2891 DbgVariableToDbgInstMap.clear();
2892 DbgVariableLabelsMap.clear();
2893 DeleteContainerSeconds(DbgScopeMap);
2894 InsnsEndScopeSet.clear();
2895 ConcreteScopes.clear();
2896 DeleteContainerSeconds(AbstractScopes);
2897 AbstractScopesList.clear();
2898 AbstractVariables.clear();
2899 LabelsBeforeInsn.clear();
2900 LabelsAfterInsn.clear();
2905 /// recordVariableFrameIndex - Record a variable's index.
2906 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
2907 assert (V && "Invalid DbgVariable!");
2908 DbgVariableToFrameIndexMap[V] = Index;
2911 /// findVariableFrameIndex - Return true if frame index for the variable
2912 /// is found. Update FI to hold value of the index.
2913 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
2914 assert (V && "Invalid DbgVariable!");
2915 DenseMap<const DbgVariable *, int>::iterator I =
2916 DbgVariableToFrameIndexMap.find(V);
2917 if (I == DbgVariableToFrameIndexMap.end())
2923 /// findVariableLabel - Find MCSymbol for the variable.
2924 const MCSymbol *DwarfDebug::findVariableLabel(const DbgVariable *V) {
2925 DenseMap<const DbgVariable *, const MCSymbol *>::iterator I
2926 = DbgVariableLabelsMap.find(V);
2927 if (I == DbgVariableLabelsMap.end())
2929 else return I->second;
2932 /// findDbgScope - Find DbgScope for the debug loc attached with an
2934 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
2935 DbgScope *Scope = NULL;
2937 MInsn->getParent()->getParent()->getFunction()->getContext();
2938 DebugLoc DL = MInsn->getDebugLoc();
2943 if (const MDNode *IA = DL.getInlinedAt(Ctx))
2944 Scope = ConcreteScopes.lookup(IA);
2946 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
2952 /// recordSourceLine - Register a source line with debug info. Returns the
2953 /// unique label that was emitted and which provides correspondence to
2954 /// the source line list.
2955 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
2962 DIDescriptor Scope(S);
2964 if (Scope.isCompileUnit()) {
2965 DICompileUnit CU(S);
2966 Dir = CU.getDirectory();
2967 Fn = CU.getFilename();
2968 } else if (Scope.isSubprogram()) {
2970 Dir = SP.getDirectory();
2971 Fn = SP.getFilename();
2972 } else if (Scope.isLexicalBlock()) {
2973 DILexicalBlock DB(S);
2974 Dir = DB.getDirectory();
2975 Fn = DB.getFilename();
2977 assert(0 && "Unexpected scope info");
2979 Src = GetOrCreateSourceID(Dir, Fn);
2982 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2983 Lines.push_back(SrcLineInfo(Line, Col, Src, Label));
2985 Asm->OutStreamer.EmitLabel(Label);
2989 //===----------------------------------------------------------------------===//
2991 //===----------------------------------------------------------------------===//
2993 /// computeSizeAndOffset - Compute the size and offset of a DIE.
2996 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
2997 // Get the children.
2998 const std::vector<DIE *> &Children = Die->getChildren();
3000 // If not last sibling and has children then add sibling offset attribute.
3001 if (!Last && !Children.empty())
3002 Die->addSiblingOffset(DIEValueAllocator);
3004 // Record the abbreviation.
3005 assignAbbrevNumber(Die->getAbbrev());
3007 // Get the abbreviation for this DIE.
3008 unsigned AbbrevNumber = Die->getAbbrevNumber();
3009 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3012 Die->setOffset(Offset);
3014 // Start the size with the size of abbreviation code.
3015 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3017 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3018 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3020 // Size the DIE attribute values.
3021 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3022 // Size attribute value.
3023 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3025 // Size the DIE children if any.
3026 if (!Children.empty()) {
3027 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3028 "Children flag not set");
3030 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3031 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3033 // End of children marker.
3034 Offset += sizeof(int8_t);
3037 Die->setSize(Offset - Die->getOffset());
3041 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3043 void DwarfDebug::computeSizeAndOffsets() {
3044 unsigned PrevOffset = 0;
3045 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3046 E = CUMap.end(); I != E; ++I) {
3047 // Compute size of compile unit header.
3048 static unsigned Offset = PrevOffset +
3049 sizeof(int32_t) + // Length of Compilation Unit Info
3050 sizeof(int16_t) + // DWARF version number
3051 sizeof(int32_t) + // Offset Into Abbrev. Section
3052 sizeof(int8_t); // Pointer Size (in bytes)
3053 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3054 PrevOffset = Offset;
3058 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3059 /// temporary label to it if SymbolStem is specified.
3060 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3061 const char *SymbolStem = 0) {
3062 Asm->OutStreamer.SwitchSection(Section);
3063 if (!SymbolStem) return 0;
3065 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3066 Asm->OutStreamer.EmitLabel(TmpSym);
3070 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3071 /// the start of each one.
3072 void DwarfDebug::EmitSectionLabels() {
3073 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3075 // Dwarf sections base addresses.
3076 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3077 DwarfFrameSectionSym =
3078 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3081 DwarfInfoSectionSym =
3082 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3083 DwarfAbbrevSectionSym =
3084 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3085 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3087 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3088 EmitSectionSym(Asm, MacroInfo);
3090 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3091 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3092 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3093 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3094 DwarfStrSectionSym =
3095 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3096 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3099 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3100 "section_debug_loc");
3102 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3103 EmitSectionSym(Asm, TLOF.getDataSection());
3106 /// emitDIE - Recusively Emits a debug information entry.
3108 void DwarfDebug::emitDIE(DIE *Die) {
3109 // Get the abbreviation for this DIE.
3110 unsigned AbbrevNumber = Die->getAbbrevNumber();
3111 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3113 // Emit the code (index) for the abbreviation.
3114 if (Asm->isVerbose())
3115 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3116 Twine::utohexstr(Die->getOffset()) + ":0x" +
3117 Twine::utohexstr(Die->getSize()) + " " +
3118 dwarf::TagString(Abbrev->getTag()));
3119 Asm->EmitULEB128(AbbrevNumber);
3121 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3122 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3124 // Emit the DIE attribute values.
3125 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3126 unsigned Attr = AbbrevData[i].getAttribute();
3127 unsigned Form = AbbrevData[i].getForm();
3128 assert(Form && "Too many attributes for DIE (check abbreviation)");
3130 if (Asm->isVerbose())
3131 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3134 case dwarf::DW_AT_sibling:
3135 Asm->EmitInt32(Die->getSiblingOffset());
3137 case dwarf::DW_AT_abstract_origin: {
3138 DIEEntry *E = cast<DIEEntry>(Values[i]);
3139 DIE *Origin = E->getEntry();
3140 unsigned Addr = Origin->getOffset();
3141 Asm->EmitInt32(Addr);
3144 case dwarf::DW_AT_ranges: {
3145 // DW_AT_range Value encodes offset in debug_range section.
3146 DIEInteger *V = cast<DIEInteger>(Values[i]);
3148 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3149 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3153 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3155 DwarfDebugRangeSectionSym,
3160 case dwarf::DW_AT_location: {
3161 if (UseDotDebugLocEntry.count(Die) != 0) {
3162 DIELabel *L = cast<DIELabel>(Values[i]);
3163 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3165 Values[i]->EmitValue(Asm, Form);
3169 // Emit an attribute using the defined form.
3170 Values[i]->EmitValue(Asm, Form);
3175 // Emit the DIE children if any.
3176 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3177 const std::vector<DIE *> &Children = Die->getChildren();
3179 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3180 emitDIE(Children[j]);
3182 if (Asm->isVerbose())
3183 Asm->OutStreamer.AddComment("End Of Children Mark");
3188 /// emitDebugInfo - Emit the debug info section.
3190 void DwarfDebug::emitDebugInfo() {
3191 // Start debug info section.
3192 Asm->OutStreamer.SwitchSection(
3193 Asm->getObjFileLowering().getDwarfInfoSection());
3194 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3195 E = CUMap.end(); I != E; ++I) {
3196 CompileUnit *TheCU = I->second;
3197 DIE *Die = TheCU->getCUDie();
3199 // Emit the compile units header.
3200 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3203 // Emit size of content not including length itself
3204 unsigned ContentSize = Die->getSize() +
3205 sizeof(int16_t) + // DWARF version number
3206 sizeof(int32_t) + // Offset Into Abbrev. Section
3207 sizeof(int8_t) + // Pointer Size (in bytes)
3208 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3210 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3211 Asm->EmitInt32(ContentSize);
3212 Asm->OutStreamer.AddComment("DWARF version number");
3213 Asm->EmitInt16(dwarf::DWARF_VERSION);
3214 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3215 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3216 DwarfAbbrevSectionSym);
3217 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3218 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3221 // FIXME - extra padding for gdb bug.
3222 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3227 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3231 /// emitAbbreviations - Emit the abbreviation section.
3233 void DwarfDebug::emitAbbreviations() const {
3234 // Check to see if it is worth the effort.
3235 if (!Abbreviations.empty()) {
3236 // Start the debug abbrev section.
3237 Asm->OutStreamer.SwitchSection(
3238 Asm->getObjFileLowering().getDwarfAbbrevSection());
3240 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3242 // For each abbrevation.
3243 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3244 // Get abbreviation data
3245 const DIEAbbrev *Abbrev = Abbreviations[i];
3247 // Emit the abbrevations code (base 1 index.)
3248 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3250 // Emit the abbreviations data.
3254 // Mark end of abbreviations.
3255 Asm->EmitULEB128(0, "EOM(3)");
3257 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3261 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3262 /// the line matrix.
3264 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3265 // Define last address of section.
3266 Asm->OutStreamer.AddComment("Extended Op");
3269 Asm->OutStreamer.AddComment("Op size");
3270 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3271 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3272 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3274 Asm->OutStreamer.AddComment("Section end label");
3276 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3277 Asm->getTargetData().getPointerSize(),
3280 // Mark end of matrix.
3281 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3287 /// emitDebugLines - Emit source line information.
3289 void DwarfDebug::emitDebugLines() {
3290 // If the target is using .loc/.file, the assembler will be emitting the
3291 // .debug_line table automatically.
3292 if (Asm->MAI->hasDotLocAndDotFile())
3295 // Minimum line delta, thus ranging from -10..(255-10).
3296 const int MinLineDelta = -(dwarf::DW_LNS_fixed_advance_pc + 1);
3297 // Maximum line delta, thus ranging from -10..(255-10).
3298 const int MaxLineDelta = 255 + MinLineDelta;
3300 // Start the dwarf line section.
3301 Asm->OutStreamer.SwitchSection(
3302 Asm->getObjFileLowering().getDwarfLineSection());
3304 // Construct the section header.
3305 Asm->OutStreamer.AddComment("Length of Source Line Info");
3306 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_end"),
3307 Asm->GetTempSymbol("line_begin"), 4);
3308 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_begin"));
3310 Asm->OutStreamer.AddComment("DWARF version number");
3311 Asm->EmitInt16(dwarf::DWARF_VERSION);
3313 Asm->OutStreamer.AddComment("Prolog Length");
3314 Asm->EmitLabelDifference(Asm->GetTempSymbol("line_prolog_end"),
3315 Asm->GetTempSymbol("line_prolog_begin"), 4);
3316 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_begin"));
3318 Asm->OutStreamer.AddComment("Minimum Instruction Length");
3320 Asm->OutStreamer.AddComment("Default is_stmt_start flag");
3322 Asm->OutStreamer.AddComment("Line Base Value (Special Opcodes)");
3323 Asm->EmitInt8(MinLineDelta);
3324 Asm->OutStreamer.AddComment("Line Range Value (Special Opcodes)");
3325 Asm->EmitInt8(MaxLineDelta);
3326 Asm->OutStreamer.AddComment("Special Opcode Base");
3327 Asm->EmitInt8(-MinLineDelta);
3329 // Line number standard opcode encodings argument count
3330 Asm->OutStreamer.AddComment("DW_LNS_copy arg count");
3332 Asm->OutStreamer.AddComment("DW_LNS_advance_pc arg count");
3334 Asm->OutStreamer.AddComment("DW_LNS_advance_line arg count");
3336 Asm->OutStreamer.AddComment("DW_LNS_set_file arg count");
3338 Asm->OutStreamer.AddComment("DW_LNS_set_column arg count");
3340 Asm->OutStreamer.AddComment("DW_LNS_negate_stmt arg count");
3342 Asm->OutStreamer.AddComment("DW_LNS_set_basic_block arg count");
3344 Asm->OutStreamer.AddComment("DW_LNS_const_add_pc arg count");
3346 Asm->OutStreamer.AddComment("DW_LNS_fixed_advance_pc arg count");
3349 // Emit directories.
3350 for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
3351 const std::string &Dir = getSourceDirectoryName(DI);
3352 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Directory");
3353 Asm->OutStreamer.EmitBytes(StringRef(Dir.c_str(), Dir.size()+1), 0);
3356 Asm->OutStreamer.AddComment("End of directories");
3360 for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
3361 // Remember source id starts at 1.
3362 std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
3363 const std::string &FN = getSourceFileName(Id.second);
3364 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("Source");
3365 Asm->OutStreamer.EmitBytes(StringRef(FN.c_str(), FN.size()+1), 0);
3367 Asm->EmitULEB128(Id.first, "Directory #");
3368 Asm->EmitULEB128(0, "Mod date");
3369 Asm->EmitULEB128(0, "File size");
3372 Asm->OutStreamer.AddComment("End of files");
3375 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_prolog_end"));
3377 // A sequence for each text section.
3378 unsigned SecSrcLinesSize = SectionSourceLines.size();
3380 for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
3381 // Isolate current sections line info.
3382 const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
3384 // Dwarf assumes we start with first line of first source file.
3385 unsigned Source = 1;
3388 // Construct rows of the address, source, line, column matrix.
3389 for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
3390 const SrcLineInfo &LineInfo = LineInfos[i];
3391 MCSymbol *Label = LineInfo.getLabel();
3392 if (!Label->isDefined()) continue; // Not emitted, in dead code.
3394 if (Asm->isVerbose()) {
3395 std::pair<unsigned, unsigned> SrcID =
3396 getSourceDirectoryAndFileIds(LineInfo.getSourceID());
3397 Asm->OutStreamer.AddComment(Twine(getSourceDirectoryName(SrcID.first)) +
3399 Twine(getSourceFileName(SrcID.second)) +
3400 ":" + Twine(LineInfo.getLine()));
3403 // Define the line address.
3404 Asm->OutStreamer.AddComment("Extended Op");
3406 Asm->OutStreamer.AddComment("Op size");
3407 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3409 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3410 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3412 Asm->OutStreamer.AddComment("Location label");
3413 Asm->OutStreamer.EmitSymbolValue(Label,
3414 Asm->getTargetData().getPointerSize(),
3417 // If change of source, then switch to the new source.
3418 if (Source != LineInfo.getSourceID()) {
3419 Source = LineInfo.getSourceID();
3420 Asm->OutStreamer.AddComment("DW_LNS_set_file");
3421 Asm->EmitInt8(dwarf::DW_LNS_set_file);
3422 Asm->EmitULEB128(Source, "New Source");
3425 // If change of line.
3426 if (Line != LineInfo.getLine()) {
3427 // Determine offset.
3428 int Offset = LineInfo.getLine() - Line;
3429 int Delta = Offset - MinLineDelta;
3432 Line = LineInfo.getLine();
3434 // If delta is small enough and in range...
3435 if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
3436 // ... then use fast opcode.
3437 Asm->OutStreamer.AddComment("Line Delta");
3438 Asm->EmitInt8(Delta - MinLineDelta);
3440 // ... otherwise use long hand.
3441 Asm->OutStreamer.AddComment("DW_LNS_advance_line");
3442 Asm->EmitInt8(dwarf::DW_LNS_advance_line);
3443 Asm->EmitSLEB128(Offset, "Line Offset");
3444 Asm->OutStreamer.AddComment("DW_LNS_copy");
3445 Asm->EmitInt8(dwarf::DW_LNS_copy);
3448 // Copy the previous row (different address or source)
3449 Asm->OutStreamer.AddComment("DW_LNS_copy");
3450 Asm->EmitInt8(dwarf::DW_LNS_copy);
3454 emitEndOfLineMatrix(j + 1);
3457 if (SecSrcLinesSize == 0)
3458 // Because we're emitting a debug_line section, we still need a line
3459 // table. The linker and friends expect it to exist. If there's nothing to
3460 // put into it, emit an empty table.
3461 emitEndOfLineMatrix(1);
3463 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("line_end"));
3466 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3468 void DwarfDebug::emitCommonDebugFrame() {
3469 if (!Asm->MAI->doesDwarfRequireFrameSection())
3472 int stackGrowth = Asm->getTargetData().getPointerSize();
3473 if (Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
3474 TargetFrameInfo::StackGrowsDown)
3477 // Start the dwarf frame section.
3478 Asm->OutStreamer.SwitchSection(
3479 Asm->getObjFileLowering().getDwarfFrameSection());
3481 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3482 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3483 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3484 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3486 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3487 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3488 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3489 Asm->OutStreamer.AddComment("CIE Version");
3490 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3491 Asm->OutStreamer.AddComment("CIE Augmentation");
3492 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3493 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3494 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3495 Asm->OutStreamer.AddComment("CIE RA Column");
3496 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3497 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3499 std::vector<MachineMove> Moves;
3500 RI->getInitialFrameState(Moves);
3502 Asm->EmitFrameMoves(Moves, 0, false);
3504 Asm->EmitAlignment(2);
3505 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3508 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3511 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3512 if (!Asm->MAI->doesDwarfRequireFrameSection())
3515 // Start the dwarf frame section.
3516 Asm->OutStreamer.SwitchSection(
3517 Asm->getObjFileLowering().getDwarfFrameSection());
3519 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3520 MCSymbol *DebugFrameBegin =
3521 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3522 MCSymbol *DebugFrameEnd =
3523 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3524 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3526 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3528 Asm->OutStreamer.AddComment("FDE CIE offset");
3529 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3530 DwarfFrameSectionSym);
3532 Asm->OutStreamer.AddComment("FDE initial location");
3533 MCSymbol *FuncBeginSym =
3534 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3535 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3536 Asm->getTargetData().getPointerSize(),
3540 Asm->OutStreamer.AddComment("FDE address range");
3541 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3542 FuncBeginSym, Asm->getTargetData().getPointerSize());
3544 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3546 Asm->EmitAlignment(2);
3547 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3550 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3552 void DwarfDebug::emitDebugPubNames() {
3553 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3554 E = CUMap.end(); I != E; ++I) {
3555 CompileUnit *TheCU = I->second;
3556 // Start the dwarf pubnames section.
3557 Asm->OutStreamer.SwitchSection(
3558 Asm->getObjFileLowering().getDwarfPubNamesSection());
3560 Asm->OutStreamer.AddComment("Length of Public Names Info");
3561 Asm->EmitLabelDifference(
3562 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3563 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3565 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3568 Asm->OutStreamer.AddComment("DWARF Version");
3569 Asm->EmitInt16(dwarf::DWARF_VERSION);
3571 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3572 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3573 DwarfInfoSectionSym);
3575 Asm->OutStreamer.AddComment("Compilation Unit Length");
3576 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3577 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3580 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3581 for (StringMap<DIE*>::const_iterator
3582 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3583 const char *Name = GI->getKeyData();
3584 DIE *Entity = GI->second;
3586 Asm->OutStreamer.AddComment("DIE offset");
3587 Asm->EmitInt32(Entity->getOffset());
3589 if (Asm->isVerbose())
3590 Asm->OutStreamer.AddComment("External Name");
3591 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3594 Asm->OutStreamer.AddComment("End Mark");
3596 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3601 void DwarfDebug::emitDebugPubTypes() {
3602 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3603 E = CUMap.end(); I != E; ++I) {
3604 CompileUnit *TheCU = I->second;
3605 // Start the dwarf pubnames section.
3606 Asm->OutStreamer.SwitchSection(
3607 Asm->getObjFileLowering().getDwarfPubTypesSection());
3608 Asm->OutStreamer.AddComment("Length of Public Types Info");
3609 Asm->EmitLabelDifference(
3610 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3611 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3613 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3616 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3617 Asm->EmitInt16(dwarf::DWARF_VERSION);
3619 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3620 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3621 DwarfInfoSectionSym);
3623 Asm->OutStreamer.AddComment("Compilation Unit Length");
3624 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3625 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3628 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3629 for (StringMap<DIE*>::const_iterator
3630 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3631 const char *Name = GI->getKeyData();
3632 DIE * Entity = GI->second;
3634 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3635 Asm->EmitInt32(Entity->getOffset());
3637 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3638 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3641 Asm->OutStreamer.AddComment("End Mark");
3643 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3648 /// emitDebugStr - Emit visible names into a debug str section.
3650 void DwarfDebug::emitDebugStr() {
3651 // Check to see if it is worth the effort.
3652 if (StringPool.empty()) return;
3654 // Start the dwarf str section.
3655 Asm->OutStreamer.SwitchSection(
3656 Asm->getObjFileLowering().getDwarfStrSection());
3658 // Get all of the string pool entries and put them in an array by their ID so
3659 // we can sort them.
3660 SmallVector<std::pair<unsigned,
3661 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3663 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3664 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3665 Entries.push_back(std::make_pair(I->second.second, &*I));
3667 array_pod_sort(Entries.begin(), Entries.end());
3669 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3670 // Emit a label for reference from debug information entries.
3671 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3673 // Emit the string itself.
3674 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3678 /// emitDebugLoc - Emit visible names into a debug loc section.
3680 void DwarfDebug::emitDebugLoc() {
3681 if (DotDebugLocEntries.empty())
3684 // Start the dwarf loc section.
3685 Asm->OutStreamer.SwitchSection(
3686 Asm->getObjFileLowering().getDwarfLocSection());
3687 unsigned char Size = Asm->getTargetData().getPointerSize();
3688 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3690 for (SmallVector<DotDebugLocEntry, 4>::iterator
3691 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3692 I != E; ++I, ++index) {
3693 DotDebugLocEntry Entry = *I;
3694 if (Entry.isEmpty()) {
3695 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3696 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3697 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3699 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3700 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3701 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3702 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3703 if (int Offset = Entry.Loc.getOffset()) {
3704 // If the value is at a certain offset from frame register then
3706 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3707 Asm->OutStreamer.AddComment("Loc expr size");
3708 Asm->EmitInt16(1 + OffsetSize);
3709 Asm->OutStreamer.AddComment(
3710 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3711 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3712 Asm->OutStreamer.AddComment("Offset");
3713 Asm->EmitSLEB128(Offset);
3716 Asm->OutStreamer.AddComment("Loc expr size");
3718 Asm->OutStreamer.AddComment(
3719 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3720 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3722 Asm->OutStreamer.AddComment("Loc expr size");
3723 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3724 Asm->EmitInt8(dwarf::DW_OP_regx);
3725 Asm->EmitULEB128(Reg);
3732 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3734 void DwarfDebug::EmitDebugARanges() {
3735 // Start the dwarf aranges section.
3736 Asm->OutStreamer.SwitchSection(
3737 Asm->getObjFileLowering().getDwarfARangesSection());
3740 /// emitDebugRanges - Emit visible names into a debug ranges section.
3742 void DwarfDebug::emitDebugRanges() {
3743 // Start the dwarf ranges section.
3744 Asm->OutStreamer.SwitchSection(
3745 Asm->getObjFileLowering().getDwarfRangesSection());
3746 unsigned char Size = Asm->getTargetData().getPointerSize();
3747 for (SmallVector<const MCSymbol *, 8>::iterator
3748 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3751 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3753 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3757 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3759 void DwarfDebug::emitDebugMacInfo() {
3760 if (const MCSection *LineInfo =
3761 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3762 // Start the dwarf macinfo section.
3763 Asm->OutStreamer.SwitchSection(LineInfo);
3767 /// emitDebugInlineInfo - Emit inline info using following format.
3769 /// 1. length of section
3770 /// 2. Dwarf version number
3771 /// 3. address size.
3773 /// Entries (one "entry" for each function that was inlined):
3775 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3776 /// otherwise offset into __debug_str for regular function name.
3777 /// 2. offset into __debug_str section for regular function name.
3778 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3779 /// instances for the function.
3781 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3782 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3783 /// __debug_info section, and the low_pc is the starting address for the
3784 /// inlining instance.
3785 void DwarfDebug::emitDebugInlineInfo() {
3786 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3792 Asm->OutStreamer.SwitchSection(
3793 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3795 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3796 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3797 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3799 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3801 Asm->OutStreamer.AddComment("Dwarf Version");
3802 Asm->EmitInt16(dwarf::DWARF_VERSION);
3803 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3804 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3806 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3807 E = InlinedSPNodes.end(); I != E; ++I) {
3809 const MDNode *Node = *I;
3810 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3811 = InlineInfo.find(Node);
3812 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3813 DISubprogram SP(Node);
3814 StringRef LName = SP.getLinkageName();
3815 StringRef Name = SP.getName();
3817 Asm->OutStreamer.AddComment("MIPS linkage name");
3818 if (LName.empty()) {
3819 Asm->OutStreamer.EmitBytes(Name, 0);
3820 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3822 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3823 DwarfStrSectionSym);
3825 Asm->OutStreamer.AddComment("Function name");
3826 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3827 Asm->EmitULEB128(Labels.size(), "Inline count");
3829 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3830 LE = Labels.end(); LI != LE; ++LI) {
3831 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3832 Asm->EmitInt32(LI->second->getOffset());
3834 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3835 Asm->OutStreamer.EmitSymbolValue(LI->first,
3836 Asm->getTargetData().getPointerSize(),0);
3840 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));