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/Instructions.h"
20 #include "llvm/CodeGen/MachineFunction.h"
21 #include "llvm/CodeGen/MachineModuleInfo.h"
22 #include "llvm/MC/MCAsmInfo.h"
23 #include "llvm/MC/MCSection.h"
24 #include "llvm/MC/MCStreamer.h"
25 #include "llvm/MC/MCSymbol.h"
26 #include "llvm/Target/Mangler.h"
27 #include "llvm/Target/TargetData.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetLoweringObjectFile.h"
30 #include "llvm/Target/TargetMachine.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
32 #include "llvm/Target/TargetOptions.h"
33 #include "llvm/Analysis/DebugInfo.h"
34 #include "llvm/Analysis/DIBuilder.h"
35 #include "llvm/ADT/Statistic.h"
36 #include "llvm/ADT/STLExtras.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/ErrorHandling.h"
41 #include "llvm/Support/ValueHandle.h"
42 #include "llvm/Support/FormattedStream.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/Path.h"
47 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
48 cl::desc("Print DbgScope information for each machine instruction"));
50 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
52 cl::desc("Disable debug info printing"));
54 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
55 cl::desc("Make an absense of debug location information explicit."),
59 STATISTIC(BlocksWithoutLineNo, "Number of blocks without any line number");
63 const char *DWARFGroupName = "DWARF Emission";
64 const char *DbgTimerName = "DWARF Debug Writer";
65 } // end anonymous namespace
67 //===----------------------------------------------------------------------===//
69 /// Configuration values for initial hash set sizes (log2).
71 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
75 //===----------------------------------------------------------------------===//
76 /// CompileUnit - This dwarf writer support class manages information associate
77 /// with a source file.
79 /// ID - File identifier for source.
83 /// Die - Compile unit debug information entry.
85 const OwningPtr<DIE> CUDie;
87 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
90 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
91 /// variables to debug information entries.
92 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
94 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
95 /// descriptors to debug information entries using a DIEEntry proxy.
96 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
98 /// Globals - A map of globally visible named entities for this unit.
100 StringMap<DIE*> Globals;
102 /// GlobalTypes - A map of globally visible types for this unit.
104 StringMap<DIE*> GlobalTypes;
107 CompileUnit(unsigned I, DIE *D)
108 : ID(I), CUDie(D), IndexTyDie(0) {}
111 unsigned getID() const { return ID; }
112 DIE* getCUDie() const { return CUDie.get(); }
113 const StringMap<DIE*> &getGlobals() const { return Globals; }
114 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
116 /// hasContent - Return true if this compile unit has something to write out.
118 bool hasContent() const { return !CUDie->getChildren().empty(); }
120 /// addGlobal - Add a new global entity to the compile unit.
122 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
124 /// addGlobalType - Add a new global type to the compile unit.
126 void addGlobalType(StringRef Name, DIE *Die) {
127 GlobalTypes[Name] = Die;
130 /// getDIE - Returns the debug information entry map slot for the
131 /// specified debug variable.
132 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
134 /// insertDIE - Insert DIE into the map.
135 void insertDIE(const MDNode *N, DIE *D) {
136 MDNodeToDieMap.insert(std::make_pair(N, D));
139 /// getDIEEntry - Returns the debug information entry for the speciefied
141 DIEEntry *getDIEEntry(const MDNode *N) {
142 DenseMap<const MDNode *, DIEEntry *>::iterator I =
143 MDNodeToDIEEntryMap.find(N);
144 if (I == MDNodeToDIEEntryMap.end())
149 /// insertDIEEntry - Insert debug information entry into the map.
150 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
151 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
154 /// addDie - Adds or interns the DIE to the compile unit.
156 void addDie(DIE *Buffer) {
157 this->CUDie->addChild(Buffer);
160 // getIndexTyDie - Get an anonymous type for index type.
161 DIE *getIndexTyDie() {
165 // setIndexTyDie - Set D as anonymous type for index which can be reused
167 void setIndexTyDie(DIE *D) {
173 //===----------------------------------------------------------------------===//
174 /// DbgVariable - This class is used to track local variable information.
177 DIVariable Var; // Variable Descriptor.
178 DIE *TheDIE; // Variable DIE.
179 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
181 // AbsVar may be NULL.
182 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
185 DIVariable getVariable() const { return Var; }
186 void setDIE(DIE *D) { TheDIE = D; }
187 DIE *getDIE() const { return TheDIE; }
188 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
189 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
190 StringRef getName() const { return Var.getName(); }
191 unsigned getTag() const { return Var.getTag(); }
192 bool variableHasComplexAddress() const {
193 assert(Var.Verify() && "Invalid complex DbgVariable!");
194 return Var.hasComplexAddress();
196 bool isBlockByrefVariable() const {
197 assert(Var.Verify() && "Invalid complex DbgVariable!");
198 return Var.isBlockByrefVariable();
200 unsigned getNumAddrElements() const {
201 assert(Var.Verify() && "Invalid complex DbgVariable!");
202 return Var.getNumAddrElements();
204 uint64_t getAddrElement(unsigned i) const {
205 return Var.getAddrElement(i);
207 DIType getType() const {
208 DIType Ty = Var.getType();
209 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
210 // addresses instead.
211 if (Var.isBlockByrefVariable()) {
212 /* Byref variables, in Blocks, are declared by the programmer as
213 "SomeType VarName;", but the compiler creates a
214 __Block_byref_x_VarName struct, and gives the variable VarName
215 either the struct, or a pointer to the struct, as its type. This
216 is necessary for various behind-the-scenes things the compiler
217 needs to do with by-reference variables in blocks.
219 However, as far as the original *programmer* is concerned, the
220 variable should still have type 'SomeType', as originally declared.
222 The following function dives into the __Block_byref_x_VarName
223 struct to find the original type of the variable. This will be
224 passed back to the code generating the type for the Debug
225 Information Entry for the variable 'VarName'. 'VarName' will then
226 have the original type 'SomeType' in its debug information.
228 The original type 'SomeType' will be the type of the field named
229 'VarName' inside the __Block_byref_x_VarName struct.
231 NOTE: In order for this to not completely fail on the debugger
232 side, the Debug Information Entry for the variable VarName needs to
233 have a DW_AT_location that tells the debugger how to unwind through
234 the pointers and __Block_byref_x_VarName struct to find the actual
235 value of the variable. The function addBlockByrefType does this. */
237 unsigned tag = Ty.getTag();
239 if (tag == dwarf::DW_TAG_pointer_type) {
240 DIDerivedType DTy = DIDerivedType(Ty);
241 subType = DTy.getTypeDerivedFrom();
244 DICompositeType blockStruct = DICompositeType(subType);
245 DIArray Elements = blockStruct.getTypeArray();
247 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
248 DIDescriptor Element = Elements.getElement(i);
249 DIDerivedType DT = DIDerivedType(Element);
250 if (getName() == DT.getName())
251 return (DT.getTypeDerivedFrom());
259 //===----------------------------------------------------------------------===//
260 /// DbgRange - This is used to track range of instructions with identical
261 /// debug info scope.
263 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
265 //===----------------------------------------------------------------------===//
266 /// DbgScope - This class is used to track scope information.
269 DbgScope *Parent; // Parent to this scope.
270 DIDescriptor Desc; // Debug info descriptor for scope.
271 // Location at which this scope is inlined.
272 AssertingVH<const MDNode> InlinedAtLocation;
273 bool AbstractScope; // Abstract Scope
274 const MachineInstr *LastInsn; // Last instruction of this scope.
275 const MachineInstr *FirstInsn; // First instruction of this scope.
276 unsigned DFSIn, DFSOut;
277 // Scopes defined in scope. Contents not owned.
278 SmallVector<DbgScope *, 4> Scopes;
279 // Variables declared in scope. Contents owned.
280 SmallVector<DbgVariable *, 8> Variables;
281 SmallVector<DbgRange, 4> Ranges;
282 // Private state for dump()
283 mutable unsigned IndentLevel;
285 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
286 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
287 LastInsn(0), FirstInsn(0),
288 DFSIn(0), DFSOut(0), IndentLevel(0) {}
292 DbgScope *getParent() const { return Parent; }
293 void setParent(DbgScope *P) { Parent = P; }
294 DIDescriptor getDesc() const { return Desc; }
295 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
296 const MDNode *getScopeNode() const { return Desc; }
297 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
298 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
299 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
301 /// openInsnRange - This scope covers instruction range starting from MI.
302 void openInsnRange(const MachineInstr *MI) {
307 Parent->openInsnRange(MI);
310 /// extendInsnRange - Extend the current instruction range covered by
312 void extendInsnRange(const MachineInstr *MI) {
313 assert (FirstInsn && "MI Range is not open!");
316 Parent->extendInsnRange(MI);
319 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
320 /// until now. This is used when a new scope is encountered while walking
321 /// machine instructions.
322 void closeInsnRange(DbgScope *NewScope = NULL) {
323 assert (LastInsn && "Last insn missing!");
324 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
327 // If Parent dominates NewScope then do not close Parent's instruction
329 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
330 Parent->closeInsnRange(NewScope);
333 void setAbstractScope() { AbstractScope = true; }
334 bool isAbstractScope() const { return AbstractScope; }
336 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
337 unsigned getDFSOut() const { return DFSOut; }
338 void setDFSOut(unsigned O) { DFSOut = O; }
339 unsigned getDFSIn() const { return DFSIn; }
340 void setDFSIn(unsigned I) { DFSIn = I; }
341 bool dominates(const DbgScope *S) {
344 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
349 /// addScope - Add a scope to the scope.
351 void addScope(DbgScope *S) { Scopes.push_back(S); }
353 /// addVariable - Add a variable to the scope.
355 void addVariable(DbgVariable *V) { Variables.push_back(V); }
362 } // end llvm namespace
365 void DbgScope::dump() const {
366 raw_ostream &err = dbgs();
367 err.indent(IndentLevel);
368 const MDNode *N = Desc;
371 err << "Abstract Scope\n";
375 err << "Children ...\n";
376 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
377 if (Scopes[i] != this)
384 DbgScope::~DbgScope() {
385 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
389 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
390 : Asm(A), MMI(Asm->MMI), FirstCU(0),
391 AbbreviationsSet(InitAbbreviationsSetSize),
392 CurrentFnDbgScope(0), PrevLabel(NULL) {
393 NextStringPoolNumber = 0;
395 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
396 DwarfStrSectionSym = TextSectionSym = 0;
397 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
398 FunctionBeginSym = FunctionEndSym = 0;
399 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
401 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
405 DwarfDebug::~DwarfDebug() {
406 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
407 DIEBlocks[j]->~DIEBlock();
410 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
411 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
412 if (Entry.first) return Entry.first;
414 Entry.second = NextStringPoolNumber++;
415 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
419 /// assignAbbrevNumber - Define a unique number for the abbreviation.
421 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
422 // Profile the node so that we can make it unique.
426 // Check the set for priors.
427 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
429 // If it's newly added.
430 if (InSet == &Abbrev) {
431 // Add to abbreviation list.
432 Abbreviations.push_back(&Abbrev);
434 // Assign the vector position + 1 as its number.
435 Abbrev.setNumber(Abbreviations.size());
437 // Assign existing abbreviation number.
438 Abbrev.setNumber(InSet->getNumber());
442 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
443 /// information entry.
444 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
445 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
449 /// addUInt - Add an unsigned integer attribute data and value.
451 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
452 unsigned Form, uint64_t Integer) {
453 if (!Form) Form = DIEInteger::BestForm(false, Integer);
454 DIEValue *Value = Integer == 1 ?
455 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
456 Die->addValue(Attribute, Form, Value);
459 /// addSInt - Add an signed integer attribute data and value.
461 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
462 unsigned Form, int64_t Integer) {
463 if (!Form) Form = DIEInteger::BestForm(true, Integer);
464 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
465 Die->addValue(Attribute, Form, Value);
468 /// addString - Add a string attribute data and value. DIEString only
469 /// keeps string reference.
470 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
472 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
473 Die->addValue(Attribute, Form, Value);
476 /// addLabel - Add a Dwarf label attribute data and value.
478 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
479 const MCSymbol *Label) {
480 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
481 Die->addValue(Attribute, Form, Value);
484 /// addDelta - Add a label delta attribute data and value.
486 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
487 const MCSymbol *Hi, const MCSymbol *Lo) {
488 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
489 Die->addValue(Attribute, Form, Value);
492 /// addDIEEntry - Add a DIE attribute data and value.
494 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
496 Die->addValue(Attribute, Form, createDIEEntry(Entry));
500 /// addBlock - Add block data.
502 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
504 Block->ComputeSize(Asm);
505 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
506 Die->addValue(Attribute, Block->BestForm(), Block);
509 /// addSourceLine - Add location information to specified debug information
511 void DwarfDebug::addSourceLine(DIE *Die, DIVariable V) {
516 unsigned Line = V.getLineNumber();
519 unsigned FileID = GetOrCreateSourceID(V.getContext().getFilename(),
520 V.getContext().getDirectory());
521 assert(FileID && "Invalid file id");
522 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
523 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
526 /// addSourceLine - Add location information to specified debug information
528 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
529 // Verify global variable.
533 unsigned Line = G.getLineNumber();
536 unsigned FileID = GetOrCreateSourceID(G.getContext().getFilename(),
537 G.getContext().getDirectory());
538 assert(FileID && "Invalid file id");
539 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
540 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
543 /// addSourceLine - Add location information to specified debug information
545 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
546 // Verify subprogram.
549 // If the line number is 0, don't add it.
550 if (SP.getLineNumber() == 0)
553 unsigned Line = SP.getLineNumber();
554 if (!SP.getContext().Verify())
556 unsigned FileID = GetOrCreateSourceID(SP.getFilename(), SP.getDirectory());
557 assert(FileID && "Invalid file id");
558 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
559 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
562 /// addSourceLine - Add location information to specified debug information
564 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
569 unsigned Line = Ty.getLineNumber();
570 if (Line == 0 || !Ty.getContext().Verify())
572 unsigned FileID = GetOrCreateSourceID(Ty.getFilename(), Ty.getDirectory());
573 assert(FileID && "Invalid file id");
574 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
575 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
578 /// addSourceLine - Add location information to specified debug information
580 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
585 unsigned Line = NS.getLineNumber();
588 StringRef FN = NS.getFilename();
590 unsigned FileID = GetOrCreateSourceID(FN, NS.getDirectory());
591 assert(FileID && "Invalid file id");
592 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
593 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
596 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based
597 /// on provided frame index.
598 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) {
599 MachineLocation Location;
601 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
602 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
603 Location.set(FrameReg, Offset);
605 if (DV->variableHasComplexAddress())
606 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
607 else if (DV->isBlockByrefVariable())
608 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
610 addAddress(Die, dwarf::DW_AT_location, Location);
613 /// addComplexAddress - Start with the address based on the location provided,
614 /// and generate the DWARF information necessary to find the actual variable
615 /// given the extra address information encoded in the DIVariable, starting from
616 /// the starting location. Add the DWARF information to the die.
618 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
620 const MachineLocation &Location) {
621 DIType Ty = DV->getType();
623 // Decode the original location, and use that as the start of the byref
624 // variable's location.
625 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
626 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
627 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
629 if (Location.isReg()) {
631 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
633 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
634 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
638 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
640 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
641 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
644 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
647 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
648 uint64_t Element = DV->getAddrElement(i);
650 if (Element == DIBuilder::OpPlus) {
651 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
652 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
653 } else if (Element == DIBuilder::OpDeref) {
654 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
655 } else llvm_unreachable("unknown DIBuilder Opcode");
658 // Now attach the location information to the DIE.
659 addBlock(Die, Attribute, 0, Block);
662 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
663 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
664 gives the variable VarName either the struct, or a pointer to the struct, as
665 its type. This is necessary for various behind-the-scenes things the
666 compiler needs to do with by-reference variables in Blocks.
668 However, as far as the original *programmer* is concerned, the variable
669 should still have type 'SomeType', as originally declared.
671 The function getBlockByrefType dives into the __Block_byref_x_VarName
672 struct to find the original type of the variable, which is then assigned to
673 the variable's Debug Information Entry as its real type. So far, so good.
674 However now the debugger will expect the variable VarName to have the type
675 SomeType. So we need the location attribute for the variable to be an
676 expression that explains to the debugger how to navigate through the
677 pointers and struct to find the actual variable of type SomeType.
679 The following function does just that. We start by getting
680 the "normal" location for the variable. This will be the location
681 of either the struct __Block_byref_x_VarName or the pointer to the
682 struct __Block_byref_x_VarName.
684 The struct will look something like:
686 struct __Block_byref_x_VarName {
688 struct __Block_byref_x_VarName *forwarding;
689 ... <various other fields>
691 ... <maybe more fields>
694 If we are given the struct directly (as our starting point) we
695 need to tell the debugger to:
697 1). Add the offset of the forwarding field.
699 2). Follow that pointer to get the real __Block_byref_x_VarName
700 struct to use (the real one may have been copied onto the heap).
702 3). Add the offset for the field VarName, to find the actual variable.
704 If we started with a pointer to the struct, then we need to
705 dereference that pointer first, before the other steps.
706 Translating this into DWARF ops, we will need to append the following
707 to the current location description for the variable:
709 DW_OP_deref -- optional, if we start with a pointer
710 DW_OP_plus_uconst <forward_fld_offset>
712 DW_OP_plus_uconst <varName_fld_offset>
714 That is what this function does. */
716 /// addBlockByrefAddress - Start with the address based on the location
717 /// provided, and generate the DWARF information necessary to find the
718 /// actual Block variable (navigating the Block struct) based on the
719 /// starting location. Add the DWARF information to the die. For
720 /// more information, read large comment just above here.
722 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
724 const MachineLocation &Location) {
725 DIType Ty = DV->getType();
727 unsigned Tag = Ty.getTag();
728 bool isPointer = false;
730 StringRef varName = DV->getName();
732 if (Tag == dwarf::DW_TAG_pointer_type) {
733 DIDerivedType DTy = DIDerivedType(Ty);
734 TmpTy = DTy.getTypeDerivedFrom();
738 DICompositeType blockStruct = DICompositeType(TmpTy);
740 // Find the __forwarding field and the variable field in the __Block_byref
742 DIArray Fields = blockStruct.getTypeArray();
743 DIDescriptor varField = DIDescriptor();
744 DIDescriptor forwardingField = DIDescriptor();
746 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
747 DIDescriptor Element = Fields.getElement(i);
748 DIDerivedType DT = DIDerivedType(Element);
749 StringRef fieldName = DT.getName();
750 if (fieldName == "__forwarding")
751 forwardingField = Element;
752 else if (fieldName == varName)
756 // Get the offsets for the forwarding field and the variable field.
757 unsigned forwardingFieldOffset =
758 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
759 unsigned varFieldOffset =
760 DIDerivedType(varField).getOffsetInBits() >> 3;
762 // Decode the original location, and use that as the start of the byref
763 // variable's location.
764 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
765 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
766 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
768 if (Location.isReg()) {
770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
773 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
777 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
779 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
780 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
783 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
786 // If we started with a pointer to the __Block_byref... struct, then
787 // the first thing we need to do is dereference the pointer (DW_OP_deref).
789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
791 // Next add the offset for the '__forwarding' field:
792 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
793 // adding the offset if it's 0.
794 if (forwardingFieldOffset > 0) {
795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
799 // Now dereference the __forwarding field to get to the real __Block_byref
800 // struct: DW_OP_deref.
801 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
803 // Now that we've got the real __Block_byref... struct, add the offset
804 // for the variable's field to get to the location of the actual variable:
805 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
806 if (varFieldOffset > 0) {
807 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
808 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
811 // Now attach the location information to the DIE.
812 addBlock(Die, Attribute, 0, Block);
815 /// addAddress - Add an address attribute to a die based on the location
817 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
818 const MachineLocation &Location) {
819 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
820 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
821 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
823 if (RI->getFrameRegister(*Asm->MF) == Location.getReg()
824 && Location.getOffset()) {
825 // If variable offset is based in frame register then use fbreg.
826 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
827 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
828 addBlock(Die, Attribute, 0, Block);
832 if (Location.isReg()) {
834 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
836 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
837 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
841 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
843 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
844 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
847 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
850 addBlock(Die, Attribute, 0, Block);
853 /// addRegisterAddress - Add register location entry in variable DIE.
854 bool DwarfDebug::addRegisterAddress(DIE *Die, const MachineOperand &MO) {
855 assert (MO.isReg() && "Invalid machine operand!");
858 MachineLocation Location;
859 Location.set(MO.getReg());
860 addAddress(Die, dwarf::DW_AT_location, Location);
864 /// addConstantValue - Add constant value entry in variable DIE.
865 bool DwarfDebug::addConstantValue(DIE *Die, const MachineOperand &MO) {
866 assert (MO.isImm() && "Invalid machine operand!");
867 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
868 unsigned Imm = MO.getImm();
869 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
870 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
874 /// addConstantFPValue - Add constant value entry in variable DIE.
875 bool DwarfDebug::addConstantFPValue(DIE *Die, 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);
899 /// addConstantValue - Add constant value entry in variable DIE.
900 bool DwarfDebug::addConstantValue(DIE *Die, ConstantInt *CI,
902 if (CI->getBitWidth() <= 64) {
904 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
907 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
912 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
914 // Get the raw data form of the large APInt.
915 const APInt Val = CI->getValue();
916 const char *Ptr = (const char*)Val.getRawData();
918 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
919 bool LittleEndian = Asm->getTargetData().isLittleEndian();
920 int Incr = (LittleEndian ? 1 : -1);
921 int Start = (LittleEndian ? 0 : NumBytes - 1);
922 int Stop = (LittleEndian ? NumBytes : -1);
924 // Output the constant to DWARF one byte at a time.
925 for (; Start != Stop; Start += Incr)
926 addUInt(Block, 0, dwarf::DW_FORM_data1,
927 (unsigned char)0xFF & Ptr[Start]);
929 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
933 /// addTemplateParams - Add template parameters in buffer.
934 void DwarfDebug::addTemplateParams(DIE &Buffer, DIArray TParams) {
935 // Add template parameters.
936 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
937 DIDescriptor Element = TParams.getElement(i);
938 if (Element.isTemplateTypeParameter())
939 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
940 DITemplateTypeParameter(Element)));
941 else if (Element.isTemplateValueParameter())
942 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
943 DITemplateValueParameter(Element)));
947 /// addToContextOwner - Add Die into the list of its context owner's children.
948 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
949 if (Context.isType()) {
950 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
951 ContextDIE->addChild(Die);
952 } else if (Context.isNameSpace()) {
953 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
954 ContextDIE->addChild(Die);
955 } else if (Context.isSubprogram()) {
956 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context));
957 ContextDIE->addChild(Die);
958 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
959 ContextDIE->addChild(Die);
961 getCompileUnit(Context)->addDie(Die);
964 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
966 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
967 CompileUnit *TypeCU = getCompileUnit(Ty);
968 DIE *TyDIE = TypeCU->getDIE(Ty);
973 TyDIE = new DIE(dwarf::DW_TAG_base_type);
974 TypeCU->insertDIE(Ty, TyDIE);
975 if (Ty.isBasicType())
976 constructTypeDIE(*TyDIE, DIBasicType(Ty));
977 else if (Ty.isCompositeType())
978 constructTypeDIE(*TyDIE, DICompositeType(Ty));
980 assert(Ty.isDerivedType() && "Unknown kind of DIType");
981 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
984 addToContextOwner(TyDIE, Ty.getContext());
988 /// addType - Add a new type attribute to the specified entity.
989 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
993 // Check for pre-existence.
994 CompileUnit *TypeCU = getCompileUnit(Ty);
995 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
996 // If it exists then use the existing value.
998 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
1003 DIE *Buffer = getOrCreateTypeDIE(Ty);
1006 Entry = createDIEEntry(Buffer);
1007 TypeCU->insertDIEEntry(Ty, Entry);
1009 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
1012 /// constructTypeDIE - Construct basic type die from DIBasicType.
1013 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1014 // Get core information.
1015 StringRef Name = BTy.getName();
1016 Buffer.setTag(dwarf::DW_TAG_base_type);
1017 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1020 // Add name if not anonymous or intermediate type.
1022 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1023 uint64_t Size = BTy.getSizeInBits() >> 3;
1024 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1027 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1028 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1029 // Get core information.
1030 StringRef Name = DTy.getName();
1031 uint64_t Size = DTy.getSizeInBits() >> 3;
1032 unsigned Tag = DTy.getTag();
1034 // FIXME - Workaround for templates.
1035 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
1039 // Map to main type, void will not have a type.
1040 DIType FromTy = DTy.getTypeDerivedFrom();
1041 addType(&Buffer, FromTy);
1043 // Add name if not anonymous or intermediate type.
1045 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1047 // Add size if non-zero (derived types might be zero-sized.)
1049 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1051 // Add source line info if available and TyDesc is not a forward declaration.
1052 if (!DTy.isForwardDecl())
1053 addSourceLine(&Buffer, DTy);
1056 /// constructTypeDIE - Construct type DIE from DICompositeType.
1057 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1058 // Get core information.
1059 StringRef Name = CTy.getName();
1061 uint64_t Size = CTy.getSizeInBits() >> 3;
1062 unsigned Tag = CTy.getTag();
1066 case dwarf::DW_TAG_vector_type:
1067 case dwarf::DW_TAG_array_type:
1068 constructArrayTypeDIE(Buffer, &CTy);
1070 case dwarf::DW_TAG_enumeration_type: {
1071 DIArray Elements = CTy.getTypeArray();
1073 // Add enumerators to enumeration type.
1074 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1075 DIE *ElemDie = NULL;
1076 DIDescriptor Enum(Elements.getElement(i));
1077 if (Enum.isEnumerator()) {
1078 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1079 Buffer.addChild(ElemDie);
1084 case dwarf::DW_TAG_subroutine_type: {
1086 DIArray Elements = CTy.getTypeArray();
1087 DIDescriptor RTy = Elements.getElement(0);
1088 addType(&Buffer, DIType(RTy));
1090 bool isPrototyped = true;
1092 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1093 DIDescriptor Ty = Elements.getElement(i);
1094 if (Ty.isUnspecifiedParameter()) {
1095 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1096 Buffer.addChild(Arg);
1097 isPrototyped = false;
1099 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1100 addType(Arg, DIType(Ty));
1101 Buffer.addChild(Arg);
1104 // Add prototype flag.
1106 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1109 case dwarf::DW_TAG_structure_type:
1110 case dwarf::DW_TAG_union_type:
1111 case dwarf::DW_TAG_class_type: {
1112 // Add elements to structure type.
1113 DIArray Elements = CTy.getTypeArray();
1115 // A forward struct declared type may not have elements available.
1116 unsigned N = Elements.getNumElements();
1120 // Add elements to structure type.
1121 for (unsigned i = 0; i < N; ++i) {
1122 DIDescriptor Element = Elements.getElement(i);
1123 DIE *ElemDie = NULL;
1124 if (Element.isSubprogram()) {
1125 DISubprogram SP(Element);
1126 ElemDie = createSubprogramDIE(DISubprogram(Element));
1127 if (SP.isProtected())
1128 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1129 dwarf::DW_ACCESS_protected);
1130 else if (SP.isPrivate())
1131 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1132 dwarf::DW_ACCESS_private);
1134 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1135 dwarf::DW_ACCESS_public);
1136 if (SP.isExplicit())
1137 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
1139 else if (Element.isVariable()) {
1140 DIVariable DV(Element);
1141 ElemDie = new DIE(dwarf::DW_TAG_variable);
1142 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1144 addType(ElemDie, DV.getType());
1145 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1146 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1147 addSourceLine(ElemDie, DV);
1148 } else if (Element.isDerivedType())
1149 ElemDie = createMemberDIE(DIDerivedType(Element));
1152 Buffer.addChild(ElemDie);
1155 if (CTy.isAppleBlockExtension())
1156 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1158 unsigned RLang = CTy.getRunTimeLang();
1160 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1161 dwarf::DW_FORM_data1, RLang);
1163 DICompositeType ContainingType = CTy.getContainingType();
1164 if (DIDescriptor(ContainingType).isCompositeType())
1165 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1166 getOrCreateTypeDIE(DIType(ContainingType)));
1168 DIDescriptor Context = CTy.getContext();
1169 addToContextOwner(&Buffer, Context);
1172 if (Tag == dwarf::DW_TAG_class_type)
1173 addTemplateParams(Buffer, CTy.getTemplateParams());
1181 // Add name if not anonymous or intermediate type.
1183 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1185 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1186 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1188 // Add size if non-zero (derived types might be zero-sized.)
1190 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1192 // Add zero size if it is not a forward declaration.
1193 if (CTy.isForwardDecl())
1194 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1196 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1199 // Add source line info if available.
1200 if (!CTy.isForwardDecl())
1201 addSourceLine(&Buffer, CTy);
1205 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1206 /// for the given DITemplateTypeParameter.
1208 DwarfDebug::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1209 CompileUnit *TypeCU = getCompileUnit(TP);
1210 DIE *ParamDIE = TypeCU->getDIE(TP);
1214 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1215 addType(ParamDIE, TP.getType());
1216 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
1220 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1221 /// for the given DITemplateValueParameter.
1223 DwarfDebug::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
1224 CompileUnit *TVCU = getCompileUnit(TPV);
1225 DIE *ParamDIE = TVCU->getDIE(TPV);
1229 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
1230 addType(ParamDIE, TPV.getType());
1231 if (!TPV.getName().empty())
1232 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
1233 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1238 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1239 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1240 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1241 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1242 int64_t L = SR.getLo();
1243 int64_t H = SR.getHi();
1245 // The L value defines the lower bounds typically zero for C/C++. The H
1246 // value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1247 // of the array. If L > H the array will be unbounded. If the L is
1248 // non zero and same is H then also the array will be unbounded. If L is
1249 // zero and H is zero then the array has one element and in such case do
1250 // not emit lower bound.
1252 if (L > H || (L == H && L != 0)) {
1253 // This is an unbounded subrange.
1254 Buffer.addChild(DW_Subrange);
1259 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1260 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1261 Buffer.addChild(DW_Subrange);
1264 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1265 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1266 DICompositeType *CTy) {
1267 Buffer.setTag(dwarf::DW_TAG_array_type);
1268 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1269 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1271 // Emit derived type.
1272 addType(&Buffer, CTy->getTypeDerivedFrom());
1273 DIArray Elements = CTy->getTypeArray();
1275 // Get an anonymous type for index type.
1276 CompileUnit *TheCU = getCompileUnit(*CTy);
1277 DIE *IdxTy = TheCU->getIndexTyDie();
1279 // Construct an anonymous type for index type.
1280 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1281 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1282 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1283 dwarf::DW_ATE_signed);
1284 TheCU->addDie(IdxTy);
1285 TheCU->setIndexTyDie(IdxTy);
1288 // Add subranges to array type.
1289 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1290 DIDescriptor Element = Elements.getElement(i);
1291 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1292 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1296 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1297 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1298 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1299 StringRef Name = ETy.getName();
1300 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1301 int64_t Value = ETy.getEnumValue();
1302 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1306 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1307 /// printer to not emit usual symbol prefix before the symbol name is used then
1308 /// return linkage name after skipping this special LLVM prefix.
1309 static StringRef getRealLinkageName(StringRef LinkageName) {
1311 if (LinkageName.startswith(StringRef(&One, 1)))
1312 return LinkageName.substr(1);
1316 /// createMemberDIE - Create new member DIE.
1317 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1318 DIE *MemberDie = new DIE(DT.getTag());
1319 StringRef Name = DT.getName();
1321 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1323 addType(MemberDie, DT.getTypeDerivedFrom());
1325 addSourceLine(MemberDie, DT);
1327 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1328 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1330 uint64_t Size = DT.getSizeInBits();
1331 uint64_t FieldSize = DT.getOriginalTypeSize();
1333 if (Size != FieldSize) {
1335 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1336 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1338 uint64_t Offset = DT.getOffsetInBits();
1339 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1340 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1341 uint64_t FieldOffset = (HiMark - FieldSize);
1342 Offset -= FieldOffset;
1344 // Maybe we need to work from the other end.
1345 if (Asm->getTargetData().isLittleEndian())
1346 Offset = FieldSize - (Offset + Size);
1347 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1349 // Here WD_AT_data_member_location points to the anonymous
1350 // field that includes this bit field.
1351 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1354 // This is not a bitfield.
1355 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1357 if (DT.getTag() == dwarf::DW_TAG_inheritance
1358 && DT.isVirtual()) {
1360 // For C++, virtual base classes are not at fixed offset. Use following
1361 // expression to extract appropriate offset from vtable.
1362 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1364 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1365 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1366 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1367 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1368 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1369 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1370 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1371 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1373 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1376 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1378 if (DT.isProtected())
1379 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1380 dwarf::DW_ACCESS_protected);
1381 else if (DT.isPrivate())
1382 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1383 dwarf::DW_ACCESS_private);
1384 // Otherwise C++ member and base classes are considered public.
1385 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1386 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1387 dwarf::DW_ACCESS_public);
1389 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1390 dwarf::DW_VIRTUALITY_virtual);
1394 /// createSubprogramDIE - Create new DIE using SP.
1395 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
1396 CompileUnit *SPCU = getCompileUnit(SP);
1397 DIE *SPDie = SPCU->getDIE(SP);
1401 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1402 // Constructors and operators for anonymous aggregates do not have names.
1403 if (!SP.getName().empty())
1404 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1406 StringRef LinkageName = SP.getLinkageName();
1407 if (!LinkageName.empty())
1408 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1409 getRealLinkageName(LinkageName));
1411 addSourceLine(SPDie, SP);
1413 if (SP.isPrototyped())
1414 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1417 DICompositeType SPTy = SP.getType();
1418 DIArray Args = SPTy.getTypeArray();
1419 unsigned SPTag = SPTy.getTag();
1421 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1422 addType(SPDie, SPTy);
1424 addType(SPDie, DIType(Args.getElement(0)));
1426 unsigned VK = SP.getVirtuality();
1428 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1429 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1430 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1431 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1432 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1433 ContainingTypeMap.insert(std::make_pair(SPDie,
1434 SP.getContainingType()));
1437 if (!SP.isDefinition()) {
1438 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1440 // Add arguments. Do not add arguments for subprogram definition. They will
1441 // be handled while processing variables.
1442 DICompositeType SPTy = SP.getType();
1443 DIArray Args = SPTy.getTypeArray();
1444 unsigned SPTag = SPTy.getTag();
1446 if (SPTag == dwarf::DW_TAG_subroutine_type)
1447 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1448 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1449 DIType ATy = DIType(DIType(Args.getElement(i)));
1451 if (ATy.isArtificial())
1452 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1453 SPDie->addChild(Arg);
1457 if (SP.isArtificial())
1458 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1460 if (!SP.isLocalToUnit())
1461 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1463 if (SP.isOptimized())
1464 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1466 if (unsigned isa = Asm->getISAEncoding()) {
1467 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1470 // Add function template parameters.
1471 addTemplateParams(*SPDie, SP.getTemplateParams());
1473 // DW_TAG_inlined_subroutine may refer to this DIE.
1474 SPCU->insertDIE(SP, SPDie);
1476 // Add to context owner.
1477 addToContextOwner(SPDie, SP.getContext());
1482 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1483 assert(N && "Invalid Scope encoding!");
1485 DbgScope *AScope = AbstractScopes.lookup(N);
1489 DbgScope *Parent = NULL;
1491 DIDescriptor Scope(N);
1492 if (Scope.isLexicalBlock()) {
1493 DILexicalBlock DB(N);
1494 DIDescriptor ParentDesc = DB.getContext();
1495 Parent = getOrCreateAbstractScope(ParentDesc);
1498 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1501 Parent->addScope(AScope);
1502 AScope->setAbstractScope();
1503 AbstractScopes[N] = AScope;
1504 if (DIDescriptor(N).isSubprogram())
1505 AbstractScopesList.push_back(AScope);
1509 /// isSubprogramContext - Return true if Context is either a subprogram
1510 /// or another context nested inside a subprogram.
1511 static bool isSubprogramContext(const MDNode *Context) {
1514 DIDescriptor D(Context);
1515 if (D.isSubprogram())
1518 return isSubprogramContext(DIType(Context).getContext());
1522 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1523 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1524 /// If there are global variables in this scope then create and insert
1525 /// DIEs for these variables.
1526 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1527 CompileUnit *SPCU = getCompileUnit(SPNode);
1528 DIE *SPDie = SPCU->getDIE(SPNode);
1530 assert(SPDie && "Unable to find subprogram DIE!");
1531 DISubprogram SP(SPNode);
1533 // There is not any need to generate specification DIE for a function
1534 // defined at compile unit level. If a function is defined inside another
1535 // function then gdb prefers the definition at top level and but does not
1536 // expect specification DIE in parent function. So avoid creating
1537 // specification DIE for a function defined inside a function.
1538 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1539 !SP.getContext().isFile() &&
1540 !isSubprogramContext(SP.getContext())) {
1541 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1544 DICompositeType SPTy = SP.getType();
1545 DIArray Args = SPTy.getTypeArray();
1546 unsigned SPTag = SPTy.getTag();
1547 if (SPTag == dwarf::DW_TAG_subroutine_type)
1548 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1549 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1550 DIType ATy = DIType(DIType(Args.getElement(i)));
1552 if (ATy.isArtificial())
1553 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1554 SPDie->addChild(Arg);
1556 DIE *SPDeclDie = SPDie;
1557 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1558 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1560 SPCU->addDie(SPDie);
1563 // Pick up abstract subprogram DIE.
1564 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1565 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1566 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1567 dwarf::DW_FORM_ref4, AbsSPDIE);
1568 SPCU->addDie(SPDie);
1571 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1572 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1573 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1574 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1575 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1576 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1577 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1582 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1583 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1584 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1586 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1587 if (Scope->isAbstractScope())
1590 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1594 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1595 if (Ranges.size() > 1) {
1596 // .debug_range section has not been laid out yet. Emit offset in
1597 // .debug_range as a uint, size 4, for now. emitDIE will handle
1598 // DW_AT_ranges appropriately.
1599 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1600 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1601 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1602 RE = Ranges.end(); RI != RE; ++RI) {
1603 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1604 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1606 DebugRangeSymbols.push_back(NULL);
1607 DebugRangeSymbols.push_back(NULL);
1611 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1612 const MCSymbol *End = getLabelAfterInsn(RI->second);
1614 if (End == 0) return 0;
1616 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1617 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1619 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1620 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1625 /// constructInlinedScopeDIE - This scope represents inlined body of
1626 /// a function. Construct DIE to represent this concrete inlined copy
1627 /// of the function.
1628 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1630 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1631 assert (Ranges.empty() == false
1632 && "DbgScope does not have instruction markers!");
1634 // FIXME : .debug_inlined section specification does not clearly state how
1635 // to emit inlined scope that is split into multiple instruction ranges.
1636 // For now, use first instruction range and emit low_pc/high_pc pair and
1637 // corresponding .debug_inlined section entry for this pair.
1638 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1639 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1640 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1642 if (StartLabel == 0 || EndLabel == 0) {
1643 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1646 assert(StartLabel->isDefined() &&
1647 "Invalid starting label for an inlined scope!");
1648 assert(EndLabel->isDefined() &&
1649 "Invalid end label for an inlined scope!");
1651 if (!Scope->getScopeNode())
1653 DIScope DS(Scope->getScopeNode());
1654 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1656 DISubprogram InlinedSP = getDISubprogram(DS);
1657 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1658 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1659 assert(OriginDIE && "Unable to find Origin DIE!");
1660 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1661 dwarf::DW_FORM_ref4, OriginDIE);
1663 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1664 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1666 InlinedSubprogramDIEs.insert(OriginDIE);
1668 // Track the start label for this inlined function.
1669 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1670 I = InlineInfo.find(InlinedSP);
1672 if (I == InlineInfo.end()) {
1673 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1675 InlinedSPNodes.push_back(InlinedSP);
1677 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1679 DILocation DL(Scope->getInlinedAt());
1680 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1681 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1687 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1688 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1689 StringRef Name = DV->getName();
1693 // Translate tag to proper Dwarf tag. The result variable is dropped for
1696 switch (DV->getTag()) {
1697 case dwarf::DW_TAG_return_variable:
1699 case dwarf::DW_TAG_arg_variable:
1700 Tag = dwarf::DW_TAG_formal_parameter;
1702 case dwarf::DW_TAG_auto_variable: // fall thru
1704 Tag = dwarf::DW_TAG_variable;
1708 // Define variable debug information entry.
1709 DIE *VariableDie = new DIE(Tag);
1712 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1713 V2AVI = VarToAbstractVarMap.find(DV);
1714 if (V2AVI != VarToAbstractVarMap.end())
1715 AbsDIE = V2AVI->second->getDIE();
1718 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1719 dwarf::DW_FORM_ref4, AbsDIE);
1721 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1722 addSourceLine(VariableDie, DV->getVariable());
1724 // Add variable type.
1725 addType(VariableDie, DV->getType());
1728 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1729 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1730 else if (DIVariable(DV->getVariable()).isArtificial())
1731 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1733 if (Scope->isAbstractScope()) {
1734 DV->setDIE(VariableDie);
1738 // Add variable address.
1740 unsigned Offset = DV->getDotDebugLocOffset();
1741 if (Offset != ~0U) {
1742 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1743 Asm->GetTempSymbol("debug_loc", Offset));
1744 DV->setDIE(VariableDie);
1745 UseDotDebugLocEntry.insert(VariableDie);
1749 // Check if variable is described by a DBG_VALUE instruction.
1750 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1751 DbgVariableToDbgInstMap.find(DV);
1752 if (DVI != DbgVariableToDbgInstMap.end()) {
1753 const MachineInstr *DVInsn = DVI->second;
1754 bool updated = false;
1755 // FIXME : Handle getNumOperands != 3
1756 if (DVInsn->getNumOperands() == 3) {
1757 if (DVInsn->getOperand(0).isReg()) {
1758 const MachineOperand RegOp = DVInsn->getOperand(0);
1759 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1760 if (DVInsn->getOperand(1).isImm() &&
1761 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1762 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1765 updated = addRegisterAddress(VariableDie, RegOp);
1767 else if (DVInsn->getOperand(0).isImm())
1768 updated = addConstantValue(VariableDie, DVInsn->getOperand(0));
1769 else if (DVInsn->getOperand(0).isFPImm())
1771 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1773 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1774 if (Location.getReg()) {
1775 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1780 // If variableDie is not updated then DBG_VALUE instruction does not
1781 // have valid variable info.
1785 DV->setDIE(VariableDie);
1789 // .. else use frame index, if available.
1791 if (findVariableFrameIndex(DV, &FI))
1792 addVariableAddress(DV, VariableDie, FI);
1794 DV->setDIE(VariableDie);
1799 void DwarfDebug::addPubTypes(DISubprogram SP) {
1800 DICompositeType SPTy = SP.getType();
1801 unsigned SPTag = SPTy.getTag();
1802 if (SPTag != dwarf::DW_TAG_subroutine_type)
1805 DIArray Args = SPTy.getTypeArray();
1806 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1807 DIType ATy(Args.getElement(i));
1810 DICompositeType CATy = getDICompositeType(ATy);
1811 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1812 && !CATy.isForwardDecl()) {
1813 CompileUnit *TheCU = getCompileUnit(CATy);
1814 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1815 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1820 /// constructScopeDIE - Construct a DIE for this scope.
1821 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1822 if (!Scope || !Scope->getScopeNode())
1825 SmallVector <DIE *, 8> Children;
1827 // Collect arguments for current function.
1828 if (Scope == CurrentFnDbgScope)
1829 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
1830 if (DbgVariable *ArgDV = CurrentFnArguments[i])
1831 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
1832 Children.push_back(Arg);
1834 // Collect lexical scope childrens first.
1835 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1836 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
1837 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
1838 Children.push_back(Variable);
1839 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1840 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
1841 if (DIE *Nested = constructScopeDIE(Scopes[j]))
1842 Children.push_back(Nested);
1843 DIScope DS(Scope->getScopeNode());
1844 DIE *ScopeDIE = NULL;
1845 if (Scope->getInlinedAt())
1846 ScopeDIE = constructInlinedScopeDIE(Scope);
1847 else if (DS.isSubprogram()) {
1848 ProcessedSPNodes.insert(DS);
1849 if (Scope->isAbstractScope()) {
1850 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1851 // Note down abstract DIE.
1853 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1856 ScopeDIE = updateSubprogramScopeDIE(DS);
1859 // There is no need to emit empty lexical block DIE.
1860 if (Children.empty())
1862 ScopeDIE = constructLexicalScopeDIE(Scope);
1865 if (!ScopeDIE) return NULL;
1868 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
1869 E = Children.end(); I != E; ++I)
1870 ScopeDIE->addChild(*I);
1872 if (DS.isSubprogram())
1873 addPubTypes(DISubprogram(DS));
1878 /// GetOrCreateSourceID - Look up the source id with the given directory and
1879 /// source file names. If none currently exists, create a new id and insert it
1880 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1883 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
1884 StringRef DirName) {
1885 // If FE did not provide a file name, then assume stdin.
1886 if (FileName.empty())
1887 return GetOrCreateSourceID("<stdin>", StringRef());
1889 // MCStream expects full path name as filename.
1890 if (!DirName.empty() && !FileName.startswith("/")) {
1891 std::string FullPathName(DirName.data());
1892 if (!DirName.endswith("/"))
1893 FullPathName += "/";
1894 FullPathName += FileName.data();
1895 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
1896 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
1899 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
1900 if (Entry.getValue())
1901 return Entry.getValue();
1903 unsigned SrcId = SourceIdMap.size();
1904 Entry.setValue(SrcId);
1906 // Print out a .file directive to specify files for .loc directives.
1907 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
1912 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1913 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1914 CompileUnit *TheCU = getCompileUnit(NS);
1915 DIE *NDie = TheCU->getDIE(NS);
1918 NDie = new DIE(dwarf::DW_TAG_namespace);
1919 TheCU->insertDIE(NS, NDie);
1920 if (!NS.getName().empty())
1921 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1922 addSourceLine(NDie, NS);
1923 addToContextOwner(NDie, NS.getContext());
1927 /// constructCompileUnit - Create new CompileUnit for the given
1928 /// metadata node with tag DW_TAG_compile_unit.
1929 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1930 DICompileUnit DIUnit(N);
1931 StringRef FN = DIUnit.getFilename();
1932 StringRef Dir = DIUnit.getDirectory();
1933 unsigned ID = GetOrCreateSourceID(FN, Dir);
1935 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1936 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1937 DIUnit.getProducer());
1938 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1939 DIUnit.getLanguage());
1940 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1941 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1942 // simplifies debug range entries.
1943 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1944 // DW_AT_stmt_list is a offset of line number information for this
1945 // compile unit in debug_line section.
1946 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1947 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1948 Asm->GetTempSymbol("section_line"));
1950 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1953 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1954 if (DIUnit.isOptimized())
1955 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1957 StringRef Flags = DIUnit.getFlags();
1959 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1961 unsigned RVer = DIUnit.getRunTimeVersion();
1963 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1964 dwarf::DW_FORM_data1, RVer);
1966 CompileUnit *NewCU = new CompileUnit(ID, Die);
1969 CUMap.insert(std::make_pair(N, NewCU));
1972 /// getCompielUnit - Get CompileUnit DIE.
1973 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1974 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1976 const MDNode *CUNode = NULL;
1977 if (D.isCompileUnit())
1979 else if (D.isSubprogram())
1980 CUNode = DISubprogram(N).getCompileUnit();
1981 else if (D.isType())
1982 CUNode = DIType(N).getCompileUnit();
1983 else if (D.isGlobalVariable())
1984 CUNode = DIGlobalVariable(N).getCompileUnit();
1985 else if (D.isVariable())
1986 CUNode = DIVariable(N).getCompileUnit();
1987 else if (D.isNameSpace())
1988 CUNode = DINameSpace(N).getCompileUnit();
1989 else if (D.isFile())
1990 CUNode = DIFile(N).getCompileUnit();
1994 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1995 = CUMap.find(CUNode);
1996 if (I == CUMap.end())
2001 /// isUnsignedDIType - Return true if type encoding is unsigned.
2002 static bool isUnsignedDIType(DIType Ty) {
2003 DIDerivedType DTy(Ty);
2005 return isUnsignedDIType(DTy.getTypeDerivedFrom());
2007 DIBasicType BTy(Ty);
2009 unsigned Encoding = BTy.getEncoding();
2010 if (Encoding == dwarf::DW_ATE_unsigned ||
2011 Encoding == dwarf::DW_ATE_unsigned_char)
2017 // Return const exprssion if value is a GEP to access merged global
2019 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
2020 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
2021 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
2022 if (!CE || CE->getNumOperands() != 3 ||
2023 CE->getOpcode() != Instruction::GetElementPtr)
2026 // First operand points to a global value.
2027 if (!isa<GlobalValue>(CE->getOperand(0)))
2030 // Second operand is zero.
2031 const ConstantInt *CI =
2032 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
2033 if (!CI || !CI->isZero())
2036 // Third operand is offset.
2037 if (!isa<ConstantInt>(CE->getOperand(2)))
2043 /// constructGlobalVariableDIE - Construct global variable DIE.
2044 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
2045 DIGlobalVariable GV(N);
2047 // If debug information is malformed then ignore it.
2048 if (GV.Verify() == false)
2051 // Check for pre-existence.
2052 CompileUnit *TheCU = getCompileUnit(N);
2053 if (TheCU->getDIE(GV))
2056 DIType GTy = GV.getType();
2057 DIE *VariableDIE = new DIE(GV.getTag());
2059 bool isGlobalVariable = GV.getGlobal() != NULL;
2062 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
2063 GV.getDisplayName());
2064 StringRef LinkageName = GV.getLinkageName();
2065 if (!LinkageName.empty() && isGlobalVariable)
2066 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
2067 getRealLinkageName(LinkageName));
2069 addType(VariableDIE, GTy);
2070 if (GTy.isCompositeType() && !GTy.getName().empty()
2071 && !GTy.isForwardDecl()) {
2072 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
2073 assert(Entry && "Missing global type!");
2074 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
2076 // Add scoping info.
2077 if (!GV.isLocalToUnit()) {
2078 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
2079 // Expose as global.
2080 TheCU->addGlobal(GV.getName(), VariableDIE);
2082 // Add line number info.
2083 addSourceLine(VariableDIE, GV);
2085 TheCU->insertDIE(N, VariableDIE);
2086 // Add to context owner.
2087 DIDescriptor GVContext = GV.getContext();
2088 addToContextOwner(VariableDIE, GVContext);
2090 if (isGlobalVariable) {
2091 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2092 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2093 addLabel(Block, 0, dwarf::DW_FORM_udata,
2094 Asm->Mang->getSymbol(GV.getGlobal()));
2095 // Do not create specification DIE if context is either compile unit
2097 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
2098 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
2099 // Create specification DIE.
2100 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
2101 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
2102 dwarf::DW_FORM_ref4, VariableDIE);
2103 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
2104 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
2105 TheCU->addDie(VariableSpecDIE);
2107 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2109 } else if (ConstantInt *CI =
2110 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
2111 addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
2112 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
2113 // GV is a merged global.
2114 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2115 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2116 addLabel(Block, 0, dwarf::DW_FORM_udata,
2117 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
2118 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
2119 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
2120 addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
2121 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
2122 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2128 /// construct SubprogramDIE - Construct subprogram DIE.
2129 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2132 // Check for pre-existence.
2133 CompileUnit *TheCU = getCompileUnit(N);
2134 if (TheCU->getDIE(N))
2137 if (!SP.isDefinition())
2138 // This is a method declaration which will be handled while constructing
2142 DIE *SubprogramDie = createSubprogramDIE(SP);
2145 TheCU->insertDIE(N, SubprogramDie);
2147 // Add to context owner.
2148 addToContextOwner(SubprogramDie, SP.getContext());
2150 // Expose as global.
2151 TheCU->addGlobal(SP.getName(), SubprogramDie);
2156 /// beginModule - Emit all Dwarf sections that should come prior to the
2157 /// content. Create global DIEs and emit initial debug info sections.
2158 /// This is inovked by the target AsmPrinter.
2159 void DwarfDebug::beginModule(Module *M) {
2160 if (DisableDebugInfoPrinting)
2163 DebugInfoFinder DbgFinder;
2164 DbgFinder.processModule(*M);
2166 bool HasDebugInfo = false;
2168 // Scan all the compile-units to see if there are any marked as the main unit.
2169 // if not, we do not generate debug info.
2170 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2171 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2172 if (DICompileUnit(*I).isMain()) {
2173 HasDebugInfo = true;
2178 if (!HasDebugInfo) return;
2180 // Tell MMI that we have debug info.
2181 MMI->setDebugInfoAvailability(true);
2183 // Emit initial sections.
2184 EmitSectionLabels();
2186 // Create all the compile unit DIEs.
2187 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2188 E = DbgFinder.compile_unit_end(); I != E; ++I)
2189 constructCompileUnit(*I);
2191 // Create DIEs for each subprogram.
2192 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2193 E = DbgFinder.subprogram_end(); I != E; ++I)
2194 constructSubprogramDIE(*I);
2196 // Create DIEs for each global variable.
2197 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2198 E = DbgFinder.global_variable_end(); I != E; ++I)
2199 constructGlobalVariableDIE(*I);
2201 //getOrCreateTypeDIE
2202 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2203 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2204 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2206 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2207 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2208 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2210 // Prime section data.
2211 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2214 /// endModule - Emit all Dwarf sections that should come after the content.
2216 void DwarfDebug::endModule() {
2217 if (!FirstCU) return;
2218 const Module *M = MMI->getModule();
2219 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2220 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2221 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2222 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2223 DISubprogram SP(AllSPs->getOperand(SI));
2224 if (!SP.Verify()) continue;
2226 // Collect info for variables that were optimized out.
2227 if (!SP.isDefinition()) continue;
2228 StringRef FName = SP.getLinkageName();
2230 FName = SP.getName();
2231 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
2233 unsigned E = NMD->getNumOperands();
2235 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2236 DeadFnScopeMap[SP] = Scope;
2237 for (unsigned I = 0; I != E; ++I) {
2238 DIVariable DV(NMD->getOperand(I));
2239 if (!DV.Verify()) continue;
2240 Scope->addVariable(new DbgVariable(DV));
2243 // Construct subprogram DIE and add variables DIEs.
2244 constructSubprogramDIE(SP);
2245 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2246 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2247 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2248 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2250 ScopeDIE->addChild(VariableDIE);
2255 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2256 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2257 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2259 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2262 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2263 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2264 DIE *SPDie = CI->first;
2265 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2267 DIE *NDie = getCompileUnit(N)->getDIE(N);
2268 if (!NDie) continue;
2269 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2272 // Standard sections final addresses.
2273 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2274 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2275 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2276 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2278 // End text sections.
2279 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2280 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2281 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2284 // Emit common frame information.
2285 emitCommonDebugFrame();
2287 // Emit function debug frame information
2288 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2289 E = DebugFrames.end(); I != E; ++I)
2290 emitFunctionDebugFrame(*I);
2292 // Compute DIE offsets and sizes.
2293 computeSizeAndOffsets();
2295 // Emit all the DIEs into a debug info section
2298 // Corresponding abbreviations into a abbrev section.
2299 emitAbbreviations();
2301 // Emit info into a debug pubnames section.
2302 emitDebugPubNames();
2304 // Emit info into a debug pubtypes section.
2305 emitDebugPubTypes();
2307 // Emit info into a debug loc section.
2310 // Emit info into a debug aranges section.
2313 // Emit info into a debug ranges section.
2316 // Emit info into a debug macinfo section.
2319 // Emit inline info.
2320 emitDebugInlineInfo();
2322 // Emit info into a debug str section.
2326 DeleteContainerSeconds(DeadFnScopeMap);
2327 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2328 E = CUMap.end(); I != E; ++I)
2330 FirstCU = NULL; // Reset for the next Module, if any.
2333 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2334 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2335 DebugLoc ScopeLoc) {
2337 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2339 return AbsDbgVariable;
2341 LLVMContext &Ctx = Var->getContext();
2342 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2346 AbsDbgVariable = new DbgVariable(Var);
2347 Scope->addVariable(AbsDbgVariable);
2348 AbstractVariables[Var] = AbsDbgVariable;
2349 return AbsDbgVariable;
2352 /// addCurrentFnArgument - If Var is an current function argument that add
2353 /// it in CurrentFnArguments list.
2354 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
2355 DbgVariable *Var, DbgScope *Scope) {
2356 if (Scope != CurrentFnDbgScope)
2358 DIVariable DV = Var->getVariable();
2359 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2361 unsigned ArgNo = DV.getArgNumber();
2365 size_t Size = CurrentFnArguments.size();
2367 CurrentFnArguments.resize(MF->getFunction()->arg_size());
2368 // llvm::Function argument size is not good indicator of how many
2369 // arguments does the function have at source level.
2371 CurrentFnArguments.resize(ArgNo * 2);
2372 CurrentFnArguments[ArgNo - 1] = Var;
2376 /// collectVariableInfoFromMMITable - Collect variable information from
2377 /// side table maintained by MMI.
2379 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2380 SmallPtrSet<const MDNode *, 16> &Processed) {
2381 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2382 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2383 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2384 VE = VMap.end(); VI != VE; ++VI) {
2385 const MDNode *Var = VI->first;
2387 Processed.insert(Var);
2389 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2391 DbgScope *Scope = 0;
2392 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2393 Scope = ConcreteScopes.lookup(IA);
2395 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2397 // If variable scope is not found then skip this variable.
2401 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2402 DbgVariable *RegVar = new DbgVariable(DV);
2403 recordVariableFrameIndex(RegVar, VP.first);
2404 if (!addCurrentFnArgument(MF, RegVar, Scope))
2405 Scope->addVariable(RegVar);
2406 if (AbsDbgVariable) {
2407 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2408 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2413 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2414 /// DBG_VALUE instruction, is in a defined reg.
2415 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2416 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2417 return MI->getNumOperands() == 3 &&
2418 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
2419 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
2422 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2424 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2425 SmallPtrSet<const MDNode *, 16> &Processed) {
2427 /// collection info from MMI table.
2428 collectVariableInfoFromMMITable(MF, Processed);
2430 for (SmallVectorImpl<const MDNode*>::const_iterator
2431 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
2433 const MDNode *Var = *UVI;
2434 if (Processed.count(Var))
2437 // History contains relevant DBG_VALUE instructions for Var and instructions
2439 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
2440 if (History.empty())
2442 const MachineInstr *MInsn = History.front();
2445 DbgScope *Scope = NULL;
2446 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2447 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2448 Scope = CurrentFnDbgScope;
2450 Scope = findDbgScope(MInsn);
2451 // If variable scope is not found then skip this variable.
2455 Processed.insert(DV);
2456 assert(MInsn->isDebugValue() && "History must begin with debug value");
2457 DbgVariable *RegVar = new DbgVariable(DV);
2458 if (!addCurrentFnArgument(MF, RegVar, Scope))
2459 Scope->addVariable(RegVar);
2460 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2461 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2462 VarToAbstractVarMap[RegVar] = AbsVar;
2465 // Simple ranges that are fully coalesced.
2466 if (History.size() <= 1 || (History.size() == 2 &&
2467 MInsn->isIdenticalTo(History.back()))) {
2468 DbgVariableToDbgInstMap[RegVar] = MInsn;
2472 // handle multiple DBG_VALUE instructions describing one variable.
2473 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2475 for (SmallVectorImpl<const MachineInstr*>::const_iterator
2476 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
2477 const MachineInstr *Begin = *HI;
2478 assert(Begin->isDebugValue() && "Invalid History entry");
2479 MachineLocation MLoc;
2480 if (Begin->getNumOperands() == 3) {
2481 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2482 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2484 MLoc = Asm->getDebugValueLocation(Begin);
2486 // FIXME: emitDebugLoc only understands registers.
2490 // Compute the range for a register location.
2491 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2492 const MCSymbol *SLabel = 0;
2495 // If Begin is the last instruction in History then its value is valid
2496 // until the end of the funtion.
2497 SLabel = FunctionEndSym;
2499 const MachineInstr *End = HI[1];
2500 if (End->isDebugValue())
2501 SLabel = getLabelBeforeInsn(End);
2503 // End is a normal instruction clobbering the range.
2504 SLabel = getLabelAfterInsn(End);
2505 assert(SLabel && "Forgot label after clobber instruction");
2510 // The value is valid until the next DBG_VALUE or clobber.
2511 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2513 DotDebugLocEntries.push_back(DotDebugLocEntry());
2516 // Collect info for variables that were optimized out.
2517 const Function *F = MF->getFunction();
2518 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
2519 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2520 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2521 if (!DV || !Processed.insert(DV))
2523 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2525 Scope->addVariable(new DbgVariable(DV));
2530 /// getLabelBeforeInsn - Return Label preceding the instruction.
2531 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2532 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
2533 assert(Label && "Didn't insert label before instruction");
2537 /// getLabelAfterInsn - Return Label immediately following the instruction.
2538 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2539 return LabelsAfterInsn.lookup(MI);
2542 /// beginInstruction - Process beginning of an instruction.
2543 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
2544 // Check if source location changes, but ignore DBG_VALUE locations.
2545 if (!MI->isDebugValue()) {
2546 DebugLoc DL = MI->getDebugLoc();
2547 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
2549 if (!DL.isUnknown()) {
2550 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2551 recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2553 recordSourceLine(0, 0, 0);
2557 // Insert labels where requested.
2558 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
2559 LabelsBeforeInsn.find(MI);
2562 if (I == LabelsBeforeInsn.end())
2565 // Label already assigned.
2570 PrevLabel = MMI->getContext().CreateTempSymbol();
2571 Asm->OutStreamer.EmitLabel(PrevLabel);
2573 I->second = PrevLabel;
2576 /// endInstruction - Process end of an instruction.
2577 void DwarfDebug::endInstruction(const MachineInstr *MI) {
2578 // Don't create a new label after DBG_VALUE instructions.
2579 // They don't generate code.
2580 if (!MI->isDebugValue())
2583 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
2584 LabelsAfterInsn.find(MI);
2587 if (I == LabelsAfterInsn.end())
2590 // Label already assigned.
2594 // We need a label after this instruction.
2596 PrevLabel = MMI->getContext().CreateTempSymbol();
2597 Asm->OutStreamer.EmitLabel(PrevLabel);
2599 I->second = PrevLabel;
2602 /// getOrCreateDbgScope - Create DbgScope for the scope.
2603 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2604 const MDNode *InlinedAt) {
2606 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2609 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2610 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2611 if (DIDescriptor(Scope).isLexicalBlock()) {
2613 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2614 WScope->setParent(Parent);
2615 Parent->addScope(WScope);
2618 if (!WScope->getParent()) {
2619 StringRef SPName = DISubprogram(Scope).getLinkageName();
2620 // We used to check only for a linkage name, but that fails
2621 // since we began omitting the linkage name for private
2622 // functions. The new way is to check for the name in metadata,
2623 // but that's not supported in old .ll test cases. Ergo, we
2625 if (SPName == Asm->MF->getFunction()->getName() ||
2626 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2627 CurrentFnDbgScope = WScope;
2633 getOrCreateAbstractScope(Scope);
2634 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2638 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2639 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2640 DILocation DL(InlinedAt);
2642 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2643 WScope->setParent(Parent);
2644 Parent->addScope(WScope);
2646 ConcreteScopes[InlinedAt] = WScope;
2651 /// hasValidLocation - Return true if debug location entry attached with
2652 /// machine instruction encodes valid location info.
2653 static bool hasValidLocation(LLVMContext &Ctx,
2654 const MachineInstr *MInsn,
2655 const MDNode *&Scope, const MDNode *&InlinedAt) {
2656 DebugLoc DL = MInsn->getDebugLoc();
2657 if (DL.isUnknown()) return false;
2659 const MDNode *S = DL.getScope(Ctx);
2661 // There is no need to create another DIE for compile unit. For all
2662 // other scopes, create one DbgScope now. This will be translated
2663 // into a scope DIE at the end.
2664 if (DIScope(S).isCompileUnit()) return false;
2667 InlinedAt = DL.getInlinedAt(Ctx);
2671 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2673 static void calculateDominanceGraph(DbgScope *Scope) {
2674 assert (Scope && "Unable to calculate scop edominance graph!");
2675 SmallVector<DbgScope *, 4> WorkStack;
2676 WorkStack.push_back(Scope);
2677 unsigned Counter = 0;
2678 while (!WorkStack.empty()) {
2679 DbgScope *WS = WorkStack.back();
2680 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2681 bool visitedChildren = false;
2682 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2683 SE = Children.end(); SI != SE; ++SI) {
2684 DbgScope *ChildScope = *SI;
2685 if (!ChildScope->getDFSOut()) {
2686 WorkStack.push_back(ChildScope);
2687 visitedChildren = true;
2688 ChildScope->setDFSIn(++Counter);
2692 if (!visitedChildren) {
2693 WorkStack.pop_back();
2694 WS->setDFSOut(++Counter);
2699 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2701 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2702 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2705 unsigned PrevDFSIn = 0;
2706 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2708 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2710 const MachineInstr *MInsn = II;
2711 const MDNode *Scope = NULL;
2712 const MDNode *InlinedAt = NULL;
2714 // Check if instruction has valid location information.
2715 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2719 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2720 MI2ScopeMap.find(MInsn);
2721 if (DI != MI2ScopeMap.end()) {
2722 DbgScope *S = DI->second;
2723 dbgs() << S->getDFSIn();
2724 PrevDFSIn = S->getDFSIn();
2726 dbgs() << PrevDFSIn;
2728 dbgs() << " [ x" << PrevDFSIn;
2736 /// extractScopeInformation - Scan machine instructions in this function
2737 /// and collect DbgScopes. Return true, if at least one scope was found.
2738 bool DwarfDebug::extractScopeInformation() {
2739 // If scope information was extracted using .dbg intrinsics then there is not
2740 // any need to extract these information by scanning each instruction.
2741 if (!DbgScopeMap.empty())
2744 // Scan each instruction and create scopes. First build working set of scopes.
2745 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2746 SmallVector<DbgRange, 4> MIRanges;
2747 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2748 const MDNode *PrevScope = NULL;
2749 const MDNode *PrevInlinedAt = NULL;
2750 const MachineInstr *RangeBeginMI = NULL;
2751 const MachineInstr *PrevMI = NULL;
2752 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2754 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2756 const MachineInstr *MInsn = II;
2757 const MDNode *Scope = NULL;
2758 const MDNode *InlinedAt = NULL;
2760 // Check if instruction has valid location information.
2761 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2766 // If scope has not changed then skip this instruction.
2767 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2772 // Ignore DBG_VALUE. It does not contribute any instruction in output.
2773 if (MInsn->isDebugValue())
2777 // If we have alread seen a beginning of a instruction range and
2778 // current instruction scope does not match scope of first instruction
2779 // in this range then create a new instruction range.
2780 DbgRange R(RangeBeginMI, PrevMI);
2781 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2783 MIRanges.push_back(R);
2786 // This is a beginning of a new instruction range.
2787 RangeBeginMI = MInsn;
2789 // Reset previous markers.
2792 PrevInlinedAt = InlinedAt;
2796 // Create last instruction range.
2797 if (RangeBeginMI && PrevMI && PrevScope) {
2798 DbgRange R(RangeBeginMI, PrevMI);
2799 MIRanges.push_back(R);
2800 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2803 if (!CurrentFnDbgScope)
2806 calculateDominanceGraph(CurrentFnDbgScope);
2808 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2810 // Find ranges of instructions covered by each DbgScope;
2811 DbgScope *PrevDbgScope = NULL;
2812 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2813 RE = MIRanges.end(); RI != RE; ++RI) {
2814 const DbgRange &R = *RI;
2815 DbgScope *S = MI2ScopeMap.lookup(R.first);
2816 assert (S && "Lost DbgScope for a machine instruction!");
2817 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2818 PrevDbgScope->closeInsnRange(S);
2819 S->openInsnRange(R.first);
2820 S->extendInsnRange(R.second);
2825 PrevDbgScope->closeInsnRange();
2827 identifyScopeMarkers();
2829 return !DbgScopeMap.empty();
2832 /// identifyScopeMarkers() -
2833 /// Each DbgScope has first instruction and last instruction to mark beginning
2834 /// and end of a scope respectively. Create an inverse map that list scopes
2835 /// starts (and ends) with an instruction. One instruction may start (or end)
2836 /// multiple scopes. Ignore scopes that are not reachable.
2837 void DwarfDebug::identifyScopeMarkers() {
2838 SmallVector<DbgScope *, 4> WorkList;
2839 WorkList.push_back(CurrentFnDbgScope);
2840 while (!WorkList.empty()) {
2841 DbgScope *S = WorkList.pop_back_val();
2843 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2844 if (!Children.empty())
2845 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2846 SE = Children.end(); SI != SE; ++SI)
2847 WorkList.push_back(*SI);
2849 if (S->isAbstractScope())
2852 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2855 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2856 RE = Ranges.end(); RI != RE; ++RI) {
2857 assert(RI->first && "DbgRange does not have first instruction!");
2858 assert(RI->second && "DbgRange does not have second instruction!");
2859 requestLabelBeforeInsn(RI->first);
2860 requestLabelAfterInsn(RI->second);
2865 /// FindFirstDebugLoc - Find the first debug location in the function. This
2866 /// is intended to be an approximation for the source position of the
2867 /// beginning of the function.
2868 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2869 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2871 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2872 MBBI != MBBE; ++MBBI) {
2873 DebugLoc DL = MBBI->getDebugLoc();
2874 if (!DL.isUnknown())
2881 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2882 /// line number information.
2883 static void CheckLineNumbers(const MachineFunction *MF) {
2884 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2886 bool FoundLineNo = false;
2887 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2889 const MachineInstr *MI = II;
2890 if (!MI->getDebugLoc().isUnknown()) {
2895 if (!FoundLineNo && I->size())
2896 ++BlocksWithoutLineNo;
2901 /// beginFunction - Gather pre-function debug information. Assumes being
2902 /// emitted immediately after the function entry point.
2903 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2904 if (!MMI->hasDebugInfo()) return;
2905 if (!extractScopeInformation()) return;
2908 CheckLineNumbers(MF);
2911 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2912 Asm->getFunctionNumber());
2913 // Assumes in correct section after the entry point.
2914 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2916 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2918 DebugLoc FDL = FindFirstDebugLoc(MF);
2919 if (FDL.isUnknown()) return;
2921 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2922 const MDNode *TheScope = 0;
2924 DISubprogram SP = getDISubprogram(Scope);
2927 Line = SP.getLineNumber();
2931 Line = FDL.getLine();
2936 recordSourceLine(Line, Col, TheScope);
2938 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
2940 /// ProcessedArgs - Collection of arguments already processed.
2941 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2943 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
2945 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
2946 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
2948 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2950 bool AtBlockEntry = true;
2951 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2953 const MachineInstr *MI = II;
2955 if (MI->isDebugValue()) {
2956 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2958 // Keep track of user variables.
2960 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
2962 // Variable is in a register, we need to check for clobbers.
2963 if (isDbgValueInDefinedReg(MI))
2964 LiveUserVar[MI->getOperand(0).getReg()] = Var;
2966 // Check the history of this variable.
2967 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
2968 if (History.empty()) {
2969 UserVariables.push_back(Var);
2970 // The first mention of a function argument gets the FunctionBeginSym
2971 // label, so arguments are visible when breaking at function entry.
2973 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
2974 DISubprogram(getDISubprogram(DV.getContext()))
2975 .describes(MF->getFunction()))
2976 LabelsBeforeInsn[MI] = FunctionBeginSym;
2978 // We have seen this variable before. Try to coalesce DBG_VALUEs.
2979 const MachineInstr *Prev = History.back();
2980 if (Prev->isDebugValue()) {
2981 // Coalesce identical entries at the end of History.
2982 if (History.size() >= 2 &&
2983 Prev->isIdenticalTo(History[History.size() - 2]))
2986 // Terminate old register assignments that don't reach MI;
2987 MachineFunction::const_iterator PrevMBB = Prev->getParent();
2988 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
2989 isDbgValueInDefinedReg(Prev)) {
2990 // Previous register assignment needs to terminate at the end of
2992 MachineBasicBlock::const_iterator LastMI =
2993 PrevMBB->getLastNonDebugInstr();
2994 if (LastMI == PrevMBB->end())
2995 // Drop DBG_VALUE for empty range.
2998 // Terminate after LastMI.
2999 History.push_back(LastMI);
3004 History.push_back(MI);
3006 // Not a DBG_VALUE instruction.
3008 AtBlockEntry = false;
3010 // Check if the instruction clobbers any registers with debug vars.
3011 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
3012 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
3013 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
3015 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
3016 unsigned Reg = *AI; ++AI) {
3017 const MDNode *Var = LiveUserVar[Reg];
3020 // Reg is now clobbered.
3021 LiveUserVar[Reg] = 0;
3023 // Was MD last defined by a DBG_VALUE referring to Reg?
3024 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
3025 if (HistI == DbgValues.end())
3027 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
3028 if (History.empty())
3030 const MachineInstr *Prev = History.back();
3031 // Sanity-check: Register assignments are terminated at the end of
3033 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
3035 // Is the variable still in Reg?
3036 if (!isDbgValueInDefinedReg(Prev) ||
3037 Prev->getOperand(0).getReg() != Reg)
3039 // Var is clobbered. Make sure the next instruction gets a label.
3040 History.push_back(MI);
3047 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
3049 SmallVectorImpl<const MachineInstr*> &History = I->second;
3050 if (History.empty())
3053 // Make sure the final register assignments are terminated.
3054 const MachineInstr *Prev = History.back();
3055 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
3056 const MachineBasicBlock *PrevMBB = Prev->getParent();
3057 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
3058 if (LastMI == PrevMBB->end())
3059 // Drop DBG_VALUE for empty range.
3062 // Terminate after LastMI.
3063 History.push_back(LastMI);
3066 // Request labels for the full history.
3067 for (unsigned i = 0, e = History.size(); i != e; ++i) {
3068 const MachineInstr *MI = History[i];
3069 if (MI->isDebugValue())
3070 requestLabelBeforeInsn(MI);
3072 requestLabelAfterInsn(MI);
3076 PrevInstLoc = DebugLoc();
3077 PrevLabel = FunctionBeginSym;
3080 /// endFunction - Gather and emit post-function debug information.
3082 void DwarfDebug::endFunction(const MachineFunction *MF) {
3083 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
3085 if (CurrentFnDbgScope) {
3087 // Define end label for subprogram.
3088 FunctionEndSym = Asm->GetTempSymbol("func_end",
3089 Asm->getFunctionNumber());
3090 // Assumes in correct section after the entry point.
3091 Asm->OutStreamer.EmitLabel(FunctionEndSym);
3093 SmallPtrSet<const MDNode *, 16> ProcessedVars;
3094 collectVariableInfo(MF, ProcessedVars);
3096 // Construct abstract scopes.
3097 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
3098 AE = AbstractScopesList.end(); AI != AE; ++AI) {
3099 DISubprogram SP((*AI)->getScopeNode());
3101 // Collect info for variables that were optimized out.
3102 StringRef FName = SP.getLinkageName();
3104 FName = SP.getName();
3105 if (NamedMDNode *NMD =
3106 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
3107 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3108 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
3109 if (!DV || !ProcessedVars.insert(DV))
3111 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
3113 Scope->addVariable(new DbgVariable(DV));
3117 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
3118 constructScopeDIE(*AI);
3121 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
3123 if (!DisableFramePointerElim(*MF))
3124 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
3125 dwarf::DW_FORM_flag, 1);
3128 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
3129 MMI->getFrameMoves()));
3133 CurrentFnDbgScope = NULL;
3134 CurrentFnArguments.clear();
3135 DbgVariableToFrameIndexMap.clear();
3136 VarToAbstractVarMap.clear();
3137 DbgVariableToDbgInstMap.clear();
3138 DeleteContainerSeconds(DbgScopeMap);
3139 UserVariables.clear();
3141 ConcreteScopes.clear();
3142 DeleteContainerSeconds(AbstractScopes);
3143 AbstractScopesList.clear();
3144 AbstractVariables.clear();
3145 LabelsBeforeInsn.clear();
3146 LabelsAfterInsn.clear();
3150 /// recordVariableFrameIndex - Record a variable's index.
3151 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
3152 assert (V && "Invalid DbgVariable!");
3153 DbgVariableToFrameIndexMap[V] = Index;
3156 /// findVariableFrameIndex - Return true if frame index for the variable
3157 /// is found. Update FI to hold value of the index.
3158 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
3159 assert (V && "Invalid DbgVariable!");
3160 DenseMap<const DbgVariable *, int>::iterator I =
3161 DbgVariableToFrameIndexMap.find(V);
3162 if (I == DbgVariableToFrameIndexMap.end())
3168 /// findDbgScope - Find DbgScope for the debug loc attached with an
3170 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
3171 DbgScope *Scope = NULL;
3173 MInsn->getParent()->getParent()->getFunction()->getContext();
3174 DebugLoc DL = MInsn->getDebugLoc();
3179 if (const MDNode *IA = DL.getInlinedAt(Ctx))
3180 Scope = ConcreteScopes.lookup(IA);
3182 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
3188 /// recordSourceLine - Register a source line with debug info. Returns the
3189 /// unique label that was emitted and which provides correspondence to
3190 /// the source line list.
3191 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S){
3196 DIDescriptor Scope(S);
3198 if (Scope.isCompileUnit()) {
3199 DICompileUnit CU(S);
3200 Fn = CU.getFilename();
3201 Dir = CU.getDirectory();
3202 } else if (Scope.isFile()) {
3204 Fn = F.getFilename();
3205 Dir = F.getDirectory();
3206 } else if (Scope.isSubprogram()) {
3208 Fn = SP.getFilename();
3209 Dir = SP.getDirectory();
3210 } else if (Scope.isLexicalBlock()) {
3211 DILexicalBlock DB(S);
3212 Fn = DB.getFilename();
3213 Dir = DB.getDirectory();
3215 assert(0 && "Unexpected scope info");
3217 Src = GetOrCreateSourceID(Fn, Dir);
3220 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
3224 //===----------------------------------------------------------------------===//
3226 //===----------------------------------------------------------------------===//
3228 /// computeSizeAndOffset - Compute the size and offset of a DIE.
3231 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
3232 // Get the children.
3233 const std::vector<DIE *> &Children = Die->getChildren();
3235 // If not last sibling and has children then add sibling offset attribute.
3236 if (!Last && !Children.empty())
3237 Die->addSiblingOffset(DIEValueAllocator);
3239 // Record the abbreviation.
3240 assignAbbrevNumber(Die->getAbbrev());
3242 // Get the abbreviation for this DIE.
3243 unsigned AbbrevNumber = Die->getAbbrevNumber();
3244 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3247 Die->setOffset(Offset);
3249 // Start the size with the size of abbreviation code.
3250 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3252 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3253 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3255 // Size the DIE attribute values.
3256 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3257 // Size attribute value.
3258 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3260 // Size the DIE children if any.
3261 if (!Children.empty()) {
3262 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3263 "Children flag not set");
3265 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3266 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3268 // End of children marker.
3269 Offset += sizeof(int8_t);
3272 Die->setSize(Offset - Die->getOffset());
3276 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3278 void DwarfDebug::computeSizeAndOffsets() {
3279 unsigned PrevOffset = 0;
3280 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3281 E = CUMap.end(); I != E; ++I) {
3282 // Compute size of compile unit header.
3283 static unsigned Offset = PrevOffset +
3284 sizeof(int32_t) + // Length of Compilation Unit Info
3285 sizeof(int16_t) + // DWARF version number
3286 sizeof(int32_t) + // Offset Into Abbrev. Section
3287 sizeof(int8_t); // Pointer Size (in bytes)
3288 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3289 PrevOffset = Offset;
3293 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3294 /// temporary label to it if SymbolStem is specified.
3295 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3296 const char *SymbolStem = 0) {
3297 Asm->OutStreamer.SwitchSection(Section);
3298 if (!SymbolStem) return 0;
3300 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3301 Asm->OutStreamer.EmitLabel(TmpSym);
3305 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3306 /// the start of each one.
3307 void DwarfDebug::EmitSectionLabels() {
3308 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3310 // Dwarf sections base addresses.
3311 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3312 DwarfFrameSectionSym =
3313 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3316 DwarfInfoSectionSym =
3317 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3318 DwarfAbbrevSectionSym =
3319 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3320 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3322 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3323 EmitSectionSym(Asm, MacroInfo);
3325 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3326 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3327 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3328 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3329 DwarfStrSectionSym =
3330 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3331 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3334 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3335 "section_debug_loc");
3337 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3338 EmitSectionSym(Asm, TLOF.getDataSection());
3341 /// emitDIE - Recusively Emits a debug information entry.
3343 void DwarfDebug::emitDIE(DIE *Die) {
3344 // Get the abbreviation for this DIE.
3345 unsigned AbbrevNumber = Die->getAbbrevNumber();
3346 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3348 // Emit the code (index) for the abbreviation.
3349 if (Asm->isVerbose())
3350 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3351 Twine::utohexstr(Die->getOffset()) + ":0x" +
3352 Twine::utohexstr(Die->getSize()) + " " +
3353 dwarf::TagString(Abbrev->getTag()));
3354 Asm->EmitULEB128(AbbrevNumber);
3356 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3357 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3359 // Emit the DIE attribute values.
3360 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3361 unsigned Attr = AbbrevData[i].getAttribute();
3362 unsigned Form = AbbrevData[i].getForm();
3363 assert(Form && "Too many attributes for DIE (check abbreviation)");
3365 if (Asm->isVerbose())
3366 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3369 case dwarf::DW_AT_sibling:
3370 Asm->EmitInt32(Die->getSiblingOffset());
3372 case dwarf::DW_AT_abstract_origin: {
3373 DIEEntry *E = cast<DIEEntry>(Values[i]);
3374 DIE *Origin = E->getEntry();
3375 unsigned Addr = Origin->getOffset();
3376 Asm->EmitInt32(Addr);
3379 case dwarf::DW_AT_ranges: {
3380 // DW_AT_range Value encodes offset in debug_range section.
3381 DIEInteger *V = cast<DIEInteger>(Values[i]);
3383 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3384 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3388 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3390 DwarfDebugRangeSectionSym,
3395 case dwarf::DW_AT_location: {
3396 if (UseDotDebugLocEntry.count(Die) != 0) {
3397 DIELabel *L = cast<DIELabel>(Values[i]);
3398 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3400 Values[i]->EmitValue(Asm, Form);
3403 case dwarf::DW_AT_accessibility: {
3404 if (Asm->isVerbose()) {
3405 DIEInteger *V = cast<DIEInteger>(Values[i]);
3406 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3408 Values[i]->EmitValue(Asm, Form);
3412 // Emit an attribute using the defined form.
3413 Values[i]->EmitValue(Asm, Form);
3418 // Emit the DIE children if any.
3419 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3420 const std::vector<DIE *> &Children = Die->getChildren();
3422 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3423 emitDIE(Children[j]);
3425 if (Asm->isVerbose())
3426 Asm->OutStreamer.AddComment("End Of Children Mark");
3431 /// emitDebugInfo - Emit the debug info section.
3433 void DwarfDebug::emitDebugInfo() {
3434 // Start debug info section.
3435 Asm->OutStreamer.SwitchSection(
3436 Asm->getObjFileLowering().getDwarfInfoSection());
3437 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3438 E = CUMap.end(); I != E; ++I) {
3439 CompileUnit *TheCU = I->second;
3440 DIE *Die = TheCU->getCUDie();
3442 // Emit the compile units header.
3443 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3446 // Emit size of content not including length itself
3447 unsigned ContentSize = Die->getSize() +
3448 sizeof(int16_t) + // DWARF version number
3449 sizeof(int32_t) + // Offset Into Abbrev. Section
3450 sizeof(int8_t) + // Pointer Size (in bytes)
3451 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3453 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3454 Asm->EmitInt32(ContentSize);
3455 Asm->OutStreamer.AddComment("DWARF version number");
3456 Asm->EmitInt16(dwarf::DWARF_VERSION);
3457 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3458 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3459 DwarfAbbrevSectionSym);
3460 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3461 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3464 // FIXME - extra padding for gdb bug.
3465 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3470 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3474 /// emitAbbreviations - Emit the abbreviation section.
3476 void DwarfDebug::emitAbbreviations() const {
3477 // Check to see if it is worth the effort.
3478 if (!Abbreviations.empty()) {
3479 // Start the debug abbrev section.
3480 Asm->OutStreamer.SwitchSection(
3481 Asm->getObjFileLowering().getDwarfAbbrevSection());
3483 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3485 // For each abbrevation.
3486 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3487 // Get abbreviation data
3488 const DIEAbbrev *Abbrev = Abbreviations[i];
3490 // Emit the abbrevations code (base 1 index.)
3491 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3493 // Emit the abbreviations data.
3497 // Mark end of abbreviations.
3498 Asm->EmitULEB128(0, "EOM(3)");
3500 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3504 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3505 /// the line matrix.
3507 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3508 // Define last address of section.
3509 Asm->OutStreamer.AddComment("Extended Op");
3512 Asm->OutStreamer.AddComment("Op size");
3513 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3514 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3515 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3517 Asm->OutStreamer.AddComment("Section end label");
3519 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3520 Asm->getTargetData().getPointerSize(),
3523 // Mark end of matrix.
3524 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3530 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3532 void DwarfDebug::emitCommonDebugFrame() {
3533 if (!Asm->MAI->doesDwarfRequireFrameSection())
3536 int stackGrowth = Asm->getTargetData().getPointerSize();
3537 if (Asm->TM.getFrameLowering()->getStackGrowthDirection() ==
3538 TargetFrameLowering::StackGrowsDown)
3541 // Start the dwarf frame section.
3542 Asm->OutStreamer.SwitchSection(
3543 Asm->getObjFileLowering().getDwarfFrameSection());
3545 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3546 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3547 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3548 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3550 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3551 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3552 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3553 Asm->OutStreamer.AddComment("CIE Version");
3554 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3555 Asm->OutStreamer.AddComment("CIE Augmentation");
3556 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3557 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3558 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3559 Asm->OutStreamer.AddComment("CIE RA Column");
3560 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3561 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
3562 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3564 std::vector<MachineMove> Moves;
3565 TFI->getInitialFrameState(Moves);
3567 Asm->EmitFrameMoves(Moves, 0, false);
3569 Asm->EmitAlignment(2);
3570 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3573 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3576 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3577 if (!Asm->MAI->doesDwarfRequireFrameSection())
3580 // Start the dwarf frame section.
3581 Asm->OutStreamer.SwitchSection(
3582 Asm->getObjFileLowering().getDwarfFrameSection());
3584 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3585 MCSymbol *DebugFrameBegin =
3586 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3587 MCSymbol *DebugFrameEnd =
3588 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3589 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3591 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3593 Asm->OutStreamer.AddComment("FDE CIE offset");
3594 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3595 DwarfFrameSectionSym);
3597 Asm->OutStreamer.AddComment("FDE initial location");
3598 MCSymbol *FuncBeginSym =
3599 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3600 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3601 Asm->getTargetData().getPointerSize(),
3605 Asm->OutStreamer.AddComment("FDE address range");
3606 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3607 FuncBeginSym, Asm->getTargetData().getPointerSize());
3609 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3611 Asm->EmitAlignment(2);
3612 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3615 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3617 void DwarfDebug::emitDebugPubNames() {
3618 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3619 E = CUMap.end(); I != E; ++I) {
3620 CompileUnit *TheCU = I->second;
3621 // Start the dwarf pubnames section.
3622 Asm->OutStreamer.SwitchSection(
3623 Asm->getObjFileLowering().getDwarfPubNamesSection());
3625 Asm->OutStreamer.AddComment("Length of Public Names Info");
3626 Asm->EmitLabelDifference(
3627 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3628 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3630 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3633 Asm->OutStreamer.AddComment("DWARF Version");
3634 Asm->EmitInt16(dwarf::DWARF_VERSION);
3636 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3637 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3638 DwarfInfoSectionSym);
3640 Asm->OutStreamer.AddComment("Compilation Unit Length");
3641 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3642 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3645 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3646 for (StringMap<DIE*>::const_iterator
3647 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3648 const char *Name = GI->getKeyData();
3649 DIE *Entity = GI->second;
3651 Asm->OutStreamer.AddComment("DIE offset");
3652 Asm->EmitInt32(Entity->getOffset());
3654 if (Asm->isVerbose())
3655 Asm->OutStreamer.AddComment("External Name");
3656 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3659 Asm->OutStreamer.AddComment("End Mark");
3661 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3666 void DwarfDebug::emitDebugPubTypes() {
3667 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3668 E = CUMap.end(); I != E; ++I) {
3669 CompileUnit *TheCU = I->second;
3670 // Start the dwarf pubnames section.
3671 Asm->OutStreamer.SwitchSection(
3672 Asm->getObjFileLowering().getDwarfPubTypesSection());
3673 Asm->OutStreamer.AddComment("Length of Public Types Info");
3674 Asm->EmitLabelDifference(
3675 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3676 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3678 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3681 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3682 Asm->EmitInt16(dwarf::DWARF_VERSION);
3684 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3685 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3686 DwarfInfoSectionSym);
3688 Asm->OutStreamer.AddComment("Compilation Unit Length");
3689 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3690 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3693 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3694 for (StringMap<DIE*>::const_iterator
3695 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3696 const char *Name = GI->getKeyData();
3697 DIE * Entity = GI->second;
3699 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3700 Asm->EmitInt32(Entity->getOffset());
3702 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3703 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3706 Asm->OutStreamer.AddComment("End Mark");
3708 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3713 /// emitDebugStr - Emit visible names into a debug str section.
3715 void DwarfDebug::emitDebugStr() {
3716 // Check to see if it is worth the effort.
3717 if (StringPool.empty()) return;
3719 // Start the dwarf str section.
3720 Asm->OutStreamer.SwitchSection(
3721 Asm->getObjFileLowering().getDwarfStrSection());
3723 // Get all of the string pool entries and put them in an array by their ID so
3724 // we can sort them.
3725 SmallVector<std::pair<unsigned,
3726 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3728 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3729 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3730 Entries.push_back(std::make_pair(I->second.second, &*I));
3732 array_pod_sort(Entries.begin(), Entries.end());
3734 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3735 // Emit a label for reference from debug information entries.
3736 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3738 // Emit the string itself.
3739 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3743 /// emitDebugLoc - Emit visible names into a debug loc section.
3745 void DwarfDebug::emitDebugLoc() {
3746 if (DotDebugLocEntries.empty())
3749 for (SmallVector<DotDebugLocEntry, 4>::iterator
3750 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3752 DotDebugLocEntry &Entry = *I;
3753 if (I + 1 != DotDebugLocEntries.end())
3757 // Start the dwarf loc section.
3758 Asm->OutStreamer.SwitchSection(
3759 Asm->getObjFileLowering().getDwarfLocSection());
3760 unsigned char Size = Asm->getTargetData().getPointerSize();
3761 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3763 for (SmallVector<DotDebugLocEntry, 4>::iterator
3764 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3765 I != E; ++I, ++index) {
3766 DotDebugLocEntry &Entry = *I;
3767 if (Entry.isMerged()) continue;
3768 if (Entry.isEmpty()) {
3769 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3770 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3771 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3773 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3774 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3775 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3776 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3777 if (int Offset = Entry.Loc.getOffset()) {
3778 // If the value is at a certain offset from frame register then
3780 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3781 Asm->OutStreamer.AddComment("Loc expr size");
3782 Asm->EmitInt16(1 + OffsetSize);
3783 Asm->OutStreamer.AddComment(
3784 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3785 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3786 Asm->OutStreamer.AddComment("Offset");
3787 Asm->EmitSLEB128(Offset);
3790 Asm->OutStreamer.AddComment("Loc expr size");
3792 Asm->OutStreamer.AddComment(
3793 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3794 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3796 Asm->OutStreamer.AddComment("Loc expr size");
3797 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3798 Asm->EmitInt8(dwarf::DW_OP_regx);
3799 Asm->EmitULEB128(Reg);
3806 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3808 void DwarfDebug::EmitDebugARanges() {
3809 // Start the dwarf aranges section.
3810 Asm->OutStreamer.SwitchSection(
3811 Asm->getObjFileLowering().getDwarfARangesSection());
3814 /// emitDebugRanges - Emit visible names into a debug ranges section.
3816 void DwarfDebug::emitDebugRanges() {
3817 // Start the dwarf ranges section.
3818 Asm->OutStreamer.SwitchSection(
3819 Asm->getObjFileLowering().getDwarfRangesSection());
3820 unsigned char Size = Asm->getTargetData().getPointerSize();
3821 for (SmallVector<const MCSymbol *, 8>::iterator
3822 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3825 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3827 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3831 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3833 void DwarfDebug::emitDebugMacInfo() {
3834 if (const MCSection *LineInfo =
3835 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3836 // Start the dwarf macinfo section.
3837 Asm->OutStreamer.SwitchSection(LineInfo);
3841 /// emitDebugInlineInfo - Emit inline info using following format.
3843 /// 1. length of section
3844 /// 2. Dwarf version number
3845 /// 3. address size.
3847 /// Entries (one "entry" for each function that was inlined):
3849 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3850 /// otherwise offset into __debug_str for regular function name.
3851 /// 2. offset into __debug_str section for regular function name.
3852 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3853 /// instances for the function.
3855 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3856 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3857 /// __debug_info section, and the low_pc is the starting address for the
3858 /// inlining instance.
3859 void DwarfDebug::emitDebugInlineInfo() {
3860 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3866 Asm->OutStreamer.SwitchSection(
3867 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3869 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3870 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3871 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3873 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3875 Asm->OutStreamer.AddComment("Dwarf Version");
3876 Asm->EmitInt16(dwarf::DWARF_VERSION);
3877 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3878 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3880 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3881 E = InlinedSPNodes.end(); I != E; ++I) {
3883 const MDNode *Node = *I;
3884 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3885 = InlineInfo.find(Node);
3886 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3887 DISubprogram SP(Node);
3888 StringRef LName = SP.getLinkageName();
3889 StringRef Name = SP.getName();
3891 Asm->OutStreamer.AddComment("MIPS linkage name");
3892 if (LName.empty()) {
3893 Asm->OutStreamer.EmitBytes(Name, 0);
3894 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3896 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3897 DwarfStrSectionSym);
3899 Asm->OutStreamer.AddComment("Function name");
3900 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3901 Asm->EmitULEB128(Labels.size(), "Inline count");
3903 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3904 LE = Labels.end(); LI != LE; ++LI) {
3905 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3906 Asm->EmitInt32(LI->second->getOffset());
3908 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3909 Asm->OutStreamer.EmitSymbolValue(LI->first,
3910 Asm->getTargetData().getPointerSize(),0);
3914 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));