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 assert(FileID && "Invalid file id");
521 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
522 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
525 /// addSourceLine - Add location information to specified debug information
527 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
528 // Verify global variable.
532 unsigned Line = G.getLineNumber();
535 unsigned FileID = GetOrCreateSourceID(G.getContext().getFilename());
536 assert(FileID && "Invalid file id");
537 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
538 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
541 /// addSourceLine - Add location information to specified debug information
543 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
544 // Verify subprogram.
547 // If the line number is 0, don't add it.
548 if (SP.getLineNumber() == 0)
551 unsigned Line = SP.getLineNumber();
552 if (!SP.getContext().Verify())
554 unsigned FileID = GetOrCreateSourceID(SP.getFilename());
555 assert(FileID && "Invalid file id");
556 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
557 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
560 /// addSourceLine - Add location information to specified debug information
562 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
567 unsigned Line = Ty.getLineNumber();
568 if (Line == 0 || !Ty.getContext().Verify())
570 unsigned FileID = GetOrCreateSourceID(Ty.getFilename());
571 assert(FileID && "Invalid file id");
572 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
573 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
576 /// addSourceLine - Add location information to specified debug information
578 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
583 unsigned Line = NS.getLineNumber();
586 StringRef FN = NS.getFilename();
588 unsigned FileID = GetOrCreateSourceID(FN);
589 assert(FileID && "Invalid file id");
590 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
591 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
594 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based
595 /// on provided frame index.
596 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) {
597 MachineLocation Location;
599 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
600 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
601 Location.set(FrameReg, Offset);
603 if (DV->variableHasComplexAddress())
604 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
605 else if (DV->isBlockByrefVariable())
606 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
608 addAddress(Die, dwarf::DW_AT_location, Location);
611 /// addComplexAddress - Start with the address based on the location provided,
612 /// and generate the DWARF information necessary to find the actual variable
613 /// given the extra address information encoded in the DIVariable, starting from
614 /// the starting location. Add the DWARF information to the die.
616 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
618 const MachineLocation &Location) {
619 DIType Ty = DV->getType();
621 // Decode the original location, and use that as the start of the byref
622 // variable's location.
623 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
624 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
625 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
627 if (Location.isReg()) {
629 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
631 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
632 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
636 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
638 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
639 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
642 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
645 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
646 uint64_t Element = DV->getAddrElement(i);
648 if (Element == DIBuilder::OpPlus) {
649 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
650 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
651 } else if (Element == DIBuilder::OpDeref) {
652 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
653 } else llvm_unreachable("unknown DIBuilder Opcode");
656 // Now attach the location information to the DIE.
657 addBlock(Die, Attribute, 0, Block);
660 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
661 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
662 gives the variable VarName either the struct, or a pointer to the struct, as
663 its type. This is necessary for various behind-the-scenes things the
664 compiler needs to do with by-reference variables in Blocks.
666 However, as far as the original *programmer* is concerned, the variable
667 should still have type 'SomeType', as originally declared.
669 The function getBlockByrefType dives into the __Block_byref_x_VarName
670 struct to find the original type of the variable, which is then assigned to
671 the variable's Debug Information Entry as its real type. So far, so good.
672 However now the debugger will expect the variable VarName to have the type
673 SomeType. So we need the location attribute for the variable to be an
674 expression that explains to the debugger how to navigate through the
675 pointers and struct to find the actual variable of type SomeType.
677 The following function does just that. We start by getting
678 the "normal" location for the variable. This will be the location
679 of either the struct __Block_byref_x_VarName or the pointer to the
680 struct __Block_byref_x_VarName.
682 The struct will look something like:
684 struct __Block_byref_x_VarName {
686 struct __Block_byref_x_VarName *forwarding;
687 ... <various other fields>
689 ... <maybe more fields>
692 If we are given the struct directly (as our starting point) we
693 need to tell the debugger to:
695 1). Add the offset of the forwarding field.
697 2). Follow that pointer to get the real __Block_byref_x_VarName
698 struct to use (the real one may have been copied onto the heap).
700 3). Add the offset for the field VarName, to find the actual variable.
702 If we started with a pointer to the struct, then we need to
703 dereference that pointer first, before the other steps.
704 Translating this into DWARF ops, we will need to append the following
705 to the current location description for the variable:
707 DW_OP_deref -- optional, if we start with a pointer
708 DW_OP_plus_uconst <forward_fld_offset>
710 DW_OP_plus_uconst <varName_fld_offset>
712 That is what this function does. */
714 /// addBlockByrefAddress - Start with the address based on the location
715 /// provided, and generate the DWARF information necessary to find the
716 /// actual Block variable (navigating the Block struct) based on the
717 /// starting location. Add the DWARF information to the die. For
718 /// more information, read large comment just above here.
720 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
722 const MachineLocation &Location) {
723 DIType Ty = DV->getType();
725 unsigned Tag = Ty.getTag();
726 bool isPointer = false;
728 StringRef varName = DV->getName();
730 if (Tag == dwarf::DW_TAG_pointer_type) {
731 DIDerivedType DTy = DIDerivedType(Ty);
732 TmpTy = DTy.getTypeDerivedFrom();
736 DICompositeType blockStruct = DICompositeType(TmpTy);
738 // Find the __forwarding field and the variable field in the __Block_byref
740 DIArray Fields = blockStruct.getTypeArray();
741 DIDescriptor varField = DIDescriptor();
742 DIDescriptor forwardingField = DIDescriptor();
744 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
745 DIDescriptor Element = Fields.getElement(i);
746 DIDerivedType DT = DIDerivedType(Element);
747 StringRef fieldName = DT.getName();
748 if (fieldName == "__forwarding")
749 forwardingField = Element;
750 else if (fieldName == varName)
754 // Get the offsets for the forwarding field and the variable field.
755 unsigned forwardingFieldOffset =
756 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
757 unsigned varFieldOffset =
758 DIDerivedType(varField).getOffsetInBits() >> 3;
760 // Decode the original location, and use that as the start of the byref
761 // variable's location.
762 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
763 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
764 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
766 if (Location.isReg()) {
768 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
771 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
775 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
777 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
778 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
781 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
784 // If we started with a pointer to the __Block_byref... struct, then
785 // the first thing we need to do is dereference the pointer (DW_OP_deref).
787 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
789 // Next add the offset for the '__forwarding' field:
790 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
791 // adding the offset if it's 0.
792 if (forwardingFieldOffset > 0) {
793 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
794 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
797 // Now dereference the __forwarding field to get to the real __Block_byref
798 // struct: DW_OP_deref.
799 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
801 // Now that we've got the real __Block_byref... struct, add the offset
802 // for the variable's field to get to the location of the actual variable:
803 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
804 if (varFieldOffset > 0) {
805 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
806 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
809 // Now attach the location information to the DIE.
810 addBlock(Die, Attribute, 0, Block);
813 /// addAddress - Add an address attribute to a die based on the location
815 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
816 const MachineLocation &Location) {
817 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
818 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
819 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
821 if (RI->getFrameRegister(*Asm->MF) == Location.getReg()
822 && Location.getOffset()) {
823 // If variable offset is based in frame register then use fbreg.
824 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
825 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
826 addBlock(Die, Attribute, 0, Block);
830 if (Location.isReg()) {
832 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
834 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
835 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
839 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
841 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
842 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
845 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
848 addBlock(Die, Attribute, 0, Block);
851 /// addRegisterAddress - Add register location entry in variable DIE.
852 bool DwarfDebug::addRegisterAddress(DIE *Die, const MachineOperand &MO) {
853 assert (MO.isReg() && "Invalid machine operand!");
856 MachineLocation Location;
857 Location.set(MO.getReg());
858 addAddress(Die, dwarf::DW_AT_location, Location);
862 /// addConstantValue - Add constant value entry in variable DIE.
863 bool DwarfDebug::addConstantValue(DIE *Die, const MachineOperand &MO) {
864 assert (MO.isImm() && "Invalid machine operand!");
865 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
866 unsigned Imm = MO.getImm();
867 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
868 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
872 /// addConstantFPValue - Add constant value entry in variable DIE.
873 bool DwarfDebug::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
874 assert (MO.isFPImm() && "Invalid machine operand!");
875 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
876 APFloat FPImm = MO.getFPImm()->getValueAPF();
878 // Get the raw data form of the floating point.
879 const APInt FltVal = FPImm.bitcastToAPInt();
880 const char *FltPtr = (const char*)FltVal.getRawData();
882 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
883 bool LittleEndian = Asm->getTargetData().isLittleEndian();
884 int Incr = (LittleEndian ? 1 : -1);
885 int Start = (LittleEndian ? 0 : NumBytes - 1);
886 int Stop = (LittleEndian ? NumBytes : -1);
888 // Output the constant to DWARF one byte at a time.
889 for (; Start != Stop; Start += Incr)
890 addUInt(Block, 0, dwarf::DW_FORM_data1,
891 (unsigned char)0xFF & FltPtr[Start]);
893 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
897 /// addConstantValue - Add constant value entry in variable DIE.
898 bool DwarfDebug::addConstantValue(DIE *Die, ConstantInt *CI,
900 if (CI->getBitWidth() <= 64) {
902 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
905 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
910 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
912 // Get the raw data form of the large APInt.
913 const APInt Val = CI->getValue();
914 const char *Ptr = (const char*)Val.getRawData();
916 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
917 bool LittleEndian = Asm->getTargetData().isLittleEndian();
918 int Incr = (LittleEndian ? 1 : -1);
919 int Start = (LittleEndian ? 0 : NumBytes - 1);
920 int Stop = (LittleEndian ? NumBytes : -1);
922 // Output the constant to DWARF one byte at a time.
923 for (; Start != Stop; Start += Incr)
924 addUInt(Block, 0, dwarf::DW_FORM_data1,
925 (unsigned char)0xFF & Ptr[Start]);
927 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
931 /// addToContextOwner - Add Die into the list of its context owner's children.
932 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
933 if (Context.isType()) {
934 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
935 ContextDIE->addChild(Die);
936 } else if (Context.isNameSpace()) {
937 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
938 ContextDIE->addChild(Die);
939 } else if (Context.isSubprogram()) {
940 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context));
941 ContextDIE->addChild(Die);
942 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
943 ContextDIE->addChild(Die);
945 getCompileUnit(Context)->addDie(Die);
948 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
950 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
951 CompileUnit *TypeCU = getCompileUnit(Ty);
952 DIE *TyDIE = TypeCU->getDIE(Ty);
957 TyDIE = new DIE(dwarf::DW_TAG_base_type);
958 TypeCU->insertDIE(Ty, TyDIE);
959 if (Ty.isBasicType())
960 constructTypeDIE(*TyDIE, DIBasicType(Ty));
961 else if (Ty.isCompositeType())
962 constructTypeDIE(*TyDIE, DICompositeType(Ty));
964 assert(Ty.isDerivedType() && "Unknown kind of DIType");
965 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
968 addToContextOwner(TyDIE, Ty.getContext());
972 /// addType - Add a new type attribute to the specified entity.
973 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
977 // Check for pre-existence.
978 CompileUnit *TypeCU = getCompileUnit(Ty);
979 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
980 // If it exists then use the existing value.
982 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
987 DIE *Buffer = getOrCreateTypeDIE(Ty);
990 Entry = createDIEEntry(Buffer);
991 TypeCU->insertDIEEntry(Ty, Entry);
993 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
996 /// constructTypeDIE - Construct basic type die from DIBasicType.
997 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
998 // Get core information.
999 StringRef Name = BTy.getName();
1000 Buffer.setTag(dwarf::DW_TAG_base_type);
1001 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1004 // Add name if not anonymous or intermediate type.
1006 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1007 uint64_t Size = BTy.getSizeInBits() >> 3;
1008 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1011 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1012 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1013 // Get core information.
1014 StringRef Name = DTy.getName();
1015 uint64_t Size = DTy.getSizeInBits() >> 3;
1016 unsigned Tag = DTy.getTag();
1018 // FIXME - Workaround for templates.
1019 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
1023 // Map to main type, void will not have a type.
1024 DIType FromTy = DTy.getTypeDerivedFrom();
1025 addType(&Buffer, FromTy);
1027 // Add name if not anonymous or intermediate type.
1029 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1031 // Add size if non-zero (derived types might be zero-sized.)
1033 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1035 // Add source line info if available and TyDesc is not a forward declaration.
1036 if (!DTy.isForwardDecl())
1037 addSourceLine(&Buffer, DTy);
1040 /// constructTypeDIE - Construct type DIE from DICompositeType.
1041 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1042 // Get core information.
1043 StringRef Name = CTy.getName();
1045 uint64_t Size = CTy.getSizeInBits() >> 3;
1046 unsigned Tag = CTy.getTag();
1050 case dwarf::DW_TAG_vector_type:
1051 case dwarf::DW_TAG_array_type:
1052 constructArrayTypeDIE(Buffer, &CTy);
1054 case dwarf::DW_TAG_enumeration_type: {
1055 DIArray Elements = CTy.getTypeArray();
1057 // Add enumerators to enumeration type.
1058 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1059 DIE *ElemDie = NULL;
1060 DIDescriptor Enum(Elements.getElement(i));
1061 if (Enum.isEnumerator()) {
1062 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1063 Buffer.addChild(ElemDie);
1068 case dwarf::DW_TAG_subroutine_type: {
1070 DIArray Elements = CTy.getTypeArray();
1071 DIDescriptor RTy = Elements.getElement(0);
1072 addType(&Buffer, DIType(RTy));
1074 bool isPrototyped = true;
1076 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1077 DIDescriptor Ty = Elements.getElement(i);
1078 if (Ty.isUnspecifiedParameter()) {
1079 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1080 Buffer.addChild(Arg);
1081 isPrototyped = false;
1083 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1084 addType(Arg, DIType(Ty));
1085 Buffer.addChild(Arg);
1088 // Add prototype flag.
1090 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1093 case dwarf::DW_TAG_structure_type:
1094 case dwarf::DW_TAG_union_type:
1095 case dwarf::DW_TAG_class_type: {
1096 // Add elements to structure type.
1097 DIArray Elements = CTy.getTypeArray();
1099 // A forward struct declared type may not have elements available.
1100 unsigned N = Elements.getNumElements();
1104 // Add elements to structure type.
1105 for (unsigned i = 0; i < N; ++i) {
1106 DIDescriptor Element = Elements.getElement(i);
1107 DIE *ElemDie = NULL;
1108 if (Element.isSubprogram()) {
1109 DISubprogram SP(Element);
1110 ElemDie = createSubprogramDIE(DISubprogram(Element));
1111 if (SP.isProtected())
1112 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1113 dwarf::DW_ACCESS_protected);
1114 else if (SP.isPrivate())
1115 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1116 dwarf::DW_ACCESS_private);
1118 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1119 dwarf::DW_ACCESS_public);
1120 if (SP.isExplicit())
1121 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
1123 else if (Element.isVariable()) {
1124 DIVariable DV(Element);
1125 ElemDie = new DIE(dwarf::DW_TAG_variable);
1126 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1128 addType(ElemDie, DV.getType());
1129 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1130 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1131 addSourceLine(ElemDie, DV);
1132 } else if (Element.isDerivedType())
1133 ElemDie = createMemberDIE(DIDerivedType(Element));
1136 Buffer.addChild(ElemDie);
1139 if (CTy.isAppleBlockExtension())
1140 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1142 unsigned RLang = CTy.getRunTimeLang();
1144 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1145 dwarf::DW_FORM_data1, RLang);
1147 DICompositeType ContainingType = CTy.getContainingType();
1148 if (DIDescriptor(ContainingType).isCompositeType())
1149 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1150 getOrCreateTypeDIE(DIType(ContainingType)));
1152 DIDescriptor Context = CTy.getContext();
1153 addToContextOwner(&Buffer, Context);
1156 if (Tag == dwarf::DW_TAG_class_type) {
1157 DIArray TParams = CTy.getTemplateParams();
1158 unsigned N = TParams.getNumElements();
1159 // Add template parameters.
1160 for (unsigned i = 0; i < N; ++i) {
1161 DIDescriptor Element = TParams.getElement(i);
1162 if (Element.isTemplateTypeParameter())
1163 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
1164 DITemplateTypeParameter(Element)));
1165 else if (Element.isTemplateValueParameter())
1166 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
1167 DITemplateValueParameter(Element)));
1176 // Add name if not anonymous or intermediate type.
1178 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1180 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1181 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1183 // Add size if non-zero (derived types might be zero-sized.)
1185 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1187 // Add zero size if it is not a forward declaration.
1188 if (CTy.isForwardDecl())
1189 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1191 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1194 // Add source line info if available.
1195 if (!CTy.isForwardDecl())
1196 addSourceLine(&Buffer, CTy);
1200 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1201 /// for the given DITemplateTypeParameter.
1203 DwarfDebug::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1204 CompileUnit *TypeCU = getCompileUnit(TP);
1205 DIE *ParamDIE = TypeCU->getDIE(TP);
1209 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1210 addType(ParamDIE, TP.getType());
1211 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
1215 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1216 /// for the given DITemplateValueParameter.
1218 DwarfDebug::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
1219 CompileUnit *TVCU = getCompileUnit(TPV);
1220 DIE *ParamDIE = TVCU->getDIE(TPV);
1224 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
1225 addType(ParamDIE, TPV.getType());
1226 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
1227 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1232 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1233 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1234 int64_t L = SR.getLo();
1235 int64_t H = SR.getHi();
1236 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1238 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1240 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1241 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1243 Buffer.addChild(DW_Subrange);
1246 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1247 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1248 DICompositeType *CTy) {
1249 Buffer.setTag(dwarf::DW_TAG_array_type);
1250 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1251 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1253 // Emit derived type.
1254 addType(&Buffer, CTy->getTypeDerivedFrom());
1255 DIArray Elements = CTy->getTypeArray();
1257 // Get an anonymous type for index type.
1258 CompileUnit *TheCU = getCompileUnit(*CTy);
1259 DIE *IdxTy = TheCU->getIndexTyDie();
1261 // Construct an anonymous type for index type.
1262 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1263 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1264 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1265 dwarf::DW_ATE_signed);
1266 TheCU->addDie(IdxTy);
1267 TheCU->setIndexTyDie(IdxTy);
1270 // Add subranges to array type.
1271 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1272 DIDescriptor Element = Elements.getElement(i);
1273 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1274 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1278 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1279 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1280 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1281 StringRef Name = ETy.getName();
1282 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1283 int64_t Value = ETy.getEnumValue();
1284 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1288 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1289 /// printer to not emit usual symbol prefix before the symbol name is used then
1290 /// return linkage name after skipping this special LLVM prefix.
1291 static StringRef getRealLinkageName(StringRef LinkageName) {
1293 if (LinkageName.startswith(StringRef(&One, 1)))
1294 return LinkageName.substr(1);
1298 /// createMemberDIE - Create new member DIE.
1299 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1300 DIE *MemberDie = new DIE(DT.getTag());
1301 StringRef Name = DT.getName();
1303 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1305 addType(MemberDie, DT.getTypeDerivedFrom());
1307 addSourceLine(MemberDie, DT);
1309 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1310 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1312 uint64_t Size = DT.getSizeInBits();
1313 uint64_t FieldSize = DT.getOriginalTypeSize();
1315 if (Size != FieldSize) {
1317 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1318 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1320 uint64_t Offset = DT.getOffsetInBits();
1321 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1322 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1323 uint64_t FieldOffset = (HiMark - FieldSize);
1324 Offset -= FieldOffset;
1326 // Maybe we need to work from the other end.
1327 if (Asm->getTargetData().isLittleEndian())
1328 Offset = FieldSize - (Offset + Size);
1329 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1331 // Here WD_AT_data_member_location points to the anonymous
1332 // field that includes this bit field.
1333 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1336 // This is not a bitfield.
1337 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1339 if (DT.getTag() == dwarf::DW_TAG_inheritance
1340 && DT.isVirtual()) {
1342 // For C++, virtual base classes are not at fixed offset. Use following
1343 // expression to extract appropriate offset from vtable.
1344 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1346 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1347 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1348 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1349 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1350 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1351 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1352 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1353 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1355 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1358 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1360 if (DT.isProtected())
1361 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1362 dwarf::DW_ACCESS_protected);
1363 else if (DT.isPrivate())
1364 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1365 dwarf::DW_ACCESS_private);
1366 // Otherwise C++ member and base classes are considered public.
1367 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1368 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1369 dwarf::DW_ACCESS_public);
1371 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1372 dwarf::DW_VIRTUALITY_virtual);
1376 /// createSubprogramDIE - Create new DIE using SP.
1377 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
1378 CompileUnit *SPCU = getCompileUnit(SP);
1379 DIE *SPDie = SPCU->getDIE(SP);
1383 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1384 // Constructors and operators for anonymous aggregates do not have names.
1385 if (!SP.getName().empty())
1386 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1388 StringRef LinkageName = SP.getLinkageName();
1389 if (!LinkageName.empty())
1390 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1391 getRealLinkageName(LinkageName));
1393 addSourceLine(SPDie, SP);
1395 if (SP.isPrototyped())
1396 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1399 DICompositeType SPTy = SP.getType();
1400 DIArray Args = SPTy.getTypeArray();
1401 unsigned SPTag = SPTy.getTag();
1403 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1404 addType(SPDie, SPTy);
1406 addType(SPDie, DIType(Args.getElement(0)));
1408 unsigned VK = SP.getVirtuality();
1410 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1411 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1412 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1413 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1414 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1415 ContainingTypeMap.insert(std::make_pair(SPDie,
1416 SP.getContainingType()));
1419 if (!SP.isDefinition()) {
1420 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1422 // Add arguments. Do not add arguments for subprogram definition. They will
1423 // be handled while processing variables.
1424 DICompositeType SPTy = SP.getType();
1425 DIArray Args = SPTy.getTypeArray();
1426 unsigned SPTag = SPTy.getTag();
1428 if (SPTag == dwarf::DW_TAG_subroutine_type)
1429 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1430 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1431 DIType ATy = DIType(DIType(Args.getElement(i)));
1433 if (ATy.isArtificial())
1434 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1435 SPDie->addChild(Arg);
1439 if (SP.isArtificial())
1440 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1442 if (!SP.isLocalToUnit())
1443 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1445 if (SP.isOptimized())
1446 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1448 if (unsigned isa = Asm->getISAEncoding()) {
1449 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1452 // DW_TAG_inlined_subroutine may refer to this DIE.
1453 SPCU->insertDIE(SP, SPDie);
1455 // Add to context owner.
1456 addToContextOwner(SPDie, SP.getContext());
1461 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1462 assert(N && "Invalid Scope encoding!");
1464 DbgScope *AScope = AbstractScopes.lookup(N);
1468 DbgScope *Parent = NULL;
1470 DIDescriptor Scope(N);
1471 if (Scope.isLexicalBlock()) {
1472 DILexicalBlock DB(N);
1473 DIDescriptor ParentDesc = DB.getContext();
1474 Parent = getOrCreateAbstractScope(ParentDesc);
1477 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1480 Parent->addScope(AScope);
1481 AScope->setAbstractScope();
1482 AbstractScopes[N] = AScope;
1483 if (DIDescriptor(N).isSubprogram())
1484 AbstractScopesList.push_back(AScope);
1488 /// isSubprogramContext - Return true if Context is either a subprogram
1489 /// or another context nested inside a subprogram.
1490 static bool isSubprogramContext(const MDNode *Context) {
1493 DIDescriptor D(Context);
1494 if (D.isSubprogram())
1497 return isSubprogramContext(DIType(Context).getContext());
1501 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1502 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1503 /// If there are global variables in this scope then create and insert
1504 /// DIEs for these variables.
1505 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1506 CompileUnit *SPCU = getCompileUnit(SPNode);
1507 DIE *SPDie = SPCU->getDIE(SPNode);
1509 assert(SPDie && "Unable to find subprogram DIE!");
1510 DISubprogram SP(SPNode);
1512 // There is not any need to generate specification DIE for a function
1513 // defined at compile unit level. If a function is defined inside another
1514 // function then gdb prefers the definition at top level and but does not
1515 // expect specification DIE in parent function. So avoid creating
1516 // specification DIE for a function defined inside a function.
1517 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1518 !SP.getContext().isFile() &&
1519 !isSubprogramContext(SP.getContext())) {
1520 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1523 DICompositeType SPTy = SP.getType();
1524 DIArray Args = SPTy.getTypeArray();
1525 unsigned SPTag = SPTy.getTag();
1526 if (SPTag == dwarf::DW_TAG_subroutine_type)
1527 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1528 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1529 DIType ATy = DIType(DIType(Args.getElement(i)));
1531 if (ATy.isArtificial())
1532 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1533 SPDie->addChild(Arg);
1535 DIE *SPDeclDie = SPDie;
1536 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1537 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1539 SPCU->addDie(SPDie);
1542 // Pick up abstract subprogram DIE.
1543 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1544 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1545 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1546 dwarf::DW_FORM_ref4, AbsSPDIE);
1547 SPCU->addDie(SPDie);
1550 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1551 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1552 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1553 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1554 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1555 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1556 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1561 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1562 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1563 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1565 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1566 if (Scope->isAbstractScope())
1569 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1573 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1574 if (Ranges.size() > 1) {
1575 // .debug_range section has not been laid out yet. Emit offset in
1576 // .debug_range as a uint, size 4, for now. emitDIE will handle
1577 // DW_AT_ranges appropriately.
1578 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1579 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1580 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1581 RE = Ranges.end(); RI != RE; ++RI) {
1582 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1583 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1585 DebugRangeSymbols.push_back(NULL);
1586 DebugRangeSymbols.push_back(NULL);
1590 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1591 const MCSymbol *End = getLabelAfterInsn(RI->second);
1593 if (End == 0) return 0;
1595 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1596 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1598 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1599 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1604 /// constructInlinedScopeDIE - This scope represents inlined body of
1605 /// a function. Construct DIE to represent this concrete inlined copy
1606 /// of the function.
1607 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1609 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1610 assert (Ranges.empty() == false
1611 && "DbgScope does not have instruction markers!");
1613 // FIXME : .debug_inlined section specification does not clearly state how
1614 // to emit inlined scope that is split into multiple instruction ranges.
1615 // For now, use first instruction range and emit low_pc/high_pc pair and
1616 // corresponding .debug_inlined section entry for this pair.
1617 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1618 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1619 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1621 if (StartLabel == 0 || EndLabel == 0) {
1622 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1625 assert(StartLabel->isDefined() &&
1626 "Invalid starting label for an inlined scope!");
1627 assert(EndLabel->isDefined() &&
1628 "Invalid end label for an inlined scope!");
1630 if (!Scope->getScopeNode())
1632 DIScope DS(Scope->getScopeNode());
1633 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1635 DISubprogram InlinedSP = getDISubprogram(DS);
1636 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1637 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1638 assert(OriginDIE && "Unable to find Origin DIE!");
1639 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1640 dwarf::DW_FORM_ref4, OriginDIE);
1642 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1643 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1645 InlinedSubprogramDIEs.insert(OriginDIE);
1647 // Track the start label for this inlined function.
1648 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1649 I = InlineInfo.find(InlinedSP);
1651 if (I == InlineInfo.end()) {
1652 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1654 InlinedSPNodes.push_back(InlinedSP);
1656 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1658 DILocation DL(Scope->getInlinedAt());
1659 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1660 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1666 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1667 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1668 StringRef Name = DV->getName();
1672 // Translate tag to proper Dwarf tag. The result variable is dropped for
1675 switch (DV->getTag()) {
1676 case dwarf::DW_TAG_return_variable:
1678 case dwarf::DW_TAG_arg_variable:
1679 Tag = dwarf::DW_TAG_formal_parameter;
1681 case dwarf::DW_TAG_auto_variable: // fall thru
1683 Tag = dwarf::DW_TAG_variable;
1687 // Define variable debug information entry.
1688 DIE *VariableDie = new DIE(Tag);
1691 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1692 V2AVI = VarToAbstractVarMap.find(DV);
1693 if (V2AVI != VarToAbstractVarMap.end())
1694 AbsDIE = V2AVI->second->getDIE();
1697 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1698 dwarf::DW_FORM_ref4, AbsDIE);
1700 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1701 addSourceLine(VariableDie, DV->getVariable());
1703 // Add variable type.
1704 addType(VariableDie, DV->getType());
1707 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1708 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1709 else if (DIVariable(DV->getVariable()).isArtificial())
1710 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1712 if (Scope->isAbstractScope()) {
1713 DV->setDIE(VariableDie);
1717 // Add variable address.
1719 unsigned Offset = DV->getDotDebugLocOffset();
1720 if (Offset != ~0U) {
1721 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1722 Asm->GetTempSymbol("debug_loc", Offset));
1723 DV->setDIE(VariableDie);
1724 UseDotDebugLocEntry.insert(VariableDie);
1728 // Check if variable is described by a DBG_VALUE instruction.
1729 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1730 DbgVariableToDbgInstMap.find(DV);
1731 if (DVI != DbgVariableToDbgInstMap.end()) {
1732 const MachineInstr *DVInsn = DVI->second;
1733 bool updated = false;
1734 // FIXME : Handle getNumOperands != 3
1735 if (DVInsn->getNumOperands() == 3) {
1736 if (DVInsn->getOperand(0).isReg()) {
1737 const MachineOperand RegOp = DVInsn->getOperand(0);
1738 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1739 if (DVInsn->getOperand(1).isImm() &&
1740 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1741 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1744 updated = addRegisterAddress(VariableDie, RegOp);
1746 else if (DVInsn->getOperand(0).isImm())
1747 updated = addConstantValue(VariableDie, DVInsn->getOperand(0));
1748 else if (DVInsn->getOperand(0).isFPImm())
1750 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1752 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1753 if (Location.getReg()) {
1754 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1759 // If variableDie is not updated then DBG_VALUE instruction does not
1760 // have valid variable info.
1764 DV->setDIE(VariableDie);
1768 // .. else use frame index, if available.
1770 if (findVariableFrameIndex(DV, &FI))
1771 addVariableAddress(DV, VariableDie, FI);
1773 DV->setDIE(VariableDie);
1778 void DwarfDebug::addPubTypes(DISubprogram SP) {
1779 DICompositeType SPTy = SP.getType();
1780 unsigned SPTag = SPTy.getTag();
1781 if (SPTag != dwarf::DW_TAG_subroutine_type)
1784 DIArray Args = SPTy.getTypeArray();
1785 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1786 DIType ATy(Args.getElement(i));
1789 DICompositeType CATy = getDICompositeType(ATy);
1790 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1791 && !CATy.isForwardDecl()) {
1792 CompileUnit *TheCU = getCompileUnit(CATy);
1793 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1794 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1799 /// constructScopeDIE - Construct a DIE for this scope.
1800 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1801 if (!Scope || !Scope->getScopeNode())
1804 SmallVector <DIE *, 8> Children;
1806 // Collect arguments for current function.
1807 if (Scope == CurrentFnDbgScope)
1808 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
1809 if (DbgVariable *ArgDV = CurrentFnArguments[i])
1810 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
1811 Children.push_back(Arg);
1813 // Collect lexical scope childrens first.
1814 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1815 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
1816 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
1817 Children.push_back(Variable);
1818 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1819 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
1820 if (DIE *Nested = constructScopeDIE(Scopes[j]))
1821 Children.push_back(Nested);
1822 DIScope DS(Scope->getScopeNode());
1823 DIE *ScopeDIE = NULL;
1824 if (Scope->getInlinedAt())
1825 ScopeDIE = constructInlinedScopeDIE(Scope);
1826 else if (DS.isSubprogram()) {
1827 ProcessedSPNodes.insert(DS);
1828 if (Scope->isAbstractScope()) {
1829 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1830 // Note down abstract DIE.
1832 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1835 ScopeDIE = updateSubprogramScopeDIE(DS);
1838 // There is no need to emit empty lexical block DIE.
1839 if (Children.empty())
1841 ScopeDIE = constructLexicalScopeDIE(Scope);
1844 if (!ScopeDIE) return NULL;
1847 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
1848 E = Children.end(); I != E; ++I)
1849 ScopeDIE->addChild(*I);
1851 if (DS.isSubprogram())
1852 addPubTypes(DISubprogram(DS));
1857 /// GetOrCreateSourceID - Look up the source id with the given directory and
1858 /// source file names. If none currently exists, create a new id and insert it
1859 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1862 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName){
1863 // If FE did not provide a file name, then assume stdin.
1864 if (FileName.empty())
1865 return GetOrCreateSourceID("<stdin>");
1867 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
1868 if (Entry.getValue())
1869 return Entry.getValue();
1871 unsigned SrcId = SourceIdMap.size();
1872 Entry.setValue(SrcId);
1874 // Print out a .file directive to specify files for .loc directives.
1875 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, FileName);
1880 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1881 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1882 CompileUnit *TheCU = getCompileUnit(NS);
1883 DIE *NDie = TheCU->getDIE(NS);
1886 NDie = new DIE(dwarf::DW_TAG_namespace);
1887 TheCU->insertDIE(NS, NDie);
1888 if (!NS.getName().empty())
1889 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1890 addSourceLine(NDie, NS);
1891 addToContextOwner(NDie, NS.getContext());
1895 /// constructCompileUnit - Create new CompileUnit for the given
1896 /// metadata node with tag DW_TAG_compile_unit.
1897 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1898 DICompileUnit DIUnit(N);
1899 StringRef FN = DIUnit.getFilename();
1900 StringRef Dir = DIUnit.getDirectory();
1901 unsigned ID = GetOrCreateSourceID(FN);
1903 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1904 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1905 DIUnit.getProducer());
1906 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1907 DIUnit.getLanguage());
1908 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1909 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1910 // simplifies debug range entries.
1911 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1912 // DW_AT_stmt_list is a offset of line number information for this
1913 // compile unit in debug_line section.
1914 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1915 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1916 Asm->GetTempSymbol("section_line"));
1918 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1921 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1922 if (DIUnit.isOptimized())
1923 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1925 StringRef Flags = DIUnit.getFlags();
1927 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1929 unsigned RVer = DIUnit.getRunTimeVersion();
1931 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1932 dwarf::DW_FORM_data1, RVer);
1934 CompileUnit *NewCU = new CompileUnit(ID, Die);
1937 CUMap.insert(std::make_pair(N, NewCU));
1940 /// getCompielUnit - Get CompileUnit DIE.
1941 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1942 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1944 const MDNode *CUNode = NULL;
1945 if (D.isCompileUnit())
1947 else if (D.isSubprogram())
1948 CUNode = DISubprogram(N).getCompileUnit();
1949 else if (D.isType())
1950 CUNode = DIType(N).getCompileUnit();
1951 else if (D.isGlobalVariable())
1952 CUNode = DIGlobalVariable(N).getCompileUnit();
1953 else if (D.isVariable())
1954 CUNode = DIVariable(N).getCompileUnit();
1955 else if (D.isNameSpace())
1956 CUNode = DINameSpace(N).getCompileUnit();
1957 else if (D.isFile())
1958 CUNode = DIFile(N).getCompileUnit();
1962 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1963 = CUMap.find(CUNode);
1964 if (I == CUMap.end())
1969 /// isUnsignedDIType - Return true if type encoding is unsigned.
1970 static bool isUnsignedDIType(DIType Ty) {
1971 DIDerivedType DTy(Ty);
1973 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1975 DIBasicType BTy(Ty);
1977 unsigned Encoding = BTy.getEncoding();
1978 if (Encoding == dwarf::DW_ATE_unsigned ||
1979 Encoding == dwarf::DW_ATE_unsigned_char)
1985 // Return const exprssion if value is a GEP to access merged global
1987 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1988 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1989 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1990 if (!CE || CE->getNumOperands() != 3 ||
1991 CE->getOpcode() != Instruction::GetElementPtr)
1994 // First operand points to a global value.
1995 if (!isa<GlobalValue>(CE->getOperand(0)))
1998 // Second operand is zero.
1999 const ConstantInt *CI =
2000 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
2001 if (!CI || !CI->isZero())
2004 // Third operand is offset.
2005 if (!isa<ConstantInt>(CE->getOperand(2)))
2011 /// constructGlobalVariableDIE - Construct global variable DIE.
2012 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
2013 DIGlobalVariable GV(N);
2015 // If debug information is malformed then ignore it.
2016 if (GV.Verify() == false)
2019 // Check for pre-existence.
2020 CompileUnit *TheCU = getCompileUnit(N);
2021 if (TheCU->getDIE(GV))
2024 DIType GTy = GV.getType();
2025 DIE *VariableDIE = new DIE(GV.getTag());
2027 bool isGlobalVariable = GV.getGlobal() != NULL;
2030 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
2031 GV.getDisplayName());
2032 StringRef LinkageName = GV.getLinkageName();
2033 if (!LinkageName.empty() && isGlobalVariable)
2034 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
2035 getRealLinkageName(LinkageName));
2037 addType(VariableDIE, GTy);
2038 if (GTy.isCompositeType() && !GTy.getName().empty()
2039 && !GTy.isForwardDecl()) {
2040 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
2041 assert(Entry && "Missing global type!");
2042 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
2044 // Add scoping info.
2045 if (!GV.isLocalToUnit()) {
2046 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
2047 // Expose as global.
2048 TheCU->addGlobal(GV.getName(), VariableDIE);
2050 // Add line number info.
2051 addSourceLine(VariableDIE, GV);
2053 TheCU->insertDIE(N, VariableDIE);
2054 // Add to context owner.
2055 DIDescriptor GVContext = GV.getContext();
2056 addToContextOwner(VariableDIE, GVContext);
2058 if (isGlobalVariable) {
2059 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2060 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2061 addLabel(Block, 0, dwarf::DW_FORM_udata,
2062 Asm->Mang->getSymbol(GV.getGlobal()));
2063 // Do not create specification DIE if context is either compile unit
2065 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
2066 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
2067 // Create specification DIE.
2068 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
2069 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
2070 dwarf::DW_FORM_ref4, VariableDIE);
2071 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
2072 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
2073 TheCU->addDie(VariableSpecDIE);
2075 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2077 } else if (ConstantInt *CI =
2078 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
2079 addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
2080 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
2081 // GV is a merged global.
2082 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2083 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2084 addLabel(Block, 0, dwarf::DW_FORM_udata,
2085 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
2086 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
2087 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
2088 addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
2089 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
2090 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2096 /// construct SubprogramDIE - Construct subprogram DIE.
2097 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2100 // Check for pre-existence.
2101 CompileUnit *TheCU = getCompileUnit(N);
2102 if (TheCU->getDIE(N))
2105 if (!SP.isDefinition())
2106 // This is a method declaration which will be handled while constructing
2110 DIE *SubprogramDie = createSubprogramDIE(SP);
2113 TheCU->insertDIE(N, SubprogramDie);
2115 // Add to context owner.
2116 addToContextOwner(SubprogramDie, SP.getContext());
2118 // Expose as global.
2119 TheCU->addGlobal(SP.getName(), SubprogramDie);
2124 /// beginModule - Emit all Dwarf sections that should come prior to the
2125 /// content. Create global DIEs and emit initial debug info sections.
2126 /// This is inovked by the target AsmPrinter.
2127 void DwarfDebug::beginModule(Module *M) {
2128 if (DisableDebugInfoPrinting)
2131 DebugInfoFinder DbgFinder;
2132 DbgFinder.processModule(*M);
2134 bool HasDebugInfo = false;
2136 // Scan all the compile-units to see if there are any marked as the main unit.
2137 // if not, we do not generate debug info.
2138 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2139 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2140 if (DICompileUnit(*I).isMain()) {
2141 HasDebugInfo = true;
2146 if (!HasDebugInfo) return;
2148 // Tell MMI that we have debug info.
2149 MMI->setDebugInfoAvailability(true);
2151 // Emit initial sections.
2152 EmitSectionLabels();
2154 // Create all the compile unit DIEs.
2155 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2156 E = DbgFinder.compile_unit_end(); I != E; ++I)
2157 constructCompileUnit(*I);
2159 // Create DIEs for each subprogram.
2160 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2161 E = DbgFinder.subprogram_end(); I != E; ++I)
2162 constructSubprogramDIE(*I);
2164 // Create DIEs for each global variable.
2165 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2166 E = DbgFinder.global_variable_end(); I != E; ++I)
2167 constructGlobalVariableDIE(*I);
2169 //getOrCreateTypeDIE
2170 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2171 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2172 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2174 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2175 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2176 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2178 // Prime section data.
2179 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2182 /// endModule - Emit all Dwarf sections that should come after the content.
2184 void DwarfDebug::endModule() {
2185 if (!FirstCU) return;
2186 const Module *M = MMI->getModule();
2187 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2188 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2189 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2190 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2191 DISubprogram SP(AllSPs->getOperand(SI));
2192 if (!SP.Verify()) continue;
2194 // Collect info for variables that were optimized out.
2195 if (!SP.isDefinition()) continue;
2196 StringRef FName = SP.getLinkageName();
2198 FName = SP.getName();
2199 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
2201 unsigned E = NMD->getNumOperands();
2203 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2204 DeadFnScopeMap[SP] = Scope;
2205 for (unsigned I = 0; I != E; ++I) {
2206 DIVariable DV(NMD->getOperand(I));
2207 if (!DV.Verify()) continue;
2208 Scope->addVariable(new DbgVariable(DV));
2211 // Construct subprogram DIE and add variables DIEs.
2212 constructSubprogramDIE(SP);
2213 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2214 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2215 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2216 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2218 ScopeDIE->addChild(VariableDIE);
2223 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2224 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2225 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2227 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2230 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2231 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2232 DIE *SPDie = CI->first;
2233 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2235 DIE *NDie = getCompileUnit(N)->getDIE(N);
2236 if (!NDie) continue;
2237 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2240 // Standard sections final addresses.
2241 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2242 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2243 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2244 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2246 // End text sections.
2247 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2248 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2249 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2252 // Emit common frame information.
2253 emitCommonDebugFrame();
2255 // Emit function debug frame information
2256 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2257 E = DebugFrames.end(); I != E; ++I)
2258 emitFunctionDebugFrame(*I);
2260 // Compute DIE offsets and sizes.
2261 computeSizeAndOffsets();
2263 // Emit all the DIEs into a debug info section
2266 // Corresponding abbreviations into a abbrev section.
2267 emitAbbreviations();
2269 // Emit info into a debug pubnames section.
2270 emitDebugPubNames();
2272 // Emit info into a debug pubtypes section.
2273 emitDebugPubTypes();
2275 // Emit info into a debug loc section.
2278 // Emit info into a debug aranges section.
2281 // Emit info into a debug ranges section.
2284 // Emit info into a debug macinfo section.
2287 // Emit inline info.
2288 emitDebugInlineInfo();
2290 // Emit info into a debug str section.
2294 DeleteContainerSeconds(DeadFnScopeMap);
2295 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2296 E = CUMap.end(); I != E; ++I)
2298 FirstCU = NULL; // Reset for the next Module, if any.
2301 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2302 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2303 DebugLoc ScopeLoc) {
2305 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2307 return AbsDbgVariable;
2309 LLVMContext &Ctx = Var->getContext();
2310 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2314 AbsDbgVariable = new DbgVariable(Var);
2315 Scope->addVariable(AbsDbgVariable);
2316 AbstractVariables[Var] = AbsDbgVariable;
2317 return AbsDbgVariable;
2320 /// addCurrentFnArgument - If Var is an current function argument that add
2321 /// it in CurrentFnArguments list.
2322 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
2323 DbgVariable *Var, DbgScope *Scope) {
2324 if (Scope != CurrentFnDbgScope)
2326 DIVariable DV = Var->getVariable();
2327 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2329 unsigned ArgNo = DV.getArgNumber();
2333 size_t Size = CurrentFnArguments.size();
2335 CurrentFnArguments.resize(MF->getFunction()->arg_size());
2336 // llvm::Function argument size is not good indicator of how many
2337 // arguments does the function have at source level.
2339 CurrentFnArguments.resize(ArgNo * 2);
2340 CurrentFnArguments[ArgNo - 1] = Var;
2344 /// collectVariableInfoFromMMITable - Collect variable information from
2345 /// side table maintained by MMI.
2347 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2348 SmallPtrSet<const MDNode *, 16> &Processed) {
2349 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2350 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2351 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2352 VE = VMap.end(); VI != VE; ++VI) {
2353 const MDNode *Var = VI->first;
2355 Processed.insert(Var);
2357 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2359 DbgScope *Scope = 0;
2360 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2361 Scope = ConcreteScopes.lookup(IA);
2363 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2365 // If variable scope is not found then skip this variable.
2369 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2370 DbgVariable *RegVar = new DbgVariable(DV);
2371 recordVariableFrameIndex(RegVar, VP.first);
2372 if (!addCurrentFnArgument(MF, RegVar, Scope))
2373 Scope->addVariable(RegVar);
2374 if (AbsDbgVariable) {
2375 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2376 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2381 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2382 /// DBG_VALUE instruction, is in a defined reg.
2383 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2384 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2385 return MI->getNumOperands() == 3 &&
2386 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
2387 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
2390 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2392 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2393 SmallPtrSet<const MDNode *, 16> &Processed) {
2395 /// collection info from MMI table.
2396 collectVariableInfoFromMMITable(MF, Processed);
2398 SmallVector<const MachineInstr *, 8> DbgValues;
2399 // Collect variable information from DBG_VALUE machine instructions;
2400 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2402 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2404 const MachineInstr *MInsn = II;
2405 if (!MInsn->isDebugValue())
2407 DbgValues.push_back(MInsn);
2410 // This is a collection of DBG_VALUE instructions describing same variable.
2411 SmallVector<const MachineInstr *, 4> MultipleValues;
2412 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2413 E = DbgValues.end(); I != E; ++I) {
2414 const MachineInstr *MInsn = *I;
2415 MultipleValues.clear();
2416 if (isDbgValueInDefinedReg(MInsn))
2417 MultipleValues.push_back(MInsn);
2418 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2419 if (Processed.count(DV) != 0)
2422 const MachineInstr *PrevMI = MInsn;
2423 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2424 ME = DbgValues.end(); MI != ME; ++MI) {
2426 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2427 if (Var == DV && !PrevMI->isIdenticalTo(*MI))
2428 MultipleValues.push_back(*MI);
2432 DbgScope *Scope = NULL;
2433 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2434 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2435 Scope = CurrentFnDbgScope;
2437 Scope = findDbgScope(MInsn);
2438 // If variable scope is not found then skip this variable.
2442 Processed.insert(DV);
2443 DbgVariable *RegVar = new DbgVariable(DV);
2444 if (!addCurrentFnArgument(MF, RegVar, Scope))
2445 Scope->addVariable(RegVar);
2446 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2447 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2448 VarToAbstractVarMap[RegVar] = AbsVar;
2450 if (MultipleValues.size() <= 1 && !RegClobberInsn.count(MInsn)) {
2451 DbgVariableToDbgInstMap[RegVar] = MInsn;
2455 // handle multiple DBG_VALUE instructions describing one variable.
2456 if (DotDebugLocEntries.empty())
2457 RegVar->setDotDebugLocOffset(0);
2459 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2461 for (SmallVector<const MachineInstr *, 4>::iterator
2462 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2463 MVI != MVE; ++MVI) {
2464 const MachineInstr *Begin = *MVI;
2465 MachineLocation MLoc;
2466 if (Begin->getNumOperands() == 3) {
2467 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2468 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2470 MLoc = Asm->getDebugValueLocation(Begin);
2475 // Compute the range for a register location.
2476 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2477 const MCSymbol *SLabel = 0;
2479 if (const MachineInstr *ClobberMI = RegClobberInsn.lookup(Begin))
2480 // The register range starting at Begin may be clobbered.
2481 SLabel = getLabelAfterInsn(ClobberMI);
2482 else if (MVI + 1 == MVE)
2483 // If Begin is the last instruction then its value is valid
2484 // until the end of the funtion.
2485 SLabel = FunctionEndSym;
2487 // The value is valid until the next DBG_VALUE.
2488 SLabel = getLabelBeforeInsn(MVI[1]);
2490 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2492 DotDebugLocEntries.push_back(DotDebugLocEntry());
2495 // Collect info for variables that were optimized out.
2496 const Function *F = MF->getFunction();
2497 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
2498 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2499 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2500 if (!DV || !Processed.insert(DV))
2502 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2504 Scope->addVariable(new DbgVariable(DV));
2509 /// getLabelBeforeInsn - Return Label preceding the instruction.
2510 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2511 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2512 LabelsBeforeInsn.find(MI);
2513 if (I == LabelsBeforeInsn.end())
2514 // FunctionBeginSym always preceeds all the instruction in current function.
2515 return FunctionBeginSym;
2519 /// getLabelAfterInsn - Return Label immediately following the instruction.
2520 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2521 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2522 LabelsAfterInsn.find(MI);
2523 if (I == LabelsAfterInsn.end())
2528 /// beginInstruction - Process beginning of an instruction.
2529 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
2530 if (InsnNeedsLabel.count(MI) == 0) {
2531 LabelsBeforeInsn[MI] = PrevLabel;
2536 DebugLoc DL = MI->getDebugLoc();
2537 if (!DL.isUnknown()) {
2538 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2539 PrevLabel = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2541 LabelsBeforeInsn[MI] = PrevLabel;
2545 // If location is unknown then use temp label for this DBG_VALUE
2547 if (MI->isDebugValue()) {
2548 PrevLabel = MMI->getContext().CreateTempSymbol();
2549 Asm->OutStreamer.EmitLabel(PrevLabel);
2550 LabelsBeforeInsn[MI] = PrevLabel;
2554 if (UnknownLocations) {
2555 PrevLabel = recordSourceLine(0, 0, 0);
2556 LabelsBeforeInsn[MI] = PrevLabel;
2560 assert (0 && "Instruction is not processed!");
2563 /// endInstruction - Process end of an instruction.
2564 void DwarfDebug::endInstruction(const MachineInstr *MI) {
2565 if (InsnsNeedsLabelAfter.count(MI) != 0) {
2566 // Emit a label if this instruction ends a scope.
2567 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
2568 Asm->OutStreamer.EmitLabel(Label);
2569 LabelsAfterInsn[MI] = Label;
2573 /// getOrCreateDbgScope - Create DbgScope for the scope.
2574 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2575 const MDNode *InlinedAt) {
2577 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2580 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2581 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2582 if (DIDescriptor(Scope).isLexicalBlock()) {
2584 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2585 WScope->setParent(Parent);
2586 Parent->addScope(WScope);
2589 if (!WScope->getParent()) {
2590 StringRef SPName = DISubprogram(Scope).getLinkageName();
2591 // We used to check only for a linkage name, but that fails
2592 // since we began omitting the linkage name for private
2593 // functions. The new way is to check for the name in metadata,
2594 // but that's not supported in old .ll test cases. Ergo, we
2596 if (SPName == Asm->MF->getFunction()->getName() ||
2597 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2598 CurrentFnDbgScope = WScope;
2604 getOrCreateAbstractScope(Scope);
2605 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2609 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2610 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2611 DILocation DL(InlinedAt);
2613 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2614 WScope->setParent(Parent);
2615 Parent->addScope(WScope);
2617 ConcreteScopes[InlinedAt] = WScope;
2622 /// hasValidLocation - Return true if debug location entry attached with
2623 /// machine instruction encodes valid location info.
2624 static bool hasValidLocation(LLVMContext &Ctx,
2625 const MachineInstr *MInsn,
2626 const MDNode *&Scope, const MDNode *&InlinedAt) {
2627 DebugLoc DL = MInsn->getDebugLoc();
2628 if (DL.isUnknown()) return false;
2630 const MDNode *S = DL.getScope(Ctx);
2632 // There is no need to create another DIE for compile unit. For all
2633 // other scopes, create one DbgScope now. This will be translated
2634 // into a scope DIE at the end.
2635 if (DIScope(S).isCompileUnit()) return false;
2638 InlinedAt = DL.getInlinedAt(Ctx);
2642 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2644 static void calculateDominanceGraph(DbgScope *Scope) {
2645 assert (Scope && "Unable to calculate scop edominance graph!");
2646 SmallVector<DbgScope *, 4> WorkStack;
2647 WorkStack.push_back(Scope);
2648 unsigned Counter = 0;
2649 while (!WorkStack.empty()) {
2650 DbgScope *WS = WorkStack.back();
2651 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2652 bool visitedChildren = false;
2653 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2654 SE = Children.end(); SI != SE; ++SI) {
2655 DbgScope *ChildScope = *SI;
2656 if (!ChildScope->getDFSOut()) {
2657 WorkStack.push_back(ChildScope);
2658 visitedChildren = true;
2659 ChildScope->setDFSIn(++Counter);
2663 if (!visitedChildren) {
2664 WorkStack.pop_back();
2665 WS->setDFSOut(++Counter);
2670 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2672 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2673 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2676 unsigned PrevDFSIn = 0;
2677 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2679 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2681 const MachineInstr *MInsn = II;
2682 const MDNode *Scope = NULL;
2683 const MDNode *InlinedAt = NULL;
2685 // Check if instruction has valid location information.
2686 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2690 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2691 MI2ScopeMap.find(MInsn);
2692 if (DI != MI2ScopeMap.end()) {
2693 DbgScope *S = DI->second;
2694 dbgs() << S->getDFSIn();
2695 PrevDFSIn = S->getDFSIn();
2697 dbgs() << PrevDFSIn;
2699 dbgs() << " [ x" << PrevDFSIn;
2707 /// extractScopeInformation - Scan machine instructions in this function
2708 /// and collect DbgScopes. Return true, if at least one scope was found.
2709 bool DwarfDebug::extractScopeInformation() {
2710 // If scope information was extracted using .dbg intrinsics then there is not
2711 // any need to extract these information by scanning each instruction.
2712 if (!DbgScopeMap.empty())
2715 // Scan each instruction and create scopes. First build working set of scopes.
2716 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2717 SmallVector<DbgRange, 4> MIRanges;
2718 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2719 const MDNode *PrevScope = NULL;
2720 const MDNode *PrevInlinedAt = NULL;
2721 const MachineInstr *RangeBeginMI = NULL;
2722 const MachineInstr *PrevMI = NULL;
2723 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2725 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2727 const MachineInstr *MInsn = II;
2728 const MDNode *Scope = NULL;
2729 const MDNode *InlinedAt = NULL;
2731 // Check if instruction has valid location information.
2732 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2737 // If scope has not changed then skip this instruction.
2738 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2743 // Ignore DBG_VALUE. It does not contribute any instruction in output.
2744 if (MInsn->isDebugValue())
2748 // If we have alread seen a beginning of a instruction range and
2749 // current instruction scope does not match scope of first instruction
2750 // in this range then create a new instruction range.
2751 DbgRange R(RangeBeginMI, PrevMI);
2752 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2754 MIRanges.push_back(R);
2757 // This is a beginning of a new instruction range.
2758 RangeBeginMI = MInsn;
2760 // Reset previous markers.
2763 PrevInlinedAt = InlinedAt;
2767 // Create last instruction range.
2768 if (RangeBeginMI && PrevMI && PrevScope) {
2769 DbgRange R(RangeBeginMI, PrevMI);
2770 MIRanges.push_back(R);
2771 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2774 if (!CurrentFnDbgScope)
2777 calculateDominanceGraph(CurrentFnDbgScope);
2779 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2781 // Find ranges of instructions covered by each DbgScope;
2782 DbgScope *PrevDbgScope = NULL;
2783 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2784 RE = MIRanges.end(); RI != RE; ++RI) {
2785 const DbgRange &R = *RI;
2786 DbgScope *S = MI2ScopeMap.lookup(R.first);
2787 assert (S && "Lost DbgScope for a machine instruction!");
2788 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2789 PrevDbgScope->closeInsnRange(S);
2790 S->openInsnRange(R.first);
2791 S->extendInsnRange(R.second);
2796 PrevDbgScope->closeInsnRange();
2798 identifyScopeMarkers();
2800 return !DbgScopeMap.empty();
2803 /// identifyScopeMarkers() -
2804 /// Each DbgScope has first instruction and last instruction to mark beginning
2805 /// and end of a scope respectively. Create an inverse map that list scopes
2806 /// starts (and ends) with an instruction. One instruction may start (or end)
2807 /// multiple scopes. Ignore scopes that are not reachable.
2808 void DwarfDebug::identifyScopeMarkers() {
2809 SmallVector<DbgScope *, 4> WorkList;
2810 WorkList.push_back(CurrentFnDbgScope);
2811 while (!WorkList.empty()) {
2812 DbgScope *S = WorkList.pop_back_val();
2814 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2815 if (!Children.empty())
2816 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2817 SE = Children.end(); SI != SE; ++SI)
2818 WorkList.push_back(*SI);
2820 if (S->isAbstractScope())
2823 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2826 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2827 RE = Ranges.end(); RI != RE; ++RI) {
2828 assert(RI->first && "DbgRange does not have first instruction!");
2829 assert(RI->second && "DbgRange does not have second instruction!");
2830 InsnsNeedsLabelAfter.insert(RI->second);
2835 /// FindFirstDebugLoc - Find the first debug location in the function. This
2836 /// is intended to be an approximation for the source position of the
2837 /// beginning of the function.
2838 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2839 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2841 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2842 MBBI != MBBE; ++MBBI) {
2843 DebugLoc DL = MBBI->getDebugLoc();
2844 if (!DL.isUnknown())
2851 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2852 /// line number information.
2853 static void CheckLineNumbers(const MachineFunction *MF) {
2854 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2856 bool FoundLineNo = false;
2857 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2859 const MachineInstr *MI = II;
2860 if (!MI->getDebugLoc().isUnknown()) {
2865 if (!FoundLineNo && I->size())
2866 ++BlocksWithoutLineNo;
2871 /// beginFunction - Gather pre-function debug information. Assumes being
2872 /// emitted immediately after the function entry point.
2873 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2874 if (!MMI->hasDebugInfo()) return;
2875 if (!extractScopeInformation()) return;
2878 CheckLineNumbers(MF);
2881 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2882 Asm->getFunctionNumber());
2883 // Assumes in correct section after the entry point.
2884 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2886 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2888 DebugLoc FDL = FindFirstDebugLoc(MF);
2889 if (FDL.isUnknown()) return;
2891 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2892 const MDNode *TheScope = 0;
2894 DISubprogram SP = getDISubprogram(Scope);
2897 Line = SP.getLineNumber();
2901 Line = FDL.getLine();
2906 recordSourceLine(Line, Col, TheScope);
2908 /// ProcessedArgs - Collection of arguments already processed.
2909 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2911 /// LastDbgValue - Refer back to the last DBG_VALUE instruction to mention MD.
2912 DenseMap<const MDNode*, const MachineInstr*> LastDbgValue;
2914 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
2916 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
2917 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
2920 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2922 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2924 const MachineInstr *MI = II;
2925 DebugLoc DL = MI->getDebugLoc();
2926 if (MI->isDebugValue()) {
2927 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2929 // Keep track of variables in registers.
2931 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
2932 LastDbgValue[Var] = MI;
2933 if (isDbgValueInDefinedReg(MI))
2934 LiveUserVar[MI->getOperand(0).getReg()] = Var;
2937 if (!DV.Verify()) continue;
2938 // If DBG_VALUE is for a local variable then it needs a label.
2939 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2940 InsnNeedsLabel.insert(MI);
2941 // DBG_VALUE for inlined functions argument needs a label.
2942 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2943 describes(MF->getFunction()))
2944 InsnNeedsLabel.insert(MI);
2945 // DBG_VALUE indicating argument location change needs a label.
2946 else if (!ProcessedArgs.insert(DV))
2947 InsnNeedsLabel.insert(MI);
2949 // If location is unknown then instruction needs a location only if
2950 // UnknownLocations flag is set.
2951 if (DL.isUnknown()) {
2952 if (UnknownLocations && !PrevLoc.isUnknown())
2953 InsnNeedsLabel.insert(MI);
2954 } else if (DL != PrevLoc)
2955 // Otherwise, instruction needs a location only if it is new location.
2956 InsnNeedsLabel.insert(MI);
2958 // Check if the instruction clobbers any registers with debug vars.
2959 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
2960 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
2961 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
2963 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
2964 unsigned Reg = *AI; ++AI) {
2965 const MDNode *Var = LiveUserVar[Reg];
2968 // Reg is now clobbered.
2969 LiveUserVar[Reg] = 0;
2971 // Was MD last defined by a DBG_VALUE referring to Reg?
2972 const MachineInstr *Last = LastDbgValue.lookup(Var);
2973 if (!Last || Last->getParent() != MI->getParent())
2975 if (!isDbgValueInDefinedReg(Last) ||
2976 Last->getOperand(0).getReg() != Reg)
2978 // MD is clobbered. Make sure the next instruction gets a label.
2979 InsnsNeedsLabelAfter.insert(MI);
2980 RegClobberInsn[Last] = MI;
2985 if (!DL.isUnknown() || UnknownLocations)
2989 PrevLabel = FunctionBeginSym;
2992 /// endFunction - Gather and emit post-function debug information.
2994 void DwarfDebug::endFunction(const MachineFunction *MF) {
2995 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2997 if (CurrentFnDbgScope) {
2999 // Define end label for subprogram.
3000 FunctionEndSym = Asm->GetTempSymbol("func_end",
3001 Asm->getFunctionNumber());
3002 // Assumes in correct section after the entry point.
3003 Asm->OutStreamer.EmitLabel(FunctionEndSym);
3005 SmallPtrSet<const MDNode *, 16> ProcessedVars;
3006 collectVariableInfo(MF, ProcessedVars);
3008 // Construct abstract scopes.
3009 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
3010 AE = AbstractScopesList.end(); AI != AE; ++AI) {
3011 DISubprogram SP((*AI)->getScopeNode());
3013 // Collect info for variables that were optimized out.
3014 StringRef FName = SP.getLinkageName();
3016 FName = SP.getName();
3017 if (NamedMDNode *NMD =
3018 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
3019 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3020 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
3021 if (!DV || !ProcessedVars.insert(DV))
3023 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
3025 Scope->addVariable(new DbgVariable(DV));
3029 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
3030 constructScopeDIE(*AI);
3033 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
3035 if (!DisableFramePointerElim(*MF))
3036 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
3037 dwarf::DW_FORM_flag, 1);
3040 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
3041 MMI->getFrameMoves()));
3045 CurrentFnDbgScope = NULL;
3046 CurrentFnArguments.clear();
3047 InsnNeedsLabel.clear();
3048 DbgVariableToFrameIndexMap.clear();
3049 VarToAbstractVarMap.clear();
3050 DbgVariableToDbgInstMap.clear();
3051 DeleteContainerSeconds(DbgScopeMap);
3052 InsnsNeedsLabelAfter.clear();
3053 RegClobberInsn.clear();
3054 ConcreteScopes.clear();
3055 DeleteContainerSeconds(AbstractScopes);
3056 AbstractScopesList.clear();
3057 AbstractVariables.clear();
3058 LabelsBeforeInsn.clear();
3059 LabelsAfterInsn.clear();
3063 /// recordVariableFrameIndex - Record a variable's index.
3064 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
3065 assert (V && "Invalid DbgVariable!");
3066 DbgVariableToFrameIndexMap[V] = Index;
3069 /// findVariableFrameIndex - Return true if frame index for the variable
3070 /// is found. Update FI to hold value of the index.
3071 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
3072 assert (V && "Invalid DbgVariable!");
3073 DenseMap<const DbgVariable *, int>::iterator I =
3074 DbgVariableToFrameIndexMap.find(V);
3075 if (I == DbgVariableToFrameIndexMap.end())
3081 /// findDbgScope - Find DbgScope for the debug loc attached with an
3083 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
3084 DbgScope *Scope = NULL;
3086 MInsn->getParent()->getParent()->getFunction()->getContext();
3087 DebugLoc DL = MInsn->getDebugLoc();
3092 if (const MDNode *IA = DL.getInlinedAt(Ctx))
3093 Scope = ConcreteScopes.lookup(IA);
3095 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
3101 /// recordSourceLine - Register a source line with debug info. Returns the
3102 /// unique label that was emitted and which provides correspondence to
3103 /// the source line list.
3104 MCSymbol *DwarfDebug::recordSourceLine(unsigned Line, unsigned Col,
3110 DIDescriptor Scope(S);
3112 if (Scope.isCompileUnit()) {
3113 DICompileUnit CU(S);
3114 Fn = CU.getFilename();
3115 } else if (Scope.isFile()) {
3117 Fn = F.getFilename();
3118 } else if (Scope.isSubprogram()) {
3120 Fn = SP.getFilename();
3121 } else if (Scope.isLexicalBlock()) {
3122 DILexicalBlock DB(S);
3123 Fn = DB.getFilename();
3125 assert(0 && "Unexpected scope info");
3127 Src = GetOrCreateSourceID(Fn);
3130 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
3133 MCSymbol *Label = MMI->getContext().CreateTempSymbol();
3134 Asm->OutStreamer.EmitLabel(Label);
3138 //===----------------------------------------------------------------------===//
3140 //===----------------------------------------------------------------------===//
3142 /// computeSizeAndOffset - Compute the size and offset of a DIE.
3145 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
3146 // Get the children.
3147 const std::vector<DIE *> &Children = Die->getChildren();
3149 // If not last sibling and has children then add sibling offset attribute.
3150 if (!Last && !Children.empty())
3151 Die->addSiblingOffset(DIEValueAllocator);
3153 // Record the abbreviation.
3154 assignAbbrevNumber(Die->getAbbrev());
3156 // Get the abbreviation for this DIE.
3157 unsigned AbbrevNumber = Die->getAbbrevNumber();
3158 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3161 Die->setOffset(Offset);
3163 // Start the size with the size of abbreviation code.
3164 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3166 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3167 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3169 // Size the DIE attribute values.
3170 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3171 // Size attribute value.
3172 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3174 // Size the DIE children if any.
3175 if (!Children.empty()) {
3176 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3177 "Children flag not set");
3179 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3180 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3182 // End of children marker.
3183 Offset += sizeof(int8_t);
3186 Die->setSize(Offset - Die->getOffset());
3190 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3192 void DwarfDebug::computeSizeAndOffsets() {
3193 unsigned PrevOffset = 0;
3194 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3195 E = CUMap.end(); I != E; ++I) {
3196 // Compute size of compile unit header.
3197 static unsigned Offset = PrevOffset +
3198 sizeof(int32_t) + // Length of Compilation Unit Info
3199 sizeof(int16_t) + // DWARF version number
3200 sizeof(int32_t) + // Offset Into Abbrev. Section
3201 sizeof(int8_t); // Pointer Size (in bytes)
3202 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3203 PrevOffset = Offset;
3207 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3208 /// temporary label to it if SymbolStem is specified.
3209 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3210 const char *SymbolStem = 0) {
3211 Asm->OutStreamer.SwitchSection(Section);
3212 if (!SymbolStem) return 0;
3214 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3215 Asm->OutStreamer.EmitLabel(TmpSym);
3219 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3220 /// the start of each one.
3221 void DwarfDebug::EmitSectionLabels() {
3222 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3224 // Dwarf sections base addresses.
3225 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3226 DwarfFrameSectionSym =
3227 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3230 DwarfInfoSectionSym =
3231 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3232 DwarfAbbrevSectionSym =
3233 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3234 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3236 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3237 EmitSectionSym(Asm, MacroInfo);
3239 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3240 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3241 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3242 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3243 DwarfStrSectionSym =
3244 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3245 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3248 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3249 "section_debug_loc");
3251 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3252 EmitSectionSym(Asm, TLOF.getDataSection());
3255 /// emitDIE - Recusively Emits a debug information entry.
3257 void DwarfDebug::emitDIE(DIE *Die) {
3258 // Get the abbreviation for this DIE.
3259 unsigned AbbrevNumber = Die->getAbbrevNumber();
3260 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3262 // Emit the code (index) for the abbreviation.
3263 if (Asm->isVerbose())
3264 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3265 Twine::utohexstr(Die->getOffset()) + ":0x" +
3266 Twine::utohexstr(Die->getSize()) + " " +
3267 dwarf::TagString(Abbrev->getTag()));
3268 Asm->EmitULEB128(AbbrevNumber);
3270 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3271 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3273 // Emit the DIE attribute values.
3274 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3275 unsigned Attr = AbbrevData[i].getAttribute();
3276 unsigned Form = AbbrevData[i].getForm();
3277 assert(Form && "Too many attributes for DIE (check abbreviation)");
3279 if (Asm->isVerbose())
3280 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3283 case dwarf::DW_AT_sibling:
3284 Asm->EmitInt32(Die->getSiblingOffset());
3286 case dwarf::DW_AT_abstract_origin: {
3287 DIEEntry *E = cast<DIEEntry>(Values[i]);
3288 DIE *Origin = E->getEntry();
3289 unsigned Addr = Origin->getOffset();
3290 Asm->EmitInt32(Addr);
3293 case dwarf::DW_AT_ranges: {
3294 // DW_AT_range Value encodes offset in debug_range section.
3295 DIEInteger *V = cast<DIEInteger>(Values[i]);
3297 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3298 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3302 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3304 DwarfDebugRangeSectionSym,
3309 case dwarf::DW_AT_location: {
3310 if (UseDotDebugLocEntry.count(Die) != 0) {
3311 DIELabel *L = cast<DIELabel>(Values[i]);
3312 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3314 Values[i]->EmitValue(Asm, Form);
3317 case dwarf::DW_AT_accessibility: {
3318 if (Asm->isVerbose()) {
3319 DIEInteger *V = cast<DIEInteger>(Values[i]);
3320 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3322 Values[i]->EmitValue(Asm, Form);
3326 // Emit an attribute using the defined form.
3327 Values[i]->EmitValue(Asm, Form);
3332 // Emit the DIE children if any.
3333 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3334 const std::vector<DIE *> &Children = Die->getChildren();
3336 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3337 emitDIE(Children[j]);
3339 if (Asm->isVerbose())
3340 Asm->OutStreamer.AddComment("End Of Children Mark");
3345 /// emitDebugInfo - Emit the debug info section.
3347 void DwarfDebug::emitDebugInfo() {
3348 // Start debug info section.
3349 Asm->OutStreamer.SwitchSection(
3350 Asm->getObjFileLowering().getDwarfInfoSection());
3351 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3352 E = CUMap.end(); I != E; ++I) {
3353 CompileUnit *TheCU = I->second;
3354 DIE *Die = TheCU->getCUDie();
3356 // Emit the compile units header.
3357 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3360 // Emit size of content not including length itself
3361 unsigned ContentSize = Die->getSize() +
3362 sizeof(int16_t) + // DWARF version number
3363 sizeof(int32_t) + // Offset Into Abbrev. Section
3364 sizeof(int8_t) + // Pointer Size (in bytes)
3365 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3367 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3368 Asm->EmitInt32(ContentSize);
3369 Asm->OutStreamer.AddComment("DWARF version number");
3370 Asm->EmitInt16(dwarf::DWARF_VERSION);
3371 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3372 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3373 DwarfAbbrevSectionSym);
3374 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3375 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3378 // FIXME - extra padding for gdb bug.
3379 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3384 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3388 /// emitAbbreviations - Emit the abbreviation section.
3390 void DwarfDebug::emitAbbreviations() const {
3391 // Check to see if it is worth the effort.
3392 if (!Abbreviations.empty()) {
3393 // Start the debug abbrev section.
3394 Asm->OutStreamer.SwitchSection(
3395 Asm->getObjFileLowering().getDwarfAbbrevSection());
3397 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3399 // For each abbrevation.
3400 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3401 // Get abbreviation data
3402 const DIEAbbrev *Abbrev = Abbreviations[i];
3404 // Emit the abbrevations code (base 1 index.)
3405 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3407 // Emit the abbreviations data.
3411 // Mark end of abbreviations.
3412 Asm->EmitULEB128(0, "EOM(3)");
3414 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3418 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3419 /// the line matrix.
3421 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3422 // Define last address of section.
3423 Asm->OutStreamer.AddComment("Extended Op");
3426 Asm->OutStreamer.AddComment("Op size");
3427 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3428 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3429 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3431 Asm->OutStreamer.AddComment("Section end label");
3433 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3434 Asm->getTargetData().getPointerSize(),
3437 // Mark end of matrix.
3438 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3444 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3446 void DwarfDebug::emitCommonDebugFrame() {
3447 if (!Asm->MAI->doesDwarfRequireFrameSection())
3450 int stackGrowth = Asm->getTargetData().getPointerSize();
3451 if (Asm->TM.getFrameLowering()->getStackGrowthDirection() ==
3452 TargetFrameLowering::StackGrowsDown)
3455 // Start the dwarf frame section.
3456 Asm->OutStreamer.SwitchSection(
3457 Asm->getObjFileLowering().getDwarfFrameSection());
3459 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3460 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3461 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3462 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3464 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3465 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3466 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3467 Asm->OutStreamer.AddComment("CIE Version");
3468 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3469 Asm->OutStreamer.AddComment("CIE Augmentation");
3470 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3471 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3472 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3473 Asm->OutStreamer.AddComment("CIE RA Column");
3474 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3475 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
3476 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3478 std::vector<MachineMove> Moves;
3479 TFI->getInitialFrameState(Moves);
3481 Asm->EmitFrameMoves(Moves, 0, false);
3483 Asm->EmitAlignment(2);
3484 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3487 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3490 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3491 if (!Asm->MAI->doesDwarfRequireFrameSection())
3494 // Start the dwarf frame section.
3495 Asm->OutStreamer.SwitchSection(
3496 Asm->getObjFileLowering().getDwarfFrameSection());
3498 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3499 MCSymbol *DebugFrameBegin =
3500 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3501 MCSymbol *DebugFrameEnd =
3502 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3503 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3505 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3507 Asm->OutStreamer.AddComment("FDE CIE offset");
3508 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3509 DwarfFrameSectionSym);
3511 Asm->OutStreamer.AddComment("FDE initial location");
3512 MCSymbol *FuncBeginSym =
3513 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3514 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3515 Asm->getTargetData().getPointerSize(),
3519 Asm->OutStreamer.AddComment("FDE address range");
3520 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3521 FuncBeginSym, Asm->getTargetData().getPointerSize());
3523 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3525 Asm->EmitAlignment(2);
3526 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3529 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3531 void DwarfDebug::emitDebugPubNames() {
3532 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3533 E = CUMap.end(); I != E; ++I) {
3534 CompileUnit *TheCU = I->second;
3535 // Start the dwarf pubnames section.
3536 Asm->OutStreamer.SwitchSection(
3537 Asm->getObjFileLowering().getDwarfPubNamesSection());
3539 Asm->OutStreamer.AddComment("Length of Public Names Info");
3540 Asm->EmitLabelDifference(
3541 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3542 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3544 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3547 Asm->OutStreamer.AddComment("DWARF Version");
3548 Asm->EmitInt16(dwarf::DWARF_VERSION);
3550 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3551 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3552 DwarfInfoSectionSym);
3554 Asm->OutStreamer.AddComment("Compilation Unit Length");
3555 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3556 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3559 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3560 for (StringMap<DIE*>::const_iterator
3561 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3562 const char *Name = GI->getKeyData();
3563 DIE *Entity = GI->second;
3565 Asm->OutStreamer.AddComment("DIE offset");
3566 Asm->EmitInt32(Entity->getOffset());
3568 if (Asm->isVerbose())
3569 Asm->OutStreamer.AddComment("External Name");
3570 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3573 Asm->OutStreamer.AddComment("End Mark");
3575 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3580 void DwarfDebug::emitDebugPubTypes() {
3581 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3582 E = CUMap.end(); I != E; ++I) {
3583 CompileUnit *TheCU = I->second;
3584 // Start the dwarf pubnames section.
3585 Asm->OutStreamer.SwitchSection(
3586 Asm->getObjFileLowering().getDwarfPubTypesSection());
3587 Asm->OutStreamer.AddComment("Length of Public Types Info");
3588 Asm->EmitLabelDifference(
3589 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3590 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3592 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3595 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3596 Asm->EmitInt16(dwarf::DWARF_VERSION);
3598 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3599 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3600 DwarfInfoSectionSym);
3602 Asm->OutStreamer.AddComment("Compilation Unit Length");
3603 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3604 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3607 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3608 for (StringMap<DIE*>::const_iterator
3609 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3610 const char *Name = GI->getKeyData();
3611 DIE * Entity = GI->second;
3613 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3614 Asm->EmitInt32(Entity->getOffset());
3616 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3617 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3620 Asm->OutStreamer.AddComment("End Mark");
3622 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3627 /// emitDebugStr - Emit visible names into a debug str section.
3629 void DwarfDebug::emitDebugStr() {
3630 // Check to see if it is worth the effort.
3631 if (StringPool.empty()) return;
3633 // Start the dwarf str section.
3634 Asm->OutStreamer.SwitchSection(
3635 Asm->getObjFileLowering().getDwarfStrSection());
3637 // Get all of the string pool entries and put them in an array by their ID so
3638 // we can sort them.
3639 SmallVector<std::pair<unsigned,
3640 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3642 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3643 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3644 Entries.push_back(std::make_pair(I->second.second, &*I));
3646 array_pod_sort(Entries.begin(), Entries.end());
3648 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3649 // Emit a label for reference from debug information entries.
3650 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3652 // Emit the string itself.
3653 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3657 /// emitDebugLoc - Emit visible names into a debug loc section.
3659 void DwarfDebug::emitDebugLoc() {
3660 if (DotDebugLocEntries.empty())
3663 for (SmallVector<DotDebugLocEntry, 4>::iterator
3664 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3666 DotDebugLocEntry &Entry = *I;
3667 if (I + 1 != DotDebugLocEntries.end())
3671 // Start the dwarf loc section.
3672 Asm->OutStreamer.SwitchSection(
3673 Asm->getObjFileLowering().getDwarfLocSection());
3674 unsigned char Size = Asm->getTargetData().getPointerSize();
3675 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3677 for (SmallVector<DotDebugLocEntry, 4>::iterator
3678 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3679 I != E; ++I, ++index) {
3680 DotDebugLocEntry &Entry = *I;
3681 if (Entry.isMerged()) continue;
3682 if (Entry.isEmpty()) {
3683 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3684 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3685 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3687 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3688 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3689 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3690 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3691 if (int Offset = Entry.Loc.getOffset()) {
3692 // If the value is at a certain offset from frame register then
3694 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3695 Asm->OutStreamer.AddComment("Loc expr size");
3696 Asm->EmitInt16(1 + OffsetSize);
3697 Asm->OutStreamer.AddComment(
3698 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3699 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3700 Asm->OutStreamer.AddComment("Offset");
3701 Asm->EmitSLEB128(Offset);
3704 Asm->OutStreamer.AddComment("Loc expr size");
3706 Asm->OutStreamer.AddComment(
3707 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3708 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3710 Asm->OutStreamer.AddComment("Loc expr size");
3711 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3712 Asm->EmitInt8(dwarf::DW_OP_regx);
3713 Asm->EmitULEB128(Reg);
3720 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3722 void DwarfDebug::EmitDebugARanges() {
3723 // Start the dwarf aranges section.
3724 Asm->OutStreamer.SwitchSection(
3725 Asm->getObjFileLowering().getDwarfARangesSection());
3728 /// emitDebugRanges - Emit visible names into a debug ranges section.
3730 void DwarfDebug::emitDebugRanges() {
3731 // Start the dwarf ranges section.
3732 Asm->OutStreamer.SwitchSection(
3733 Asm->getObjFileLowering().getDwarfRangesSection());
3734 unsigned char Size = Asm->getTargetData().getPointerSize();
3735 for (SmallVector<const MCSymbol *, 8>::iterator
3736 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3739 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3741 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3745 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3747 void DwarfDebug::emitDebugMacInfo() {
3748 if (const MCSection *LineInfo =
3749 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3750 // Start the dwarf macinfo section.
3751 Asm->OutStreamer.SwitchSection(LineInfo);
3755 /// emitDebugInlineInfo - Emit inline info using following format.
3757 /// 1. length of section
3758 /// 2. Dwarf version number
3759 /// 3. address size.
3761 /// Entries (one "entry" for each function that was inlined):
3763 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3764 /// otherwise offset into __debug_str for regular function name.
3765 /// 2. offset into __debug_str section for regular function name.
3766 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3767 /// instances for the function.
3769 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3770 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3771 /// __debug_info section, and the low_pc is the starting address for the
3772 /// inlining instance.
3773 void DwarfDebug::emitDebugInlineInfo() {
3774 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3780 Asm->OutStreamer.SwitchSection(
3781 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3783 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3784 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3785 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3787 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3789 Asm->OutStreamer.AddComment("Dwarf Version");
3790 Asm->EmitInt16(dwarf::DWARF_VERSION);
3791 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3792 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3794 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3795 E = InlinedSPNodes.end(); I != E; ++I) {
3797 const MDNode *Node = *I;
3798 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3799 = InlineInfo.find(Node);
3800 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3801 DISubprogram SP(Node);
3802 StringRef LName = SP.getLinkageName();
3803 StringRef Name = SP.getName();
3805 Asm->OutStreamer.AddComment("MIPS linkage name");
3806 if (LName.empty()) {
3807 Asm->OutStreamer.EmitBytes(Name, 0);
3808 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3810 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3811 DwarfStrSectionSym);
3813 Asm->OutStreamer.AddComment("Function name");
3814 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3815 Asm->EmitULEB128(Labels.size(), "Inline count");
3817 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3818 LE = Labels.end(); LI != LE; ++LI) {
3819 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3820 Asm->EmitInt32(LI->second->getOffset());
3822 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3823 Asm->OutStreamer.EmitSymbolValue(LI->first,
3824 Asm->getTargetData().getPointerSize(),0);
3828 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));