1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for writing dwarf debug info into asm files.
12 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "dwarfdebug"
15 #include "DwarfDebug.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/Instructions.h"
20 #include "llvm/CodeGen/MachineFunction.h"
21 #include "llvm/CodeGen/MachineModuleInfo.h"
22 #include "llvm/MC/MCAsmInfo.h"
23 #include "llvm/MC/MCSection.h"
24 #include "llvm/MC/MCStreamer.h"
25 #include "llvm/MC/MCSymbol.h"
26 #include "llvm/Target/Mangler.h"
27 #include "llvm/Target/TargetData.h"
28 #include "llvm/Target/TargetFrameLowering.h"
29 #include "llvm/Target/TargetLoweringObjectFile.h"
30 #include "llvm/Target/TargetMachine.h"
31 #include "llvm/Target/TargetRegisterInfo.h"
32 #include "llvm/Target/TargetOptions.h"
33 #include "llvm/Analysis/DebugInfo.h"
34 #include "llvm/Analysis/DIBuilder.h"
35 #include "llvm/ADT/Statistic.h"
36 #include "llvm/ADT/STLExtras.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/ErrorHandling.h"
41 #include "llvm/Support/ValueHandle.h"
42 #include "llvm/Support/FormattedStream.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/Path.h"
47 static cl::opt<bool> PrintDbgScope("print-dbgscope", cl::Hidden,
48 cl::desc("Print DbgScope information for each machine instruction"));
50 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
52 cl::desc("Disable debug info printing"));
54 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
55 cl::desc("Make an absense of debug location information explicit."),
59 STATISTIC(BlocksWithoutLineNo, "Number of blocks without any line number");
63 const char *DWARFGroupName = "DWARF Emission";
64 const char *DbgTimerName = "DWARF Debug Writer";
65 } // end anonymous namespace
67 //===----------------------------------------------------------------------===//
69 /// Configuration values for initial hash set sizes (log2).
71 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
75 //===----------------------------------------------------------------------===//
76 /// CompileUnit - This dwarf writer support class manages information associate
77 /// with a source file.
79 /// ID - File identifier for source.
83 /// Die - Compile unit debug information entry.
85 const OwningPtr<DIE> CUDie;
87 /// IndexTyDie - An anonymous type for index type. Owned by CUDie.
90 /// MDNodeToDieMap - Tracks the mapping of unit level debug informaton
91 /// variables to debug information entries.
92 DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
94 /// MDNodeToDIEEntryMap - Tracks the mapping of unit level debug informaton
95 /// descriptors to debug information entries using a DIEEntry proxy.
96 DenseMap<const MDNode *, DIEEntry *> MDNodeToDIEEntryMap;
98 /// Globals - A map of globally visible named entities for this unit.
100 StringMap<DIE*> Globals;
102 /// GlobalTypes - A map of globally visible types for this unit.
104 StringMap<DIE*> GlobalTypes;
107 CompileUnit(unsigned I, DIE *D)
108 : ID(I), CUDie(D), IndexTyDie(0) {}
111 unsigned getID() const { return ID; }
112 DIE* getCUDie() const { return CUDie.get(); }
113 const StringMap<DIE*> &getGlobals() const { return Globals; }
114 const StringMap<DIE*> &getGlobalTypes() const { return GlobalTypes; }
116 /// hasContent - Return true if this compile unit has something to write out.
118 bool hasContent() const { return !CUDie->getChildren().empty(); }
120 /// addGlobal - Add a new global entity to the compile unit.
122 void addGlobal(StringRef Name, DIE *Die) { Globals[Name] = Die; }
124 /// addGlobalType - Add a new global type to the compile unit.
126 void addGlobalType(StringRef Name, DIE *Die) {
127 GlobalTypes[Name] = Die;
130 /// getDIE - Returns the debug information entry map slot for the
131 /// specified debug variable.
132 DIE *getDIE(const MDNode *N) { return MDNodeToDieMap.lookup(N); }
134 /// insertDIE - Insert DIE into the map.
135 void insertDIE(const MDNode *N, DIE *D) {
136 MDNodeToDieMap.insert(std::make_pair(N, D));
139 /// getDIEEntry - Returns the debug information entry for the speciefied
141 DIEEntry *getDIEEntry(const MDNode *N) {
142 DenseMap<const MDNode *, DIEEntry *>::iterator I =
143 MDNodeToDIEEntryMap.find(N);
144 if (I == MDNodeToDIEEntryMap.end())
149 /// insertDIEEntry - Insert debug information entry into the map.
150 void insertDIEEntry(const MDNode *N, DIEEntry *E) {
151 MDNodeToDIEEntryMap.insert(std::make_pair(N, E));
154 /// addDie - Adds or interns the DIE to the compile unit.
156 void addDie(DIE *Buffer) {
157 this->CUDie->addChild(Buffer);
160 // getIndexTyDie - Get an anonymous type for index type.
161 DIE *getIndexTyDie() {
165 // setIndexTyDie - Set D as anonymous type for index which can be reused
167 void setIndexTyDie(DIE *D) {
173 //===----------------------------------------------------------------------===//
174 /// DbgVariable - This class is used to track local variable information.
177 DIVariable Var; // Variable Descriptor.
178 DIE *TheDIE; // Variable DIE.
179 unsigned DotDebugLocOffset; // Offset in DotDebugLocEntries.
181 // AbsVar may be NULL.
182 DbgVariable(DIVariable V) : Var(V), TheDIE(0), DotDebugLocOffset(~0U) {}
185 DIVariable getVariable() const { return Var; }
186 void setDIE(DIE *D) { TheDIE = D; }
187 DIE *getDIE() const { return TheDIE; }
188 void setDotDebugLocOffset(unsigned O) { DotDebugLocOffset = O; }
189 unsigned getDotDebugLocOffset() const { return DotDebugLocOffset; }
190 StringRef getName() const { return Var.getName(); }
191 unsigned getTag() const { return Var.getTag(); }
192 bool variableHasComplexAddress() const {
193 assert(Var.Verify() && "Invalid complex DbgVariable!");
194 return Var.hasComplexAddress();
196 bool isBlockByrefVariable() const {
197 assert(Var.Verify() && "Invalid complex DbgVariable!");
198 return Var.isBlockByrefVariable();
200 unsigned getNumAddrElements() const {
201 assert(Var.Verify() && "Invalid complex DbgVariable!");
202 return Var.getNumAddrElements();
204 uint64_t getAddrElement(unsigned i) const {
205 return Var.getAddrElement(i);
207 DIType getType() const {
208 DIType Ty = Var.getType();
209 // FIXME: isBlockByrefVariable should be reformulated in terms of complex
210 // addresses instead.
211 if (Var.isBlockByrefVariable()) {
212 /* Byref variables, in Blocks, are declared by the programmer as
213 "SomeType VarName;", but the compiler creates a
214 __Block_byref_x_VarName struct, and gives the variable VarName
215 either the struct, or a pointer to the struct, as its type. This
216 is necessary for various behind-the-scenes things the compiler
217 needs to do with by-reference variables in blocks.
219 However, as far as the original *programmer* is concerned, the
220 variable should still have type 'SomeType', as originally declared.
222 The following function dives into the __Block_byref_x_VarName
223 struct to find the original type of the variable. This will be
224 passed back to the code generating the type for the Debug
225 Information Entry for the variable 'VarName'. 'VarName' will then
226 have the original type 'SomeType' in its debug information.
228 The original type 'SomeType' will be the type of the field named
229 'VarName' inside the __Block_byref_x_VarName struct.
231 NOTE: In order for this to not completely fail on the debugger
232 side, the Debug Information Entry for the variable VarName needs to
233 have a DW_AT_location that tells the debugger how to unwind through
234 the pointers and __Block_byref_x_VarName struct to find the actual
235 value of the variable. The function addBlockByrefType does this. */
237 unsigned tag = Ty.getTag();
239 if (tag == dwarf::DW_TAG_pointer_type) {
240 DIDerivedType DTy = DIDerivedType(Ty);
241 subType = DTy.getTypeDerivedFrom();
244 DICompositeType blockStruct = DICompositeType(subType);
245 DIArray Elements = blockStruct.getTypeArray();
247 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
248 DIDescriptor Element = Elements.getElement(i);
249 DIDerivedType DT = DIDerivedType(Element);
250 if (getName() == DT.getName())
251 return (DT.getTypeDerivedFrom());
259 //===----------------------------------------------------------------------===//
260 /// DbgRange - This is used to track range of instructions with identical
261 /// debug info scope.
263 typedef std::pair<const MachineInstr *, const MachineInstr *> DbgRange;
265 //===----------------------------------------------------------------------===//
266 /// DbgScope - This class is used to track scope information.
269 DbgScope *Parent; // Parent to this scope.
270 DIDescriptor Desc; // Debug info descriptor for scope.
271 // Location at which this scope is inlined.
272 AssertingVH<const MDNode> InlinedAtLocation;
273 bool AbstractScope; // Abstract Scope
274 const MachineInstr *LastInsn; // Last instruction of this scope.
275 const MachineInstr *FirstInsn; // First instruction of this scope.
276 unsigned DFSIn, DFSOut;
277 // Scopes defined in scope. Contents not owned.
278 SmallVector<DbgScope *, 4> Scopes;
279 // Variables declared in scope. Contents owned.
280 SmallVector<DbgVariable *, 8> Variables;
281 SmallVector<DbgRange, 4> Ranges;
282 // Private state for dump()
283 mutable unsigned IndentLevel;
285 DbgScope(DbgScope *P, DIDescriptor D, const MDNode *I = 0)
286 : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(false),
287 LastInsn(0), FirstInsn(0),
288 DFSIn(0), DFSOut(0), IndentLevel(0) {}
292 DbgScope *getParent() const { return Parent; }
293 void setParent(DbgScope *P) { Parent = P; }
294 DIDescriptor getDesc() const { return Desc; }
295 const MDNode *getInlinedAt() const { return InlinedAtLocation; }
296 const MDNode *getScopeNode() const { return Desc; }
297 const SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
298 const SmallVector<DbgVariable *, 8> &getDbgVariables() { return Variables; }
299 const SmallVector<DbgRange, 4> &getRanges() { return Ranges; }
301 /// openInsnRange - This scope covers instruction range starting from MI.
302 void openInsnRange(const MachineInstr *MI) {
307 Parent->openInsnRange(MI);
310 /// extendInsnRange - Extend the current instruction range covered by
312 void extendInsnRange(const MachineInstr *MI) {
313 assert (FirstInsn && "MI Range is not open!");
316 Parent->extendInsnRange(MI);
319 /// closeInsnRange - Create a range based on FirstInsn and LastInsn collected
320 /// until now. This is used when a new scope is encountered while walking
321 /// machine instructions.
322 void closeInsnRange(DbgScope *NewScope = NULL) {
323 assert (LastInsn && "Last insn missing!");
324 Ranges.push_back(DbgRange(FirstInsn, LastInsn));
327 // If Parent dominates NewScope then do not close Parent's instruction
329 if (Parent && (!NewScope || !Parent->dominates(NewScope)))
330 Parent->closeInsnRange(NewScope);
333 void setAbstractScope() { AbstractScope = true; }
334 bool isAbstractScope() const { return AbstractScope; }
336 // Depth First Search support to walk and mainpluate DbgScope hierarchy.
337 unsigned getDFSOut() const { return DFSOut; }
338 void setDFSOut(unsigned O) { DFSOut = O; }
339 unsigned getDFSIn() const { return DFSIn; }
340 void setDFSIn(unsigned I) { DFSIn = I; }
341 bool dominates(const DbgScope *S) {
344 if (DFSIn < S->getDFSIn() && DFSOut > S->getDFSOut())
349 /// addScope - Add a scope to the scope.
351 void addScope(DbgScope *S) { Scopes.push_back(S); }
353 /// addVariable - Add a variable to the scope.
355 void addVariable(DbgVariable *V) { Variables.push_back(V); }
362 } // end llvm namespace
365 void DbgScope::dump() const {
366 raw_ostream &err = dbgs();
367 err.indent(IndentLevel);
368 const MDNode *N = Desc;
371 err << "Abstract Scope\n";
375 err << "Children ...\n";
376 for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
377 if (Scopes[i] != this)
384 DbgScope::~DbgScope() {
385 for (unsigned j = 0, M = Variables.size(); j < M; ++j)
389 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
390 : Asm(A), MMI(Asm->MMI), FirstCU(0),
391 AbbreviationsSet(InitAbbreviationsSetSize),
392 CurrentFnDbgScope(0), PrevLabel(NULL) {
393 NextStringPoolNumber = 0;
395 DwarfFrameSectionSym = DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
396 DwarfStrSectionSym = TextSectionSym = 0;
397 DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
398 FunctionBeginSym = FunctionEndSym = 0;
399 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
401 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
405 DwarfDebug::~DwarfDebug() {
406 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
407 DIEBlocks[j]->~DIEBlock();
410 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
411 std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
412 if (Entry.first) return Entry.first;
414 Entry.second = NextStringPoolNumber++;
415 return Entry.first = Asm->GetTempSymbol("string", Entry.second);
419 /// assignAbbrevNumber - Define a unique number for the abbreviation.
421 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
422 // Profile the node so that we can make it unique.
426 // Check the set for priors.
427 DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
429 // If it's newly added.
430 if (InSet == &Abbrev) {
431 // Add to abbreviation list.
432 Abbreviations.push_back(&Abbrev);
434 // Assign the vector position + 1 as its number.
435 Abbrev.setNumber(Abbreviations.size());
437 // Assign existing abbreviation number.
438 Abbrev.setNumber(InSet->getNumber());
442 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
443 /// information entry.
444 DIEEntry *DwarfDebug::createDIEEntry(DIE *Entry) {
445 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
449 /// addUInt - Add an unsigned integer attribute data and value.
451 void DwarfDebug::addUInt(DIE *Die, unsigned Attribute,
452 unsigned Form, uint64_t Integer) {
453 if (!Form) Form = DIEInteger::BestForm(false, Integer);
454 DIEValue *Value = Integer == 1 ?
455 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
456 Die->addValue(Attribute, Form, Value);
459 /// addSInt - Add an signed integer attribute data and value.
461 void DwarfDebug::addSInt(DIE *Die, unsigned Attribute,
462 unsigned Form, int64_t Integer) {
463 if (!Form) Form = DIEInteger::BestForm(true, Integer);
464 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
465 Die->addValue(Attribute, Form, Value);
468 /// addString - Add a string attribute data and value. DIEString only
469 /// keeps string reference.
470 void DwarfDebug::addString(DIE *Die, unsigned Attribute, unsigned Form,
472 DIEValue *Value = new (DIEValueAllocator) DIEString(String);
473 Die->addValue(Attribute, Form, Value);
476 /// addLabel - Add a Dwarf label attribute data and value.
478 void DwarfDebug::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
479 const MCSymbol *Label) {
480 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
481 Die->addValue(Attribute, Form, Value);
484 /// addDelta - Add a label delta attribute data and value.
486 void DwarfDebug::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
487 const MCSymbol *Hi, const MCSymbol *Lo) {
488 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
489 Die->addValue(Attribute, Form, Value);
492 /// addDIEEntry - Add a DIE attribute data and value.
494 void DwarfDebug::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
496 Die->addValue(Attribute, Form, createDIEEntry(Entry));
500 /// addBlock - Add block data.
502 void DwarfDebug::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
504 Block->ComputeSize(Asm);
505 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
506 Die->addValue(Attribute, Block->BestForm(), Block);
509 /// addSourceLine - Add location information to specified debug information
511 void DwarfDebug::addSourceLine(DIE *Die, DIVariable V) {
516 unsigned Line = V.getLineNumber();
519 unsigned FileID = GetOrCreateSourceID(V.getContext().getFilename(),
520 V.getContext().getDirectory());
521 assert(FileID && "Invalid file id");
522 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
523 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
526 /// addSourceLine - Add location information to specified debug information
528 void DwarfDebug::addSourceLine(DIE *Die, DIGlobalVariable G) {
529 // Verify global variable.
533 unsigned Line = G.getLineNumber();
536 unsigned FileID = GetOrCreateSourceID(G.getContext().getFilename(),
537 G.getContext().getDirectory());
538 assert(FileID && "Invalid file id");
539 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
540 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
543 /// addSourceLine - Add location information to specified debug information
545 void DwarfDebug::addSourceLine(DIE *Die, DISubprogram SP) {
546 // Verify subprogram.
549 // If the line number is 0, don't add it.
550 if (SP.getLineNumber() == 0)
553 unsigned Line = SP.getLineNumber();
554 if (!SP.getContext().Verify())
556 unsigned FileID = GetOrCreateSourceID(SP.getFilename(), SP.getDirectory());
557 assert(FileID && "Invalid file id");
558 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
559 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
562 /// addSourceLine - Add location information to specified debug information
564 void DwarfDebug::addSourceLine(DIE *Die, DIType Ty) {
569 unsigned Line = Ty.getLineNumber();
570 if (Line == 0 || !Ty.getContext().Verify())
572 unsigned FileID = GetOrCreateSourceID(Ty.getFilename(), Ty.getDirectory());
573 assert(FileID && "Invalid file id");
574 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
575 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
578 /// addSourceLine - Add location information to specified debug information
580 void DwarfDebug::addSourceLine(DIE *Die, DINameSpace NS) {
585 unsigned Line = NS.getLineNumber();
588 StringRef FN = NS.getFilename();
590 unsigned FileID = GetOrCreateSourceID(FN, NS.getDirectory());
591 assert(FileID && "Invalid file id");
592 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
593 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
596 /// addVariableAddress - Add DW_AT_location attribute for a DbgVariable based
597 /// on provided frame index.
598 void DwarfDebug::addVariableAddress(DbgVariable *&DV, DIE *Die, int64_t FI) {
599 MachineLocation Location;
601 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
602 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
603 Location.set(FrameReg, Offset);
605 if (DV->variableHasComplexAddress())
606 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
607 else if (DV->isBlockByrefVariable())
608 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
610 addAddress(Die, dwarf::DW_AT_location, Location);
613 /// addComplexAddress - Start with the address based on the location provided,
614 /// and generate the DWARF information necessary to find the actual variable
615 /// given the extra address information encoded in the DIVariable, starting from
616 /// the starting location. Add the DWARF information to the die.
618 void DwarfDebug::addComplexAddress(DbgVariable *&DV, DIE *Die,
620 const MachineLocation &Location) {
621 DIType Ty = DV->getType();
623 // Decode the original location, and use that as the start of the byref
624 // variable's location.
625 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
626 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
627 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
629 if (Location.isReg()) {
631 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
633 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
634 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
638 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
640 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
641 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
644 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
647 for (unsigned i = 0, N = DV->getNumAddrElements(); i < N; ++i) {
648 uint64_t Element = DV->getAddrElement(i);
650 if (Element == DIBuilder::OpPlus) {
651 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
652 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
653 } else if (Element == DIBuilder::OpDeref) {
654 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
655 } else llvm_unreachable("unknown DIBuilder Opcode");
658 // Now attach the location information to the DIE.
659 addBlock(Die, Attribute, 0, Block);
662 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
663 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
664 gives the variable VarName either the struct, or a pointer to the struct, as
665 its type. This is necessary for various behind-the-scenes things the
666 compiler needs to do with by-reference variables in Blocks.
668 However, as far as the original *programmer* is concerned, the variable
669 should still have type 'SomeType', as originally declared.
671 The function getBlockByrefType dives into the __Block_byref_x_VarName
672 struct to find the original type of the variable, which is then assigned to
673 the variable's Debug Information Entry as its real type. So far, so good.
674 However now the debugger will expect the variable VarName to have the type
675 SomeType. So we need the location attribute for the variable to be an
676 expression that explains to the debugger how to navigate through the
677 pointers and struct to find the actual variable of type SomeType.
679 The following function does just that. We start by getting
680 the "normal" location for the variable. This will be the location
681 of either the struct __Block_byref_x_VarName or the pointer to the
682 struct __Block_byref_x_VarName.
684 The struct will look something like:
686 struct __Block_byref_x_VarName {
688 struct __Block_byref_x_VarName *forwarding;
689 ... <various other fields>
691 ... <maybe more fields>
694 If we are given the struct directly (as our starting point) we
695 need to tell the debugger to:
697 1). Add the offset of the forwarding field.
699 2). Follow that pointer to get the real __Block_byref_x_VarName
700 struct to use (the real one may have been copied onto the heap).
702 3). Add the offset for the field VarName, to find the actual variable.
704 If we started with a pointer to the struct, then we need to
705 dereference that pointer first, before the other steps.
706 Translating this into DWARF ops, we will need to append the following
707 to the current location description for the variable:
709 DW_OP_deref -- optional, if we start with a pointer
710 DW_OP_plus_uconst <forward_fld_offset>
712 DW_OP_plus_uconst <varName_fld_offset>
714 That is what this function does. */
716 /// addBlockByrefAddress - Start with the address based on the location
717 /// provided, and generate the DWARF information necessary to find the
718 /// actual Block variable (navigating the Block struct) based on the
719 /// starting location. Add the DWARF information to the die. For
720 /// more information, read large comment just above here.
722 void DwarfDebug::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
724 const MachineLocation &Location) {
725 DIType Ty = DV->getType();
727 unsigned Tag = Ty.getTag();
728 bool isPointer = false;
730 StringRef varName = DV->getName();
732 if (Tag == dwarf::DW_TAG_pointer_type) {
733 DIDerivedType DTy = DIDerivedType(Ty);
734 TmpTy = DTy.getTypeDerivedFrom();
738 DICompositeType blockStruct = DICompositeType(TmpTy);
740 // Find the __forwarding field and the variable field in the __Block_byref
742 DIArray Fields = blockStruct.getTypeArray();
743 DIDescriptor varField = DIDescriptor();
744 DIDescriptor forwardingField = DIDescriptor();
746 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
747 DIDescriptor Element = Fields.getElement(i);
748 DIDerivedType DT = DIDerivedType(Element);
749 StringRef fieldName = DT.getName();
750 if (fieldName == "__forwarding")
751 forwardingField = Element;
752 else if (fieldName == varName)
756 // Get the offsets for the forwarding field and the variable field.
757 unsigned forwardingFieldOffset =
758 DIDerivedType(forwardingField).getOffsetInBits() >> 3;
759 unsigned varFieldOffset =
760 DIDerivedType(varField).getOffsetInBits() >> 3;
762 // Decode the original location, and use that as the start of the byref
763 // variable's location.
764 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
765 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
766 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
768 if (Location.isReg()) {
770 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
772 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
773 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
777 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
779 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
780 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
783 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
786 // If we started with a pointer to the __Block_byref... struct, then
787 // the first thing we need to do is dereference the pointer (DW_OP_deref).
789 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
791 // Next add the offset for the '__forwarding' field:
792 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in
793 // adding the offset if it's 0.
794 if (forwardingFieldOffset > 0) {
795 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
796 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
799 // Now dereference the __forwarding field to get to the real __Block_byref
800 // struct: DW_OP_deref.
801 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
803 // Now that we've got the real __Block_byref... struct, add the offset
804 // for the variable's field to get to the location of the actual variable:
805 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0.
806 if (varFieldOffset > 0) {
807 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
808 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
811 // Now attach the location information to the DIE.
812 addBlock(Die, Attribute, 0, Block);
815 /// addAddress - Add an address attribute to a die based on the location
817 void DwarfDebug::addAddress(DIE *Die, unsigned Attribute,
818 const MachineLocation &Location) {
819 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
820 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
821 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
823 if (RI->getFrameRegister(*Asm->MF) == Location.getReg()
824 && Location.getOffset()) {
825 // If variable offset is based in frame register then use fbreg.
826 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
827 addSInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
828 addBlock(Die, Attribute, 0, Block);
832 if (Location.isReg()) {
834 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
836 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
837 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
841 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
843 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
844 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
847 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
850 addBlock(Die, Attribute, 0, Block);
853 /// addRegisterAddress - Add register location entry in variable DIE.
854 bool DwarfDebug::addRegisterAddress(DIE *Die, const MachineOperand &MO) {
855 assert (MO.isReg() && "Invalid machine operand!");
858 MachineLocation Location;
859 Location.set(MO.getReg());
860 addAddress(Die, dwarf::DW_AT_location, Location);
864 /// addConstantValue - Add constant value entry in variable DIE.
865 bool DwarfDebug::addConstantValue(DIE *Die, const MachineOperand &MO) {
866 assert (MO.isImm() && "Invalid machine operand!");
867 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
868 unsigned Imm = MO.getImm();
869 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm);
870 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
874 /// addConstantFPValue - Add constant value entry in variable DIE.
875 bool DwarfDebug::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
876 assert (MO.isFPImm() && "Invalid machine operand!");
877 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
878 APFloat FPImm = MO.getFPImm()->getValueAPF();
880 // Get the raw data form of the floating point.
881 const APInt FltVal = FPImm.bitcastToAPInt();
882 const char *FltPtr = (const char*)FltVal.getRawData();
884 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
885 bool LittleEndian = Asm->getTargetData().isLittleEndian();
886 int Incr = (LittleEndian ? 1 : -1);
887 int Start = (LittleEndian ? 0 : NumBytes - 1);
888 int Stop = (LittleEndian ? NumBytes : -1);
890 // Output the constant to DWARF one byte at a time.
891 for (; Start != Stop; Start += Incr)
892 addUInt(Block, 0, dwarf::DW_FORM_data1,
893 (unsigned char)0xFF & FltPtr[Start]);
895 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
899 /// addConstantValue - Add constant value entry in variable DIE.
900 bool DwarfDebug::addConstantValue(DIE *Die, ConstantInt *CI,
902 if (CI->getBitWidth() <= 64) {
904 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
907 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
912 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
914 // Get the raw data form of the large APInt.
915 const APInt Val = CI->getValue();
916 const char *Ptr = (const char*)Val.getRawData();
918 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
919 bool LittleEndian = Asm->getTargetData().isLittleEndian();
920 int Incr = (LittleEndian ? 1 : -1);
921 int Start = (LittleEndian ? 0 : NumBytes - 1);
922 int Stop = (LittleEndian ? NumBytes : -1);
924 // Output the constant to DWARF one byte at a time.
925 for (; Start != Stop; Start += Incr)
926 addUInt(Block, 0, dwarf::DW_FORM_data1,
927 (unsigned char)0xFF & Ptr[Start]);
929 addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
933 /// addToContextOwner - Add Die into the list of its context owner's children.
934 void DwarfDebug::addToContextOwner(DIE *Die, DIDescriptor Context) {
935 if (Context.isType()) {
936 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
937 ContextDIE->addChild(Die);
938 } else if (Context.isNameSpace()) {
939 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
940 ContextDIE->addChild(Die);
941 } else if (Context.isSubprogram()) {
942 DIE *ContextDIE = createSubprogramDIE(DISubprogram(Context));
943 ContextDIE->addChild(Die);
944 } else if (DIE *ContextDIE = getCompileUnit(Context)->getDIE(Context))
945 ContextDIE->addChild(Die);
947 getCompileUnit(Context)->addDie(Die);
950 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
952 DIE *DwarfDebug::getOrCreateTypeDIE(DIType Ty) {
953 CompileUnit *TypeCU = getCompileUnit(Ty);
954 DIE *TyDIE = TypeCU->getDIE(Ty);
959 TyDIE = new DIE(dwarf::DW_TAG_base_type);
960 TypeCU->insertDIE(Ty, TyDIE);
961 if (Ty.isBasicType())
962 constructTypeDIE(*TyDIE, DIBasicType(Ty));
963 else if (Ty.isCompositeType())
964 constructTypeDIE(*TyDIE, DICompositeType(Ty));
966 assert(Ty.isDerivedType() && "Unknown kind of DIType");
967 constructTypeDIE(*TyDIE, DIDerivedType(Ty));
970 addToContextOwner(TyDIE, Ty.getContext());
974 /// addType - Add a new type attribute to the specified entity.
975 void DwarfDebug::addType(DIE *Entity, DIType Ty) {
979 // Check for pre-existence.
980 CompileUnit *TypeCU = getCompileUnit(Ty);
981 DIEEntry *Entry = TypeCU->getDIEEntry(Ty);
982 // If it exists then use the existing value.
984 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
989 DIE *Buffer = getOrCreateTypeDIE(Ty);
992 Entry = createDIEEntry(Buffer);
993 TypeCU->insertDIEEntry(Ty, Entry);
995 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry);
998 /// constructTypeDIE - Construct basic type die from DIBasicType.
999 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
1000 // Get core information.
1001 StringRef Name = BTy.getName();
1002 Buffer.setTag(dwarf::DW_TAG_base_type);
1003 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1006 // Add name if not anonymous or intermediate type.
1008 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1009 uint64_t Size = BTy.getSizeInBits() >> 3;
1010 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1013 /// constructTypeDIE - Construct derived type die from DIDerivedType.
1014 void DwarfDebug::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
1015 // Get core information.
1016 StringRef Name = DTy.getName();
1017 uint64_t Size = DTy.getSizeInBits() >> 3;
1018 unsigned Tag = DTy.getTag();
1020 // FIXME - Workaround for templates.
1021 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
1025 // Map to main type, void will not have a type.
1026 DIType FromTy = DTy.getTypeDerivedFrom();
1027 addType(&Buffer, FromTy);
1029 // Add name if not anonymous or intermediate type.
1031 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1033 // Add size if non-zero (derived types might be zero-sized.)
1035 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1037 // Add source line info if available and TyDesc is not a forward declaration.
1038 if (!DTy.isForwardDecl())
1039 addSourceLine(&Buffer, DTy);
1042 /// constructTypeDIE - Construct type DIE from DICompositeType.
1043 void DwarfDebug::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
1044 // Get core information.
1045 StringRef Name = CTy.getName();
1047 uint64_t Size = CTy.getSizeInBits() >> 3;
1048 unsigned Tag = CTy.getTag();
1052 case dwarf::DW_TAG_vector_type:
1053 case dwarf::DW_TAG_array_type:
1054 constructArrayTypeDIE(Buffer, &CTy);
1056 case dwarf::DW_TAG_enumeration_type: {
1057 DIArray Elements = CTy.getTypeArray();
1059 // Add enumerators to enumeration type.
1060 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1061 DIE *ElemDie = NULL;
1062 DIDescriptor Enum(Elements.getElement(i));
1063 if (Enum.isEnumerator()) {
1064 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
1065 Buffer.addChild(ElemDie);
1070 case dwarf::DW_TAG_subroutine_type: {
1072 DIArray Elements = CTy.getTypeArray();
1073 DIDescriptor RTy = Elements.getElement(0);
1074 addType(&Buffer, DIType(RTy));
1076 bool isPrototyped = true;
1078 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
1079 DIDescriptor Ty = Elements.getElement(i);
1080 if (Ty.isUnspecifiedParameter()) {
1081 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
1082 Buffer.addChild(Arg);
1083 isPrototyped = false;
1085 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1086 addType(Arg, DIType(Ty));
1087 Buffer.addChild(Arg);
1090 // Add prototype flag.
1092 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1095 case dwarf::DW_TAG_structure_type:
1096 case dwarf::DW_TAG_union_type:
1097 case dwarf::DW_TAG_class_type: {
1098 // Add elements to structure type.
1099 DIArray Elements = CTy.getTypeArray();
1101 // A forward struct declared type may not have elements available.
1102 unsigned N = Elements.getNumElements();
1106 // Add elements to structure type.
1107 for (unsigned i = 0; i < N; ++i) {
1108 DIDescriptor Element = Elements.getElement(i);
1109 DIE *ElemDie = NULL;
1110 if (Element.isSubprogram()) {
1111 DISubprogram SP(Element);
1112 ElemDie = createSubprogramDIE(DISubprogram(Element));
1113 if (SP.isProtected())
1114 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1115 dwarf::DW_ACCESS_protected);
1116 else if (SP.isPrivate())
1117 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1118 dwarf::DW_ACCESS_private);
1120 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1121 dwarf::DW_ACCESS_public);
1122 if (SP.isExplicit())
1123 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
1125 else if (Element.isVariable()) {
1126 DIVariable DV(Element);
1127 ElemDie = new DIE(dwarf::DW_TAG_variable);
1128 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string,
1130 addType(ElemDie, DV.getType());
1131 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1132 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1133 addSourceLine(ElemDie, DV);
1134 } else if (Element.isDerivedType())
1135 ElemDie = createMemberDIE(DIDerivedType(Element));
1138 Buffer.addChild(ElemDie);
1141 if (CTy.isAppleBlockExtension())
1142 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
1144 unsigned RLang = CTy.getRunTimeLang();
1146 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1147 dwarf::DW_FORM_data1, RLang);
1149 DICompositeType ContainingType = CTy.getContainingType();
1150 if (DIDescriptor(ContainingType).isCompositeType())
1151 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1152 getOrCreateTypeDIE(DIType(ContainingType)));
1154 DIDescriptor Context = CTy.getContext();
1155 addToContextOwner(&Buffer, Context);
1158 if (Tag == dwarf::DW_TAG_class_type) {
1159 DIArray TParams = CTy.getTemplateParams();
1160 unsigned N = TParams.getNumElements();
1161 // Add template parameters.
1162 for (unsigned i = 0; i < N; ++i) {
1163 DIDescriptor Element = TParams.getElement(i);
1164 if (Element.isTemplateTypeParameter())
1165 Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
1166 DITemplateTypeParameter(Element)));
1167 else if (Element.isTemplateValueParameter())
1168 Buffer.addChild(getOrCreateTemplateValueParameterDIE(
1169 DITemplateValueParameter(Element)));
1178 // Add name if not anonymous or intermediate type.
1180 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1182 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
1183 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
1185 // Add size if non-zero (derived types might be zero-sized.)
1187 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1189 // Add zero size if it is not a forward declaration.
1190 if (CTy.isForwardDecl())
1191 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1193 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1196 // Add source line info if available.
1197 if (!CTy.isForwardDecl())
1198 addSourceLine(&Buffer, CTy);
1202 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1203 /// for the given DITemplateTypeParameter.
1205 DwarfDebug::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1206 CompileUnit *TypeCU = getCompileUnit(TP);
1207 DIE *ParamDIE = TypeCU->getDIE(TP);
1211 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1212 addType(ParamDIE, TP.getType());
1213 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName());
1217 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1218 /// for the given DITemplateValueParameter.
1220 DwarfDebug::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
1221 CompileUnit *TVCU = getCompileUnit(TPV);
1222 DIE *ParamDIE = TVCU->getDIE(TPV);
1226 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
1227 addType(ParamDIE, TPV.getType());
1228 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName());
1229 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
1234 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1235 void DwarfDebug::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1236 int64_t L = SR.getLo();
1237 int64_t H = SR.getHi();
1238 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1240 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1242 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1243 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1245 Buffer.addChild(DW_Subrange);
1248 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1249 void DwarfDebug::constructArrayTypeDIE(DIE &Buffer,
1250 DICompositeType *CTy) {
1251 Buffer.setTag(dwarf::DW_TAG_array_type);
1252 if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1253 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1255 // Emit derived type.
1256 addType(&Buffer, CTy->getTypeDerivedFrom());
1257 DIArray Elements = CTy->getTypeArray();
1259 // Get an anonymous type for index type.
1260 CompileUnit *TheCU = getCompileUnit(*CTy);
1261 DIE *IdxTy = TheCU->getIndexTyDie();
1263 // Construct an anonymous type for index type.
1264 IdxTy = new DIE(dwarf::DW_TAG_base_type);
1265 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1266 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1267 dwarf::DW_ATE_signed);
1268 TheCU->addDie(IdxTy);
1269 TheCU->setIndexTyDie(IdxTy);
1272 // Add subranges to array type.
1273 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1274 DIDescriptor Element = Elements.getElement(i);
1275 if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1276 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1280 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1281 DIE *DwarfDebug::constructEnumTypeDIE(DIEnumerator ETy) {
1282 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1283 StringRef Name = ETy.getName();
1284 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1285 int64_t Value = ETy.getEnumValue();
1286 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1290 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1291 /// printer to not emit usual symbol prefix before the symbol name is used then
1292 /// return linkage name after skipping this special LLVM prefix.
1293 static StringRef getRealLinkageName(StringRef LinkageName) {
1295 if (LinkageName.startswith(StringRef(&One, 1)))
1296 return LinkageName.substr(1);
1300 /// createMemberDIE - Create new member DIE.
1301 DIE *DwarfDebug::createMemberDIE(DIDerivedType DT) {
1302 DIE *MemberDie = new DIE(DT.getTag());
1303 StringRef Name = DT.getName();
1305 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1307 addType(MemberDie, DT.getTypeDerivedFrom());
1309 addSourceLine(MemberDie, DT);
1311 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1312 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1314 uint64_t Size = DT.getSizeInBits();
1315 uint64_t FieldSize = DT.getOriginalTypeSize();
1317 if (Size != FieldSize) {
1319 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1320 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1322 uint64_t Offset = DT.getOffsetInBits();
1323 uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1324 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1325 uint64_t FieldOffset = (HiMark - FieldSize);
1326 Offset -= FieldOffset;
1328 // Maybe we need to work from the other end.
1329 if (Asm->getTargetData().isLittleEndian())
1330 Offset = FieldSize - (Offset + Size);
1331 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1333 // Here WD_AT_data_member_location points to the anonymous
1334 // field that includes this bit field.
1335 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1338 // This is not a bitfield.
1339 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1341 if (DT.getTag() == dwarf::DW_TAG_inheritance
1342 && DT.isVirtual()) {
1344 // For C++, virtual base classes are not at fixed offset. Use following
1345 // expression to extract appropriate offset from vtable.
1346 // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1348 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1349 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1350 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1351 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1352 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1353 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1354 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1355 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1357 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1360 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1362 if (DT.isProtected())
1363 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1364 dwarf::DW_ACCESS_protected);
1365 else if (DT.isPrivate())
1366 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1367 dwarf::DW_ACCESS_private);
1368 // Otherwise C++ member and base classes are considered public.
1369 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus)
1370 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag,
1371 dwarf::DW_ACCESS_public);
1373 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag,
1374 dwarf::DW_VIRTUALITY_virtual);
1378 /// createSubprogramDIE - Create new DIE using SP.
1379 DIE *DwarfDebug::createSubprogramDIE(DISubprogram SP) {
1380 CompileUnit *SPCU = getCompileUnit(SP);
1381 DIE *SPDie = SPCU->getDIE(SP);
1385 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1386 // Constructors and operators for anonymous aggregates do not have names.
1387 if (!SP.getName().empty())
1388 addString(SPDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, SP.getName());
1390 StringRef LinkageName = SP.getLinkageName();
1391 if (!LinkageName.empty())
1392 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
1393 getRealLinkageName(LinkageName));
1395 addSourceLine(SPDie, SP);
1397 if (SP.isPrototyped())
1398 addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1401 DICompositeType SPTy = SP.getType();
1402 DIArray Args = SPTy.getTypeArray();
1403 unsigned SPTag = SPTy.getTag();
1405 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1406 addType(SPDie, SPTy);
1408 addType(SPDie, DIType(Args.getElement(0)));
1410 unsigned VK = SP.getVirtuality();
1412 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, VK);
1413 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1414 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1415 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1416 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1417 ContainingTypeMap.insert(std::make_pair(SPDie,
1418 SP.getContainingType()));
1421 if (!SP.isDefinition()) {
1422 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1424 // Add arguments. Do not add arguments for subprogram definition. They will
1425 // be handled while processing variables.
1426 DICompositeType SPTy = SP.getType();
1427 DIArray Args = SPTy.getTypeArray();
1428 unsigned SPTag = SPTy.getTag();
1430 if (SPTag == dwarf::DW_TAG_subroutine_type)
1431 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1432 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1433 DIType ATy = DIType(DIType(Args.getElement(i)));
1435 if (ATy.isArtificial())
1436 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1437 SPDie->addChild(Arg);
1441 if (SP.isArtificial())
1442 addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1444 if (!SP.isLocalToUnit())
1445 addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1447 if (SP.isOptimized())
1448 addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1450 if (unsigned isa = Asm->getISAEncoding()) {
1451 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1454 // DW_TAG_inlined_subroutine may refer to this DIE.
1455 SPCU->insertDIE(SP, SPDie);
1457 // Add to context owner.
1458 addToContextOwner(SPDie, SP.getContext());
1463 DbgScope *DwarfDebug::getOrCreateAbstractScope(const MDNode *N) {
1464 assert(N && "Invalid Scope encoding!");
1466 DbgScope *AScope = AbstractScopes.lookup(N);
1470 DbgScope *Parent = NULL;
1472 DIDescriptor Scope(N);
1473 if (Scope.isLexicalBlock()) {
1474 DILexicalBlock DB(N);
1475 DIDescriptor ParentDesc = DB.getContext();
1476 Parent = getOrCreateAbstractScope(ParentDesc);
1479 AScope = new DbgScope(Parent, DIDescriptor(N), NULL);
1482 Parent->addScope(AScope);
1483 AScope->setAbstractScope();
1484 AbstractScopes[N] = AScope;
1485 if (DIDescriptor(N).isSubprogram())
1486 AbstractScopesList.push_back(AScope);
1490 /// isSubprogramContext - Return true if Context is either a subprogram
1491 /// or another context nested inside a subprogram.
1492 static bool isSubprogramContext(const MDNode *Context) {
1495 DIDescriptor D(Context);
1496 if (D.isSubprogram())
1499 return isSubprogramContext(DIType(Context).getContext());
1503 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
1504 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
1505 /// If there are global variables in this scope then create and insert
1506 /// DIEs for these variables.
1507 DIE *DwarfDebug::updateSubprogramScopeDIE(const MDNode *SPNode) {
1508 CompileUnit *SPCU = getCompileUnit(SPNode);
1509 DIE *SPDie = SPCU->getDIE(SPNode);
1511 assert(SPDie && "Unable to find subprogram DIE!");
1512 DISubprogram SP(SPNode);
1514 // There is not any need to generate specification DIE for a function
1515 // defined at compile unit level. If a function is defined inside another
1516 // function then gdb prefers the definition at top level and but does not
1517 // expect specification DIE in parent function. So avoid creating
1518 // specification DIE for a function defined inside a function.
1519 if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
1520 !SP.getContext().isFile() &&
1521 !isSubprogramContext(SP.getContext())) {
1522 addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1525 DICompositeType SPTy = SP.getType();
1526 DIArray Args = SPTy.getTypeArray();
1527 unsigned SPTag = SPTy.getTag();
1528 if (SPTag == dwarf::DW_TAG_subroutine_type)
1529 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
1530 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1531 DIType ATy = DIType(DIType(Args.getElement(i)));
1533 if (ATy.isArtificial())
1534 addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1535 SPDie->addChild(Arg);
1537 DIE *SPDeclDie = SPDie;
1538 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1539 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1541 SPCU->addDie(SPDie);
1544 // Pick up abstract subprogram DIE.
1545 if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
1546 SPDie = new DIE(dwarf::DW_TAG_subprogram);
1547 addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
1548 dwarf::DW_FORM_ref4, AbsSPDIE);
1549 SPCU->addDie(SPDie);
1552 addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
1553 Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
1554 addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
1555 Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
1556 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
1557 MachineLocation Location(RI->getFrameRegister(*Asm->MF));
1558 addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
1563 /// constructLexicalScope - Construct new DW_TAG_lexical_block
1564 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
1565 DIE *DwarfDebug::constructLexicalScopeDIE(DbgScope *Scope) {
1567 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
1568 if (Scope->isAbstractScope())
1571 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1575 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1576 if (Ranges.size() > 1) {
1577 // .debug_range section has not been laid out yet. Emit offset in
1578 // .debug_range as a uint, size 4, for now. emitDIE will handle
1579 // DW_AT_ranges appropriately.
1580 addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
1581 DebugRangeSymbols.size() * Asm->getTargetData().getPointerSize());
1582 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
1583 RE = Ranges.end(); RI != RE; ++RI) {
1584 DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
1585 DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
1587 DebugRangeSymbols.push_back(NULL);
1588 DebugRangeSymbols.push_back(NULL);
1592 const MCSymbol *Start = getLabelBeforeInsn(RI->first);
1593 const MCSymbol *End = getLabelAfterInsn(RI->second);
1595 if (End == 0) return 0;
1597 assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
1598 assert(End->isDefined() && "Invalid end label for an inlined scope!");
1600 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
1601 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
1606 /// constructInlinedScopeDIE - This scope represents inlined body of
1607 /// a function. Construct DIE to represent this concrete inlined copy
1608 /// of the function.
1609 DIE *DwarfDebug::constructInlinedScopeDIE(DbgScope *Scope) {
1611 const SmallVector<DbgRange, 4> &Ranges = Scope->getRanges();
1612 assert (Ranges.empty() == false
1613 && "DbgScope does not have instruction markers!");
1615 // FIXME : .debug_inlined section specification does not clearly state how
1616 // to emit inlined scope that is split into multiple instruction ranges.
1617 // For now, use first instruction range and emit low_pc/high_pc pair and
1618 // corresponding .debug_inlined section entry for this pair.
1619 SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin();
1620 const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
1621 const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
1623 if (StartLabel == 0 || EndLabel == 0) {
1624 assert (0 && "Unexpected Start and End labels for a inlined scope!");
1627 assert(StartLabel->isDefined() &&
1628 "Invalid starting label for an inlined scope!");
1629 assert(EndLabel->isDefined() &&
1630 "Invalid end label for an inlined scope!");
1632 if (!Scope->getScopeNode())
1634 DIScope DS(Scope->getScopeNode());
1635 DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
1637 DISubprogram InlinedSP = getDISubprogram(DS);
1638 CompileUnit *TheCU = getCompileUnit(InlinedSP);
1639 DIE *OriginDIE = TheCU->getDIE(InlinedSP);
1640 assert(OriginDIE && "Unable to find Origin DIE!");
1641 addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
1642 dwarf::DW_FORM_ref4, OriginDIE);
1644 addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, StartLabel);
1645 addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, EndLabel);
1647 InlinedSubprogramDIEs.insert(OriginDIE);
1649 // Track the start label for this inlined function.
1650 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
1651 I = InlineInfo.find(InlinedSP);
1653 if (I == InlineInfo.end()) {
1654 InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel,
1656 InlinedSPNodes.push_back(InlinedSP);
1658 I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
1660 DILocation DL(Scope->getInlinedAt());
1661 addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
1662 addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
1668 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1669 DIE *DwarfDebug::constructVariableDIE(DbgVariable *DV, DbgScope *Scope) {
1670 StringRef Name = DV->getName();
1674 // Translate tag to proper Dwarf tag. The result variable is dropped for
1677 switch (DV->getTag()) {
1678 case dwarf::DW_TAG_return_variable:
1680 case dwarf::DW_TAG_arg_variable:
1681 Tag = dwarf::DW_TAG_formal_parameter;
1683 case dwarf::DW_TAG_auto_variable: // fall thru
1685 Tag = dwarf::DW_TAG_variable;
1689 // Define variable debug information entry.
1690 DIE *VariableDie = new DIE(Tag);
1693 DenseMap<const DbgVariable *, const DbgVariable *>::iterator
1694 V2AVI = VarToAbstractVarMap.find(DV);
1695 if (V2AVI != VarToAbstractVarMap.end())
1696 AbsDIE = V2AVI->second->getDIE();
1699 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1700 dwarf::DW_FORM_ref4, AbsDIE);
1702 addString(VariableDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name);
1703 addSourceLine(VariableDie, DV->getVariable());
1705 // Add variable type.
1706 addType(VariableDie, DV->getType());
1709 if (Tag == dwarf::DW_TAG_formal_parameter && DV->getType().isArtificial())
1710 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1711 else if (DIVariable(DV->getVariable()).isArtificial())
1712 addUInt(VariableDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1714 if (Scope->isAbstractScope()) {
1715 DV->setDIE(VariableDie);
1719 // Add variable address.
1721 unsigned Offset = DV->getDotDebugLocOffset();
1722 if (Offset != ~0U) {
1723 addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1724 Asm->GetTempSymbol("debug_loc", Offset));
1725 DV->setDIE(VariableDie);
1726 UseDotDebugLocEntry.insert(VariableDie);
1730 // Check if variable is described by a DBG_VALUE instruction.
1731 DenseMap<const DbgVariable *, const MachineInstr *>::iterator DVI =
1732 DbgVariableToDbgInstMap.find(DV);
1733 if (DVI != DbgVariableToDbgInstMap.end()) {
1734 const MachineInstr *DVInsn = DVI->second;
1735 bool updated = false;
1736 // FIXME : Handle getNumOperands != 3
1737 if (DVInsn->getNumOperands() == 3) {
1738 if (DVInsn->getOperand(0).isReg()) {
1739 const MachineOperand RegOp = DVInsn->getOperand(0);
1740 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1741 if (DVInsn->getOperand(1).isImm() &&
1742 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1743 addVariableAddress(DV, VariableDie, DVInsn->getOperand(1).getImm());
1746 updated = addRegisterAddress(VariableDie, RegOp);
1748 else if (DVInsn->getOperand(0).isImm())
1749 updated = addConstantValue(VariableDie, DVInsn->getOperand(0));
1750 else if (DVInsn->getOperand(0).isFPImm())
1752 addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1754 MachineLocation Location = Asm->getDebugValueLocation(DVInsn);
1755 if (Location.getReg()) {
1756 addAddress(VariableDie, dwarf::DW_AT_location, Location);
1761 // If variableDie is not updated then DBG_VALUE instruction does not
1762 // have valid variable info.
1766 DV->setDIE(VariableDie);
1770 // .. else use frame index, if available.
1772 if (findVariableFrameIndex(DV, &FI))
1773 addVariableAddress(DV, VariableDie, FI);
1775 DV->setDIE(VariableDie);
1780 void DwarfDebug::addPubTypes(DISubprogram SP) {
1781 DICompositeType SPTy = SP.getType();
1782 unsigned SPTag = SPTy.getTag();
1783 if (SPTag != dwarf::DW_TAG_subroutine_type)
1786 DIArray Args = SPTy.getTypeArray();
1787 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
1788 DIType ATy(Args.getElement(i));
1791 DICompositeType CATy = getDICompositeType(ATy);
1792 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty()
1793 && !CATy.isForwardDecl()) {
1794 CompileUnit *TheCU = getCompileUnit(CATy);
1795 if (DIEEntry *Entry = TheCU->getDIEEntry(CATy))
1796 TheCU->addGlobalType(CATy.getName(), Entry->getEntry());
1801 /// constructScopeDIE - Construct a DIE for this scope.
1802 DIE *DwarfDebug::constructScopeDIE(DbgScope *Scope) {
1803 if (!Scope || !Scope->getScopeNode())
1806 SmallVector <DIE *, 8> Children;
1808 // Collect arguments for current function.
1809 if (Scope == CurrentFnDbgScope)
1810 for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
1811 if (DbgVariable *ArgDV = CurrentFnArguments[i])
1812 if (DIE *Arg = constructVariableDIE(ArgDV, Scope))
1813 Children.push_back(Arg);
1815 // Collect lexical scope childrens first.
1816 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
1817 for (unsigned i = 0, N = Variables.size(); i < N; ++i)
1818 if (DIE *Variable = constructVariableDIE(Variables[i], Scope))
1819 Children.push_back(Variable);
1820 const SmallVector<DbgScope *, 4> &Scopes = Scope->getScopes();
1821 for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
1822 if (DIE *Nested = constructScopeDIE(Scopes[j]))
1823 Children.push_back(Nested);
1824 DIScope DS(Scope->getScopeNode());
1825 DIE *ScopeDIE = NULL;
1826 if (Scope->getInlinedAt())
1827 ScopeDIE = constructInlinedScopeDIE(Scope);
1828 else if (DS.isSubprogram()) {
1829 ProcessedSPNodes.insert(DS);
1830 if (Scope->isAbstractScope()) {
1831 ScopeDIE = getCompileUnit(DS)->getDIE(DS);
1832 // Note down abstract DIE.
1834 AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
1837 ScopeDIE = updateSubprogramScopeDIE(DS);
1840 // There is no need to emit empty lexical block DIE.
1841 if (Children.empty())
1843 ScopeDIE = constructLexicalScopeDIE(Scope);
1846 if (!ScopeDIE) return NULL;
1849 for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
1850 E = Children.end(); I != E; ++I)
1851 ScopeDIE->addChild(*I);
1853 if (DS.isSubprogram())
1854 addPubTypes(DISubprogram(DS));
1859 /// GetOrCreateSourceID - Look up the source id with the given directory and
1860 /// source file names. If none currently exists, create a new id and insert it
1861 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
1864 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
1865 StringRef DirName) {
1866 // If FE did not provide a file name, then assume stdin.
1867 if (FileName.empty())
1868 return GetOrCreateSourceID("<stdin>", StringRef());
1870 // MCStream expects full path name as filename.
1871 if (!DirName.empty() && !FileName.startswith("/")) {
1872 std::string FullPathName(DirName.data());
1873 if (!DirName.endswith("/"))
1874 FullPathName += "/";
1875 FullPathName += FileName.data();
1876 // Here FullPathName will be copied into StringMap by GetOrCreateSourceID.
1877 return GetOrCreateSourceID(StringRef(FullPathName), StringRef());
1880 StringMapEntry<unsigned> &Entry = SourceIdMap.GetOrCreateValue(FileName);
1881 if (Entry.getValue())
1882 return Entry.getValue();
1884 unsigned SrcId = SourceIdMap.size();
1885 Entry.setValue(SrcId);
1887 // Print out a .file directive to specify files for .loc directives.
1888 Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
1893 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1894 DIE *DwarfDebug::getOrCreateNameSpace(DINameSpace NS) {
1895 CompileUnit *TheCU = getCompileUnit(NS);
1896 DIE *NDie = TheCU->getDIE(NS);
1899 NDie = new DIE(dwarf::DW_TAG_namespace);
1900 TheCU->insertDIE(NS, NDie);
1901 if (!NS.getName().empty())
1902 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName());
1903 addSourceLine(NDie, NS);
1904 addToContextOwner(NDie, NS.getContext());
1908 /// constructCompileUnit - Create new CompileUnit for the given
1909 /// metadata node with tag DW_TAG_compile_unit.
1910 void DwarfDebug::constructCompileUnit(const MDNode *N) {
1911 DICompileUnit DIUnit(N);
1912 StringRef FN = DIUnit.getFilename();
1913 StringRef Dir = DIUnit.getDirectory();
1914 unsigned ID = GetOrCreateSourceID(FN, Dir);
1916 DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
1917 addString(Die, dwarf::DW_AT_producer, dwarf::DW_FORM_string,
1918 DIUnit.getProducer());
1919 addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
1920 DIUnit.getLanguage());
1921 addString(Die, dwarf::DW_AT_name, dwarf::DW_FORM_string, FN);
1922 // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
1923 // simplifies debug range entries.
1924 addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
1925 // DW_AT_stmt_list is a offset of line number information for this
1926 // compile unit in debug_line section.
1927 if (Asm->MAI->doesDwarfUsesAbsoluteLabelForStmtList())
1928 addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_addr,
1929 Asm->GetTempSymbol("section_line"));
1931 addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
1934 addString(Die, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string, Dir);
1935 if (DIUnit.isOptimized())
1936 addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1938 StringRef Flags = DIUnit.getFlags();
1940 addString(Die, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string, Flags);
1942 unsigned RVer = DIUnit.getRunTimeVersion();
1944 addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
1945 dwarf::DW_FORM_data1, RVer);
1947 CompileUnit *NewCU = new CompileUnit(ID, Die);
1950 CUMap.insert(std::make_pair(N, NewCU));
1953 /// getCompielUnit - Get CompileUnit DIE.
1954 CompileUnit *DwarfDebug::getCompileUnit(const MDNode *N) const {
1955 assert (N && "Invalid DwarfDebug::getCompileUnit argument!");
1957 const MDNode *CUNode = NULL;
1958 if (D.isCompileUnit())
1960 else if (D.isSubprogram())
1961 CUNode = DISubprogram(N).getCompileUnit();
1962 else if (D.isType())
1963 CUNode = DIType(N).getCompileUnit();
1964 else if (D.isGlobalVariable())
1965 CUNode = DIGlobalVariable(N).getCompileUnit();
1966 else if (D.isVariable())
1967 CUNode = DIVariable(N).getCompileUnit();
1968 else if (D.isNameSpace())
1969 CUNode = DINameSpace(N).getCompileUnit();
1970 else if (D.isFile())
1971 CUNode = DIFile(N).getCompileUnit();
1975 DenseMap<const MDNode *, CompileUnit *>::const_iterator I
1976 = CUMap.find(CUNode);
1977 if (I == CUMap.end())
1982 /// isUnsignedDIType - Return true if type encoding is unsigned.
1983 static bool isUnsignedDIType(DIType Ty) {
1984 DIDerivedType DTy(Ty);
1986 return isUnsignedDIType(DTy.getTypeDerivedFrom());
1988 DIBasicType BTy(Ty);
1990 unsigned Encoding = BTy.getEncoding();
1991 if (Encoding == dwarf::DW_ATE_unsigned ||
1992 Encoding == dwarf::DW_ATE_unsigned_char)
1998 // Return const exprssion if value is a GEP to access merged global
2000 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
2001 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
2002 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
2003 if (!CE || CE->getNumOperands() != 3 ||
2004 CE->getOpcode() != Instruction::GetElementPtr)
2007 // First operand points to a global value.
2008 if (!isa<GlobalValue>(CE->getOperand(0)))
2011 // Second operand is zero.
2012 const ConstantInt *CI =
2013 dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
2014 if (!CI || !CI->isZero())
2017 // Third operand is offset.
2018 if (!isa<ConstantInt>(CE->getOperand(2)))
2024 /// constructGlobalVariableDIE - Construct global variable DIE.
2025 void DwarfDebug::constructGlobalVariableDIE(const MDNode *N) {
2026 DIGlobalVariable GV(N);
2028 // If debug information is malformed then ignore it.
2029 if (GV.Verify() == false)
2032 // Check for pre-existence.
2033 CompileUnit *TheCU = getCompileUnit(N);
2034 if (TheCU->getDIE(GV))
2037 DIType GTy = GV.getType();
2038 DIE *VariableDIE = new DIE(GV.getTag());
2040 bool isGlobalVariable = GV.getGlobal() != NULL;
2043 addString(VariableDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string,
2044 GV.getDisplayName());
2045 StringRef LinkageName = GV.getLinkageName();
2046 if (!LinkageName.empty() && isGlobalVariable)
2047 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, dwarf::DW_FORM_string,
2048 getRealLinkageName(LinkageName));
2050 addType(VariableDIE, GTy);
2051 if (GTy.isCompositeType() && !GTy.getName().empty()
2052 && !GTy.isForwardDecl()) {
2053 DIEEntry *Entry = TheCU->getDIEEntry(GTy);
2054 assert(Entry && "Missing global type!");
2055 TheCU->addGlobalType(GTy.getName(), Entry->getEntry());
2057 // Add scoping info.
2058 if (!GV.isLocalToUnit()) {
2059 addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
2060 // Expose as global.
2061 TheCU->addGlobal(GV.getName(), VariableDIE);
2063 // Add line number info.
2064 addSourceLine(VariableDIE, GV);
2066 TheCU->insertDIE(N, VariableDIE);
2067 // Add to context owner.
2068 DIDescriptor GVContext = GV.getContext();
2069 addToContextOwner(VariableDIE, GVContext);
2071 if (isGlobalVariable) {
2072 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2073 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2074 addLabel(Block, 0, dwarf::DW_FORM_udata,
2075 Asm->Mang->getSymbol(GV.getGlobal()));
2076 // Do not create specification DIE if context is either compile unit
2078 if (GV.isDefinition() && !GVContext.isCompileUnit() &&
2079 !GVContext.isFile() && !isSubprogramContext(GVContext)) {
2080 // Create specification DIE.
2081 DIE *VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
2082 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
2083 dwarf::DW_FORM_ref4, VariableDIE);
2084 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
2085 addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
2086 TheCU->addDie(VariableSpecDIE);
2088 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2090 } else if (ConstantInt *CI =
2091 dyn_cast_or_null<ConstantInt>(GV.getConstant()))
2092 addConstantValue(VariableDIE, CI, isUnsignedDIType(GTy));
2093 else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
2094 // GV is a merged global.
2095 DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
2096 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
2097 addLabel(Block, 0, dwarf::DW_FORM_udata,
2098 Asm->Mang->getSymbol(cast<GlobalValue>(CE->getOperand(0))));
2099 ConstantInt *CII = cast<ConstantInt>(CE->getOperand(2));
2100 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
2101 addUInt(Block, 0, dwarf::DW_FORM_udata, CII->getZExtValue());
2102 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
2103 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
2109 /// construct SubprogramDIE - Construct subprogram DIE.
2110 void DwarfDebug::constructSubprogramDIE(const MDNode *N) {
2113 // Check for pre-existence.
2114 CompileUnit *TheCU = getCompileUnit(N);
2115 if (TheCU->getDIE(N))
2118 if (!SP.isDefinition())
2119 // This is a method declaration which will be handled while constructing
2123 DIE *SubprogramDie = createSubprogramDIE(SP);
2126 TheCU->insertDIE(N, SubprogramDie);
2128 // Add to context owner.
2129 addToContextOwner(SubprogramDie, SP.getContext());
2131 // Expose as global.
2132 TheCU->addGlobal(SP.getName(), SubprogramDie);
2137 /// beginModule - Emit all Dwarf sections that should come prior to the
2138 /// content. Create global DIEs and emit initial debug info sections.
2139 /// This is inovked by the target AsmPrinter.
2140 void DwarfDebug::beginModule(Module *M) {
2141 if (DisableDebugInfoPrinting)
2144 DebugInfoFinder DbgFinder;
2145 DbgFinder.processModule(*M);
2147 bool HasDebugInfo = false;
2149 // Scan all the compile-units to see if there are any marked as the main unit.
2150 // if not, we do not generate debug info.
2151 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2152 E = DbgFinder.compile_unit_end(); I != E; ++I) {
2153 if (DICompileUnit(*I).isMain()) {
2154 HasDebugInfo = true;
2159 if (!HasDebugInfo) return;
2161 // Tell MMI that we have debug info.
2162 MMI->setDebugInfoAvailability(true);
2164 // Emit initial sections.
2165 EmitSectionLabels();
2167 // Create all the compile unit DIEs.
2168 for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
2169 E = DbgFinder.compile_unit_end(); I != E; ++I)
2170 constructCompileUnit(*I);
2172 // Create DIEs for each subprogram.
2173 for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
2174 E = DbgFinder.subprogram_end(); I != E; ++I)
2175 constructSubprogramDIE(*I);
2177 // Create DIEs for each global variable.
2178 for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
2179 E = DbgFinder.global_variable_end(); I != E; ++I)
2180 constructGlobalVariableDIE(*I);
2182 //getOrCreateTypeDIE
2183 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
2184 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2185 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2187 if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
2188 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
2189 getOrCreateTypeDIE(DIType(NMD->getOperand(i)));
2191 // Prime section data.
2192 SectionMap.insert(Asm->getObjFileLowering().getTextSection());
2195 /// endModule - Emit all Dwarf sections that should come after the content.
2197 void DwarfDebug::endModule() {
2198 if (!FirstCU) return;
2199 const Module *M = MMI->getModule();
2200 DenseMap<const MDNode *, DbgScope *> DeadFnScopeMap;
2201 if (NamedMDNode *AllSPs = M->getNamedMetadata("llvm.dbg.sp")) {
2202 for (unsigned SI = 0, SE = AllSPs->getNumOperands(); SI != SE; ++SI) {
2203 if (ProcessedSPNodes.count(AllSPs->getOperand(SI)) != 0) continue;
2204 DISubprogram SP(AllSPs->getOperand(SI));
2205 if (!SP.Verify()) continue;
2207 // Collect info for variables that were optimized out.
2208 if (!SP.isDefinition()) continue;
2209 StringRef FName = SP.getLinkageName();
2211 FName = SP.getName();
2212 NamedMDNode *NMD = getFnSpecificMDNode(*(MMI->getModule()), FName);
2214 unsigned E = NMD->getNumOperands();
2216 DbgScope *Scope = new DbgScope(NULL, DIDescriptor(SP), NULL);
2217 DeadFnScopeMap[SP] = Scope;
2218 for (unsigned I = 0; I != E; ++I) {
2219 DIVariable DV(NMD->getOperand(I));
2220 if (!DV.Verify()) continue;
2221 Scope->addVariable(new DbgVariable(DV));
2224 // Construct subprogram DIE and add variables DIEs.
2225 constructSubprogramDIE(SP);
2226 DIE *ScopeDIE = getCompileUnit(SP)->getDIE(SP);
2227 const SmallVector<DbgVariable *, 8> &Variables = Scope->getDbgVariables();
2228 for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
2229 DIE *VariableDIE = constructVariableDIE(Variables[i], Scope);
2231 ScopeDIE->addChild(VariableDIE);
2236 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
2237 for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
2238 AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
2240 addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
2243 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
2244 CE = ContainingTypeMap.end(); CI != CE; ++CI) {
2245 DIE *SPDie = CI->first;
2246 const MDNode *N = dyn_cast_or_null<MDNode>(CI->second);
2248 DIE *NDie = getCompileUnit(N)->getDIE(N);
2249 if (!NDie) continue;
2250 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
2253 // Standard sections final addresses.
2254 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
2255 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
2256 Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
2257 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
2259 // End text sections.
2260 for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
2261 Asm->OutStreamer.SwitchSection(SectionMap[i]);
2262 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
2265 // Emit common frame information.
2266 emitCommonDebugFrame();
2268 // Emit function debug frame information
2269 for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
2270 E = DebugFrames.end(); I != E; ++I)
2271 emitFunctionDebugFrame(*I);
2273 // Compute DIE offsets and sizes.
2274 computeSizeAndOffsets();
2276 // Emit all the DIEs into a debug info section
2279 // Corresponding abbreviations into a abbrev section.
2280 emitAbbreviations();
2282 // Emit info into a debug pubnames section.
2283 emitDebugPubNames();
2285 // Emit info into a debug pubtypes section.
2286 emitDebugPubTypes();
2288 // Emit info into a debug loc section.
2291 // Emit info into a debug aranges section.
2294 // Emit info into a debug ranges section.
2297 // Emit info into a debug macinfo section.
2300 // Emit inline info.
2301 emitDebugInlineInfo();
2303 // Emit info into a debug str section.
2307 DeleteContainerSeconds(DeadFnScopeMap);
2308 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2309 E = CUMap.end(); I != E; ++I)
2311 FirstCU = NULL; // Reset for the next Module, if any.
2314 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
2315 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
2316 DebugLoc ScopeLoc) {
2318 DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
2320 return AbsDbgVariable;
2322 LLVMContext &Ctx = Var->getContext();
2323 DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
2327 AbsDbgVariable = new DbgVariable(Var);
2328 Scope->addVariable(AbsDbgVariable);
2329 AbstractVariables[Var] = AbsDbgVariable;
2330 return AbsDbgVariable;
2333 /// addCurrentFnArgument - If Var is an current function argument that add
2334 /// it in CurrentFnArguments list.
2335 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
2336 DbgVariable *Var, DbgScope *Scope) {
2337 if (Scope != CurrentFnDbgScope)
2339 DIVariable DV = Var->getVariable();
2340 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2342 unsigned ArgNo = DV.getArgNumber();
2346 size_t Size = CurrentFnArguments.size();
2348 CurrentFnArguments.resize(MF->getFunction()->arg_size());
2349 // llvm::Function argument size is not good indicator of how many
2350 // arguments does the function have at source level.
2352 CurrentFnArguments.resize(ArgNo * 2);
2353 CurrentFnArguments[ArgNo - 1] = Var;
2357 /// collectVariableInfoFromMMITable - Collect variable information from
2358 /// side table maintained by MMI.
2360 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction * MF,
2361 SmallPtrSet<const MDNode *, 16> &Processed) {
2362 const LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2363 MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
2364 for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
2365 VE = VMap.end(); VI != VE; ++VI) {
2366 const MDNode *Var = VI->first;
2368 Processed.insert(Var);
2370 const std::pair<unsigned, DebugLoc> &VP = VI->second;
2372 DbgScope *Scope = 0;
2373 if (const MDNode *IA = VP.second.getInlinedAt(Ctx))
2374 Scope = ConcreteScopes.lookup(IA);
2376 Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
2378 // If variable scope is not found then skip this variable.
2382 DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
2383 DbgVariable *RegVar = new DbgVariable(DV);
2384 recordVariableFrameIndex(RegVar, VP.first);
2385 if (!addCurrentFnArgument(MF, RegVar, Scope))
2386 Scope->addVariable(RegVar);
2387 if (AbsDbgVariable) {
2388 recordVariableFrameIndex(AbsDbgVariable, VP.first);
2389 VarToAbstractVarMap[RegVar] = AbsDbgVariable;
2394 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
2395 /// DBG_VALUE instruction, is in a defined reg.
2396 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
2397 assert (MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
2398 return MI->getNumOperands() == 3 &&
2399 MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
2400 MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
2403 /// collectVariableInfo - Populate DbgScope entries with variables' info.
2405 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
2406 SmallPtrSet<const MDNode *, 16> &Processed) {
2408 /// collection info from MMI table.
2409 collectVariableInfoFromMMITable(MF, Processed);
2411 SmallVector<const MachineInstr *, 8> DbgValues;
2412 // Collect variable information from DBG_VALUE machine instructions;
2413 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2415 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2417 const MachineInstr *MInsn = II;
2418 if (!MInsn->isDebugValue())
2420 DbgValues.push_back(MInsn);
2423 // This is a collection of DBG_VALUE instructions describing same variable.
2424 SmallVector<const MachineInstr *, 4> MultipleValues;
2425 for(SmallVector<const MachineInstr *, 8>::iterator I = DbgValues.begin(),
2426 E = DbgValues.end(); I != E; ++I) {
2427 const MachineInstr *MInsn = *I;
2428 MultipleValues.clear();
2429 if (isDbgValueInDefinedReg(MInsn))
2430 MultipleValues.push_back(MInsn);
2431 DIVariable DV(MInsn->getOperand(MInsn->getNumOperands() - 1).getMetadata());
2432 if (Processed.count(DV) != 0)
2435 for (SmallVector<const MachineInstr *, 8>::iterator MI = I+1,
2436 ME = DbgValues.end(); MI != ME; ++MI) {
2438 (*MI)->getOperand((*MI)->getNumOperands()-1).getMetadata();
2440 MultipleValues.push_back(*MI);
2443 DbgScope *Scope = NULL;
2444 if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
2445 DISubprogram(DV.getContext()).describes(MF->getFunction()))
2446 Scope = CurrentFnDbgScope;
2448 Scope = findDbgScope(MInsn);
2449 // If variable scope is not found then skip this variable.
2453 Processed.insert(DV);
2454 DbgVariable *RegVar = new DbgVariable(DV);
2455 if (!addCurrentFnArgument(MF, RegVar, Scope))
2456 Scope->addVariable(RegVar);
2457 if (DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc())) {
2458 DbgVariableToDbgInstMap[AbsVar] = MInsn;
2459 VarToAbstractVarMap[RegVar] = AbsVar;
2461 if (MultipleValues.size() <= 1 && !RegClobberInsn.count(MInsn)) {
2462 DbgVariableToDbgInstMap[RegVar] = MInsn;
2466 // handle multiple DBG_VALUE instructions describing one variable.
2467 if (DotDebugLocEntries.empty())
2468 RegVar->setDotDebugLocOffset(0);
2470 RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
2472 for (SmallVector<const MachineInstr *, 4>::iterator
2473 MVI = MultipleValues.begin(), MVE = MultipleValues.end();
2474 MVI != MVE; ++MVI) {
2475 const MachineInstr *Begin = *MVI;
2476 MachineLocation MLoc;
2477 if (Begin->getNumOperands() == 3) {
2478 if (Begin->getOperand(0).isReg() && Begin->getOperand(1).isImm())
2479 MLoc.set(Begin->getOperand(0).getReg(), Begin->getOperand(1).getImm());
2481 MLoc = Asm->getDebugValueLocation(Begin);
2486 // Compute the range for a register location.
2487 const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
2488 const MCSymbol *SLabel = 0;
2490 if (const MachineInstr *ClobberMI = RegClobberInsn.lookup(Begin))
2491 // The register range starting at Begin may be clobbered.
2492 SLabel = getLabelAfterInsn(ClobberMI);
2493 else if (MVI + 1 == MVE)
2494 // If Begin is the last instruction then its value is valid
2495 // until the end of the funtion.
2496 SLabel = FunctionEndSym;
2498 // The value is valid until the next DBG_VALUE.
2499 SLabel = getLabelBeforeInsn(MVI[1]);
2501 DotDebugLocEntries.push_back(DotDebugLocEntry(FLabel, SLabel, MLoc));
2503 DotDebugLocEntries.push_back(DotDebugLocEntry());
2506 // Collect info for variables that were optimized out.
2507 const Function *F = MF->getFunction();
2508 if (NamedMDNode *NMD = getFnSpecificMDNode(*(F->getParent()), F->getName())) {
2509 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2510 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
2511 if (!DV || !Processed.insert(DV))
2513 DbgScope *Scope = DbgScopeMap.lookup(DV.getContext());
2515 Scope->addVariable(new DbgVariable(DV));
2520 /// getLabelBeforeInsn - Return Label preceding the instruction.
2521 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
2522 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2523 LabelsBeforeInsn.find(MI);
2524 if (I == LabelsBeforeInsn.end())
2525 // FunctionBeginSym always preceeds all the instruction in current function.
2526 return FunctionBeginSym;
2530 /// getLabelAfterInsn - Return Label immediately following the instruction.
2531 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
2532 DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
2533 LabelsAfterInsn.find(MI);
2534 if (I == LabelsAfterInsn.end())
2539 /// beginInstruction - Process beginning of an instruction.
2540 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
2541 // Check if source location changes, but ignore DBG_VALUE locations.
2542 if (!MI->isDebugValue()) {
2543 DebugLoc DL = MI->getDebugLoc();
2544 if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
2546 if (!DL.isUnknown()) {
2547 const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
2548 recordSourceLine(DL.getLine(), DL.getCol(), Scope);
2550 recordSourceLine(0, 0, 0);
2554 // Insert labels where requested.
2555 if (!InsnNeedsLabel.count(MI))
2559 PrevLabel = MMI->getContext().CreateTempSymbol();
2560 Asm->OutStreamer.EmitLabel(PrevLabel);
2562 LabelsBeforeInsn[MI] = PrevLabel;
2565 /// endInstruction - Process end of an instruction.
2566 void DwarfDebug::endInstruction(const MachineInstr *MI) {
2567 // Don't create a new label after DBG_VALUE instructions.
2568 // They don't generate code.
2569 if (!MI->isDebugValue())
2572 if (!InsnsNeedsLabelAfter.count(MI))
2575 // We need a label after this instruction.
2577 PrevLabel = MMI->getContext().CreateTempSymbol();
2578 Asm->OutStreamer.EmitLabel(PrevLabel);
2580 LabelsAfterInsn[MI] = PrevLabel;
2583 /// getOrCreateDbgScope - Create DbgScope for the scope.
2584 DbgScope *DwarfDebug::getOrCreateDbgScope(const MDNode *Scope,
2585 const MDNode *InlinedAt) {
2587 DbgScope *WScope = DbgScopeMap.lookup(Scope);
2590 WScope = new DbgScope(NULL, DIDescriptor(Scope), NULL);
2591 DbgScopeMap.insert(std::make_pair(Scope, WScope));
2592 if (DIDescriptor(Scope).isLexicalBlock()) {
2594 getOrCreateDbgScope(DILexicalBlock(Scope).getContext(), NULL);
2595 WScope->setParent(Parent);
2596 Parent->addScope(WScope);
2599 if (!WScope->getParent()) {
2600 StringRef SPName = DISubprogram(Scope).getLinkageName();
2601 // We used to check only for a linkage name, but that fails
2602 // since we began omitting the linkage name for private
2603 // functions. The new way is to check for the name in metadata,
2604 // but that's not supported in old .ll test cases. Ergo, we
2606 if (SPName == Asm->MF->getFunction()->getName() ||
2607 DISubprogram(Scope).getFunction() == Asm->MF->getFunction())
2608 CurrentFnDbgScope = WScope;
2614 getOrCreateAbstractScope(Scope);
2615 DbgScope *WScope = DbgScopeMap.lookup(InlinedAt);
2619 WScope = new DbgScope(NULL, DIDescriptor(Scope), InlinedAt);
2620 DbgScopeMap.insert(std::make_pair(InlinedAt, WScope));
2621 DILocation DL(InlinedAt);
2623 getOrCreateDbgScope(DL.getScope(), DL.getOrigLocation());
2624 WScope->setParent(Parent);
2625 Parent->addScope(WScope);
2627 ConcreteScopes[InlinedAt] = WScope;
2632 /// hasValidLocation - Return true if debug location entry attached with
2633 /// machine instruction encodes valid location info.
2634 static bool hasValidLocation(LLVMContext &Ctx,
2635 const MachineInstr *MInsn,
2636 const MDNode *&Scope, const MDNode *&InlinedAt) {
2637 DebugLoc DL = MInsn->getDebugLoc();
2638 if (DL.isUnknown()) return false;
2640 const MDNode *S = DL.getScope(Ctx);
2642 // There is no need to create another DIE for compile unit. For all
2643 // other scopes, create one DbgScope now. This will be translated
2644 // into a scope DIE at the end.
2645 if (DIScope(S).isCompileUnit()) return false;
2648 InlinedAt = DL.getInlinedAt(Ctx);
2652 /// calculateDominanceGraph - Calculate dominance graph for DbgScope
2654 static void calculateDominanceGraph(DbgScope *Scope) {
2655 assert (Scope && "Unable to calculate scop edominance graph!");
2656 SmallVector<DbgScope *, 4> WorkStack;
2657 WorkStack.push_back(Scope);
2658 unsigned Counter = 0;
2659 while (!WorkStack.empty()) {
2660 DbgScope *WS = WorkStack.back();
2661 const SmallVector<DbgScope *, 4> &Children = WS->getScopes();
2662 bool visitedChildren = false;
2663 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2664 SE = Children.end(); SI != SE; ++SI) {
2665 DbgScope *ChildScope = *SI;
2666 if (!ChildScope->getDFSOut()) {
2667 WorkStack.push_back(ChildScope);
2668 visitedChildren = true;
2669 ChildScope->setDFSIn(++Counter);
2673 if (!visitedChildren) {
2674 WorkStack.pop_back();
2675 WS->setDFSOut(++Counter);
2680 /// printDbgScopeInfo - Print DbgScope info for each machine instruction.
2682 void printDbgScopeInfo(LLVMContext &Ctx, const MachineFunction *MF,
2683 DenseMap<const MachineInstr *, DbgScope *> &MI2ScopeMap)
2686 unsigned PrevDFSIn = 0;
2687 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2689 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2691 const MachineInstr *MInsn = II;
2692 const MDNode *Scope = NULL;
2693 const MDNode *InlinedAt = NULL;
2695 // Check if instruction has valid location information.
2696 if (hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2700 DenseMap<const MachineInstr *, DbgScope *>::iterator DI =
2701 MI2ScopeMap.find(MInsn);
2702 if (DI != MI2ScopeMap.end()) {
2703 DbgScope *S = DI->second;
2704 dbgs() << S->getDFSIn();
2705 PrevDFSIn = S->getDFSIn();
2707 dbgs() << PrevDFSIn;
2709 dbgs() << " [ x" << PrevDFSIn;
2717 /// extractScopeInformation - Scan machine instructions in this function
2718 /// and collect DbgScopes. Return true, if at least one scope was found.
2719 bool DwarfDebug::extractScopeInformation() {
2720 // If scope information was extracted using .dbg intrinsics then there is not
2721 // any need to extract these information by scanning each instruction.
2722 if (!DbgScopeMap.empty())
2725 // Scan each instruction and create scopes. First build working set of scopes.
2726 LLVMContext &Ctx = Asm->MF->getFunction()->getContext();
2727 SmallVector<DbgRange, 4> MIRanges;
2728 DenseMap<const MachineInstr *, DbgScope *> MI2ScopeMap;
2729 const MDNode *PrevScope = NULL;
2730 const MDNode *PrevInlinedAt = NULL;
2731 const MachineInstr *RangeBeginMI = NULL;
2732 const MachineInstr *PrevMI = NULL;
2733 for (MachineFunction::const_iterator I = Asm->MF->begin(), E = Asm->MF->end();
2735 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2737 const MachineInstr *MInsn = II;
2738 const MDNode *Scope = NULL;
2739 const MDNode *InlinedAt = NULL;
2741 // Check if instruction has valid location information.
2742 if (!hasValidLocation(Ctx, MInsn, Scope, InlinedAt)) {
2747 // If scope has not changed then skip this instruction.
2748 if (Scope == PrevScope && PrevInlinedAt == InlinedAt) {
2753 // Ignore DBG_VALUE. It does not contribute any instruction in output.
2754 if (MInsn->isDebugValue())
2758 // If we have alread seen a beginning of a instruction range and
2759 // current instruction scope does not match scope of first instruction
2760 // in this range then create a new instruction range.
2761 DbgRange R(RangeBeginMI, PrevMI);
2762 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope,
2764 MIRanges.push_back(R);
2767 // This is a beginning of a new instruction range.
2768 RangeBeginMI = MInsn;
2770 // Reset previous markers.
2773 PrevInlinedAt = InlinedAt;
2777 // Create last instruction range.
2778 if (RangeBeginMI && PrevMI && PrevScope) {
2779 DbgRange R(RangeBeginMI, PrevMI);
2780 MIRanges.push_back(R);
2781 MI2ScopeMap[RangeBeginMI] = getOrCreateDbgScope(PrevScope, PrevInlinedAt);
2784 if (!CurrentFnDbgScope)
2787 calculateDominanceGraph(CurrentFnDbgScope);
2789 printDbgScopeInfo(Ctx, Asm->MF, MI2ScopeMap);
2791 // Find ranges of instructions covered by each DbgScope;
2792 DbgScope *PrevDbgScope = NULL;
2793 for (SmallVector<DbgRange, 4>::const_iterator RI = MIRanges.begin(),
2794 RE = MIRanges.end(); RI != RE; ++RI) {
2795 const DbgRange &R = *RI;
2796 DbgScope *S = MI2ScopeMap.lookup(R.first);
2797 assert (S && "Lost DbgScope for a machine instruction!");
2798 if (PrevDbgScope && !PrevDbgScope->dominates(S))
2799 PrevDbgScope->closeInsnRange(S);
2800 S->openInsnRange(R.first);
2801 S->extendInsnRange(R.second);
2806 PrevDbgScope->closeInsnRange();
2808 identifyScopeMarkers();
2810 return !DbgScopeMap.empty();
2813 /// identifyScopeMarkers() -
2814 /// Each DbgScope has first instruction and last instruction to mark beginning
2815 /// and end of a scope respectively. Create an inverse map that list scopes
2816 /// starts (and ends) with an instruction. One instruction may start (or end)
2817 /// multiple scopes. Ignore scopes that are not reachable.
2818 void DwarfDebug::identifyScopeMarkers() {
2819 SmallVector<DbgScope *, 4> WorkList;
2820 WorkList.push_back(CurrentFnDbgScope);
2821 while (!WorkList.empty()) {
2822 DbgScope *S = WorkList.pop_back_val();
2824 const SmallVector<DbgScope *, 4> &Children = S->getScopes();
2825 if (!Children.empty())
2826 for (SmallVector<DbgScope *, 4>::const_iterator SI = Children.begin(),
2827 SE = Children.end(); SI != SE; ++SI)
2828 WorkList.push_back(*SI);
2830 if (S->isAbstractScope())
2833 const SmallVector<DbgRange, 4> &Ranges = S->getRanges();
2836 for (SmallVector<DbgRange, 4>::const_iterator RI = Ranges.begin(),
2837 RE = Ranges.end(); RI != RE; ++RI) {
2838 assert(RI->first && "DbgRange does not have first instruction!");
2839 assert(RI->second && "DbgRange does not have second instruction!");
2840 InsnNeedsLabel.insert(RI->first);
2841 InsnsNeedsLabelAfter.insert(RI->second);
2846 /// FindFirstDebugLoc - Find the first debug location in the function. This
2847 /// is intended to be an approximation for the source position of the
2848 /// beginning of the function.
2849 static DebugLoc FindFirstDebugLoc(const MachineFunction *MF) {
2850 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2852 for (MachineBasicBlock::const_iterator MBBI = I->begin(), MBBE = I->end();
2853 MBBI != MBBE; ++MBBI) {
2854 DebugLoc DL = MBBI->getDebugLoc();
2855 if (!DL.isUnknown())
2862 /// CheckLineNumbers - Count basicblocks whose instructions do not have any
2863 /// line number information.
2864 static void CheckLineNumbers(const MachineFunction *MF) {
2865 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2867 bool FoundLineNo = false;
2868 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2870 const MachineInstr *MI = II;
2871 if (!MI->getDebugLoc().isUnknown()) {
2876 if (!FoundLineNo && I->size())
2877 ++BlocksWithoutLineNo;
2882 /// beginFunction - Gather pre-function debug information. Assumes being
2883 /// emitted immediately after the function entry point.
2884 void DwarfDebug::beginFunction(const MachineFunction *MF) {
2885 if (!MMI->hasDebugInfo()) return;
2886 if (!extractScopeInformation()) return;
2889 CheckLineNumbers(MF);
2892 FunctionBeginSym = Asm->GetTempSymbol("func_begin",
2893 Asm->getFunctionNumber());
2894 // Assumes in correct section after the entry point.
2895 Asm->OutStreamer.EmitLabel(FunctionBeginSym);
2897 // Emit label for the implicitly defined dbg.stoppoint at the start of the
2899 DebugLoc FDL = FindFirstDebugLoc(MF);
2900 if (FDL.isUnknown()) return;
2902 const MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
2903 const MDNode *TheScope = 0;
2905 DISubprogram SP = getDISubprogram(Scope);
2908 Line = SP.getLineNumber();
2912 Line = FDL.getLine();
2917 recordSourceLine(Line, Col, TheScope);
2919 /// ProcessedArgs - Collection of arguments already processed.
2920 SmallPtrSet<const MDNode *, 8> ProcessedArgs;
2922 /// LastDbgValue - Refer back to the last DBG_VALUE instruction to mention MD.
2923 DenseMap<const MDNode*, const MachineInstr*> LastDbgValue;
2925 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
2927 /// LiveUserVar - Map physreg numbers to the MDNode they contain.
2928 std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
2930 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
2932 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
2934 const MachineInstr *MI = II;
2935 DebugLoc DL = MI->getDebugLoc();
2936 if (MI->isDebugValue()) {
2937 assert (MI->getNumOperands() > 1 && "Invalid machine instruction!");
2939 // Keep track of variables in registers.
2941 MI->getOperand(MI->getNumOperands() - 1).getMetadata();
2942 LastDbgValue[Var] = MI;
2943 if (isDbgValueInDefinedReg(MI))
2944 LiveUserVar[MI->getOperand(0).getReg()] = Var;
2947 if (!DV.Verify()) continue;
2948 // If DBG_VALUE is for a local variable then it needs a label.
2949 if (DV.getTag() != dwarf::DW_TAG_arg_variable)
2950 InsnNeedsLabel.insert(MI);
2951 // DBG_VALUE for inlined functions argument needs a label.
2952 else if (!DISubprogram(getDISubprogram(DV.getContext())).
2953 describes(MF->getFunction()))
2954 InsnNeedsLabel.insert(MI);
2955 // DBG_VALUE indicating argument location change needs a label.
2956 else if (!ProcessedArgs.insert(DV))
2957 InsnNeedsLabel.insert(MI);
2959 // Check if the instruction clobbers any registers with debug vars.
2960 for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
2961 MOE = MI->operands_end(); MOI != MOE; ++MOI) {
2962 if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
2964 for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
2965 unsigned Reg = *AI; ++AI) {
2966 const MDNode *Var = LiveUserVar[Reg];
2969 // Reg is now clobbered.
2970 LiveUserVar[Reg] = 0;
2972 // Was MD last defined by a DBG_VALUE referring to Reg?
2973 const MachineInstr *Last = LastDbgValue.lookup(Var);
2974 if (!Last || Last->getParent() != MI->getParent())
2976 if (!isDbgValueInDefinedReg(Last) ||
2977 Last->getOperand(0).getReg() != Reg)
2979 // MD is clobbered. Make sure the next instruction gets a label.
2980 InsnsNeedsLabelAfter.insert(MI);
2981 RegClobberInsn[Last] = MI;
2987 PrevInstLoc = DebugLoc();
2988 PrevLabel = FunctionBeginSym;
2991 /// endFunction - Gather and emit post-function debug information.
2993 void DwarfDebug::endFunction(const MachineFunction *MF) {
2994 if (!MMI->hasDebugInfo() || DbgScopeMap.empty()) return;
2996 if (CurrentFnDbgScope) {
2998 // Define end label for subprogram.
2999 FunctionEndSym = Asm->GetTempSymbol("func_end",
3000 Asm->getFunctionNumber());
3001 // Assumes in correct section after the entry point.
3002 Asm->OutStreamer.EmitLabel(FunctionEndSym);
3004 SmallPtrSet<const MDNode *, 16> ProcessedVars;
3005 collectVariableInfo(MF, ProcessedVars);
3007 // Construct abstract scopes.
3008 for (SmallVector<DbgScope *, 4>::iterator AI = AbstractScopesList.begin(),
3009 AE = AbstractScopesList.end(); AI != AE; ++AI) {
3010 DISubprogram SP((*AI)->getScopeNode());
3012 // Collect info for variables that were optimized out.
3013 StringRef FName = SP.getLinkageName();
3015 FName = SP.getName();
3016 if (NamedMDNode *NMD =
3017 getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
3018 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3019 DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
3020 if (!DV || !ProcessedVars.insert(DV))
3022 DbgScope *Scope = AbstractScopes.lookup(DV.getContext());
3024 Scope->addVariable(new DbgVariable(DV));
3028 if (ProcessedSPNodes.count((*AI)->getScopeNode()) == 0)
3029 constructScopeDIE(*AI);
3032 DIE *CurFnDIE = constructScopeDIE(CurrentFnDbgScope);
3034 if (!DisableFramePointerElim(*MF))
3035 addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
3036 dwarf::DW_FORM_flag, 1);
3039 DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
3040 MMI->getFrameMoves()));
3044 CurrentFnDbgScope = NULL;
3045 CurrentFnArguments.clear();
3046 InsnNeedsLabel.clear();
3047 DbgVariableToFrameIndexMap.clear();
3048 VarToAbstractVarMap.clear();
3049 DbgVariableToDbgInstMap.clear();
3050 DeleteContainerSeconds(DbgScopeMap);
3051 InsnsNeedsLabelAfter.clear();
3052 RegClobberInsn.clear();
3053 ConcreteScopes.clear();
3054 DeleteContainerSeconds(AbstractScopes);
3055 AbstractScopesList.clear();
3056 AbstractVariables.clear();
3057 LabelsBeforeInsn.clear();
3058 LabelsAfterInsn.clear();
3062 /// recordVariableFrameIndex - Record a variable's index.
3063 void DwarfDebug::recordVariableFrameIndex(const DbgVariable *V, int Index) {
3064 assert (V && "Invalid DbgVariable!");
3065 DbgVariableToFrameIndexMap[V] = Index;
3068 /// findVariableFrameIndex - Return true if frame index for the variable
3069 /// is found. Update FI to hold value of the index.
3070 bool DwarfDebug::findVariableFrameIndex(const DbgVariable *V, int *FI) {
3071 assert (V && "Invalid DbgVariable!");
3072 DenseMap<const DbgVariable *, int>::iterator I =
3073 DbgVariableToFrameIndexMap.find(V);
3074 if (I == DbgVariableToFrameIndexMap.end())
3080 /// findDbgScope - Find DbgScope for the debug loc attached with an
3082 DbgScope *DwarfDebug::findDbgScope(const MachineInstr *MInsn) {
3083 DbgScope *Scope = NULL;
3085 MInsn->getParent()->getParent()->getFunction()->getContext();
3086 DebugLoc DL = MInsn->getDebugLoc();
3091 if (const MDNode *IA = DL.getInlinedAt(Ctx))
3092 Scope = ConcreteScopes.lookup(IA);
3094 Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
3100 /// recordSourceLine - Register a source line with debug info. Returns the
3101 /// unique label that was emitted and which provides correspondence to
3102 /// the source line list.
3103 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S){
3108 DIDescriptor Scope(S);
3110 if (Scope.isCompileUnit()) {
3111 DICompileUnit CU(S);
3112 Fn = CU.getFilename();
3113 Dir = CU.getDirectory();
3114 } else if (Scope.isFile()) {
3116 Fn = F.getFilename();
3117 Dir = F.getDirectory();
3118 } else if (Scope.isSubprogram()) {
3120 Fn = SP.getFilename();
3121 Dir = SP.getDirectory();
3122 } else if (Scope.isLexicalBlock()) {
3123 DILexicalBlock DB(S);
3124 Fn = DB.getFilename();
3125 Dir = DB.getDirectory();
3127 assert(0 && "Unexpected scope info");
3129 Src = GetOrCreateSourceID(Fn, Dir);
3132 Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, DWARF2_FLAG_IS_STMT,
3136 //===----------------------------------------------------------------------===//
3138 //===----------------------------------------------------------------------===//
3140 /// computeSizeAndOffset - Compute the size and offset of a DIE.
3143 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
3144 // Get the children.
3145 const std::vector<DIE *> &Children = Die->getChildren();
3147 // If not last sibling and has children then add sibling offset attribute.
3148 if (!Last && !Children.empty())
3149 Die->addSiblingOffset(DIEValueAllocator);
3151 // Record the abbreviation.
3152 assignAbbrevNumber(Die->getAbbrev());
3154 // Get the abbreviation for this DIE.
3155 unsigned AbbrevNumber = Die->getAbbrevNumber();
3156 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3159 Die->setOffset(Offset);
3161 // Start the size with the size of abbreviation code.
3162 Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
3164 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3165 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3167 // Size the DIE attribute values.
3168 for (unsigned i = 0, N = Values.size(); i < N; ++i)
3169 // Size attribute value.
3170 Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
3172 // Size the DIE children if any.
3173 if (!Children.empty()) {
3174 assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
3175 "Children flag not set");
3177 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3178 Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
3180 // End of children marker.
3181 Offset += sizeof(int8_t);
3184 Die->setSize(Offset - Die->getOffset());
3188 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
3190 void DwarfDebug::computeSizeAndOffsets() {
3191 unsigned PrevOffset = 0;
3192 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3193 E = CUMap.end(); I != E; ++I) {
3194 // Compute size of compile unit header.
3195 static unsigned Offset = PrevOffset +
3196 sizeof(int32_t) + // Length of Compilation Unit Info
3197 sizeof(int16_t) + // DWARF version number
3198 sizeof(int32_t) + // Offset Into Abbrev. Section
3199 sizeof(int8_t); // Pointer Size (in bytes)
3200 computeSizeAndOffset(I->second->getCUDie(), Offset, true);
3201 PrevOffset = Offset;
3205 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
3206 /// temporary label to it if SymbolStem is specified.
3207 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
3208 const char *SymbolStem = 0) {
3209 Asm->OutStreamer.SwitchSection(Section);
3210 if (!SymbolStem) return 0;
3212 MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
3213 Asm->OutStreamer.EmitLabel(TmpSym);
3217 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
3218 /// the start of each one.
3219 void DwarfDebug::EmitSectionLabels() {
3220 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
3222 // Dwarf sections base addresses.
3223 if (Asm->MAI->doesDwarfRequireFrameSection()) {
3224 DwarfFrameSectionSym =
3225 EmitSectionSym(Asm, TLOF.getDwarfFrameSection(), "section_debug_frame");
3228 DwarfInfoSectionSym =
3229 EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
3230 DwarfAbbrevSectionSym =
3231 EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
3232 EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
3234 if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
3235 EmitSectionSym(Asm, MacroInfo);
3237 EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
3238 EmitSectionSym(Asm, TLOF.getDwarfLocSection());
3239 EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
3240 EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
3241 DwarfStrSectionSym =
3242 EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
3243 DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
3246 DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
3247 "section_debug_loc");
3249 TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
3250 EmitSectionSym(Asm, TLOF.getDataSection());
3253 /// emitDIE - Recusively Emits a debug information entry.
3255 void DwarfDebug::emitDIE(DIE *Die) {
3256 // Get the abbreviation for this DIE.
3257 unsigned AbbrevNumber = Die->getAbbrevNumber();
3258 const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
3260 // Emit the code (index) for the abbreviation.
3261 if (Asm->isVerbose())
3262 Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
3263 Twine::utohexstr(Die->getOffset()) + ":0x" +
3264 Twine::utohexstr(Die->getSize()) + " " +
3265 dwarf::TagString(Abbrev->getTag()));
3266 Asm->EmitULEB128(AbbrevNumber);
3268 const SmallVector<DIEValue*, 32> &Values = Die->getValues();
3269 const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
3271 // Emit the DIE attribute values.
3272 for (unsigned i = 0, N = Values.size(); i < N; ++i) {
3273 unsigned Attr = AbbrevData[i].getAttribute();
3274 unsigned Form = AbbrevData[i].getForm();
3275 assert(Form && "Too many attributes for DIE (check abbreviation)");
3277 if (Asm->isVerbose())
3278 Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
3281 case dwarf::DW_AT_sibling:
3282 Asm->EmitInt32(Die->getSiblingOffset());
3284 case dwarf::DW_AT_abstract_origin: {
3285 DIEEntry *E = cast<DIEEntry>(Values[i]);
3286 DIE *Origin = E->getEntry();
3287 unsigned Addr = Origin->getOffset();
3288 Asm->EmitInt32(Addr);
3291 case dwarf::DW_AT_ranges: {
3292 // DW_AT_range Value encodes offset in debug_range section.
3293 DIEInteger *V = cast<DIEInteger>(Values[i]);
3295 if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
3296 Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
3300 Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
3302 DwarfDebugRangeSectionSym,
3307 case dwarf::DW_AT_location: {
3308 if (UseDotDebugLocEntry.count(Die) != 0) {
3309 DIELabel *L = cast<DIELabel>(Values[i]);
3310 Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
3312 Values[i]->EmitValue(Asm, Form);
3315 case dwarf::DW_AT_accessibility: {
3316 if (Asm->isVerbose()) {
3317 DIEInteger *V = cast<DIEInteger>(Values[i]);
3318 Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
3320 Values[i]->EmitValue(Asm, Form);
3324 // Emit an attribute using the defined form.
3325 Values[i]->EmitValue(Asm, Form);
3330 // Emit the DIE children if any.
3331 if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
3332 const std::vector<DIE *> &Children = Die->getChildren();
3334 for (unsigned j = 0, M = Children.size(); j < M; ++j)
3335 emitDIE(Children[j]);
3337 if (Asm->isVerbose())
3338 Asm->OutStreamer.AddComment("End Of Children Mark");
3343 /// emitDebugInfo - Emit the debug info section.
3345 void DwarfDebug::emitDebugInfo() {
3346 // Start debug info section.
3347 Asm->OutStreamer.SwitchSection(
3348 Asm->getObjFileLowering().getDwarfInfoSection());
3349 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3350 E = CUMap.end(); I != E; ++I) {
3351 CompileUnit *TheCU = I->second;
3352 DIE *Die = TheCU->getCUDie();
3354 // Emit the compile units header.
3355 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
3358 // Emit size of content not including length itself
3359 unsigned ContentSize = Die->getSize() +
3360 sizeof(int16_t) + // DWARF version number
3361 sizeof(int32_t) + // Offset Into Abbrev. Section
3362 sizeof(int8_t) + // Pointer Size (in bytes)
3363 sizeof(int32_t); // FIXME - extra pad for gdb bug.
3365 Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
3366 Asm->EmitInt32(ContentSize);
3367 Asm->OutStreamer.AddComment("DWARF version number");
3368 Asm->EmitInt16(dwarf::DWARF_VERSION);
3369 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
3370 Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
3371 DwarfAbbrevSectionSym);
3372 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3373 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3376 // FIXME - extra padding for gdb bug.
3377 Asm->OutStreamer.AddComment("4 extra padding bytes for GDB");
3382 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
3386 /// emitAbbreviations - Emit the abbreviation section.
3388 void DwarfDebug::emitAbbreviations() const {
3389 // Check to see if it is worth the effort.
3390 if (!Abbreviations.empty()) {
3391 // Start the debug abbrev section.
3392 Asm->OutStreamer.SwitchSection(
3393 Asm->getObjFileLowering().getDwarfAbbrevSection());
3395 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
3397 // For each abbrevation.
3398 for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
3399 // Get abbreviation data
3400 const DIEAbbrev *Abbrev = Abbreviations[i];
3402 // Emit the abbrevations code (base 1 index.)
3403 Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
3405 // Emit the abbreviations data.
3409 // Mark end of abbreviations.
3410 Asm->EmitULEB128(0, "EOM(3)");
3412 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
3416 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
3417 /// the line matrix.
3419 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
3420 // Define last address of section.
3421 Asm->OutStreamer.AddComment("Extended Op");
3424 Asm->OutStreamer.AddComment("Op size");
3425 Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
3426 Asm->OutStreamer.AddComment("DW_LNE_set_address");
3427 Asm->EmitInt8(dwarf::DW_LNE_set_address);
3429 Asm->OutStreamer.AddComment("Section end label");
3431 Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
3432 Asm->getTargetData().getPointerSize(),
3435 // Mark end of matrix.
3436 Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
3442 /// emitCommonDebugFrame - Emit common frame info into a debug frame section.
3444 void DwarfDebug::emitCommonDebugFrame() {
3445 if (!Asm->MAI->doesDwarfRequireFrameSection())
3448 int stackGrowth = Asm->getTargetData().getPointerSize();
3449 if (Asm->TM.getFrameLowering()->getStackGrowthDirection() ==
3450 TargetFrameLowering::StackGrowsDown)
3453 // Start the dwarf frame section.
3454 Asm->OutStreamer.SwitchSection(
3455 Asm->getObjFileLowering().getDwarfFrameSection());
3457 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common"));
3458 Asm->OutStreamer.AddComment("Length of Common Information Entry");
3459 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_frame_common_end"),
3460 Asm->GetTempSymbol("debug_frame_common_begin"), 4);
3462 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_begin"));
3463 Asm->OutStreamer.AddComment("CIE Identifier Tag");
3464 Asm->EmitInt32((int)dwarf::DW_CIE_ID);
3465 Asm->OutStreamer.AddComment("CIE Version");
3466 Asm->EmitInt8(dwarf::DW_CIE_VERSION);
3467 Asm->OutStreamer.AddComment("CIE Augmentation");
3468 Asm->OutStreamer.EmitIntValue(0, 1, /*addrspace*/0); // nul terminator.
3469 Asm->EmitULEB128(1, "CIE Code Alignment Factor");
3470 Asm->EmitSLEB128(stackGrowth, "CIE Data Alignment Factor");
3471 Asm->OutStreamer.AddComment("CIE RA Column");
3472 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3473 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
3474 Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
3476 std::vector<MachineMove> Moves;
3477 TFI->getInitialFrameState(Moves);
3479 Asm->EmitFrameMoves(Moves, 0, false);
3481 Asm->EmitAlignment(2);
3482 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_frame_common_end"));
3485 /// emitFunctionDebugFrame - Emit per function frame info into a debug frame
3488 emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
3489 if (!Asm->MAI->doesDwarfRequireFrameSection())
3492 // Start the dwarf frame section.
3493 Asm->OutStreamer.SwitchSection(
3494 Asm->getObjFileLowering().getDwarfFrameSection());
3496 Asm->OutStreamer.AddComment("Length of Frame Information Entry");
3497 MCSymbol *DebugFrameBegin =
3498 Asm->GetTempSymbol("debug_frame_begin", DebugFrameInfo.Number);
3499 MCSymbol *DebugFrameEnd =
3500 Asm->GetTempSymbol("debug_frame_end", DebugFrameInfo.Number);
3501 Asm->EmitLabelDifference(DebugFrameEnd, DebugFrameBegin, 4);
3503 Asm->OutStreamer.EmitLabel(DebugFrameBegin);
3505 Asm->OutStreamer.AddComment("FDE CIE offset");
3506 Asm->EmitSectionOffset(Asm->GetTempSymbol("debug_frame_common"),
3507 DwarfFrameSectionSym);
3509 Asm->OutStreamer.AddComment("FDE initial location");
3510 MCSymbol *FuncBeginSym =
3511 Asm->GetTempSymbol("func_begin", DebugFrameInfo.Number);
3512 Asm->OutStreamer.EmitSymbolValue(FuncBeginSym,
3513 Asm->getTargetData().getPointerSize(),
3517 Asm->OutStreamer.AddComment("FDE address range");
3518 Asm->EmitLabelDifference(Asm->GetTempSymbol("func_end",DebugFrameInfo.Number),
3519 FuncBeginSym, Asm->getTargetData().getPointerSize());
3521 Asm->EmitFrameMoves(DebugFrameInfo.Moves, FuncBeginSym, false);
3523 Asm->EmitAlignment(2);
3524 Asm->OutStreamer.EmitLabel(DebugFrameEnd);
3527 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
3529 void DwarfDebug::emitDebugPubNames() {
3530 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3531 E = CUMap.end(); I != E; ++I) {
3532 CompileUnit *TheCU = I->second;
3533 // Start the dwarf pubnames section.
3534 Asm->OutStreamer.SwitchSection(
3535 Asm->getObjFileLowering().getDwarfPubNamesSection());
3537 Asm->OutStreamer.AddComment("Length of Public Names Info");
3538 Asm->EmitLabelDifference(
3539 Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
3540 Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
3542 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
3545 Asm->OutStreamer.AddComment("DWARF Version");
3546 Asm->EmitInt16(dwarf::DWARF_VERSION);
3548 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3549 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3550 DwarfInfoSectionSym);
3552 Asm->OutStreamer.AddComment("Compilation Unit Length");
3553 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3554 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3557 const StringMap<DIE*> &Globals = TheCU->getGlobals();
3558 for (StringMap<DIE*>::const_iterator
3559 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3560 const char *Name = GI->getKeyData();
3561 DIE *Entity = GI->second;
3563 Asm->OutStreamer.AddComment("DIE offset");
3564 Asm->EmitInt32(Entity->getOffset());
3566 if (Asm->isVerbose())
3567 Asm->OutStreamer.AddComment("External Name");
3568 Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
3571 Asm->OutStreamer.AddComment("End Mark");
3573 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
3578 void DwarfDebug::emitDebugPubTypes() {
3579 for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
3580 E = CUMap.end(); I != E; ++I) {
3581 CompileUnit *TheCU = I->second;
3582 // Start the dwarf pubnames section.
3583 Asm->OutStreamer.SwitchSection(
3584 Asm->getObjFileLowering().getDwarfPubTypesSection());
3585 Asm->OutStreamer.AddComment("Length of Public Types Info");
3586 Asm->EmitLabelDifference(
3587 Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
3588 Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
3590 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
3593 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
3594 Asm->EmitInt16(dwarf::DWARF_VERSION);
3596 Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
3597 Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
3598 DwarfInfoSectionSym);
3600 Asm->OutStreamer.AddComment("Compilation Unit Length");
3601 Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
3602 Asm->GetTempSymbol("info_begin", TheCU->getID()),
3605 const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
3606 for (StringMap<DIE*>::const_iterator
3607 GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
3608 const char *Name = GI->getKeyData();
3609 DIE * Entity = GI->second;
3611 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3612 Asm->EmitInt32(Entity->getOffset());
3614 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
3615 Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
3618 Asm->OutStreamer.AddComment("End Mark");
3620 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
3625 /// emitDebugStr - Emit visible names into a debug str section.
3627 void DwarfDebug::emitDebugStr() {
3628 // Check to see if it is worth the effort.
3629 if (StringPool.empty()) return;
3631 // Start the dwarf str section.
3632 Asm->OutStreamer.SwitchSection(
3633 Asm->getObjFileLowering().getDwarfStrSection());
3635 // Get all of the string pool entries and put them in an array by their ID so
3636 // we can sort them.
3637 SmallVector<std::pair<unsigned,
3638 StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
3640 for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
3641 I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
3642 Entries.push_back(std::make_pair(I->second.second, &*I));
3644 array_pod_sort(Entries.begin(), Entries.end());
3646 for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
3647 // Emit a label for reference from debug information entries.
3648 Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
3650 // Emit the string itself.
3651 Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
3655 /// emitDebugLoc - Emit visible names into a debug loc section.
3657 void DwarfDebug::emitDebugLoc() {
3658 if (DotDebugLocEntries.empty())
3661 for (SmallVector<DotDebugLocEntry, 4>::iterator
3662 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3664 DotDebugLocEntry &Entry = *I;
3665 if (I + 1 != DotDebugLocEntries.end())
3669 // Start the dwarf loc section.
3670 Asm->OutStreamer.SwitchSection(
3671 Asm->getObjFileLowering().getDwarfLocSection());
3672 unsigned char Size = Asm->getTargetData().getPointerSize();
3673 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
3675 for (SmallVector<DotDebugLocEntry, 4>::iterator
3676 I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
3677 I != E; ++I, ++index) {
3678 DotDebugLocEntry &Entry = *I;
3679 if (Entry.isMerged()) continue;
3680 if (Entry.isEmpty()) {
3681 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3682 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3683 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
3685 Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
3686 Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
3687 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
3688 unsigned Reg = RI->getDwarfRegNum(Entry.Loc.getReg(), false);
3689 if (int Offset = Entry.Loc.getOffset()) {
3690 // If the value is at a certain offset from frame register then
3692 unsigned OffsetSize = Offset ? MCAsmInfo::getSLEB128Size(Offset) : 1;
3693 Asm->OutStreamer.AddComment("Loc expr size");
3694 Asm->EmitInt16(1 + OffsetSize);
3695 Asm->OutStreamer.AddComment(
3696 dwarf::OperationEncodingString(dwarf::DW_OP_fbreg));
3697 Asm->EmitInt8(dwarf::DW_OP_fbreg);
3698 Asm->OutStreamer.AddComment("Offset");
3699 Asm->EmitSLEB128(Offset);
3702 Asm->OutStreamer.AddComment("Loc expr size");
3704 Asm->OutStreamer.AddComment(
3705 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
3706 Asm->EmitInt8(dwarf::DW_OP_reg0 + Reg);
3708 Asm->OutStreamer.AddComment("Loc expr size");
3709 Asm->EmitInt16(1 + MCAsmInfo::getULEB128Size(Reg));
3710 Asm->EmitInt8(dwarf::DW_OP_regx);
3711 Asm->EmitULEB128(Reg);
3718 /// EmitDebugARanges - Emit visible names into a debug aranges section.
3720 void DwarfDebug::EmitDebugARanges() {
3721 // Start the dwarf aranges section.
3722 Asm->OutStreamer.SwitchSection(
3723 Asm->getObjFileLowering().getDwarfARangesSection());
3726 /// emitDebugRanges - Emit visible names into a debug ranges section.
3728 void DwarfDebug::emitDebugRanges() {
3729 // Start the dwarf ranges section.
3730 Asm->OutStreamer.SwitchSection(
3731 Asm->getObjFileLowering().getDwarfRangesSection());
3732 unsigned char Size = Asm->getTargetData().getPointerSize();
3733 for (SmallVector<const MCSymbol *, 8>::iterator
3734 I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
3737 Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
3739 Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
3743 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
3745 void DwarfDebug::emitDebugMacInfo() {
3746 if (const MCSection *LineInfo =
3747 Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
3748 // Start the dwarf macinfo section.
3749 Asm->OutStreamer.SwitchSection(LineInfo);
3753 /// emitDebugInlineInfo - Emit inline info using following format.
3755 /// 1. length of section
3756 /// 2. Dwarf version number
3757 /// 3. address size.
3759 /// Entries (one "entry" for each function that was inlined):
3761 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
3762 /// otherwise offset into __debug_str for regular function name.
3763 /// 2. offset into __debug_str section for regular function name.
3764 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
3765 /// instances for the function.
3767 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
3768 /// inlined instance; the die_offset points to the inlined_subroutine die in the
3769 /// __debug_info section, and the low_pc is the starting address for the
3770 /// inlining instance.
3771 void DwarfDebug::emitDebugInlineInfo() {
3772 if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
3778 Asm->OutStreamer.SwitchSection(
3779 Asm->getObjFileLowering().getDwarfDebugInlineSection());
3781 Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
3782 Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
3783 Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
3785 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
3787 Asm->OutStreamer.AddComment("Dwarf Version");
3788 Asm->EmitInt16(dwarf::DWARF_VERSION);
3789 Asm->OutStreamer.AddComment("Address Size (in bytes)");
3790 Asm->EmitInt8(Asm->getTargetData().getPointerSize());
3792 for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
3793 E = InlinedSPNodes.end(); I != E; ++I) {
3795 const MDNode *Node = *I;
3796 DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
3797 = InlineInfo.find(Node);
3798 SmallVector<InlineInfoLabels, 4> &Labels = II->second;
3799 DISubprogram SP(Node);
3800 StringRef LName = SP.getLinkageName();
3801 StringRef Name = SP.getName();
3803 Asm->OutStreamer.AddComment("MIPS linkage name");
3804 if (LName.empty()) {
3805 Asm->OutStreamer.EmitBytes(Name, 0);
3806 Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
3808 Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
3809 DwarfStrSectionSym);
3811 Asm->OutStreamer.AddComment("Function name");
3812 Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
3813 Asm->EmitULEB128(Labels.size(), "Inline count");
3815 for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
3816 LE = Labels.end(); LI != LE; ++LI) {
3817 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
3818 Asm->EmitInt32(LI->second->getOffset());
3820 if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
3821 Asm->OutStreamer.EmitSymbolValue(LI->first,
3822 Asm->getTargetData().getPointerSize(),0);
3826 Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));