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 which is typically zero for C/C++. The
1246 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size
1247 // of the array. If L > H then do not emit DW_AT_lower_bound and
1248 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1249 // array has one element and in such case do not emit lower bound.
1252 Buffer.addChild(DW_Subrange);
1256 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1257 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1258 Buffer.addChild(DW_Subrange);
1261 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1262 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1263 DICompositeType *CTy) {
1264 Buffer.setTag(dwarf::DW_TAG_array_type);
1265 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1266 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1268 // Emit derived type.
1269 addType(&Buffer, CTy->getTypeDerivedFrom());
1270 DIArray Elements = CTy->getTypeArray();
1272 // Get an anonymous type for index type.
1273 CompileUnit *TheCU = getCompileUnit(*CTy);
1274 DIE *IdxTy = TheCU->getIndexTyDie();
1276 // Construct an anonymous type for index type.
1277 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1278 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1279 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1280 dwarf::DW_ATE_signed);
1281 TheCU->addDie(IdxTy);
1282 TheCU->setIndexTyDie(IdxTy);
1285 // Add subranges to array type.
1286 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1287 DIDescriptor Element = Elements.getElement(i);
1288 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1289 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1293 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1294 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1295 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1296 StringRef Name = ETy.getName();
1297 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1298 int64_t Value = ETy.getEnumValue();
1299 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1303 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1304 /// printer to not emit usual symbol prefix before the symbol name is used then
1305 /// return linkage name after skipping this special LLVM prefix.
1306 static StringRef getRealLinkageName(StringRef LinkageName) {
1308 if (LinkageName.startswith(StringRef(&One, 1)))
1309 return LinkageName.substr(1);
1313 /// createMemberDIE - Create new member DIE.
1314 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1315 DIE *MemberDie = new DIE(DT.getTag());
1316 StringRef Name = DT.getName();
1318 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1320 addType(MemberDie, DT.getTypeDerivedFrom());
1322 addSourceLine(MemberDie, DT);
1324 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1325 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1327 uint64_t Size = DT.getSizeInBits();
1328 uint64_t FieldSize = DT.getOriginalTypeSize();
1330 if (Size != FieldSize) {
1332 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1333 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1335 uint64_t Offset = DT.getOffsetInBits();
1336 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1337 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1338 uint64_t FieldOffset = (HiMark - FieldSize);
1339 Offset -= FieldOffset;
1341 // Maybe we need to work from the other end.
1342 if (Asm->getTargetData().isLittleEndian())
1343 Offset = FieldSize - (Offset + Size);
1344 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1346 // Here WD_AT_data_member_location points to the anonymous
1347 // field that includes this bit field.
1348 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1351 // This is not a bitfield.
1352 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1354 if (DT.getTag() == dwarf::DW_TAG_inheritance
1355 && DT.isVirtual()) {
1357 // For C++, virtual base classes are not at fixed offset. Use following
1358 // expression to extract appropriate offset from vtable.
1359 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1361 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1362 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1363 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1364 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1365 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1366 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1367 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1368 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1370 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1373 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1375 if (DT.isProtected())
1376 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1377 dwarf::DW_ACCESS_protected);
1378 else if (DT.isPrivate())
1379 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1380 dwarf::DW_ACCESS_private);
1381 // Otherwise C++ member and base classes are considered public.
1382 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1383 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1384 dwarf::DW_ACCESS_public);
1386 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1387 dwarf::DW_VIRTUALITY_virtual);
1391 /// createSubprogramDIE - Create new DIE using SP.
1392 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
1393 CompileUnit *SPCU = getCompileUnit(SP);
1394 DIE *SPDie = SPCU->getDIE(SP);
1398 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1399 // Constructors and operators for anonymous aggregates do not have names.
1400 if (!SP.getName().empty())
1401 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1403 StringRef LinkageName = SP.getLinkageName();
1404 if (!LinkageName.empty())
1405 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1406 getRealLinkageName(LinkageName));
1408 addSourceLine(SPDie, SP);
1410 if (SP.isPrototyped())
1411 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1414 DICompositeType SPTy = SP.getType();
1415 DIArray Args = SPTy.getTypeArray();
1416 unsigned SPTag = SPTy.getTag();
1418 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1419 addType(SPDie, SPTy);
1421 addType(SPDie, DIType(Args.getElement(0)));
1423 unsigned VK = SP.getVirtuality();
1425 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1426 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1427 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1428 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1429 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1430 ContainingTypeMap.insert(std::make_pair(SPDie,
1431 SP.getContainingType()));
1434 if (!SP.isDefinition()) {
1435 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1437 // Add arguments. Do not add arguments for subprogram definition. They will
1438 // be handled while processing variables.
1439 DICompositeType SPTy = SP.getType();
1440 DIArray Args = SPTy.getTypeArray();
1441 unsigned SPTag = SPTy.getTag();
1443 if (SPTag == dwarf::DW_TAG_subroutine_type)
1444 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1445 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1446 DIType ATy = DIType(DIType(Args.getElement(i)));
1448 if (ATy.isArtificial())
1449 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1450 SPDie->addChild(Arg);
1454 if (SP.isArtificial())
1455 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1457 if (!SP.isLocalToUnit())
1458 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1460 if (SP.isOptimized())
1461 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1463 if (unsigned isa = Asm->getISAEncoding()) {
1464 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1467 // Add function template parameters.
1468 addTemplateParams(*SPDie, SP.getTemplateParams());
1470 // DW_TAG_inlined_subroutine may refer to this DIE.
1471 SPCU->insertDIE(SP, SPDie);
1473 // Add to context owner.
1474 addToContextOwner(SPDie, SP.getContext());
1479 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1480 assert(N && "Invalid Scope encoding!");
1482 DbgScope *AScope = AbstractScopes.lookup(N);
1486 DbgScope *Parent = NULL;
1488 DIDescriptor Scope(N);
1489 if (Scope.isLexicalBlock()) {
1490 DILexicalBlock DB(N);
1491 DIDescriptor ParentDesc = DB.getContext();
1492 Parent = getOrCreateAbstractScope(ParentDesc);
1495 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1498 Parent->addScope(AScope);
1499 AScope->setAbstractScope();
1500 AbstractScopes[N] = AScope;
1501 if (DIDescriptor(N).isSubprogram())
1502 AbstractScopesList.push_back(AScope);
1506 /// isSubprogramContext - Return true if Context is either a subprogram
1507 /// or another context nested inside a subprogram.
1508 static bool isSubprogramContext(const MDNode *Context) {
1511 DIDescriptor D(Context);
1512 if (D.isSubprogram())
1515 return isSubprogramContext(DIType(Context).getContext());
1519 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1520 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1521 /// If there are global variables in this scope then create and insert
1522 /// DIEs for these variables.
1523 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1524 CompileUnit *SPCU = getCompileUnit(SPNode);
1525 DIE *SPDie = SPCU->getDIE(SPNode);
1527 assert(SPDie && "Unable to find subprogram DIE!");
1528 DISubprogram SP(SPNode);
1530 // There is not any need to generate specification DIE for a function
1531 // defined at compile unit level. If a function is defined inside another
1532 // function then gdb prefers the definition at top level and but does not
1533 // expect specification DIE in parent function. So avoid creating
1534 // specification DIE for a function defined inside a function.
1535 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1536 !SP.getContext().isFile() &&
1537 !isSubprogramContext(SP.getContext())) {
1538 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1541 DICompositeType SPTy = SP.getType();
1542 DIArray Args = SPTy.getTypeArray();
1543 unsigned SPTag = SPTy.getTag();
1544 if (SPTag == dwarf::DW_TAG_subroutine_type)
1545 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1546 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1547 DIType ATy = DIType(DIType(Args.getElement(i)));
1549 if (ATy.isArtificial())
1550 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1551 SPDie->addChild(Arg);
1553 DIE *SPDeclDie = SPDie;
1554 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1555 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1557 SPCU->addDie(SPDie);
1560 // Pick up abstract subprogram DIE.
1561 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1562 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1563 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1564 dwarf::DW_FORM_ref4, AbsSPDIE);
1565 SPCU->addDie(SPDie);
1568 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1569 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1570 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1571 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1572 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1573 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1574 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1579 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1580 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1581 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1583 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1584 if (Scope->isAbstractScope())
1587 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1591 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1592 if (Ranges.size() > 1) {
1593 // .debug_range section has not been laid out yet. Emit offset in
1594 // .debug_range as a uint, size 4, for now. emitDIE will handle
1595 // DW_AT_ranges appropriately.
1596 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1597 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1598 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1599 RE = Ranges.end(); RI != RE; ++RI) {
1600 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1601 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1603 DebugRangeSymbols.push_back(NULL);
1604 DebugRangeSymbols.push_back(NULL);
1608 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1609 const MCSymbol *End = getLabelAfterInsn(RI->second);
1611 if (End == 0) return 0;
1613 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1614 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1616 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1617 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1622 /// constructInlinedScopeDIE - This scope represents inlined body of
1623 /// a function. Construct DIE to represent this concrete inlined copy
1624 /// of the function.
1625 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1627 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1628 assert (Ranges.empty() == false
1629 && "DbgScope does not have instruction markers!");
1631 // FIXME : .debug_inlined section specification does not clearly state how
1632 // to emit inlined scope that is split into multiple instruction ranges.
1633 // For now, use first instruction range and emit low_pc/high_pc pair and
1634 // corresponding .debug_inlined section entry for this pair.
1635 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1636 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1637 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1639 if (StartLabel == 0 || EndLabel == 0) {
1640 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1643 assert(StartLabel->isDefined() &&
1644 "Invalid starting label for an inlined scope!");
1645 assert(EndLabel->isDefined() &&
1646 "Invalid end label for an inlined scope!");
1648 if (!Scope->getScopeNode())
1650 DIScope DS(Scope->getScopeNode());
1651 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1653 DISubprogram InlinedSP = getDISubprogram(DS);
1654 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1655 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1656 assert(OriginDIE && "Unable to find Origin DIE!");
1657 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1658 dwarf::DW_FORM_ref4, OriginDIE);
1660 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1661 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1663 InlinedSubprogramDIEs.insert(OriginDIE);
1665 // Track the start label for this inlined function.
1666 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1667 I = InlineInfo.find(InlinedSP);
1669 if (I == InlineInfo.end()) {
1670 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1672 InlinedSPNodes.push_back(InlinedSP);
1674 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1676 DILocation DL(Scope->getInlinedAt());
1677 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1678 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1684 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1685 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1686 StringRef Name = DV->getName();
1690 // Translate tag to proper Dwarf tag. The result variable is dropped for
1693 switch (DV->getTag()) {
1694 case dwarf::DW_TAG_return_variable:
1696 case dwarf::DW_TAG_arg_variable:
1697 Tag = dwarf::DW_TAG_formal_parameter;
1699 case dwarf::DW_TAG_auto_variable: // fall thru
1701 Tag = dwarf::DW_TAG_variable;
1705 // Define variable debug information entry.
1706 DIE *VariableDie = new DIE(Tag);
1709 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1710 V2AVI = VarToAbstractVarMap.find(DV);
1711 if (V2AVI != VarToAbstractVarMap.end())
1712 AbsDIE = V2AVI->second->getDIE();
1715 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1716 dwarf::DW_FORM_ref4, AbsDIE);
1718 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1719 addSourceLine(VariableDie, DV->getVariable());
1721 // Add variable type.
1722 addType(VariableDie, DV->getType());
1725 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1726 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1727 else if (DIVariable(DV->getVariable()).isArtificial())
1728 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1730 if (Scope->isAbstractScope()) {
1731 DV->setDIE(VariableDie);
1735 // Add variable address.
1737 unsigned Offset = DV->getDotDebugLocOffset();
1738 if (Offset != ~0U) {
1739 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1740 Asm->GetTempSymbol("debug_loc", Offset));
1741 DV->setDIE(VariableDie);
1742 UseDotDebugLocEntry.insert(VariableDie);
1746 // Check if variable is described by a DBG_VALUE instruction.
1747 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1748 DbgVariableToDbgInstMap.find(DV);
1749 if (DVI != DbgVariableToDbgInstMap.end()) {
1750 const MachineInstr *DVInsn = DVI->second;
1751 bool updated = false;
1752 // FIXME : Handle getNumOperands != 3
1753 if (DVInsn->getNumOperands() == 3) {
1754 if (DVInsn->getOperand(0).isReg()) {
1755 const MachineOperand RegOp = DVInsn->getOperand(0);
1756 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1757 if (DVInsn->getOperand(1).isImm() &&
1758 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1759 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1762 updated = addRegisterAddress(VariableDie, RegOp);
1764 else if (DVInsn->getOperand(0).isImm())
1765 updated = addConstantValue(VariableDie, DVInsn->getOperand(0));
1766 else if (DVInsn->getOperand(0).isFPImm())
1768 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1770 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1771 if (Location.getReg()) {
1772 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1777 // If variableDie is not updated then DBG_VALUE instruction does not
1778 // have valid variable info.
1782 DV->setDIE(VariableDie);
1786 // .. else use frame index, if available.
1788 if (findVariableFrameIndex(DV, &FI))
1789 addVariableAddress(DV, VariableDie, FI);
1791 DV->setDIE(VariableDie);
1796 void DwarfDebug::addPubTypes(DISubprogram SP) {
1797 DICompositeType SPTy = SP.getType();
1798 unsigned SPTag = SPTy.getTag();
1799 if (SPTag != dwarf::DW_TAG_subroutine_type)
1802 DIArray Args = SPTy.getTypeArray();
1803 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1804 DIType ATy(Args.getElement(i));
1807 DICompositeType CATy = getDICompositeType(ATy);
1808 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1809 && !CATy.isForwardDecl()) {
1810 CompileUnit *TheCU = getCompileUnit(CATy);
1811 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1812 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1817 /// constructScopeDIE - Construct a DIE for this scope.
1818 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1819 if (!Scope || !Scope->getScopeNode())
1822 SmallVector <DIE *, 8> Children;
1824 // Collect arguments for current function.
1825 if (Scope == CurrentFnDbgScope)
1826 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
1827 if (DbgVariable *ArgDV = CurrentFnArguments[i])
1828 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
1829 Children.push_back(Arg);
1831 // Collect lexical scope childrens first.
1832 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1833 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
1834 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
1835 Children.push_back(Variable);
1836 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1837 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
1838 if (DIE *Nested = constructScopeDIE(Scopes[j]))
1839 Children.push_back(Nested);
1840 DIScope DS(Scope->getScopeNode());
1841 DIE *ScopeDIE = NULL;
1842 if (Scope->getInlinedAt())
1843 ScopeDIE = constructInlinedScopeDIE(Scope);
1844 else if (DS.isSubprogram()) {
1845 ProcessedSPNodes.insert(DS);
1846 if (Scope->isAbstractScope()) {
1847 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1848 // Note down abstract DIE.
1850 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1853 ScopeDIE = updateSubprogramScopeDIE(DS);
1856 // There is no need to emit empty lexical block DIE.
1857 if (Children.empty())
1859 ScopeDIE = constructLexicalScopeDIE(Scope);
1862 if (!ScopeDIE) return NULL;
1865 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
1866 E = Children.end(); I != E; ++I)
1867 ScopeDIE->addChild(*I);
1869 if (DS.isSubprogram())
1870 addPubTypes(DISubprogram(DS));
1875 /// GetOrCreateSourceID - Look up the source id with the given directory and
1876 /// source file names. If none currently exists, create a new id and insert it
1877 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1880 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
1881 StringRef DirName) {
1882 // If FE did not provide a file name, then assume stdin.
1883 if (FileName.empty())
1884 return GetOrCreateSourceID("<stdin>", StringRef());
1886 // MCStream expects full path name as filename.
1887 if (!DirName.empty() && !FileName.startswith("/")) {
1888 std::string FullPathName(DirName.data());
1889 if (!DirName.endswith("/"))
1890 FullPathName += "/";
1891 FullPathName += FileName.data();
1892 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
1893 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
1896 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
1897 if (Entry.getValue())
1898 return Entry.getValue();
1900 unsigned SrcId = SourceIdMap.size();
1901 Entry.setValue(SrcId);
1903 // Print out a .file directive to specify files for .loc directives.
1904 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
1909 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1910 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1911 CompileUnit *TheCU = getCompileUnit(NS);
1912 DIE *NDie = TheCU->getDIE(NS);
1915 NDie = new DIE(dwarf::DW_TAG_namespace);
1916 TheCU->insertDIE(NS, NDie);
1917 if (!NS.getName().empty())
1918 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1919 addSourceLine(NDie, NS);
1920 addToContextOwner(NDie, NS.getContext());
1924 /// constructCompileUnit - Create new CompileUnit for the given
1925 /// metadata node with tag DW_TAG_compile_unit.
1926 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1927 DICompileUnit DIUnit(N);
1928 StringRef FN = DIUnit.getFilename();
1929 StringRef Dir = DIUnit.getDirectory();
1930 unsigned ID = GetOrCreateSourceID(FN, Dir);
1932 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1933 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1934 DIUnit.getProducer());
1935 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1936 DIUnit.getLanguage());
1937 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1938 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1939 // simplifies debug range entries.
1940 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1941 // DW_AT_stmt_list is a offset of line number information for this
1942 // compile unit in debug_line section.
1943 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1944 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1945 Asm->GetTempSymbol("section_line"));
1947 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1950 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1951 if (DIUnit.isOptimized())
1952 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1954 StringRef Flags = DIUnit.getFlags();
1956 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1958 unsigned RVer = DIUnit.getRunTimeVersion();
1960 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1961 dwarf::DW_FORM_data1, RVer);
1963 CompileUnit *NewCU = new CompileUnit(ID, Die);
1966 CUMap.insert(std::make_pair(N, NewCU));
1969 /// getCompielUnit - Get CompileUnit DIE.
1970 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1971 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1973 const MDNode *CUNode = NULL;
1974 if (D.isCompileUnit())
1976 else if (D.isSubprogram())
1977 CUNode = DISubprogram(N).getCompileUnit();
1978 else if (D.isType())
1979 CUNode = DIType(N).getCompileUnit();
1980 else if (D.isGlobalVariable())
1981 CUNode = DIGlobalVariable(N).getCompileUnit();
1982 else if (D.isVariable())
1983 CUNode = DIVariable(N).getCompileUnit();
1984 else if (D.isNameSpace())
1985 CUNode = DINameSpace(N).getCompileUnit();
1986 else if (D.isFile())
1987 CUNode = DIFile(N).getCompileUnit();
1991 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1992 = CUMap.find(CUNode);
1993 if (I == CUMap.end())
1998 /// isUnsignedDIType - Return true if type encoding is unsigned.
1999 static bool isUnsignedDIType(DIType Ty) {
2000 DIDerivedType DTy(Ty);
2002 return isUnsignedDIType(DTy.getTypeDerivedFrom());
2004 DIBasicType BTy(Ty);
2006 unsigned Encoding = BTy.getEncoding();
2007 if (Encoding == dwarf::DW_ATE_unsigned ||
2008 Encoding == dwarf::DW_ATE_unsigned_char)
2014 // Return const exprssion if value is a GEP to access merged global
2016 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
2017 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
2018 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
2019 if (!CE || CE->getNumOperands() != 3 ||
2020 CE->getOpcode() != Instruction::GetElementPtr)
2023 // First operand points to a global value.
2024 if (!isa<GlobalValue>(CE->getOperand(0)))
2027 // Second operand is zero.
2028 const ConstantInt *CI =
2029 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
2030 if (!CI || !CI->isZero())
2033 // Third operand is offset.
2034 if (!isa<ConstantInt>(CE->getOperand(2)))
2040 /// constructGlobalVariableDIE - Construct global variable DIE.
2041 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
2042 DIGlobalVariable GV(N);
2044 // If debug information is malformed then ignore it.
2045 if (GV.Verify() == false)
2048 // Check for pre-existence.
2049 CompileUnit *TheCU = getCompileUnit(N);
2050 if (TheCU->getDIE(GV))
2053 DIType GTy = GV.getType();
2054 DIE *VariableDIE = new DIE(GV.getTag());
2056 bool isGlobalVariable = GV.getGlobal() != NULL;
2059 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
2060 GV.getDisplayName());
2061 StringRef LinkageName = GV.getLinkageName();
2062 if (!LinkageName.empty() && isGlobalVariable)
2063 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
2064 getRealLinkageName(LinkageName));
2066 addType(VariableDIE, GTy);
2067 if (GTy.isCompositeType() && !GTy.getName().empty()
2068 && !GTy.isForwardDecl()) {
2069 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
2070 assert(Entry && "Missing global type!");
2071 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
2073 // Add scoping info.
2074 if (!GV.isLocalToUnit()) {
2075 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
2076 // Expose as global.
2077 TheCU->addGlobal(GV.getName(), VariableDIE);
2079 // Add line number info.
2080 addSourceLine(VariableDIE, GV);
2082 TheCU->insertDIE(N, VariableDIE);
2083 // Add to context owner.
2084 DIDescriptor GVContext = GV.getContext();
2085 addToContextOwner(VariableDIE, GVContext);
2087 if (isGlobalVariable) {
2088 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2089 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2090 addLabel(Block, 0, dwarf::DW_FORM_udata,
2091 Asm->Mang->getSymbol(GV.getGlobal()));
2092 // Do not create specification DIE if context is either compile unit
2094 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
2095 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
2096 // Create specification DIE.
2097 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
2098 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
2099 dwarf::DW_FORM_ref4, VariableDIE);
2100 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
2101 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
2102 TheCU->addDie(VariableSpecDIE);
2104 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2106 } else if (ConstantInt *CI =
2107 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
2108 addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
2109 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
2110 // GV is a merged global.
2111 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2112 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2113 addLabel(Block, 0, dwarf::DW_FORM_udata,
2114 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
2115 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
2116 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
2117 addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
2118 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
2119 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2125 /// construct SubprogramDIE - Construct subprogram DIE.
2126 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2129 // Check for pre-existence.
2130 CompileUnit *TheCU = getCompileUnit(N);
2131 if (TheCU->getDIE(N))
2134 if (!SP.isDefinition())
2135 // This is a method declaration which will be handled while constructing
2139 DIE *SubprogramDie = createSubprogramDIE(SP);
2142 TheCU->insertDIE(N, SubprogramDie);
2144 // Add to context owner.
2145 addToContextOwner(SubprogramDie, SP.getContext());
2147 // Expose as global.
2148 TheCU->addGlobal(SP.getName(), SubprogramDie);
2153 /// beginModule - Emit all Dwarf sections that should come prior to the
2154 /// content. Create global DIEs and emit initial debug info sections.
2155 /// This is inovked by the target AsmPrinter.
2156 void DwarfDebug::beginModule(Module *M) {
2157 if (DisableDebugInfoPrinting)
2160 DebugInfoFinder DbgFinder;
2161 DbgFinder.processModule(*M);
2163 bool HasDebugInfo = false;
2165 // Scan all the compile-units to see if there are any marked as the main unit.
2166 // if not, we do not generate debug info.
2167 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2168 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2169 if (DICompileUnit(*I).isMain()) {
2170 HasDebugInfo = true;
2175 if (!HasDebugInfo) return;
2177 // Tell MMI that we have debug info.
2178 MMI->setDebugInfoAvailability(true);
2180 // Emit initial sections.
2181 EmitSectionLabels();
2183 // Create all the compile unit DIEs.
2184 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2185 E = DbgFinder.compile_unit_end(); I != E; ++I)
2186 constructCompileUnit(*I);
2188 // Create DIEs for each subprogram.
2189 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2190 E = DbgFinder.subprogram_end(); I != E; ++I)
2191 constructSubprogramDIE(*I);
2193 // Create DIEs for each global variable.
2194 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2195 E = DbgFinder.global_variable_end(); I != E; ++I)
2196 constructGlobalVariableDIE(*I);
2198 //getOrCreateTypeDIE
2199 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2200 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2201 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2203 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2204 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2205 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2207 // Prime section data.
2208 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2211 /// endModule - Emit all Dwarf sections that should come after the content.
2213 void DwarfDebug::endModule() {
2214 if (!FirstCU) return;
2215 const Module *M = MMI->getModule();
2216 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2217 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2218 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2219 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2220 DISubprogram SP(AllSPs->getOperand(SI));
2221 if (!SP.Verify()) continue;
2223 // Collect info for variables that were optimized out.
2224 if (!SP.isDefinition()) continue;
2225 StringRef FName = SP.getLinkageName();
2227 FName = SP.getName();
2228 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
2230 unsigned E = NMD->getNumOperands();
2232 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2233 DeadFnScopeMap[SP] = Scope;
2234 for (unsigned I = 0; I != E; ++I) {
2235 DIVariable DV(NMD->getOperand(I));
2236 if (!DV.Verify()) continue;
2237 Scope->addVariable(new DbgVariable(DV));
2240 // Construct subprogram DIE and add variables DIEs.
2241 constructSubprogramDIE(SP);
2242 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2243 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2244 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2245 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2247 ScopeDIE->addChild(VariableDIE);
2252 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2253 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2254 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2256 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2259 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2260 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2261 DIE *SPDie = CI->first;
2262 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2264 DIE *NDie = getCompileUnit(N)->getDIE(N);
2265 if (!NDie) continue;
2266 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2269 // Standard sections final addresses.
2270 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2271 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2272 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2273 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2275 // End text sections.
2276 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2277 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2278 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2281 // Emit common frame information.
2282 emitCommonDebugFrame();
2284 // Emit function debug frame information
2285 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2286 E = DebugFrames.end(); I != E; ++I)
2287 emitFunctionDebugFrame(*I);
2289 // Compute DIE offsets and sizes.
2290 computeSizeAndOffsets();
2292 // Emit all the DIEs into a debug info section
2295 // Corresponding abbreviations into a abbrev section.
2296 emitAbbreviations();
2298 // Emit info into a debug pubnames section.
2299 emitDebugPubNames();
2301 // Emit info into a debug pubtypes section.
2302 emitDebugPubTypes();
2304 // Emit info into a debug loc section.
2307 // Emit info into a debug aranges section.
2310 // Emit info into a debug ranges section.
2313 // Emit info into a debug macinfo section.
2316 // Emit inline info.
2317 emitDebugInlineInfo();
2319 // Emit info into a debug str section.
2323 DeleteContainerSeconds(DeadFnScopeMap);
2324 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2325 E = CUMap.end(); I != E; ++I)
2327 FirstCU = NULL; // Reset for the next Module, if any.
2330 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2331 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2332 DebugLoc ScopeLoc) {
2334 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2336 return AbsDbgVariable;
2338 LLVMContext &Ctx = Var->getContext();
2339 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2343 AbsDbgVariable = new DbgVariable(Var);
2344 Scope->addVariable(AbsDbgVariable);
2345 AbstractVariables[Var] = AbsDbgVariable;
2346 return AbsDbgVariable;
2349 /// addCurrentFnArgument - If Var is an current function argument that add
2350 /// it in CurrentFnArguments list.
2351 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
2352 DbgVariable *Var, DbgScope *Scope) {
2353 if (Scope != CurrentFnDbgScope)
2355 DIVariable DV = Var->getVariable();
2356 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2358 unsigned ArgNo = DV.getArgNumber();
2362 size_t Size = CurrentFnArguments.size();
2364 CurrentFnArguments.resize(MF->getFunction()->arg_size());
2365 // llvm::Function argument size is not good indicator of how many
2366 // arguments does the function have at source level.
2368 CurrentFnArguments.resize(ArgNo * 2);
2369 CurrentFnArguments[ArgNo - 1] = Var;
2373 /// collectVariableInfoFromMMITable - Collect variable information from
2374 /// side table maintained by MMI.
2376 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2377 SmallPtrSet<const MDNode *, 16> &Processed) {
2378 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2379 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2380 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2381 VE = VMap.end(); VI != VE; ++VI) {
2382 const MDNode *Var = VI->first;
2384 Processed.insert(Var);
2386 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2388 DbgScope *Scope = 0;
2389 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2390 Scope = ConcreteScopes.lookup(IA);
2392 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2394 // If variable scope is not found then skip this variable.
2398 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2399 DbgVariable *RegVar = new DbgVariable(DV);
2400 recordVariableFrameIndex(RegVar, VP.first);
2401 if (!addCurrentFnArgument(MF, RegVar, Scope))
2402 Scope->addVariable(RegVar);
2403 if (AbsDbgVariable) {
2404 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2405 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2410 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2411 /// DBG_VALUE instruction, is in a defined reg.
2412 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2413 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2414 return MI->getNumOperands() == 3 &&
2415 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
2416 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
2419 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2421 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2422 SmallPtrSet<const MDNode *, 16> &Processed) {
2424 /// collection info from MMI table.
2425 collectVariableInfoFromMMITable(MF, Processed);
2427 for (SmallVectorImpl<const MDNode*>::const_iterator
2428 UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
2430 const MDNode *Var = *UVI;
2431 if (Processed.count(Var))
2434 // History contains relevant DBG_VALUE instructions for Var and instructions
2436 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
2437 if (History.empty())
2439 const MachineInstr *MInsn = History.front();
2442 DbgScope *Scope = NULL;
2443 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2444 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2445 Scope = CurrentFnDbgScope;
2447 Scope = findDbgScope(MInsn);
2448 // If variable scope is not found then skip this variable.
2452 Processed.insert(DV);
2453 assert(MInsn->isDebugValue() && "History must begin with debug value");
2454 DbgVariable *RegVar = new DbgVariable(DV);
2455 if (!addCurrentFnArgument(MF, RegVar, Scope))
2456 Scope->addVariable(RegVar);
2457 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2458 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2459 VarToAbstractVarMap[RegVar] = AbsVar;
2462 // Simple ranges that are fully coalesced.
2463 if (History.size() <= 1 || (History.size() == 2 &&
2464 MInsn->isIdenticalTo(History.back()))) {
2465 DbgVariableToDbgInstMap[RegVar] = MInsn;
2469 // handle multiple DBG_VALUE instructions describing one variable.
2470 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2472 for (SmallVectorImpl<const MachineInstr*>::const_iterator
2473 HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
2474 const MachineInstr *Begin = *HI;
2475 assert(Begin->isDebugValue() && "Invalid History entry");
2476 MachineLocation MLoc;
2477 if (Begin->getNumOperands() == 3) {
2478 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2479 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2481 MLoc = Asm->getDebugValueLocation(Begin);
2483 // FIXME: emitDebugLoc only understands registers.
2487 // Compute the range for a register location.
2488 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2489 const MCSymbol *SLabel = 0;
2492 // If Begin is the last instruction in History then its value is valid
2493 // until the end of the funtion.
2494 SLabel = FunctionEndSym;
2496 const MachineInstr *End = HI[1];
2497 if (End->isDebugValue())
2498 SLabel = getLabelBeforeInsn(End);
2500 // End is a normal instruction clobbering the range.
2501 SLabel = getLabelAfterInsn(End);
2502 assert(SLabel && "Forgot label after clobber instruction");
2507 // The value is valid until the next DBG_VALUE or clobber.
2508 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2510 DotDebugLocEntries.push_back(DotDebugLocEntry());
2513 // Collect info for variables that were optimized out.
2514 const Function *F = MF->getFunction();
2515 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
2516 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2517 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2518 if (!DV || !Processed.insert(DV))
2520 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2522 Scope->addVariable(new DbgVariable(DV));
2527 /// getLabelBeforeInsn - Return Label preceding the instruction.
2528 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2529 MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
2530 assert(Label && "Didn't insert label before instruction");
2534 /// getLabelAfterInsn - Return Label immediately following the instruction.
2535 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2536 return LabelsAfterInsn.lookup(MI);
2539 /// beginInstruction - Process beginning of an instruction.
2540 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
2541 // Check if source location changes, but ignore DBG_VALUE locations.
2542 if (!MI->isDebugValue()) {
2543 DebugLoc DL = MI->getDebugLoc();
2544 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
2546 if (!DL.isUnknown()) {
2547 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2548 recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2550 recordSourceLine(0, 0, 0);
2554 // Insert labels where requested.
2555 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
2556 LabelsBeforeInsn.find(MI);
2559 if (I == LabelsBeforeInsn.end())
2562 // Label already assigned.
2567 PrevLabel = MMI->getContext().CreateTempSymbol();
2568 Asm->OutStreamer.EmitLabel(PrevLabel);
2570 I->second = PrevLabel;
2573 /// endInstruction - Process end of an instruction.
2574 void DwarfDebug::endInstruction(const MachineInstr *MI) {
2575 // Don't create a new label after DBG_VALUE instructions.
2576 // They don't generate code.
2577 if (!MI->isDebugValue())
2580 DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
2581 LabelsAfterInsn.find(MI);
2584 if (I == LabelsAfterInsn.end())
2587 // Label already assigned.
2591 // We need a label after this instruction.
2593 PrevLabel = MMI->getContext().CreateTempSymbol();
2594 Asm->OutStreamer.EmitLabel(PrevLabel);
2596 I->second = PrevLabel;
2599 /// getOrCreateDbgScope - Create DbgScope for the scope.
2600 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2601 const MDNode *InlinedAt) {
2603 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2606 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2607 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2608 if (DIDescriptor(Scope).isLexicalBlock()) {
2610 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2611 WScope->setParent(Parent);
2612 Parent->addScope(WScope);
2615 if (!WScope->getParent()) {
2616 StringRef SPName = DISubprogram(Scope).getLinkageName();
2617 // We used to check only for a linkage name, but that fails
2618 // since we began omitting the linkage name for private
2619 // functions. The new way is to check for the name in metadata,
2620 // but that's not supported in old .ll test cases. Ergo, we
2622 if (SPName == Asm->MF->getFunction()->getName() ||
2623 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2624 CurrentFnDbgScope = WScope;
2630 getOrCreateAbstractScope(Scope);
2631 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2635 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2636 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2637 DILocation DL(InlinedAt);
2639 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2640 WScope->setParent(Parent);
2641 Parent->addScope(WScope);
2643 ConcreteScopes[InlinedAt] = WScope;
2648 /// hasValidLocation - Return true if debug location entry attached with
2649 /// machine instruction encodes valid location info.
2650 static bool hasValidLocation(LLVMContext &Ctx,
2651 const MachineInstr *MInsn,
2652 const MDNode *&Scope, const MDNode *&InlinedAt) {
2653 DebugLoc DL = MInsn->getDebugLoc();
2654 if (DL.isUnknown()) return false;
2656 const MDNode *S = DL.getScope(Ctx);
2658 // There is no need to create another DIE for compile unit. For all
2659 // other scopes, create one DbgScope now. This will be translated
2660 // into a scope DIE at the end.
2661 if (DIScope(S).isCompileUnit()) return false;
2664 InlinedAt = DL.getInlinedAt(Ctx);
2668 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2670 static void calculateDominanceGraph(DbgScope *Scope) {
2671 assert (Scope && "Unable to calculate scop edominance graph!");
2672 SmallVector<DbgScope *, 4> WorkStack;
2673 WorkStack.push_back(Scope);
2674 unsigned Counter = 0;
2675 while (!WorkStack.empty()) {
2676 DbgScope *WS = WorkStack.back();
2677 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2678 bool visitedChildren = false;
2679 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2680 SE = Children.end(); SI != SE; ++SI) {
2681 DbgScope *ChildScope = *SI;
2682 if (!ChildScope->getDFSOut()) {
2683 WorkStack.push_back(ChildScope);
2684 visitedChildren = true;
2685 ChildScope->setDFSIn(++Counter);
2689 if (!visitedChildren) {
2690 WorkStack.pop_back();
2691 WS->setDFSOut(++Counter);
2696 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2698 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2699 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2702 unsigned PrevDFSIn = 0;
2703 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2705 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2707 const MachineInstr *MInsn = II;
2708 const MDNode *Scope = NULL;
2709 const MDNode *InlinedAt = NULL;
2711 // Check if instruction has valid location information.
2712 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2716 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2717 MI2ScopeMap.find(MInsn);
2718 if (DI != MI2ScopeMap.end()) {
2719 DbgScope *S = DI->second;
2720 dbgs() << S->getDFSIn();
2721 PrevDFSIn = S->getDFSIn();
2723 dbgs() << PrevDFSIn;
2725 dbgs() << " [ x" << PrevDFSIn;
2733 /// extractScopeInformation - Scan machine instructions in this function
2734 /// and collect DbgScopes. Return true, if at least one scope was found.
2735 bool DwarfDebug::extractScopeInformation() {
2736 // If scope information was extracted using .dbg intrinsics then there is not
2737 // any need to extract these information by scanning each instruction.
2738 if (!DbgScopeMap.empty())
2741 // Scan each instruction and create scopes. First build working set of scopes.
2742 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2743 SmallVector<DbgRange, 4> MIRanges;
2744 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2745 const MDNode *PrevScope = NULL;
2746 const MDNode *PrevInlinedAt = NULL;
2747 const MachineInstr *RangeBeginMI = NULL;
2748 const MachineInstr *PrevMI = NULL;
2749 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2751 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2753 const MachineInstr *MInsn = II;
2754 const MDNode *Scope = NULL;
2755 const MDNode *InlinedAt = NULL;
2757 // Check if instruction has valid location information.
2758 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2763 // If scope has not changed then skip this instruction.
2764 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2769 // Ignore DBG_VALUE. It does not contribute any instruction in output.
2770 if (MInsn->isDebugValue())
2774 // If we have alread seen a beginning of a instruction range and
2775 // current instruction scope does not match scope of first instruction
2776 // in this range then create a new instruction range.
2777 DbgRange R(RangeBeginMI, PrevMI);
2778 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2780 MIRanges.push_back(R);
2783 // This is a beginning of a new instruction range.
2784 RangeBeginMI = MInsn;
2786 // Reset previous markers.
2789 PrevInlinedAt = InlinedAt;
2793 // Create last instruction range.
2794 if (RangeBeginMI && PrevMI && PrevScope) {
2795 DbgRange R(RangeBeginMI, PrevMI);
2796 MIRanges.push_back(R);
2797 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2800 if (!CurrentFnDbgScope)
2803 calculateDominanceGraph(CurrentFnDbgScope);
2805 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2807 // Find ranges of instructions covered by each DbgScope;
2808 DbgScope *PrevDbgScope = NULL;
2809 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2810 RE = MIRanges.end(); RI != RE; ++RI) {
2811 const DbgRange &R = *RI;
2812 DbgScope *S = MI2ScopeMap.lookup(R.first);
2813 assert (S && "Lost DbgScope for a machine instruction!");
2814 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2815 PrevDbgScope->closeInsnRange(S);
2816 S->openInsnRange(R.first);
2817 S->extendInsnRange(R.second);
2822 PrevDbgScope->closeInsnRange();
2824 identifyScopeMarkers();
2826 return !DbgScopeMap.empty();
2829 /// identifyScopeMarkers() -
2830 /// Each DbgScope has first instruction and last instruction to mark beginning
2831 /// and end of a scope respectively. Create an inverse map that list scopes
2832 /// starts (and ends) with an instruction. One instruction may start (or end)
2833 /// multiple scopes. Ignore scopes that are not reachable.
2834 void DwarfDebug::identifyScopeMarkers() {
2835 SmallVector<DbgScope *, 4> WorkList;
2836 WorkList.push_back(CurrentFnDbgScope);
2837 while (!WorkList.empty()) {
2838 DbgScope *S = WorkList.pop_back_val();
2840 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2841 if (!Children.empty())
2842 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2843 SE = Children.end(); SI != SE; ++SI)
2844 WorkList.push_back(*SI);
2846 if (S->isAbstractScope())
2849 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2852 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2853 RE = Ranges.end(); RI != RE; ++RI) {
2854 assert(RI->first && "DbgRange does not have first instruction!");
2855 assert(RI->second && "DbgRange does not have second instruction!");
2856 requestLabelBeforeInsn(RI->first);
2857 requestLabelAfterInsn(RI->second);
2862 /// FindFirstDebugLoc - Find the first debug location in the function. This
2863 /// is intended to be an approximation for the source position of the
2864 /// beginning of the function.
2865 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2866 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2868 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2869 MBBI != MBBE; ++MBBI) {
2870 DebugLoc DL = MBBI->getDebugLoc();
2871 if (!DL.isUnknown())
2878 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2879 /// line number information.
2880 static void CheckLineNumbers(const MachineFunction *MF) {
2881 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2883 bool FoundLineNo = false;
2884 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2886 const MachineInstr *MI = II;
2887 if (!MI->getDebugLoc().isUnknown()) {
2892 if (!FoundLineNo && I->size())
2893 ++BlocksWithoutLineNo;
2898 /// beginFunction - Gather pre-function debug information. Assumes being
2899 /// emitted immediately after the function entry point.
2900 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2901 if (!MMI->hasDebugInfo()) return;
2902 if (!extractScopeInformation()) return;
2905 CheckLineNumbers(MF);
2908 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2909 Asm->getFunctionNumber());
2910 // Assumes in correct section after the entry point.
2911 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2913 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2915 DebugLoc FDL = FindFirstDebugLoc(MF);
2916 if (FDL.isUnknown()) return;
2918 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2919 const MDNode *TheScope = 0;
2921 DISubprogram SP = getDISubprogram(Scope);
2924 Line = SP.getLineNumber();
2928 Line = FDL.getLine();
2933 recordSourceLine(Line, Col, TheScope);
2935 assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
2937 /// ProcessedArgs - Collection of arguments already processed.
2938 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2940 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
2942 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
2943 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
2945 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2947 bool AtBlockEntry = true;
2948 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2950 const MachineInstr *MI = II;
2952 if (MI->isDebugValue()) {
2953 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2955 // Keep track of user variables.
2957 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
2959 // Variable is in a register, we need to check for clobbers.
2960 if (isDbgValueInDefinedReg(MI))
2961 LiveUserVar[MI->getOperand(0).getReg()] = Var;
2963 // Check the history of this variable.
2964 SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
2965 if (History.empty()) {
2966 UserVariables.push_back(Var);
2967 // The first mention of a function argument gets the FunctionBeginSym
2968 // label, so arguments are visible when breaking at function entry.
2970 if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
2971 DISubprogram(getDISubprogram(DV.getContext()))
2972 .describes(MF->getFunction()))
2973 LabelsBeforeInsn[MI] = FunctionBeginSym;
2975 // We have seen this variable before. Try to coalesce DBG_VALUEs.
2976 const MachineInstr *Prev = History.back();
2977 if (Prev->isDebugValue()) {
2978 // Coalesce identical entries at the end of History.
2979 if (History.size() >= 2 &&
2980 Prev->isIdenticalTo(History[History.size() - 2]))
2983 // Terminate old register assignments that don't reach MI;
2984 MachineFunction::const_iterator PrevMBB = Prev->getParent();
2985 if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
2986 isDbgValueInDefinedReg(Prev)) {
2987 // Previous register assignment needs to terminate at the end of
2989 MachineBasicBlock::const_iterator LastMI =
2990 PrevMBB->getLastNonDebugInstr();
2991 if (LastMI == PrevMBB->end())
2992 // Drop DBG_VALUE for empty range.
2995 // Terminate after LastMI.
2996 History.push_back(LastMI);
3001 History.push_back(MI);
3003 // Not a DBG_VALUE instruction.
3005 AtBlockEntry = false;
3007 // Check if the instruction clobbers any registers with debug vars.
3008 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
3009 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
3010 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
3012 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
3013 unsigned Reg = *AI; ++AI) {
3014 const MDNode *Var = LiveUserVar[Reg];
3017 // Reg is now clobbered.
3018 LiveUserVar[Reg] = 0;
3020 // Was MD last defined by a DBG_VALUE referring to Reg?
3021 DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
3022 if (HistI == DbgValues.end())
3024 SmallVectorImpl<const MachineInstr*> &History = HistI->second;
3025 if (History.empty())
3027 const MachineInstr *Prev = History.back();
3028 // Sanity-check: Register assignments are terminated at the end of
3030 if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
3032 // Is the variable still in Reg?
3033 if (!isDbgValueInDefinedReg(Prev) ||
3034 Prev->getOperand(0).getReg() != Reg)
3036 // Var is clobbered. Make sure the next instruction gets a label.
3037 History.push_back(MI);
3044 for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
3046 SmallVectorImpl<const MachineInstr*> &History = I->second;
3047 if (History.empty())
3050 // Make sure the final register assignments are terminated.
3051 const MachineInstr *Prev = History.back();
3052 if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
3053 const MachineBasicBlock *PrevMBB = Prev->getParent();
3054 MachineBasicBlock::const_iterator LastMI = PrevMBB->getLastNonDebugInstr();
3055 if (LastMI == PrevMBB->end())
3056 // Drop DBG_VALUE for empty range.
3059 // Terminate after LastMI.
3060 History.push_back(LastMI);
3063 // Request labels for the full history.
3064 for (unsigned i = 0, e = History.size(); i != e; ++i) {
3065 const MachineInstr *MI = History[i];
3066 if (MI->isDebugValue())
3067 requestLabelBeforeInsn(MI);
3069 requestLabelAfterInsn(MI);
3073 PrevInstLoc = DebugLoc();
3074 PrevLabel = FunctionBeginSym;
3077 /// endFunction - Gather and emit post-function debug information.
3079 void DwarfDebug::endFunction(const MachineFunction *MF) {
3080 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
3082 if (CurrentFnDbgScope) {
3084 // Define end label for subprogram.
3085 FunctionEndSym = Asm->GetTempSymbol("func_end",
3086 Asm->getFunctionNumber());
3087 // Assumes in correct section after the entry point.
3088 Asm->OutStreamer.EmitLabel(FunctionEndSym);
3090 SmallPtrSet<const MDNode *, 16> ProcessedVars;
3091 collectVariableInfo(MF, ProcessedVars);
3093 // Construct abstract scopes.
3094 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
3095 AE = AbstractScopesList.end(); AI != AE; ++AI) {
3096 DISubprogram SP((*AI)->getScopeNode());
3098 // Collect info for variables that were optimized out.
3099 StringRef FName = SP.getLinkageName();
3101 FName = SP.getName();
3102 if (NamedMDNode *NMD =
3103 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
3104 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3105 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
3106 if (!DV || !ProcessedVars.insert(DV))
3108 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
3110 Scope->addVariable(new DbgVariable(DV));
3114 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
3115 constructScopeDIE(*AI);
3118 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
3120 if (!DisableFramePointerElim(*MF))
3121 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
3122 dwarf::DW_FORM_flag, 1);
3125 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
3126 MMI->getFrameMoves()));
3130 CurrentFnDbgScope = NULL;
3131 CurrentFnArguments.clear();
3132 DbgVariableToFrameIndexMap.clear();
3133 VarToAbstractVarMap.clear();
3134 DbgVariableToDbgInstMap.clear();
3135 DeleteContainerSeconds(DbgScopeMap);
3136 UserVariables.clear();
3138 ConcreteScopes.clear();
3139 DeleteContainerSeconds(AbstractScopes);
3140 AbstractScopesList.clear();
3141 AbstractVariables.clear();
3142 LabelsBeforeInsn.clear();
3143 LabelsAfterInsn.clear();
3147 /// recordVariableFrameIndex - Record a variable's index.
3148 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
3149 assert (V && "Invalid DbgVariable!");
3150 DbgVariableToFrameIndexMap[V] = Index;
3153 /// findVariableFrameIndex - Return true if frame index for the variable
3154 /// is found. Update FI to hold value of the index.
3155 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
3156 assert (V && "Invalid DbgVariable!");
3157 DenseMap<const DbgVariable *, int>::iterator I =
3158 DbgVariableToFrameIndexMap.find(V);
3159 if (I == DbgVariableToFrameIndexMap.end())
3165 /// findDbgScope - Find DbgScope for the debug loc attached with an
3167 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
3168 DbgScope *Scope = NULL;
3170 MInsn->getParent()->getParent()->getFunction()->getContext();
3171 DebugLoc DL = MInsn->getDebugLoc();
3176 if (const MDNode *IA = DL.getInlinedAt(Ctx))
3177 Scope = ConcreteScopes.lookup(IA);
3179 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
3185 /// recordSourceLine - Register a source line with debug info. Returns the
3186 /// unique label that was emitted and which provides correspondence to
3187 /// the source line list.
3188 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S){
3193 DIDescriptor Scope(S);
3195 if (Scope.isCompileUnit()) {
3196 DICompileUnit CU(S);
3197 Fn = CU.getFilename();
3198 Dir = CU.getDirectory();
3199 } else if (Scope.isFile()) {
3201 Fn = F.getFilename();
3202 Dir = F.getDirectory();
3203 } else if (Scope.isSubprogram()) {
3205 Fn = SP.getFilename();
3206 Dir = SP.getDirectory();
3207 } else if (Scope.isLexicalBlock()) {
3208 DILexicalBlock DB(S);
3209 Fn = DB.getFilename();
3210 Dir = DB.getDirectory();
3212 assert(0 && "Unexpected scope info");
3214 Src = GetOrCreateSourceID(Fn, Dir);
3217 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
3221 //===----------------------------------------------------------------------===//
3223 //===----------------------------------------------------------------------===//
3225 /// computeSizeAndOffset - Compute the size and offset of a DIE.
3228 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
3229 // Get the children.
3230 const std::vector<DIE *> &Children = Die->getChildren();
3232 // If not last sibling and has children then add sibling offset attribute.
3233 if (!Last && !Children.empty())
3234 Die->addSiblingOffset(DIEValueAllocator);
3236 // Record the abbreviation.
3237 assignAbbrevNumber(Die->getAbbrev());
3239 // Get the abbreviation for this DIE.
3240 unsigned AbbrevNumber = Die->getAbbrevNumber();
3241 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3244 Die->setOffset(Offset);
3246 // Start the size with the size of abbreviation code.
3247 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3249 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3250 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3252 // Size the DIE attribute values.
3253 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3254 // Size attribute value.
3255 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3257 // Size the DIE children if any.
3258 if (!Children.empty()) {
3259 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3260 "Children flag not set");
3262 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3263 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3265 // End of children marker.
3266 Offset += sizeof(int8_t);
3269 Die->setSize(Offset - Die->getOffset());
3273 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3275 void DwarfDebug::computeSizeAndOffsets() {
3276 unsigned PrevOffset = 0;
3277 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3278 E = CUMap.end(); I != E; ++I) {
3279 // Compute size of compile unit header.
3280 static unsigned Offset = PrevOffset +
3281 sizeof(int32_t) + // Length of Compilation Unit Info
3282 sizeof(int16_t) + // DWARF version number
3283 sizeof(int32_t) + // Offset Into Abbrev. Section
3284 sizeof(int8_t); // Pointer Size (in bytes)
3285 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3286 PrevOffset = Offset;
3290 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3291 /// temporary label to it if SymbolStem is specified.
3292 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3293 const char *SymbolStem = 0) {
3294 Asm->OutStreamer.SwitchSection(Section);
3295 if (!SymbolStem) return 0;
3297 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3298 Asm->OutStreamer.EmitLabel(TmpSym);
3302 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3303 /// the start of each one.
3304 void DwarfDebug::EmitSectionLabels() {
3305 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3307 // Dwarf sections base addresses.
3308 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3309 DwarfFrameSectionSym =
3310 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3313 DwarfInfoSectionSym =
3314 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3315 DwarfAbbrevSectionSym =
3316 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3317 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3319 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3320 EmitSectionSym(Asm, MacroInfo);
3322 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3323 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3324 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3325 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3326 DwarfStrSectionSym =
3327 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3328 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3331 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3332 "section_debug_loc");
3334 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3335 EmitSectionSym(Asm, TLOF.getDataSection());
3338 /// emitDIE - Recusively Emits a debug information entry.
3340 void DwarfDebug::emitDIE(DIE *Die) {
3341 // Get the abbreviation for this DIE.
3342 unsigned AbbrevNumber = Die->getAbbrevNumber();
3343 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3345 // Emit the code (index) for the abbreviation.
3346 if (Asm->isVerbose())
3347 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3348 Twine::utohexstr(Die->getOffset()) + ":0x" +
3349 Twine::utohexstr(Die->getSize()) + " " +
3350 dwarf::TagString(Abbrev->getTag()));
3351 Asm->EmitULEB128(AbbrevNumber);
3353 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3354 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3356 // Emit the DIE attribute values.
3357 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3358 unsigned Attr = AbbrevData[i].getAttribute();
3359 unsigned Form = AbbrevData[i].getForm();
3360 assert(Form && "Too many attributes for DIE (check abbreviation)");
3362 if (Asm->isVerbose())
3363 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3366 case dwarf::DW_AT_sibling:
3367 Asm->EmitInt32(Die->getSiblingOffset());
3369 case dwarf::DW_AT_abstract_origin: {
3370 DIEEntry *E = cast<DIEEntry>(Values[i]);
3371 DIE *Origin = E->getEntry();
3372 unsigned Addr = Origin->getOffset();
3373 Asm->EmitInt32(Addr);
3376 case dwarf::DW_AT_ranges: {
3377 // DW_AT_range Value encodes offset in debug_range section.
3378 DIEInteger *V = cast<DIEInteger>(Values[i]);
3380 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3381 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3385 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3387 DwarfDebugRangeSectionSym,
3392 case dwarf::DW_AT_location: {
3393 if (UseDotDebugLocEntry.count(Die) != 0) {
3394 DIELabel *L = cast<DIELabel>(Values[i]);
3395 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3397 Values[i]->EmitValue(Asm, Form);
3400 case dwarf::DW_AT_accessibility: {
3401 if (Asm->isVerbose()) {
3402 DIEInteger *V = cast<DIEInteger>(Values[i]);
3403 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3405 Values[i]->EmitValue(Asm, Form);
3409 // Emit an attribute using the defined form.
3410 Values[i]->EmitValue(Asm, Form);
3415 // Emit the DIE children if any.
3416 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3417 const std::vector<DIE *> &Children = Die->getChildren();
3419 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3420 emitDIE(Children[j]);
3422 if (Asm->isVerbose())
3423 Asm->OutStreamer.AddComment("End Of Children Mark");
3428 /// emitDebugInfo - Emit the debug info section.
3430 void DwarfDebug::emitDebugInfo() {
3431 // Start debug info section.
3432 Asm->OutStreamer.SwitchSection(
3433 Asm->getObjFileLowering().getDwarfInfoSection());
3434 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3435 E = CUMap.end(); I != E; ++I) {
3436 CompileUnit *TheCU = I->second;
3437 DIE *Die = TheCU->getCUDie();
3439 // Emit the compile units header.
3440 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3443 // Emit size of content not including length itself
3444 unsigned ContentSize = Die->getSize() +
3445 sizeof(int16_t) + // DWARF version number
3446 sizeof(int32_t) + // Offset Into Abbrev. Section
3447 sizeof(int8_t) + // Pointer Size (in bytes)
3448 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3450 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3451 Asm->EmitInt32(ContentSize);
3452 Asm->OutStreamer.AddComment("DWARF version number");
3453 Asm->EmitInt16(dwarf::DWARF_VERSION);
3454 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3455 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3456 DwarfAbbrevSectionSym);
3457 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3458 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3461 // FIXME - extra padding for gdb bug.
3462 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3467 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3471 /// emitAbbreviations - Emit the abbreviation section.
3473 void DwarfDebug::emitAbbreviations() const {
3474 // Check to see if it is worth the effort.
3475 if (!Abbreviations.empty()) {
3476 // Start the debug abbrev section.
3477 Asm->OutStreamer.SwitchSection(
3478 Asm->getObjFileLowering().getDwarfAbbrevSection());
3480 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3482 // For each abbrevation.
3483 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3484 // Get abbreviation data
3485 const DIEAbbrev *Abbrev = Abbreviations[i];
3487 // Emit the abbrevations code (base 1 index.)
3488 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3490 // Emit the abbreviations data.
3494 // Mark end of abbreviations.
3495 Asm->EmitULEB128(0, "EOM(3)");
3497 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3501 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3502 /// the line matrix.
3504 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3505 // Define last address of section.
3506 Asm->OutStreamer.AddComment("Extended Op");
3509 Asm->OutStreamer.AddComment("Op size");
3510 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3511 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3512 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3514 Asm->OutStreamer.AddComment("Section end label");
3516 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3517 Asm->getTargetData().getPointerSize(),
3520 // Mark end of matrix.
3521 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3527 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3529 void DwarfDebug::emitCommonDebugFrame() {
3530 if (!Asm->MAI->doesDwarfRequireFrameSection())
3533 int stackGrowth = Asm->getTargetData().getPointerSize();
3534 if (Asm->TM.getFrameLowering()->getStackGrowthDirection() ==
3535 TargetFrameLowering::StackGrowsDown)
3538 // Start the dwarf frame section.
3539 Asm->OutStreamer.SwitchSection(
3540 Asm->getObjFileLowering().getDwarfFrameSection());
3542 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3543 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3544 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3545 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3547 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3548 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3549 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3550 Asm->OutStreamer.AddComment("CIE Version");
3551 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3552 Asm->OutStreamer.AddComment("CIE Augmentation");
3553 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3554 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3555 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3556 Asm->OutStreamer.AddComment("CIE RA Column");
3557 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3558 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
3559 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3561 std::vector<MachineMove> Moves;
3562 TFI->getInitialFrameState(Moves);
3564 Asm->EmitFrameMoves(Moves, 0, false);
3566 Asm->EmitAlignment(2);
3567 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3570 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3573 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3574 if (!Asm->MAI->doesDwarfRequireFrameSection())
3577 // Start the dwarf frame section.
3578 Asm->OutStreamer.SwitchSection(
3579 Asm->getObjFileLowering().getDwarfFrameSection());
3581 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3582 MCSymbol *DebugFrameBegin =
3583 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3584 MCSymbol *DebugFrameEnd =
3585 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3586 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3588 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3590 Asm->OutStreamer.AddComment("FDE CIE offset");
3591 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3592 DwarfFrameSectionSym);
3594 Asm->OutStreamer.AddComment("FDE initial location");
3595 MCSymbol *FuncBeginSym =
3596 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3597 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3598 Asm->getTargetData().getPointerSize(),
3602 Asm->OutStreamer.AddComment("FDE address range");
3603 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3604 FuncBeginSym, Asm->getTargetData().getPointerSize());
3606 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3608 Asm->EmitAlignment(2);
3609 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3612 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3614 void DwarfDebug::emitDebugPubNames() {
3615 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3616 E = CUMap.end(); I != E; ++I) {
3617 CompileUnit *TheCU = I->second;
3618 // Start the dwarf pubnames section.
3619 Asm->OutStreamer.SwitchSection(
3620 Asm->getObjFileLowering().getDwarfPubNamesSection());
3622 Asm->OutStreamer.AddComment("Length of Public Names Info");
3623 Asm->EmitLabelDifference(
3624 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3625 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3627 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3630 Asm->OutStreamer.AddComment("DWARF Version");
3631 Asm->EmitInt16(dwarf::DWARF_VERSION);
3633 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3634 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3635 DwarfInfoSectionSym);
3637 Asm->OutStreamer.AddComment("Compilation Unit Length");
3638 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3639 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3642 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3643 for (StringMap<DIE*>::const_iterator
3644 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3645 const char *Name = GI->getKeyData();
3646 DIE *Entity = GI->second;
3648 Asm->OutStreamer.AddComment("DIE offset");
3649 Asm->EmitInt32(Entity->getOffset());
3651 if (Asm->isVerbose())
3652 Asm->OutStreamer.AddComment("External Name");
3653 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3656 Asm->OutStreamer.AddComment("End Mark");
3658 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3663 void DwarfDebug::emitDebugPubTypes() {
3664 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3665 E = CUMap.end(); I != E; ++I) {
3666 CompileUnit *TheCU = I->second;
3667 // Start the dwarf pubnames section.
3668 Asm->OutStreamer.SwitchSection(
3669 Asm->getObjFileLowering().getDwarfPubTypesSection());
3670 Asm->OutStreamer.AddComment("Length of Public Types Info");
3671 Asm->EmitLabelDifference(
3672 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3673 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3675 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3678 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3679 Asm->EmitInt16(dwarf::DWARF_VERSION);
3681 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3682 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3683 DwarfInfoSectionSym);
3685 Asm->OutStreamer.AddComment("Compilation Unit Length");
3686 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3687 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3690 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3691 for (StringMap<DIE*>::const_iterator
3692 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3693 const char *Name = GI->getKeyData();
3694 DIE * Entity = GI->second;
3696 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3697 Asm->EmitInt32(Entity->getOffset());
3699 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3700 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3703 Asm->OutStreamer.AddComment("End Mark");
3705 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3710 /// emitDebugStr - Emit visible names into a debug str section.
3712 void DwarfDebug::emitDebugStr() {
3713 // Check to see if it is worth the effort.
3714 if (StringPool.empty()) return;
3716 // Start the dwarf str section.
3717 Asm->OutStreamer.SwitchSection(
3718 Asm->getObjFileLowering().getDwarfStrSection());
3720 // Get all of the string pool entries and put them in an array by their ID so
3721 // we can sort them.
3722 SmallVector<std::pair<unsigned,
3723 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3725 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3726 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3727 Entries.push_back(std::make_pair(I->second.second, &*I));
3729 array_pod_sort(Entries.begin(), Entries.end());
3731 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3732 // Emit a label for reference from debug information entries.
3733 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3735 // Emit the string itself.
3736 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3740 /// emitDebugLoc - Emit visible names into a debug loc section.
3742 void DwarfDebug::emitDebugLoc() {
3743 if (DotDebugLocEntries.empty())
3746 for (SmallVector<DotDebugLocEntry, 4>::iterator
3747 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3749 DotDebugLocEntry &Entry = *I;
3750 if (I + 1 != DotDebugLocEntries.end())
3754 // Start the dwarf loc section.
3755 Asm->OutStreamer.SwitchSection(
3756 Asm->getObjFileLowering().getDwarfLocSection());
3757 unsigned char Size = Asm->getTargetData().getPointerSize();
3758 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3760 for (SmallVector<DotDebugLocEntry, 4>::iterator
3761 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3762 I != E; ++I, ++index) {
3763 DotDebugLocEntry &Entry = *I;
3764 if (Entry.isMerged()) continue;
3765 if (Entry.isEmpty()) {
3766 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3767 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3768 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3770 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3771 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3772 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3773 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3774 if (int Offset = Entry.Loc.getOffset()) {
3775 // If the value is at a certain offset from frame register then
3777 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3778 Asm->OutStreamer.AddComment("Loc expr size");
3779 Asm->EmitInt16(1 + OffsetSize);
3780 Asm->OutStreamer.AddComment(
3781 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3782 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3783 Asm->OutStreamer.AddComment("Offset");
3784 Asm->EmitSLEB128(Offset);
3787 Asm->OutStreamer.AddComment("Loc expr size");
3789 Asm->OutStreamer.AddComment(
3790 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3791 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3793 Asm->OutStreamer.AddComment("Loc expr size");
3794 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3795 Asm->EmitInt8(dwarf::DW_OP_regx);
3796 Asm->EmitULEB128(Reg);
3803 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3805 void DwarfDebug::EmitDebugARanges() {
3806 // Start the dwarf aranges section.
3807 Asm->OutStreamer.SwitchSection(
3808 Asm->getObjFileLowering().getDwarfARangesSection());
3811 /// emitDebugRanges - Emit visible names into a debug ranges section.
3813 void DwarfDebug::emitDebugRanges() {
3814 // Start the dwarf ranges section.
3815 Asm->OutStreamer.SwitchSection(
3816 Asm->getObjFileLowering().getDwarfRangesSection());
3817 unsigned char Size = Asm->getTargetData().getPointerSize();
3818 for (SmallVector<const MCSymbol *, 8>::iterator
3819 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3822 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3824 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3828 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3830 void DwarfDebug::emitDebugMacInfo() {
3831 if (const MCSection *LineInfo =
3832 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3833 // Start the dwarf macinfo section.
3834 Asm->OutStreamer.SwitchSection(LineInfo);
3838 /// emitDebugInlineInfo - Emit inline info using following format.
3840 /// 1. length of section
3841 /// 2. Dwarf version number
3842 /// 3. address size.
3844 /// Entries (one "entry" for each function that was inlined):
3846 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3847 /// otherwise offset into __debug_str for regular function name.
3848 /// 2. offset into __debug_str section for regular function name.
3849 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3850 /// instances for the function.
3852 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3853 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3854 /// __debug_info section, and the low_pc is the starting address for the
3855 /// inlining instance.
3856 void DwarfDebug::emitDebugInlineInfo() {
3857 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3863 Asm->OutStreamer.SwitchSection(
3864 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3866 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3867 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3868 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3870 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3872 Asm->OutStreamer.AddComment("Dwarf Version");
3873 Asm->EmitInt16(dwarf::DWARF_VERSION);
3874 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3875 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3877 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3878 E = InlinedSPNodes.end(); I != E; ++I) {
3880 const MDNode *Node = *I;
3881 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3882 = InlineInfo.find(Node);
3883 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3884 DISubprogram SP(Node);
3885 StringRef LName = SP.getLinkageName();
3886 StringRef Name = SP.getName();
3888 Asm->OutStreamer.AddComment("MIPS linkage name");
3889 if (LName.empty()) {
3890 Asm->OutStreamer.EmitBytes(Name, 0);
3891 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3893 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3894 DwarfStrSectionSym);
3896 Asm->OutStreamer.AddComment("Function name");
3897 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3898 Asm->EmitULEB128(Labels.size(), "Inline count");
3900 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3901 LE = Labels.end(); LI != LE; ++LI) {
3902 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3903 Asm->EmitInt32(LI->second->getOffset());
3905 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3906 Asm->OutStreamer.EmitSymbolValue(LI->first,
3907 Asm->getTargetData().getPointerSize(),0);
3911 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));